azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Regular modifier checker implemented (initial version). A set of tests fixed accordingly.

Browse Source 
Most of modifier diagnostic is expressed by REDUNDANT_MODIFIER, INCOMPATIBLE_MODIFIERS, REPEATED_MODIFIER, WRONG_MODIFIER_TARGET, WRONG_MODIFIER_PARENT.
A set of modifier diagnostics is not in use now (but not deleted yet).
This commit is contained in:
Mikhail Glukhikh
2015-06-16 13:08:05 +03:00
parent faac06ff7e
commit 4bd48c4796
67 changed files with 588 additions and 616 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java
+3 -1
View File
@@ -108,10 +108,12 @@ public interface Errors {
// Modifiers
DiagnosticFactory1<PsiElement, Collection<JetModifierKeywordToken>> INCOMPATIBLE_MODIFIERS = DiagnosticFactory1.create(ERROR);
DiagnosticFactory2<PsiElement, JetModifierKeywordToken, JetModifierKeywordToken> INCOMPATIBLE_MODIFIERS = DiagnosticFactory2.create(ERROR);
DiagnosticFactory1<PsiElement, JetModifierKeywordToken> ILLEGAL_MODIFIER = DiagnosticFactory1.create(ERROR);
DiagnosticFactory1<PsiElement, JetModifierKeywordToken> REPEATED_MODIFIER = DiagnosticFactory1.create(ERROR);
DiagnosticFactory2<PsiElement, JetModifierKeywordToken, JetModifierKeywordToken> REDUNDANT_MODIFIER = DiagnosticFactory2.create(WARNING);
DiagnosticFactory2<PsiElement, JetModifierKeywordToken, String> WRONG_MODIFIER_TARGET = DiagnosticFactory2.create(ERROR);
DiagnosticFactory2<PsiElement, JetModifierKeywordToken, String> WRONG_MODIFIER_CONTAINING_DECLARATION = DiagnosticFactory2.create(ERROR);
DiagnosticFactory0<PsiElement> INAPPLICABLE_PLATFORM_NAME = DiagnosticFactory0.create(ERROR);
DiagnosticFactory1<JetAnnotationEntry, String> WRONG_ANNOTATION_TARGET = DiagnosticFactory1.create(ERROR);
DiagnosticFactory0<JetAnnotationEntry> REPEATED_ANNOTATION = DiagnosticFactory0.create(ERROR);
compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java
+3 -14
View File
@@ -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<Collection<JetModifierKeywordToken>>() {
@NotNull
@Override
public String render(@NotNull Collection<JetModifierKeywordToken> 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");
compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationChecker.kt
+34 -31
View File
@@ -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<KotlinTarget> {
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<KotlinTarget> {
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()
}
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java
+2 -2
View File
@@ -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) {
compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.java
+2 -65
View File
@@ -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
compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt
-11
View File
@@ -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)
}
}
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.java
+11 -197
View File
@@ -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<JetModifierKeywordToken> MODALITY_MODIFIERS =
@@ -189,175 +185,29 @@ public class ModifiersChecker {
}
}
public void reportIllegalModifiers(
@Nullable JetModifierList modifierList,
@NotNull Collection<JetModifierKeywordToken> 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<JetModifierKeywordToken> illegalModifiers
) {
reportIllegalModifiers(modifierListOwner.getModifierList(), illegalModifiers);
}
public void checkIncompatibleModifiers(
@Nullable JetModifierList modifierList,
@NotNull Collection<JetModifierKeywordToken> availableModifiers,
@NotNull Collection<JetModifierKeywordToken>... availableCombinations
) {
if (modifierList == null) return;
Collection<JetModifierKeywordToken> presentModifiers = Sets.newLinkedHashSet();
for (JetModifierKeywordToken modifier : availableModifiers) {
if (modifierList.hasModifier(modifier)) {
presentModifiers.add(modifier);
}
}
checkRepeatedModifiers(modifierList, availableModifiers);
if (presentModifiers.size() == 1) {
return;
}
for (Collection<JetModifierKeywordToken> 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<JetModifierKeywordToken> availableModifiers
) {
for (JetModifierKeywordToken token : availableModifiers) {
if (!modifierList.hasModifier(token)) continue;
List<ASTNode> 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<JetModifierKeywordToken> availableModifiers,
Collection<JetModifierKeywordToken>... availableCombinations
) {
checkIncompatibleModifiers(modifierList, availableModifiers, availableCombinations);
}
private void checkRedundantModifier(
@NotNull JetModifierList modifierList,
Pair<JetModifierKeywordToken, JetModifierKeywordToken>... redundantBundles
) {
for (Pair<JetModifierKeywordToken, JetModifierKeywordToken> 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<JetModifierKeywordToken, ASTNode> 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<JetTypeParameter> 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
compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.kt
+203
View File
@@ -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<JetModifierKeywordToken, Set<KotlinTarget>>(
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<JetModifierKeywordToken, Set<KotlinTarget>>(
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<Pair<JetModifierKeywordToken, JetModifierKeywordToken>, Compatibility> {
val result = hashMapOf<Pair<JetModifierKeywordToken, JetModifierKeywordToken>, 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<Pair<JetModifierKeywordToken, JetModifierKeywordToken>, Compatibility> {
return mapOf(Pair(sufficient, redundant) to Compatibility.REDUNDANT,
Pair(redundant, sufficient) to Compatibility.REVERSE_REDUNDANT)
}
private fun incompatibilityRegister(
list: List<JetModifierKeywordToken>
): Map<Pair<JetModifierKeywordToken, JetModifierKeywordToken>, Compatibility> {
val result = hashMapOf<Pair<JetModifierKeywordToken, JetModifierKeywordToken>, 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<ASTNode>) {
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<KotlinTarget>): 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<KotlinTarget> = 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<KotlinTarget>) {
val incorrectNodes = hashSetOf<ASTNode>()
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)
}
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt
+1 -3
View File
@@ -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]
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt
+1 -1
View File
@@ -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,
compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java
+1 -5
View File
@@ -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);
}
compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingVisitor.java
+2 -5
View File
@@ -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);
compiler/testData/cli/jvm/multipleTextRangesInDiagnosticsOrder.out
Vendored
+2 -2
View File
@@ -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
compiler/testData/codegen/box/classes/delegation4.kt
Vendored
+2 -2
View File
@@ -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
}
compiler/testData/codegen/box/superConstructorCall/deepLocalHierarchy.kt
Vendored
+1 -1
View File
@@ -1,5 +1,5 @@
fun box(): String {
open interface L1 {
interface L1 {
fun foo(): String
}
compiler/testData/codegen/boxInline/complex/use.2.kt
Vendored
+1 -1
View File
@@ -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() {}
}
compiler/testData/codegen/boxInline/complex/with.2.kt
Vendored
+1 -1
View File
@@ -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() {}
}
compiler/testData/diagnostics/tests/Abstract.kt
Vendored
+19 -19
View File
@@ -3,44 +3,44 @@ package MyPackage
//properties
<!MUST_BE_INITIALIZED!>val a: Int<!>
val a1: Int = 1
<!MUST_BE_INITIALIZED!><!ILLEGAL_MODIFIER!>abstract<!> val a2: Int<!>
<!ILLEGAL_MODIFIER!>abstract<!> val a3: Int = 1
<!MUST_BE_INITIALIZED!><!WRONG_MODIFIER_TARGET!>abstract<!> val a2: Int<!>
<!WRONG_MODIFIER_TARGET!>abstract<!> val a3: Int = 1
<!MUST_BE_INITIALIZED!>var b: Int<!> private set
var b1: Int = 0; private set
<!MUST_BE_INITIALIZED!><!ILLEGAL_MODIFIER!>abstract<!> var b2: Int<!> private set
<!ILLEGAL_MODIFIER!>abstract<!> var b3: Int = 0; private set
<!MUST_BE_INITIALIZED!><!WRONG_MODIFIER_TARGET!>abstract<!> var b2: Int<!> private set
<!WRONG_MODIFIER_TARGET!>abstract<!> var b3: Int = 0; private set
<!MUST_BE_INITIALIZED!>var c: Int<!> set(v: Int) { $c = v }
var c1: Int = 0; set(v: Int) { $c1 = v }
<!MUST_BE_INITIALIZED!><!ILLEGAL_MODIFIER!>abstract<!> var c2: Int<!> set(v: Int) { $c2 = v }
<!ILLEGAL_MODIFIER!>abstract<!> var c3: Int = 0; set(v: Int) { $c3 = v }
<!MUST_BE_INITIALIZED!><!WRONG_MODIFIER_TARGET!>abstract<!> var c2: Int<!> set(v: Int) { $c2 = v }
<!WRONG_MODIFIER_TARGET!>abstract<!> var c3: Int = 0; set(v: Int) { $c3 = v }
val e: Int get() = a
val e1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; get() = a
<!ILLEGAL_MODIFIER!>abstract<!> val e2: Int get() = a
<!ILLEGAL_MODIFIER!>abstract<!> val e3: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; get() = a
<!WRONG_MODIFIER_TARGET!>abstract<!> val e2: Int get() = a
<!WRONG_MODIFIER_TARGET!>abstract<!> val e3: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; get() = a
//methods
<!NON_MEMBER_FUNCTION_NO_BODY!>fun f()<!>
fun g() {}
<!ILLEGAL_MODIFIER!>abstract<!> fun h()
<!ILLEGAL_MODIFIER!>abstract<!> fun j() {}
<!WRONG_MODIFIER_TARGET!>abstract<!> fun h()
<!WRONG_MODIFIER_TARGET!>abstract<!> fun j() {}
//property accessors
var i: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var i1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var i: Int <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set
var i1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set
var j: Int get() = i; <!ILLEGAL_MODIFIER!>abstract<!> set
var j1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; get() = i; <!ILLEGAL_MODIFIER!>abstract<!> set
var j: Int get() = i; <!WRONG_MODIFIER_TARGET!>abstract<!> set
var j1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; get() = i; <!WRONG_MODIFIER_TARGET!>abstract<!> set
<!MUST_BE_INITIALIZED!>var k: Int<!> <!ILLEGAL_MODIFIER!>abstract<!> set
var k1: Int = 0; <!ILLEGAL_MODIFIER!>abstract<!> set
<!MUST_BE_INITIALIZED!>var k: Int<!> <!WRONG_MODIFIER_TARGET!>abstract<!> set
var k1: Int = 0; <!WRONG_MODIFIER_TARGET!>abstract<!> set
var l: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var l1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var l: Int <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set
var l1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set
var n: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set(v: Int) {}
var n: Int <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set(v: Int) {}
// FILE: c.kt
//creating an instance
compiler/testData/diagnostics/tests/AbstractInAbstractClass.kt
Vendored
+9 -9
View File
@@ -29,17 +29,17 @@ abstract class MyAbstractClass() {
<!ABSTRACT_FUNCTION_WITH_BODY!>abstract<!> fun j() {}
//property accessors
var i: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var i1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var i: Int <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set
var i1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set
var j: Int get() = i; <!ILLEGAL_MODIFIER!>abstract<!> set
var j1: Int get() = i; <!ILLEGAL_MODIFIER!>abstract<!> set
var j: Int get() = i; <!WRONG_MODIFIER_TARGET!>abstract<!> set
var j1: Int get() = i; <!WRONG_MODIFIER_TARGET!>abstract<!> set
<!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>var k: Int<!> <!ILLEGAL_MODIFIER!>abstract<!> set
var k1: Int = 0; <!ILLEGAL_MODIFIER!>abstract<!> set
<!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>var k: Int<!> <!WRONG_MODIFIER_TARGET!>abstract<!> set
var k1: Int = 0; <!WRONG_MODIFIER_TARGET!>abstract<!> set
var l: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var l1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var l: Int <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set
var l1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set
var n: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set(v: Int) {}
var n: Int <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set(v: Int) {}
}
compiler/testData/diagnostics/tests/AbstractInClass.kt
Vendored
+9 -9
View File
@@ -29,17 +29,17 @@ class MyClass() {
<!ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS, ABSTRACT_FUNCTION_WITH_BODY!>abstract<!> fun j() {}
//property accessors
var i: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var i1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var i: Int <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set
var i1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set
var j: Int get() = i; <!ILLEGAL_MODIFIER!>abstract<!> set
var j1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; get() = i; <!ILLEGAL_MODIFIER!>abstract<!> set
var j: Int get() = i; <!WRONG_MODIFIER_TARGET!>abstract<!> set
var j1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; get() = i; <!WRONG_MODIFIER_TARGET!>abstract<!> set
<!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>var k: Int<!> <!ILLEGAL_MODIFIER!>abstract<!> set
var k1: Int = 0; <!ILLEGAL_MODIFIER!>abstract<!> set
<!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>var k: Int<!> <!WRONG_MODIFIER_TARGET!>abstract<!> set
var k1: Int = 0; <!WRONG_MODIFIER_TARGET!>abstract<!> set
var l: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var l1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var l: Int <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set
var l1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set
var n: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set(v: Int) {}
var n: Int <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set(v: Int) {}
}
compiler/testData/diagnostics/tests/AbstractInTrait.kt
Vendored
+9 -9
View File
@@ -29,17 +29,17 @@ interface MyTrait {
<!ABSTRACT_MODIFIER_IN_TRAIT, ABSTRACT_FUNCTION_WITH_BODY!>abstract<!> fun j() {}
//property accessors
var i: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var i1: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>0<!>; <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var i: Int <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set
var i1: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>0<!>; <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set
var j: Int get() = i; <!ILLEGAL_MODIFIER!>abstract<!> set
var j1: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>0<!>; get() = i; <!ILLEGAL_MODIFIER!>abstract<!> set
var j: Int get() = i; <!WRONG_MODIFIER_TARGET!>abstract<!> set
var j1: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>0<!>; get() = i; <!WRONG_MODIFIER_TARGET!>abstract<!> set
var k: Int <!ILLEGAL_MODIFIER!>abstract<!> set
var k1: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>0<!>; <!ILLEGAL_MODIFIER!>abstract<!> set
var k: Int <!WRONG_MODIFIER_TARGET!>abstract<!> set
var k1: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>0<!>; <!WRONG_MODIFIER_TARGET!>abstract<!> set
var l: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var l1: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>0<!>; <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var l: Int <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set
var l1: Int = <!PROPERTY_INITIALIZER_IN_TRAIT!>0<!>; <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set
var n: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set(v: Int) {}
var n: Int <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set(v: Int) {}
}
compiler/testData/diagnostics/tests/annotations/kt1886annotationBody.kt
Vendored
+1 -1
View File
@@ -11,7 +11,7 @@ annotation class Annotation4() <!ANNOTATION_CLASS_WITH_BODY!>{
}<!>
annotation class Annotation5() <!ANNOTATION_CLASS_WITH_BODY!>{
companion object {}
<!WRONG_MODIFIER_CONTAINING_DECLARATION!>companion<!> object {}
}<!>
annotation class Annotation6() <!ANNOTATION_CLASS_WITH_BODY!>{
compiler/testData/diagnostics/tests/annotations/onInitializer.kt
Vendored
+4 -4
View File
@@ -1,15 +1,15 @@
class A {
<!WRONG_ANNOTATION_TARGET!>ann<!> init {}
<!WRONG_ANNOTATION_TARGET!>@ann<!> init {}
<!UNRESOLVED_REFERENCE, WRONG_ANNOTATION_TARGET!>aaa<!> init {}
<!UNRESOLVED_REFERENCE, WRONG_ANNOTATION_TARGET!>@aaa<!> init {}
<!WRONG_ANNOTATION_TARGET, UNRESOLVED_REFERENCE!>aaa<!> init {}
<!WRONG_ANNOTATION_TARGET, UNRESOLVED_REFERENCE!>@aaa<!> init {}
}
interface T {
<!ANONYMOUS_INITIALIZER_IN_TRAIT!><!WRONG_ANNOTATION_TARGET!>ann<!> init {}<!>
<!ANONYMOUS_INITIALIZER_IN_TRAIT!><!WRONG_ANNOTATION_TARGET!>@ann<!> init {}<!>
<!ANONYMOUS_INITIALIZER_IN_TRAIT!><!UNRESOLVED_REFERENCE, WRONG_ANNOTATION_TARGET!>aaa<!> init {}<!>
<!ANONYMOUS_INITIALIZER_IN_TRAIT!><!UNRESOLVED_REFERENCE, WRONG_ANNOTATION_TARGET!>@aaa<!> init {}<!>
<!ANONYMOUS_INITIALIZER_IN_TRAIT!><!WRONG_ANNOTATION_TARGET, UNRESOLVED_REFERENCE!>aaa<!> init {}<!>
<!ANONYMOUS_INITIALIZER_IN_TRAIT!><!WRONG_ANNOTATION_TARGET, UNRESOLVED_REFERENCE!>@aaa<!> init {}<!>
}
annotation class ann
compiler/testData/diagnostics/tests/classObjects/ClassObjects.kt
Vendored
+1 -1
View File
@@ -26,7 +26,7 @@ class B() {
}
object b {
<!COMPANION_OBJECT_NOT_ALLOWED!>companion<!> object {
<!WRONG_MODIFIER_CONTAINING_DECLARATION!>companion<!> object {
val x = 1
} // error
}
compiler/testData/diagnostics/tests/classObjects/InnerClassClassObject.kt
Vendored
+1 -1
View File
@@ -2,7 +2,7 @@
class A {
inner class B {
<!COMPANION_OBJECT_NOT_ALLOWED!>companion<!> object { }
<!WRONG_MODIFIER_CONTAINING_DECLARATION!>companion<!> object { }
}
}
compiler/testData/diagnostics/tests/classObjects/classObjectInLocalClass.kt
Vendored
+2 -2
View File
@@ -1,9 +1,9 @@
fun test() {
class A {
<!COMPANION_OBJECT_NOT_ALLOWED!>companion<!> object {}
<!WRONG_MODIFIER_CONTAINING_DECLARATION!>companion<!> object {}
}
object {
<!COMPANION_OBJECT_NOT_ALLOWED!>companion<!> object {}
<!WRONG_MODIFIER_CONTAINING_DECLARATION!>companion<!> object {}
}
}
compiler/testData/diagnostics/tests/classObjects/multipleDissallowedDefaultObjects.kt
Vendored
+6 -6
View File
@@ -1,17 +1,17 @@
class A {
inner class I {
<!COMPANION_OBJECT_NOT_ALLOWED!>companion<!> object A
<!WRONG_MODIFIER_CONTAINING_DECLARATION!>companion<!> object A
<!MANY_COMPANION_OBJECTS, COMPANION_OBJECT_NOT_ALLOWED!>companion<!> object B
<!MANY_COMPANION_OBJECTS, WRONG_MODIFIER_CONTAINING_DECLARATION!>companion<!> object B
<!MANY_COMPANION_OBJECTS, COMPANION_OBJECT_NOT_ALLOWED!>companion<!> object C
<!MANY_COMPANION_OBJECTS, WRONG_MODIFIER_CONTAINING_DECLARATION!>companion<!> object C
}
}
object O {
<!COMPANION_OBJECT_NOT_ALLOWED!>companion<!> object A
<!WRONG_MODIFIER_CONTAINING_DECLARATION!>companion<!> object A
<!MANY_COMPANION_OBJECTS, COMPANION_OBJECT_NOT_ALLOWED!>companion<!> object B
<!MANY_COMPANION_OBJECTS, WRONG_MODIFIER_CONTAINING_DECLARATION!>companion<!> object B
<!MANY_COMPANION_OBJECTS, COMPANION_OBJECT_NOT_ALLOWED!>companion<!> object C
<!MANY_COMPANION_OBJECTS, WRONG_MODIFIER_CONTAINING_DECLARATION!>companion<!> object C
}
compiler/testData/diagnostics/tests/declarationChecks/ambiguousObjectExpressionType.kt
Vendored
+2 -2
View File
@@ -90,7 +90,7 @@ class Foo {
<!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>private val packagePrivateProperty<!> = object : MyClass(), MyTrait {}
<!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!><!PACKAGE_MEMBER_CANNOT_BE_PROTECTED!>protected<!> val packageProtectedProperty<!> = object : MyClass(), MyTrait {}
<!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!><!WRONG_MODIFIER_TARGET!>protected<!> val packageProtectedProperty<!> = object : MyClass(), MyTrait {}
<!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>val packageInternalProperty<!> = object : MyClass(), MyTrait {}
@@ -98,7 +98,7 @@ class Foo {
<!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!>public val packagePublicProperty<!> = object : MyClass(), MyTrait {}
<!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!><!PACKAGE_MEMBER_CANNOT_BE_PROTECTED!>protected<!> fun packageProtectedFunction()<!> = object : MyClass(), MyTrait {}
<!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!><!WRONG_MODIFIER_TARGET!>protected<!> fun packageProtectedFunction()<!> = object : MyClass(), MyTrait {}
<!AMBIGUOUS_ANONYMOUS_TYPE_INFERRED!>fun packageInternalFunction()<!> = object : MyClass(), MyTrait {}
compiler/testData/diagnostics/tests/declarationChecks/illegalModifiersOnClass.kt
Vendored
+12 -12
View File
@@ -2,18 +2,18 @@
// KT-3464 Front-end shouldn't allow override modifier in class declaration
<!ILLEGAL_MODIFIER!>override<!> class A {
<!ILLEGAL_MODIFIER!>override<!> companion object {}
<!ILLEGAL_MODIFIER!>open<!> companion object {}
<!ILLEGAL_MODIFIER!>abstract<!> companion object {}
<!ILLEGAL_MODIFIER!>final<!> companion object {}
<!WRONG_MODIFIER_TARGET!>override<!> class A {
<!WRONG_MODIFIER_TARGET!>override<!> companion object {}
<!WRONG_MODIFIER_TARGET!>open<!> companion object {}
<!WRONG_MODIFIER_TARGET!>abstract<!> companion object {}
<!WRONG_MODIFIER_TARGET!>final<!> companion object {}
}
<!ILLEGAL_MODIFIER!>override<!> object B1 {}
<!ILLEGAL_MODIFIER!>open<!> object B2 {}
<!ILLEGAL_MODIFIER!>abstract<!> object B3 {}
<!ILLEGAL_MODIFIER!>final<!> object B4 {}
<!WRONG_MODIFIER_TARGET!>override<!> object B1 {}
<!WRONG_MODIFIER_TARGET!>open<!> object B2 {}
<!WRONG_MODIFIER_TARGET!>abstract<!> object B3 {}
<!WRONG_MODIFIER_TARGET!>final<!> object B4 {}
<!ILLEGAL_MODIFIER!>override<!> enum class C {}
<!ILLEGAL_MODIFIER!>override<!> interface D {}
<!ILLEGAL_MODIFIER!>override<!> annotation class E
<!WRONG_MODIFIER_TARGET!>override<!> enum class C {}
<!WRONG_MODIFIER_TARGET!>override<!> interface D {}
<!WRONG_MODIFIER_TARGET!>override<!> annotation class E
compiler/testData/diagnostics/tests/declarationChecks/localDeclarationModifiers.kt
Vendored
+4 -4
View File
@@ -5,8 +5,8 @@ class T {
}
fun foo() {
<!ILLEGAL_MODIFIER!>public<!> val <!UNUSED_VARIABLE!>i<!> = 11
<!ILLEGAL_MODIFIER!>abstract<!> val <!VARIABLE_WITH_NO_TYPE_NO_INITIALIZER, UNUSED_VARIABLE!>j<!>
<!ILLEGAL_MODIFIER!>override<!> fun T.baz() = 2
<!ILLEGAL_MODIFIER!>private<!> fun bar() = 2
<!WRONG_MODIFIER_TARGET!>public<!> val <!UNUSED_VARIABLE!>i<!> = 11
<!WRONG_MODIFIER_TARGET!>abstract<!> val <!VARIABLE_WITH_NO_TYPE_NO_INITIALIZER, UNUSED_VARIABLE!>j<!>
<!WRONG_MODIFIER_TARGET!>override<!> fun T.baz() = 2
<!WRONG_MODIFIER_TARGET!>private<!> fun bar() = 2
}
compiler/testData/diagnostics/tests/declarationChecks/localFunctionNoInheritVisibility.kt
Vendored
+2 -2
View File
@@ -4,10 +4,10 @@ class T {
fun baz() = 1
}
<!ILLEGAL_MODIFIER!>override<!> fun zzz() {}
<!WRONG_MODIFIER_TARGET!>override<!> fun zzz() {}
fun foo(t: T) {
<!ILLEGAL_MODIFIER!>override<!> fun T.baz() = 2
<!WRONG_MODIFIER_TARGET!>override<!> fun T.baz() = 2
// was "Visibility is unknown yet exception"
t.baz()
compiler/testData/diagnostics/tests/declarationChecks/packageDeclarationModifiers.kt
Vendored
+5 -6
View File
@@ -1,13 +1,12 @@
package d
<!ILLEGAL_MODIFIER!>abstract<!> val a : Int = 1
<!WRONG_MODIFIER_TARGET!>abstract<!> val a : Int = 1
<!ILLEGAL_MODIFIER!>override<!> val c : Int = 1
<!WRONG_MODIFIER_TARGET!>override<!> val c : Int = 1
<!ILLEGAL_MODIFIER!>final<!> fun foo() = 2
<!WRONG_MODIFIER_TARGET!>final<!> fun foo() = 2
<!ILLEGAL_MODIFIER!>abstract<!> fun baz() = 2
<!WRONG_MODIFIER_TARGET!>abstract<!> fun baz() = 2
class T {}
<!ILLEGAL_MODIFIER!>override<!> fun T.bar() = 2
<!WRONG_MODIFIER_TARGET!>override<!> fun T.bar() = 2
compiler/testData/diagnostics/tests/declarationChecks/propertyInPackageHasNoInheritVisibility.kt
Vendored
+2 -2
View File
@@ -1,10 +1,10 @@
package d
<!ILLEGAL_MODIFIER!>override<!> val f : ()-> Int = { 12 }
<!WRONG_MODIFIER_TARGET!>override<!> val f : ()-> Int = { 12 }
fun test() {
f()
}
var g: Int = 1
<!PACKAGE_MEMBER_CANNOT_BE_PROTECTED!>protected<!> set(i: Int) {}
<!WRONG_MODIFIER_CONTAINING_DECLARATION!>protected<!> set(i: Int) {}
compiler/testData/diagnostics/tests/declarationChecks/unambiguousObjectExpressionType.kt
Vendored
+2 -2
View File
@@ -136,7 +136,7 @@ class Foo {
}
<!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!><!PACKAGE_MEMBER_CANNOT_BE_PROTECTED!>protected<!> val packageProtectedProperty<!> = object : MyClass() {}
<!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!><!WRONG_MODIFIER_TARGET!>protected<!> val packageProtectedProperty<!> = object : MyClass() {}
<!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!>public val packagePublicProperty<!> = object : MyClass() {}
@@ -164,7 +164,7 @@ fun testProperties() {
private fun privateFunction() = object : MyClass() {fun invisible() {}}
<!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!><!PACKAGE_MEMBER_CANNOT_BE_PROTECTED!>protected<!> fun protectedFunction()<!> = object : MyClass() {}
<!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!><!WRONG_MODIFIER_TARGET!>protected<!> fun protectedFunction()<!> = object : MyClass() {}
<!PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE!>public fun publicFunction()<!> = object : MyClass() {}
compiler/testData/diagnostics/tests/delegation/DelegationNotTotrait.kt
Vendored
+1 -1
View File
@@ -8,7 +8,7 @@ interface T {}
class Br(t : T) : T by t {}
<!OPEN_MODIFIER_IN_ENUM!>open<!> enum class EN() {
<!WRONG_MODIFIER_TARGET!>open<!> enum class EN() {
A
}
compiler/testData/diagnostics/tests/enum/AbstractEnum.kt
Vendored
+1 -1
View File
@@ -1,3 +1,3 @@
package abstract
<!ABSTRACT_MODIFIER_IN_ENUM!>abstract<!> enum class MyAbstractEnum() {}
<!WRONG_MODIFIER_TARGET!>abstract<!> enum class MyAbstractEnum() {}
compiler/testData/diagnostics/tests/enum/AbstractInEnum.kt
Vendored
+9 -9
View File
@@ -30,17 +30,17 @@ enum class MyEnum() {
<!ABSTRACT_FUNCTION_WITH_BODY!>abstract<!> fun j() {}
//property accessors
var i: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var i1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var i: Int <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set
var i1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set
var j: Int get() = i; <!ILLEGAL_MODIFIER!>abstract<!> set
var j1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; get() = i; <!ILLEGAL_MODIFIER!>abstract<!> set
var j: Int get() = i; <!WRONG_MODIFIER_TARGET!>abstract<!> set
var j1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; get() = i; <!WRONG_MODIFIER_TARGET!>abstract<!> set
<!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>var k: Int<!> <!ILLEGAL_MODIFIER!>abstract<!> set
var k1: Int = 0; <!ILLEGAL_MODIFIER!>abstract<!> set
<!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>var k: Int<!> <!WRONG_MODIFIER_TARGET!>abstract<!> set
var k1: Int = 0; <!WRONG_MODIFIER_TARGET!>abstract<!> set
var l: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var l1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
var l: Int <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set
var l1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set
var n: Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set(v: Int) {}
var n: Int <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set(v: Int) {}
}
compiler/testData/diagnostics/tests/enum/enumEntryCannotHaveClassObject.kt
Vendored
+1 -1
View File
@@ -2,7 +2,7 @@ enum class E {
FIRST,
SECOND {
<!COMPANION_OBJECT_NOT_ALLOWED!>companion<!> object {
<!WRONG_MODIFIER_CONTAINING_DECLARATION!>companion<!> object {
fun foo() = 42
}
};
compiler/testData/diagnostics/tests/enum/enumModifier.kt
Vendored
+6 -6
View File
@@ -1,15 +1,15 @@
enum class B {}
class A {
<!ILLEGAL_ENUM_ANNOTATION!>enum<!> companion object {}
<!WRONG_MODIFIER_TARGET!>enum<!> companion object {}
}
<!ILLEGAL_ENUM_ANNOTATION!>enum<!> object O {}
<!WRONG_MODIFIER_TARGET!>enum<!> object O {}
<!ILLEGAL_ENUM_ANNOTATION!>enum<!> interface T {}
<!WRONG_MODIFIER_TARGET!>enum<!> interface T {}
<!ILLEGAL_ENUM_ANNOTATION!>enum<!> fun f() = 0
<!WRONG_MODIFIER_TARGET!>enum<!> fun f() = 0
<!ILLEGAL_ENUM_ANNOTATION!>enum<!> val x = 0
<!WRONG_MODIFIER_TARGET!>enum<!> val x = 0
<!ILLEGAL_ENUM_ANNOTATION!>enum<!> var y = 0
<!WRONG_MODIFIER_TARGET!>enum<!> var y = 0
compiler/testData/diagnostics/tests/enum/inheritanceFromEnum.kt
Vendored
+1 -1
View File
@@ -2,7 +2,7 @@
public enum MyJavaEnum {}
// FILE: test.kt
<!OPEN_MODIFIER_IN_ENUM!>open<!> enum class MyEnum() {
<!WRONG_MODIFIER_TARGET!>open<!> enum class MyEnum() {
A()
}
compiler/testData/diagnostics/tests/enum/interfaceWithEnumKeyword.kt
Vendored
+1 -1
View File
@@ -1,4 +1,4 @@
<!ILLEGAL_ENUM_ANNOTATION!>enum<!> interface Some {
<!WRONG_MODIFIER_TARGET!>enum<!> interface Some {
// Enum part
<!ABSTRACT_MEMBER_NOT_IMPLEMENTED, ENUM_ENTRY_USES_DEPRECATED_OR_NO_DELIMITER!>D<!>
compiler/testData/diagnostics/tests/enum/modifiersOnEnumEntry.kt
Vendored
+15 -15
View File
@@ -1,23 +1,23 @@
enum class E {
<!ILLEGAL_MODIFIER!>public<!> <!ILLEGAL_MODIFIER!>final<!> SUBCLASS {
<!WRONG_MODIFIER_TARGET!>public<!> <!WRONG_MODIFIER_TARGET!>final<!> SUBCLASS {
fun foo() {}
},
<!ILLEGAL_MODIFIER!>public<!> PUBLIC,
<!ILLEGAL_MODIFIER!>protected<!> PROTECTED,
<!ILLEGAL_MODIFIER!>private<!> PRIVATE,
<!ILLEGAL_MODIFIER!>internal<!> INTERNAL,
<!WRONG_MODIFIER_TARGET!>public<!> PUBLIC,
<!WRONG_MODIFIER_TARGET!>protected<!> PROTECTED,
<!WRONG_MODIFIER_TARGET!>private<!> PRIVATE,
<!WRONG_MODIFIER_TARGET!>internal<!> INTERNAL,
<!ILLEGAL_MODIFIER!>abstract<!> ABSTRACT,
<!ILLEGAL_MODIFIER!>open<!> OPEN,
<!ILLEGAL_MODIFIER!>override<!> OVERRIDE,
<!ILLEGAL_MODIFIER!>final<!> FINAL,
<!WRONG_MODIFIER_TARGET!>abstract<!> ABSTRACT,
<!WRONG_MODIFIER_TARGET!>open<!> OPEN,
<!WRONG_MODIFIER_TARGET!>override<!> OVERRIDE,
<!WRONG_MODIFIER_TARGET!>final<!> FINAL,
<!ILLEGAL_MODIFIER!>inner<!> INNER,
<!WRONG_MODIFIER_TARGET!>inner<!> INNER,
<!ENUM_ENTRY_USES_DEPRECATED_OR_NO_DELIMITER!>annotation<!> ANNOTATION,
<!ILLEGAL_MODIFIER!>enum<!> ENUM,
<!ILLEGAL_MODIFIER!>out<!> OUT,
<!ILLEGAL_MODIFIER!>in<!> IN,
<!ILLEGAL_MODIFIER!>vararg<!> VARARG,
<!ILLEGAL_MODIFIER!>reified<!> REIFIED
<!WRONG_MODIFIER_TARGET!>enum<!> ENUM,
<!WRONG_MODIFIER_TARGET!>out<!> OUT,
<!WRONG_MODIFIER_TARGET!>in<!> IN,
<!WRONG_MODIFIER_TARGET!>vararg<!> VARARG,
<!WRONG_MODIFIER_TARGET!>reified<!> REIFIED
}
compiler/testData/diagnostics/tests/infos/PropertiesWithBackingFields.kt
Vendored
+2 -2
View File
@@ -39,8 +39,8 @@ abstract class Test() {
abstract var v8 : Int get set
<!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>var v9 : Int<!> set
<!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>var v10 : Int<!> get
abstract val v11 : Int <!ILLEGAL_MODIFIER!>abstract<!> get
abstract var v12 : Int <!ILLEGAL_MODIFIER!>abstract<!> get <!ILLEGAL_MODIFIER!>abstract<!> set
abstract val v11 : Int <!WRONG_MODIFIER_TARGET!>abstract<!> get
abstract var v12 : Int <!WRONG_MODIFIER_TARGET!>abstract<!> get <!WRONG_MODIFIER_TARGET!>abstract<!> set
}
compiler/testData/diagnostics/tests/inner/deepInnerClass.kt
Vendored
+1 -1
View File
@@ -4,7 +4,7 @@ class A<T> {
class B {
fun test() {
class C<W>() : P<W, <!INACCESSIBLE_OUTER_CLASS_EXPRESSION!>T<!>> {
<!COMPANION_OBJECT_NOT_ALLOWED!>companion<!> object : P<<!INACCESSIBLE_OUTER_CLASS_EXPRESSION!>W<!>, <!INACCESSIBLE_OUTER_CLASS_EXPRESSION!>T<!>> {
<!WRONG_MODIFIER_CONTAINING_DECLARATION!>companion<!> object : P<<!INACCESSIBLE_OUTER_CLASS_EXPRESSION!>W<!>, <!INACCESSIBLE_OUTER_CLASS_EXPRESSION!>T<!>> {
}
inner class D : P<W, <!INACCESSIBLE_OUTER_CLASS_EXPRESSION!>T<!>>
compiler/testData/diagnostics/tests/inner/illegalModifier.kt
Vendored
+14 -14
View File
@@ -1,21 +1,21 @@
<!ILLEGAL_MODIFIER!>inner<!> fun foo() {}
<!ILLEGAL_MODIFIER!>inner<!> val prop = 42
<!WRONG_MODIFIER_TARGET!>inner<!> fun foo() {}
<!WRONG_MODIFIER_TARGET!>inner<!> val prop = 42
<!ILLEGAL_MODIFIER!>inner<!> class A
<!ILLEGAL_MODIFIER!>inner<!> interface B
<!ILLEGAL_MODIFIER!>inner<!> object C
<!WRONG_MODIFIER_TARGET!>inner<!> class A
<!WRONG_MODIFIER_TARGET!>inner<!> interface B
<!WRONG_MODIFIER_TARGET!>inner<!> object C
class D {
inner class E
<!ILLEGAL_MODIFIER!>inner<!> interface F
<!ILLEGAL_MODIFIER!>inner<!> object G
<!ILLEGAL_MODIFIER!>inner<!> enum class R
<!ILLEGAL_MODIFIER!>inner<!> annotation class S
<!ILLEGAL_MODIFIER!>inner<!> companion object
<!WRONG_MODIFIER_TARGET!>inner<!> interface F
<!WRONG_MODIFIER_TARGET!>inner<!> object G
<!WRONG_MODIFIER_TARGET!>inner<!> enum class R
<!WRONG_MODIFIER_TARGET!>inner<!> annotation class S
<!WRONG_MODIFIER_TARGET!>inner<!> companion object
}
enum class H {
<!ILLEGAL_MODIFIER!>inner<!> I {
<!WRONG_MODIFIER_TARGET!>inner<!> I {
inner class II
};
@@ -23,16 +23,16 @@ enum class H {
}
interface K {
<!INNER_CLASS_IN_TRAIT!>inner<!> class L
<!WRONG_MODIFIER_TARGET!>inner<!> class L
}
object N {
<!INNER_CLASS_IN_OBJECT!>inner<!> class O
<!WRONG_MODIFIER_TARGET!>inner<!> class O
}
class P {
companion object {
<!INNER_CLASS_IN_OBJECT!>inner<!> class Q
<!WRONG_MODIFIER_TARGET!>inner<!> class Q
}
}
compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.kt
Vendored
+66 -66
View File
@@ -1,4 +1,4 @@
<!UNRESOLVED_REFERENCE!>myAnnotation<!> <!ILLEGAL_MODIFIER!>public<!> package illegal_modifiers
<!UNRESOLVED_REFERENCE!>myAnnotation<!> <!WRONG_MODIFIER_TARGET!>public<!> package illegal_modifiers
abstract class A() {
<!INCOMPATIBLE_MODIFIERS!>abstract<!> <!INCOMPATIBLE_MODIFIERS!>final<!> fun f()
@@ -7,17 +7,17 @@ abstract class A() {
<!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>open var r: String<!>
get
<!ILLEGAL_MODIFIER!>abstract<!> protected set
<!WRONG_MODIFIER_TARGET!>abstract<!> protected set
}
<!TRAIT_CAN_NOT_BE_FINAL!>final<!> interface T {}
<!WRONG_MODIFIER_TARGET!>final<!> interface T {}
class FinalClass() {
<!NON_FINAL_MEMBER_IN_FINAL_CLASS!>open<!> fun foo() {}
val i: Int = 1
<!ILLEGAL_MODIFIER!>open<!> get(): Int = $i
<!WRONG_MODIFIER_TARGET!>open<!> get(): Int = $i
var j: Int = 1
<!ILLEGAL_MODIFIER!>open<!> set(v: Int) {}
<!WRONG_MODIFIER_TARGET!>open<!> set(v: Int) {}
}
<!INCOMPATIBLE_MODIFIERS!>private<!> <!INCOMPATIBLE_MODIFIERS!>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(
<!ILLEGAL_MODIFIER!>in<!>
<!ILLEGAL_MODIFIER!>out<!>
<!ILLEGAL_MODIFIER!>reified<!>
<!ILLEGAL_MODIFIER!>enum<!>
<!ILLEGAL_MODIFIER!>private<!>
<!WRONG_MODIFIER_TARGET!>in<!>
<!INCOMPATIBLE_MODIFIERS!>out<!>
<!WRONG_MODIFIER_TARGET!>reified<!>
<!WRONG_MODIFIER_TARGET!>enum<!>
<!WRONG_MODIFIER_TARGET!>private<!>
<!UNUSED_PARAMETER!>a<!>: Int)
//Check multiple illegal modifiers in constructor
class IllegalModifiers2(<!ILLEGAL_MODIFIER!>private<!> <!ILLEGAL_MODIFIER!>abstract<!> <!UNUSED_PARAMETER!>a<!>: Int)
class IllegalModifiers2(<!WRONG_MODIFIER_TARGET!>private<!> <!WRONG_MODIFIER_TARGET!>abstract<!> <!UNUSED_PARAMETER!>a<!>: Int)
//Check annotations with illegal modifiers in constructor
class IllegalModifiers3(annotated <!ILLEGAL_MODIFIER!>public<!> <!ILLEGAL_MODIFIER!>abstract<!> <!UNUSED_PARAMETER!>b<!>: String)
class IllegalModifiers3(annotated <!WRONG_MODIFIER_TARGET!>public<!> <!WRONG_MODIFIER_TARGET!>abstract<!> <!UNUSED_PARAMETER!>b<!>: String)
//Check annotations and vararg with illegal modifiers in constructor
class IllegalModifiers4(val a: Int, annotated("a text") <!ILLEGAL_MODIFIER!>protected<!> vararg <!UNUSED_PARAMETER!>v<!>: Int)
class IllegalModifiers4(val a: Int, annotated("a text") <!WRONG_MODIFIER_TARGET!>protected<!> vararg <!UNUSED_PARAMETER!>v<!>: Int)
//Check illegal modifiers for functions and catch block
abstract class IllegalModifiers5() {
//Check illegal modifier in function parameter
abstract fun foo(<!ILLEGAL_MODIFIER!>public<!> a: Int, vararg v: String)
abstract fun foo(<!WRONG_MODIFIER_TARGET!>public<!> a: Int, vararg v: String)
//Check multiple illegal modifiers in function parameter
abstract fun bar(<!ILLEGAL_MODIFIER!>public<!> <!ILLEGAL_MODIFIER!>abstract<!> a: Int, vararg v: String)
abstract fun bar(<!WRONG_MODIFIER_TARGET!>public<!> <!WRONG_MODIFIER_TARGET!>abstract<!> a: Int, vararg v: String)
//Check annotations with illegal modifiers
abstract fun baz(annotated("a text") <!ILLEGAL_MODIFIER!>public<!> <!ILLEGAL_MODIFIER!>abstract<!> a: Int)
abstract fun baz(annotated("a text") <!WRONG_MODIFIER_TARGET!>public<!> <!WRONG_MODIFIER_TARGET!>abstract<!> a: Int)
private fun qux() {
//Check illegal modifier in catch block
try {} catch (<!ILLEGAL_MODIFIER!>in<!> <!ILLEGAL_MODIFIER!>out<!> <!ILLEGAL_MODIFIER!>reified<!> <!ILLEGAL_MODIFIER!>enum<!> <!ILLEGAL_MODIFIER!>public<!> e: Exception) {}
try {} catch (<!WRONG_MODIFIER_TARGET!>in<!> <!INCOMPATIBLE_MODIFIERS!>out<!> <!WRONG_MODIFIER_TARGET!>reified<!> <!WRONG_MODIFIER_TARGET!>enum<!> <!WRONG_MODIFIER_TARGET!>public<!> e: Exception) {}
//Check multiple illegal modifiers in catch block
try {} catch (<!ILLEGAL_MODIFIER!>in<!> <!ILLEGAL_MODIFIER!>out<!> <!ILLEGAL_MODIFIER!>reified<!> <!ILLEGAL_MODIFIER!>enum<!> <!ILLEGAL_MODIFIER!>abstract<!> <!ILLEGAL_MODIFIER!>public<!> e: Exception) {}
try {} catch (<!WRONG_MODIFIER_TARGET!>in<!> <!INCOMPATIBLE_MODIFIERS!>out<!> <!WRONG_MODIFIER_TARGET!>reified<!> <!WRONG_MODIFIER_TARGET!>enum<!> <!WRONG_MODIFIER_TARGET!>abstract<!> <!WRONG_MODIFIER_TARGET!>public<!> e: Exception) {}
//Check annotations with illegal modifiers
try {} catch (annotated("a text") <!ILLEGAL_MODIFIER!>abstract<!> <!ILLEGAL_MODIFIER!>public<!> e: Exception) {}
try {} catch (annotated("a text") <!WRONG_MODIFIER_TARGET!>abstract<!> <!WRONG_MODIFIER_TARGET!>public<!> e: Exception) {}
}
}
//Check illegal modifiers on anonymous initializers
abstract class IllegalModifiers6() {
<!ILLEGAL_MODIFIER!>public<!> init {}
<!ILLEGAL_MODIFIER!>private<!> init {}
<!ILLEGAL_MODIFIER!>protected<!> init {}
<!ILLEGAL_MODIFIER!>vararg<!> init {}
<!ILLEGAL_MODIFIER!>abstract<!> init {}
<!ILLEGAL_MODIFIER!>open<!> init {}
<!ILLEGAL_MODIFIER!>final<!> init {}
<!WRONG_MODIFIER_TARGET!>public<!> init {}
<!WRONG_MODIFIER_TARGET!>private<!> init {}
<!WRONG_MODIFIER_TARGET!>protected<!> init {}
<!WRONG_MODIFIER_TARGET!>vararg<!> init {}
<!WRONG_MODIFIER_TARGET!>abstract<!> init {}
<!WRONG_MODIFIER_TARGET!>open<!> init {}
<!WRONG_MODIFIER_TARGET!>final<!> init {}
<!ILLEGAL_MODIFIER!>public<!> <!WRONG_ANNOTATION_TARGET!>annotated<!> init {}
<!WRONG_MODIFIER_TARGET!>public<!> <!WRONG_ANNOTATION_TARGET!>annotated<!> init {}
<!ILLEGAL_MODIFIER!>private<!> <!NOT_AN_ANNOTATION_CLASS, WRONG_ANNOTATION_TARGET!>IllegalModifiers6()<!> init {}
<!WRONG_MODIFIER_TARGET!>private<!> <!WRONG_ANNOTATION_TARGET, NOT_AN_ANNOTATION_CLASS!>IllegalModifiers6()<!> init {}
}
// strange inappropriate modifiers usages
<!ILLEGAL_MODIFIER!>override<!>
<!ILLEGAL_MODIFIER!>out<!>
<!ILLEGAL_MODIFIER!>in<!>
<!ILLEGAL_MODIFIER!>vararg<!>
<!ILLEGAL_MODIFIER!>reified<!>
<!WRONG_MODIFIER_TARGET!>override<!>
<!WRONG_MODIFIER_TARGET!>out<!>
<!INCOMPATIBLE_MODIFIERS!>in<!>
<!WRONG_MODIFIER_TARGET!>vararg<!>
<!WRONG_MODIFIER_TARGET!>reified<!>
class IllegalModifiers7() {
<!ILLEGAL_ENUM_ANNOTATION!>enum<!>
<!ILLEGAL_MODIFIER!>inner<!>
<!WRONG_MODIFIER_TARGET!>enum<!>
<!WRONG_MODIFIER_TARGET!>inner<!>
<!WRONG_ANNOTATION_TARGET!>annotation<!>
<!ILLEGAL_MODIFIER!>out<!>
<!ILLEGAL_MODIFIER!>in<!>
<!ILLEGAL_MODIFIER!>vararg<!>
<!ILLEGAL_MODIFIER!>reified<!>
<!WRONG_MODIFIER_TARGET!>out<!>
<!INCOMPATIBLE_MODIFIERS!>in<!>
<!WRONG_MODIFIER_TARGET!>vararg<!>
<!WRONG_MODIFIER_TARGET!>reified<!>
val x = 1
<!ILLEGAL_ENUM_ANNOTATION!>enum<!>
<!ILLEGAL_MODIFIER!>inner<!>
<!WRONG_MODIFIER_TARGET!>enum<!>
<!WRONG_MODIFIER_TARGET!>inner<!>
<!WRONG_ANNOTATION_TARGET!>annotation<!>
<!ILLEGAL_MODIFIER!>out<!>
<!ILLEGAL_MODIFIER!>in<!>
<!ILLEGAL_MODIFIER!>vararg<!>
<!ILLEGAL_MODIFIER!>reified<!>
<!WRONG_MODIFIER_TARGET!>out<!>
<!INCOMPATIBLE_MODIFIERS!>in<!>
<!WRONG_MODIFIER_TARGET!>vararg<!>
<!WRONG_MODIFIER_TARGET!>reified<!>
fun foo() {}
}
// Secondary constructors
class IllegalModifiers8 {
<!ILLEGAL_MODIFIER, INCOMPATIBLE_MODIFIERS!>abstract<!>
<!ILLEGAL_ENUM_ANNOTATION!>enum<!>
<!ILLEGAL_MODIFIER, REDUNDANT_MODIFIER, REDUNDANT_MODIFIER, INCOMPATIBLE_MODIFIERS!>open<!>
<!ILLEGAL_MODIFIER!>inner<!>
<!WRONG_MODIFIER_TARGET!>abstract<!>
<!WRONG_MODIFIER_TARGET!>enum<!>
<!REDUNDANT_MODIFIER!>open<!>
<!WRONG_MODIFIER_TARGET!>inner<!>
<!WRONG_ANNOTATION_TARGET!>annotation<!>
<!ILLEGAL_MODIFIER!>override<!>
<!ILLEGAL_MODIFIER!>out<!>
<!ILLEGAL_MODIFIER!>in<!>
<!ILLEGAL_MODIFIER, INCOMPATIBLE_MODIFIERS!>final<!>
<!ILLEGAL_MODIFIER!>vararg<!>
<!ILLEGAL_MODIFIER!>reified<!>
<!WRONG_MODIFIER_TARGET!>override<!>
<!WRONG_MODIFIER_TARGET!>out<!>
<!INCOMPATIBLE_MODIFIERS!>in<!>
<!INCOMPATIBLE_MODIFIERS!>final<!>
<!WRONG_MODIFIER_TARGET!>vararg<!>
<!WRONG_MODIFIER_TARGET!>reified<!>
constructor() {}
constructor(<!ILLEGAL_MODIFIER!>private<!> <!ILLEGAL_MODIFIER!>enum<!> <!ILLEGAL_MODIFIER!>abstract<!> <!UNUSED_PARAMETER!>x<!>: Int) {}
constructor(<!WRONG_MODIFIER_TARGET!>private<!> <!WRONG_MODIFIER_TARGET!>enum<!> <!WRONG_MODIFIER_TARGET!>abstract<!> <!UNUSED_PARAMETER!>x<!>: Int) {}
}
class IllegalModifiers9 {
@@ -139,16 +139,16 @@ class IllegalModifiers9 {
// Illegal modifiers on primary constructor
class IllegalModifiers10
<!ILLEGAL_MODIFIER, INCOMPATIBLE_MODIFIERS!>abstract<!>
<!ILLEGAL_ENUM_ANNOTATION!>enum<!>
<!ILLEGAL_MODIFIER, REDUNDANT_MODIFIER, REDUNDANT_MODIFIER, INCOMPATIBLE_MODIFIERS!>open<!>
<!ILLEGAL_MODIFIER!>inner<!>
<!WRONG_MODIFIER_TARGET!>abstract<!>
<!WRONG_MODIFIER_TARGET!>enum<!>
<!REDUNDANT_MODIFIER!>open<!>
<!WRONG_MODIFIER_TARGET!>inner<!>
<!WRONG_ANNOTATION_TARGET!>annotation<!>
<!ILLEGAL_MODIFIER!>override<!>
<!ILLEGAL_MODIFIER!>out<!>
<!ILLEGAL_MODIFIER!>in<!>
<!ILLEGAL_MODIFIER, INCOMPATIBLE_MODIFIERS!>final<!>
<!ILLEGAL_MODIFIER!>vararg<!>
<!ILLEGAL_MODIFIER!>reified<!> constructor()
<!WRONG_MODIFIER_TARGET!>override<!>
<!WRONG_MODIFIER_TARGET!>out<!>
<!INCOMPATIBLE_MODIFIERS!>in<!>
<!INCOMPATIBLE_MODIFIERS!>final<!>
<!WRONG_MODIFIER_TARGET!>vararg<!>
<!WRONG_MODIFIER_TARGET!>reified<!> constructor()
class IllegalModifiers11 <!INCOMPATIBLE_MODIFIERS!>private<!> <!INCOMPATIBLE_MODIFIERS!>protected<!> constructor()
compiler/testData/diagnostics/tests/modifiers/defaultModifier.kt
Vendored
+12 -12
View File
@@ -1,4 +1,4 @@
<!ILLEGAL_MODIFIER!>companion<!> class A {
<!WRONG_MODIFIER_TARGET!>companion<!> class A {
companion object {
}
@@ -18,38 +18,38 @@ class C {
class D {
companion object A {
<!COMPANION_OBJECT_NOT_ALLOWED!>companion<!> object {
<!WRONG_MODIFIER_CONTAINING_DECLARATION!>companion<!> object {
}
}
}
<!ILLEGAL_MODIFIER!>companion<!> object G {
<!COMPANION_OBJECT_NOT_ALLOWED!>companion<!> object
<!WRONG_MODIFIER_CONTAINING_DECLARATION!>companion<!> object G {
<!WRONG_MODIFIER_CONTAINING_DECLARATION!>companion<!> object
}
<!ILLEGAL_MODIFIER!>companion<!> interface H {
<!WRONG_MODIFIER_TARGET!>companion<!> interface H {
companion object
}
class J {
companion object C {
<!COMPANION_OBJECT_NOT_ALLOWED!>companion<!> object
<!WRONG_MODIFIER_CONTAINING_DECLARATION!>companion<!> object
}
}
<!ILLEGAL_MODIFIER!>companion<!> enum class Enum {
<!WRONG_MODIFIER_TARGET!>companion<!> enum class Enum {
E1,
E2;
companion object
}
<!ILLEGAL_MODIFIER!>companion<!> fun main() {
<!WRONG_MODIFIER_TARGET!>companion<!> fun main() {
}
<!ILLEGAL_MODIFIER!>companion<!> var prop: Int = 1
<!ILLEGAL_MODIFIER!>companion<!> get
<!ILLEGAL_MODIFIER!>companion<!> set
<!WRONG_MODIFIER_TARGET!>companion<!> var prop: Int = 1
<!WRONG_MODIFIER_TARGET!>companion<!> get
<!WRONG_MODIFIER_TARGET!>companion<!> set
class Z(<!ILLEGAL_MODIFIER!>companion<!> val c: Int)
class Z(<!WRONG_MODIFIER_TARGET!>companion<!> val c: Int)
compiler/testData/diagnostics/tests/modifiers/incompatibleVarianceModifiers.kt
Vendored
+6 -6
View File
@@ -2,22 +2,22 @@
interface Foo<T>
interface Foo1<<!INCOMPATIBLE_MODIFIERS!>in<!> <!INCOMPATIBLE_MODIFIERS!>out<!> T>
interface Foo2<<!REPEATED_MODIFIER!>in<!> <!REPEATED_MODIFIER!>in<!> T>
interface Foo2<in <!REPEATED_MODIFIER!>in<!> T>
fun test1(foo: Foo<<!INCOMPATIBLE_MODIFIERS!>in<!> <!INCOMPATIBLE_MODIFIERS!>out<!> Int>) = foo
fun test2(): Foo<<!REPEATED_MODIFIER!>in<!> <!REPEATED_MODIFIER!>in<!> Int> = throw Exception()
fun test2(): Foo<in <!REPEATED_MODIFIER!>in<!> Int> = throw Exception()
fun test3() {
val f: Foo<<!REPEATED_MODIFIER!>out<!> <!REPEATED_MODIFIER!>out<!> <!REPEATED_MODIFIER!>out<!> <!REPEATED_MODIFIER!>out<!> Int>
val f: Foo<out <!REPEATED_MODIFIER!>out<!> <!REPEATED_MODIFIER!>out<!> <!REPEATED_MODIFIER!>out<!> Int>
class Bzz<<!REPEATED_MODIFIER!>in<!> <!REPEATED_MODIFIER!>in<!> T>
class Bzz<in <!REPEATED_MODIFIER!>in<!> T>
}
class A {
fun <<!VARIANCE_ON_TYPE_PARAMETER_OF_FUNCTION_OR_PROPERTY, REPEATED_MODIFIER!>out<!> <!REPEATED_MODIFIER!>out<!> T> bar() {
fun <<!VARIANCE_ON_TYPE_PARAMETER_OF_FUNCTION_OR_PROPERTY!>out<!> <!REPEATED_MODIFIER!>out<!> T> bar() {
}
}
fun test4(a: A) {
a.bar<<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT, REPEATED_MODIFIER!>out<!> <!REPEATED_MODIFIER!>out<!> Int>()
a.bar<<!PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT!>out<!> <!REPEATED_MODIFIER!>out<!> Int>()
}
compiler/testData/diagnostics/tests/modifiers/repeatedModifiers.kt
Vendored
+19 -19
View File
@@ -1,41 +1,41 @@
<!REPEATED_MODIFIER!>abstract<!> <!REPEATED_MODIFIER!>abstract<!> class Foo
<!REPEATED_MODIFIER!>public<!> <!REPEATED_MODIFIER!>public<!> class Bar
<!REPEATED_MODIFIER, INCOMPATIBLE_MODIFIERS!>open<!> <!REPEATED_MODIFIER!>open<!> <!INCOMPATIBLE_MODIFIERS!>final<!> class Baz {
<!REPEATED_MODIFIER!>private<!> <!REPEATED_MODIFIER!>private<!> fun foo() {}
abstract <!REPEATED_MODIFIER!>abstract<!> class Foo
public <!REPEATED_MODIFIER!>public<!> class Bar
<!INCOMPATIBLE_MODIFIERS!>open<!> <!REPEATED_MODIFIER!>open<!> <!INCOMPATIBLE_MODIFIERS!>final<!> class Baz {
private <!REPEATED_MODIFIER!>private<!> fun foo() {}
}
class Bzz(<!REPEATED_MODIFIER!>public<!> <!REPEATED_MODIFIER!>public<!> val q: Int = 1) {
<!REPEATED_MODIFIER!>public<!> <!REPEATED_MODIFIER!>public<!> val x: Int = 2
class Bzz(public <!REPEATED_MODIFIER!>public<!> val q: Int = 1) {
public <!REPEATED_MODIFIER!>public<!> val x: Int = 2
public val y: Int
<!REPEATED_MODIFIER, REDUNDANT_MODIFIER_IN_GETTER!>public<!> <!REPEATED_MODIFIER!>public<!> get() = 3
<!REDUNDANT_MODIFIER_IN_GETTER!>public<!> <!REPEATED_MODIFIER!>public<!> get() = 3
val z: Int
<!INCOMPATIBLE_MODIFIERS, ILLEGAL_MODIFIER!>open<!> <!INCOMPATIBLE_MODIFIERS, ILLEGAL_MODIFIER!>final<!> get() = 4
<!WRONG_MODIFIER_TARGET!>open<!> <!INCOMPATIBLE_MODIFIERS!>final<!> get() = 4
<!REPEATED_MODIFIER!>public<!> <!REPEATED_MODIFIER!>public<!> class B(<!REPEATED_MODIFIER!>public<!> <!REPEATED_MODIFIER!>public<!> val z: Int = 1) {
<!REPEATED_MODIFIER!>public<!> <!REPEATED_MODIFIER!>public<!> val y: Int = 2
public <!REPEATED_MODIFIER!>public<!> class B(public <!REPEATED_MODIFIER!>public<!> val z: Int = 1) {
public <!REPEATED_MODIFIER!>public<!> val y: Int = 2
public val x: Int
<!REPEATED_MODIFIER, REDUNDANT_MODIFIER_IN_GETTER!>public<!> <!REPEATED_MODIFIER!>public<!> get() = 3
<!REDUNDANT_MODIFIER_IN_GETTER!>public<!> <!REPEATED_MODIFIER!>public<!> get() = 3
}
<!REPEATED_MODIFIER!>public<!> <!REPEATED_MODIFIER!>public<!> object C {
<!REPEATED_MODIFIER!>public<!> <!REPEATED_MODIFIER!>public<!> val y: Int = 1
<!REPEATED_MODIFIER!>public<!> <!REPEATED_MODIFIER!>public<!> fun z(): Int = 1
public <!REPEATED_MODIFIER!>public<!> object C {
public <!REPEATED_MODIFIER!>public<!> val y: Int = 1
public <!REPEATED_MODIFIER!>public<!> fun z(): Int = 1
}
}
<!REPEATED_MODIFIER!>public<!> <!REPEATED_MODIFIER!>public<!> val bar: Int = 1
public <!REPEATED_MODIFIER!>public<!> val bar: Int = 1
<!REPEATED_MODIFIER!>public<!> <!REPEATED_MODIFIER!>public<!> fun foo(): Int = 1
public <!REPEATED_MODIFIER!>public<!> fun foo(): Int = 1
fun test() {
<!REPEATED_MODIFIER!>public<!> <!REPEATED_MODIFIER!>public<!> class B(<!REPEATED_MODIFIER!>public<!> <!REPEATED_MODIFIER!>public<!> val z: Int = 1) {
<!REPEATED_MODIFIER!>public<!> <!REPEATED_MODIFIER!>public<!> val y: Int = 2
public <!REPEATED_MODIFIER!>public<!> class B(public <!REPEATED_MODIFIER!>public<!> val z: Int = 1) {
public <!REPEATED_MODIFIER!>public<!> val y: Int = 2
public val x: Int
<!REPEATED_MODIFIER, REDUNDANT_MODIFIER_IN_GETTER!>public<!> <!REPEATED_MODIFIER!>public<!> get() = 3
<!REDUNDANT_MODIFIER_IN_GETTER!>public<!> <!REPEATED_MODIFIER!>public<!> get() = 3
}
}
compiler/testData/diagnostics/tests/scopes/visibility.kt
Vendored
+4 -4
View File
@@ -1,11 +1,11 @@
//FILE:a.kt
package test_visibility
<!PACKAGE_MEMBER_CANNOT_BE_PROTECTED!>protected<!> class ProtectedClass
<!PACKAGE_MEMBER_CANNOT_BE_PROTECTED!>protected<!> interface ProtectedTrait
<!WRONG_MODIFIER_CONTAINING_DECLARATION!>protected<!> class ProtectedClass
<!WRONG_MODIFIER_CONTAINING_DECLARATION!>protected<!> interface ProtectedTrait
<!PACKAGE_MEMBER_CANNOT_BE_PROTECTED!>protected<!> val protected_val : Int = 4
<!PACKAGE_MEMBER_CANNOT_BE_PROTECTED!>protected<!> fun protected_fun() {}
<!WRONG_MODIFIER_TARGET!>protected<!> val protected_val : Int = 4
<!WRONG_MODIFIER_TARGET!>protected<!> fun protected_fun() {}
private val private_val : Int = 4
private fun private_fun() {}
compiler/testData/diagnostics/tests/sealed/NeverEnum.kt
Vendored
+1 -1
View File
@@ -1,4 +1,4 @@
<!SEALED_MODIFIER_IN_ENUM!>sealed<!> enum class SealedEnum {
<!WRONG_MODIFIER_TARGET!>sealed<!> enum class SealedEnum {
FIRST,
SECOND;
compiler/testData/diagnostics/tests/sealed/NeverFinal.kt
Vendored
+1 -1
View File
@@ -1,3 +1,3 @@
<!FINAL_MODIFIER_IN_SEALED!>final<!> sealed class Base {
<!INCOMPATIBLE_MODIFIERS!>final<!> <!INCOMPATIBLE_MODIFIERS!>sealed<!> class Base {
}
compiler/testData/diagnostics/tests/sealed/NeverInterface.kt
Vendored
+1 -1
View File
@@ -1,3 +1,3 @@
<!TRAIT_CAN_NOT_BE_SEALED!>sealed<!> interface Base {
<!WRONG_MODIFIER_TARGET!>sealed<!> interface Base {
}
compiler/testData/diagnostics/tests/sealed/NeverObject.kt
Vendored
+1 -1
View File
@@ -1,3 +1,3 @@
<!ILLEGAL_MODIFIER!>sealed<!> object Sealed {
<!WRONG_MODIFIER_TARGET!>sealed<!> object Sealed {
}
compiler/testData/diagnostics/tests/sealed/NeverOpen.kt
Vendored
+1 -1
View File
@@ -1,3 +1,3 @@
<!OPEN_MODIFIER_IN_SEALED!>open<!> sealed class Base {
<!INCOMPATIBLE_MODIFIERS!>open<!> <!INCOMPATIBLE_MODIFIERS!>sealed<!> class Base {
}
compiler/testData/diagnostics/tests/sealed/RedundantAbstract.kt
Vendored
+1 -1
View File
@@ -1,3 +1,3 @@
<!ABSTRACT_MODIFIER_IN_SEALED!>abstract<!> sealed class Base {
<!REDUNDANT_MODIFIER!>abstract<!> sealed class Base {
}
compiler/testData/diagnostics/tests/secondaryConstructors/valOrValAndModifiersInCtr.kt
Vendored
+1 -1
View File
@@ -3,5 +3,5 @@ class A {
constructor(
<!VAL_OR_VAR_ON_SECONDARY_CONSTRUCTOR_PARAMETER!>val<!> x: Int, y: Int,
<!VAL_OR_VAR_ON_SECONDARY_CONSTRUCTOR_PARAMETER!>var<!> z: Int,
<!ILLEGAL_MODIFIER!>public<!> a: Int)
<!WRONG_MODIFIER_TARGET!>public<!> a: Int)
}
compiler/testData/diagnostics/testsWithStdLib/instar.kt
Vendored
+1 -1
View File
@@ -3,7 +3,7 @@
import java.util.ArrayList
abstract class J {
public abstract fun <T : Collection<S>, S : List<<!ILLEGAL_MODIFIER!>in<!> *>> foo(x: T)
public abstract fun <T : Collection<S>, S : List<<!WRONG_MODIFIER_TARGET!>in<!> *>> foo(x: T)
fun bar() {
val s = ArrayList<ArrayList<Int>>()
foo(s)
compiler/testData/diagnostics/testsWithStdLib/outstar.kt
Vendored
+1 -1
View File
@@ -3,7 +3,7 @@
import java.util.ArrayList
abstract class J {
public abstract fun <T : Collection<S>, S : List<<!ILLEGAL_MODIFIER!>out<!> *>> foo(x: T)
public abstract fun <T : Collection<S>, S : List<<!WRONG_MODIFIER_TARGET!>out<!> *>> foo(x: T)
fun bar() {
val s = ArrayList<ArrayList<Int>>()
foo(s)
core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/KotlinTarget.kt
+48 -6
View File
@@ -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<KotlinTarget> = values().toSet()
public fun classActualTargets(descriptor: ClassDescriptor): List<KotlinTarget> = 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)
}
}
}
idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixRegistrar.kt
+2
View File
@@ -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)
idea/testData/checker/ClassObjects.kt
Vendored
+1 -1
View File
@@ -14,7 +14,7 @@ class B() {
}
object b {
<error descr="[COMPANION_OBJECT_NOT_ALLOWED] A companion object is not allowed here">companion</error> object {
<error descr="[WRONG_MODIFIER_CONTAINING_DECLARATION] Modifier 'companion' is not applicable inside 'object'">companion</error> object {
val x = 1
}
// error
idea/testData/checker/PlatformStaticUsagesRuntime.kt
Vendored
+4 -4
View File
@@ -1,15 +1,15 @@
import kotlin.platform.platformStatic
<error descr="[WRONG_ANNOTATION_TARGET] This annotation is not applicable to target 'classifier'">platformStatic</error>
<error descr="[WRONG_ANNOTATION_TARGET] This annotation is not applicable to target 'class'">platformStatic</error>
class A {
<error descr="[WRONG_ANNOTATION_TARGET] This annotation is not applicable to target 'classifier'">platformStatic</error>
<error descr="[WRONG_ANNOTATION_TARGET] This annotation is not applicable to target 'object'">platformStatic</error>
companion object {
platformStatic fun a1() {
}
}
<error descr="[WRONG_ANNOTATION_TARGET] This annotation is not applicable to target 'classifier'">platformStatic</error>
<error descr="[WRONG_ANNOTATION_TARGET] This annotation is not applicable to target 'object'">platformStatic</error>
object A {
platformStatic fun a2() {
@@ -29,7 +29,7 @@ class A {
}
}
<error descr="[WRONG_ANNOTATION_TARGET] This annotation is not applicable to target 'classifier'">platformStatic</error>
<error descr="[WRONG_ANNOTATION_TARGET] This annotation is not applicable to target 'interface'">platformStatic</error>
interface B {
companion object {
<error descr="[PLATFORM_STATIC_NOT_IN_OBJECT] Only functions in named objects and companion objects of classes can be annotated with 'platformStatic'">platformStatic fun a1()</error> {
j2k/testData/fileOrElement/annotations/annotationInterface3.kt
Vendored
+1
View File
@@ -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 {
js/js.translator/testData/delegation/cases/delegation4.kt
Vendored
+2 -2
View File
@@ -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
}
js/js.translator/testData/inlineMultiFile/cases/use/use.2.kt
Vendored
+1 -1
View File
@@ -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() {}
}
js/js.translator/testData/inlineMultiFile/cases/with/with.2.kt
Vendored
+1 -1
View File
@@ -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() {}
}