Drop annotations from stdlib and compiler

compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/native.kt

@@ -16,22 +16,21 @@
 
 package org.jetbrains.kotlin.load.kotlin.nativeDeclarations
 
-import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.resolve.DeclarationChecker
-import org.jetbrains.kotlin.psi.JetDeclaration
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.diagnostics.DiagnosticSink
-import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.descriptors.ConstructorDescriptor
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.Modality
-import org.jetbrains.kotlin.diagnostics.Errors
-import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm
+import org.jetbrains.kotlin.diagnostics.DiagnosticSink
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.psi.JetDeclaration
 import org.jetbrains.kotlin.psi.JetDeclarationWithBody
 import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.resolve.annotations.hasInlineAnnotation
-import org.jetbrains.kotlin.resolve.diagnostics.SuppressDiagnosticsByAnnotations
+import org.jetbrains.kotlin.resolve.DeclarationChecker
+import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.diagnostics.FUNCTION_NO_BODY_ERRORS
+import org.jetbrains.kotlin.resolve.diagnostics.SuppressDiagnosticsByAnnotations
+import org.jetbrains.kotlin.resolve.inline.InlineUtil
+import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm
 
 private val NATIVE_ANNOTATION_CLASS_NAME = FqName("kotlin.jvm.native")
 private val EXTERNAL_ANNOTATION_CLASS_NAME = FqName("kotlin.external")
@@ -66,7 +65,7 @@ public class NativeFunChecker : DeclarationChecker {
             diagnosticHolder.report(ErrorsJvm.EXTERNAL_DECLARATION_CANNOT_HAVE_BODY.on(declaration))
         }
 
