): EvaluationResult<AnalysisStepResult> {
        val failureReasons = mutableListOf<NotEvaluated.StageFailure>()

        val evaluationSchema = step.evaluationSchemaForStep

        val resolver = tracingCodeResolver(evaluationSchema.operationGenerationId, evaluationSchema.analysisStatementFilter)

        val languageModel = languageModelFromLightParser(scriptIdentifier, scriptSource)

    <dependency>
      <groupId>org.apache.maven.resolver</groupId>
      <artifactId>maven-resolver-api</artifactId>
    </dependency>
    <dependency>
      <groupId>org.apache.maven.resolver</groupId>
      <artifactId>maven-resolver-spi</artifactId>
    </dependency>
    <dependency>
      <groupId>org.apache.maven.resolver</groupId>
      <artifactId>maven-resolver-util</artifactId>
    </dependency>
    <dependency>

import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirOfType
import org.jetbrains.kotlin.analysis.low.level.api.fir.resolver.ResolutionParameters
import org.jetbrains.kotlin.analysis.low.level.api.fir.resolver.SingleCandidateResolutionMode
import org.jetbrains.kotlin.analysis.low.level.api.fir.resolver.SingleCandidateResolver
import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.llFirSession

val string = DataTypeInternal.DefaultStringDataType.ref


val boolean = DataTypeInternal.DefaultBooleanDataType.ref


fun AnalysisSchema.resolve(
    code: String,
    resolver: Resolver = tracingCodeResolver()
): ResolutionResult {
    val parsedTree = parse(code)

    val languageBuilder = DefaultLanguageTreeBuilder()
    val tree = languageBuilder.build(parsedTree, SourceIdentifier("demo"))

        val owner = analysisSession.getClassLikeSymbol(classId) ?: return null
        val firSession = analysisSession.useSiteSession
        val resolver = FirSamResolver(firSession, analysisSession.getScopeSessionFor(firSession))
        return resolver.getSamConstructor(owner)?.let {
            analysisSession.firSymbolBuilder.functionLikeBuilder.buildSamConstructorSymbol(it.symbol)
        }
    }

import org.jetbrains.kotlin.com.intellij.psi.tree.IElementType
import org.junit.jupiter.api.Test
import kotlin.test.assertEquals
import kotlin.test.assertTrue


class ImportTest {
    private
    val resolver = defaultCodeResolver()
    private
    val errorCollector = ErrorCollectorImpl()

    private
    fun testContext(): AnalysisContext {
        return AnalysisContext(
            DefaultAnalysisSchema(

      <artifactId>maven-slf4j-wrapper</artifactId>
    </dependency>
    <dependency>
      <groupId>org.apache.maven.resolver</groupId>
      <artifactId>maven-resolver-api</artifactId>
    </dependency>
    <dependency>
      <groupId>org.apache.maven.resolver</groupId>
      <artifactId>maven-resolver-util</artifactId>
    </dependency>
    <dependency>
      <groupId>org.codehaus.plexus</groupId>

    public fun KtReference.resolveToSymbols(): Collection<KaSymbol> = withValidityAssertion {
        return analysisSession.resolver.resolveToSymbols(this)
    }

    public fun KtReference.resolveToSymbol(): KaSymbol? = withValidityAssertion {
        return analysisSession.resolver.resolveToSymbols(this).singleOrNull()
    }

    /**

        this.resultId = resultId;
        this.module = module;
        this.id = id;
        this.componentIdentifier = componentIdentifier;
        this.resolver = resolver;
        this.implicitCapability = DefaultImmutableCapability.defaultCapabilityForComponent(id);

import org.gradle.internal.component.model.VariantGraphResolveState;
import org.gradle.internal.model.CalculatedValueContainerFactory;
import org.gradle.internal.resolve.resolver.ArtifactResolver;
import org.gradle.internal.resolve.resolver.DefaultVariantArtifactResolver;
import org.gradle.internal.resolve.resolver.VariantArtifactResolver;

import java.util.function.LongFunction;

/**