Function CompileRule

policy/compiler.go:271–315

CompileRule creates a compiled rules from the policy which contains a set of compiled variables and match statements. The compiled rule defines an expression graph, which can be composed into a single expression via the RuleComposer.Compose method.

(env *cel.Env, p *Policy, opts ...CompilerOption)

// match statements. The compiled rule defines an expression graph, which can be composed into a single
// expression via the RuleComposer.Compose method.
func CompileRule(env *cel.Env, p *Policy, opts ...CompilerOption) (*CompiledRule, *cel.Issues) {
	c := &compiler{
		env:                  env,
		info:                 p.SourceInfo(),
		src:                  p.Source(),
		compileMatchOutput:   defaultCompileMatchOutput,
		maxNestedExpressions: defaultMaxNestedExpressions,
	}
	var err error
	errs := common.NewErrors(c.src)
	iss := cel.NewIssuesWithSourceInfo(errs, c.info)
	for _, o := range opts {
		if err = o(c); err != nil {
			iss.ReportErrorAtID(p.Name().ID, "error configuring compiler option: %s", err)
			return nil, iss
		}
	}
	c.env, err = c.env.Extend(cel.EagerlyValidateDeclarations(true))
	if err != nil {
		iss.ReportErrorAtID(p.Name().ID, "error configuring environment: %s", err)
		return nil, iss
	}

	importCount := len(p.Imports())
	if importCount > 0 {
		importNames := make([]string, 0, importCount)
		for _, imp := range p.Imports() {
			typeName := imp.Name().Value
			_, err := containers.NewContainer(containers.Abbrevs(typeName))
			if err != nil {
				iss.ReportErrorAtID(imp.Name().ID, "error configuring import: %s", err)
			} else {
				importNames = append(importNames, typeName)
			}
		}
		env, err := c.env.Extend(cel.Abbrevs(importNames...))
		if err != nil {
			// validation happens earlier in the sequence, so this should be unreachable.
			iss.ReportErrorAtID(p.Imports()[0].SourceID(), "error configuring imports: %s", err)
		} else {
			c.env = env
		}
	}
	return c.compileRule(p.Rule(), p, c.env, iss, false)
}

type compiler struct {
	env  *cel.Env