// Authorizer provides the authorizer used for the "authorizer" and
	// "authorizer.requestResource" variable bindings. If the expression was compiled with
	// OptionalVariableDeclarations.HasAuthorizer set to true this must be non-nil.
	Authorizer authorizer.Authorizer
}

// Filter contains a function to evaluate compiled CEL-typed values
// It expects the inbound object to already have been converted to the version expected

// type from the sym package since loader imports sym.
type LoaderSym uint32

// A CompilationUnit represents a set of source files that are compiled
// together. Since all Go sources in a Go package are compiled together,
// there's one CompilationUnit per package that represents all Go sources in
// that package, plus one for each assembly file.
//

                """#if swift(>=4.0)
                        XCTFail("Compilation unit compiled with Swift 4+ instead of Swift 3.x");
                    #elseif swift(>=3.0)
                        // Do nothing
                    #else
                        XCTFail("Compilation unit compiled with Swift 2- instead of Swift 3.x");
                    #endif
                """)
        ]
    }

// are in external code, and will continue to use R30,
// this might well result in another SIGSEGV.

// save_g saves the g register into pthread-provided
// thread-local memory, so that we can call externally compiled
// ppc64 code that will overwrite this register.
//
// If !iscgo, this is a no-op.
//
// NOTE: setg_gcc<> assume this clobbers only R31.
TEXT runtime·save_g(SB),NOSPLIT|NOFRAME,$0-0
#ifndef GOOS_aix

    protected
    val kotlinDslEvalBaseTempDir: File
        get() = dslTestFixture.kotlinDslEvalBaseTempDir

    /**
     * Evaluates the given Kotlin [script] against this [Project] writing compiled classes
     * to sub-directories of [baseCacheDir] using [scriptCompilationClassPath].
     */
    fun Project.eval(
        script: String,
        baseCacheDir: File = kotlinDslEvalBaseCacheDir,

import com.intellij.psi.PsiElement
import com.intellij.psi.PsiType
import com.intellij.psi.PsiTypeElement
import com.intellij.psi.SyntheticElement
import com.intellij.psi.impl.compiled.ClsTypeElementImpl
import com.intellij.psi.impl.compiled.SignatureParsing
import com.intellij.psi.impl.compiled.StubBuildingVisitor
import org.jetbrains.kotlin.analysis.api.components.KaPsiTypeProvider
import org.jetbrains.kotlin.analysis.api.descriptors.KaFe10Session

            CLASSPATH,
            BODY,
            CLASSPATH,
            BODY,
            CLASSPATH,
            BODY,
            CLASSPATH,
            BODY
        ]

        when: // already compiled build scripts
        succeeds "help", '-I', 'init.gradle'

        then:
        operations.all(CompileScriptBuildOperationType).size() == 0

        when: // changing cached build script

import java.util.Set;

public interface SourceFileClassNameConverter {
    /**
     * Returns the classes that were compiled from this source file or an empty set if unknown.
     */
    Set<String> getClassNames(String sourceFileRelativePath);

    /**
     * Returns the source files that this class was compiled from.
     * Can be multiple files when the same class declaration was made in several files.

package org.gradle.api.tasks;

import org.gradle.api.file.FileCollection;

import javax.annotation.Nullable;
import java.io.File;
import java.util.Map;

/**
 * A collection of all output directories (compiled classes, processed resources, etc.) - notice that {@link SourceSetOutput} extends {@link FileCollection}.
 * <p>

        }
    }

    static <T> ChildMap<T> childMap(CaseSensitivity caseSensitivity, ChildMap.Entry<T> entry1, ChildMap.Entry<T> entry2) {
        int compared = PathUtil.getPathComparator(caseSensitivity).compare(entry1.getPath(), entry2.getPath());
        List<ChildMap.Entry<T>> sortedEntries = compared < 0
            ? ImmutableList.of(entry1, entry2)
            : ImmutableList.of(entry2, entry1);
        return childMapFromSorted(sortedEntries);