Revert "Revert "[light classes] drop old light classes and backend: iteration #6""

This reverts commit 8db53c0ca7.

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CliExtraDiagnosticsProvider.kt

@@ -12,12 +12,12 @@ import com.intellij.psi.util.CachedValuesManager
 import org.jetbrains.kotlin.asJava.KotlinAsJavaSupport
 import org.jetbrains.kotlin.asJava.KotlinExtraDiagnosticsProvider
 import org.jetbrains.kotlin.asJava.LightClassGenerationSupport
-import org.jetbrains.kotlin.asJava.builder.LightClassDataHolder
-import org.jetbrains.kotlin.asJava.builder.buildLightClass
 import org.jetbrains.kotlin.asJava.classes.getOutermostClassOrObject
 import org.jetbrains.kotlin.asJava.classes.safeIsLocal
 import org.jetbrains.kotlin.asJava.classes.safeScript
 import org.jetbrains.kotlin.asJava.classes.shouldNotBeVisibleAsLightClass
+import org.jetbrains.kotlin.cli.jvm.compiler.builder.LightClassDataHolder
+import org.jetbrains.kotlin.cli.jvm.compiler.builder.buildLightClass
 import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil
 import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.KtFile

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CliLightClassGenerationSupport.kt

@@ -6,16 +6,12 @@
 package org.jetbrains.kotlin.cli.jvm.compiler
 
 import com.intellij.openapi.project.Project
-import org.jetbrains.kotlin.asJava.LightClassBuilder
 import org.jetbrains.kotlin.asJava.LightClassGenerationSupport
-import org.jetbrains.kotlin.asJava.builder.InvalidLightClassDataHolder
-import org.jetbrains.kotlin.asJava.builder.LightClassConstructionContext
-import org.jetbrains.kotlin.asJava.builder.LightClassDataHolder
-import org.jetbrains.kotlin.asJava.builder.LightClassDataHolderImpl
 import org.jetbrains.kotlin.asJava.classes.KtUltraLightSupport
 import org.jetbrains.kotlin.asJava.classes.cleanFromAnonymousTypes
 import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.asJava.classes.tryGetPredefinedName
+import org.jetbrains.kotlin.cli.jvm.compiler.builder.*
 import org.jetbrains.kotlin.codegen.ClassBuilderMode
 import org.jetbrains.kotlin.codegen.JvmCodegenUtil
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
@@ -129,3 +125,5 @@ class CliLightClassGenerationSupport(
 
     override fun analyzeWithContent(element: KtClassOrObject) = traceHolder.bindingContext
 }
+
+typealias LightClassBuilder = (LightClassConstructionContext) -> LightClassBuilderResult

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/LightClassDataProvider.kt

@@ -10,10 +10,10 @@ import com.intellij.psi.util.CachedValueProvider
 import com.intellij.psi.util.PsiTreeUtil
 import org.jetbrains.kotlin.analyzer.KotlinModificationTrackerService
 import org.jetbrains.kotlin.asJava.LightClassGenerationSupport
-import org.jetbrains.kotlin.asJava.builder.LightClassDataHolder
-import org.jetbrains.kotlin.asJava.builder.buildLightClass
 import org.jetbrains.kotlin.asJava.classes.getOutermostClassOrObject
 import org.jetbrains.kotlin.asJava.classes.safeIsLocal
+import org.jetbrains.kotlin.cli.jvm.compiler.builder.LightClassDataHolder
+import org.jetbrains.kotlin.cli.jvm.compiler.builder.buildLightClass
 import org.jetbrains.kotlin.codegen.MemberCodegen
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/builder/KotlinLightClassBuilderFactory.kt

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.cli.jvm.compiler.builder
+
+import com.intellij.openapi.diagnostic.Logger
+import com.intellij.psi.PsiElement
+import com.intellij.psi.impl.java.stubs.PsiJavaFileStub
+import com.intellij.psi.stubs.StubElement
+import com.intellij.util.containers.Stack
+import org.jetbrains.kotlin.codegen.ClassBuilder
+import org.jetbrains.kotlin.codegen.ClassBuilderFactory
+import org.jetbrains.kotlin.codegen.ClassBuilderMode
+import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
+
+class KotlinLightClassBuilderFactory(private val javaFileStub: PsiJavaFileStub) : ClassBuilderFactory {
+    private val stubStack = Stack<StubElement<PsiElement>>().apply {
+        @Suppress("UNCHECKED_CAST")
+        push(javaFileStub as StubElement<PsiElement>)
+    }
+
+    override fun getClassBuilderMode(): ClassBuilderMode = ClassBuilderMode.LIGHT_CLASSES
+    override fun newClassBuilder(origin: JvmDeclarationOrigin) =
+        StubClassBuilder(stubStack, javaFileStub)
+
+    override fun asText(builder: ClassBuilder) = throw UnsupportedOperationException("asText is not implemented")
+    override fun asBytes(builder: ClassBuilder) = throw UnsupportedOperationException("asBytes is not implemented")
+    override fun close() {}
+
+    fun result(): PsiJavaFileStub {
+        val pop = stubStack.pop()
+        if (pop !== javaFileStub) {
+            LOG.error("Unbalanced stack operations: $pop")
+        }
+
+        return javaFileStub
+    }
+}
+
+private val LOG = Logger.getInstance(KotlinLightClassBuilderFactory::class.java)

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/builder/LightClassBuilder.kt

