Cleanup 202 bunch files

Leave 202 in .bunch file to give some time for updating build server

compiler/psi/src/org/jetbrains/kotlin/psi/KtElementImplStub.java.202

@@ -1,146 +0,0 @@
-/*
- * Copyright 2010-2015 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.
- */
-
-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.impl.source.PsiFileImpl;
-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 = "";
-            if (file.isValid()) {
-                try {
-                    fileString = " " + file.getText();
-                }
-                catch (Exception e) {
-                    // ignore when failed to get file text
-                }
-            }
-            // getNode() will fail if getContainingFile() returns not PsiFileImpl instance
-            String nodeString = (file instanceof PsiFileImpl ? (" node = " + getNode()) : "");
-
-            throw new IllegalStateException("KtElement not inside KtFile: " +
-                                            file + fileString + " of type " + file.getClass() +
-                                            " for element " + this + " of type " + this.getClass() + nodeString);
-        }
-        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();
-    }
-}

compiler/psi/src/org/jetbrains/kotlin/psi/stubs/elements/KtAnnotationUseSiteTargetElementType.kt.202

@@ -1,46 +0,0 @@
-/*
- * Copyright 2010-2015 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.
- */
-
-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<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!!)
-    }
-}

compiler/psi/src/org/jetbrains/kotlin/psi/stubs/elements/KtContractEffectElementType.kt.202

@@ -1,28 +0,0 @@
-/*
- * 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.KtContractEffect
-import org.jetbrains.kotlin.psi.stubs.KotlinContractEffectStub
-import org.jetbrains.kotlin.psi.stubs.impl.KotlinContractEffectStubImpl
-
-class KtContractEffectElementType(debugName: String, psiClass: Class<KtContractEffect>) :
-    KtStubElementType<KotlinContractEffectStub, KtContractEffect>(debugName, psiClass, KotlinContractEffectStub::class.java) {
-    override fun serialize(stub: KotlinContractEffectStub, dataStream: StubOutputStream) {
-    }
-
-    override fun deserialize(dataStream: StubInputStream, parentStub: StubElement<PsiElement>?): KotlinContractEffectStub {
-        return KotlinContractEffectStubImpl(parentStub, this)
-    }
-
-    override fun createStub(psi: KtContractEffect, parentStub: StubElement<PsiElement>?): KotlinContractEffectStub {
-        return KotlinContractEffectStubImpl(parentStub, this)
-    }
-}

compiler/psi/src/org/jetbrains/kotlin/psi/stubs/elements/KtImportAliasElementType.kt.202

@@ -1,42 +0,0 @@
-/*
- * 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.
- */
-
-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<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)
-    }
-}

compiler/psi/src/org/jetbrains/kotlin/psi/stubs/elements/KtModifierListElementType.java.202

@@ -1,55 +0,0 @@
-/*
- * Copyright 2010-2015 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.
- */
-
-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);
-    }
-}

compiler/psi/src/org/jetbrains/kotlin/psi/stubs/elements/KtPlaceHolderStubElementType.java.202

@@ -1,51 +0,0 @@
-/*
- * Copyright 2010-2015 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.
- */
-
-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);
-    }
-}

compiler/psi/src/org/jetbrains/kotlin/psi/stubs/elements/KtScriptElementType.kt.202

@@ -1,50 +0,0 @@
-/*
- * Copyright 2010-2015 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.
- */
-
-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<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)
-    }
-}

compiler/psi/src/org/jetbrains/kotlin/psi/stubs/elements/KtStubElementType.java.202

@@ -1,119 +0,0 @@
-/*
- * Copyright 2010-2015 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.
- */
-
-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;
-    }
-}

compiler/psi/src/org/jetbrains/kotlin/psi/stubs/elements/KtValueArgumentElementType.kt.202

@@ -1,31 +0,0 @@
-/*
- * Copyright 2010-2018 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<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)
-    }
-}

compiler/psi/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinImportAliasStubImpl.kt.202

@@ -1,31 +0,0 @@
-/*
- * 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.
- */
-
-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<PsiElement>?,
-    private val name: StringRef?
-) : KotlinStubBaseImpl<KtImportAlias>(parent, KtStubElementTypes.IMPORT_ALIAS), KotlinImportAliasStub {
-    override fun getName(): String? = StringRef.toString(name)
-}

gradle/versions.properties.202

@@ -1,23 +0,0 @@
-versions.intellijSdk=202.7660.26
-versions.intellijSdk.forIde.202=202.7660.26
-versions.intellijSdk.forIde.203=203.6682.168
-versions.intellijSdk.forIde.211=211.7442.40
-versions.idea.NodeJS=193.6494.7
-versions.jar.asm-all=8.0.1
-versions.jar.guava=29.0-jre
-versions.jar.groovy=2.5.11
-versions.jar.groovy-xml=2.5.11
-versions.jar.lombok-ast=0.2.3
-versions.jar.swingx-core=1.6.2-2
-versions.jar.kxml2=2.3.0
-versions.jar.streamex=0.7.2
-versions.jar.gson=2.8.6
-versions.jar.oro=2.0.8
-versions.jar.picocontainer=1.2
-versions.jar.serviceMessages=2019.1.4
-versions.jar.lz4-java=1.7.1
-ignore.jar.snappy-in-java=true
-versions.gradle-api=4.5.1
-versions.shadow=6.1.0
-versions.junit-bom=5.7.0
-versions.org.junit.platform=1.7.0