// to a kernel. Key that uniquely identifies a compilation output.
struct DeviceCompilationClusterSignature {
  // Name of the cluster, built from the function name and it's attributes.
  string name;

  // List of args (either as a TensorTypeAndShape or as a Tensor value)
  // for compile-time constant arguments to the compilation, ordered by
  // argument number. Tensors must be in host memory.

			StabilityLevel: metrics.ALPHA,
		}),
	}

	legacyregistry.MustRegister(m.compilationTime)
	legacyregistry.MustRegister(m.evaluationTime)

	return m
}

// ObserveCompilation records a CEL compilation with the time the compilation took.
func (m *CelMetrics) ObserveCompilation(elapsed time.Duration) {
	seconds := elapsed.Seconds()
	m.compilationTime.Observe(seconds)
}

        } catch (Exception e) {
            accumulator.fullRebuildNeeded(classSet + " could not be analyzed for incremental compilation. See the debug log for more details");
            if (LOGGER.isDebugEnabled()) {
                LOGGER.debug("Could not analyze " + classSet + " for incremental compilation", e);
            }
        }

        return accumulator.getAnalysis();
    }

rootProject.name = "cross-compilation"...

                """#if swift(>=6.0)
                        XCTFail("Compilation unit compiled with Swift 6+ instead of Swift 5.x");
                    #elseif swift(>=5.0)
                        // Do nothing
                    #else
                        XCTFail("Compilation unit compiled with Swift 4- instead of Swift 5.x");
                    #endif
                """)
        ]
    }

CreateTPUClusterFormationPass(bool strict_clusters = false);

// Creates a pass that extracts outside compilation (Host ops inside device
// cluster) at head/tail of Device cluster to run before/after XLA computation.
std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>>
CreateExtractHeadTailOutsideCompilationPass();

// Creates a pass that extract outside compilation (Host ops inside cevice
// cluster) ops to a separate parallel_execute region to run on CPU.

        return super.getSource();
    }

    /**
     * Returns the compilation outputs needed by Scaladoc filtered to include <a href="https://docs.scala-lang.org/scala3/guides/tasty-overview.html">TASTy</a> files.
     * <p>
     * NOTE: This is only useful with Scala 3 or later. Scala 2 only processes source files.
     * </p>
     * @return the compilation outputs produced from the sources
     * @since 7.3
     */
    @InputFiles

    boolean useJar = false

    def setup() {
        configureGroovyIncrementalCompilation()
    }

    @Issue("https://github.com/gradle/gradle/issues/22531")
    def 'incremental compilation does not fail on api change referenced via static property when affected class is #bCompileStatic#bSuffix'() {
        given:
        // A is a private dependency of B1 and B1 is referenced in E1.isCacheEnabled through inheritance.

        then:
        configurationCache.assertStateStored()
        outputContains("Groovy compilation avoidance is an incubating feature")

        when:
        configurationCacheRun("compileGroovy", "--rerun-tasks")

        then:
        configurationCache.assertStateLoaded()
        outputContains("Groovy compilation avoidance is an incubating feature")
    }

        when:
        succeeds ':compileJava' // the internal class can be accessed

        then:
        javaClassFile('consumer/MainModule.class').exists()
    }

    def "fails module compilation for missing requires"() {
        given:
        publishJavaModule('moda')
        consumingModuleInfo()
        consumingModuleClass('moda.ModaClass')

        when:
        fails ':compileJava'