Method Optimize

policy/composer.go:279–336

(ctx *cel.OptimizerContext, a *ast.AST)

}

func (opt *ruleUnnesterImpl) Optimize(ctx *cel.OptimizerContext, a *ast.AST) *ast.AST {
	// Since the optimizer is based on the original environment provided to the composer,
	// a second pass on the `cel.@block` will require a rebuilding of the cel environment
	ruleExpr := ast.NavigateAST(a)
	var varExprs []ast.Expr
	var varDecls []cel.EnvOption
	unnestOffset := opt.nextVarIndex
	if ruleExpr.Kind() == ast.CallKind && ruleExpr.AsCall().FunctionName() == "cel.@block" {
		// Check that the result of the compose pass is consistent with the intial set of variable
		// definitions in the optimizer. Extract the value expressions and types to set up the
		// checker environment.
		block := ruleExpr.AsCall()
		ruleExpr = block.Args()[1].(ast.NavigableExpr)

		// Collect the list of variables associated with the block
		blockList := block.Args()[0].(ast.NavigableExpr)
		vars := blockList.AsList()
		if vars.Size() != len(opt.varIndices) {
			ctx.ReportErrorAtID(ruleExpr.ID(), "ast block list and computed one have different sizes")
			return a
		}
		varExprs = make([]ast.Expr, vars.Size())
		varDecls = make([]cel.EnvOption, vars.Size())
		for i, v := range opt.varIndices {
			if i >= len(varExprs) {
				break
			}
			varDecls[i] = cel.Variable(v.indexVar, v.celType)
			varExprs[i] = v.expr
		}
	}
	if len(varDecls) != 0 {
		err := ctx.ExtendEnv(varDecls...)
		if err != nil {
			ctx.ReportErrorAtID(ruleExpr.ID(), "%s", err.Error())
		}
	}

	// Attempt to unnest the rule.
	ruleExpr = opt.maybeUnnestRule(ctx, ruleExpr)
	// If there were no variables, return the expression.
	if len(opt.varIndices) == 0 {
		return a
	}

	// Otherwise populate the cel.@block with the variable declarations and wrap the expression
	// in the block.
	for i := unnestOffset; i < len(opt.varIndices); i++ {
		vi := opt.varIndices[i]
		varExprs = append(varExprs, vi.expr)
		err := ctx.ExtendEnv(cel.Variable(vi.indexVar, vi.celType))
		if err != nil {
			ctx.ReportErrorAtID(ruleExpr.ID(), "%s", err.Error())
		}
	}
	blockExpr := ctx.NewCall("cel.@block", ctx.NewList(varExprs, []int32{}), ruleExpr)
	return ctx.NewAST(blockExpr)
}