private String moduleName;
    private File moduleFile;
    private SwiftVersion sourceCompatibility;
    private Collection<File> changedFiles;

    @Override
    public String getModuleName() {
        return moduleName;
    }

    @Override
    public void setModuleName(String moduleName) {
        this.moduleName = moduleName;
    }

    @Override

    final GreeterElement cppGreeter
    final String moduleName

    SwiftGreeterUsingCppFunction(GreeterElement cppGreeter, String moduleName = 'cppGreeter') {
        this.cppGreeter = cppGreeter
        this.moduleName = moduleName
    }

    @Override
    SourceFile getSourceFile() {
        sourceFile("swift", "greeter.swift", """
            import ${moduleName}

            public class Greeter {

        file("build/modules/main/release/${lib.moduleName}.swiftmodule").assertIsFile()
        sharedLibrary("build/lib/main/release/${lib.moduleName}").assertExists()
        sharedLibrary("build/lib/main/release/${lib.moduleName}").assertHasStrippedDebugSymbolsFor(["greeter.o", "sum.o", "multiply.o"])
    }

    def "can use link file as task dependency"() {
        given:
        def lib = new SwiftLib()

 *
 * @since 4.5
 */
public class ModuleMap implements Serializable {
    private final String moduleName;
    private final List<String> publicHeaderPaths;

    public ModuleMap(String moduleName, List<String> publicHeaderPaths) {
        this.moduleName = moduleName;
        this.publicHeaderPaths = publicHeaderPaths;
    }

    /**
     * The name of the module to use for the generated module map.

        for (String moduleName : GRADLE_EXTENSION_MODULES) {
            Set<Module> extensionModules = allRequiredModulesOf(moduleName);
            classpath = plusExtensionModules(classpath, extensionModules, coreModules);
        }
        for (String moduleName : GRADLE_OPTIONAL_EXTENSION_MODULES) {
            Set<Module> optionalExtensionModules = allRequiredModulesOfOptional(moduleName);

    }

    private Module loadOptionalModule(final String moduleName) {
        File jarFile = findJar(moduleName, jarFile1 -> hasModuleProperties(moduleName, jarFile1));
        if (jarFile != null) {
            Set<File> implementationClasspath = new LinkedHashSet<>();
            implementationClasspath.add(jarFile);

        assertEquals("main", sourceModule.moduleName)
        assertEquals(sourceModule.moduleName, sourceModule.stableModuleName)
    }

    @Test
    fun testKotlinSourceModuleSessionWithVirtualFile() {
        val root = "otherModuleUsage"
        lateinit var sourceModule: KtSourceModule
        val session = buildStandaloneAnalysisAPISession(disposable) {
            buildKtModuleProvider {

            executable("build/exe/test/${componentUnderTest.moduleName}").assertExists()
            installation("build/install/test").assertInstalled()
        } else {
            machOBundle("build/exe/test/${componentUnderTest.moduleName}").assertExists()
            file("build/install/test/${componentUnderTest.moduleName}").assertIsFile()
            file("build/install/test/${componentUnderTest.moduleName}.xctest").assertIsDir()
        }
    }

        }

        void assertHasModule(String scope = 'COMPILE', String name) {
            assert modules.any { ImlModule it ->
                it.scope == scope && it.moduleName == name
            }  : "No module '$name' with scope $scope found in ${modules*.moduleName}"
        }

        void assertHasLibrary(String scope = 'COMPILE', String name) {
            assert libraries.any { ImlModuleLibrary it ->

         */
        @Nonnull
        private final String moduleName;

        /**
         * Creates a new path type for the specified module.
         *
         * @param moduleName name of the module for which a path is specified
         */
        private Modular(@Nonnull String moduleName) {
            this.moduleName = Objects.requireNonNull(moduleName);
        }

        /**