@@ -0,0 +1,103 @@
+/*
+ * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.cli.jvm.compiler.builder
+
+import com.intellij.openapi.diagnostic.Logger
+import com.intellij.openapi.progress.ProcessCanceledException
+import com.intellij.openapi.util.SystemInfo
+import com.intellij.openapi.util.registry.Registry
+import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.psi.impl.compiled.ClsFileImpl
+import com.intellij.psi.impl.java.stubs.PsiJavaFileStub
+import com.intellij.psi.impl.java.stubs.impl.PsiJavaFileStubImpl
+import org.jetbrains.kotlin.asJava.builder.ClsWrapperStubPsiFactory
+import org.jetbrains.kotlin.codegen.state.GenerationState
+import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.JVMConfigurationKeys
+import org.jetbrains.kotlin.config.languageVersionSettings
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics
+
+data class LightClassBuilderResult(val stub: PsiJavaFileStub, val bindingContext: BindingContext, val diagnostics: Diagnostics)
+
+fun buildLightClass(
+    packageFqName: FqName,
+    files: Collection<KtFile>,
+    generateClassFilter: GenerationState.GenerateClassFilter,
+    context: LightClassConstructionContext,
+    generate: (state: GenerationState, files: Collection<KtFile>) -> Unit
+): LightClassBuilderResult {
+    val project = files.first().project
+
+    try {
+        if (Registry.`is`("kotlin.ultra.light.classes.error.on.old.backend", false)) {
+            error("Access to backend detected")
+        }
+
+        val classBuilderFactory = KotlinLightClassBuilderFactory(createJavaFileStub(packageFqName, files))
+        val state = GenerationState.Builder(
+            project,
+            classBuilderFactory,
+            context.module,
+            context.bindingContext,
+            context.languageVersionSettings?.let {
+                CompilerConfiguration().apply {
+                    languageVersionSettings = it
+                    put(JVMConfigurationKeys.JVM_TARGET, context.jvmTarget)
+                    isReadOnly = true
+                }
+            } ?: CompilerConfiguration.EMPTY
+
+        ).generateDeclaredClassFilter(generateClassFilter).wantsDiagnostics(false).build()
+        state.beforeCompile()
+        state.oldBEInitTrace(files)
+
+        generate(state, files)
+
+        val javaFileStub = classBuilderFactory.result()
+
+        stubComputationTrackerInstance(project)?.onStubComputed(javaFileStub, context)
+        return LightClassBuilderResult(javaFileStub, context.bindingContext, state.collectedExtraJvmDiagnostics)
+    } catch (e: ProcessCanceledException) {
+        throw e
+    } catch (e: RuntimeException) {
+        logErrorWithOSInfo(e, packageFqName, files.firstOrNull()?.virtualFile)
+        throw e
+    }
+}
+
+private fun createJavaFileStub(packageFqName: FqName, files: Collection<KtFile>): PsiJavaFileStub {
+    val javaFileStub = PsiJavaFileStubImpl(packageFqName.asString(), /* compiled = */true)
+    javaFileStub.psiFactory = ClsWrapperStubPsiFactory.INSTANCE
+
+    val fakeFile = object : ClsFileImpl(files.first().viewProvider) {
+        override fun getStub() = javaFileStub
+
+        override fun getPackageName() = packageFqName.asString()
+
+        override fun isPhysical() = false
+
+        override fun getText(): String {
+            return files.singleOrNull()?.text ?: super.getText()
+        }
+    }
+
+    javaFileStub.psi = fakeFile
+    return javaFileStub
+}
+
+private fun logErrorWithOSInfo(cause: Throwable?, fqName: FqName, virtualFile: VirtualFile?) {
+    val path = virtualFile?.path ?: "<null>"
+    LOG.error(
+        "Could not generate LightClass for $fqName declared in $path\n" +
+                "System: ${SystemInfo.OS_NAME} ${SystemInfo.OS_VERSION} Java Runtime: ${SystemInfo.JAVA_RUNTIME_VERSION}",
+        cause,
+    )
+}
+
+private val LOG = Logger.getInstance(LightClassBuilderResult::class.java)

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/builder/LightClassConstructionContext.kt