-        if (descriptor.hasInlineAnnotation()) {
+        if (InlineUtil.isInline(descriptor)) {
             diagnosticHolder.report(ErrorsJvm.EXTERNAL_DECLARATION_CANNOT_BE_INLINED.on(declaration))
         }
 

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/declarationCheckers.kt

@@ -28,9 +28,9 @@ import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DeclarationChecker
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
 import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.resolve.annotations.hasInlineAnnotation
 import org.jetbrains.kotlin.resolve.annotations.hasIntrinsicAnnotation
 import org.jetbrains.kotlin.resolve.annotations.hasPlatformStaticAnnotation
+import org.jetbrains.kotlin.resolve.inline.InlineUtil
 import org.jetbrains.kotlin.resolve.jvm.annotations.hasJvmOverloadsAnnotation
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm
 
@@ -41,7 +41,7 @@ public class LocalFunInlineChecker : DeclarationChecker {
             descriptor: DeclarationDescriptor,
             diagnosticHolder: DiagnosticSink,
             bindingContext: BindingContext) {
-        if (descriptor.hasInlineAnnotation() &&
+        if (InlineUtil.isInline(descriptor) &&
             declaration is JetNamedFunction &&
             descriptor is FunctionDescriptor &&
             descriptor.getVisibility() == Visibilities.LOCAL) {
@@ -217,9 +217,10 @@ public class ReifiedTypeParameterAnnotationChecker : DeclarationChecker {
     ) {
         if (descriptor.hasIntrinsicAnnotation()) return
 
-        if (descriptor is CallableDescriptor && !descriptor.hasInlineAnnotation()) {
+        if (descriptor is CallableDescriptor && !InlineUtil.isInline(descriptor)) {
             checkTypeParameterDescriptorsAreNotReified(descriptor.getTypeParameters(), diagnosticHolder)
         }
+
         if (descriptor is ClassDescriptor) {
             checkTypeParameterDescriptorsAreNotReified(descriptor.getTypeConstructor().getParameters(), diagnosticHolder)
         }

compiler/frontend/src/org/jetbrains/kotlin/cfg/JetFlowInformationProvider.java

@@ -795,7 +795,7 @@ public class JetFlowInformationProvider {
     public void markTailCalls() {
         final DeclarationDescriptor subroutineDescriptor = trace.get(BindingContext.DECLARATION_TO_DESCRIPTOR, subroutine);
         if (!(subroutineDescriptor instanceof FunctionDescriptor)) return;
-        if (!KotlinBuiltIns.isTailRecursive(subroutineDescriptor)) return;
+        if (!((FunctionDescriptor) subroutineDescriptor).isTailrec()) return;
 
         // finally blocks are copied which leads to multiple diagnostics reported on one instruction
         class KindAndCall {

compiler/frontend/src/org/jetbrains/kotlin/lexer/JetTokens.java

@@ -216,11 +216,6 @@ public interface JetTokens {
                     CONST_KEYWORD, OPERATOR_KEYWORD, INFIX_KEYWORD
             };
 
-    // Please synchronize this array with org.jetbrains.kotlin.descriptors.annotations.ANNOTATION_MODIFIERS_FQ_NAMES
-    JetModifierKeywordToken[] ANNOTATION_MODIFIERS_KEYWORDS_ARRAY = new JetModifierKeywordToken[] {
-            INLINE_KEYWORD, NOINLINE_KEYWORD, TAILREC_KEYWORD, EXTERNAL_KEYWORD, CROSSINLINE_KEYWORD
-    };
-
     TokenSet MODIFIER_KEYWORDS = TokenSet.create(MODIFIER_KEYWORDS_ARRAY);
 
     TokenSet VISIBILITY_MODIFIERS = TokenSet.create(PRIVATE_KEYWORD, PUBLIC_KEYWORD, INTERNAL_KEYWORD, PROTECTED_KEYWORD);

compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java

@@ -18,14 +18,10 @@ package org.jetbrains.kotlin.resolve;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.annotations.*;
 import org.jetbrains.kotlin.diagnostics.Errors;
-import org.jetbrains.kotlin.lexer.JetModifierKeywordToken;
-import org.jetbrains.kotlin.lexer.JetTokens;
 import org.jetbrains.kotlin.psi.*;
-import org.jetbrains.kotlin.resolve.annotations.AnnotationUtilKt;
 import org.jetbrains.kotlin.resolve.calls.CallResolver;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedValueArgument;
 import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResults;
@@ -55,19 +51,14 @@ public class AnnotationResolver {
     @NotNull private TypeResolver typeResolver;
     @NotNull private final ConstantExpressionEvaluator constantExpressionEvaluator;
 
-    @NotNull private final List<AnnotationDescriptor> modifiersAnnotations;
-
     public AnnotationResolver(
             @NotNull CallResolver callResolver,
             @NotNull ConstantExpressionEvaluator constantExpressionEvaluator,
-            @NotNull StorageManager storageManager,
-            @NotNull KotlinBuiltIns kotlinBuiltIns
+            @NotNull StorageManager storageManager
     ) {
         this.callResolver = callResolver;
         this.constantExpressionEvaluator = constantExpressionEvaluator;
         this.storageManager = storageManager;
-
-        modifiersAnnotations = AnnotationUtilKt.buildMigrationAnnotationDescriptors(kotlinBuiltIns);
     }
 
 
@@ -124,30 +115,7 @@ public class AnnotationResolver {
         }
 
         List<JetAnnotationEntry> annotationEntryElements = modifierList.getAnnotationEntries();
-
-        return resolveAndAppendAnnotationsFromModifiers(
-                resolveAnnotationEntries(scope, annotationEntryElements, trace, shouldResolveArguments),
-                modifierList
-        );
-    }
-
-    @NotNull
-    public Annotations resolveAndAppendAnnotationsFromModifiers(
-            @NotNull Annotations annotations,
-            @NotNull JetModifierList modifierList
-    ) {
-        List<AnnotationDescriptor> annotationFromModifiers = new ArrayList<AnnotationDescriptor>();
-
-        for (int i = 0; i < JetTokens.ANNOTATION_MODIFIERS_KEYWORDS_ARRAY.length; i++) {
-            JetModifierKeywordToken modifier = JetTokens.ANNOTATION_MODIFIERS_KEYWORDS_ARRAY[i];
-            if (modifierList.hasModifier(modifier)) {
-                annotationFromModifiers.add(modifiersAnnotations.get(i));
-            }
-        }
-
-        if (annotationFromModifiers.isEmpty()) return annotations;
-
-        return new CompositeAnnotations(annotations, new AnnotationsImpl(annotationFromModifiers));
+        return resolveAnnotationEntries(scope, annotationEntryElements, trace, shouldResolveArguments);
     }
 
     private Annotations resolveAnnotationEntries(

compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUtil.kt

@@ -16,21 +16,14 @@
 
 package org.jetbrains.kotlin.resolve.annotations
 
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.descriptors.PropertyAccessorDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptorImpl
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
-import org.jetbrains.kotlin.lexer.JetTokens
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.types.JetTypeImpl
-
-public fun DeclarationDescriptor.hasInlineAnnotation(): Boolean {
-    return getAnnotations().findAnnotation(FqName("kotlin.inline")) != null
-}
 
 public fun DeclarationDescriptor.hasPlatformStaticAnnotation(): Boolean {
     return getAnnotations().findAnnotation(FqName("kotlin.platform.platformStatic")) != null ||
@@ -67,21 +60,4 @@ public fun AnnotationDescriptor.argumentValue(parameterName: String): Any? {
     return getAllValueArguments().entrySet()
             .singleOrNull { it.key.getName().asString() == parameterName }
             ?.value?.value
-}
-
-public fun KotlinBuiltIns.buildMigrationAnnotationDescriptors(): List<AnnotationDescriptor> =
-    JetTokens.ANNOTATION_MODIFIERS_KEYWORDS_ARRAY.map {
-        modifierKeyword ->
-
-        val name = Name.identifier(modifierKeyword.value)
-        val type = JetTypeImpl.create(
-                Annotations.EMPTY,
-                getBuiltInClassByNameNullable(name) ?: getAnnotationClassByName(name),
-                /* nullable = */false, /* arguments = */emptyList()
-        )
-
-        AnnotationDescriptorImpl(
-                type,
-                emptyMap(), SourceElement.NO_SOURCE
-        )
-    }
+}

compiler/frontend/src/org/jetbrains/kotlin/resolve/inline/InlineUtil.java

@@ -22,7 +22,6 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.descriptors.*;
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingTrace;
@@ -31,14 +30,16 @@ import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilKt;
 import org.jetbrains.kotlin.resolve.calls.model.ArgumentMapping;
 import org.jetbrains.kotlin.resolve.calls.model.ArgumentMatch;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
-import org.jetbrains.kotlin.resolve.constants.ConstantValue;
-import org.jetbrains.kotlin.resolve.constants.EnumValue;
-
-import static kotlin.CollectionsKt.firstOrNull;
 
 public class InlineUtil {
     public static boolean isInlineLambdaParameter(@NotNull ParameterDescriptor valueParameterOrReceiver) {
-        return !KotlinBuiltIns.isNoinline(valueParameterOrReceiver) &&
+        boolean isNoinlineParameter = false;
+
+        if (valueParameterOrReceiver instanceof ValueParameterDescriptor) {
+            isNoinlineParameter = ((ValueParameterDescriptor) valueParameterOrReceiver).isNoinline();
+        }
+
+        return !isNoinlineParameter &&
                KotlinBuiltIns.isExactFunctionOrExtensionFunctionType(valueParameterOrReceiver.getOriginal().getType());
     }
 
@@ -48,20 +49,12 @@ public class InlineUtil {
 
     @NotNull
     public static InlineStrategy getInlineStrategy(@NotNull DeclarationDescriptor descriptor) {
-        AnnotationDescriptor annotation = descriptor.getAnnotations().findAnnotation(KotlinBuiltIns.FQ_NAMES.inline);
-        if (annotation == null) {
-            return InlineStrategy.NOT_INLINE;
-        }
-        ConstantValue<?> argument = firstOrNull(annotation.getAllValueArguments().values());
-        if (argument == null) {
+        if (descriptor instanceof FunctionDescriptor &&
+            ((FunctionDescriptor) descriptor).isInline()) {
             return InlineStrategy.AS_FUNCTION;
         }
-        assert argument instanceof EnumValue : "Inline annotation parameter should be enum entry but was: " + argument;
-        return InlineStrategy.valueOf(((EnumValue) argument).getValue().getName().asString());
-    }
 
-    public static boolean hasOnlyLocalReturn(@NotNull ValueParameterDescriptor descriptor) {
-        return descriptor.getAnnotations().findAnnotation(KotlinBuiltIns.FQ_NAMES.crossinline) != null;
+        return InlineStrategy.NOT_INLINE;
     }
 
     public static boolean checkNonLocalReturnUsage(
@@ -141,7 +134,7 @@ public class InlineUtil {
 
     public static boolean allowsNonLocalReturns(@NotNull CallableDescriptor lambda) {
         if (lambda instanceof ValueParameterDescriptor) {
-            if (hasOnlyLocalReturn((ValueParameterDescriptor) lambda)) {
+            if (((ValueParameterDescriptor) lambda).isCrossinline()) {
                 //annotated
                 return false;
             }

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java

@@ -170,7 +170,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
         });
 
         if (modifierList != null) {
-            LazyAnnotations classAnnotations = new LazyAnnotations(
+            this.annotations = new LazyAnnotations(
                     new LazyAnnotationsContext(
                             c.getAnnotationResolver(),
                             storageManager,
@@ -184,9 +184,6 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
                     },
                     modifierList.getAnnotationEntries()
             );
-            this.annotations = c.getAnnotationResolver().resolveAndAppendAnnotationsFromModifiers(
-                    classAnnotations, modifierList
-            );
         }
         else {
             this.annotations = Annotations.Companion.getEMPTY();