Drop JVMConfigurationKeys.ANNOTATIONS_PATH_KEY and external annotations in CLI

CoreExternalAnnotationsManager is moved to the only usage left, which is in the
test

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CoreExternalAnnotationsManager.java

@@ -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();
-    }
-}

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

@@ -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

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/config/JVMConfigurationKeys.java

@@ -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");
 

compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/TraceBasedExternalSignatureResolver.java

@@ -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 =
+        AlternativeMethodSignatureData data = new AlternativeMethodSignatureData(
-                new AlternativeMethodSignatureData(externalAnnotationResolver, methodOrConstructor, receiverType, project, valueParameters,
+                methodOrConstructor, receiverType, project, valueParameters, returnType, typeParameters, hasSuperMethods
-                                                   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 =
+        AlternativeFieldSignatureData data = new AlternativeFieldSignatureData(field, returnType, project, isVar);
-                new AlternativeFieldSignatureData(externalAnnotationResolver, field, returnType, project, isVar);
 
         if (data.isAnnotated() && !data.hasErrors()) {
             if (JvmPackage.getPLATFORM_TYPES()) {

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/AlternativeFieldSignatureData.java

@@ -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);

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/AlternativeMethodSignatureData.java

@@ -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);

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/SignaturesUtil.java

@@ -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.JavaAnnotation;
-import org.jetbrains.kotlin.load.java.structure.*;
+import org.jetbrains.kotlin.load.java.structure.JavaAnnotationArgument;
-import org.jetbrains.kotlin.name.FqName;
+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) {
+    public static String getKotlinSignature(@NotNull JavaMember member) {
-        JavaAnnotation newAnnotation = findAnnotationWithExternal(externalAnnotationResolver, member, KOTLIN_SIGNATURE);
+        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);
-    }
-
 }

compiler/tests/org/jetbrains/kotlin/jvm/compiler/JdkAnnotationsValidityTest.java

@@ -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);
     }
 

compiler/util/src/org/jetbrains/kotlin/utils/PathUtil.java

@@ -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);