<buildTestSrc>${project.build.testSourceDirectory}</buildTestSrc>
    <buildScriptSrc>${project.build.scriptSourceDirectory}</buildScriptSrc>
    <buildOut>${project.build.directory}</buildOut>
    <buildMainOut>${project.build.outputDirectory}</buildMainOut>
    <buildTestOut>${project.build.testOutputDirectory}</buildTestOut>
    <siteOut>${project.reporting.outputDirectory}</siteOut>

                new File(pom.getValue("properties/buildScriptSrc").toString()));
        assertEquals(
                new File(pom.getBasedir(), "target"),
                new File(pom.getValue("properties/buildOut").toString()));
        assertEquals(
                new File(pom.getBasedir(), "target/classes"),
                new File(pom.getValue("properties/buildMainOut").toString()));
        assertEquals(

    @Delegate
    DaemonEventSequenceBuilder sequenceBuilder =
        new DaemonEventSequenceBuilder(stateTransitionTimeout * 1000)

    def buildDir(buildNum) {
        file("builds/$buildNum")
    }

    def buildDirWithScript(buildNum, buildScript) {
        def dir = buildDir(buildNum)
        dir.file("settings.gradle").touch()
        dir.file("build.gradle") << buildScript
        dir
    }

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import (
	"./a"
)

//go:noinline
func BuildInt() int {
	return a.BuildInt()
}

func main() {
	BuildInt()

    List<ScopeIds> getIds() {
        idsOfBuildTrees.collect { it.get(":") }
    }

    Map<String, ScopeIds> idsOfBuildTree(int buildNum) {
        idsOfBuildTrees.get(buildNum)
    }

    ScopeIds ids(int buildNum) {
        assert idsOfBuildTrees.size() > buildNum
        getIds()[buildNum]
    }

    UniqueId getBuildInvocationId() {
        idsOfBuildTrees.last().":".buildInvocation
    }

        given:
        def grammar = """
        header {
            package org.acme;
        }

        class TestGrammar extends Parser;

        options {
            buildAST = true;
        }

        expr:   mexpr (PLUS^ mexpr)* SEMI!
            ;

        mexpr
            :   atom (STAR^ atom)*
            ;

        atom:   INT
            ;"""
        expect:

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import (
	"./a"
	"fmt"
)

func BuildInt() int {
	return a.BuildInt()
}

func main() {
	if got, want := BuildInt(), 0; got != want {
		panic(fmt.Sprintf("got %d, want %d", got, want))
	}

            header {
                package org.acme;
            }

            class TestGrammar extends Parser;

            options {
                buildAST = true;
            }

            expr:   mexpr (PLUS^ mexpr)* SEMI!
                ;

            mexpr
                :   atom (STAR^ atom)*
                ;

            atom:   INT

        }
    }

    override fun getAllPossibleNames(): Set<Name> = withValidityAssertion {
        buildSet {
            subScopes.flatMapTo(this) { it.getAllPossibleNames() }
        }
    }

    override fun getPossibleCallableNames(): Set<Name> = withValidityAssertion {
        buildSet {
            subScopes.flatMapTo(this) { it.getPossibleCallableNames() }
        }
    }

                return false
            }
        }
    }

    override fun getSubPackageFqNames(packageFqName: FqName, platform: TargetPlatform, nameFilter: (Name) -> Boolean): Set<Name> =
        buildSet {
            addAll(getKotlinOnlySubPackagesFqNames(packageFqName, nameFilter))
            addAll(getPlatformSpecificSubPackagesFqNames(packageFqName, platform, nameFilter))
        }