type InlineVariable … // Name returns the qualified variable or field selection to replace. func (v *InlineVariable) Name() string { … } // Alias returns the alias to use when performing cel.bind() calls during inlining. func (v *InlineVariable) Alias() string { … } // Expr returns the inlined expression value. func (v *InlineVariable) Expr() ast.Expr { … } // Type indicates the inlined expression type. func (v *InlineVariable) Type() *Type { … } // NewInlineVariable declares a variable name to be replaced by a checked expression. func NewInlineVariable(name string, definition *Ast) *InlineVariable { … } // NewInlineVariableWithAlias declares a variable name to be replaced by a checked expression. // If the variable occurs more than once, the provided alias will be used to replace the expressions // where the variable name occurs. func NewInlineVariableWithAlias(name, alias string, definition *Ast) *InlineVariable { … } // NewInliningOptimizer creates and optimizer which replaces variables with expression definitions. // // If a variable occurs one time, the variable is replaced by the inline definition. If the // variable occurs more than once, the variable occurences are replaced by a cel.bind() call. func NewInliningOptimizer(inlineVars ...*InlineVariable) ASTOptimizer { … } type inliningOptimizer … func (opt *inliningOptimizer) Optimize(ctx *OptimizerContext, a *ast.AST) *ast.AST { … } // inlineExpr replaces the current expression with the inlined one, unless the location of the inlining // happens within a presence test, e.g. has(a.b.c) -> inline alpha for a.b.c in which case an attempt is // made to determine whether the inlined value can be presence or existence tested. func (opt *inliningOptimizer) inlineExpr(ctx *OptimizerContext, prev ast.NavigableExpr, inlined ast.Expr, inlinedType *Type) { … } // rewritePresenceExpr converts the inlined expression, when it occurs within a has() macro, to type-safe // expression appropriate for the inlined type, if possible. // // If the rewrite is not possible an error is reported at the inline expression site. func (opt *inliningOptimizer) rewritePresenceExpr(ctx *OptimizerContext, prev, inlined ast.Expr, inlinedType *Type) { … } // isBindable indicates whether the inlined type can be used within a cel.bind() if the expression // being replaced occurs within a presence test. Value types with a size() method or field selection // support can be bound. // // In future iterations, support may also be added for indexer types which can be rewritten as an `in` // expression; however, this would imply a rewrite of the inlined expression that may not be necessary // in most cases. func isBindable(matches []ast.NavigableExpr, inlined ast.Expr, inlinedType *Type) bool { … } // matchVariable matches simple identifiers, select expressions, and presence test expressions // which match the (potentially) qualified variable name provided as input. // // Note, this function does not support inlining against select expressions which includes optional // field selection. This may be a future refinement. func (opt *inliningOptimizer) matchVariable(varName string) ast.ExprMatcher { … }