Don't use external annotations in compiler

External annotations will be re-enabled in the IDE later.

This fixes LazyJavaAnnotations which was breaking the contract of Annotations:
findAnnotation(FqName) was looking for external annotations, while iterator()
did not. This resulted in some inconsistencies in the compiler and IDE tests.

The other way, i.e. making iterator() look up external annotations, would have
been too costly for the compiler and with no clear benefit at the moment.

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/annotationUtils.kt

@@ -16,42 +16,27 @@
 
 package org.jetbrains.kotlin.load.java.lazy
 
+import org.jetbrains.kotlin.descriptors.annotations.Annotations
+import org.jetbrains.kotlin.load.java.lazy.descriptors.resolveAnnotation
 import org.jetbrains.kotlin.load.java.structure.JavaAnnotation
 import org.jetbrains.kotlin.load.java.structure.JavaAnnotationOwner
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.descriptors.annotations.Annotations
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
-import org.jetbrains.kotlin.load.java.JvmAnnotationNames
-import org.jetbrains.kotlin.load.java.lazy.descriptors.resolveAnnotation
 
 class LazyJavaAnnotations(
-        c: LazyJavaResolverContext,
-        val annotationOwner: JavaAnnotationOwner,
-        private val extraLookup: (FqName) -> JavaAnnotation? = { null }
+        private val c: LazyJavaResolverContext,
+        val annotationOwner: JavaAnnotationOwner
 ) : Annotations {
     private val annotationDescriptors = c.storageManager.createMemoizedFunctionWithNullableValues {
         annotation: JavaAnnotation ->
         c.resolveAnnotation(annotation)
     }
 
-    override fun findAnnotation(fqName: FqName): AnnotationDescriptor? {
-        val jAnnotation = annotationOwner.findAnnotation(fqName) ?: extraLookup(fqName)
-        if (jAnnotation == null) return null
+    override fun findAnnotation(fqName: FqName) = annotationOwner.findAnnotation(fqName)?.let(annotationDescriptors)
 
-        return annotationDescriptors(jAnnotation)
-    }
-
-    override fun iterator() = annotationOwner.getAnnotations().stream().map { annotationDescriptors(it) }.filterNotNull().iterator()
+    override fun iterator() = annotationOwner.getAnnotations().sequence().map(annotationDescriptors).filterNotNull().iterator()
 
     override fun isEmpty() = !iterator().hasNext()
 }
 
 fun LazyJavaResolverContext.resolveAnnotations(annotationsOwner: JavaAnnotationOwner): Annotations
-        = LazyJavaAnnotations(this, annotationsOwner) { fqName -> externalAnnotationResolver.findExternalAnnotation(annotationsOwner, fqName) }
-
-private fun GlobalJavaResolverContext.hasAnnotation(owner: JavaAnnotationOwner, annotationFqName: FqName): Boolean
-        = owner.findAnnotation(annotationFqName) != null || externalAnnotationResolver.findExternalAnnotation(owner, annotationFqName) != null
-
-fun GlobalJavaResolverContext.hasMutableAnnotation(owner: JavaAnnotationOwner): Boolean = hasAnnotation(owner, JvmAnnotationNames.JETBRAINS_MUTABLE_ANNOTATION)
-fun GlobalJavaResolverContext.hasReadOnlyAnnotation(owner: JavaAnnotationOwner): Boolean = hasAnnotation(owner, JvmAnnotationNames.JETBRAINS_READONLY_ANNOTATION)
-fun GlobalJavaResolverContext.hasNotNullAnnotation(owner: JavaAnnotationOwner): Boolean = hasAnnotation(owner, JvmAnnotationNames.JETBRAINS_NOT_NULL_ANNOTATION)
+        = LazyJavaAnnotations(this, annotationsOwner)

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaMemberScope.kt

@@ -16,36 +16,37 @@
 
 package org.jetbrains.kotlin.load.java.lazy.descriptors
 
-import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.storage.NotNullLazyValue
-import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.resolve.scopes.JetScope
-import org.jetbrains.kotlin.load.java.structure.JavaMethod
-import org.jetbrains.kotlin.load.java.structure.JavaField
-import org.jetbrains.kotlin.load.java.lazy.LazyJavaResolverContext
-import org.jetbrains.kotlin.load.java.descriptors.JavaMethodDescriptor
-import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.load.java.lazy.child
-import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl
-import org.jetbrains.kotlin.load.java.lazy.resolveAnnotations
-import org.jetbrains.kotlin.load.java.structure.JavaArrayType
-import org.jetbrains.kotlin.load.java.components.TypeUsage
-import org.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.load.java.lazy.hasNotNullAnnotation
+import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.descriptors.annotations.Annotations
+import org.jetbrains.kotlin.descriptors.impl.PropertyDescriptorImpl
+import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl
+import org.jetbrains.kotlin.load.java.components.ExternalSignatureResolver
+import org.jetbrains.kotlin.load.java.components.TypeUsage
+import org.jetbrains.kotlin.load.java.descriptors.JavaMethodDescriptor
+import org.jetbrains.kotlin.load.java.descriptors.JavaPropertyDescriptor
+import org.jetbrains.kotlin.load.java.lazy.LazyJavaResolverContext
+import org.jetbrains.kotlin.load.java.lazy.child
+import org.jetbrains.kotlin.load.java.lazy.resolveAnnotations
 import org.jetbrains.kotlin.load.java.lazy.types.LazyJavaTypeAttributes