@@ -0,0 +1,18 @@
+/*
+ * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.cli.jvm.compiler.builder
+
+import org.jetbrains.kotlin.config.JvmTarget
+import org.jetbrains.kotlin.config.LanguageVersionSettings
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.resolve.BindingContext
+
+open class LightClassConstructionContext(
+    val bindingContext: BindingContext,
+    val module: ModuleDescriptor,
+    val languageVersionSettings: LanguageVersionSettings?,
+    val jvmTarget: JvmTarget,
+)

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/builder/LightClassDataHolder.kt

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.cli.jvm.compiler.builder
+
+import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics
+
+interface LightClassDataHolder {
+    val extraDiagnostics: Diagnostics
+
+    interface ForClass : LightClassDataHolder
+    interface ForFacade : LightClassDataHolder
+    interface ForScript : ForClass
+}
+
+object InvalidLightClassDataHolder : LightClassDataHolder.ForClass {
+    override val extraDiagnostics: Diagnostics get() = shouldNotBeCalled()
+
+    private fun shouldNotBeCalled(): Nothing = throw UnsupportedOperationException("Should not be called")
+}
+
+class LightClassDataHolderImpl(
+    override val extraDiagnostics: Diagnostics
+) : LightClassDataHolder.ForClass, LightClassDataHolder.ForFacade, LightClassDataHolder.ForScript

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/builder/StubClassBuilder.java

@@ -0,0 +1,203 @@
+/*
+ * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.cli.jvm.compiler.builder;
+
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.impl.compiled.InnerClassSourceStrategy;
+import com.intellij.psi.impl.compiled.StubBuildingVisitor;
+import com.intellij.psi.impl.java.stubs.PsiClassStub;
+import com.intellij.psi.impl.java.stubs.PsiJavaFileStub;
+import com.intellij.psi.stubs.StubBase;
+import com.intellij.psi.stubs.StubElement;
+import com.intellij.util.containers.Stack;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.asJava.builder.ClsWrapperStubPsiFactory;
+import org.jetbrains.kotlin.asJava.builder.LightElementOrigin;
+import org.jetbrains.kotlin.asJava.builder.LightElementOriginKt;
+import org.jetbrains.kotlin.codegen.AbstractClassBuilder;
+import org.jetbrains.kotlin.fileClasses.OldPackageFacadeClassUtils;
+import org.jetbrains.kotlin.name.FqName;
+import org.jetbrains.kotlin.psi.KtFile;
+import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin;
+import org.jetbrains.org.objectweb.asm.ClassVisitor;
+import org.jetbrains.org.objectweb.asm.FieldVisitor;
+import org.jetbrains.org.objectweb.asm.MethodVisitor;
+
+import java.util.List;
+
+public class StubClassBuilder extends AbstractClassBuilder {
+    private static final InnerClassSourceStrategy<Object> EMPTY_STRATEGY = new InnerClassSourceStrategy<Object>() {
+        @Override
+        public Object findInnerClass(String s, Object o) {
+            return null;
+        }
+
+        @Override
+        public void accept(Object innerClass, StubBuildingVisitor<Object> visitor) {
+            throw new UnsupportedOperationException("Shall not be called!");
+        }
+    };
+    private final StubElement parent;
+    private final PsiJavaFileStub fileStub;
+    private StubBuildingVisitor v;
+    private final Stack<StubElement> parentStack;
+    private boolean isPackageClass = false;
+
+    public StubClassBuilder(@NotNull Stack<StubElement> parentStack, @NotNull PsiJavaFileStub fileStub) {
+        this.parentStack = parentStack;
+        this.parent = parentStack.peek();
+        this.fileStub = fileStub;
+    }
+
+    @NotNull
+    @Override
+    public ClassVisitor getVisitor() {
+        assert v != null : "Called before class is defined";
+        return v;
+    }
+
+    @Override
+    public void defineClass(
+            PsiElement origin,
+            int version,
+            int access,
+            @NotNull String name,
+            @Nullable String signature,
+            @NotNull String superName,
+            @NotNull String[] interfaces
+    ) {
+        assert v == null : "defineClass() called twice?";
+
+        //noinspection ConstantConditions
+        v = new StubBuildingVisitor<>(null, EMPTY_STRATEGY, parent, access, calculateShortName(name));
+
+        super.defineClass(origin, version, access, name, signature, superName, interfaces);
+
+        if (origin instanceof KtFile) {
+            FqName packageName = ((KtFile) origin).getPackageFqName();
+            String packageClassName = OldPackageFacadeClassUtils.getPackageClassName(packageName);
+
+            if (name.equals(packageClassName) || name.endsWith("/" + packageClassName)) {
+                isPackageClass = true;
+            }
+        }
+
+        if (!isPackageClass) {
+            parentStack.push(v.getResult());
+        }
+
+        ((StubBase) v.getResult()).putUserData(ClsWrapperStubPsiFactory.ORIGIN, LightElementOriginKt.toLightClassOrigin(origin));
+    }
+
+    @Nullable
+    private String calculateShortName(@NotNull String internalName) {
+        if (parent instanceof PsiJavaFileStub) {
+            assert parent == fileStub;
+            String packagePrefix = getPackageInternalNamePrefix();
+            assert internalName.startsWith(packagePrefix) : internalName + " : " + packagePrefix;
+            return internalName.substring(packagePrefix.length());
+        }
+        if (parent instanceof PsiClassStub<?>) {
+            String parentPrefix = getClassInternalNamePrefix((PsiClassStub) parent);
+            if (parentPrefix == null) return null;
+
+            assert internalName.startsWith(parentPrefix) : internalName + " : " + parentPrefix;
+            return internalName.substring(parentPrefix.length());
+        }
+        return null;
+    }
+
+    @Nullable
+    private String getClassInternalNamePrefix(@NotNull PsiClassStub classStub) {
+        String packageName = fileStub.getPackageName();
+
+        String classStubQualifiedName = classStub.getQualifiedName();
+        if (classStubQualifiedName == null) return null;
+
+        if (packageName.isEmpty()) {
+            return classStubQualifiedName.replace('.', '$') + "$";
+        }
+        else {
+            return packageName.replace('.', '/') + "/" + classStubQualifiedName.substring(packageName.length() + 1).replace('.', '$') + "$";
+        }
+    }
+
+
+    @NotNull
+    private String getPackageInternalNamePrefix() {
+        String packageName = fileStub.getPackageName();
+        if (packageName.isEmpty()) {
+            return "";
+        }
+        else {
+            return packageName.replace('.', '/') + "/";
+        }
+    }
+
+    @NotNull
+    @Override
+    public MethodVisitor newMethod(
+            @NotNull JvmDeclarationOrigin origin,
+            int access,
+            @NotNull String name,
+            @NotNull String desc,
+            @Nullable String signature,
+            @Nullable String[] exceptions
+    ) {
+        MethodVisitor internalVisitor = super.newMethod(origin, access, name, desc, signature, exceptions);
+
+        if (internalVisitor != EMPTY_METHOD_VISITOR) {
+            // If stub for method generated
+            markLastChild(origin);
+        }
+
+        return internalVisitor;
+    }
+
+    @NotNull
+    @Override
+    public FieldVisitor newField(
+            @NotNull JvmDeclarationOrigin origin,
+            int access,
+            @NotNull String name,
+            @NotNull String desc,
+            @Nullable String signature,
+            @Nullable Object value
+    ) {
+        FieldVisitor internalVisitor = super.newField(origin, access, name, desc, signature, value);
+
+        if (internalVisitor != EMPTY_FIELD_VISITOR) {
+            // If stub for field generated
+            markLastChild(origin);
+        }
+
+        return internalVisitor;
+    }
+
+    private void markLastChild(@NotNull JvmDeclarationOrigin origin) {
+        List children = v.getResult().getChildrenStubs();
+        StubBase last = (StubBase) children.get(children.size() - 1);
+
+        LightElementOrigin oldOrigin = last.getUserData(ClsWrapperStubPsiFactory.ORIGIN);
+        if (oldOrigin != null) {
+            PsiElement originalElement = oldOrigin.getOriginalElement();
+            throw new IllegalStateException("Rewriting origin element: " +
+                                            (originalElement != null ? originalElement.getText() : null) + " for stub " + last.toString());
+        }
+
+        last.putUserData(ClsWrapperStubPsiFactory.ORIGIN, LightElementOriginKt.toLightMemberOrigin(origin));
+    }
+
+    @Override
+    public void done() {
+        if (!isPackageClass) {
+            StubElement pop = parentStack.pop();
+            assert pop == v.getResult() : "parentStack: got " + pop + ", expected " + v.getResult();
+        }
+        super.done();
+    }
+}

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/builder/stubComputationTracker.kt

@@ -0,0 +1,17 @@
+/*
+ * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.cli.jvm.compiler.builder
+
+import com.intellij.openapi.project.Project
+import com.intellij.psi.impl.java.stubs.PsiJavaFileStub
+
+fun stubComputationTrackerInstance(project: Project): StubComputationTracker? {
+    return project.getComponent(StubComputationTracker::class.java)
+}
+
+interface StubComputationTracker {
+    fun onStubComputed(javaFileStub: PsiJavaFileStub, context: LightClassConstructionContext)
+}