//
		// 	//go:wasmimport a_module add
		// 	func importedAdd(a, b uint) uint
		//
		// will roughly become
		//
		// 	(import "a_module" "add" (func (param i32 i32) (result i32)))
		abiConfig := AbiForBodylessFuncStackMap(f)
		abiInfo := abiConfig.ABIAnalyzeFuncType(f.Type())
		wi.Params = paramsToWasmFields(f, abiInfo, abiInfo.InParams())
		wi.Results = resultsToWasmFields(f, abiInfo, abiInfo.OutParams())
	}

        def testModule = mavenRepo().module(orgGradleGroupId, 'test', '1.45')
        def fooModule = mavenRepo().module(orgGradleGroupId, 'foo', '2.0')
        fooModule.publish()
        def barModule = mavenRepo().module(orgGradleGroupId, 'bar', '3.0')
        barModule.publish()
        def bazModule = mavenRepo().module(orgGradleGroupId, 'baz', '6.0')
        bazModule.publish()

 * limitations under the License.
 */
package org.gradle.plugins.ear.descriptor;

import groovy.util.Node;

/**
 * A module element in a deployment descriptor like application.xml.
 */
public interface EarModule {

    /**
     * The connector element specifies the URI of an archive file, relative to the top level of the application package.
     */
    String getPath();

public class KtModuleProviderBuilder(
    public val kotlinCoreProjectEnvironment: KotlinCoreProjectEnvironment,
) {
    private val mainModules: MutableList<KtModule> = mutableListOf()

    public fun <M : KtModule> addModule(module: M): M {
        mainModules.add(module)
        return module
    }

    public lateinit var platform: TargetPlatform

    public fun build(): KtStaticProjectStructureProvider {

                boolean testOnly = isTestConfiguration(configurations.get(artifact.getId()));
                boolean asModule = isModule(testOnly, artifact.getFile());
                if (componentIdentifier instanceof ProjectComponentIdentifier) {
                    visitor.visitProjectDependency(artifact, testOnly, asModule);
                } else {
                    if (componentIdentifier instanceof ModuleComponentIdentifier) {

// RUN: tf-mlir-translate -mlir-tf-str-attr-to-mlir %s -mlir-print-debuginfo -mlir-print-local-scope | FileCheck %s

"\0A\0Amodule attributes {tf.versions = {producer = 888 : i32}} {\0A func.func @main(%arg0: tensor<?xi32>) -> tensor<?xi32> {\0A %0 = \22tf.Identity\22(%arg0) : (tensor<?xi32>) -> tensor<?xi32> loc(unknown)\0A return %0 : tensor<?xi32> loc(unknown)\0A } loc(unknown)\0A} loc(unknown)"

// Test simple serialized computation consisting of a function named `main`

        and:
        repoA = mavenRepo("maven-repo")
        repoB = ivyRepo("ivy-repo")

        and:
        def abModule = publishPlugin(pluginAB, repoB).pluginModule
        (publishPlugin(pluginA, repoA).pluginModule as MavenModule)
            .dependsOn(abModule.group, abModule.module, abModule.version)
            .publishPom()

        and:
        use(repoB, repoA)

        and:
        buildFile << """

                val stdlib = addModule(
                    buildKtLibraryModule {
                        addBinaryRoot(Paths.get("dist/common/kotlin-stdlib-common.jar"))
                        platform = CommonPlatforms.defaultCommonPlatform
                        libraryName = "stdlib"
                    }
                )
                val commonModule = addModule(
                    buildKtSourceModule {

        d.group == 'aGroup'
        !d.module
    }

    def "with module"() {
        when:
        ExcludeRule d = parser.parseNotation([module: 'aModule']);
        then:
        d != null;
        d instanceof DefaultExcludeRule
        d.module == 'aModule'
        !d.group
    }

    def "with group and module"() {
        when:

    private val base: GlobalSearchScope,
    private val useSiteModule: KtModule,
    private val shadowed: GlobalSearchScope,
) : GlobalSearchScope() {
    override fun getProject(): Project? = base.project
    override fun isSearchInModuleContent(aModule: Module): Boolean = base.isSearchInModuleContent(aModule)
    override fun isSearchInLibraries(): Boolean = base.isSearchInLibraries