diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java index a3bbb09161e..ae28b47a220 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java @@ -108,10 +108,12 @@ public interface Errors { // Modifiers - DiagnosticFactory1> INCOMPATIBLE_MODIFIERS = DiagnosticFactory1.create(ERROR); + DiagnosticFactory2 INCOMPATIBLE_MODIFIERS = DiagnosticFactory2.create(ERROR); DiagnosticFactory1 ILLEGAL_MODIFIER = DiagnosticFactory1.create(ERROR); DiagnosticFactory1 REPEATED_MODIFIER = DiagnosticFactory1.create(ERROR); DiagnosticFactory2 REDUNDANT_MODIFIER = DiagnosticFactory2.create(WARNING); + DiagnosticFactory2 WRONG_MODIFIER_TARGET = DiagnosticFactory2.create(ERROR); + DiagnosticFactory2 WRONG_MODIFIER_CONTAINING_DECLARATION = DiagnosticFactory2.create(ERROR); DiagnosticFactory0 INAPPLICABLE_PLATFORM_NAME = DiagnosticFactory0.create(ERROR); DiagnosticFactory1 WRONG_ANNOTATION_TARGET = DiagnosticFactory1.create(ERROR); DiagnosticFactory0 REPEATED_ANNOTATION = DiagnosticFactory0.create(ERROR); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java index fe14901d328..91871e1614d 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java @@ -119,22 +119,11 @@ public class DefaultErrorMessages { MAP.put(NAME_SHADOWING, "Name shadowed: {0}", STRING); MAP.put(TYPE_MISMATCH, "Type mismatch: inferred type is {1} but {0} was expected", RENDER_TYPE, RENDER_TYPE); - MAP.put(INCOMPATIBLE_MODIFIERS, "Incompatible modifiers: ''{0}''", new Renderer>() { - @NotNull - @Override - public String render(@NotNull Collection tokens) { - StringBuilder sb = new StringBuilder(); - for (JetKeywordToken token : tokens) { - if (sb.length() != 0) { - sb.append(" "); - } - sb.append(token.getValue()); - } - return sb.toString(); - } - }); + MAP.put(INCOMPATIBLE_MODIFIERS, "Modifier ''{0}'' is incompatible with ''{1}''", TO_STRING, TO_STRING); MAP.put(ILLEGAL_MODIFIER, "Illegal modifier ''{0}''", TO_STRING); MAP.put(REPEATED_MODIFIER, "Repeated ''{0}''", TO_STRING); + MAP.put(WRONG_MODIFIER_TARGET, "Modifier ''{0}'' is not applicable to ''{1}''", TO_STRING, TO_STRING); + MAP.put(WRONG_MODIFIER_CONTAINING_DECLARATION, "Modifier ''{0}'' is not applicable inside ''{1}''", TO_STRING, TO_STRING); MAP.put(INAPPLICABLE_PLATFORM_NAME, "platformName annotation is not applicable to this declaration"); MAP.put(WRONG_ANNOTATION_TARGET, "This annotation is not applicable to target ''{0}''", TO_STRING); MAP.put(REPEATED_ANNOTATION, "This annotation is not repeatable"); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationChecker.kt index 77da1680d57..e3b3ff15e18 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationChecker.kt @@ -18,7 +18,6 @@ package org.jetbrains.kotlin.resolve import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.descriptors.ClassDescriptor -import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.diagnostics.Errors import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.psi.psiUtil.getAnnotationEntries @@ -28,6 +27,7 @@ import org.jetbrains.kotlin.types.JetType import org.jetbrains.kotlin.types.TypeUtils import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget import org.jetbrains.kotlin.resolve.descriptorUtil.isRepeatableAnnotation +import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget.* public object AnnotationChecker { @@ -50,11 +50,6 @@ public object AnnotationChecker { } } } - if (annotated is JetClassOrObject) { - for (initializer in annotated.getAnonymousInitializers()) { - check(initializer, trace) - } - } } public fun checkExpression(expression: JetExpression, trace: BindingTrace) { @@ -103,32 +98,40 @@ public object AnnotationChecker { trace.report(Errors.WRONG_ANNOTATION_TARGET.on(entry, actualTargets.firstOrNull()?.description ?: "unidentified target")) } - private fun getActualTargetList(annotated: JetAnnotated, descriptor: ClassDescriptor?): List { - if (annotated is JetClassOrObject) { - if (annotated is JetEnumEntry) return listOf(KotlinTarget.PROPERTY, KotlinTarget.FIELD) - return if (descriptor?.kind == ClassKind.ANNOTATION_CLASS) { - listOf(KotlinTarget.ANNOTATION_CLASS, KotlinTarget.CLASSIFIER) - } - else { - listOf(KotlinTarget.CLASSIFIER) - } + public fun getActualTargetList(annotated: JetElement, descriptor: ClassDescriptor?): List { + return when (annotated) { + is JetClassOrObject -> descriptor?.let { KotlinTarget.classActualTargets(it) } ?: listOf(CLASSIFIER) + is JetProperty -> + if (annotated.isLocal) { + listOf(LOCAL_VARIABLE) + } + else if (annotated.parent is JetClassOrObject || annotated.parent is JetClassBody) { + listOf(MEMBER_PROPERTY, PROPERTY, FIELD) + } + else { + listOf(TOP_LEVEL_PROPERTY, PROPERTY, FIELD) + } + is JetParameter -> if (annotated.hasValOrVar()) listOf(PROPERTY_PARAMETER, MEMBER_PROPERTY, PROPERTY, FIELD) else listOf(VALUE_PARAMETER) + is JetConstructor<*> -> listOf(CONSTRUCTOR) + is JetFunction -> + if (annotated.isLocal) { + listOf(LOCAL_FUNCTION, FUNCTION) + } + else if (annotated.parent is JetClassOrObject || annotated.parent is JetClassBody) { + listOf(MEMBER_FUNCTION, FUNCTION) + } + else { + listOf(TOP_LEVEL_FUNCTION, FUNCTION) + } + is JetPropertyAccessor -> if (annotated.isGetter) listOf(PROPERTY_GETTER) else listOf(PROPERTY_SETTER) + is JetPackageDirective -> listOf(PACKAGE) + is JetTypeReference -> listOf(TYPE) + is JetFile -> listOf(FILE) + is JetTypeParameter -> listOf(TYPE_PARAMETER) + is JetTypeProjection -> if (annotated.projectionKind == JetProjectionKind.STAR) listOf(STAR_PROJECTION) else listOf(TYPE_PROJECTION) + is JetClassInitializer -> listOf(INITIALIZER) + else -> listOf() } - if (annotated is JetProperty) { - return if (annotated.isLocal) listOf(KotlinTarget.LOCAL_VARIABLE) else listOf(KotlinTarget.PROPERTY, KotlinTarget.FIELD) - } - if (annotated is JetParameter) { - return if (annotated.hasValOrVar()) listOf(KotlinTarget.PROPERTY, KotlinTarget.FIELD) else listOf(KotlinTarget.VALUE_PARAMETER) - } - if (annotated is JetConstructor<*>) return listOf(KotlinTarget.CONSTRUCTOR) - if (annotated is JetFunction) return listOf(KotlinTarget.FUNCTION) - if (annotated is JetPropertyAccessor) { - return if (annotated.isGetter) listOf(KotlinTarget.PROPERTY_GETTER) else listOf(KotlinTarget.PROPERTY_SETTER) - } - if (annotated is JetPackageDirective) return listOf(KotlinTarget.PACKAGE) - if (annotated is JetTypeReference) return listOf(KotlinTarget.TYPE) - if (annotated is JetFile) return listOf(KotlinTarget.FILE) - if (annotated is JetTypeParameter) return listOf(KotlinTarget.TYPE_PARAMETER) - return listOf() } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java index ec539daa7bc..ea1521b7b21 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java @@ -507,12 +507,12 @@ public class BodyResolver { } private void processModifiersOnInitializer(@NotNull JetModifierListOwner owner, @NotNull JetScope scope) { + AnnotationChecker.INSTANCE$.check(owner, trace, null); + ModifierCheckerCore.INSTANCE$.check(owner, trace, null); JetModifierList modifierList = owner.getModifierList(); if (modifierList == null) return; annotationResolver.resolveAnnotationsWithArguments(scope, modifierList, trace); - - modifiersChecker.withTrace(trace).reportIllegalModifiers(modifierList, Arrays.asList(JetTokens.MODIFIER_KEYWORDS_ARRAY)); } private void resolvePrimaryConstructorParameters(@NotNull BodiesResolveContext c) { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.java index 8ecd9ce4d8f..fffb0d6c588 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.java @@ -114,17 +114,9 @@ public class DeclarationsChecker { } private void checkConstructorDeclaration(ConstructorDescriptor constructorDescriptor, JetDeclaration declaration) { - modifiersChecker.reportIllegalModalityModifiers(declaration); - reportErrorIfHasIllegalModifier(declaration); modifiersChecker.checkModifiersForDeclaration(declaration, constructorDescriptor); } - private void reportErrorIfHasIllegalModifier(JetModifierListOwner declaration) { - if (declaration.hasModifier(JetTokens.ENUM_KEYWORD)) { - trace.report(ILLEGAL_ENUM_ANNOTATION.on(declaration)); - } - } - private void checkModifiersAndAnnotationsInPackageDirective(JetFile file) { JetPackageDirective packageDirective = file.getPackageDirective(); if (packageDirective == null) return; @@ -142,8 +134,7 @@ public class DeclarationsChecker { } } AnnotationChecker.INSTANCE$.check(packageDirective, trace, null); - - modifiersChecker.reportIllegalModifiers(modifierList, Arrays.asList(JetTokens.MODIFIER_KEYWORDS_ARRAY)); + ModifierCheckerCore.INSTANCE$.check(packageDirective, trace, null); } private void checkTypesInClassHeader(@NotNull JetClassOrObject classOrObject) { @@ -228,8 +219,8 @@ public class DeclarationsChecker { } } } + private void checkObject(JetObjectDeclaration declaration, ClassDescriptor classDescriptor) { - reportErrorIfHasIllegalModifier(declaration); if (declaration.isLocal() && !declaration.isCompanion() && !declaration.isObjectLiteral()) { trace.report(LOCAL_OBJECT_NOT_ALLOWED.on(declaration, classDescriptor)); } @@ -245,11 +236,9 @@ public class DeclarationsChecker { trace.report(Errors.DEPRECATED_TRAIT_KEYWORD.on(traitKeyword.getPsi())); } - checkTraitModifiers(aClass); checkConstructorInTrait(aClass); } else if (aClass.isEnum()) { - checkEnumModifiers(aClass); if (aClass.isLocal()) { trace.report(LOCAL_ENUM_NOT_ALLOWED.on(aClass, classDescriptor)); } @@ -263,9 +252,6 @@ public class DeclarationsChecker { checkAnnotationClassWithBody(aClass); checkValOnAnnotationParameter(aClass); } - else if (aClass.hasModifier(JetTokens.SEALED_KEYWORD)) { - checkSealedModifiers(aClass); - } else if (aClass instanceof JetEnumEntry) { checkEnumEntry((JetEnumEntry) aClass, classDescriptor); } @@ -314,24 +300,6 @@ public class DeclarationsChecker { } } - private void checkTraitModifiers(JetClass aClass) { - reportErrorIfHasIllegalModifier(aClass); - JetModifierList modifierList = aClass.getModifierList(); - if (modifierList == null) return; - if (modifierList.hasModifier(JetTokens.FINAL_KEYWORD)) { - trace.report(Errors.TRAIT_CAN_NOT_BE_FINAL.on(aClass)); - } - if (modifierList.hasModifier(JetTokens.SEALED_KEYWORD)) { - trace.report(Errors.TRAIT_CAN_NOT_BE_SEALED.on(aClass)); - } - if (modifierList.hasModifier(JetTokens.ABSTRACT_KEYWORD)) { - trace.report(Errors.ABSTRACT_MODIFIER_IN_TRAIT.on(aClass)); - } - if (modifierList.hasModifier(JetTokens.OPEN_KEYWORD)) { - trace.report(Errors.OPEN_MODIFIER_IN_TRAIT.on(aClass)); - } - } - private void checkAnnotationClassWithBody(JetClassOrObject classOrObject) { if (classOrObject.getBody() != null) { trace.report(ANNOTATION_CLASS_WITH_BODY.on(classOrObject.getBody())); @@ -359,14 +327,10 @@ public class DeclarationsChecker { } private void checkProperty(JetProperty property, PropertyDescriptor propertyDescriptor) { - reportErrorIfHasIllegalModifier(property); DeclarationDescriptor containingDeclaration = propertyDescriptor.getContainingDeclaration(); if (containingDeclaration instanceof ClassDescriptor) { checkPropertyAbstractness(property, propertyDescriptor, (ClassDescriptor) containingDeclaration); } - else { - modifiersChecker.reportIllegalModalityModifiers(property); - } checkPropertyInitializer(property, propertyDescriptor); checkAccessors(property, propertyDescriptor); checkDeclaredTypeInPublicMember(property, propertyDescriptor); @@ -490,7 +454,6 @@ public class DeclarationsChecker { } protected void checkFunction(JetNamedFunction function, SimpleFunctionDescriptor functionDescriptor) { - reportErrorIfHasIllegalModifier(function); DeclarationDescriptor containingDescriptor = functionDescriptor.getContainingDeclaration(); boolean hasAbstractModifier = function.hasModifier(JetTokens.ABSTRACT_KEYWORD); checkDeclaredTypeInPublicMember(function, functionDescriptor); @@ -515,7 +478,6 @@ public class DeclarationsChecker { } return; } - modifiersChecker.reportIllegalModalityModifiers(function); if (!function.hasBody() && !hasAbstractModifier) { trace.report(NON_MEMBER_FUNCTION_NO_BODY.on(function, functionDescriptor)); } @@ -526,7 +488,6 @@ public class DeclarationsChecker { PropertyAccessorDescriptor propertyAccessorDescriptor = accessor.isGetter() ? propertyDescriptor.getGetter() : propertyDescriptor.getSetter(); assert propertyAccessorDescriptor != null : "No property accessor descriptor for " + property.getText(); modifiersChecker.checkModifiersForDeclaration(accessor, propertyAccessorDescriptor); - modifiersChecker.reportIllegalModalityModifiers(accessor); } JetPropertyAccessor getter = property.getGetter(); PropertyGetterDescriptor getterDescriptor = propertyDescriptor.getGetter(); @@ -548,30 +509,6 @@ public class DeclarationsChecker { } } - private void checkEnumModifiers(JetClass aClass) { - if (aClass.hasModifier(JetTokens.OPEN_KEYWORD)) { - trace.report(OPEN_MODIFIER_IN_ENUM.on(aClass)); - } - if (aClass.hasModifier(JetTokens.ABSTRACT_KEYWORD)) { - trace.report(ABSTRACT_MODIFIER_IN_ENUM.on(aClass)); - } - if (aClass.hasModifier(JetTokens.SEALED_KEYWORD)) { - trace.report(SEALED_MODIFIER_IN_ENUM.on(aClass)); - } - } - - private void checkSealedModifiers(JetClass aClass) { - if (aClass.hasModifier(JetTokens.OPEN_KEYWORD)) { - trace.report(OPEN_MODIFIER_IN_SEALED.on(aClass)); - } - if (aClass.hasModifier(JetTokens.FINAL_KEYWORD)) { - trace.report(FINAL_MODIFIER_IN_SEALED.on(aClass)); - } - if (aClass.hasModifier(JetTokens.ABSTRACT_KEYWORD)) { - trace.report(ABSTRACT_MODIFIER_IN_SEALED.on(aClass)); - } - } - // Temporary // Returns true if deprecated constructor is in use, like // ENTRY: Enum(arguments) instead of diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt index cd076428ef7..6d09f616c7d 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt @@ -344,12 +344,8 @@ class FunctionDescriptorResolver( valueParameter, if (isConstructor) VAL_OR_VAR_ON_SECONDARY_CONSTRUCTOR_PARAMETER else VAL_OR_VAR_ON_FUN_PARAMETER ) - checkParameterHasNoModifier(valueParameter) } } - else { - checkConstructorParameterHasNoModifier(trace, valueParameter) - } val valueParameterDescriptor = descriptorResolver.resolveValueParameterDescriptor(parameterScope, functionDescriptor, valueParameter, i, type, trace) @@ -358,11 +354,4 @@ class FunctionDescriptorResolver( } return result } - - private fun checkConstructorParameterHasNoModifier(trace: BindingTrace, parameter: JetParameter) { - // If is not a property, then it must have no modifier - if (!parameter.hasValOrVar()) { - modifiersChecker.withTrace(trace).checkParameterHasNoModifier(parameter) - } - } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.java index 695b3de2eee..ce012509c28 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.java @@ -20,14 +20,12 @@ import com.google.common.collect.Lists; import com.google.common.collect.Maps; import com.google.common.collect.Sets; import com.intellij.lang.ASTNode; -import com.intellij.openapi.util.Pair; import com.intellij.psi.PsiElement; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.descriptors.*; import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.kotlin.diagnostics.DiagnosticFactory1; -import org.jetbrains.kotlin.diagnostics.Errors; import org.jetbrains.kotlin.lexer.JetKeywordToken; import org.jetbrains.kotlin.lexer.JetModifierKeywordToken; import org.jetbrains.kotlin.lexer.JetTokens; @@ -42,8 +40,6 @@ import java.util.*; import static org.jetbrains.kotlin.diagnostics.Errors.*; import static org.jetbrains.kotlin.lexer.JetTokens.*; import static org.jetbrains.kotlin.psi.JetStubbedPsiUtil.getContainingDeclaration; -import static org.jetbrains.kotlin.resolve.DescriptorUtils.isCompanionObject; -import static org.jetbrains.kotlin.resolve.DescriptorUtils.isEnumEntry; public class ModifiersChecker { private static final Collection MODALITY_MODIFIERS = @@ -189,175 +185,29 @@ public class ModifiersChecker { } } - public void reportIllegalModifiers( - @Nullable JetModifierList modifierList, - @NotNull Collection illegalModifiers - ) { - if (modifierList == null) return; - - for (JetModifierKeywordToken modifierToken : illegalModifiers) { - if (modifierList.hasModifier(modifierToken)) { - PsiElement modifierPsi = modifierList.getModifier(modifierToken); - assert modifierPsi != null; - trace.report(ILLEGAL_MODIFIER.on(modifierPsi, modifierToken)); - } - } - } - - public void reportIllegalModifiers( - @NotNull JetModifierListOwner modifierListOwner, - @NotNull Collection illegalModifiers - ) { - reportIllegalModifiers(modifierListOwner.getModifierList(), illegalModifiers); - } - - public void checkIncompatibleModifiers( - @Nullable JetModifierList modifierList, - @NotNull Collection availableModifiers, - @NotNull Collection... availableCombinations - ) { - if (modifierList == null) return; - Collection presentModifiers = Sets.newLinkedHashSet(); - for (JetModifierKeywordToken modifier : availableModifiers) { - if (modifierList.hasModifier(modifier)) { - presentModifiers.add(modifier); - } - } - checkRepeatedModifiers(modifierList, availableModifiers); - - if (presentModifiers.size() == 1) { - return; - } - for (Collection combination : availableCombinations) { - if (presentModifiers.containsAll(combination) && combination.containsAll(presentModifiers)) { - return; - } - } - for (JetModifierKeywordToken token : presentModifiers) { - trace.report(Errors.INCOMPATIBLE_MODIFIERS.on(modifierList.getModifierNode(token).getPsi(), presentModifiers)); - } - } - - private void checkRepeatedModifiers( - @NotNull JetModifierList modifierList, - @NotNull Collection availableModifiers - ) { - for (JetModifierKeywordToken token : availableModifiers) { - if (!modifierList.hasModifier(token)) continue; - - List nodesOfRepeatedTokens = Lists.newArrayList(); - ASTNode node = modifierList.getNode().getFirstChildNode(); - while (node != null) { - if (node.getElementType() == token) { - nodesOfRepeatedTokens.add(node); - } - node = node.getTreeNext(); - } - if (nodesOfRepeatedTokens.size() > 1) { - for (ASTNode repeatedToken : nodesOfRepeatedTokens) { - trace.report(REPEATED_MODIFIER.on(repeatedToken.getPsi(), token)); - } - } - } - } - - public void checkIncompatibleVarianceModifiers(@Nullable JetModifierList modifierList) { - checkIncompatibleModifiers(modifierList, Arrays.asList(JetTokens.IN_KEYWORD, JetTokens.OUT_KEYWORD)); - } - - public void checkModifiersForDeclaration(@NotNull JetDeclaration modifierListOwner, @NotNull MemberDescriptor descriptor) { - if (modifierListOwner instanceof JetEnumEntry) { - reportIllegalModifiers(modifierListOwner.getModifierList(), Arrays.asList(MODIFIER_KEYWORDS_ARRAY)); - } - else { - checkInnerModifier(modifierListOwner, descriptor); - checkCompanionModifier(modifierListOwner); - checkModalityModifiers(modifierListOwner); - checkVisibilityModifiers(modifierListOwner, descriptor); - checkVarianceModifiers(modifierListOwner); - checkVarargsModifiers(modifierListOwner, descriptor); - } + checkNestedClassAllowed(modifierListOwner, descriptor); + ModifierCheckerCore.INSTANCE$.check(modifierListOwner, trace, descriptor); + checkTypeParametersModifiers(modifierListOwner); checkPlatformNameApplicability(descriptor); runDeclarationCheckers(modifierListOwner, descriptor); - AnnotationChecker.INSTANCE$.check(modifierListOwner, trace, - descriptor instanceof ClassDescriptor ? (ClassDescriptor) descriptor : null); - } - - private void checkVarargsModifiers(@NotNull JetDeclaration owner, @NotNull MemberDescriptor descriptor) { - if (!(owner instanceof JetParameter)) { - reportIllegalModifiers(owner.getModifierList(), Collections.singleton(VARARG_KEYWORD)); - } + ClassDescriptor classDescriptor = descriptor instanceof ClassDescriptor ? (ClassDescriptor) descriptor : null; + AnnotationChecker.INSTANCE$.check(modifierListOwner, trace, classDescriptor); } public void checkModifiersForLocalDeclaration( @NotNull JetDeclaration modifierListOwner, @NotNull DeclarationDescriptor descriptor ) { - reportIllegalModalityModifiers(modifierListOwner); - reportIllegalVisibilityModifiers(modifierListOwner); checkPlatformNameApplicability(descriptor); runDeclarationCheckers(modifierListOwner, descriptor); AnnotationChecker.INSTANCE$.check(modifierListOwner, trace, - descriptor instanceof ClassDescriptor ? (ClassDescriptor) descriptor : null); + descriptor instanceof ClassDescriptor ? (ClassDescriptor) descriptor : null); + ModifierCheckerCore.INSTANCE$.check(modifierListOwner, trace, descriptor); } - public void reportIllegalModalityModifiers(@NotNull JetModifierListOwner modifierListOwner) { - reportIllegalModifiers(modifierListOwner, MODALITY_MODIFIERS); - } - - public void reportIllegalVisibilityModifiers(@NotNull JetModifierListOwner modifierListOwner) { - reportIllegalModifiers(modifierListOwner, VISIBILITY_MODIFIERS); - } - - private void checkModalityModifiers(@NotNull JetModifierListOwner modifierListOwner) { - JetModifierList modifierList = modifierListOwner.getModifierList(); - if (modifierList == null) return; - - checkRedundantModifier(modifierList, Pair.create(OPEN_KEYWORD, ABSTRACT_KEYWORD), Pair.create(OPEN_KEYWORD, OVERRIDE_KEYWORD)); - - checkCompatibility(modifierList, Arrays.asList(ABSTRACT_KEYWORD, OPEN_KEYWORD, FINAL_KEYWORD), - Arrays.asList(ABSTRACT_KEYWORD, OPEN_KEYWORD)); - - if (modifierListOwner instanceof JetObjectDeclaration) { - reportIllegalModalityModifiers(modifierListOwner); - } - else if (modifierListOwner instanceof JetClassOrObject) { - reportIllegalModifiers(modifierListOwner, Collections.singletonList(OVERRIDE_KEYWORD)); - } - } - - private void checkVisibilityModifiers(@NotNull JetModifierListOwner modifierListOwner, @NotNull DeclarationDescriptor descriptor) { - JetModifierList modifierList = modifierListOwner.getModifierList(); - if (modifierList == null) return; - - DeclarationDescriptor containingDeclaration = descriptor.getContainingDeclaration(); - if (containingDeclaration instanceof PackageFragmentDescriptor) { - if (modifierList.hasModifier(PROTECTED_KEYWORD)) { - trace.report(Errors.PACKAGE_MEMBER_CANNOT_BE_PROTECTED.on(modifierListOwner)); - } - } - - checkCompatibility(modifierList, VISIBILITY_MODIFIERS); - } - - private void checkInnerModifier(@NotNull JetModifierListOwner modifierListOwner, @NotNull DeclarationDescriptor descriptor) { - if (modifierListOwner.hasModifier(INNER_KEYWORD)) { - switch (checkIllegalInner(descriptor)) { - case ALLOWED: - break; - case ILLEGAL_POSITION: - reportIllegalModifiers(modifierListOwner, Collections.singletonList(INNER_KEYWORD)); - break; - case IN_TRAIT: - trace.report(INNER_CLASS_IN_TRAIT.on(modifierListOwner)); - break; - case IN_OBJECT: - trace.report(INNER_CLASS_IN_OBJECT.on(modifierListOwner)); - break; - } - return; - } + private void checkNestedClassAllowed(@NotNull JetModifierListOwner modifierListOwner, @NotNull DeclarationDescriptor descriptor) { + if (modifierListOwner.hasModifier(INNER_KEYWORD)) return; if (modifierListOwner instanceof JetClass && !(modifierListOwner instanceof JetEnumEntry)) { JetClass aClass = (JetClass) modifierListOwner; boolean localEnumError = aClass.isLocal() && aClass.isEnum(); @@ -367,12 +217,6 @@ public class ModifiersChecker { } } - private void checkCompanionModifier(@NotNull JetDeclaration declaration) { - if (declaration.hasModifier(COMPANION_KEYWORD) && !isCompanionModifierAllowed(declaration)) { - reportIllegalModifiers(declaration, Collections.singletonList(COMPANION_KEYWORD)); - } - } - private void checkPlatformNameApplicability(@NotNull DeclarationDescriptor descriptor) { AnnotationDescriptor annotation = descriptor.getAnnotations().findAnnotation(new FqName("kotlin.platform.platformName")); if (annotation == null) return; @@ -411,28 +255,6 @@ public class ModifiersChecker { return containingDescriptor instanceof PackageFragmentDescriptor || containingDescriptor instanceof ClassDescriptor; } - private void checkCompatibility( - @Nullable JetModifierList modifierList, - Collection availableModifiers, - Collection... availableCombinations - ) { - checkIncompatibleModifiers(modifierList, availableModifiers, availableCombinations); - } - - private void checkRedundantModifier( - @NotNull JetModifierList modifierList, - Pair... redundantBundles - ) { - for (Pair tokenPair : redundantBundles) { - JetModifierKeywordToken redundantModifier = tokenPair.getFirst(); - JetModifierKeywordToken sufficientModifier = tokenPair.getSecond(); - if (modifierList.hasModifier(redundantModifier) && modifierList.hasModifier(sufficientModifier)) { - trace.report(Errors.REDUNDANT_MODIFIER.on(modifierList.getModifierNode(redundantModifier).getPsi(), redundantModifier, - sufficientModifier)); - } - } - } - @NotNull public Map getNodesCorrespondingToModifiers( @NotNull JetModifierList modifierList, @@ -454,21 +276,13 @@ public class ModifiersChecker { } } - public void checkVarianceModifiers(@NotNull JetModifierListOwner modifierListOwner) { - reportIllegalModifiers(modifierListOwner.getModifierList(), Arrays.asList(IN_KEYWORD, OUT_KEYWORD, REIFIED_KEYWORD)); + public void checkTypeParametersModifiers(@NotNull JetModifierListOwner modifierListOwner) { if (!(modifierListOwner instanceof JetTypeParameterListOwner)) return; List typeParameters = ((JetTypeParameterListOwner) modifierListOwner).getTypeParameters(); for (JetTypeParameter typeParameter : typeParameters) { - JetModifierList modifierList = typeParameter.getModifierList(); - checkIncompatibleVarianceModifiers(modifierList); + ModifierCheckerCore.INSTANCE$.check(typeParameter, trace, null); } } - - public void checkParameterHasNoModifier( - @NotNull JetParameter parameter - ) { - reportIllegalModifiers(parameter.getModifierList(), MODIFIERS_ILLEGAL_ON_PARAMETERS); - } } @NotNull diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.kt new file mode 100644 index 00000000000..85229f70b02 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.kt @@ -0,0 +1,203 @@ +/* + * 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.resolve + +import com.intellij.lang.ASTNode +import com.intellij.psi.tree.TokenSet +import org.jetbrains.kotlin.descriptors.* +import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget +import org.jetbrains.kotlin.diagnostics.Errors +import org.jetbrains.kotlin.lexer.JetModifierKeywordToken +import java.util.* +import org.jetbrains.kotlin.lexer.JetTokens.* +import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget.* +import org.jetbrains.kotlin.lexer.JetTokens +import org.jetbrains.kotlin.psi.* + +public object ModifierCheckerCore { + private enum class Compatibility { + COMPATIBLE, + REDUNDANT, + REVERSE_REDUNDANT, + REPEATED, + INCOMPATIBLE + } + + private val possibleTargetMap = mapOf>( + ENUM_KEYWORD to EnumSet.of(ENUM_CLASS), + ABSTRACT_KEYWORD to EnumSet.of(CLASS, LOCAL_CLASS, INNER_CLASS, MEMBER_PROPERTY, MEMBER_FUNCTION), + OPEN_KEYWORD to EnumSet.of(CLASS, LOCAL_CLASS, INNER_CLASS, MEMBER_PROPERTY, MEMBER_FUNCTION), + FINAL_KEYWORD to EnumSet.of(CLASS, LOCAL_CLASS, INNER_CLASS, MEMBER_PROPERTY, MEMBER_FUNCTION), + SEALED_KEYWORD to EnumSet.of(CLASS, LOCAL_CLASS, INNER_CLASS), + INNER_KEYWORD to EnumSet.of(INNER_CLASS), + OVERRIDE_KEYWORD to EnumSet.of(MEMBER_PROPERTY, MEMBER_FUNCTION), + PRIVATE_KEYWORD to EnumSet.of(CLASSIFIER, MEMBER_FUNCTION, TOP_LEVEL_FUNCTION, PROPERTY_GETTER, PROPERTY_SETTER, + MEMBER_PROPERTY, TOP_LEVEL_PROPERTY, CONSTRUCTOR), + PUBLIC_KEYWORD to EnumSet.of(CLASSIFIER, MEMBER_FUNCTION, TOP_LEVEL_FUNCTION, PROPERTY_GETTER, PROPERTY_SETTER, + MEMBER_PROPERTY, TOP_LEVEL_PROPERTY, CONSTRUCTOR), + INTERNAL_KEYWORD to EnumSet.of(CLASSIFIER, MEMBER_FUNCTION, TOP_LEVEL_FUNCTION, PROPERTY_GETTER, PROPERTY_SETTER, + MEMBER_PROPERTY, TOP_LEVEL_PROPERTY, CONSTRUCTOR), + PROTECTED_KEYWORD to EnumSet.of(CLASSIFIER, MEMBER_FUNCTION, PROPERTY_GETTER, PROPERTY_SETTER, MEMBER_PROPERTY, CONSTRUCTOR), + IN_KEYWORD to EnumSet.of(TYPE_PARAMETER, TYPE_PROJECTION), + OUT_KEYWORD to EnumSet.of(TYPE_PARAMETER, TYPE_PROJECTION), + REIFIED_KEYWORD to EnumSet.of(TYPE_PARAMETER), + VARARG_KEYWORD to EnumSet.of(VALUE_PARAMETER, PROPERTY_PARAMETER), + DYNAMIC_KEYWORD to emptySet(), // not really a modifier + COMPANION_KEYWORD to EnumSet.of(OBJECT) + ) + + private val possibleParentTargetMap = mapOf>( + INNER_KEYWORD to EnumSet.of(CLASS, INNER_CLASS, LOCAL_CLASS, ENUM_CLASS, ENUM_ENTRY), + OVERRIDE_KEYWORD to EnumSet.of(CLASSIFIER, ENUM_ENTRY), + PROTECTED_KEYWORD to EnumSet.of(CLASSIFIER, ENUM_ENTRY), + COMPANION_KEYWORD to EnumSet.of(CLASS, ENUM_CLASS, INTERFACE) + ) + + // First modifier in pair should be also first in declaration + private val mutualCompatibility = buildCompatibilityMap() + + private fun buildCompatibilityMap(): Map, Compatibility> { + val result = hashMapOf, Compatibility>() + // Variance: in + out are incompatible + result += incompatibilityRegister(listOf(IN_KEYWORD, OUT_KEYWORD)) + // Visibilities: incompatible + result += incompatibilityRegister(listOf(PRIVATE_KEYWORD, PROTECTED_KEYWORD, PUBLIC_KEYWORD, INTERNAL_KEYWORD)) + // Abstract + open + final + sealed: incompatible + result += incompatibilityRegister(listOf(ABSTRACT_KEYWORD, OPEN_KEYWORD, FINAL_KEYWORD, SEALED_KEYWORD)) + // open is redundant to abstract & override + result += redundantRegister(ABSTRACT_KEYWORD, OPEN_KEYWORD) + result += redundantRegister(OVERRIDE_KEYWORD, OPEN_KEYWORD) + // abstract is redundant to sealed + result += redundantRegister(SEALED_KEYWORD, ABSTRACT_KEYWORD) + return result + } + + private fun redundantRegister( + sufficient: JetModifierKeywordToken, + redundant: JetModifierKeywordToken + ): Map, Compatibility> { + return mapOf(Pair(sufficient, redundant) to Compatibility.REDUNDANT, + Pair(redundant, sufficient) to Compatibility.REVERSE_REDUNDANT) + } + + private fun incompatibilityRegister( + list: List + ): Map, Compatibility> { + val result = hashMapOf, Compatibility>() + for (first in list) { + for (second in list) { + if (first != second) { + result[Pair(first, second)] = Compatibility.INCOMPATIBLE + } + } + } + return result + } + + private fun compatibility(first: JetModifierKeywordToken, second: JetModifierKeywordToken): Compatibility { + if (first == second) { + return Compatibility.REPEATED + } + else { + return mutualCompatibility[Pair(first, second)] ?: Compatibility.COMPATIBLE + } + } + + private fun checkCompatibility(trace: BindingTrace, firstNode: ASTNode, secondNode: ASTNode, incorrectNodes: MutableSet) { + val first = firstNode.elementType as JetModifierKeywordToken + val second = secondNode.elementType as JetModifierKeywordToken + val compatibility = compatibility(first, second) + when (compatibility) { + Compatibility.COMPATIBLE -> {} + Compatibility.REPEATED -> if (incorrectNodes.add(secondNode)) { + trace.report(Errors.REPEATED_MODIFIER.on (secondNode.psi, first)) + } + Compatibility.REDUNDANT -> if (incorrectNodes.add(secondNode)) { + trace.report(Errors.REDUNDANT_MODIFIER.on(secondNode.psi, first, second)) + } + Compatibility.REVERSE_REDUNDANT -> if (incorrectNodes.add(firstNode)) { + trace.report(Errors.REDUNDANT_MODIFIER.on(firstNode.psi, second, first)) + } + Compatibility.INCOMPATIBLE -> { + if (incorrectNodes.add(firstNode)) { + trace.report(Errors.INCOMPATIBLE_MODIFIERS.on(firstNode.psi, first, second)) + } + if (incorrectNodes.add(secondNode)) { + trace.report(Errors.INCOMPATIBLE_MODIFIERS.on(secondNode.psi, second, first)) + } + } + } + } + + private fun checkTarget(trace: BindingTrace, node: ASTNode, actualTargets: List): Boolean { + val modifier = node.elementType as JetModifierKeywordToken + val possibleTargets = possibleTargetMap[modifier] ?: emptySet() + if (actualTargets.any { it in possibleTargets }) return true + trace.report(Errors.WRONG_MODIFIER_TARGET.on(node.psi, modifier, actualTargets.firstOrNull()?.description ?: "this")) + return false + } + + private fun checkParent(trace: BindingTrace, node: ASTNode, parentDescriptor: DeclarationDescriptor?): Boolean { + val modifier = node.elementType as JetModifierKeywordToken + val actualParents: List = when (parentDescriptor) { + is ClassDescriptor -> KotlinTarget.classActualTargets(parentDescriptor) + is FunctionDescriptor -> listOf(FUNCTION) + else -> listOf(PACKAGE) + } + val possibleParents = possibleParentTargetMap[modifier] ?: return true + if (possibleParents == KotlinTarget.ALL_TARGET_SET) return true + if (actualParents.any { it in possibleParents }) return true + trace.report(Errors.WRONG_MODIFIER_CONTAINING_DECLARATION.on(node.psi, modifier, actualParents.firstOrNull()?.description ?: "this scope")) + return false + } + + private val MODIFIER_KEYWORD_SET = TokenSet.orSet(JetTokens.SOFT_KEYWORDS, TokenSet.create(JetTokens.IN_KEYWORD)) + + private fun checkModifierList(list: JetModifierList, trace: BindingTrace, parentDescriptor: DeclarationDescriptor?, actualTargets: List) { + val incorrectNodes = hashSetOf() + val children = list.node.getChildren(MODIFIER_KEYWORD_SET) + for (second in children) { + for (first in children) { + if (first == second) { + break; + } + checkCompatibility(trace, first, second, incorrectNodes) + } + if (second !in incorrectNodes) { + if (!checkTarget(trace, second, actualTargets)) { + incorrectNodes += second + } + else if (!checkParent(trace, second, parentDescriptor)) { + incorrectNodes += second + } + } + } + } + + public fun check(listOwner: JetModifierListOwner, trace: BindingTrace, descriptor: DeclarationDescriptor?) { + if (listOwner is JetFunction) { + for (parameter in listOwner.valueParameters) { + if (!parameter.hasValOrVar()) { + check(parameter, trace, null) + } + } + } + val actualTargets = AnnotationChecker.getActualTargetList(listOwner, descriptor as? ClassDescriptor) + val list = listOwner.modifierList ?: return + checkModifierList(list, trace, descriptor?.containingDeclaration, actualTargets) + } +} \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt index 8cc680b93e9..ef7dc7b89e3 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt @@ -269,10 +269,8 @@ public class TypeResolver( return argumentElements.mapIndexed { i, argumentElement -> val projectionKind = argumentElement.getProjectionKind() - modifiersChecker.withTrace(c.trace).checkIncompatibleVarianceModifiers(argumentElement.getModifierList()) + ModifierCheckerCore.check(argumentElement, c.trace, null) if (projectionKind == JetProjectionKind.STAR) { - modifiersChecker.withTrace(c.trace).reportIllegalModifiers(argumentElement.getModifierList(), listOf(JetTokens.IN_KEYWORD, JetTokens.OUT_KEYWORD)) - val parameters = constructor.getParameters() if (parameters.size() > i) { val parameterDescriptor = parameters[i] diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt index 0c229dba823..d8b53a29263 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt @@ -126,7 +126,7 @@ public class CandidateResolver( for (projection in jetTypeArguments) { if (projection.getProjectionKind() != JetProjectionKind.NONE) { trace.report(PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT.on(projection)) - modifiersChecker.withTrace(trace).checkIncompatibleVarianceModifiers(projection.getModifierList()) + ModifierCheckerCore.check(projection, trace, null) } val type = argumentTypeResolver.resolveTypeRefWithDefault( projection.getTypeReference(), scope, trace, diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java index 30a4f6c9dbb..bcc6f068540 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java @@ -381,12 +381,8 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes } @Nullable - private JetClassLikeInfo getCompanionObjectInfo(@Nullable JetObjectDeclaration companionObject) { + private static JetClassLikeInfo getCompanionObjectInfo(@Nullable JetObjectDeclaration companionObject) { if (companionObject != null) { - if (!isCompanionObjectAllowed()) { - c.getTrace().report(COMPANION_OBJECT_NOT_ALLOWED.on(companionObject)); - } - return JetClassInfoUtil.createClassLikeInfo(companionObject); } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingVisitor.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingVisitor.java index 1c3aaa01fc4..5bdca1c3b28 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingVisitor.java @@ -26,10 +26,7 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns; import org.jetbrains.kotlin.descriptors.*; import org.jetbrains.kotlin.diagnostics.Errors; import org.jetbrains.kotlin.psi.*; -import org.jetbrains.kotlin.resolve.BindingContext; -import org.jetbrains.kotlin.resolve.BindingContextUtils; -import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils; -import org.jetbrains.kotlin.resolve.ModifiersChecker; +import org.jetbrains.kotlin.resolve.*; import org.jetbrains.kotlin.resolve.calls.model.MutableDataFlowInfoForArguments; import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall; import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo; @@ -474,7 +471,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { if (catchParameter != null) { ModifiersChecker.ModifiersCheckingProcedure modifiersChecking = components.modifiersChecker.withTrace(context.trace); modifiersChecking.checkParameterHasNoValOrVar(catchParameter, VAL_OR_VAR_ON_CATCH_PARAMETER); - modifiersChecking.checkParameterHasNoModifier(catchParameter); + ModifierCheckerCore.INSTANCE$.check(catchParameter, context.trace, null); VariableDescriptor variableDescriptor = components.descriptorResolver.resolveLocalVariableDescriptor( context.scope, catchParameter, context.trace); diff --git a/compiler/testData/cli/jvm/multipleTextRangesInDiagnosticsOrder.out b/compiler/testData/cli/jvm/multipleTextRangesInDiagnosticsOrder.out index 0e19e5c3287..14a61d6dd91 100644 --- a/compiler/testData/cli/jvm/multipleTextRangesInDiagnosticsOrder.out +++ b/compiler/testData/cli/jvm/multipleTextRangesInDiagnosticsOrder.out @@ -1,10 +1,10 @@ compiler/testData/cli/jvm/multipleTextRangesInDiagnosticsOrder.kt:6:14: error: cannot weaken access privilege 'public' for 'c' in 'A' override protected private val c: Int ^ -compiler/testData/cli/jvm/multipleTextRangesInDiagnosticsOrder.kt:6:14: error: incompatible modifiers: 'private protected' +compiler/testData/cli/jvm/multipleTextRangesInDiagnosticsOrder.kt:6:14: error: modifier 'protected' is incompatible with 'private' override protected private val c: Int ^ -compiler/testData/cli/jvm/multipleTextRangesInDiagnosticsOrder.kt:6:24: error: incompatible modifiers: 'private protected' +compiler/testData/cli/jvm/multipleTextRangesInDiagnosticsOrder.kt:6:24: error: modifier 'private' is incompatible with 'protected' override protected private val c: Int ^ COMPILATION_ERROR diff --git a/compiler/testData/codegen/box/classes/delegation4.kt b/compiler/testData/codegen/box/classes/delegation4.kt index d29ddb16c89..7a9c9449e58 100644 --- a/compiler/testData/codegen/box/classes/delegation4.kt +++ b/compiler/testData/codegen/box/classes/delegation4.kt @@ -1,8 +1,8 @@ -open interface First { +interface First { public open fun foo() : Int } -open interface Second : First { +interface Second : First { public open fun bar() : Int } diff --git a/compiler/testData/codegen/box/superConstructorCall/deepLocalHierarchy.kt b/compiler/testData/codegen/box/superConstructorCall/deepLocalHierarchy.kt index 534370e134e..1b596e12610 100644 --- a/compiler/testData/codegen/box/superConstructorCall/deepLocalHierarchy.kt +++ b/compiler/testData/codegen/box/superConstructorCall/deepLocalHierarchy.kt @@ -1,5 +1,5 @@ fun box(): String { - open interface L1 { + interface L1 { fun foo(): String } diff --git a/compiler/testData/codegen/boxInline/complex/use.2.kt b/compiler/testData/codegen/boxInline/complex/use.2.kt index c2a6ac78683..42f0ce1bfbd 100644 --- a/compiler/testData/codegen/boxInline/complex/use.2.kt +++ b/compiler/testData/codegen/boxInline/complex/use.2.kt @@ -9,7 +9,7 @@ public class Output(val d: Data) : Closeable { public fun doOutput(data: Int): Int = data } -public open interface Closeable { +public interface Closeable { open public fun close() {} } diff --git a/compiler/testData/codegen/boxInline/complex/with.2.kt b/compiler/testData/codegen/boxInline/complex/with.2.kt index a4ac07cfd41..896304eb3e8 100644 --- a/compiler/testData/codegen/boxInline/complex/with.2.kt +++ b/compiler/testData/codegen/boxInline/complex/with.2.kt @@ -11,7 +11,7 @@ public class Output(val d: Data) : Closeable { public fun doOutput(data: Int): Int = data } -public open interface Closeable { +public interface Closeable { open public fun close() {} } diff --git a/compiler/testData/diagnostics/tests/Abstract.kt b/compiler/testData/diagnostics/tests/Abstract.kt index e6fe05bc245..e62f77a36bc 100644 --- a/compiler/testData/diagnostics/tests/Abstract.kt +++ b/compiler/testData/diagnostics/tests/Abstract.kt @@ -3,44 +3,44 @@ package MyPackage //properties val a: Int val a1: Int = 1 - abstract val a2: Int - abstract val a3: Int = 1 + abstract val a2: Int + abstract val a3: Int = 1 var b: Int private set var b1: Int = 0; private set - abstract var b2: Int private set - abstract var b3: Int = 0; private set + abstract var b2: Int private set + abstract var b3: Int = 0; private set var c: Int set(v: Int) { $c = v } var c1: Int = 0; set(v: Int) { $c1 = v } - abstract var c2: Int set(v: Int) { $c2 = v } - abstract var c3: Int = 0; set(v: Int) { $c3 = v } + abstract var c2: Int set(v: Int) { $c2 = v } + abstract var c3: Int = 0; set(v: Int) { $c3 = v } val e: Int get() = a val e1: Int = 0; get() = a - abstract val e2: Int get() = a - abstract val e3: Int = 0; get() = a + abstract val e2: Int get() = a + abstract val e3: Int = 0; get() = a //methods fun f() fun g() {} - abstract fun h() - abstract fun j() {} + abstract fun h() + abstract fun j() {} //property accessors - var i: Int abstract get abstract set - var i1: Int = 0; abstract get abstract set + var i: Int abstract get abstract set + var i1: Int = 0; abstract get abstract set - var j: Int get() = i; abstract set - var j1: Int = 0; get() = i; abstract set + var j: Int get() = i; abstract set + var j1: Int = 0; get() = i; abstract set - var k: Int abstract set - var k1: Int = 0; abstract set + var k: Int abstract set + var k1: Int = 0; abstract set - var l: Int abstract get abstract set - var l1: Int = 0; abstract get abstract set + var l: Int abstract get abstract set + var l1: Int = 0; abstract get abstract set - var n: Int abstract get abstract set(v: Int) {} + var n: Int abstract get abstract set(v: Int) {} // FILE: c.kt //creating an instance diff --git a/compiler/testData/diagnostics/tests/AbstractInAbstractClass.kt b/compiler/testData/diagnostics/tests/AbstractInAbstractClass.kt index 218bb40075e..5c2b1e9135b 100644 --- a/compiler/testData/diagnostics/tests/AbstractInAbstractClass.kt +++ b/compiler/testData/diagnostics/tests/AbstractInAbstractClass.kt @@ -29,17 +29,17 @@ abstract class MyAbstractClass() { abstract fun j() {} //property accessors - var i: Int abstract get abstract set - var i1: Int = 0; abstract get abstract set + var i: Int abstract get abstract set + var i1: Int = 0; abstract get abstract set - var j: Int get() = i; abstract set - var j1: Int get() = i; abstract set + var j: Int get() = i; abstract set + var j1: Int get() = i; abstract set - var k: Int abstract set - var k1: Int = 0; abstract set + var k: Int abstract set + var k1: Int = 0; abstract set - var l: Int abstract get abstract set - var l1: Int = 0; abstract get abstract set + var l: Int abstract get abstract set + var l1: Int = 0; abstract get abstract set - var n: Int abstract get abstract set(v: Int) {} + var n: Int abstract get abstract set(v: Int) {} } \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/AbstractInClass.kt b/compiler/testData/diagnostics/tests/AbstractInClass.kt index 587fbecf3e6..0084a0192d8 100644 --- a/compiler/testData/diagnostics/tests/AbstractInClass.kt +++ b/compiler/testData/diagnostics/tests/AbstractInClass.kt @@ -29,17 +29,17 @@ class MyClass() { abstract fun j() {} //property accessors - var i: Int abstract get abstract set - var i1: Int = 0; abstract get abstract set + var i: Int abstract get abstract set + var i1: Int = 0; abstract get abstract set - var j: Int get() = i; abstract set - var j1: Int = 0; get() = i; abstract set + var j: Int get() = i; abstract set + var j1: Int = 0; get() = i; abstract set - var k: Int abstract set - var k1: Int = 0; abstract set + var k: Int abstract set + var k1: Int = 0; abstract set - var l: Int abstract get abstract set - var l1: Int = 0; abstract get abstract set + var l: Int abstract get abstract set + var l1: Int = 0; abstract get abstract set - var n: Int abstract get abstract set(v: Int) {} + var n: Int abstract get abstract set(v: Int) {} } \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/AbstractInTrait.kt b/compiler/testData/diagnostics/tests/AbstractInTrait.kt index dca6ca1344e..35e05fe559b 100644 --- a/compiler/testData/diagnostics/tests/AbstractInTrait.kt +++ b/compiler/testData/diagnostics/tests/AbstractInTrait.kt @@ -29,17 +29,17 @@ interface MyTrait { abstract fun j() {} //property accessors - var i: Int abstract get abstract set - var i1: Int = 0; abstract get abstract set + var i: Int abstract get abstract set + var i1: Int = 0; abstract get abstract set - var j: Int get() = i; abstract set - var j1: Int = 0; get() = i; abstract set + var j: Int get() = i; abstract set + var j1: Int = 0; get() = i; abstract set - var k: Int abstract set - var k1: Int = 0; abstract set + var k: Int abstract set + var k1: Int = 0; abstract set - var l: Int abstract get abstract set - var l1: Int = 0; abstract get abstract set + var l: Int abstract get abstract set + var l1: Int = 0; abstract get abstract set - var n: Int abstract get abstract set(v: Int) {} + var n: Int abstract get abstract set(v: Int) {} } \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/annotations/kt1886annotationBody.kt b/compiler/testData/diagnostics/tests/annotations/kt1886annotationBody.kt index cf65dd2ccb3..7c0f524f365 100644 --- a/compiler/testData/diagnostics/tests/annotations/kt1886annotationBody.kt +++ b/compiler/testData/diagnostics/tests/annotations/kt1886annotationBody.kt @@ -11,7 +11,7 @@ annotation class Annotation4() { } annotation class Annotation5() { - companion object {} + companion object {} } annotation class Annotation6() { diff --git a/compiler/testData/diagnostics/tests/annotations/onInitializer.kt b/compiler/testData/diagnostics/tests/annotations/onInitializer.kt index 150b324718d..07b7acc09dd 100644 --- a/compiler/testData/diagnostics/tests/annotations/onInitializer.kt +++ b/compiler/testData/diagnostics/tests/annotations/onInitializer.kt @@ -1,15 +1,15 @@ class A { ann init {} @ann init {} - aaa init {} - @aaa init {} + aaa init {} + @aaa init {} } interface T { ann init {} @ann init {} - aaa init {} - @aaa init {} + aaa init {} + @aaa init {} } annotation class ann \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/classObjects/ClassObjects.kt b/compiler/testData/diagnostics/tests/classObjects/ClassObjects.kt index 0f24874764d..cdc94614a12 100644 --- a/compiler/testData/diagnostics/tests/classObjects/ClassObjects.kt +++ b/compiler/testData/diagnostics/tests/classObjects/ClassObjects.kt @@ -26,7 +26,7 @@ class B() { } object b { - companion object { + companion object { val x = 1 } // error } diff --git a/compiler/testData/diagnostics/tests/classObjects/InnerClassClassObject.kt b/compiler/testData/diagnostics/tests/classObjects/InnerClassClassObject.kt index 2e1a5c26ed8..f660c0f89ea 100644 --- a/compiler/testData/diagnostics/tests/classObjects/InnerClassClassObject.kt +++ b/compiler/testData/diagnostics/tests/classObjects/InnerClassClassObject.kt @@ -2,7 +2,7 @@ class A { inner class B { - companion object { } + companion object { } } } diff --git a/compiler/testData/diagnostics/tests/classObjects/classObjectInLocalClass.kt b/compiler/testData/diagnostics/tests/classObjects/classObjectInLocalClass.kt index ee2ef6db157..d9d28a48188 100644 --- a/compiler/testData/diagnostics/tests/classObjects/classObjectInLocalClass.kt +++ b/compiler/testData/diagnostics/tests/classObjects/classObjectInLocalClass.kt @@ -1,9 +1,9 @@ fun test() { class A { - companion object {} + companion object {} } object { - companion object {} + companion object {} } } \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/classObjects/multipleDissallowedDefaultObjects.kt b/compiler/testData/diagnostics/tests/classObjects/multipleDissallowedDefaultObjects.kt index 9690fb58523..77d75ed47f6 100644 --- a/compiler/testData/diagnostics/tests/classObjects/multipleDissallowedDefaultObjects.kt +++ b/compiler/testData/diagnostics/tests/classObjects/multipleDissallowedDefaultObjects.kt @@ -1,17 +1,17 @@ class A { inner class I { - companion object A + companion object A - companion object B + companion object B - companion object C + companion object C } } object O { - companion object A + companion object A - companion object B + companion object B - companion object C + companion object C } \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/declarationChecks/ambiguousObjectExpressionType.kt b/compiler/testData/diagnostics/tests/declarationChecks/ambiguousObjectExpressionType.kt index 34d002fe049..eaabbcbcb0a 100644 --- a/compiler/testData/diagnostics/tests/declarationChecks/ambiguousObjectExpressionType.kt +++ b/compiler/testData/diagnostics/tests/declarationChecks/ambiguousObjectExpressionType.kt @@ -90,7 +90,7 @@ class Foo { private val packagePrivateProperty = object : MyClass(), MyTrait {} -protected val packageProtectedProperty = object : MyClass(), MyTrait {} +protected val packageProtectedProperty = object : MyClass(), MyTrait {} val packageInternalProperty = object : MyClass(), MyTrait {} @@ -98,7 +98,7 @@ class Foo { public val packagePublicProperty = object : MyClass(), MyTrait {} -protected fun packageProtectedFunction() = object : MyClass(), MyTrait {} +protected fun packageProtectedFunction() = object : MyClass(), MyTrait {} fun packageInternalFunction() = object : MyClass(), MyTrait {} diff --git a/compiler/testData/diagnostics/tests/declarationChecks/illegalModifiersOnClass.kt b/compiler/testData/diagnostics/tests/declarationChecks/illegalModifiersOnClass.kt index 8a5deec1784..950324590e7 100644 --- a/compiler/testData/diagnostics/tests/declarationChecks/illegalModifiersOnClass.kt +++ b/compiler/testData/diagnostics/tests/declarationChecks/illegalModifiersOnClass.kt @@ -2,18 +2,18 @@ // KT-3464 Front-end shouldn't allow override modifier in class declaration -override class A { - override companion object {} - open companion object {} - abstract companion object {} - final companion object {} +override class A { + override companion object {} + open companion object {} + abstract companion object {} + final companion object {} } -override object B1 {} -open object B2 {} -abstract object B3 {} -final object B4 {} +override object B1 {} +open object B2 {} +abstract object B3 {} +final object B4 {} -override enum class C {} -override interface D {} -override annotation class E +override enum class C {} +override interface D {} +override annotation class E \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/declarationChecks/localDeclarationModifiers.kt b/compiler/testData/diagnostics/tests/declarationChecks/localDeclarationModifiers.kt index 8d5cfea8e8f..563d53a17da 100644 --- a/compiler/testData/diagnostics/tests/declarationChecks/localDeclarationModifiers.kt +++ b/compiler/testData/diagnostics/tests/declarationChecks/localDeclarationModifiers.kt @@ -5,8 +5,8 @@ class T { } fun foo() { - public val i = 11 - abstract val j - override fun T.baz() = 2 - private fun bar() = 2 + public val i = 11 + abstract val j + override fun T.baz() = 2 + private fun bar() = 2 } \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/declarationChecks/localFunctionNoInheritVisibility.kt b/compiler/testData/diagnostics/tests/declarationChecks/localFunctionNoInheritVisibility.kt index 2d43f4e8d27..44a5b20249e 100644 --- a/compiler/testData/diagnostics/tests/declarationChecks/localFunctionNoInheritVisibility.kt +++ b/compiler/testData/diagnostics/tests/declarationChecks/localFunctionNoInheritVisibility.kt @@ -4,10 +4,10 @@ class T { fun baz() = 1 } -override fun zzz() {} +override fun zzz() {} fun foo(t: T) { - override fun T.baz() = 2 + override fun T.baz() = 2 // was "Visibility is unknown yet exception" t.baz() diff --git a/compiler/testData/diagnostics/tests/declarationChecks/packageDeclarationModifiers.kt b/compiler/testData/diagnostics/tests/declarationChecks/packageDeclarationModifiers.kt index 77cfcadb8b5..6641ec56792 100644 --- a/compiler/testData/diagnostics/tests/declarationChecks/packageDeclarationModifiers.kt +++ b/compiler/testData/diagnostics/tests/declarationChecks/packageDeclarationModifiers.kt @@ -1,13 +1,12 @@ package d -abstract val a : Int = 1 +abstract val a : Int = 1 -override val c : Int = 1 +override val c : Int = 1 -final fun foo() = 2 +final fun foo() = 2 -abstract fun baz() = 2 +abstract fun baz() = 2 class T {} -override fun T.bar() = 2 - +override fun T.bar() = 2 \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/declarationChecks/propertyInPackageHasNoInheritVisibility.kt b/compiler/testData/diagnostics/tests/declarationChecks/propertyInPackageHasNoInheritVisibility.kt index 0dd832f8738..33f9c2e8398 100644 --- a/compiler/testData/diagnostics/tests/declarationChecks/propertyInPackageHasNoInheritVisibility.kt +++ b/compiler/testData/diagnostics/tests/declarationChecks/propertyInPackageHasNoInheritVisibility.kt @@ -1,10 +1,10 @@ package d -override val f : ()-> Int = { 12 } +override val f : ()-> Int = { 12 } fun test() { f() } var g: Int = 1 - protected set(i: Int) {} \ No newline at end of file + protected set(i: Int) {} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/declarationChecks/unambiguousObjectExpressionType.kt b/compiler/testData/diagnostics/tests/declarationChecks/unambiguousObjectExpressionType.kt index d899c9045e0..6e1d08ec959 100644 --- a/compiler/testData/diagnostics/tests/declarationChecks/unambiguousObjectExpressionType.kt +++ b/compiler/testData/diagnostics/tests/declarationChecks/unambiguousObjectExpressionType.kt @@ -136,7 +136,7 @@ class Foo { } -protected val packageProtectedProperty = object : MyClass() {} +protected val packageProtectedProperty = object : MyClass() {} public val packagePublicProperty = object : MyClass() {} @@ -164,7 +164,7 @@ fun testProperties() { private fun privateFunction() = object : MyClass() {fun invisible() {}} -protected fun protectedFunction() = object : MyClass() {} +protected fun protectedFunction() = object : MyClass() {} public fun publicFunction() = object : MyClass() {} diff --git a/compiler/testData/diagnostics/tests/delegation/DelegationNotTotrait.kt b/compiler/testData/diagnostics/tests/delegation/DelegationNotTotrait.kt index 044c92ed23a..c0361f843a6 100644 --- a/compiler/testData/diagnostics/tests/delegation/DelegationNotTotrait.kt +++ b/compiler/testData/diagnostics/tests/delegation/DelegationNotTotrait.kt @@ -8,7 +8,7 @@ interface T {} class Br(t : T) : T by t {} -open enum class EN() { +open enum class EN() { A } diff --git a/compiler/testData/diagnostics/tests/enum/AbstractEnum.kt b/compiler/testData/diagnostics/tests/enum/AbstractEnum.kt index 87d785e169e..8bca5a6beb5 100644 --- a/compiler/testData/diagnostics/tests/enum/AbstractEnum.kt +++ b/compiler/testData/diagnostics/tests/enum/AbstractEnum.kt @@ -1,3 +1,3 @@ package abstract -abstract enum class MyAbstractEnum() {} \ No newline at end of file +abstract enum class MyAbstractEnum() {} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/enum/AbstractInEnum.kt b/compiler/testData/diagnostics/tests/enum/AbstractInEnum.kt index fe330dd5291..6d978e817c1 100644 --- a/compiler/testData/diagnostics/tests/enum/AbstractInEnum.kt +++ b/compiler/testData/diagnostics/tests/enum/AbstractInEnum.kt @@ -30,17 +30,17 @@ enum class MyEnum() { abstract fun j() {} //property accessors - var i: Int abstract get abstract set - var i1: Int = 0; abstract get abstract set + var i: Int abstract get abstract set + var i1: Int = 0; abstract get abstract set - var j: Int get() = i; abstract set - var j1: Int = 0; get() = i; abstract set + var j: Int get() = i; abstract set + var j1: Int = 0; get() = i; abstract set - var k: Int abstract set - var k1: Int = 0; abstract set + var k: Int abstract set + var k1: Int = 0; abstract set - var l: Int abstract get abstract set - var l1: Int = 0; abstract get abstract set + var l: Int abstract get abstract set + var l1: Int = 0; abstract get abstract set - var n: Int abstract get abstract set(v: Int) {} + var n: Int abstract get abstract set(v: Int) {} } \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/enum/enumEntryCannotHaveClassObject.kt b/compiler/testData/diagnostics/tests/enum/enumEntryCannotHaveClassObject.kt index e650bddb2b1..e65fd1ed973 100644 --- a/compiler/testData/diagnostics/tests/enum/enumEntryCannotHaveClassObject.kt +++ b/compiler/testData/diagnostics/tests/enum/enumEntryCannotHaveClassObject.kt @@ -2,7 +2,7 @@ enum class E { FIRST, SECOND { - companion object { + companion object { fun foo() = 42 } }; diff --git a/compiler/testData/diagnostics/tests/enum/enumModifier.kt b/compiler/testData/diagnostics/tests/enum/enumModifier.kt index 15e6c87869d..9e216bb9f81 100644 --- a/compiler/testData/diagnostics/tests/enum/enumModifier.kt +++ b/compiler/testData/diagnostics/tests/enum/enumModifier.kt @@ -1,15 +1,15 @@ enum class B {} class A { - enum companion object {} + enum companion object {} } -enum object O {} +enum object O {} -enum interface T {} +enum interface T {} -enum fun f() = 0 +enum fun f() = 0 -enum val x = 0 +enum val x = 0 -enum var y = 0 +enum var y = 0 \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/enum/inheritanceFromEnum.kt b/compiler/testData/diagnostics/tests/enum/inheritanceFromEnum.kt index febf92f1f96..b4f3ac1e3a4 100644 --- a/compiler/testData/diagnostics/tests/enum/inheritanceFromEnum.kt +++ b/compiler/testData/diagnostics/tests/enum/inheritanceFromEnum.kt @@ -2,7 +2,7 @@ public enum MyJavaEnum {} // FILE: test.kt -open enum class MyEnum() { +open enum class MyEnum() { A() } diff --git a/compiler/testData/diagnostics/tests/enum/interfaceWithEnumKeyword.kt b/compiler/testData/diagnostics/tests/enum/interfaceWithEnumKeyword.kt index 2bc34f6a387..b42cf92f216 100644 --- a/compiler/testData/diagnostics/tests/enum/interfaceWithEnumKeyword.kt +++ b/compiler/testData/diagnostics/tests/enum/interfaceWithEnumKeyword.kt @@ -1,4 +1,4 @@ -enum interface Some { +enum interface Some { // Enum part D diff --git a/compiler/testData/diagnostics/tests/enum/modifiersOnEnumEntry.kt b/compiler/testData/diagnostics/tests/enum/modifiersOnEnumEntry.kt index 2a76a527fb7..210adfc4cdf 100644 --- a/compiler/testData/diagnostics/tests/enum/modifiersOnEnumEntry.kt +++ b/compiler/testData/diagnostics/tests/enum/modifiersOnEnumEntry.kt @@ -1,23 +1,23 @@ enum class E { - public final SUBCLASS { + public final SUBCLASS { fun foo() {} }, - public PUBLIC, - protected PROTECTED, - private PRIVATE, - internal INTERNAL, + public PUBLIC, + protected PROTECTED, + private PRIVATE, + internal INTERNAL, - abstract ABSTRACT, - open OPEN, - override OVERRIDE, - final FINAL, + abstract ABSTRACT, + open OPEN, + override OVERRIDE, + final FINAL, - inner INNER, + inner INNER, annotation ANNOTATION, - enum ENUM, - out OUT, - in IN, - vararg VARARG, - reified REIFIED + enum ENUM, + out OUT, + in IN, + vararg VARARG, + reified REIFIED } diff --git a/compiler/testData/diagnostics/tests/infos/PropertiesWithBackingFields.kt b/compiler/testData/diagnostics/tests/infos/PropertiesWithBackingFields.kt index 046b3a70a24..7a089a45588 100644 --- a/compiler/testData/diagnostics/tests/infos/PropertiesWithBackingFields.kt +++ b/compiler/testData/diagnostics/tests/infos/PropertiesWithBackingFields.kt @@ -39,8 +39,8 @@ abstract class Test() { abstract var v8 : Int get set var v9 : Int set var v10 : Int get - abstract val v11 : Int abstract get - abstract var v12 : Int abstract get abstract set + abstract val v11 : Int abstract get + abstract var v12 : Int abstract get abstract set } diff --git a/compiler/testData/diagnostics/tests/inner/deepInnerClass.kt b/compiler/testData/diagnostics/tests/inner/deepInnerClass.kt index 0ca1ab2dad2..5b86be12c82 100644 --- a/compiler/testData/diagnostics/tests/inner/deepInnerClass.kt +++ b/compiler/testData/diagnostics/tests/inner/deepInnerClass.kt @@ -4,7 +4,7 @@ class A { class B { fun test() { class C() : PT> { - companion object : P<W, T> { + companion object : P<W, T> { } inner class D : PT> diff --git a/compiler/testData/diagnostics/tests/inner/illegalModifier.kt b/compiler/testData/diagnostics/tests/inner/illegalModifier.kt index e5573d81d69..a98607e2ed9 100644 --- a/compiler/testData/diagnostics/tests/inner/illegalModifier.kt +++ b/compiler/testData/diagnostics/tests/inner/illegalModifier.kt @@ -1,21 +1,21 @@ -inner fun foo() {} -inner val prop = 42 +inner fun foo() {} +inner val prop = 42 -inner class A -inner interface B -inner object C +inner class A +inner interface B +inner object C class D { inner class E - inner interface F - inner object G - inner enum class R - inner annotation class S - inner companion object + inner interface F + inner object G + inner enum class R + inner annotation class S + inner companion object } enum class H { - inner I { + inner I { inner class II }; @@ -23,16 +23,16 @@ enum class H { } interface K { - inner class L + inner class L } object N { - inner class O + inner class O } class P { companion object { - inner class Q + inner class Q } } diff --git a/compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.kt b/compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.kt index f4f0706f2eb..f7309d7bb15 100644 --- a/compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.kt +++ b/compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.kt @@ -1,4 +1,4 @@ -myAnnotation public package illegal_modifiers +myAnnotation public package illegal_modifiers abstract class A() { abstract final fun f() @@ -7,17 +7,17 @@ abstract class A() { open var r: String get - abstract protected set + abstract protected set } -final interface T {} +final interface T {} class FinalClass() { open fun foo() {} val i: Int = 1 - open get(): Int = $i + open get(): Int = $i var j: Int = 1 - open set(v: Int) {} + open set(v: Int) {} } private public class C @@ -31,104 +31,104 @@ class LegalModifier(val a: Int, annotated private var b: String, annotated varar //Check illegal modifier in constructor parameters class IllegalModifiers1( - in - out - reified - enum - private + in + out + reified + enum + private a: Int) //Check multiple illegal modifiers in constructor -class IllegalModifiers2(private abstract a: Int) +class IllegalModifiers2(private abstract a: Int) //Check annotations with illegal modifiers in constructor -class IllegalModifiers3(annotated public abstract b: String) +class IllegalModifiers3(annotated public abstract b: String) //Check annotations and vararg with illegal modifiers in constructor -class IllegalModifiers4(val a: Int, annotated("a text") protected vararg v: Int) +class IllegalModifiers4(val a: Int, annotated("a text") protected vararg v: Int) //Check illegal modifiers for functions and catch block abstract class IllegalModifiers5() { //Check illegal modifier in function parameter - abstract fun foo(public a: Int, vararg v: String) + abstract fun foo(public a: Int, vararg v: String) //Check multiple illegal modifiers in function parameter - abstract fun bar(public abstract a: Int, vararg v: String) + abstract fun bar(public abstract a: Int, vararg v: String) //Check annotations with illegal modifiers - abstract fun baz(annotated("a text") public abstract a: Int) + abstract fun baz(annotated("a text") public abstract a: Int) private fun qux() { //Check illegal modifier in catch block - try {} catch (in out reified enum public e: Exception) {} + try {} catch (in out reified enum public e: Exception) {} //Check multiple illegal modifiers in catch block - try {} catch (in out reified enum abstract public e: Exception) {} + try {} catch (in out reified enum abstract public e: Exception) {} //Check annotations with illegal modifiers - try {} catch (annotated("a text") abstract public e: Exception) {} + try {} catch (annotated("a text") abstract public e: Exception) {} } } //Check illegal modifiers on anonymous initializers abstract class IllegalModifiers6() { - public init {} - private init {} - protected init {} - vararg init {} - abstract init {} - open init {} - final init {} + public init {} + private init {} + protected init {} + vararg init {} + abstract init {} + open init {} + final init {} - public annotated init {} + public annotated init {} - private IllegalModifiers6() init {} + private IllegalModifiers6() init {} } // strange inappropriate modifiers usages -override -out -in -vararg -reified +override +out +in +vararg +reified class IllegalModifiers7() { - enum - inner + enum + inner annotation - out - in - vararg - reified + out + in + vararg + reified val x = 1 - enum - inner + enum + inner annotation - out - in - vararg - reified + out + in + vararg + reified fun foo() {} } // Secondary constructors class IllegalModifiers8 { - abstract - enum - open - inner + abstract + enum + open + inner annotation - override - out - in - final - vararg - reified + override + out + in + final + vararg + reified constructor() {} - constructor(private enum abstract x: Int) {} + constructor(private enum abstract x: Int) {} } class IllegalModifiers9 { @@ -139,16 +139,16 @@ class IllegalModifiers9 { // Illegal modifiers on primary constructor class IllegalModifiers10 -abstract -enum -open -inner +abstract +enum +open +inner annotation -override -out -in -final -vararg -reified constructor() +override +out +in +final +vararg +reified constructor() class IllegalModifiers11 private protected constructor() diff --git a/compiler/testData/diagnostics/tests/modifiers/defaultModifier.kt b/compiler/testData/diagnostics/tests/modifiers/defaultModifier.kt index 67e1a954575..e928bcc2f25 100644 --- a/compiler/testData/diagnostics/tests/modifiers/defaultModifier.kt +++ b/compiler/testData/diagnostics/tests/modifiers/defaultModifier.kt @@ -1,4 +1,4 @@ -companion class A { +companion class A { companion object { } @@ -18,38 +18,38 @@ class C { class D { companion object A { - companion object { + companion object { } } } -companion object G { - companion object +companion object G { + companion object } -companion interface H { +companion interface H { companion object } class J { companion object C { - companion object + companion object } } -companion enum class Enum { +companion enum class Enum { E1, E2; companion object } -companion fun main() { +companion fun main() { } -companion var prop: Int = 1 - companion get - companion set +companion var prop: Int = 1 + companion get + companion set -class Z(companion val c: Int) \ No newline at end of file +class Z(companion val c: Int) \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/modifiers/incompatibleVarianceModifiers.kt b/compiler/testData/diagnostics/tests/modifiers/incompatibleVarianceModifiers.kt index 7902c43d96f..0441b23cb3c 100644 --- a/compiler/testData/diagnostics/tests/modifiers/incompatibleVarianceModifiers.kt +++ b/compiler/testData/diagnostics/tests/modifiers/incompatibleVarianceModifiers.kt @@ -2,22 +2,22 @@ interface Foo interface Foo1<in out T> -interface Foo2<in in T> +interface Foo2in T> fun test1(foo: Foo<in out Int>) = foo -fun test2(): Foo<in in Int> = throw Exception() +fun test2(): Fooin Int> = throw Exception() fun test3() { - val f: Foo<out out out out Int> + val f: Fooout out out Int> - class Bzz<in in T> + class Bzzin T> } class A { - fun <out out T> bar() { + fun <out out T> bar() { } } fun test4(a: A) { - a.bar<out out Int>() + a.bar<out out Int>() } diff --git a/compiler/testData/diagnostics/tests/modifiers/repeatedModifiers.kt b/compiler/testData/diagnostics/tests/modifiers/repeatedModifiers.kt index 2571fbee5cf..eaefcd60fbc 100644 --- a/compiler/testData/diagnostics/tests/modifiers/repeatedModifiers.kt +++ b/compiler/testData/diagnostics/tests/modifiers/repeatedModifiers.kt @@ -1,41 +1,41 @@ -abstract abstract class Foo -public public class Bar -open open final class Baz { - private private fun foo() {} +abstract abstract class Foo +public public class Bar +open open final class Baz { + private private fun foo() {} } -class Bzz(public public val q: Int = 1) { - public public val x: Int = 2 +class Bzz(public public val q: Int = 1) { + public public val x: Int = 2 public val y: Int - public public get() = 3 + public public get() = 3 val z: Int - open final get() = 4 + open final get() = 4 - public public class B(public public val z: Int = 1) { - public public val y: Int = 2 + public public class B(public public val z: Int = 1) { + public public val y: Int = 2 public val x: Int - public public get() = 3 + public public get() = 3 } - public public object C { - public public val y: Int = 1 - public public fun z(): Int = 1 + public public object C { + public public val y: Int = 1 + public public fun z(): Int = 1 } } -public public val bar: Int = 1 +public public val bar: Int = 1 -public public fun foo(): Int = 1 +public public fun foo(): Int = 1 fun test() { - public public class B(public public val z: Int = 1) { - public public val y: Int = 2 + public public class B(public public val z: Int = 1) { + public public val y: Int = 2 public val x: Int - public public get() = 3 + public public get() = 3 } } diff --git a/compiler/testData/diagnostics/tests/scopes/visibility.kt b/compiler/testData/diagnostics/tests/scopes/visibility.kt index b20b2763ad6..5404053db72 100644 --- a/compiler/testData/diagnostics/tests/scopes/visibility.kt +++ b/compiler/testData/diagnostics/tests/scopes/visibility.kt @@ -1,11 +1,11 @@ //FILE:a.kt package test_visibility -protected class ProtectedClass -protected interface ProtectedTrait +protected class ProtectedClass +protected interface ProtectedTrait -protected val protected_val : Int = 4 -protected fun protected_fun() {} +protected val protected_val : Int = 4 +protected fun protected_fun() {} private val private_val : Int = 4 private fun private_fun() {} diff --git a/compiler/testData/diagnostics/tests/sealed/NeverEnum.kt b/compiler/testData/diagnostics/tests/sealed/NeverEnum.kt index bac4bed5130..6143254681d 100644 --- a/compiler/testData/diagnostics/tests/sealed/NeverEnum.kt +++ b/compiler/testData/diagnostics/tests/sealed/NeverEnum.kt @@ -1,4 +1,4 @@ -sealed enum class SealedEnum { +sealed enum class SealedEnum { FIRST, SECOND; diff --git a/compiler/testData/diagnostics/tests/sealed/NeverFinal.kt b/compiler/testData/diagnostics/tests/sealed/NeverFinal.kt index f1fe4036d56..8dc1fad9a32 100644 --- a/compiler/testData/diagnostics/tests/sealed/NeverFinal.kt +++ b/compiler/testData/diagnostics/tests/sealed/NeverFinal.kt @@ -1,3 +1,3 @@ -final sealed class Base { +final sealed class Base { } \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/sealed/NeverInterface.kt b/compiler/testData/diagnostics/tests/sealed/NeverInterface.kt index 146bff3e649..b22a4a90a43 100644 --- a/compiler/testData/diagnostics/tests/sealed/NeverInterface.kt +++ b/compiler/testData/diagnostics/tests/sealed/NeverInterface.kt @@ -1,3 +1,3 @@ -sealed interface Base { +sealed interface Base { } diff --git a/compiler/testData/diagnostics/tests/sealed/NeverObject.kt b/compiler/testData/diagnostics/tests/sealed/NeverObject.kt index 8cde5f8bbb6..fb3c58456a8 100644 --- a/compiler/testData/diagnostics/tests/sealed/NeverObject.kt +++ b/compiler/testData/diagnostics/tests/sealed/NeverObject.kt @@ -1,3 +1,3 @@ -sealed object Sealed { +sealed object Sealed { } diff --git a/compiler/testData/diagnostics/tests/sealed/NeverOpen.kt b/compiler/testData/diagnostics/tests/sealed/NeverOpen.kt index ee1ec2d1347..6b92d13dbbc 100644 --- a/compiler/testData/diagnostics/tests/sealed/NeverOpen.kt +++ b/compiler/testData/diagnostics/tests/sealed/NeverOpen.kt @@ -1,3 +1,3 @@ -open sealed class Base { +open sealed class Base { } \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/sealed/RedundantAbstract.kt b/compiler/testData/diagnostics/tests/sealed/RedundantAbstract.kt index d4bf9e9848f..c4ee1cfbb91 100644 --- a/compiler/testData/diagnostics/tests/sealed/RedundantAbstract.kt +++ b/compiler/testData/diagnostics/tests/sealed/RedundantAbstract.kt @@ -1,3 +1,3 @@ -abstract sealed class Base { +abstract sealed class Base { } \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/valOrValAndModifiersInCtr.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/valOrValAndModifiersInCtr.kt index fcdbb1b3833..d9a388c61bd 100644 --- a/compiler/testData/diagnostics/tests/secondaryConstructors/valOrValAndModifiersInCtr.kt +++ b/compiler/testData/diagnostics/tests/secondaryConstructors/valOrValAndModifiersInCtr.kt @@ -3,5 +3,5 @@ class A { constructor( val x: Int, y: Int, var z: Int, - public a: Int) + public a: Int) } diff --git a/compiler/testData/diagnostics/testsWithStdLib/instar.kt b/compiler/testData/diagnostics/testsWithStdLib/instar.kt index 816e423619f..daa63d51d3d 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/instar.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/instar.kt @@ -3,7 +3,7 @@ import java.util.ArrayList abstract class J { - public abstract fun , S : List<in *>> foo(x: T) + public abstract fun , S : List<in *>> foo(x: T) fun bar() { val s = ArrayList>() foo(s) diff --git a/compiler/testData/diagnostics/testsWithStdLib/outstar.kt b/compiler/testData/diagnostics/testsWithStdLib/outstar.kt index 149aa4df681..1bed3baf38b 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/outstar.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/outstar.kt @@ -3,7 +3,7 @@ import java.util.ArrayList abstract class J { - public abstract fun , S : List<out *>> foo(x: T) + public abstract fun , S : List<out *>> foo(x: T) fun bar() { val s = ArrayList>() foo(s) diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/KotlinTarget.kt b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/KotlinTarget.kt index 4712af9fadb..90549ba3f6c 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/KotlinTarget.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/KotlinTarget.kt @@ -16,26 +16,52 @@ package org.jetbrains.kotlin.descriptors.annotations +import org.jetbrains.kotlin.descriptors.ClassDescriptor +import org.jetbrains.kotlin.descriptors.ClassKind +import org.jetbrains.kotlin.resolve.DescriptorUtils import java.util.* -import kotlin.annotation -// NOTE: this enum must have the same entries with kotlin.annotation.AnnotationTarget +// NOTE: this enum must have the same entries with kotlin.annotation.AnnotationTarget, +// and may also have some additional entries public enum class KotlinTarget(val description: String, val isDefault: Boolean = true) { PACKAGE("package"), - CLASSIFIER("classifier"), + CLASSIFIER("classifier"), // includes CLASS, OBJECT, INTERFACE, *_CLASS but not ENUM_ENTRY ANNOTATION_CLASS("annotation class"), TYPE_PARAMETER("type parameter", false), - PROPERTY("property"), + PROPERTY("property"), // includes *_PROPERTY, PROPERTY_PARAMETER, ENUM_ENTRY FIELD("field"), LOCAL_VARIABLE("local variable"), VALUE_PARAMETER("value parameter"), CONSTRUCTOR("constructor"), - FUNCTION("function"), + FUNCTION("function"), // includes *_FUNCTION PROPERTY_GETTER("getter"), PROPERTY_SETTER("setter"), TYPE("type usage", false), EXPRESSION("expression", false), - FILE("file", false); + FILE("file", false), + + TYPE_PROJECTION("type projection", false), + STAR_PROJECTION("star projection", false), + PROPERTY_PARAMETER("property constructor parameter", false), + + CLASS("class", false), + OBJECT("object", false), + INTERFACE("interface", false), + ENUM_CLASS("enum class", false), + ENUM_ENTRY("enum entry", false), + + INNER_CLASS("inner class", false), + LOCAL_CLASS("local class", false), + + LOCAL_FUNCTION("local function", false), + MEMBER_FUNCTION("member function", false), + TOP_LEVEL_FUNCTION("top level function", false), + + MEMBER_PROPERTY("member property", false), // includes PROPERTY_PARAMETER + TOP_LEVEL_PROPERTY("top level property", false), + + INITIALIZER("initializer", false) + ; companion object { @@ -53,5 +79,21 @@ public enum class KotlinTarget(val description: String, val isDefault: Boolean = public val ALL_TARGET_SET: Set = values().toSet() + public fun classActualTargets(descriptor: ClassDescriptor): List = when (descriptor.kind) { + ClassKind.ANNOTATION_CLASS -> listOf(ANNOTATION_CLASS, CLASSIFIER) + ClassKind.CLASS -> if (descriptor.isInner) { + listOf(INNER_CLASS, CLASSIFIER) + } + else if (DescriptorUtils.isLocal(descriptor)) { + listOf(LOCAL_CLASS, CLASSIFIER) + } + else { + listOf(CLASS, CLASSIFIER) + } + ClassKind.OBJECT -> listOf(OBJECT, CLASSIFIER) + ClassKind.INTERFACE -> listOf(INTERFACE, CLASSIFIER) + ClassKind.ENUM_CLASS -> listOf(ENUM_CLASS, CLASSIFIER) + ClassKind.ENUM_ENTRY -> listOf(ENUM_ENTRY, PROPERTY, FIELD) + } } } \ No newline at end of file diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixRegistrar.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixRegistrar.kt index 5ec428d76be..5e0e921b6ea 100644 --- a/idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixRegistrar.kt +++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixRegistrar.kt @@ -115,6 +115,8 @@ public class QuickFixRegistrar : QuickFixContributor { GETTER_VISIBILITY_DIFFERS_FROM_PROPERTY_VISIBILITY.registerFactory(removeModifierFactory) REDUNDANT_MODIFIER_IN_GETTER.registerFactory(removeRedundantModifierFactory) ILLEGAL_MODIFIER.registerFactory(removeModifierFactory) + WRONG_MODIFIER_TARGET.registerFactory(removeModifierFactory) + WRONG_MODIFIER_CONTAINING_DECLARATION.registerFactory(removeModifierFactory) REPEATED_MODIFIER.registerFactory(removeModifierFactory) val removeInnerModifierFactory = RemoveModifierFix.createRemoveModifierFromListOwnerFactory(INNER_KEYWORD) diff --git a/idea/testData/checker/ClassObjects.kt b/idea/testData/checker/ClassObjects.kt index edc6e74ec34..c520ddbf85b 100644 --- a/idea/testData/checker/ClassObjects.kt +++ b/idea/testData/checker/ClassObjects.kt @@ -14,7 +14,7 @@ class B() { } object b { - companion object { + companion object { val x = 1 } // error diff --git a/idea/testData/checker/PlatformStaticUsagesRuntime.kt b/idea/testData/checker/PlatformStaticUsagesRuntime.kt index 7f1f2b9c323..aac4ba83248 100644 --- a/idea/testData/checker/PlatformStaticUsagesRuntime.kt +++ b/idea/testData/checker/PlatformStaticUsagesRuntime.kt @@ -1,15 +1,15 @@ import kotlin.platform.platformStatic -platformStatic +platformStatic class A { - platformStatic + platformStatic companion object { platformStatic fun a1() { } } - platformStatic + platformStatic object A { platformStatic fun a2() { @@ -29,7 +29,7 @@ class A { } } -platformStatic +platformStatic interface B { companion object { platformStatic fun a1() { diff --git a/j2k/testData/fileOrElement/annotations/annotationInterface3.kt b/j2k/testData/fileOrElement/annotations/annotationInterface3.kt index 79b2338b2aa..40a676a0d58 100644 --- a/j2k/testData/fileOrElement/annotations/annotationInterface3.kt +++ b/j2k/testData/fileOrElement/annotations/annotationInterface3.kt @@ -1,4 +1,5 @@ // ERROR: Body is not allowed for annotation class +// ERROR: Modifier 'companion' is not applicable inside 'annotation class' annotation class Anon(public val value: String) { public enum class E { diff --git a/js/js.translator/testData/delegation/cases/delegation4.kt b/js/js.translator/testData/delegation/cases/delegation4.kt index 3b619332d8b..44d03d992f7 100644 --- a/js/js.translator/testData/delegation/cases/delegation4.kt +++ b/js/js.translator/testData/delegation/cases/delegation4.kt @@ -1,11 +1,11 @@ // This test was adapted from compiler/testData/codegen/box/classes package foo -open trait First { +interface First { public open fun foo(): Int } -open trait Second : First { +interface Second : First { public open fun bar(): Int } diff --git a/js/js.translator/testData/inlineMultiFile/cases/use/use.2.kt b/js/js.translator/testData/inlineMultiFile/cases/use/use.2.kt index 35715359e72..2af5e33df5d 100644 --- a/js/js.translator/testData/inlineMultiFile/cases/use/use.2.kt +++ b/js/js.translator/testData/inlineMultiFile/cases/use/use.2.kt @@ -15,7 +15,7 @@ public class Output(val d: Data) : Closeable { public fun doOutput(data: Int): Int = data } -public open trait Closeable { +public interface Closeable { open public fun close() {} } diff --git a/js/js.translator/testData/inlineMultiFile/cases/with/with.2.kt b/js/js.translator/testData/inlineMultiFile/cases/with/with.2.kt index 67c32c70e78..e5728117fbc 100644 --- a/js/js.translator/testData/inlineMultiFile/cases/with/with.2.kt +++ b/js/js.translator/testData/inlineMultiFile/cases/with/with.2.kt @@ -16,7 +16,7 @@ public class Output(val d: Data) : Closeable { public fun doOutput(data: Int): Int = data } -public open trait Closeable { +public interface Closeable { open public fun close() {} }