From f5878eddd44ff19e8ed37bf511af1f13117b8a3b Mon Sep 17 00:00:00 2001 From: "Pavel V. Talanov" Date: Wed, 22 Jul 2015 14:54:35 +0300 Subject: [PATCH] Refactor ModifiersChecker to be more component-like A couple of minor prettifications --- .../kotlin/resolve/BodyResolver.java | 7 +- .../kotlin/resolve/DeclarationsChecker.java | 8 +- .../kotlin/resolve/DescriptorResolver.java | 24 - .../resolve/FunctionDescriptorResolver.kt | 37 +- .../kotlin/resolve/ModifiersChecker.java | 596 ++++++++++-------- .../jetbrains/kotlin/resolve/TypeResolver.kt | 7 +- .../kotlin/resolve/calls/CandidateResolver.kt | 5 +- .../resolve/lazy/data/JetObjectInfo.java | 6 +- .../ControlStructureTypingVisitor.java | 12 +- .../ExpressionTypingComponents.java | 6 + .../ExpressionTypingVisitorForStatements.java | 2 +- .../expressions/FunctionsTypingVisitor.kt | 3 +- 12 files changed, 377 insertions(+), 336 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java index a8a8f85fac7..6977e132e80 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java @@ -54,6 +54,7 @@ import static org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE; public class BodyResolver { @NotNull private final ScriptBodyResolver scriptBodyResolverResolver; + @NotNull private final ModifiersChecker modifiersChecker; @NotNull private final ExpressionTypingServices expressionTypingServices; @NotNull private final CallResolver callResolver; @NotNull private final ObservableBindingTrace trace; @@ -78,7 +79,8 @@ public class BodyResolver { @NotNull FunctionAnalyzerExtension functionAnalyzerExtension, @NotNull ScriptBodyResolver scriptBodyResolverResolver, @NotNull BindingTrace trace, - @NotNull ValueParameterResolver valueParameterResolver + @NotNull ValueParameterResolver valueParameterResolver, + @NotNull ModifiersChecker modifiersChecker ) { this.additionalCheckerProvider = additionalCheckerProvider; this.annotationResolver = annotationResolver; @@ -90,6 +92,7 @@ public class BodyResolver { this.expressionTypingServices = expressionTypingServices; this.functionAnalyzerExtension = functionAnalyzerExtension; this.scriptBodyResolverResolver = scriptBodyResolverResolver; + this.modifiersChecker = modifiersChecker; this.trace = new ObservableBindingTrace(trace); this.valueParameterResolver = valueParameterResolver; } @@ -512,7 +515,7 @@ public class BodyResolver { annotationResolver.resolveAnnotationsWithArguments(scope, modifierList, trace); - ModifiersChecker.reportIllegalModifiers(modifierList, Arrays.asList(JetTokens.MODIFIER_KEYWORDS_ARRAY), 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 18b9fa6b54f..182907b05ec 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.java @@ -45,7 +45,7 @@ import static org.jetbrains.kotlin.resolve.DescriptorUtils.classCanHaveOpenMembe public class DeclarationsChecker { @NotNull private final BindingTrace trace; - @NotNull private final ModifiersChecker modifiersChecker; + @NotNull private final ModifiersChecker.ModifiersCheckingProcedure modifiersChecker; @NotNull private final DescriptorResolver descriptorResolver; public DeclarationsChecker( @@ -54,7 +54,7 @@ public class DeclarationsChecker { @NotNull BindingTrace trace ) { this.descriptorResolver = descriptorResolver; - this.modifiersChecker = modifiersChecker; + this.modifiersChecker = modifiersChecker.withTrace(trace); this.trace = trace; } @@ -143,7 +143,7 @@ public class DeclarationsChecker { } AnnotationTargetChecker.INSTANCE$.check(packageDirective, trace, null); - ModifiersChecker.reportIllegalModifiers(modifierList, Arrays.asList(JetTokens.MODIFIER_KEYWORDS_ARRAY), trace); + modifiersChecker.reportIllegalModifiers(modifierList, Arrays.asList(JetTokens.MODIFIER_KEYWORDS_ARRAY)); } private void checkTypesInClassHeader(@NotNull JetClassOrObject classOrObject) { @@ -532,7 +532,7 @@ public class DeclarationsChecker { PropertyGetterDescriptor getterDescriptor = propertyDescriptor.getGetter(); JetModifierList getterModifierList = getter != null ? getter.getModifierList() : null; if (getterModifierList != null && getterDescriptor != null) { - Map nodes = ModifiersChecker.getNodesCorrespondingToModifiers(getterModifierList, Sets + Map nodes = modifiersChecker.getNodesCorrespondingToModifiers(getterModifierList, Sets .newHashSet(JetTokens.PUBLIC_KEYWORD, JetTokens.PROTECTED_KEYWORD, JetTokens.PRIVATE_KEYWORD, JetTokens.INTERNAL_KEYWORD)); if (getterDescriptor.getVisibility() != propertyDescriptor.getVisibility()) { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java index 044c8149153..c9fdc661113 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java @@ -61,12 +61,6 @@ import static org.jetbrains.kotlin.resolve.source.SourcePackage.toSourceElement; public class DescriptorResolver { public static final Name COPY_METHOD_NAME = Name.identifier("copy"); - private static final Set MODIFIERS_ILLEGAL_ON_PARAMETERS; - static { - MODIFIERS_ILLEGAL_ON_PARAMETERS = Sets.newHashSet(); - MODIFIERS_ILLEGAL_ON_PARAMETERS.addAll(Arrays.asList(JetTokens.MODIFIER_KEYWORDS_ARRAY)); - MODIFIERS_ILLEGAL_ON_PARAMETERS.remove(JetTokens.VARARG_KEYWORD); - } @NotNull private final TypeResolver typeResolver; @NotNull private final AnnotationResolver annotationResolver; @@ -1165,24 +1159,6 @@ public class DescriptorResolver { return getParentOfType(scope.getContainingDeclaration(), ClassDescriptor.class, false); } - public static void checkParameterHasNoValOrVar( - @NotNull BindingTrace trace, - @NotNull JetParameter parameter, - @NotNull DiagnosticFactory1 diagnosticFactory - ) { - PsiElement valOrVar = parameter.getValOrVarKeyword(); - if (valOrVar != null) { - trace.report(diagnosticFactory.on(valOrVar, ((JetKeywordToken) valOrVar.getNode().getElementType()))); - } - } - - public static void checkParameterHasNoModifier( - @NotNull BindingTrace trace, - @NotNull JetParameter parameter - ) { - ModifiersChecker.reportIllegalModifiers(parameter.getModifierList(), MODIFIERS_ILLEGAL_ON_PARAMETERS, trace); - } - public static void resolvePackageHeader( @NotNull JetPackageDirective packageDirective, @NotNull ModuleDescriptor module, diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt index 9b81a8349a3..cd076428ef7 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt @@ -16,13 +16,14 @@ package org.jetbrains.kotlin.resolve -import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.builtins -import org.jetbrains.kotlin.builtins.KotlinBuiltIns.* import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.descriptors.annotations.Annotations -import org.jetbrains.kotlin.descriptors.impl.* +import org.jetbrains.kotlin.descriptors.impl.ConstructorDescriptorImpl +import org.jetbrains.kotlin.descriptors.impl.FunctionExpressionDescriptor +import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl +import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl.create +import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl import org.jetbrains.kotlin.diagnostics.DiagnosticUtils import org.jetbrains.kotlin.diagnostics.Errors.* import org.jetbrains.kotlin.name.Name @@ -33,6 +34,7 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils.* import org.jetbrains.kotlin.resolve.DescriptorResolver.* import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil +import org.jetbrains.kotlin.resolve.scopes.JetScope import org.jetbrains.kotlin.resolve.scopes.WritableScope import org.jetbrains.kotlin.resolve.scopes.WritableScopeImpl import org.jetbrains.kotlin.resolve.source.toSourceElement @@ -47,12 +49,13 @@ import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils import java.util.ArrayList class FunctionDescriptorResolver( - val typeResolver: TypeResolver, - val descriptorResolver: DescriptorResolver, - val annotationResolver: AnnotationResolver, - val storageManager: StorageManager, - val expressionTypingServices: ExpressionTypingServices, - val builtIns: KotlinBuiltIns + private val typeResolver: TypeResolver, + private val descriptorResolver: DescriptorResolver, + private val annotationResolver: AnnotationResolver, + private val storageManager: StorageManager, + private val expressionTypingServices: ExpressionTypingServices, + private val builtIns: KotlinBuiltIns, + private val modifiersChecker: ModifiersChecker ) { public fun resolveFunctionDescriptor( containingDescriptor: DeclarationDescriptor, @@ -336,11 +339,13 @@ class FunctionDescriptorResolver( if (functionDescriptor !is ConstructorDescriptor || !functionDescriptor.isPrimary()) { val isConstructor = functionDescriptor is ConstructorDescriptor - DescriptorResolver.checkParameterHasNoValOrVar( - trace, valueParameter, - if (isConstructor) VAL_OR_VAR_ON_SECONDARY_CONSTRUCTOR_PARAMETER else VAL_OR_VAR_ON_FUN_PARAMETER - ) - DescriptorResolver.checkParameterHasNoModifier(trace, valueParameter) + with (modifiersChecker.withTrace(trace)) { + checkParameterHasNoValOrVar( + valueParameter, + if (isConstructor) VAL_OR_VAR_ON_SECONDARY_CONSTRUCTOR_PARAMETER else VAL_OR_VAR_ON_FUN_PARAMETER + ) + checkParameterHasNoModifier(valueParameter) + } } else { checkConstructorParameterHasNoModifier(trace, valueParameter) @@ -357,7 +362,7 @@ class FunctionDescriptorResolver( private fun checkConstructorParameterHasNoModifier(trace: BindingTrace, parameter: JetParameter) { // If is not a property, then it must have no modifier if (!parameter.hasValOrVar()) { - DescriptorResolver.checkParameterHasNoModifier(trace, parameter) + 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 6ea26fce784..0aa8c4c098b 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.java @@ -26,7 +26,9 @@ 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; import org.jetbrains.kotlin.name.FqName; @@ -50,188 +52,12 @@ public class ModifiersChecker { private static final Collection VISIBILITY_MODIFIERS = Lists.newArrayList(PRIVATE_KEYWORD, PROTECTED_KEYWORD, PUBLIC_KEYWORD, INTERNAL_KEYWORD); - public static void reportIllegalModifiers( - @Nullable JetModifierList modifierList, - @NotNull Collection illegalModifiers, - @NotNull BindingTrace trace - ) { - if (modifierList == null) return; + private static final Set MODIFIERS_ILLEGAL_ON_PARAMETERS; - for (JetModifierKeywordToken modifierToken : illegalModifiers) { - if (modifierList.hasModifier(modifierToken)) { - PsiElement modifierPsi = modifierList.getModifier(modifierToken); - assert modifierPsi != null; - trace.report(ILLEGAL_MODIFIER.on(modifierPsi, modifierToken)); - } - } - } - - public static void checkIncompatibleModifiers( - @Nullable JetModifierList modifierList, - @NotNull BindingTrace trace, - @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, trace, 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 static void checkRepeatedModifiers( - @NotNull JetModifierList modifierList, - @NotNull BindingTrace trace, - @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 static void checkIncompatibleVarianceModifiers(@Nullable JetModifierList modifierList, @NotNull BindingTrace trace) { - checkIncompatibleModifiers(modifierList, trace, Arrays.asList(JetTokens.IN_KEYWORD, JetTokens.OUT_KEYWORD)); - } - - @NotNull - private final BindingTrace trace; - @NotNull - private final AdditionalCheckerProvider additionalCheckerProvider; - - public ModifiersChecker(@NotNull BindingTrace trace, @NotNull AdditionalCheckerProvider additionalCheckerProvider) { - this.trace = trace; - this.additionalCheckerProvider = additionalCheckerProvider; - } - - public static ModifiersChecker create(@NotNull BindingTrace trace, @NotNull AdditionalCheckerProvider provider) { - return new ModifiersChecker(trace, provider); - } - - public void checkModifiersForDeclaration(@NotNull JetDeclaration modifierListOwner, @NotNull MemberDescriptor descriptor) { - if (modifierListOwner instanceof JetEnumEntry) { - reportIllegalModifiers(modifierListOwner, Arrays.asList(MODIFIER_KEYWORDS_ARRAY)); - } - else { - checkInnerModifier(modifierListOwner, descriptor); - checkDefaultModifier(modifierListOwner); - checkModalityModifiers(modifierListOwner); - checkVisibilityModifiers(modifierListOwner, descriptor); - checkVarianceModifiers(modifierListOwner); - checkVarargsModifiers(modifierListOwner, descriptor); - } - checkPlatformNameApplicability(descriptor); - runDeclarationCheckers(modifierListOwner, descriptor); - AnnotationTargetChecker.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, Collections.singleton(VARARG_KEYWORD)); - } - } - - public void checkModifiersForLocalDeclaration(@NotNull JetDeclaration modifierListOwner, @NotNull DeclarationDescriptor descriptor) { - reportIllegalModalityModifiers(modifierListOwner); - reportIllegalVisibilityModifiers(modifierListOwner); - checkPlatformNameApplicability(descriptor); - runDeclarationCheckers(modifierListOwner, descriptor); - AnnotationTargetChecker.INSTANCE$.check(modifierListOwner, trace, - descriptor instanceof ClassDescriptor ? (ClassDescriptor) descriptor : null); - } - - 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; - } - if (modifierListOwner instanceof JetClass && !(modifierListOwner instanceof JetEnumEntry)) { - JetClass aClass = (JetClass) modifierListOwner; - boolean localEnumError = aClass.isLocal() && aClass.isEnum(); - if (!localEnumError && isIllegalNestedClass(descriptor)) { - trace.report(NESTED_CLASS_NOT_ALLOWED.on(aClass)); - } - } + static { + MODIFIERS_ILLEGAL_ON_PARAMETERS = Sets.newHashSet(); + MODIFIERS_ILLEGAL_ON_PARAMETERS.addAll(Arrays.asList(JetTokens.MODIFIER_KEYWORDS_ARRAY)); + MODIFIERS_ILLEGAL_ON_PARAMETERS.remove(JetTokens.VARARG_KEYWORD); } public static boolean isIllegalInner(@NotNull DeclarationDescriptor descriptor) { @@ -245,15 +71,10 @@ public class ModifiersChecker { IN_OBJECT, } - private void checkDefaultModifier(@NotNull JetDeclaration declaration) { - if (declaration.hasModifier(COMPANION_KEYWORD) && !isDefaultModifierAllowed(declaration)) { - reportIllegalModifiers(declaration, Collections.singletonList(COMPANION_KEYWORD)); - } - } // NOTE: just checks if this is legal context for companion modifier (Companion object descriptor can be created) // COMPANION_OBJECT_NOT_ALLOWED can be reported later - public static boolean isDefaultModifierAllowed(@NotNull JetDeclaration declaration) { + public static boolean isCompanionModifierAllowed(@NotNull JetDeclaration declaration) { if (declaration instanceof JetObjectDeclaration) { JetDeclaration containingDeclaration = getContainingDeclaration(declaration); if (containingDeclaration instanceof JetClassOrObject) { @@ -264,7 +85,7 @@ public class ModifiersChecker { } @NotNull - private static InnerModifierCheckResult checkIllegalInner(DeclarationDescriptor descriptor) { + private static InnerModifierCheckResult checkIllegalInner(@NotNull DeclarationDescriptor descriptor) { if (!(descriptor instanceof ClassDescriptor)) return InnerModifierCheckResult.ILLEGAL_POSITION; ClassDescriptor classDescriptor = (ClassDescriptor) descriptor; @@ -292,81 +113,15 @@ public class ModifiersChecker { return containingClass.isInner() || containingClass.getContainingDeclaration() instanceof FunctionDescriptor; } - private void checkPlatformNameApplicability(@NotNull DeclarationDescriptor descriptor) { - AnnotationDescriptor annotation = descriptor.getAnnotations().findAnnotation(new FqName("kotlin.platform.platformName")); - if (annotation == null) return; - - JetAnnotationEntry annotationEntry = trace.get(BindingContext.ANNOTATION_DESCRIPTOR_TO_PSI_ELEMENT, annotation); - if (annotationEntry == null) return; - - if (descriptor instanceof FunctionDescriptor && !isRenamableFunction((FunctionDescriptor) descriptor)) { - trace.report(INAPPLICABLE_PLATFORM_NAME.on(annotationEntry)); - } - - String value = null; - Collection> values = annotation.getAllValueArguments().values(); - if (!values.isEmpty()) { - ConstantValue name = values.iterator().next(); - if (name instanceof StringValue) { - value = ((StringValue) name).getValue(); - } - } - if (value == null || !Name.isValidIdentifier(value)) { - trace.report(ILLEGAL_PLATFORM_NAME.on(annotationEntry, String.valueOf(value))); - } - - if (descriptor instanceof CallableMemberDescriptor) { - CallableMemberDescriptor callableMemberDescriptor = (CallableMemberDescriptor) descriptor; - if (DescriptorUtils.isOverride(callableMemberDescriptor) || callableMemberDescriptor.getModality().isOverridable()) { - trace.report(INAPPLICABLE_PLATFORM_NAME.on(annotationEntry)); - } - } - - } - - private static boolean isRenamableFunction(@NotNull FunctionDescriptor descriptor) { - DeclarationDescriptor containingDescriptor = descriptor.getContainingDeclaration(); - - return containingDescriptor instanceof PackageFragmentDescriptor || containingDescriptor instanceof ClassDescriptor; - } - - private void checkCompatibility(@Nullable JetModifierList modifierList, Collection availableModifiers, Collection... availableCombinations) { - checkIncompatibleModifiers(modifierList, trace, 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)); - } - } - } - - public void reportIllegalModifiers( + @NotNull + public static Modality resolveModalityFromModifiers( @NotNull JetModifierListOwner modifierListOwner, - @NotNull Collection illegalModifiers + @NotNull Modality defaultModality ) { - reportIllegalModifiers(modifierListOwner.getModifierList(), illegalModifiers, trace); - } - - @NotNull - public static Map getNodesCorrespondingToModifiers(@NotNull JetModifierList modifierList, @NotNull Collection possibleModifiers) { - Map nodes = Maps.newHashMap(); - for (JetModifierKeywordToken modifier : possibleModifiers) { - if (modifierList.hasModifier(modifier)) { - nodes.put(modifier, modifierList.getModifierNode(modifier)); - } - } - return nodes; - } - - @NotNull - public static Modality resolveModalityFromModifiers(@NotNull JetModifierListOwner modifierListOwner, @NotNull Modality defaultModality) { return resolveModalityFromModifiers(modifierListOwner.getModifierList(), defaultModality); } + @NotNull public static Modality resolveModalityFromModifiers(@Nullable JetModifierList modifierList, @NotNull Modality defaultModality) { if (modifierList == null) return defaultModality; boolean hasAbstractModifier = modifierList.hasModifier(ABSTRACT_KEYWORD); @@ -395,7 +150,10 @@ public class ModifiersChecker { } @NotNull - public static Visibility resolveVisibilityFromModifiers(@NotNull JetModifierListOwner modifierListOwner, @NotNull Visibility defaultVisibility) { + public static Visibility resolveVisibilityFromModifiers( + @NotNull JetModifierListOwner modifierListOwner, + @NotNull Visibility defaultVisibility + ) { return resolveVisibilityFromModifiers(modifierListOwner.getModifierList(), defaultVisibility); } @@ -421,19 +179,317 @@ public class ModifiersChecker { return Visibilities.INTERNAL; } - private void runDeclarationCheckers(@NotNull JetDeclaration declaration, @NotNull DeclarationDescriptor descriptor) { - for (DeclarationChecker checker : additionalCheckerProvider.getDeclarationCheckers()) { - checker.check(declaration, descriptor, trace, trace.getBindingContext()); + + public class ModifiersCheckingProcedure { + + @NotNull + private final BindingTrace trace; + + private ModifiersCheckingProcedure(@NotNull BindingTrace trace) { + this.trace = trace; + } + + public void checkParameterHasNoValOrVar( + @NotNull JetParameter parameter, + @NotNull DiagnosticFactory1 diagnosticFactory + ) { + PsiElement valOrVar = parameter.getValOrVarKeyword(); + if (valOrVar != null) { + trace.report(diagnosticFactory.on(valOrVar, ((JetKeywordToken) valOrVar.getNode().getElementType()))); + } + } + + 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); + } + checkPlatformNameApplicability(descriptor); + runDeclarationCheckers(modifierListOwner, descriptor); + AnnotationTargetChecker.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)); + } + } + + public void checkModifiersForLocalDeclaration( + @NotNull JetDeclaration modifierListOwner, + @NotNull DeclarationDescriptor descriptor + ) { + reportIllegalModalityModifiers(modifierListOwner); + reportIllegalVisibilityModifiers(modifierListOwner); + checkPlatformNameApplicability(descriptor); + runDeclarationCheckers(modifierListOwner, descriptor); + AnnotationTargetChecker.INSTANCE$.check(modifierListOwner, trace, + descriptor instanceof ClassDescriptor ? (ClassDescriptor) descriptor : null); + } + + 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; + } + if (modifierListOwner instanceof JetClass && !(modifierListOwner instanceof JetEnumEntry)) { + JetClass aClass = (JetClass) modifierListOwner; + boolean localEnumError = aClass.isLocal() && aClass.isEnum(); + if (!localEnumError && isIllegalNestedClass(descriptor)) { + trace.report(NESTED_CLASS_NOT_ALLOWED.on(aClass)); + } + } + } + + 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; + + JetAnnotationEntry annotationEntry = trace.get(BindingContext.ANNOTATION_DESCRIPTOR_TO_PSI_ELEMENT, annotation); + if (annotationEntry == null) return; + + if (descriptor instanceof FunctionDescriptor && !isRenamableFunction((FunctionDescriptor) descriptor)) { + trace.report(INAPPLICABLE_PLATFORM_NAME.on(annotationEntry)); + } + + String value = null; + Collection> values = annotation.getAllValueArguments().values(); + if (!values.isEmpty()) { + ConstantValue name = values.iterator().next(); + if (name instanceof StringValue) { + value = ((StringValue) name).getValue(); + } + } + if (value == null || !Name.isValidIdentifier(value)) { + trace.report(ILLEGAL_PLATFORM_NAME.on(annotationEntry, String.valueOf(value))); + } + + if (descriptor instanceof CallableMemberDescriptor) { + CallableMemberDescriptor callableMemberDescriptor = (CallableMemberDescriptor) descriptor; + if (DescriptorUtils.isOverride(callableMemberDescriptor) || callableMemberDescriptor.getModality().isOverridable()) { + trace.report(INAPPLICABLE_PLATFORM_NAME.on(annotationEntry)); + } + } + } + + + private boolean isRenamableFunction(@NotNull FunctionDescriptor descriptor) { + DeclarationDescriptor containingDescriptor = descriptor.getContainingDeclaration(); + + 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, + @NotNull Collection possibleModifiers + ) { + Map nodes = Maps.newHashMap(); + for (JetModifierKeywordToken modifier : possibleModifiers) { + if (modifierList.hasModifier(modifier)) { + nodes.put(modifier, modifierList.getModifierNode(modifier)); + } + } + return nodes; + } + + + private void runDeclarationCheckers(@NotNull JetDeclaration declaration, @NotNull DeclarationDescriptor descriptor) { + for (DeclarationChecker checker : additionalCheckerProvider.getDeclarationCheckers()) { + checker.check(declaration, descriptor, trace, trace.getBindingContext()); + } + } + + public void checkVarianceModifiers(@NotNull JetModifierListOwner modifierListOwner) { + reportIllegalModifiers(modifierListOwner.getModifierList(), Arrays.asList(IN_KEYWORD, OUT_KEYWORD, REIFIED_KEYWORD)); + if (!(modifierListOwner instanceof JetTypeParameterListOwner)) return; + List typeParameters = ((JetTypeParameterListOwner) modifierListOwner).getTypeParameters(); + for (JetTypeParameter typeParameter : typeParameters) { + JetModifierList modifierList = typeParameter.getModifierList(); + checkIncompatibleVarianceModifiers(modifierList); + } + } + + public void checkParameterHasNoModifier( + @NotNull JetParameter parameter + ) { + reportIllegalModifiers(parameter.getModifierList(), MODIFIERS_ILLEGAL_ON_PARAMETERS); } } - public void checkVarianceModifiers(@NotNull JetModifierListOwner modifierListOwner) { - reportIllegalModifiers(modifierListOwner, Arrays.asList(IN_KEYWORD, OUT_KEYWORD, REIFIED_KEYWORD)); - if (!(modifierListOwner instanceof JetTypeParameterListOwner)) return; - List typeParameters = ((JetTypeParameterListOwner) modifierListOwner).getTypeParameters(); - for (JetTypeParameter typeParameter : typeParameters) { - JetModifierList modifierList = typeParameter.getModifierList(); - checkIncompatibleVarianceModifiers(modifierList, trace); - } + @NotNull + private final AdditionalCheckerProvider additionalCheckerProvider; + + public ModifiersChecker(@NotNull AdditionalCheckerProvider additionalCheckerProvider) { + this.additionalCheckerProvider = additionalCheckerProvider; + } + + @NotNull + public ModifiersCheckingProcedure withTrace(@NotNull BindingTrace trace) { + return new ModifiersCheckingProcedure(trace); } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt index 55c3ea047b3..8cc680b93e9 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt @@ -49,7 +49,8 @@ public class TypeResolver( private val flexibleTypeCapabilitiesProvider: FlexibleTypeCapabilitiesProvider, private val storageManager: StorageManager, private val lazinessToken: TypeLazinessToken, - private val dynamicTypesSettings: DynamicTypesSettings + private val dynamicTypesSettings: DynamicTypesSettings, + private val modifiersChecker: ModifiersChecker ) { public open class FlexibleTypeCapabilitiesProvider { @@ -268,9 +269,9 @@ public class TypeResolver( return argumentElements.mapIndexed { i, argumentElement -> val projectionKind = argumentElement.getProjectionKind() - ModifiersChecker.checkIncompatibleVarianceModifiers(argumentElement.getModifierList(), c.trace) + modifiersChecker.withTrace(c.trace).checkIncompatibleVarianceModifiers(argumentElement.getModifierList()) if (projectionKind == JetProjectionKind.STAR) { - ModifiersChecker.reportIllegalModifiers(argumentElement.getModifierList(), listOf(JetTokens.IN_KEYWORD, JetTokens.OUT_KEYWORD), c.trace) + modifiersChecker.withTrace(c.trace).reportIllegalModifiers(argumentElement.getModifierList(), listOf(JetTokens.IN_KEYWORD, JetTokens.OUT_KEYWORD)) val parameters = constructor.getParameters() if (parameters.size() > 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 2bf545e83c4..e72cb37e6e8 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt @@ -63,7 +63,8 @@ import java.util.ArrayList public class CandidateResolver( private val argumentTypeResolver: ArgumentTypeResolver, private val genericCandidateResolver: GenericCandidateResolver, - private val reflectionTypes: ReflectionTypes + private val reflectionTypes: ReflectionTypes, + private val modifiersChecker: ModifiersChecker ){ public fun performResolutionForCandidateCall( @@ -123,7 +124,7 @@ public class CandidateResolver( for (projection in jetTypeArguments) { if (projection.getProjectionKind() != JetProjectionKind.NONE) { trace.report(PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT.on(projection)) - ModifiersChecker.checkIncompatibleVarianceModifiers(projection.getModifierList(), trace) + modifiersChecker.withTrace(trace).checkIncompatibleVarianceModifiers(projection.getModifierList()) } val type = argumentTypeResolver.resolveTypeRefWithDefault( projection.getTypeReference(), scope, trace, diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetObjectInfo.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetObjectInfo.java index adc5ed94d83..270c5c7b058 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetObjectInfo.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetObjectInfo.java @@ -20,13 +20,9 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.descriptors.ClassKind; import org.jetbrains.kotlin.psi.JetObjectDeclaration; -import org.jetbrains.kotlin.psi.JetParameter; import org.jetbrains.kotlin.psi.JetTypeParameterList; import org.jetbrains.kotlin.resolve.ModifiersChecker; -import java.util.Collections; -import java.util.List; - public class JetObjectInfo extends JetClassOrObjectInfo { @NotNull private final ClassKind kind; @@ -49,6 +45,6 @@ public class JetObjectInfo extends JetClassOrObjectInfo { } public boolean isCompanionObject() { - return element.isCompanion() && ModifiersChecker.isDefaultModifierAllowed(element); + return element.isCompanion() && ModifiersChecker.isCompanionModifierAllowed(element); } } 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 9c04006e664..87d4ce6a51e 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.DescriptorResolver; -import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils; +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; @@ -426,7 +423,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { JetType expectedParameterType, ExpressionTypingContext context ) { - DescriptorResolver.checkParameterHasNoValOrVar(context.trace, loopParameter, VAL_OR_VAR_ON_LOOP_PARAMETER); + components.modifiersChecker.withTrace(context.trace).checkParameterHasNoValOrVar(loopParameter, VAL_OR_VAR_ON_LOOP_PARAMETER); JetTypeReference typeReference = loopParameter.getTypeReference(); VariableDescriptor variableDescriptor; @@ -468,8 +465,9 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { JetParameter catchParameter = catchClause.getCatchParameter(); JetExpression catchBody = catchClause.getCatchBody(); if (catchParameter != null) { - DescriptorResolver.checkParameterHasNoValOrVar(context.trace, catchParameter, VAL_OR_VAR_ON_CATCH_PARAMETER); - DescriptorResolver.checkParameterHasNoModifier(context.trace, catchParameter); + ModifiersChecker.ModifiersCheckingProcedure modifiersChecking = components.modifiersChecker.withTrace(context.trace); + modifiersChecking.checkParameterHasNoValOrVar(catchParameter, VAL_OR_VAR_ON_CATCH_PARAMETER); + modifiersChecking.checkParameterHasNoModifier(catchParameter); VariableDescriptor variableDescriptor = components.descriptorResolver.resolveLocalVariableDescriptor( context.scope, catchParameter, context.trace); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingComponents.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingComponents.java index 45bd05ae3fd..2ab29e3cded 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingComponents.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingComponents.java @@ -51,6 +51,7 @@ public class ExpressionTypingComponents { /*package*/ ValueParameterResolver valueParameterResolver; /*package*/ MultiDeclarationResolver multiDeclarationResolver; /*package*/ ConstantExpressionEvaluator constantExpressionEvaluator; + /*package*/ ModifiersChecker modifiersChecker; @Inject public void setGlobalContext(@NotNull GlobalContext globalContext) { @@ -161,4 +162,9 @@ public class ExpressionTypingComponents { public void setConstantExpressionEvaluator(@NotNull ConstantExpressionEvaluator constantExpressionEvaluator) { this.constantExpressionEvaluator = constantExpressionEvaluator; } + + @Inject + public void setModifiersChecker(ModifiersChecker modifiersChecker) { + this.modifiersChecker = modifiersChecker; + } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorForStatements.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorForStatements.java index 30e12e7e517..2d6c0b3c9e9 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorForStatements.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorForStatements.java @@ -162,7 +162,7 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito } scope.addVariableDescriptor(propertyDescriptor); - ModifiersChecker.create(context.trace, components.additionalCheckerProvider).checkModifiersForLocalDeclaration(property, propertyDescriptor); + components.modifiersChecker.withTrace(context.trace).checkModifiersForLocalDeclaration(property, propertyDescriptor); return typeInfo.replaceType(DataFlowUtils.checkStatementType(property, context)); } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt index dfa6f649dd9..d3ee6f82cc3 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt @@ -103,8 +103,7 @@ public class FunctionsTypingVisitor(facade: ExpressionTypingInternals) : Express function.getValueParameters(), functionDescriptor.getValueParameters(), context.scope, context.dataFlowInfo, context.trace ) - ModifiersChecker.create(context.trace, components.additionalCheckerProvider) - .checkModifiersForLocalDeclaration(function, functionDescriptor) + components.modifiersChecker.withTrace(context.trace).checkModifiersForLocalDeclaration(function, functionDescriptor) if (!function.hasBody()) { context.trace.report(NON_MEMBER_FUNCTION_NO_BODY.on(function, functionDescriptor)) }