Add support for UltraLightScripts

2020-04-30 22:24:14 +03:00
parent 6a2461f2c6
commit 62c24c95b5
16 changed files with 404 additions and 51 deletions
@@ -19,15 +19,11 @@ package org.jetbrains.kotlin.asJava
 import com.intellij.openapi.components.ServiceManager
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiManager
-import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.util.CachedValue
 import org.jetbrains.kotlin.asJava.builder.LightClassBuilderResult
 import org.jetbrains.kotlin.asJava.builder.LightClassConstructionContext
 import org.jetbrains.kotlin.asJava.builder.LightClassDataHolder
-import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade
-import org.jetbrains.kotlin.asJava.classes.KtUltraLightClass
-import org.jetbrains.kotlin.asJava.classes.KtUltraLightClassForFacade
-import org.jetbrains.kotlin.asJava.classes.KtUltraLightSupport
+import org.jetbrains.kotlin.asJava.classes.*
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.*
@@ -50,6 +46,8 @@ abstract class LightClassGenerationSupport {

    abstract fun createUltraLightClass(element: KtClassOrObject): KtUltraLightClass?

+    abstract fun createUltraLightClassForScript(script: KtScript): KtUltraLightClassForScript?
+
    abstract fun createUltraLightClassForFacade(
        manager: PsiManager,
        facadeClassFqName: FqName,
@@ -1,29 +1,26 @@
 /*
- * Copyright 2010-2017 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * Copyright 2010-2020 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.asJava.classes

 import com.intellij.openapi.util.Comparing
 import com.intellij.openapi.util.Key
+import com.intellij.openapi.util.registry.Registry
 import com.intellij.psi.*
+import com.intellij.psi.impl.PsiSuperMethodImplUtil
+import com.intellij.psi.impl.java.stubs.PsiJavaFileStub
 import com.intellij.psi.impl.light.LightEmptyImplementsList
 import com.intellij.psi.impl.light.LightModifierList
 import com.intellij.psi.util.CachedValue
+import com.intellij.psi.util.CachedValueProvider
 import com.intellij.psi.util.CachedValuesManager
+import com.intellij.util.IncorrectOperationException
 import org.jetbrains.annotations.NonNls
+import org.jetbrains.kotlin.analyzer.KotlinModificationTrackerService
+import org.jetbrains.kotlin.asJava.LightClassGenerationSupport
+import org.jetbrains.kotlin.asJava.builder.LightClassData
 import org.jetbrains.kotlin.asJava.builder.LightClassDataHolder
 import org.jetbrains.kotlin.asJava.builder.LightClassDataProviderForScript
 import org.jetbrains.kotlin.asJava.elements.FakeFileForLightClass
@@ -31,13 +28,20 @@ import org.jetbrains.kotlin.idea.KotlinLanguage
 import org.jetbrains.kotlin.load.java.structure.LightClassOriginKind
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.KtClassOrObject
+import org.jetbrains.kotlin.psi.KtCodeFragment
 import org.jetbrains.kotlin.psi.KtScript
 import javax.swing.Icon

-class KtLightClassForScript private constructor(
-        val script: KtScript,
-        private val lightClassDataCache: CachedValue<LightClassDataHolder.ForScript>
-) : KtLazyLightClass(script.manager) {
+open class KtLightClassForScript(val script: KtScript) : KtLazyLightClass(script.manager) {
+
+    protected open fun getLightClassDataHolder(): LightClassDataHolder.ForScript =
+        getLightClassCachedValue(script).value
+
+    override val lightClassData: LightClassData
+        get() = getLightClassDataHolder().findDataForScript(script.fqName)
+
+    protected open val javaFileStub: PsiJavaFileStub?
+        get() = getLightClassDataHolder().javaFileStub

    private val hashCode: Int = computeHashCode()

@@ -49,10 +53,11 @@ class KtLightClassForScript private constructor(

    private val _containingFile by lazyPub {
        FakeFileForLightClass(
-                script.containingKtFile,
-                lightClass = { this },
-                stub = { lightClassDataCache.value.javaFileStub },
-                packageFqName = packageFqName)
+            script.containingKtFile,
+            lightClass = { this },
+            stub = { javaFileStub },
+            packageFqName = packageFqName,
+        )
    }

    override val kotlinOrigin: KtClassOrObject? get() = null
@@ -85,17 +90,19 @@ class KtLightClassForScript private constructor(

    override fun getImplementsList() = implementsList

+    override fun getExtendsList(): PsiReferenceList? = implementsList
+
    override fun getImplementsListTypes(): Array<PsiClassType> = PsiClassType.EMPTY_ARRAY

    override fun getInterfaces(): Array<PsiClass> = PsiClass.EMPTY_ARRAY

    override fun getOwnInnerClasses(): List<PsiClass> {
        return script.declarations.filterIsInstance<KtClassOrObject>()
-                // workaround for ClassInnerStuffCache not supporting classes with null names, see KT-13927
-                // inner classes with null names can't be searched for and can't be used from java anyway
-                // we can't prohibit creating light classes with null names either since they can contain members
-                .filter { it.name != null }
-                .mapNotNull { KtLightClassForSourceDeclaration.create(it) }
+            // workaround for ClassInnerStuffCache not supporting classes with null names, see KT-13927
+            // inner classes with null names can't be searched for and can't be used from java anyway
+            // we can't prohibit creating light classes with null names either since they can contain members
+            .filter { it.name != null }
+            .mapNotNull { KtLightClassForSourceDeclaration.create(it) }
    }

    override fun getInitializers(): Array<PsiClassInitializer> = PsiClassInitializer.EMPTY_ARRAY
@@ -106,17 +113,49 @@ class KtLightClassForScript private constructor(

    override fun isValid() = script.isValid

-    override fun copy() = KtLightClassForScript(script, lightClassDataCache)
-
-    override val lightClassData = lightClassDataCache.value.findDataForScript(script.fqName)
+    override fun copy() = KtLightClassForScript(script)

    override fun getNavigationElement() = script

    override fun isEquivalentTo(another: PsiElement?): Boolean =
-            another is PsiClass && Comparing.equal(another.qualifiedName, qualifiedName)
+        another is PsiClass && Comparing.equal(another.qualifiedName, qualifiedName)

    override fun getElementIcon(flags: Int): Icon? = throw UnsupportedOperationException("This should be done by JetIconProvider")

+    override val originKind: LightClassOriginKind get() = LightClassOriginKind.SOURCE
+
+    override fun getLBrace(): PsiElement? = null
+
+    override fun getRBrace(): PsiElement? = null
+
+    override fun getVisibleSignatures(): MutableCollection<HierarchicalMethodSignature> = PsiSuperMethodImplUtil.getVisibleSignatures(this)
+
+    override fun setName(name: String): PsiElement? = throw IncorrectOperationException()
+
+    override fun isInheritor(baseClass: PsiClass, checkDeep: Boolean): Boolean {
+        return baseClass.qualifiedName == CommonClassNames.JAVA_LANG_OBJECT
+    }
+
+    override fun isInheritorDeep(baseClass: PsiClass?, classToByPass: PsiClass?): Boolean = false
+
+    override fun getSuperClass(): PsiClass? {
+        return JavaPsiFacade.getInstance(project).findClass(CommonClassNames.JAVA_LANG_OBJECT, resolveScope)
+    }
+
+    override fun getSupers(): Array<PsiClass> {
+        return superClass?.let { arrayOf(it) } ?: arrayOf()
+    }
+
+    override fun getSuperTypes(): Array<PsiClassType> {
+        return arrayOf(PsiType.getJavaLangObject(manager, resolveScope))
+    }
+
+    override fun getNameIdentifier(): PsiIdentifier? = null
+
+    override fun getParent(): PsiElement = containingFile
+
+    override fun getScope(): PsiElement = parent
+
    override fun hashCode() = hashCode

    private fun computeHashCode(): Int {
@@ -146,16 +185,39 @@ class KtLightClassForScript private constructor(

        private val JAVA_API_STUB_FOR_SCRIPT = Key.create<CachedValue<LightClassDataHolder.ForScript>>("JAVA_API_STUB_FOR_SCRIPT")

-        fun create(script: KtScript): KtLightClassForScript = KtLightClassForScript(script, getLightClassCachedValue(script))
+        fun create(script: KtScript): KtLightClassForScript? =
+            CachedValuesManager.getCachedValue(script) {
+                CachedValueProvider.Result
+                    .create(
+                        createNoCache(script, KtUltraLightSupport.forceUsingOldLightClasses),
+                        KotlinModificationTrackerService.getInstance(script.project).outOfBlockModificationTracker,
+                    )
+            }
+
+        fun createNoCache(script: KtScript, forceUsingOldLightClasses: Boolean): KtLightClassForScript? {
+            val containingFile = script.containingFile
+            if (containingFile is KtCodeFragment) {
+                // Avoid building light classes for code fragments
+                return null
+            }
+
+            if (!forceUsingOldLightClasses && Registry.`is`("kotlin.use.ultra.light.classes", true)) {
+                LightClassGenerationSupport.getInstance(script.project).createUltraLightClassForScript(script)?.let { return it }
+            }
+
+            return KtLightClassForScript(script)
+        }

        fun getLightClassCachedValue(script: KtScript): CachedValue<LightClassDataHolder.ForScript> {
-            return script.getUserData(JAVA_API_STUB_FOR_SCRIPT) ?:
-                   createCachedValueForScript(script).also { script.putUserData(JAVA_API_STUB_FOR_SCRIPT, it) }
+            return script.getUserData(JAVA_API_STUB_FOR_SCRIPT) ?: createCachedValueForScript(script).also {
+                script.putUserData(
+                    JAVA_API_STUB_FOR_SCRIPT,
+                    it,
+                )
+            }
        }

        private fun createCachedValueForScript(script: KtScript): CachedValue<LightClassDataHolder.ForScript> =
-                CachedValuesManager.getManager(script.project).createCachedValue(LightClassDataProviderForScript(script), false)
+            CachedValuesManager.getManager(script.project).createCachedValue(LightClassDataProviderForScript(script), false)
    }
-
-    override val originKind: LightClassOriginKind get() = LightClassOriginKind.SOURCE
 }
@@ -462,9 +462,16 @@ open class KtUltraLightClass(classOrObject: KtClassOrObject, internal val suppor
    override fun getInitializers(): Array<PsiClassInitializer> = emptyArray()

    override fun getContainingClass(): PsiClass? {
+
        val containingBody = classOrObject.parent as? KtClassBody
        val containingClass = containingBody?.parent as? KtClassOrObject
-        return containingClass?.let { create(it) }
+        containingClass?.let { return create(it) }
+
+        val containingBlock = classOrObject.parent as? KtBlockExpression
+        val containingScript = containingBlock?.parent as? KtScript
+        containingScript?.let { return KtLightClassForScript.create(it) }
+
+        return null
    }

    override fun getParent(): PsiElement? = containingClass ?: containingFile
@@ -0,0 +1,137 @@
+/*
+ * Copyright 2010-2020 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.asJava.classes
+
+import com.intellij.psi.PsiClass
+import com.intellij.psi.PsiModifier
+import com.intellij.psi.PsiType
+import com.intellij.psi.impl.java.stubs.PsiJavaFileStub
+import com.intellij.psi.impl.light.LightMethodBuilder
+import com.intellij.psi.util.CachedValue
+import com.intellij.psi.util.CachedValueProvider
+import com.intellij.psi.util.CachedValuesManager
+import org.jetbrains.kotlin.analyzer.KotlinModificationTrackerService
+import org.jetbrains.kotlin.asJava.builder.LightClassData
+import org.jetbrains.kotlin.asJava.builder.LightClassDataHolder
+import org.jetbrains.kotlin.asJava.elements.KtLightField
+import org.jetbrains.kotlin.asJava.elements.KtLightMethod
+import org.jetbrains.kotlin.psi.KtNamedFunction
+import org.jetbrains.kotlin.psi.KtProperty
+import org.jetbrains.kotlin.psi.KtScript
+
+class KtUltraLightClassForScript(
+    script: KtScript,
+    private val support: KtUltraLightSupport,
+) : KtLightClassForScript(script) {
+
+    override val clsDelegate: PsiClass get() = invalidAccess()
+
+    override val lightClassData: LightClassData get() = invalidAccess()
+
+    override fun getLightClassDataHolder(): LightClassDataHolder.ForScript = invalidAccess()
+
+    override val javaFileStub: PsiJavaFileStub? = null
+
+    private val membersBuilder by lazyPub {
+        UltraLightMembersCreator(
+            containingClass = this,
+            containingClassIsNamedObject = false,
+            containingClassIsSealed = true,
+            mangleInternalFunctions = true,
+            support = support,
+        )
+    }
+
+    internal inner class KtUltraLightScriptMainParameter(mainMethod: KtUltraLightMethod) :
+        KtUltraLightParameter(
+            name = "args",
+            kotlinOrigin = null,
+            support = support,
+            ultraLightMethod = mainMethod
+        ) {
+
+        override fun getType(): PsiType =
+            PsiType.getJavaLangString(manager, resolveScope).createArrayType()
+
+        override fun isVarArgs(): Boolean = false
+
+        override val qualifiedNameForNullabilityAnnotation: String? = null
+    }
+
+    private fun MutableList<KtLightMethod>.addScriptDefaultMethods() {
+        val defaultConstructor = KtUltraLightMethodForSourceDeclaration(
+            delegate = LightMethodBuilder(manager, language, name).setConstructor(true).addModifier(PsiModifier.PUBLIC),
+            declaration = script,
+            support = support,
+            containingClass = this@KtUltraLightClassForScript,
+            methodIndex = METHOD_INDEX_FOR_DEFAULT_CTOR,
+        )
+        add(defaultConstructor)
+
+        val methodBuilder = LightMethodBuilder(manager, language, "main").apply {
+            isConstructor = false
+            addModifiers(PsiModifier.PUBLIC, PsiModifier.STATIC, PsiModifier.FINAL)
+            setMethodReturnType(PsiType.VOID)
+        }
+
+        val mainMethod = KtUltraLightMethodForSourceDeclaration(
+            delegate = methodBuilder,
+            declaration = script,
+            support = support,
+            containingClass = this@KtUltraLightClassForScript,
+            methodIndex = METHOD_INDEX_FOR_SCRIPT_MAIN,
+        )
+
+        methodBuilder.addParameter(KtUltraLightScriptMainParameter(mainMethod))
+
+        add(mainMethod)
+    }
+
+    private fun ownMethods(): List<KtLightMethod> {
+        val result = mutableListOf<KtLightMethod>()
+
+        result.addScriptDefaultMethods()
+
+        for (declaration in script.declarations.filterNot { it.isHiddenByDeprecation(support) }) {
+            when (declaration) {
+                is KtNamedFunction -> result.addAll(membersBuilder.createMethods(declaration, forceStatic = false))
+                is KtProperty -> result.addAll(
+                    membersBuilder.propertyAccessors(declaration, declaration.isVar, forceStatic = false, onlyJvmStatic = false),
+                )
+            }
+        }
+        return result
+    }
+
+    private val _ownMethods: CachedValue<List<KtLightMethod>> = CachedValuesManager.getManager(project).createCachedValue(
+        {
+            CachedValueProvider.Result.create(
+                ownMethods(),
+                KotlinModificationTrackerService.getInstance(project).outOfBlockModificationTracker,
+            )
+        },
+        false,
+    )
+
+    override fun getOwnMethods(): List<KtLightMethod> = _ownMethods.value
+
+    private val _ownFields: List<KtLightField> by lazyPub {
+
+        val result = arrayListOf<KtLightField>()
+        val usedNames = hashSetOf<String>()
+
+        for (property in script.declarations.filterIsInstance<KtProperty>()) {
+            membersBuilder
+                .createPropertyField(property, usedNames, forceStatic = false)
+                ?.let(result::add)
+        }
+        result
+    }
+
+    override fun getOwnFields(): List<KtLightField> = _ownFields
+
+    override fun copy(): KtLightClassForScript = KtUltraLightClassForScript(script, support)
+}
@@ -37,7 +37,8 @@ internal const val METHOD_INDEX_FOR_SETTER = 2
 internal const val METHOD_INDEX_FOR_DEFAULT_CTOR = 3
 internal const val METHOD_INDEX_FOR_NO_ARG_OVERLOAD_CTOR = 4
 internal const val METHOD_INDEX_FOR_NON_ORIGIN_METHOD = 5
-internal const val METHOD_INDEX_BASE = 6
+internal const val METHOD_INDEX_FOR_SCRIPT_MAIN = 6
+internal const val METHOD_INDEX_BASE = 7

 internal abstract class KtUltraLightMethod(
    internal val delegate: PsiMethod,
@@ -24,6 +24,9 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiElementVisitor
 import com.intellij.psi.PsiFileFactory
 import com.intellij.psi.impl.compiled.ClsFileImpl
+import com.intellij.psi.impl.java.stubs.ClsStubPsiFactory
+import com.intellij.psi.impl.java.stubs.PsiJavaFileStub
+import com.intellij.psi.impl.java.stubs.impl.PsiJavaFileStubImpl
 import com.intellij.psi.impl.source.PsiFileImpl
 import com.intellij.psi.impl.source.SourceTreeToPsiMap
 import com.intellij.psi.impl.source.tree.TreeElement
@@ -41,7 +44,7 @@ import java.lang.ref.Reference
 open class FakeFileForLightClass(
    val ktFile: KtFile,
    private val lightClass: () -> KtLightClass,
-    private val stub: () -> PsiClassHolderFileStub<*>,
+    private val stub: () -> PsiClassHolderFileStub<*>?,
    private val packageFqName: FqName = ktFile.packageFqName
 ) : ClsFileImpl(ktFile.viewProvider) {

@@ -50,7 +53,14 @@ open class FakeFileForLightClass(

    override fun getPackageName() = packageFqName.asString()

-    override fun getStub() = stub()
+    private fun createFakeJavaFileStub(): PsiJavaFileStub {
+        val javaFileStub = PsiJavaFileStubImpl(packageFqName.asString(), /*compiled = */true)
+        javaFileStub.psiFactory = ClsStubPsiFactory.INSTANCE
+        javaFileStub.psi = this
+        return javaFileStub
+    }
+
+    override fun getStub() = stub() ?: createFakeJavaFileStub()

    override fun getClasses() = arrayOf(lightClass())