}

    @ToBeImplemented
    @Issue('https://github.com/gradle/gradle/issues/29147')
    def "can connect transformed incoming elements of a configuration to task input ListProperty"() {
        withZipArtifactProducingSubprojects 'p1', 'p2'
        withIdentityTransform()
        buildFile '''
            apply plugin: 'base'

    // Adjust the function arguments to match the types of the caller.
    // So e.g.
    //
    // func.func @f(%x : foo) {
    // }
    // ...
    // func.call @f(%x : bar)
    //
    // will be transformed to
    //
    // func.func @f(%x : bar) {
    //   ...
    // }
    // ...
    // func.call @f(%x : bar)

    CallInterfaceCallable callable = call.getCallableForCallee();

    @Override
    public InputFingerprinter getInputFingerprinter() {
        return inputFingerprinter;
    }

    private static File getOutputDir(File workspace) {
        return new File(workspace, "transformed");
    }

    private static File getResultsFile(File workspace) {
        return new File(workspace, "results.bin");
    }

    @Override
    public ExecutionBehavior getExecutionBehavior() {

              <!-- internal field removed -->
              <exclude>org.apache.maven.graph.DefaultGraphBuilder#projectBuilder</exclude>
              <!-- MavenPluginValidator has been transformed into an interface -->
              <exclude>org.apache.maven.plugin.MavenPluginValidator</exclude>
              <!-- Remove plexus logger -->

  // separate pass.
  pass_manager.addPass(mlir::odml::CreateUnfoldSplatConstantPass());

  if (pass_config.enable_stablehlo_quantizer) {
    // When using StableHLO Quantizer, MHLO ops should be transformed back into
    // StableHLO because the quantizer takes StableHLO dialect as its input.
    pass_manager.addPass(mlir::mhlo::createHloLegalizeToStablehloPass());
  }
}

void AddPostQuantizationStableHloToTfPasses(

			// offset from the start of the compile unit.
			o = ldr.SymValue(rs) + r.Add() - ldr.SymValue(loader.Sym(ldr.SymUnit(rs).Textp[0]))

		// r.Sym() can be 0 when CALL $(constant) is transformed from absolute PC to relative PC call.
		case objabi.R_GOTPCREL:
			if target.IsDynlinkingGo() && target.IsDarwin() && rs != 0 {
				nExtReloc++
				o = r.Add()
				break
			}

        output.text == "16"

        when:
        input.text = "10"
        configurationCacheRun(":transformer")

        then:
        configurationCache.assertStateLoaded()
        result.assertTasksExecutedAndNotSkipped(":producer", ":transformer")
        output.text == "22"

        when:
        configurationCacheRun(":transformer")

        then:

    ) {
        final Transformer transformer = extractingTransformer != null ? extractingTransformer.getTransformer() : null;
        logger.info("Compiling {} using {}.", source.getDisplayName(), transformer != null ? transformer.getClass().getSimpleName() : "no transformer");

        final EmptyScriptDetector emptyScriptDetector = new EmptyScriptDetector();

	originalTransformer := s.transformer.(*storagetesting.PrefixTransformer)
	transformer := *originalTransformer
	s.transformer = modifier(&transformer)
	s.watcher.transformer = modifier(&transformer)
	return func() {
		s.transformer = originalTransformer
		s.watcher.transformer = originalTransformer
	}
}

func TestGuaranteedUpdate(t *testing.T) {

    useSiteSession: FirSession,
    classId: ClassId,
    transformer: (index: Int, annotation: FirAnnotation) -> KaAnnotation?,
): List<KaAnnotation> = mapIndexedNotNull { index, annotation ->
    if (annotation.toAnnotationClassId(useSiteSession) != classId) {
        return@mapIndexedNotNull null
    }

    transformer(index, annotation)
}

private fun computeTargetAnnotationArguments(