Package gen contains all of the ANTLR-generated sources used by the cel-go parser.

EnableHiddenAccumulatorName uses an accumulator variable name that is not a normally accessible identifier in source for comprehension macros.

EnableIdentEscapeSyntax enables backtick (`) escaped field identifiers.

EnableOptionalSyntax enables syntax for optional field and index selection.

EnableVariadicOperatorASTs enables a compact representation of chained like-kind commutative operators.

ErrorRecoveryLimit limits the number of attempts the parser will perform to recover from an error.

ErrorRecoveryLookaheadTokenLimit limits the number of lexer tokens that may be considered during error recovery.

ErrorReportingLimit limits the number of syntax error reports before terminating parsing.

ExpressionSizeCodePointLimit is an option which limits the maximum code point count of an expression.

Macros adds the given macros to the parser.

MakeAll expands the input call arguments into a comprehension that returns true if all of the elements in the range match the predicate expressions: <iterRange>.all(<iterVar>, <predicate>).

MakeExists expands the input call arguments into a comprehension that returns true if any of the elements in the range match the predicate expressions: <iterRange>.exists(<iterVar>, <predicate>).

MakeExistsOne expands the input call arguments into a comprehension that returns true if exactly one of the elements in the range match the predicate expressions: <iterRange>.exists_one(<iterVar>, <predicate>).

MakeFilter expands the input call arguments into a comprehension which produces a list which contains only elements which match the provided predicate expression: <iterRange>.filter(<iterVar>, <predicate>).

MakeHas expands the input call arguments into a presence test, e.g.

MakeMap expands the input call arguments into a comprehension that transforms each element in the input to produce an output list.

MaxRecursionDepth limits the maximum depth the parser will attempt to parse the expression before giving up.

NewGlobalMacro creates a Macro for a global function with the specified arg count.

NewGlobalVarArgMacro creates a Macro for a global function with a variable arg count.

NewParser builds and returns a new Parser using the provided options.

NewReceiverMacro creates a Macro for a receiver function matching the specified arg count.

NewReceiverVarArgMacro creates a Macro for a receiver function matching a variable arg count.

Parse converts a source input a parsed expression.

PopulateMacroCalls ensures that the original call signatures replaced by expanded macros are preserved in the `SourceInfo` of parse result.

Unparse takes an input expression and source position information and generates a human-readable expression.

WrapAfterColumnLimit dictates whether to insert a newline before or after the specified operator when word wrapping is performed.

WrapOnColumn wraps the output expression when its string length exceeds a specified limit for operators set by WrapOnOperators function or by default, "&&" and "||" will be wrapped.

WrapOnOperators specifies which operators to perform word wrapping on an output expression when its string length exceeds the column limit set by WrapOnColumn function.

AccumulatorName is the traditional variable name assigned to the fold accumulator variable.

HiddenAccumulatorName is a proposed update to the default fold accumlator variable.

AllMacro expands "range.all(var, predicate)" into a comprehension which ensures that all elements in the range satisfy the predicate.

AllMacros includes the list of all spec-supported macros.

ExistsMacro expands "range.exists(var, predicate)" into a comprehension which ensures that some element in the range satisfies the predicate.

ExistsOneMacro expands "range.exists_one(var, predicate)", which is true if for exactly one element in range the predicate holds.

ExistsOneMacroNew expands "range.existsOne(var, predicate)", which is true if for exactly one element in range the predicate holds.

FilterMacro expands "range.filter(var, predicate)" into a comprehension which filters elements in the range, producing a new list from the elements that satisfy the predicate.

HasMacro expands "has(m.f)" which tests the presence of a field, avoiding the need to specify the field as a string.

MapFilterMacro expands "range.map(var, predicate, function)" into a comprehension which first filters the elements in the range by the predicate, then applies the transform function to produce a new list.

MapMacro expands "range.map(var, function)" into a comprehension which applies the function to each element in the range to produce a new list.

NoMacros list.

Parser encapsulates the context necessary to perform parsing for different expressions.

ExprHelper assists with the creation of Expr values in a manner which is consistent the internal semantics and id generation behaviors of the parser and checker libraries.

Macro interface for describing the function signature to match and the MacroExpander to apply.

MacroExpander converts a call and its associated arguments into a new CEL abstract syntax tree.

Option configures the behavior of the parser.

UnparserOption is a functional option for configuring the output formatting of the Unparse function.