}

        private boolean isGroovyIndyCallsite(Handle bootstrapMethodHandle) {
            return (bootstrapMethodHandle.getOwner().equals(GROOVY_INDY_INTERFACE_TYPE) ||
                bootstrapMethodHandle.getOwner().equals(GROOVY_INDY_INTERFACE_V7_TYPE)) &&
                bootstrapMethodHandle.getName().equals("bootstrap") &&

        this.classpath = classpath;
        this.projectDependencyBuilder = new ProjectDependencyBuilder(ideArtifactRegistry);
        this.currentProjectId = ((ProjectInternal) classpath.getProject()).getOwner().getComponentIdentifier();
        this.gradleApiSourcesResolver = gradleApiSourcesResolver;
        this.inferModulePath = inferModulePath;
    }

    public List<AbstractClasspathEntry> createDependencyEntries() {

// Checks if all the users is ReadVariableOp.
def HasOnlyReadVariableOpUsers : Constraint<
  CPred<"llvm::all_of($0.getUsers(), [](mlir::OpOperand op) { "
        "return llvm::isa<mlir::TF::ReadVariableOp>(op.getOwner()); })">>;

def CopyAttrs: NativeCodeCallVoid<"CopyDeviceAndUnderscoredAttributesAdaptor($0, $1)">;

//===----------------------------------------------------------------------===//
// Add op patterns.

        CalculationState<T, S> calculationState = this.calculationState;
        if (calculationState != null && calculationState.supplier.usesMutableProjectState()) {
            return calculationState.supplier.getOwningProject().getOwner();
        } else {
            return RootScriptDomainObjectContext.INSTANCE.getModel();
        }
    }

    /**
     * Visits the dependencies required to calculate the value.
     */

        return new BuildOperationWrappingBuilder(
            new LockSingleProjectBuilder(
                locateForClientOperation(modelName, target.getMutableModel(), parameter), target),
            modelName, target.getOwner(), target, target.getDisplayName(), buildOperationRunner);
    }

    @Nullable
    @Override
    public Builder maybeLocateForBuildScope(String modelName, boolean parameter, BuildState target) {

    }

    private void fireWhenReady() {
        // We know that we're running single-threaded here, so we can use coarse grained project locks
        gradleInternal.getOwner().getProjects().withMutableStateOfAllProjects(
            () -> buildOperationRunner.run(
                new NotifyTaskGraphWhenReady(DefaultTaskExecutionGraph.this, graphListeners.getSource(), gradleInternal)
            )

        delegate.configurationTargetIdentifier

    override fun isRootBuild(): Boolean =
        delegate.isRootBuild

    override fun getOwner(): BuildState =
        delegate.owner

    override fun getProjectEvaluationBroadcaster(): ProjectEvaluationListener =
        delegate.projectEvaluationBroadcaster

        return action.apply(toolingModelControllerFactory.createController(targetBuild(), this));
    }

    private BuildState targetBuild() {
        return gradle.getOwner();
    }

    @Override
    public ExecutionResult<Void> finishBuild(@Nullable Throwable failure) {
        return state.transition(CONFIGURATION_STATES, State.BuildFinishHooks, stageFailures -> {

    def projectState = Mock(ProjectState) {
        fromMutableState(_) >> { Function factory -> factory.apply(project) }
    }
    def project = Stub(ProjectInternal) {
        getOwner() >> projectState
        getIdentityPath() >> Path.path(":path")
    }
    def registry = new TestProjectPublicationRegistry()
    def projectConfigurer = Mock(ProjectConfigurer)

    for (Value value_to_visit : values_to_visit) {
      if (!visited_values.insert(value_to_visit).second) continue;

      for (auto& use : value_to_visit.getUses()) {
        Operation* owner = use.getOwner();
        if (auto sharding = llvm::dyn_cast<mlir::TF::XlaShardingOp>(owner))
          return sharding.get_XlaSharding();

        if (auto logical_device = AssignLogicalDeviceFromTPUReplicatedCoreAttr(