abstract String getLanguageId()

    def "registers transformation for language"() {
        when:
        dsl {
            apply plugin: pluginClass
        }

        then:
        def transform = realize("languageTransforms").find { it.languageName == languageId }

        transform != null
        transform.sourceSetType == languageSourceSet
    }

    const ::stablehlo::quantization::DebuggerConfig& debugger_config);

// Deserializes StableHLO functions serialized and embedded in XlaCallModuleOps.
void AddXlaCallModuleOpDeserializationPasses(OpPassManager& pm);

// Legalizes shape/tensor/arith dialect ops to StableHLO for handling dynamic
// shapes, by going through a round-trip to MHLO.
void AddShapeLegalizationPasses(OpPassManager& pm);

        when:
        dsl {
            apply plugin: ComponentBasePlugin
            model {
                baseComponent(ComponentSpec) {
                }
            }
        }

        then:
        realize("baseComponent") instanceof ComponentSpec
    }

    def "adds a 'components' container to the project model"() {
        when:
        dsl {
            apply plugin: ComponentBasePlugin
        }

        dsl {
            apply plugin: LanguageBasePlugin
            model {
                baseSourceSet(LanguageSourceSet) {
                }
            }
        }

        then:
        realize("baseSourceSet") instanceof LanguageSourceSet
    }

    def "adds a 'sources' container to the project model"() {
        when:
        dsl {
            apply plugin: LanguageBasePlugin
        }

        // Looks in the correct project registry for this binary
        VisualStudioExtension visualStudioExtension = getComponentModel(nativeBinary).realize("visualStudio", VisualStudioExtension.class);
        VisualStudioProjectRegistry projectRegistry = ((VisualStudioExtensionInternal) visualStudioExtension).getProjectRegistry();

      /*allow_mutable_tensors=*/true));

  // Generic MLIR optimization passes.
  pm.addPass(mlir::createCanonicalizerPass());
  pm.addPass(mlir::TF::CreateTFShapeInferencePass());

  // Legalizes TF UniformQuantized types into MHLO.
  pm.addNestedPass<func::FuncOp>(
      mlir::quant::stablehlo::CreateConvertTFQuantOpsToMHLOPass());
  pm.addPass(mlir::createCanonicalizerPass());

  // TF -> StableHLO legalization.

import org.gradle.api.NonNullApi;

@NonNullApi
public class GradleProjectBuilderOptions {

    /**
     * Determines whether a builder for the {@link org.gradle.tooling.model.GradleProject} model should realize tasks.
     * <p>
     * This method has to be invoked during builder execution time to provide an effective value.

    }

    def "can put existing unmanaged instance"() {
        when:
        mutate {
            put("foo", "bar")
        }

        then:
        registry.realize("map.foo", String) == "bar"
    }

    @Managed
    abstract static class Invalid<T> implements SpecialNamedThingInterface {}

    def "cannot create invalid subtype"() {
        when:
        mutate {

            components {
                main(NativeLibrarySpec)
            }
        }
        project.evaluate()

        when:
        CUnitTestSuiteSpec testSuite = project.modelRegistry.realize("testSuites", modelMap(TestSuiteSpec)).mainTest
        def sources = testSuite.sources.values()
        def binaries = testSuite.binaries.values()

        then:
        sources.size() == 2

        dsl {
            apply plugin: ComponentModelBasePlugin
            model {
                baseComponent(type) {
                }
            }
        }

        then:
        type.isInstance(realize("baseComponent"))

        where:
        type                 | _
        GeneralComponentSpec | _
        ApplicationSpec      | _
        LibrarySpec          | _
    }