[Gradle][Native] Setup refinesPaths as expectedBy module dependencies

Previously, dependsOn dependencies were just passed as friend modules to shared native compilations. ^KT-55071 Verification Pending
2022-11-23 10:16:17 +01:00
parent 0be789e9e3
commit 752ff04245
14 changed files with 99 additions and 78 deletions
@@ -281,6 +281,16 @@ class K2NativeCompilerArguments : CommonCompilerArguments() {
    )
    var friendModules: String? = null

+    /**
+     * @see K2MetadataCompilerArguments.refinesPaths
+     */
+    @Argument(
+        value = "-Xrefines-paths",
+        valueDescription = "<path>",
+        description = "Paths to output directories for refined modules (whose expects this module can actualize)"
+    )
+    var refinesPaths: String? = null
+
    @Argument(value = "-Xdebug-info-version", description = "generate debug info of given version (1, 2)")
    var debugInfoFormatVersion: String = "1" /* command line parser doesn't accept kotlin.Int type */

@@ -1,12 +1,11 @@
 package org.jetbrains.kotlin.serialization.konan

-import org.jetbrains.kotlin.library.resolver.KotlinLibraryResolveResult
 import org.jetbrains.kotlin.backend.common.serialization.metadata.KlibMetadataModuleDescriptorFactory
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.konan.file.File
-import org.jetbrains.kotlin.library.KotlinLibrary
+import org.jetbrains.kotlin.library.resolver.KotlinLibraryResolveResult
 import org.jetbrains.kotlin.storage.StorageManager

 interface KlibResolvedModuleDescriptorsFactory {
@@ -31,6 +30,7 @@ interface KlibResolvedModuleDescriptorsFactory {
        builtIns: KotlinBuiltIns?,
        languageVersionSettings: LanguageVersionSettings,
        friendModuleFiles: Set<File>,
+        refinesModuleFiles: Set<File>,
        includedLibraryFiles: Set<File>,
        additionalDependencyModules: Iterable<ModuleDescriptorImpl>,
        isForMetadataCompilation: Boolean,
@@ -51,5 +51,6 @@ class KotlinResolvedModuleDescriptors(
     */
    val forwardDeclarationsModule: ModuleDescriptorImpl,

-    val friendModules: Set<ModuleDescriptorImpl>
+    val friendModules: Set<ModuleDescriptorImpl>,
+    val refinesModules: Set<ModuleDescriptorImpl>
 )
@@ -1,6 +1,5 @@
 package org.jetbrains.kotlin.serialization.konan.impl

-import org.jetbrains.kotlin.library.resolver.KotlinLibraryResolveResult
 import org.jetbrains.kotlin.backend.common.serialization.metadata.KlibMetadataModuleDescriptorFactory
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.config.LanguageVersionSettings
@@ -13,9 +12,9 @@ import org.jetbrains.kotlin.descriptors.konan.SyntheticModulesOrigin
 import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.konan.file.File
-import org.jetbrains.kotlin.util.profile
 import org.jetbrains.kotlin.library.KotlinLibrary
 import org.jetbrains.kotlin.library.metadata.PackageAccessHandler
+import org.jetbrains.kotlin.library.resolver.KotlinLibraryResolveResult
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
@@ -26,12 +25,13 @@ import org.jetbrains.kotlin.serialization.konan.KotlinResolvedModuleDescriptors
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.storage.getValue
+import org.jetbrains.kotlin.util.profile
 import org.jetbrains.kotlin.utils.Printer

 // TODO: eliminate Native specifics.
 class KlibResolvedModuleDescriptorsFactoryImpl(
    override val moduleDescriptorFactory: KlibMetadataModuleDescriptorFactory
-): KlibResolvedModuleDescriptorsFactory {
+) : KlibResolvedModuleDescriptorsFactory {

    override fun createResolved(
        resolvedLibraries: KotlinLibraryResolveResult,
@@ -39,6 +39,7 @@ class KlibResolvedModuleDescriptorsFactoryImpl(
        builtIns: KotlinBuiltIns?,
        languageVersionSettings: LanguageVersionSettings,
        friendModuleFiles: Set<File>,
+        refinesModuleFiles: Set<File>,
        includedLibraryFiles: Set<File>,
        additionalDependencyModules: Iterable<ModuleDescriptorImpl>,
        isForMetadataCompilation: Boolean,
@@ -50,6 +51,7 @@ class KlibResolvedModuleDescriptorsFactoryImpl(
        var builtIns = builtIns

        val friendModuleDescriptors = mutableSetOf<ModuleDescriptorImpl>()
+        val refinesModuleDescriptors = mutableSetOf<ModuleDescriptorImpl>()
        val includedLibraryDescriptors = mutableSetOf<ModuleDescriptorImpl>()

        // Build module descriptors.
@@ -63,6 +65,8 @@ class KlibResolvedModuleDescriptorsFactoryImpl(
                builtIns = moduleDescriptor.builtIns
                moduleDescriptors.add(moduleDescriptor)

+                if (refinesModuleFiles.contains(library.libraryFile))
+                    refinesModuleDescriptors.add(moduleDescriptor)
                if (friendModuleFiles.contains(library.libraryFile))
                    friendModuleDescriptors.add(moduleDescriptor)
                if (includedLibraryFiles.contains(library.libraryFile))
@@ -88,8 +92,11 @@ class KlibResolvedModuleDescriptorsFactoryImpl(
        // Set inter-dependencies between module descriptors, add forwarding declarations module.
        for (module in moduleDescriptors) {
            val friends = additionalDependencyModules.toMutableSet()
-            if (module in includedLibraryDescriptors)
+            if (module in includedLibraryDescriptors) {
                friends.addAll(friendModuleDescriptors)
+                friends.addAll(refinesModuleDescriptors)
+            }
+
            module.setDependencies(
                // Yes, just to all of them.
                moduleDescriptors + additionalDependencyModules + forwardDeclarationsModule,
@@ -97,7 +104,12 @@ class KlibResolvedModuleDescriptorsFactoryImpl(
            )
        }

-        return KotlinResolvedModuleDescriptors(moduleDescriptors, forwardDeclarationsModule, friendModuleDescriptors)
+        return KotlinResolvedModuleDescriptors(
+            resolvedDescriptors = moduleDescriptors,
+            forwardDeclarationsModule = forwardDeclarationsModule,
+            friendModules = friendModuleDescriptors,
+            refinesModules = refinesModuleDescriptors
+        )
    }

    fun createForwardDeclarationsModule(
@@ -133,21 +145,21 @@ class KlibResolvedModuleDescriptorsFactoryImpl(
    }

    private fun createDescriptorOptionalBuiltsIns(
-            name: Name,
-            storageManager: StorageManager,
-            builtIns: KotlinBuiltIns?,
-            moduleOrigin: KlibModuleOrigin
+        name: Name,
+        storageManager: StorageManager,
+        builtIns: KotlinBuiltIns?,
+        moduleOrigin: KlibModuleOrigin
    ) = if (builtIns != null)
        moduleDescriptorFactory.descriptorFactory.createDescriptor(name, storageManager, builtIns, moduleOrigin)
    else
        moduleDescriptorFactory.descriptorFactory.createDescriptorAndNewBuiltIns(name, storageManager, moduleOrigin)

    private fun createDescriptorOptionalBuiltsIns(
-            library: KotlinLibrary,
-            languageVersionSettings: LanguageVersionSettings,
-            storageManager: StorageManager,
-            builtIns: KotlinBuiltIns?,
-            packageAccessHandler: PackageAccessHandler?
+        library: KotlinLibrary,
+        languageVersionSettings: LanguageVersionSettings,
+        storageManager: StorageManager,
+        builtIns: KotlinBuiltIns?,
+        packageAccessHandler: PackageAccessHandler?
    ) = if (builtIns != null)
        moduleDescriptorFactory.createDescriptor(library, languageVersionSettings, storageManager, builtIns, packageAccessHandler)
    else
@@ -256,6 +256,9 @@ class K2Native : CLICompiler<K2NativeCompilerArguments>() {
                if (arguments.friendModules != null)
                    put(FRIEND_MODULES, arguments.friendModules!!.split(File.pathSeparator).filterNot(String::isEmpty))

+                if(arguments.refinesPaths != null)
+                    put(REFINES_MODULES, arguments.refinesPaths!!.split(File.pathSeparator).filterNot(String::isEmpty))
+
                put(EXPORTED_LIBRARIES, selectExportedLibraries(configuration, arguments, outputKind))
                put(INCLUDED_LIBRARIES, selectIncludes(configuration, arguments, outputKind))
                put(FRAMEWORK_IMPORT_HEADERS, arguments.frameworkImportHeaders.toNonNullList())
@@ -339,6 +339,9 @@ class KonanConfig(val project: Project, val configuration: CompilerConfiguration
    internal val friendModuleFiles: Set<File> =
            configuration.get(KonanConfigKeys.FRIEND_MODULES)?.map { File(it) }?.toSet() ?: emptySet()

+    internal val refinesModuleFiles: Set<File> =
+            configuration.get(KonanConfigKeys.REFINES_MODULES)?.map { File(it) }?.toSet().orEmpty()
+
    internal val manifestProperties = configuration.get(KonanConfigKeys.MANIFEST_FILE)?.let {
        File(it).loadProperties()
    }
@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.backend.konan

 import org.jetbrains.kotlin.config.CompilerConfigurationKey
 import org.jetbrains.kotlin.konan.target.CompilerOutputKind
-import org.jetbrains.kotlin.serialization.js.ModuleKind

 class KonanConfigKeys {
    companion object {
@@ -46,6 +45,8 @@ class KonanConfigKeys {
                = CompilerConfigurationKey.create<List<String>>("headers imported to framework header")
        val FRIEND_MODULES: CompilerConfigurationKey<List<String>>
                = CompilerConfigurationKey.create<List<String>>("friend module paths")
+        val REFINES_MODULES: CompilerConfigurationKey<List<String>>
+                = CompilerConfigurationKey.create<List<String>>("refines module paths")
        val GENERATE_TEST_RUNNER: CompilerConfigurationKey<TestRunnerKind>
                = CompilerConfigurationKey.create("generate test runner") 
        val INCLUDED_BINARY_FILES: CompilerConfigurationKey<List<String>>
@@ -14,6 +14,7 @@ import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.context.MutableModuleContextImpl
 import org.jetbrains.kotlin.context.ProjectContext
 import org.jetbrains.kotlin.descriptors.PackageFragmentProvider
+import org.jetbrains.kotlin.descriptors.impl.ModuleDependenciesImpl
 import org.jetbrains.kotlin.descriptors.konan.CurrentKlibModuleOrigin
 import org.jetbrains.kotlin.descriptors.konan.isNativeStdlib
 import org.jetbrains.kotlin.konan.util.KlibMetadataFactories
@@ -31,7 +32,7 @@ internal object TopDownAnalyzerFacadeForKonan {

    fun analyzeFiles(files: Collection<KtFile>, context: Context): AnalysisResult {
        val config = context.config
-        val moduleName = Name.special("<${config.moduleId}>") 
+        val moduleName = Name.special("<${config.moduleId}>")

        val projectContext = ProjectContext(config.project, "TopDownAnalyzer for Konan")

@@ -41,13 +42,19 @@ internal object TopDownAnalyzerFacadeForKonan {

        val resolvedModuleDescriptors = nativeFactories.DefaultResolvedDescriptorsFactory.createResolved(
                config.resolvedLibraries, projectContext.storageManager, module.builtIns, config.languageVersionSettings,
-                config.friendModuleFiles, config.resolve.includedLibraries.map { it.libraryFile }.toSet(), listOf(module),
+                config.friendModuleFiles, config.refinesModuleFiles,
+                config.resolve.includedLibraries.map { it.libraryFile }.toSet(), listOf(module),
                isForMetadataCompilation = config.metadataKlib)

        val additionalPackages = mutableListOf<PackageFragmentProvider>()
        if (!module.isNativeStdlib()) {
-            val dependencies = listOf(module) + resolvedModuleDescriptors.resolvedDescriptors + resolvedModuleDescriptors.forwardDeclarationsModule
-            module.setDependencies(dependencies, resolvedModuleDescriptors.friendModules)
+            module.setDependencies(ModuleDependenciesImpl(
+                    allDependencies =
+                    listOf(module) + resolvedModuleDescriptors.resolvedDescriptors + resolvedModuleDescriptors.forwardDeclarationsModule,
+                    modulesWhoseInternalsAreVisible = resolvedModuleDescriptors.friendModules,
+                    directExpectedByDependencies = resolvedModuleDescriptors.refinesModules.toList(),
+                    allExpectedByDependencies = resolvedModuleDescriptors.refinesModules
+            ))
        } else {
            assert(resolvedModuleDescriptors.resolvedDescriptors.isEmpty())
            moduleContext.setDependencies(module)
@@ -70,7 +77,7 @@ internal object TopDownAnalyzerFacadeForKonan {
        // we print out each file we compile if frontend phase is verbose
        files.takeIf {
            context.shouldPrintFiles()
-        } ?.forEach(::println)
+        }?.forEach(::println)

        val container = createTopDownAnalyzerProviderForKonan(
                moduleContext, trace,
@@ -11,10 +11,13 @@ import org.gradle.api.Project
 import org.gradle.api.file.ConfigurableFileCollection
 import org.gradle.api.file.FileCollection
 import org.gradle.api.file.SourceDirectorySet
+import org.jetbrains.kotlin.gradle.dsl.multiplatformExtensionOrNull
 import org.jetbrains.kotlin.gradle.plugin.mpp.internal
 import org.jetbrains.kotlin.gradle.plugin.mpp.isMain
+import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.GradleKpmAbstractFragmentMetadataCompilationData
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.GradleKpmCompilationData
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.GradleKpmModule
+import org.jetbrains.kotlin.gradle.plugin.sources.dependsOnClosure
 import org.jetbrains.kotlin.gradle.utils.filesProvider
 import org.jetbrains.kotlin.project.model.LanguageSettings

@@ -30,6 +33,7 @@ internal sealed class KotlinCompilationInfo {
    abstract val compileAllTaskName: String
    abstract val languageSettings: LanguageSettings
    abstract val friendPaths: FileCollection
+    abstract val refinesPaths: FileCollection
    abstract val isMain: Boolean
    abstract val classesDirs: ConfigurableFileCollection
    abstract val compileDependencyFiles: FileCollection
@@ -70,6 +74,13 @@ internal sealed class KotlinCompilationInfo {
        override val friendPaths: FileCollection
            get() = project.filesProvider { origin.internal.friendPaths }

+        override val refinesPaths: FileCollection
+            get() = project.filesProvider files@{
+                val metadataTarget = project.multiplatformExtensionOrNull?.metadata() ?: return@files emptyList<Any>()
+                origin.kotlinSourceSets.dependsOnClosure
+                    .mapNotNull { sourceSet -> metadataTarget.compilations.findByName(sourceSet.name)?.output?.classesDirs }
+            }
+
        override val isMain: Boolean
            get() = origin.isMain()

@@ -117,6 +128,17 @@ internal sealed class KotlinCompilationInfo {
        override val friendPaths: FileCollection
            get() = project.filesProvider { origin.friendPaths }

+        override val refinesPaths: FileCollection
+            get() = project.filesProvider files@{
+                val compilationData = origin as? GradleKpmAbstractFragmentMetadataCompilationData<*> ?: return@files emptyList<Any>()
+                val fragment = compilationData.fragment
+
+                fragment.refinesClosure.minus(fragment).map {
+                    val compilation = compilationData.metadataCompilationRegistry.getForFragmentOrNull(it) ?: return@map project.files()
+                    compilation.output.classesDirs
+                }
+            }
+
        override val isMain: Boolean
            get() = origin.compilationPurpose == GradleKpmModule.MAIN_MODULE_NAME

@@ -146,4 +168,4 @@ internal val KotlinCompilationInfo.kpmOrNull: KotlinCompilationInfo.KPM?
    get() = when (this) {
        is KotlinCompilationInfo.KPM -> this
        is KotlinCompilationInfo.TCS -> null
-    }
+    }
@@ -10,8 +10,6 @@ import org.gradle.api.tasks.TaskProvider
 import org.gradle.api.tasks.bundling.AbstractArchiveTask
 import org.jetbrains.kotlin.gradle.plugin.mpp.*
 import org.jetbrains.kotlin.gradle.plugin.sources.getVisibleSourceSetsFromAssociateCompilations
-import org.jetbrains.kotlin.gradle.plugin.sources.internal
-import org.jetbrains.kotlin.gradle.targets.metadata.getMetadataCompilationForSourceSet
 import org.jetbrains.kotlin.gradle.utils.filesProvider

 internal interface KotlinCompilationFriendPathsResolver {
@@ -75,19 +73,6 @@ internal class DefaultKotlinCompilationFriendPathsResolver(
        }
    }

-    object AdditionalSharedNativeMetadataFriendArtifactResolver : FriendArtifactResolver {
-        override fun resolveFriendArtifacts(compilation: InternalKotlinCompilation<*>): FileCollection {
-            // TODO: implement proper dependsOn/refines compiler args for Kotlin/Native and pass the dependsOn klibs separately;
-            //       But for now, those dependencies don't have any special semantics, so passing all them as friends works, too
-            val friendSourceSets = getVisibleSourceSetsFromAssociateCompilations(compilation.defaultSourceSet) +
-                    compilation.defaultSourceSet.internal.dependsOnClosure
-
-            return compilation.project.files(
-                friendSourceSets.mapNotNull { compilation.project.getMetadataCompilationForSourceSet(it)?.output?.classesDirs }
-            )
-        }
-    }
-
    object AdditionalAndroidFriendArtifactResolver : FriendArtifactResolver {
        override fun resolveFriendArtifacts(compilation: InternalKotlinCompilation<*>): FileCollection {
            return compilation.project.files((compilation.decoratedInstance as KotlinJvmAndroidCompilation).testedVariantArtifacts)
@@ -213,8 +213,6 @@ val KotlinSourceSet.dependsOnClosure: Set<KotlinSourceSet> get() = this.internal
@Deprecated("Use InternalKotlinSourceSet.withDependsOnClosure instead. Will be removed in Kotlin 1.9")
 val KotlinSourceSet.withDependsOnClosure: Set<KotlinSourceSet> get() = this.internal.withDependsOnClosure

-@Suppress("Unused") // Still part of public API
-@Deprecated("Use InternalKotlinSourceSet.withDependsOnClosure instead. Will be removed in Kotlin 1.9")
 val Iterable<KotlinSourceSet>.dependsOnClosure: Set<KotlinSourceSet>
    get() = flatMap { it.internal.dependsOnClosure }.toSet() - this.toSet()

@@ -43,7 +43,7 @@ open class KotlinSharedNativeCompilationFactory internal constructor(
            compilationFriendPathsResolver = DefaultKotlinCompilationFriendPathsResolver(
                friendArtifactResolver = DefaultKotlinCompilationFriendPathsResolver.FriendArtifactResolver.composite(
                    DefaultKotlinCompilationFriendPathsResolver.DefaultFriendArtifactResolver,
-                    DefaultKotlinCompilationFriendPathsResolver.AdditionalSharedNativeMetadataFriendArtifactResolver
+                    DefaultKotlinCompilationFriendPathsResolver.AdditionalMetadataFriendArtifactResolver
                )
            ),

@@ -23,7 +23,8 @@ internal class CompilerPluginData(

 internal class SharedCompilationData(
    val manifestFile: File,
-    val isAllowCommonizer: Boolean
+    val isAllowCommonizer: Boolean,
+    val refinesPaths: FileCollection
 )

 internal fun buildKotlinNativeKlibCompilerArgs(
@@ -63,6 +64,13 @@ internal fun buildKotlinNativeKlibCompilerArgs(
        addArg("-friend-modules", friends.joinToString(File.pathSeparator) { it.absolutePath })
    }

+    if (sharedCompilationData != null) {
+        val refinesPaths = sharedCompilationData.refinesPaths.files
+        if (refinesPaths.isNotEmpty()) {
+            addArg("-Xrefines-paths", refinesPaths.joinToString(File.pathSeparator) { it.absolutePath })
+        }
+    }
+
    addAll(buildKotlinNativeCompileCommonArgs(enableEndorsedLibs, languageSettings, compilerOptions, compilerPlugins))

    addAll(source.map { it.absolutePath })
@@ -205,4 +213,4 @@ private fun MutableList<String>.addKey(key: String, enabled: Boolean) {
    if (enabled) {
        add(key)
    }
-}
+}
@@ -181,6 +181,9 @@ abstract class AbstractKotlinNativeCompile<
    @get:Classpath
    protected val friendModule: FileCollection = project.files({ compilation.friendPaths })

+    @get:Classpath
+    protected val refinesModule: FileCollection = project.files({ compilation.refinesPaths })
+
    @get:Input
    val target: String by project.provider { konanTarget.name }

@@ -468,7 +471,7 @@ internal constructor(
        properties[KLIB_PROPERTY_NATIVE_TARGETS] = konanTargetsForManifest
        properties.saveToFile(org.jetbrains.kotlin.konan.file.File(manifestFile.toPath()))

-        return SharedCompilationData(manifestFile, isAllowCommonizer)
+        return SharedCompilationData(manifestFile, isAllowCommonizer, refinesModule)
    }

    @TaskAction
@@ -5,16 +5,10 @@

 package org.jetbrains.kotlin.gradle.tasks.configuration

-import org.gradle.api.Project
-import org.gradle.api.provider.Provider
 import org.jetbrains.kotlin.gradle.plugin.KotlinCompilationInfo
-import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinCommonCompilation
-import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.GradleKpmAbstractFragmentMetadataCompilationData
 import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.GradleKpmMetadataCompilationData
-import org.jetbrains.kotlin.gradle.plugin.sources.internal
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompileCommon
-import java.io.File

 internal class KotlinCompileCommonConfig(
    private val compilationInfo: KotlinCompilationInfo,
@@ -27,33 +21,7 @@ internal class KotlinCompileCommonConfig(
                            compilationInfo.origin is GradleKpmMetadataCompilationData<*>
                }
            ).disallowChanges()
-            task.refinesMetadataPaths.from(getRefinesMetadataPaths(project)).disallowChanges()
-        }
-    }
-
-    private fun getRefinesMetadataPaths(project: Project): Provider<Iterable<File>> {
-        return project.provider {
-            when (compilationInfo) {
-                is KotlinCompilationInfo.TCS -> {
-                    val defaultKotlinSourceSet: KotlinSourceSet = compilationInfo.compilation.defaultSourceSet
-                    val metadataTarget = compilationInfo.compilation.target
-                    defaultKotlinSourceSet.internal.dependsOnClosure
-                        .mapNotNull { sourceSet -> metadataTarget.compilations.findByName(sourceSet.name)?.output?.classesDirs }
-                        .flatten()
-                }
-
-                is KotlinCompilationInfo.KPM -> {
-                    val compilationData = compilationInfo.compilationData as GradleKpmAbstractFragmentMetadataCompilationData<*>
-                    val fragment = compilationData.fragment
-                    project.files(
-                        fragment.refinesClosure.minus(fragment).map {
-                            val compilation = compilationData.metadataCompilationRegistry.getForFragmentOrNull(it)
-                                ?: return@map project.files()
-                            compilation.output.classesDirs
-                        }
-                    )
-                }
-            }
+            task.refinesMetadataPaths.from(compilationInfo.refinesPaths).disallowChanges()
        }
    }
 }