val fileFacadeClassName = InternalName(baseFileName + "Kt")
    val moduleName = "kotlin-dsl-plugin-spec-accessors"
    val moduleMetadata = moduleMetadataBytesFor(listOf(fileFacadeClassName))
    writeFile(
        moduleFileFor(binDir, moduleName),
        moduleMetadata
    )

                        addSourceRoot(testDataPath("resolveAgainstNativeKLib/src"))
                        addRegularDependency(kLib)
                        platform = nativePlatform
                        moduleName = "source"
                    }
                )
            }
        }
        val ktFile = session.modulesWithFiles.getValue(sourceModule).single() as KtFile

abstract class AbstractKotlinDslScriptsModelBuilder : ToolingModelBuilder {

    companion object {
        private
        const val MODEL_NAME = "org.gradle.tooling.model.kotlin.dsl.KotlinDslScriptsModel"
    }

    override fun canBuild(modelName: String): Boolean =
        modelName == MODEL_NAME

    override fun buildAll(modelName: String, project: Project): KotlinDslScriptsModel {
        requireRootProject(project)

                apply plugin: 'java-library'
            """
        }
        file("groovy-lib/src/main/resources/META-INF/groovy/org.codehaus.groovy.runtime.ExtensionModule") << """
            moduleName=Test module
            moduleVersion=1.0-test
            extensionClasses=support.FrenchStrings
        """
        file("groovy-lib/src/main/groovy/support/FrenchStrings.groovy") << """
            package support

            @Override
            protected List<IncrementalElement.Transform> getIncrementalChanges() {
                return [modify(mainFile, alternateFile)]
            }

            final String moduleName = "App"
        }
    }

    @Override
    protected SourceElement getComponentWithoutMainUnderTest() {
        return new SwiftLib()
    }

    @Override

        return error  # type: ignore[return-value]

    def create_body_model(
        *, fields: Sequence[ModelField], model_name: str
    ) -> Type[BaseModel]:
        field_params = {f.name: (f.field_info.annotation, f.field_info) for f in fields}
        BodyModel: Type[BaseModel] = create_model(model_name, **field_params)  # type: ignore[call-overload]
        return BodyModel

else:

                        addSourceRoot(testDataPath("stdlibFunctionUsage"))
                        addRegularDependency(stdlib)
                        platform = targetPlatform
                        moduleName = "source"
                    }
                )
            }
        }
        val ktFile = session.modulesWithFiles.getValue(sourceModule).single() as KtFile

        // call

            firSession.typeApproximator,
            scopeSession,
            JvmSerializationBindings(),
            useTypeTable = true,
            moduleName = (analysisSession.useSiteModule as KtSourceModule).run { stableModuleName ?: moduleName },
            classBuilderMode = ClassBuilderMode.KAPT3,
            isParamAssertionsDisabled = false,
            unifiedNullChecks = true,

 */
@NonNullApi
public class IsolatedProjectsSafeIdeaModelBuilder implements IdeaModelBuilderInternal, ParameterizedToolingModelBuilder<IdeaModelParameter> {

    private static final String MODEL_NAME = IdeaProject.class.getName();

    private final IntermediateToolingModelProvider intermediateToolingModelProvider;
    private final GradleProjectBuilderInternal gradleProjectBuilder;

    }

    PBXNativeTarget getIndexTarget() {
        return targets.find { it instanceof PBXNativeTarget }
    }

    List<PBXTarget> findTargets(String moduleName) {
        return targets.findAll { it.name == moduleName }
    }

    PBXLegacyTarget getGradleTarget() {
        return targets.find { it instanceof PBXLegacyTarget }
    }

    PBXGroup getMainGroup() {