appendLine("${KaTypeScope::class.simpleName}:")
                appendLine(typeScope?.let { renderForTests(it) } ?: "NO_SCOPE")
                appendLine()

                appendLine("Declaration Scope:")
                appendLine(declaredScopeByTypeScope?.let { renderForTests(it) } ?: "NO_SCOPE")

            }

            val signaturePretty = prettyPrint {
                appendLine("${KaTypeScope::class.simpleName}:")

            constraint("org.test:foo:1.0")
            constraint("org.test:bar:1.0")
            noMoreDependencies()
        }
        javaPlatform.parsedPom.scopes.keySet() == ['no_scope'] as Set
        javaPlatform.parsedPom.scope('no_scope') {
            assertNoDependencies()
            assertDependencyManagement("org.test:bar:1.0", "org.test:foo:1.0")
        }
    }

    def "can define a platform with local projects"() {

                scopesByDependency.put(mavenDependency.getKey(), scope.name)
            }

            pom.dependencyManagement.dependencies.dependency.each { dep ->
                def scope = createScope(dep.scope, 'no_scope')
                MavenDependency mavenDependency = createDependency(dep)
                scope.dependencyManagement[mavenDependency.getKey()] = mavenDependency
            }

        javaLibrary.parsedPom.scopes.keySet() == ["compile", "no_scope", "runtime"] as Set
        javaLibrary.parsedPom.scopes.compile.assertDependsOn("org.springframework:spring-core:1.2.9")

        javaLibrary.parsedPom.scopes.runtime.assertDependsOn("org.apache.commons:commons-compress:1.5")
        javaLibrary.parsedPom.scopes.no_scope.assertDependencyManagement("commons-logging:commons-logging:1.1", "org.tukaani:xz:1.6")

        then:
        platformModule.parsedPom.packaging == 'pom'
        platformModule.parsedPom.scopes.compile.assertDependsOn("org.test:foo:1.0")
        platformModule.parsedPom.scopes.no_scope.assertDependencyManagement("org.test:bar:1.1")
        platformModule.parsedModuleMetadata.variant('apiElements') {
            dependency("org.test:foo:1.0").exists()
            constraint("org.test:bar:1.1").exists()

            val failedScope = newScope().apply {
                io { throw IllegalStateException() }
            }
            awaitExceptionFrom(failedScope)

            // then: actions can still be scheduled in separate scope
            val isolatedScopeAction = CompletableFuture<Unit>()
            newScope().apply {
                io { isolatedScopeAction.complete(Unit) }
            }
            assertThat(

 *
 * [close] guarantees all scheduled IO actions are executed before returning.
 *
 * Each [IOScope] operates independently and failures in one [IOScope]
 * do not affect existing or future [IOScope]s.
 *
 * Each [IOScope] can only be used from a single thread at a time.
 */
interface IOScope : IO, AutoCloseable


/**
 * A Gradle build service to offload IO actions to a dedicated thread.
 */

    executorServiceProvider: () -> ExecutorService
) : Closeable, AsyncIOScopeFactory {

    private
    val executorService = lazy(executorServiceProvider)

    override fun newScope(): IOScope = object : IOScope {

        private
        val failure = AtomicReference<Throwable?>(null)

        private
        var pending: Future<*>? = null

        override fun io(action: () -> Unit) {

	}
	if debugResolve {
		r.trace("opening scope @%v", pos)
	}
	r.topScope = ast.NewScope(r.topScope)
}

func (r *resolver) closeScope() {
	r.depth--
	if debugResolve {
		r.trace("closing scope")
	}
	r.topScope = r.topScope.Outer
}

func (r *resolver) openLabelScope() {
	r.labelScope = ast.NewScope(r.labelScope)
	r.targetStack = append(r.targetStack, nil)
}

	p.openScope()
	p.pkgScope = p.topScope

	// for the same reason, set up a label scope
	p.openLabelScope()
}

// ----------------------------------------------------------------------------
// Scoping support

func (p *parser) openScope() {
	p.topScope = ast.NewScope(p.topScope)
}

func (p *parser) closeScope() {
	p.topScope = p.topScope.Outer
}

func (p *parser) openLabelScope() {