}

func (c compiler) compile(expressionAccessor ExpressionAccessor, envVarName string) (CompilationResult, error) {
	resultError := func(errorString string, errType apiservercel.ErrorType) (CompilationResult, error) {
		return CompilationResult{}, &apiservercel.Error{
			Type:   errType,
			Detail: errorString,
		}
	}

	env, err := c.varEnvs[envVarName].Env(environment.StoredExpressions)
	if err != nil {

func (c compiler) CompileCELExpression(expressionAccessor ExpressionAccessor, options OptionalVariableDeclarations, envType environment.Type) CompilationResult {
	resultError := func(errorString string, errType apiservercel.ErrorType) CompilationResult {
		return CompilationResult{
			Error: &apiservercel.Error{
				Type:   errType,
				Detail: errorString,
			},
			ExpressionAccessor: expressionAccessor,
		}
	}

      : client_(client) {}

  absl::StatusOr<std::unique_ptr<xla::PjRtLoadedExecutable>> BuildExecutable(
      const XlaCompiler::Options& options,
      const XlaCompiler::CompilationResult& result) override;

  // Returns a platform-specific serialization of `executable`. The
  // serialization is not guaranteed to be stable over time. `executable` must
  // have been produced by this client.

      const XlaCompiler::Options& options,
      const XlaCompiler::CompilationResult& result) override;

  // Loads a serialized AOT result (`serialized_executable`) into an
  // xla::LocalExecutable and returns it.
  absl::StatusOr<std::unique_ptr<xla::LocalExecutable>> LoadExecutable(
      const XlaCompiler::Options& options,
      const XlaCompiler::CompilationResult& result,
      const std::string& serialized_executable) override;

// ExpressionAccessor is an interface that provides access to a CEL expression.
type ExpressionAccessor interface {
	GetExpression() string
	ReturnTypes() []*celgo.Type
}

// CompilationResult represents a compiled validations expression.
type CompilationResult struct {
	Program            celgo.Program
	AST                *celgo.Ast
	ExpressionAccessor ExpressionAccessor
}

func NewCompositedCompilerFromTemplate(context *CompositionEnv) *CompositedCompiler {
	context = &CompositionEnv{
		MapType:           context.MapType,
		EnvSet:            context.EnvSet,
		CompiledVariables: map[string]CompilationResult{},
	}
	compiler := NewCompiler(context.EnvSet)
	filterCompiler := NewFilterCompiler(context.EnvSet)
	return &CompositedCompiler{
		Compiler:       compiler,
		FilterCompiler: filterCompiler,

  }
  return shape_ptrs;
}
}  // namespace

absl::StatusOr<std::unique_ptr<xla::LocalExecutable>>
XlaDeviceCompilerClient::BuildExecutable(
    const XlaCompiler::Options& options,
    const XlaCompiler::CompilationResult& result) {
  VLOG(2) << "Compiling to xla::LocalExecutable.";

  std::vector<const xla::Shape*> argument_layouts =
      GetShapePointers(result.xla_input_shapes);

  // XlaCompiler::CompilationResult that was used to build the executable.
  absl::StatusOr<std::vector<std::unique_ptr<xla::PjRtBuffer>>> RunExecutable(
      const std::vector<const Tensor*>& inputs,
      const std::vector<VariableInfo>& variables,
      const XlaCompiler::CompilationResult* result,
      xla::PjRtLoadedExecutable* executable) {

		}
		c.requests = append(c.requests, compilation)
	}
	return c, nil
}

type Controller struct {
	filter   *cel.CompilationResult
	requests []cel.CompilationResult
}

func (c *Controller) NodeIsSuitable(ctx context.Context, model Model) (bool, error) {
	indices, err := c.allocate(ctx, model)
	return len(indices) == len(c.requests), err
}

  return absl::OkStatus();
}
}  // namespace

Status XlaCompileOnDemandOp::Run(const ResourceVarsSnapshot& variable_args,
                                 const XlaCompiler::CompilationResult* result,
                                 const XlaDeviceCompiler* xla_device_compiler,
                                 xla::LocalExecutable* executable,
                                 OpKernelContext* ctx) {