struct Entry {
    mutable mutex mu;

    // The current compilation state for this entry.
    DeviceCompileState compile_state TF_GUARDED_BY(mu) =
        DeviceCompileState::kUncompiled;

    // The number of times a compilation with this signature has been requested.
    int64_t request_count TF_GUARDED_BY(mu) = 0;

    // Did compilation succeed?
    Status compilation_status TF_GUARDED_BY(mu);

 * limitations under the License.
 */

package org.gradle.api.tasks.scala;

import org.gradle.language.scala.tasks.BaseScalaCompileOptions;

/**
 * Options for Scala Compilation.
 */
public abstract class ScalaCompileOptions extends BaseScalaCompileOptions {

subprojects {
    apply plugin: "groovy"

    dependencies {
        implementation localGroovy()
    }

    compileJava.options.fork = true

    // force creation of multiple daemons for Java compilation by alternating between two distinct sets of JVM args
    def count = (project.name - "project") as int
    compileJava.options.forkOptions.jvmArgs = count % 2 ? ["-dsa"] : ["-esa"]

      std::string launch_error =
          absl::StrCat("Node `", op->getName().getStringRef().str(), "` ",
                       "is a launch op which should have been removed by "
                       "outside compilation");

      op->emitError() << launch_error;
      LOG(ERROR) << launch_error;
      return WalkResult::interrupt();
    }

    if (HasXlaOutsideCompilationMarker(*op)) {

        run("impl:${language.compileTaskName}")

        then:
        impl.noneRecompiled()
    }

    def "new jar with duplicate class appearing earlier on classpath must trigger compilation"() {
        source impl: ["class A extends org.junit.Assert {}"]

        file("impl/build.gradle") << """
            configurations.implementation.dependencies.clear()
            dependencies {

 * limitations under the License.
 */

package org.gradle.internal.exceptions;

/**
 * An exception that is not caused by a Gradle specific problem. e.g. a problem caused by a compilation error.
 * This serves as a marker interface.
 */
public interface NonGradleCause {

        return assemblerArgs;
    }

    public void setAssemblerArgs(List<String> assemblerArgs) {
        this.assemblerArgs = assemblerArgs;
    }

    /**
     * The tool chain used for compilation.
     *
     * @since 4.7
     */
    @Internal
    public Property<NativeToolChain> getToolChain() {
        return toolChain;
    }

    /**
     * The platform being compiled for.

	}

	ast, issues := env.Compile(expressionAccessor.GetExpression())
	if issues != nil {
		return resultError("compilation failed: "+issues.String(), apiservercel.ErrorTypeInvalid)
	}

	found := false
	returnTypes := expressionAccessor.ReturnTypes()
	for _, returnType := range returnTypes {

     tf_executor.fetch
  }
  func.return
}

func.func @func() attributes {tf.entry_function = {}} {
  func.return
}

// -----

// expected-error @+1 {{does not support top-level compilation marker}}
func.func @top_level_compilation_marker() attributes {_xla_compile_device_type = "CPU", tf.entry_function = {}} {
  func.return

        <conf name="runtime" visibility="public" description="this scope indicates that the dependency is not required for compilation, but is for execution. It is in the runtime and test classpaths, but not the compile classpath." extends="compile"/>