+import org.jetbrains.kotlin.load.java.structure.JavaArrayType
+import org.jetbrains.kotlin.load.java.structure.JavaField
+import org.jetbrains.kotlin.load.java.structure.JavaMethod
 import org.jetbrains.kotlin.load.java.structure.JavaValueParameter
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.resolve.DescriptorUtils
+import org.jetbrains.kotlin.resolve.jvm.PLATFORM_TYPES
+import org.jetbrains.kotlin.resolve.scopes.DescriptorKindExclude.NonExtensions
+import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
+import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.storage.NotNullLazyValue
+import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.TypeUtils
+import org.jetbrains.kotlin.utils.Printer
+import org.jetbrains.kotlin.utils.addIfNotNull
+import org.jetbrains.kotlin.utils.toReadOnlyList
 import java.util.ArrayList
 import java.util.LinkedHashSet
-import org.jetbrains.kotlin.types.JetType
-import org.jetbrains.kotlin.load.java.descriptors.JavaPropertyDescriptor
-import org.jetbrains.kotlin.descriptors.impl.PropertyDescriptorImpl
-import org.jetbrains.kotlin.load.java.components.ExternalSignatureResolver
-import org.jetbrains.kotlin.utils.*
-import org.jetbrains.kotlin.resolve.jvm.PLATFORM_TYPES
-import org.jetbrains.kotlin.descriptors.annotations.Annotations
-import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
-import org.jetbrains.kotlin.resolve.scopes.DescriptorKindExclude.NonExtensions
 
 public abstract class LazyJavaMemberScope(
         protected val c: LazyJavaResolverContext,
@@ -167,26 +168,21 @@ public abstract class LazyJavaMemberScope(
             jValueParameters: List<JavaValueParameter>
     ): ResolvedValueParameters {
         var synthesizedNames = false
-        val descriptors = jValueParameters.withIndices().map { pair ->
+        val descriptors = jValueParameters.withIndex().map { pair ->
             val (index, javaParameter) = pair
 
             val annotations = c.resolveAnnotations(javaParameter)
             val typeUsage = LazyJavaTypeAttributes(c, javaParameter, TypeUsage.MEMBER_SIGNATURE_CONTRAVARIANT, annotations)
             val (outType, varargElementType) =
-                if (javaParameter.isVararg()) {
-                    val paramType = javaParameter.getType()
-                    assert (paramType is JavaArrayType) { "Vararg parameter should be an array: $paramType" }
-                    val arrayType = c.typeResolver.transformArrayType(paramType as JavaArrayType, typeUsage, true)
-                    val outType = if (PLATFORM_TYPES) arrayType else TypeUtils.makeNotNullable(arrayType)
-                    outType to KotlinBuiltIns.getInstance().getArrayElementType(outType)
-                }
-                else {
-                    val jetType = c.typeResolver.transformJavaType(javaParameter.getType(), typeUsage)
-                    if (!PLATFORM_TYPES && jetType.isMarkedNullable() && c.hasNotNullAnnotation(javaParameter))
-                        TypeUtils.makeNotNullable(jetType) to null
-                    else
-                        jetType to null
-                }
+                    if (javaParameter.isVararg()) {
+                        val paramType = javaParameter.getType() as? JavaArrayType
+                                        ?: throw AssertionError("Vararg parameter should be an array: $javaParameter")
+                        val outType = c.typeResolver.transformArrayType(paramType, typeUsage, true)
+                        outType to KotlinBuiltIns.getInstance().getArrayElementType(outType)
+                    }
+                    else {
+                        c.typeResolver.transformJavaType(javaParameter.getType(), typeUsage) to null
+                    }
 
             val name = if (function.getName().asString() == "equals" &&
                            jValueParameters.size() == 1 &&

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/types/LazyJavaTypeResolver.kt

@@ -25,7 +25,6 @@ import org.jetbrains.kotlin.load.java.components.TypeUsage
 import org.jetbrains.kotlin.load.java.components.TypeUsage.*
 import org.jetbrains.kotlin.load.java.lazy.LazyJavaResolverContext
 import org.jetbrains.kotlin.load.java.lazy.TypeParameterResolver
-import org.jetbrains.kotlin.load.java.lazy.hasNotNullAnnotation
 import org.jetbrains.kotlin.load.java.lazy.types.JavaTypeFlexibility.FLEXIBLE_LOWER_BOUND
 import org.jetbrains.kotlin.load.java.lazy.types.JavaTypeFlexibility.FLEXIBLE_UPPER_BOUND
 import org.jetbrains.kotlin.load.java.lazy.types.JavaTypeFlexibility.INFLEXIBLE
@@ -379,7 +378,9 @@ class LazyJavaTypeAttributes(
             TypeUsage.MEMBER_SIGNATURE_COVARIANT
     }
 
-    override val isMarkedNotNull: Boolean by c.storageManager.createLazyValue { c.hasNotNullAnnotation(annotationOwner) }
+    override val isMarkedNotNull: Boolean by c.storageManager.createLazyValue {
+        annotationOwner.findAnnotation(JvmAnnotationNames.JETBRAINS_NOT_NULL_ANNOTATION) != null
+    }
 }
 
 private fun Annotations.isMarkedReadOnly() = findAnnotation(JvmAnnotationNames.JETBRAINS_READONLY_ANNOTATION) != null