203: Fix compilation for 203

2020-07-06 16:09:26 +02:00
parent 4c4af9971e
commit 346df07adc
23 changed files with 5389 additions and 0 deletions
@@ -0,0 +1,55 @@
+/*
+ * 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.cli.jvm.compiler;
+
+import com.intellij.DynamicBundle;
+import com.intellij.codeInsight.ContainerProvider;
+import com.intellij.codeInsight.runner.JavaMainMethodProvider;
+import com.intellij.core.JavaCoreApplicationEnvironment;
+import com.intellij.lang.MetaLanguage;
+import com.intellij.openapi.Disposable;
+import com.intellij.openapi.extensions.Extensions;
+import com.intellij.openapi.vfs.VirtualFileSystem;
+import com.intellij.psi.FileContextProvider;
+import com.intellij.psi.augment.PsiAugmentProvider;
+import com.intellij.psi.compiled.ClassFileDecompilers;
+import com.intellij.psi.meta.MetaDataContributor;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.cli.jvm.modules.CoreJrtFileSystem;
+
+public class KotlinCoreApplicationEnvironment extends JavaCoreApplicationEnvironment {
+    public static KotlinCoreApplicationEnvironment create(@NotNull Disposable parentDisposable, boolean unitTestMode) {
+        KotlinCoreApplicationEnvironment environment = new KotlinCoreApplicationEnvironment(parentDisposable, unitTestMode);
+        registerExtensionPoints();
+        return environment;
+    }
+
+    private KotlinCoreApplicationEnvironment(@NotNull Disposable parentDisposable, boolean unitTestMode) {
+        super(parentDisposable, unitTestMode);
+    }
+
+    private static void registerExtensionPoints() {
+        registerApplicationExtensionPoint(DynamicBundle.LanguageBundleEP.EP_NAME, DynamicBundle.LanguageBundleEP.class);
+        registerApplicationExtensionPoint(FileContextProvider.EP_NAME, FileContextProvider.class);
+
+        registerApplicationExtensionPoint(MetaDataContributor.EP_NAME, MetaDataContributor.class);
+        registerApplicationExtensionPoint(PsiAugmentProvider.EP_NAME, PsiAugmentProvider.class);
+        registerApplicationExtensionPoint(JavaMainMethodProvider.EP_NAME, JavaMainMethodProvider.class);
+
+        registerApplicationExtensionPoint(ContainerProvider.EP_NAME, ContainerProvider.class);
+        registerApplicationExtensionPoint(ClassFileDecompilers.getInstance().EP_NAME, ClassFileDecompilers.Decompiler.class);
+
+        registerApplicationExtensionPoint(MetaLanguage.EP_NAME, MetaLanguage.class);
+
+        IdeaExtensionPoints.INSTANCE.registerVersionSpecificAppExtensionPoints(Extensions.getRootArea());
+    }
+
+    @Nullable
+    @Override
+    protected VirtualFileSystem createJrtFileSystem() {
+        return new CoreJrtFileSystem();
+    }
+}
@@ -0,0 +1,122 @@
+/*
+ * 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.psi;
+
+import com.intellij.extapi.psi.StubBasedPsiElementBase;
+import com.intellij.lang.ASTNode;
+import com.intellij.lang.Language;
+import com.intellij.psi.*;
+import com.intellij.psi.stubs.IStubElementType;
+import com.intellij.psi.stubs.StubElement;
+import com.intellij.util.IncorrectOperationException;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.kotlin.idea.KotlinLanguage;
+import org.jetbrains.kotlin.psi.psiUtil.KtPsiUtilKt;
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementType;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class KtElementImplStub<T extends StubElement<?>> extends StubBasedPsiElementBase<T>
+        implements KtElement, StubBasedPsiElement<T> {
+    public KtElementImplStub(@NotNull T stub, @NotNull IStubElementType nodeType) {
+        super(stub, nodeType);
+    }
+
+    public KtElementImplStub(@NotNull ASTNode node) {
+        super(node);
+    }
+
+    @NotNull
+    @Override
+    public Language getLanguage() {
+        return KotlinLanguage.INSTANCE;
+    }
+
+    @Override
+    public String toString() {
+        return getElementType().toString();
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public final void accept(@NotNull PsiElementVisitor visitor) {
+        if (visitor instanceof KtVisitor) {
+            accept((KtVisitor) visitor, null);
+        }
+        else {
+            visitor.visitElement(this);
+        }
+    }
+
+    @NotNull
+    @Override
+    public KtFile getContainingKtFile() {
+        PsiFile file = getContainingFile();
+        if (!(file instanceof KtFile)) {
+            // KtElementImpl.copy() might be the reason for this exception
+            String fileString = file.isValid() ? (" " + file.getText()) : "";
+            throw new IllegalStateException("KtElement not inside KtFile: " + file + fileString +
+                                            " for element " + this + " of type " + this.getClass() + " node = " + getNode());
+        }
+        return (KtFile) file;
+    }
+
+    @Override
+    public <D> void acceptChildren(@NotNull KtVisitor<Void, D> visitor, D data) {
+        PsiElement child = getFirstChild();
+        while (child != null) {
+            if (child instanceof KtElement) {
+                ((KtElement) child).accept(visitor, data);
+            }
+            child = child.getNextSibling();
+        }
+    }
+
+    @Override
+    public <R, D> R accept(@NotNull KtVisitor<R, D> visitor, D data) {
+        return visitor.visitKtElement(this, data);
+    }
+
+    @Override
+    public void delete() throws IncorrectOperationException {
+        KtElementUtilsKt.deleteSemicolon(this);
+        super.delete();
+    }
+
+    @Override
+    @SuppressWarnings("deprecation")
+    public PsiReference getReference() {
+        PsiReference[] references = getReferences();
+        if (references.length == 1) return references[0];
+        else return null;
+    }
+
+    @NotNull
+    @Override
+    public PsiReference[] getReferences() {
+        return KotlinReferenceProvidersService.getReferencesFromProviders(this);
+    }
+
+    @NotNull
+    protected <PsiT extends KtElementImplStub<?>, StubT extends StubElement<?>> List<PsiT> getStubOrPsiChildrenAsList(
+            @NotNull KtStubElementType<StubT, PsiT> elementType
+    ) {
+        return Arrays.asList(getStubOrPsiChildren(elementType, elementType.getArrayFactory()));
+    }
+
+    @NotNull
+    @Override
+    public KtElement getPsiOrParent() {
+        return this;
+    }
+
+    @Override
+    public PsiElement getParent() {
+        PsiElement substitute = KtPsiUtilKt.getParentSubstitute(this);
+        return substitute != null ? substitute : super.getParent();
+    }
+}
@@ -0,0 +1,35 @@
+/*
+ * 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.psi.stubs.elements
+
+import com.intellij.psi.PsiElement
+import com.intellij.psi.stubs.StubElement
+import com.intellij.psi.stubs.StubInputStream
+import com.intellij.psi.stubs.StubOutputStream
+import com.intellij.util.io.StringRef
+import org.jetbrains.kotlin.psi.KtAnnotationUseSiteTarget
+import org.jetbrains.kotlin.psi.stubs.KotlinAnnotationUseSiteTargetStub
+import org.jetbrains.kotlin.psi.stubs.impl.KotlinAnnotationUseSiteTargetStubImpl
+
+class KtAnnotationUseSiteTargetElementType(debugName: String) :
+    KtStubElementType<KotlinAnnotationUseSiteTargetStub, KtAnnotationUseSiteTarget>(
+        debugName, KtAnnotationUseSiteTarget::class.java, KotlinAnnotationUseSiteTargetStub::class.java
+    ) {
+
+    override fun createStub(psi: KtAnnotationUseSiteTarget, parentStub: StubElement<out PsiElement>): KotlinAnnotationUseSiteTargetStub {
+        val useSiteTarget = psi.getAnnotationUseSiteTarget().name
+        return KotlinAnnotationUseSiteTargetStubImpl(parentStub, StringRef.fromString(useSiteTarget)!!)
+    }
+
+    override fun serialize(stub: KotlinAnnotationUseSiteTargetStub, dataStream: StubOutputStream) {
+        dataStream.writeName(stub.getUseSiteTarget())
+    }
+
+    override fun deserialize(dataStream: StubInputStream, parentStub: StubElement<PsiElement>): KotlinAnnotationUseSiteTargetStub {
+        val useSiteTarget = dataStream.readName()
+        return KotlinAnnotationUseSiteTargetStubImpl(parentStub, useSiteTarget!!)
+    }
+}
@@ -0,0 +1,31 @@
+/*
+ * 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.psi.stubs.elements
+
+import com.intellij.psi.PsiElement
+import com.intellij.psi.stubs.StubElement
+import com.intellij.psi.stubs.StubInputStream
+import com.intellij.psi.stubs.StubOutputStream
+import com.intellij.util.io.StringRef
+import org.jetbrains.kotlin.psi.KtImportAlias
+import org.jetbrains.kotlin.psi.stubs.KotlinImportAliasStub
+import org.jetbrains.kotlin.psi.stubs.impl.KotlinImportAliasStubImpl
+
+class KtImportAliasElementType(debugName: String) :
+    KtStubElementType<KotlinImportAliasStub, KtImportAlias>(debugName, KtImportAlias::class.java, KotlinImportAliasStub::class.java) {
+    override fun createStub(psi: KtImportAlias, parentStub: StubElement<out PsiElement>?): KotlinImportAliasStub {
+        return KotlinImportAliasStubImpl(parentStub, StringRef.fromString(psi.name))
+    }
+
+    override fun serialize(stub: KotlinImportAliasStub, dataStream: StubOutputStream) {
+        dataStream.writeName(stub.getName())
+    }
+
+    override fun deserialize(dataStream: StubInputStream, parentStub: StubElement<PsiElement>?): KotlinImportAliasStub {
+        val name = dataStream.readName()
+        return KotlinImportAliasStubImpl(parentStub, name)
+    }
+}
@@ -0,0 +1,44 @@
+/*
+ * 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.psi.stubs.elements;
+
+import com.intellij.psi.stubs.StubElement;
+import com.intellij.psi.stubs.StubInputStream;
+import com.intellij.psi.stubs.StubOutputStream;
+import com.intellij.util.io.DataInputOutputUtil;
+import org.jetbrains.annotations.NonNls;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.kotlin.psi.KtModifierList;
+import org.jetbrains.kotlin.psi.stubs.KotlinModifierListStub;
+import org.jetbrains.kotlin.psi.stubs.impl.KotlinModifierListStubImpl;
+
+import java.io.IOException;
+
+import static org.jetbrains.kotlin.psi.stubs.impl.ModifierMaskUtils.computeMaskFromModifierList;
+
+public class KtModifierListElementType<T extends KtModifierList> extends KtStubElementType<KotlinModifierListStub, T> {
+    public KtModifierListElementType(@NotNull @NonNls String debugName, @NotNull Class<T> psiClass) {
+        super(debugName, psiClass, KotlinModifierListStub.class);
+    }
+
+    @Override
+    public KotlinModifierListStub createStub(@NotNull T psi, StubElement<?> parentStub) {
+        return new KotlinModifierListStubImpl(parentStub, computeMaskFromModifierList(psi), this);
+    }
+
+    @Override
+    public void serialize(@NotNull KotlinModifierListStub stub, @NotNull StubOutputStream dataStream) throws IOException {
+        long mask = ((KotlinModifierListStubImpl) stub).getMask();
+        DataInputOutputUtil.writeLONG(dataStream, mask);
+    }
+
+    @NotNull
+    @Override
+    public KotlinModifierListStub deserialize(@NotNull StubInputStream dataStream, StubElement parentStub) throws IOException {
+        long mask = DataInputOutputUtil.readLONG(dataStream);
+        return new KotlinModifierListStubImpl(parentStub, mask, this);
+    }
+}
@@ -0,0 +1,40 @@
+/*
+ * 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.psi.stubs.elements;
+
+import com.intellij.psi.stubs.StubElement;
+import com.intellij.psi.stubs.StubInputStream;
+import com.intellij.psi.stubs.StubOutputStream;
+import org.jetbrains.annotations.NonNls;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.kotlin.psi.KtElementImplStub;
+import org.jetbrains.kotlin.psi.stubs.KotlinPlaceHolderStub;
+import org.jetbrains.kotlin.psi.stubs.impl.KotlinPlaceHolderStubImpl;
+
+import java.io.IOException;
+
+public class KtPlaceHolderStubElementType<T extends KtElementImplStub<? extends StubElement<?>>> extends
+                                                                                                 KtStubElementType<KotlinPlaceHolderStub<T>, T> {
+    public KtPlaceHolderStubElementType(@NotNull @NonNls String debugName, @NotNull Class<T> psiClass) {
+        super(debugName, psiClass, KotlinPlaceHolderStub.class);
+    }
+
+    @Override
+    public KotlinPlaceHolderStub<T> createStub(@NotNull T psi, StubElement<?> parentStub) {
+        return new KotlinPlaceHolderStubImpl<>(parentStub, this);
+    }
+
+    @Override
+    public void serialize(@NotNull KotlinPlaceHolderStub<T> stub, @NotNull StubOutputStream dataStream) throws IOException {
+        //do nothing
+    }
+
+    @NotNull
+    @Override
+    public KotlinPlaceHolderStub<T> deserialize(@NotNull StubInputStream dataStream, StubElement parentStub) throws IOException {
+        return new KotlinPlaceHolderStubImpl<>(parentStub, this);
+    }
+}
@@ -0,0 +1,39 @@
+/*
+ * 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.psi.stubs.elements
+
+import com.intellij.psi.PsiElement
+import com.intellij.psi.stubs.IndexSink
+import com.intellij.psi.stubs.StubElement
+import com.intellij.psi.stubs.StubInputStream
+import com.intellij.psi.stubs.StubOutputStream
+import com.intellij.util.io.StringRef
+import org.jetbrains.kotlin.psi.KtScript
+import org.jetbrains.kotlin.psi.stubs.KotlinScriptStub
+import org.jetbrains.kotlin.psi.stubs.impl.KotlinScriptStubImpl
+
+class KtScriptElementType(debugName: String) : KtStubElementType<KotlinScriptStub, KtScript>(
+    debugName, KtScript::class.java, KotlinScriptStub::class.java
+) {
+
+    override fun createStub(psi: KtScript, parentStub: StubElement<out PsiElement>): KotlinScriptStub {
+        return KotlinScriptStubImpl(parentStub, StringRef.fromString(psi.fqName.asString()))
+    }
+
+    override fun serialize(stub: KotlinScriptStub, dataStream: StubOutputStream) {
+        dataStream.writeName(stub.getFqName().asString())
+    }
+
+    override fun deserialize(dataStream: StubInputStream, parentStub: StubElement<PsiElement>): KotlinScriptStub {
+        val fqName = dataStream.readName()
+        return KotlinScriptStubImpl(parentStub, fqName)
+    }
+
+
+    override fun indexStub(stub: KotlinScriptStub, sink: IndexSink) {
+        StubIndexService.getInstance().indexScript(stub, sink)
+    }
+}
@@ -0,0 +1,108 @@
+/*
+ * 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.psi.stubs.elements;
+
+import com.intellij.lang.ASTNode;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.stubs.IStubElementType;
+import com.intellij.psi.stubs.IndexSink;
+import com.intellij.psi.stubs.StubElement;
+import com.intellij.psi.tree.IElementType;
+import com.intellij.psi.tree.IStubFileElementType;
+import com.intellij.util.ArrayFactory;
+import com.intellij.util.ReflectionUtil;
+import org.jetbrains.annotations.NonNls;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.kotlin.idea.KotlinLanguage;
+import org.jetbrains.kotlin.psi.KtClassOrObject;
+import org.jetbrains.kotlin.psi.KtElementImplStub;
+import org.jetbrains.kotlin.psi.KtFunction;
+import org.jetbrains.kotlin.psi.KtProperty;
+
+import java.lang.reflect.Array;
+import java.lang.reflect.Constructor;
+
+public abstract class KtStubElementType<StubT extends StubElement<?>, PsiT extends KtElementImplStub<?>> extends IStubElementType<StubT, PsiT> {
+
+    @NotNull
+    private final Constructor<PsiT> byNodeConstructor;
+    @NotNull
+    private final Constructor<PsiT> byStubConstructor;
+    @NotNull
+    private final PsiT[] emptyArray;
+    @NotNull
+    private final ArrayFactory<PsiT> arrayFactory;
+
+    @SuppressWarnings("unchecked")
+    public KtStubElementType(@NotNull @NonNls String debugName, @NotNull Class<PsiT> psiClass, @NotNull Class<?> stubClass) {
+        super(debugName, KotlinLanguage.INSTANCE);
+        try {
+            byNodeConstructor = psiClass.getConstructor(ASTNode.class);
+            byStubConstructor = psiClass.getConstructor(stubClass);
+        }
+        catch (NoSuchMethodException e) {
+            throw new RuntimeException("Stub element type declaration for " + psiClass.getSimpleName() + " is missing required constructors",e);
+        }
+        emptyArray = (PsiT[]) Array.newInstance(psiClass, 0);
+        arrayFactory = count -> {
+            if (count == 0) {
+                return emptyArray;
+            }
+            return (PsiT[]) Array.newInstance(psiClass, count);
+        };
+    }
+
+    @NotNull
+    public PsiT createPsiFromAst(@NotNull ASTNode node) {
+        return ReflectionUtil.createInstance(byNodeConstructor, node);
+    }
+
+    @Override
+    @NotNull
+    public PsiT createPsi(@NotNull StubT stub) {
+        return ReflectionUtil.createInstance(byStubConstructor, stub);
+    }
+
+    @NotNull
+    @Override
+    public String getExternalId() {
+        return "kotlin." + toString();
+    }
+
+    @Override
+    public boolean shouldCreateStub(ASTNode node) {
+        PsiElement psi = node.getPsi();
+        if (psi instanceof KtClassOrObject || psi instanceof KtFunction) {
+            return true;
+        }
+        if (psi instanceof KtProperty) {
+            return !((KtProperty) psi).isLocal();
+        }
+        return createStubDependingOnParent(node);
+    }
+
+    private static boolean createStubDependingOnParent(ASTNode node) {
+        ASTNode parent = node.getTreeParent();
+        IElementType parentType = parent.getElementType();
+        if (parentType instanceof IStubElementType) {
+            return ((IStubElementType) parentType).shouldCreateStub(parent);
+        }
+        if (parentType instanceof IStubFileElementType) {
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void indexStub(@NotNull StubT stub, @NotNull IndexSink sink) {
+        // do not force inheritors to implement this method
+    }
+
+    @NotNull
+    public ArrayFactory<PsiT> getArrayFactory() {
+        return arrayFactory;
+    }
+}
@@ -0,0 +1,31 @@
+/*
+ * 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.psi.stubs.elements
+
+import com.intellij.psi.PsiElement
+import com.intellij.psi.stubs.StubElement
+import com.intellij.psi.stubs.StubInputStream
+import com.intellij.psi.stubs.StubOutputStream
+import org.jetbrains.kotlin.psi.KtValueArgument
+import org.jetbrains.kotlin.psi.stubs.KotlinValueArgumentStub
+import org.jetbrains.kotlin.psi.stubs.impl.KotlinValueArgumentStubImpl
+
+class KtValueArgumentElementType<T : KtValueArgument>(debugName: String, psiClass: Class<T>) :
+    KtStubElementType<KotlinValueArgumentStub<T>, T>(debugName, psiClass, KotlinValueArgumentStub::class.java) {
+
+    override fun createStub(psi: T, parentStub: StubElement<out PsiElement>?): KotlinValueArgumentStub<T> {
+        return KotlinValueArgumentStubImpl(parentStub, this, psi.isSpread)
+    }
+
+    override fun serialize(stub: KotlinValueArgumentStub<T>, dataStream: StubOutputStream) {
+        dataStream.writeBoolean(stub.isSpread())
+    }
+
+    override fun deserialize(dataStream: StubInputStream, parentStub: StubElement<PsiElement>?): KotlinValueArgumentStub<T> {
+        val isSpread = dataStream.readBoolean()
+        return KotlinValueArgumentStubImpl(parentStub, this, isSpread)
+    }
+}
@@ -0,0 +1,20 @@
+/*
+ * 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.psi.stubs.impl
+
+import com.intellij.psi.PsiElement
+import com.intellij.psi.stubs.StubElement
+import com.intellij.util.io.StringRef
+import org.jetbrains.kotlin.psi.KtImportAlias
+import org.jetbrains.kotlin.psi.stubs.KotlinImportAliasStub
+import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
+
+class KotlinImportAliasStubImpl(
+    parent: StubElement<out PsiElement>?,
+    private val name: StringRef?
+) : KotlinStubBaseImpl<KtImportAlias>(parent, KtStubElementTypes.IMPORT_ALIAS), KotlinImportAliasStub {
+    override fun getName(): String? = StringRef.toString(name)
+}