#set ( $allFields = $Helper.xmlFields( $class ) )
    protected ${class.name} transform${class.name}(${class.name} target) {
        if (target == null) {
            return null;
        }
        Supplier<${class.name}.Builder> creator = () -> ${class.name}.newBuilder(target);
        ${class.name}.Builder builder = null;
    #foreach ( $field in $allFields )

#set ( $rootLcapName = $Helper.uncapitalise( $root.name ) )
#
#set ( $needXmlContext = false )
#foreach ( $class in $model.allClasses )
  #set ( $allFields = $Helper.xmlFields( $class ) )
  #foreach ( $field in $allFields )
    #if ( $Helper.xmlFieldMetadata( $field ).format )
      #set ( $needXmlContext = true )
    #end
  #end
#end
#

							subNameCount := len(names)
							// nested relation fields
							relFields := make([]*schema.Field, 0, subNameCount-1)
							relFields = append(relFields, rel.Field)
							for _, name := range names[1 : subNameCount-1] {
								rel = rel.FieldSchema.Relationships.Relations[name]
								relFields = append(relFields, rel.Field)
							}
							// latest name is raw dbname
							dbName := names[subNameCount-1]

    val allFiles = this
    val filesQueueToAnalyze = ArrayDeque(allFiles)
    val collector = InlineFunctionsCollector(allFiles.first().project, reifiedInlineFunctionsOnly = false) { declaration ->
        val containingFile = declaration.containingKtFile
        if (allFiles.add(containingFile)) {
            filesQueueToAnalyze += containingFile
        }
    }

	valuesYAML := ""
	var allFiles []string
	manifestDir := filepath.Join(repoRootDir, "manifests/charts")
	for _, sd := range []string{"base", "gateways", "istio-cni", "istio-control"} {
		dir := filepath.Join(manifestDir, sd)
		files, err := util.FindFiles(dir, yamlFileFilter)
		if err != nil {
			t.Fatalf(err.Error())
		}
		allFiles = append(allFiles, files...)
	}
	for _, f := range allFiles {

    operation_ids: Set[str] = set()
    all_fields = get_fields_from_routes(list(routes or []) + list(webhooks or []))
    model_name_map = get_compat_model_name_map(all_fields)
    schema_generator = GenerateJsonSchema(ref_template=REF_TEMPLATE)
    field_mapping, definitions = get_definitions(
        fields=all_fields,
        schema_generator=schema_generator,
        model_name_map=model_name_map,

        return new SourceFile(path, name, file.text);
    }

    void writeSources(TestFile sourceDir) {
        gradleBuild.writeToDir(sourceDir)
        for (SourceFile srcFile : allFiles) {
            srcFile.writeToDir(sourceDir)
        }
    }

    List<SourceFile> sourceFiles(String baseDir, String rootDir = getName()) {
        List sourceFiles = new ArrayList()

                }
            }
            analyzedElements.addAll(nextInlineFunctions)
        }
    }

    /**
     * Returns the list of files that contain all reached inline functions.
     */
    fun allFiles(): List<KtFile> = analyzedElements.mapTo(mutableSetOf()) { it.containingKtFile }.toList()

    /**
     * Returns the set of [KtObjectDeclaration]s which are defined as an object literal in one of the reached inline functions.

        // by the backend.
        val inlineAnalyzer = InlineFunctionAnalyzer(analysisContext, analyzeOnlyReifiedInlineFunctions = disableInline)
        inlineAnalyzer.analyze(file)

        val filesToCompile = inlineAnalyzer.allFiles().collectReachableInlineDelegatedPropertyAccessors()
        val bindingContext = analysisContext.analyze(filesToCompile, AnalysisMode.ALL_COMPILER_CHECKS)

        then:
        targetDir.file(settingsFile).exists()
        !targetDir.file(buildFile).exists()

        def allFiles = getAllFiles(targetDir)
            .findAll { it.name !in ["gradle-wrapper.jar", "gradlew", "gradlew.bat"] }

        allFiles.each {
            assert !it.text.containsIgnoreCase("generated by")
        }

        when:
        succeeds "build"

        then: