Drop JVMConfigurationKeys.ANNOTATIONS_PATH_KEY and external annotations in CLI

CoreExternalAnnotationsManager is moved to the only usage left, which is in the test
2015-04-25 00:31:28 +03:00
parent b0a4e812e5
commit c41aefe2cb
9 changed files with 15 additions and 148 deletions
@@ -1,76 +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.cli.jvm.compiler;
-
-import com.intellij.codeInsight.BaseExternalAnnotationsManager;
-import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.psi.*;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.ArrayList;
-import java.util.List;
-
-public class CoreExternalAnnotationsManager extends BaseExternalAnnotationsManager {
-    static {
-        // This is an ugly workaround for JDOM 1.1 used from application started from Ant 1.8 without forking
-        System.setProperty("javax.xml.parsers.SAXParserFactory", "com.sun.org.apache.xerces.internal.jaxp.SAXParserFactoryImpl");
-    }
-
-    private final List<VirtualFile> externalAnnotationsRoots = new ArrayList<VirtualFile>();
-
-    public CoreExternalAnnotationsManager(@NotNull PsiManager psiManager) {
-        super(psiManager);
-    }
-
-    public void addExternalAnnotationsRoot(VirtualFile externalAnnotationsRoot) {
-        externalAnnotationsRoots.add(externalAnnotationsRoot);
-    }
-
-    @Override
-    protected boolean hasAnyAnnotationsRoots() {
-        return true;
-    }
-
-    @NotNull
-    @Override
-    protected List<VirtualFile> getExternalAnnotationsRoots(@NotNull VirtualFile libraryFile) {
-        return externalAnnotationsRoots;
-    }
-
-    @Override
-    public void annotateExternally(@NotNull PsiModifierListOwner listOwner, @NotNull String annotationFQName, @NotNull PsiFile fromFile,
-            PsiNameValuePair[] value) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public boolean deannotate(@NotNull PsiModifierListOwner listOwner, @NotNull String annotationFQN) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public boolean editExternalAnnotation(@NotNull PsiModifierListOwner listOwner, @NotNull String annotationFQN,
-            @Nullable PsiNameValuePair[] value) {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public AnnotationPlace chooseAnnotationsPlace(@NotNull PsiElement element) {
-        throw new UnsupportedOperationException();
-    }
-}
@@ -18,7 +18,6 @@ package org.jetbrains.kotlin.cli.jvm.compiler

 import com.google.common.collect.Sets
 import com.intellij.codeInsight.ContainerProvider
-import com.intellij.codeInsight.ExternalAnnotationsManager
 import com.intellij.codeInsight.runner.JavaMainMethodProvider
 import com.intellij.core.CoreApplicationEnvironment
 import com.intellij.core.CoreJavaFileManager
@@ -39,7 +38,6 @@ import com.intellij.openapi.util.text.StringUtil
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.psi.FileContextProvider
 import com.intellij.psi.PsiElementFinder
-import com.intellij.psi.PsiManager
 import com.intellij.psi.augment.PsiAugmentProvider
 import com.intellij.psi.compiled.ClassFileDecompilers
 import com.intellij.psi.impl.JavaClassSupersImpl
@@ -102,8 +100,6 @@ public class KotlinCoreEnvironment private constructor(
    private val sourceFiles = ArrayList<JetFile>()
    private val javaRoots = ArrayList<JavaRoot>()

-    private val annotationsManager: CoreExternalAnnotationsManager
-
    public val configuration: CompilerConfiguration = configuration.copy().let {
        it.setReadOnly(true)
        it
@@ -111,8 +107,6 @@ public class KotlinCoreEnvironment private constructor(

    init {
        val project = projectEnvironment.getProject()
-        annotationsManager = CoreExternalAnnotationsManager(project.getComponent(javaClass<PsiManager>())!!)
-        project.registerService(javaClass<ExternalAnnotationsManager>(), annotationsManager)
        project.registerService(javaClass<DeclarationProviderFactoryService>(), CliDeclarationProviderFactoryService(sourceFiles))
        project.registerService(ModuleVisibilityManager::class.java, CliModuleVisibilityManagerImpl())

@@ -124,9 +118,6 @@ public class KotlinCoreEnvironment private constructor(
        val index = JvmDependenciesIndex(javaRoots)
        (fileManager as KotlinCliJavaFileManagerImpl).initIndex(index)

-        for (path in configuration.getList(JVMConfigurationKeys.ANNOTATIONS_PATH_KEY)) {
-            addExternalAnnotationsRoot(path)
-        }
        sourceFiles.addAll(CompileEnvironmentUtil.getJetFiles(project, getSourceRootsCheckingForDuplicates(), {
            message ->
            report(ERROR, message)
@@ -169,14 +160,6 @@ public class KotlinCoreEnvironment private constructor(
                StringUtil.getLineBreakCount(it.getText()) + (if (StringUtil.endsWithLineBreak(text)) 0 else 1)
            }

-    private fun addExternalAnnotationsRoot(path: File) {
-        if (!path.exists()) {
-            report(WARNING, "Annotations path entry points to a non-existent location: " + path)
-            return
-        }
-        annotationsManager.addExternalAnnotationsRoot(PathUtil.jarFileOrDirectoryToVirtualFile(path))
-    }
-
    private fun fillClasspath(configuration: CompilerConfiguration) {
        for (root in configuration.getList(CommonConfigurationKeys.CONTENT_ROOTS)) {
            val javaRoot = root as? JvmContentRoot ?: continue
@@ -22,16 +22,12 @@ import org.jetbrains.kotlin.config.CompilerConfigurationKey;
 import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCompilationComponents;
 import org.jetbrains.kotlin.resolve.AnalyzerScriptParameter;

-import java.io.File;
 import java.util.List;

 public class JVMConfigurationKeys {
    private JVMConfigurationKeys() {
    }

-    public static final CompilerConfigurationKey<List<File>> ANNOTATIONS_PATH_KEY =
-            CompilerConfigurationKey.create("external annotations path");
-
    public static final CompilerConfigurationKey<List<AnalyzerScriptParameter>> SCRIPT_PARAMETERS =
            CompilerConfigurationKey.create("script");

@@ -40,15 +40,12 @@ import java.util.List;

 public class TraceBasedExternalSignatureResolver implements ExternalSignatureResolver {
    @NotNull private final BindingTrace trace;
-    @NotNull private final ExternalAnnotationResolver externalAnnotationResolver;
    @NotNull private final Project project;

    public TraceBasedExternalSignatureResolver(
-            @NotNull ExternalAnnotationResolver externalAnnotationResolver,
            @NotNull Project project,
            @NotNull BindingTrace trace
    ) {
-        this.externalAnnotationResolver = externalAnnotationResolver;
        this.project = project;
        this.trace = trace;
    }
@@ -84,9 +81,9 @@ public class TraceBasedExternalSignatureResolver implements ExternalSignatureRes
        assert methodOrConstructor instanceof JavaMethod || methodOrConstructor instanceof JavaConstructor :
                "Not a method or a constructor: " + methodOrConstructor.getName();

-        AlternativeMethodSignatureData data =
-                new AlternativeMethodSignatureData(externalAnnotationResolver, methodOrConstructor, receiverType, project, valueParameters,
-                                                   returnType, typeParameters, hasSuperMethods);
+        AlternativeMethodSignatureData data = new AlternativeMethodSignatureData(
+                methodOrConstructor, receiverType, project, valueParameters, returnType, typeParameters, hasSuperMethods
+        );

        if (data.isAnnotated() && !data.hasErrors()) {
            if (JvmPackage.getPLATFORM_TYPES()) {
@@ -110,8 +107,7 @@ public class TraceBasedExternalSignatureResolver implements ExternalSignatureRes
            @NotNull JetType returnType,
            boolean isVar
    ) {
-        AlternativeFieldSignatureData data =
-                new AlternativeFieldSignatureData(externalAnnotationResolver, field, returnType, project, isVar);
+        AlternativeFieldSignatureData data = new AlternativeFieldSignatureData(field, returnType, project, isVar);

        if (data.isAnnotated() && !data.hasErrors()) {
            if (JvmPackage.getPLATFORM_TYPES()) {
@@ -21,7 +21,6 @@ import com.intellij.util.containers.ComparatorUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor;
 import org.jetbrains.kotlin.descriptors.impl.TypeParameterDescriptorImpl;
-import org.jetbrains.kotlin.load.java.components.ExternalAnnotationResolver;
 import org.jetbrains.kotlin.load.java.structure.JavaField;
 import org.jetbrains.kotlin.psi.JetProperty;
 import org.jetbrains.kotlin.types.JetType;
@@ -34,13 +33,12 @@ public class AlternativeFieldSignatureData extends ElementAlternativeSignatureDa
    private JetType altReturnType;

    public AlternativeFieldSignatureData(
-            @NotNull ExternalAnnotationResolver externalAnnotationResolver,
            @NotNull JavaField field,
            @NotNull JetType originalReturnType,
            @NotNull Project project,
            boolean isVar
    ) {
-        String signature = SignaturesUtil.getKotlinSignature(externalAnnotationResolver, field);
+        String signature = SignaturesUtil.getKotlinSignature(field);

        if (signature == null) {
            setAnnotated(false);
@@ -28,7 +28,6 @@ import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor;
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor;
 import org.jetbrains.kotlin.descriptors.impl.TypeParameterDescriptorImpl;
 import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl;
-import org.jetbrains.kotlin.load.java.components.ExternalAnnotationResolver;
 import org.jetbrains.kotlin.load.java.structure.JavaMember;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
@@ -63,7 +62,6 @@ public class AlternativeMethodSignatureData extends ElementAlternativeSignatureD
    private Map<TypeParameterDescriptor, TypeParameterDescriptorImpl> originalToAltTypeParameters;

    public AlternativeMethodSignatureData(
-            @NotNull ExternalAnnotationResolver externalAnnotationResolver,
            @NotNull JavaMember methodOrConstructor,
            @Nullable JetType receiverType,
            @NotNull Project project,
@@ -72,7 +70,7 @@ public class AlternativeMethodSignatureData extends ElementAlternativeSignatureD
            @NotNull List<TypeParameterDescriptor> methodTypeParameters,
            boolean hasSuperMethods
    ) {
-        String signature = SignaturesUtil.getKotlinSignature(externalAnnotationResolver, methodOrConstructor);
+        String signature = SignaturesUtil.getKotlinSignature(methodOrConstructor);

        if (signature == null) {
            setAnnotated(false);
@@ -19,9 +19,10 @@ package org.jetbrains.kotlin.resolve.jvm.kotlinSignature;
 import com.intellij.openapi.util.text.StringUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.load.java.components.ExternalAnnotationResolver;
-import org.jetbrains.kotlin.load.java.structure.*;
-import org.jetbrains.kotlin.name.FqName;
+import org.jetbrains.kotlin.load.java.structure.JavaAnnotation;
+import org.jetbrains.kotlin.load.java.structure.JavaAnnotationArgument;
+import org.jetbrains.kotlin.load.java.structure.JavaLiteralAnnotationArgument;
+import org.jetbrains.kotlin.load.java.structure.JavaMember;

 import static org.jetbrains.kotlin.load.java.JvmAnnotationNames.*;

@@ -30,11 +31,11 @@ public class SignaturesUtil {
    }

    @Nullable
-    public static String getKotlinSignature(@NotNull ExternalAnnotationResolver externalAnnotationResolver, @NotNull JavaMember member) {
-        JavaAnnotation newAnnotation = findAnnotationWithExternal(externalAnnotationResolver, member, KOTLIN_SIGNATURE);
+    public static String getKotlinSignature(@NotNull JavaMember member) {
+        JavaAnnotation newAnnotation = member.findAnnotation(KOTLIN_SIGNATURE);
        if (newAnnotation != null) return extractKotlinSignatureArgument(newAnnotation);

-        JavaAnnotation oldAnnotation = findAnnotationWithExternal(externalAnnotationResolver, member, OLD_KOTLIN_SIGNATURE);
+        JavaAnnotation oldAnnotation = member.findAnnotation(OLD_KOTLIN_SIGNATURE);
        if (oldAnnotation != null) return extractKotlinSignatureArgument(oldAnnotation);

        return null;
@@ -51,15 +52,4 @@ public class SignaturesUtil {
        }
        return null;
    }
-
-    @Nullable
-    public static JavaAnnotation findAnnotationWithExternal(@NotNull ExternalAnnotationResolver externalAnnotationResolver, @NotNull JavaAnnotationOwner owner, @NotNull FqName name) {
-        JavaAnnotation annotation = owner.findAnnotation(name);
-        if (annotation != null) {
-            return annotation;
-        }
-
-        return externalAnnotationResolver.findExternalAnnotation(owner, name);
-    }
-
 }
@@ -71,7 +71,8 @@ public class JdkAnnotationsValidityTest extends AbstractSdkAnnotationsValidityTe
        CompilerConfiguration configuration = JetTestUtils.compilerConfigurationForTests(
                ConfigurationKind.JDK_ONLY, TestJdkKind.FULL_JDK, JetTestUtils.getAnnotationsJar()
        );
-        configuration.add(JVMConfigurationKeys.ANNOTATIONS_PATH_KEY, new File("ideaSDK/lib/jdkAnnotations.jar"));
+        // TODO: move this test to idea-tests and re-implement it for ExternalAnnotationsManagerImpl
+        // configuration.add(JVMConfigurationKeys.ANNOTATIONS_PATH_KEY, new File("ideaSDK/lib/jdkAnnotations.jar"));
        return KotlinCoreEnvironment.createForTests(parentDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
    }

@@ -18,9 +18,6 @@ package org.jetbrains.kotlin.utils;

 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.application.PathManager;
-import com.intellij.openapi.util.io.FileUtil;
-import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.openapi.vfs.VirtualFileManager;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jps.model.java.impl.JavaSdkUtil;

@@ -144,22 +141,6 @@ public class PathUtil {
        return new File(resourceRoot).getAbsoluteFile();
    }

-    @NotNull
-    public static VirtualFile jarFileOrDirectoryToVirtualFile(@NotNull File file) {
-        if (file.exists()) {
-            if (file.isDirectory()) {
-                return VirtualFileManager.getInstance()
-                        .findFileByUrl("file://" + FileUtil.toSystemIndependentName(file.getAbsolutePath()));
-            }
-            else {
-                return VirtualFileManager.getInstance().findFileByUrl("jar://" + FileUtil.toSystemIndependentName(file.getAbsolutePath()) + "!/");
-            }
-        }
-        else {
-            throw new IllegalStateException("Path " + file + " does not exist.");
-        }
-    }
-
    @NotNull
    public static List<File> getJdkClassesRoots() {
        return JavaSdkUtil.getJdkClassesRoots(new File(System.getProperty("java.home")), true);