From 065798281a495d44fcbe95cd9b8e6d217994aebc Mon Sep 17 00:00:00 2001 From: Alexey Kudravtsev Date: Wed, 29 Dec 2021 15:40:56 +0100 Subject: [PATCH] cleanup GitOrigin-RevId: b9620e6f5df659a1547053feea885e2b1873731f --- ...tractApplicationConfigurationProducer.java | 4 +- .../ApplicationRunLineMarkerProvider.java | 4 +- .../analysis/AnnotationsHighlightUtil.java | 48 +-- .../impl/analysis/GenericsHighlightUtil.java | 294 ++++++++--------- .../analysis/HighlightControlFlowUtil.java | 112 +++---- .../impl/analysis/HighlightMethodUtil.java | 96 +++--- .../impl/analysis/HighlightNamesUtil.java | 24 +- .../daemon/impl/analysis/HighlightUtil.java | 310 +++++++++--------- .../impl/analysis/HighlightingFeature.java | 26 +- .../impl/analysis/JavaHighlightUtil.java | 54 ++- .../impl/analysis/LambdaHighlightingUtil.java | 16 +- .../analysis/PostHighlightingVisitor.java | 48 +-- .../analysis/PreviewFeatureVisitorBase.java | 52 +-- .../PsiMethodReferenceHighlightingUtil.java | 18 +- .../daemon/impl/analysis/RefCountHolder.java | 2 +- .../impl/analysis/RemoveNewKeywordFix.java | 10 +- .../JavaOutOfSourcesResolveScopeProvider.java | 8 +- .../WrongPackageStatementInspection.java | 4 +- .../daemon/JavaProblemHighlightFilter.java | 4 +- .../daemon/LightJava11HighlightingTest.kt | 4 +- 20 files changed, 582 insertions(+), 556 deletions(-) diff --git a/java/execution/impl/src/com/intellij/execution/application/AbstractApplicationConfigurationProducer.java b/java/execution/impl/src/com/intellij/execution/application/AbstractApplicationConfigurationProducer.java index 8ce97bb1b531..12bc5161a39d 100644 --- a/java/execution/impl/src/com/intellij/execution/application/AbstractApplicationConfigurationProducer.java +++ b/java/execution/impl/src/com/intellij/execution/application/AbstractApplicationConfigurationProducer.java @@ -2,7 +2,7 @@ package com.intellij.execution.application; import com.intellij.codeInsight.TestFrameworks; -import com.intellij.codeInsight.daemon.impl.analysis.HighlightClassUtil; +import com.intellij.codeInsight.daemon.impl.analysis.JavaHighlightUtil; import com.intellij.execution.JavaExecutionUtil; import com.intellij.execution.Location; import com.intellij.execution.actions.ConfigurationContext; @@ -46,7 +46,7 @@ public abstract class AbstractApplicationConfigurationProducer names = new HashSet<>(); PsiNameValuePair[] attributes = annotation.getParameterList().getAttributes(); for (PsiNameValuePair attribute : attributes) { - final String name = attribute.getName(); + String name = attribute.getName(); names.add(Objects.requireNonNullElse(name, PsiAnnotation.DEFAULT_REFERENCED_METHOD_NAME)); } @@ -345,7 +345,7 @@ public final class AnnotationsHighlightUtil { } static HighlightInfo checkConstantExpression(@NotNull PsiExpression expression) { - final PsiElement parent = expression.getParent(); + PsiElement parent = expression.getParent(); if (PsiUtil.isAnnotationMethod(parent) || parent instanceof PsiNameValuePair || parent instanceof PsiArrayInitializerMemberValue) { if (!PsiUtil.isConstantExpression(expression)) { String description = JavaErrorBundle.message("annotation.non.constant.attribute.value"); @@ -428,7 +428,7 @@ public final class AnnotationsHighlightUtil { return annotationError(annotation, message); } if (typeElement.isInferredType()) { - final HighlightInfo info = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) + HighlightInfo info = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(annotation) .descriptionAndTooltip(JavaErrorBundle.message("annotation.not.allowed.var")) .create(); @@ -459,10 +459,10 @@ public final class AnnotationsHighlightUtil { } @Nullable - private static HighlightInfo annotationError(@NotNull final PsiAnnotation annotation, - @NotNull final @NlsContexts.DetailedDescription String message, - @NotNull final IntentionAction fix) { - final HighlightInfo info = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) + private static HighlightInfo annotationError(@NotNull PsiAnnotation annotation, + @NotNull @NlsContexts.DetailedDescription String message, + @NotNull IntentionAction fix) { + HighlightInfo info = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(annotation) .descriptionAndTooltip(message) .create(); @@ -473,16 +473,16 @@ public final class AnnotationsHighlightUtil { @Nullable private static HighlightInfo checkReferenceTarget(@NotNull PsiAnnotation annotation, @Nullable PsiJavaCodeReferenceElement ref) { if (ref == null) return null; - final PsiElement refTarget = ref.resolve(); + PsiElement refTarget = ref.resolve(); if (refTarget == null) return null; if (!(refTarget instanceof PsiClass)) { return annotationError(annotation, JavaErrorBundle.message("annotation.not.allowed.ref")); } - final PsiElement parent = ref.getParent(); + PsiElement parent = ref.getParent(); if (parent instanceof PsiJavaCodeReferenceElement) { - final PsiElement qualified = ((PsiJavaCodeReferenceElement)parent).resolve(); + PsiElement qualified = ((PsiJavaCodeReferenceElement)parent).resolve(); if (qualified instanceof PsiMember && ((PsiMember)qualified).hasModifierProperty(PsiModifier.STATIC)) { return annotationError(annotation, JavaErrorBundle.message("annotation.not.allowed.static"), @@ -528,13 +528,13 @@ public final class AnnotationsHighlightUtil { private static boolean cyclicDependencies(@NotNull PsiClass aClass, @Nullable PsiType type, @NotNull Set checked) { - final PsiClass resolvedClass = PsiUtil.resolveClassInType(type); + PsiClass resolvedClass = PsiUtil.resolveClassInType(type); if (resolvedClass != null && resolvedClass.isAnnotationType()) { if (aClass == resolvedClass) { return true; } if (!checked.add(resolvedClass) || !BaseIntentionAction.canModify(resolvedClass)) return false; - final PsiMethod[] methods = resolvedClass.getMethods(); + PsiMethod[] methods = resolvedClass.getMethods(); for (PsiMethod method : methods) { if (cyclicDependencies(aClass, method.getReturnType(), checked)) return true; } @@ -543,13 +543,13 @@ public final class AnnotationsHighlightUtil { } static HighlightInfo checkClashesWithSuperMethods(@NotNull PsiAnnotationMethod psiMethod) { - final PsiIdentifier nameIdentifier = psiMethod.getNameIdentifier(); + PsiIdentifier nameIdentifier = psiMethod.getNameIdentifier(); if (nameIdentifier != null) { - final PsiMethod[] methods = psiMethod.findDeepestSuperMethods(); + PsiMethod[] methods = psiMethod.findDeepestSuperMethods(); for (PsiMethod method : methods) { - final PsiClass containingClass = method.getContainingClass(); + PsiClass containingClass = method.getContainingClass(); if (containingClass != null) { - final String qualifiedName = containingClass.getQualifiedName(); + String qualifiedName = containingClass.getQualifiedName(); if (CommonClassNames.JAVA_LANG_OBJECT.equals(qualifiedName) || CommonClassNames.JAVA_LANG_ANNOTATION_ANNOTATION.equals(qualifiedName)) { return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(nameIdentifier).descriptionAndTooltip( JavaErrorBundle.message("error.interface.member.clashes", JavaHighlightUtil.formatMethod(method), @@ -635,11 +635,11 @@ public final class AnnotationsHighlightUtil { static HighlightInfo checkFunctionalInterface(@NotNull PsiAnnotation annotation, @NotNull LanguageLevel languageLevel) { if (languageLevel.isAtLeast(LanguageLevel.JDK_1_8) && Comparing.strEqual(annotation.getQualifiedName(), CommonClassNames.JAVA_LANG_FUNCTIONAL_INTERFACE)) { - final PsiAnnotationOwner owner = annotation.getOwner(); + PsiAnnotationOwner owner = annotation.getOwner(); if (owner instanceof PsiModifierList) { - final PsiElement parent = ((PsiModifierList)owner).getParent(); + PsiElement parent = ((PsiModifierList)owner).getParent(); if (parent instanceof PsiClass) { - final String errorMessage = LambdaHighlightingUtil.checkInterfaceFunctional((PsiClass)parent, JavaErrorBundle.message("not.a.functional.interface", ((PsiClass)parent).getName())); + String errorMessage = LambdaHighlightingUtil.checkInterfaceFunctional((PsiClass)parent, JavaErrorBundle.message("not.a.functional.interface", ((PsiClass)parent).getName())); if (errorMessage != null) { HighlightInfo info = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(annotation).descriptionAndTooltip(errorMessage).create(); diff --git a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/GenericsHighlightUtil.java b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/GenericsHighlightUtil.java index eadc9603f728..b70caba39557 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/GenericsHighlightUtil.java +++ b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/GenericsHighlightUtil.java @@ -52,11 +52,11 @@ public final class GenericsHighlightUtil { @NotNull PsiElement call, @NotNull PsiSubstitutor substitutor) { PsiTypeParameter[] typeParameters = listOwner.getTypeParameters(); - final Pair inferredTypeArgument = GenericsUtil.findTypeParameterWithBoundError(typeParameters, substitutor, + Pair inferredTypeArgument = GenericsUtil.findTypeParameterWithBoundError(typeParameters, substitutor, call, false); if (inferredTypeArgument != null) { - final PsiType extendsType = inferredTypeArgument.second; - final PsiTypeParameter typeParameter = inferredTypeArgument.first; + PsiType extendsType = inferredTypeArgument.second; + PsiTypeParameter typeParameter = inferredTypeArgument.first; PsiClass boundClass = extendsType instanceof PsiClassType ? ((PsiClassType)extendsType).resolve() : null; @NonNls String messageKey = boundClass == null || typeParameter.isInterface() == boundClass.isInterface() @@ -80,7 +80,7 @@ public final class GenericsHighlightUtil { @NotNull PsiSubstitutor substitutor, @NotNull JavaSdkVersion javaSdkVersion) { if (!(resolved instanceof PsiTypeParameterListOwner)) return null; - final PsiTypeParameterListOwner typeParameterListOwner = (PsiTypeParameterListOwner)resolved; + PsiTypeParameterListOwner typeParameterListOwner = (PsiTypeParameterListOwner)resolved; return checkReferenceTypeArgumentList(typeParameterListOwner, referenceElement.getParameterList(), substitutor, true, javaSdkVersion); } @@ -95,7 +95,7 @@ public final class GenericsHighlightUtil { referenceElements = referenceParameterList.getTypeParameterElements(); if (referenceElements.length == 1 && referenceElements[0].getType() instanceof PsiDiamondType) { if (!typeParameterListOwner.hasTypeParameters()) { - final String description = JavaErrorBundle.message("generics.diamond.not.applicable"); + String description = JavaErrorBundle.message("generics.diamond.not.applicable"); HighlightInfo info = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(referenceParameterList).descriptionAndTooltip(description) .create(); @@ -103,9 +103,9 @@ public final class GenericsHighlightUtil { return info; } inferenceResult = ((PsiDiamondType)referenceElements[0].getType()).resolveInferredTypes(); - final String errorMessage = inferenceResult.getErrorMessage(); + String errorMessage = inferenceResult.getErrorMessage(); if (errorMessage != null) { - final PsiType expectedType = detectExpectedType(referenceParameterList); + PsiType expectedType = detectExpectedType(referenceParameterList); if (!(inferenceResult.failedToInfer() && expectedType instanceof PsiClassType && ((PsiClassType)expectedType).isRaw())) { HighlightInfo highlightInfo = HighlightInfo .newHighlightInfo(HighlightInfoType.ERROR).range(referenceParameterList).descriptionAndTooltip(errorMessage).create(); @@ -134,11 +134,11 @@ public final class GenericsHighlightUtil { } } - final PsiTypeParameter[] typeParameters = typeParameterListOwner.getTypeParameters(); - final int targetParametersNum = typeParameters.length; - final int refParametersNum = referenceParameterList == null ? 0 : referenceParameterList.getTypeArguments().length; + PsiTypeParameter[] typeParameters = typeParameterListOwner.getTypeParameters(); + int targetParametersNum = typeParameters.length; + int refParametersNum = referenceParameterList == null ? 0 : referenceParameterList.getTypeArguments().length; if (targetParametersNum != refParametersNum && refParametersNum != 0) { - final String description; + String description; if (targetParametersNum == 0) { if (PsiTreeUtil.getParentOfType(referenceParameterList, PsiCall.class) != null && typeParameterListOwner instanceof PsiMethod && @@ -184,17 +184,17 @@ public final class GenericsHighlightUtil { // bounds check if (targetParametersNum > 0 && refParametersNum != 0) { if (inferenceResult != null) { - final PsiType[] types = inferenceResult.getTypes(); + PsiType[] types = inferenceResult.getTypes(); for (int i = 0; i < typeParameters.length; i++) { - final PsiType type = types[i]; - final HighlightInfo highlightInfo = checkTypeParameterWithinItsBound(typeParameters[i], substitutor, type, referenceElements[0], referenceParameterList); + PsiType type = types[i]; + HighlightInfo highlightInfo = checkTypeParameterWithinItsBound(typeParameters[i], substitutor, type, referenceElements[0], referenceParameterList); if (highlightInfo != null) return highlightInfo; } } else { for (int i = 0; i < typeParameters.length; i++) { - final PsiTypeElement typeElement = referenceElements[i]; - final HighlightInfo highlightInfo = checkTypeParameterWithinItsBound(typeParameters[i], substitutor, typeElement.getType(), typeElement, referenceParameterList); + PsiTypeElement typeElement = referenceElements[i]; + HighlightInfo highlightInfo = checkTypeParameterWithinItsBound(typeParameters[i], substitutor, typeElement.getType(), typeElement, referenceParameterList); if (highlightInfo != null) return highlightInfo; } } @@ -211,9 +211,9 @@ public final class GenericsHighlightUtil { } private static PsiType detectExpectedType(@NotNull PsiReferenceParameterList referenceParameterList) { - final PsiNewExpression newExpression = PsiTreeUtil.getParentOfType(referenceParameterList, PsiNewExpression.class); + PsiNewExpression newExpression = PsiTreeUtil.getParentOfType(referenceParameterList, PsiNewExpression.class); LOG.assertTrue(newExpression != null); - final PsiElement parent = newExpression.getParent(); + PsiElement parent = newExpression.getParent(); PsiType expectedType = null; if (parent instanceof PsiVariable && newExpression.equals(((PsiVariable)parent).getInitializer())) { expectedType = ((PsiVariable)parent).getType(); @@ -228,16 +228,16 @@ public final class GenericsHighlightUtil { } } else if (parent instanceof PsiExpressionList) { - final PsiElement pParent = parent.getParent(); + PsiElement pParent = parent.getParent(); if (pParent instanceof PsiCallExpression) { PsiExpressionList argumentList = ((PsiCallExpression)pParent).getArgumentList(); if (parent.equals(argumentList)) { - final PsiMethod method = ((PsiCallExpression)pParent).resolveMethod(); + PsiMethod method = ((PsiCallExpression)pParent).resolveMethod(); if (method != null) { - final PsiExpression[] expressions = argumentList.getExpressions(); - final int idx = ArrayUtilRt.find(expressions, newExpression); + PsiExpression[] expressions = argumentList.getExpressions(); + int idx = ArrayUtilRt.find(expressions, newExpression); if (idx > -1) { - final PsiParameter parameter = method.getParameterList().getParameter(idx); + PsiParameter parameter = method.getParameterList().getParameter(idx); if (parameter != null) { expectedType = parameter.getType(); } @@ -254,22 +254,22 @@ public final class GenericsHighlightUtil { @NotNull PsiType type, @NotNull PsiElement typeElement2Highlight, @Nullable PsiReferenceParameterList referenceParameterList) { - final PsiClass referenceClass = type instanceof PsiClassType ? ((PsiClassType)type).resolve() : null; - final PsiType psiType = substitutor.substitute(classParameter); + PsiClass referenceClass = type instanceof PsiClassType ? ((PsiClassType)type).resolve() : null; + PsiType psiType = substitutor.substitute(classParameter); if (psiType instanceof PsiClassType && !(PsiUtil.resolveClassInType(psiType) instanceof PsiTypeParameter)) { if (GenericsUtil.checkNotInBounds(type, psiType, referenceParameterList)) { - final String description = JavaErrorBundle.message("actual.type.argument.contradict.inferred.type"); + String description = JavaErrorBundle.message("actual.type.argument.contradict.inferred.type"); return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(typeElement2Highlight).descriptionAndTooltip(description).create(); } } - final PsiClassType[] bounds = classParameter.getSuperTypes(); + PsiClassType[] bounds = classParameter.getSuperTypes(); for (PsiType bound : bounds) { bound = substitutor.substitute(bound); if (!bound.equalsToText(CommonClassNames.JAVA_LANG_OBJECT) && GenericsUtil.checkNotInBounds(type, bound, referenceParameterList)) { PsiClass boundClass = bound instanceof PsiClassType ? ((PsiClassType)bound).resolve() : null; - @NonNls final String messageKey = boundClass == null || referenceClass == null || referenceClass.isInterface() == boundClass.isInterface() + @NonNls String messageKey = boundClass == null || referenceClass == null || referenceClass.isInterface() == boundClass.isInterface() ? "generics.type.parameter.is.not.within.its.bound.extend" : "generics.type.parameter.is.not.within.its.bound.implement"; @@ -277,7 +277,7 @@ public final class GenericsHighlightUtil { referenceClass != null ? HighlightUtil.formatClass(referenceClass) : type.getPresentableText(), JavaHighlightUtil.formatType(bound)); - final HighlightInfo info = + HighlightInfo info = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(typeElement2Highlight).descriptionAndTooltip(description).create(); if (bound instanceof PsiClassType && referenceClass != null && info != null) { QuickFixAction @@ -322,7 +322,7 @@ public final class GenericsHighlightUtil { @NotNull PsiClass aClass, @NotNull JavaResolveResult resolveResult, @NotNull PsiElement element) { - final PsiJavaCodeReferenceElement[] referenceElements = referenceList.getReferenceElements(); + PsiJavaCodeReferenceElement[] referenceElements = referenceList.getReferenceElements(); PsiClass extendFrom = (PsiClass)resolveResult.getElement(); if (extendFrom == null) return null; HighlightInfo errorResult = null; @@ -334,7 +334,7 @@ public final class GenericsHighlightUtil { QuickFixAction.registerQuickFixAction(errorResult, QUICK_FIX_FACTORY.createMoveBoundClassToFrontFix(aClass, type), null); } else if (referenceElements.length != 0 && element != referenceElements[0] && referenceElements[0].resolve() instanceof PsiTypeParameter) { - final String description = JavaErrorBundle.message("type.parameter.cannot.be.followed.by.other.bounds"); + String description = JavaErrorBundle.message("type.parameter.cannot.be.followed.by.other.bounds"); errorResult = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(element).descriptionAndTooltip(description).create(); PsiClassType type = JavaPsiFacade.getElementFactory(aClass.getProject()).createType(extendFrom, resolveResult.getSubstitutor()); @@ -344,9 +344,9 @@ public final class GenericsHighlightUtil { } static HighlightInfo checkInterfaceMultipleInheritance(@NotNull PsiClass aClass) { - final PsiClassType[] types = aClass.getSuperTypes(); + PsiClassType[] types = aClass.getSuperTypes(); if (types.length < 2) return null; - final TextRange textRange = HighlightNamesUtil.getClassDeclarationTextRange(aClass); + TextRange textRange = HighlightNamesUtil.getClassDeclarationTextRange(aClass); return checkInterfaceMultipleInheritance(aClass, aClass, PsiSubstitutor.EMPTY, new HashMap<>(), @@ -359,9 +359,9 @@ public final class GenericsHighlightUtil { @NotNull Map inheritedClasses, @NotNull Set visited, @NotNull TextRange textRange) { - final List superTypes = PsiClassImplUtil.getScopeCorrectedSuperTypes(aClass, place.getResolveScope()); + List superTypes = PsiClassImplUtil.getScopeCorrectedSuperTypes(aClass, place.getResolveScope()); for (PsiClassType.ClassResolveResult result : superTypes) { - final PsiClass superClass = result.getElement(); + PsiClass superClass = result.getElement(); if (superClass == null || visited.contains(superClass)) continue; PsiSubstitutor superTypeSubstitutor = result.getSubstitutor(); PsiElementFactory elementFactory = JavaPsiFacade.getElementFactory(aClass.getProject()); @@ -369,9 +369,9 @@ public final class GenericsHighlightUtil { superTypeSubstitutor = PsiUtil.isRawSubstitutor(aClass, derivedSubstitutor) ? elementFactory.createRawSubstitutor(superClass) : MethodSignatureUtil.combineSubstitutors(superTypeSubstitutor, derivedSubstitutor); - final PsiSubstitutor inheritedSubstitutor = inheritedClasses.get(superClass); + PsiSubstitutor inheritedSubstitutor = inheritedClasses.get(superClass); if (inheritedSubstitutor != null) { - final PsiTypeParameter[] typeParameters = superClass.getTypeParameters(); + PsiTypeParameter[] typeParameters = superClass.getTypeParameters(); for (PsiTypeParameter typeParameter : typeParameters) { PsiType type1 = inheritedSubstitutor.substitute(typeParameter); PsiType type2 = superTypeSubstitutor.substitute(typeParameter); @@ -395,7 +395,7 @@ public final class GenericsHighlightUtil { } inheritedClasses.put(superClass, superTypeSubstitutor); visited.add(superClass); - final HighlightInfo highlightInfo = checkInterfaceMultipleInheritance(superClass, place, superTypeSubstitutor, inheritedClasses, visited, textRange); + HighlightInfo highlightInfo = checkInterfaceMultipleInheritance(superClass, place, superTypeSubstitutor, inheritedClasses, visited, textRange); visited.remove(superClass); if (highlightInfo != null) return highlightInfo; @@ -406,12 +406,12 @@ public final class GenericsHighlightUtil { @NotNull static Collection checkOverrideEquivalentMethods(@NotNull PsiClass aClass) { List result = new ArrayList<>(); - final Collection signaturesWithSupers = aClass.getVisibleSignatures(); + Collection signaturesWithSupers = aClass.getVisibleSignatures(); PsiManager manager = aClass.getManager(); Map sameErasureMethods = MethodSignatureUtil.createErasedMethodSignatureMap(); - final Set foundProblems = MethodSignatureUtil.createErasedMethodSignatureSet(); + Set foundProblems = MethodSignatureUtil.createErasedMethodSignatureSet(); for (HierarchicalMethodSignature signature : signaturesWithSupers) { HighlightInfo info = checkSameErasureNotSubSignatureInner(signature, manager, aClass, sameErasureMethods); if (info != null && foundProblems.add(signature)) { @@ -435,8 +435,8 @@ public final class GenericsHighlightUtil { if (languageLevel.isAtLeast(LanguageLevel.JDK_1_8) && aClass.isInterface() && method.hasModifierProperty(PsiModifier.DEFAULT)) { HierarchicalMethodSignature sig = method.getHierarchicalMethodSignature(); for (HierarchicalMethodSignature methodSignature : sig.getSuperSignatures()) { - final PsiMethod objectMethod = methodSignature.getMethod(); - final PsiClass containingClass = objectMethod.getContainingClass(); + PsiMethod objectMethod = methodSignature.getMethod(); + PsiClass containingClass = objectMethod.getContainingClass(); if (containingClass != null && CommonClassNames.JAVA_LANG_OBJECT.equals(containingClass.getQualifiedName()) && objectMethod.hasModifierProperty(PsiModifier.PUBLIC)) { return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .descriptionAndTooltip(JavaErrorBundle.message("default.method.overrides.object.member", sig.getName())) @@ -458,13 +458,13 @@ public final class GenericsHighlightUtil { @NotNull Collection overrideEquivalentSuperMethods, boolean skipMethodInSelf) { if (overrideEquivalentSuperMethods.size() <= 1) return null; - final boolean isInterface = aClass.isInterface(); + boolean isInterface = aClass.isInterface(); List defaults = null; List abstracts = null; boolean hasConcrete = false; for (PsiMethod method : overrideEquivalentSuperMethods) { - final boolean isDefault = method.hasModifierProperty(PsiModifier.DEFAULT); - final boolean isAbstract = method.hasModifierProperty(PsiModifier.ABSTRACT); + boolean isDefault = method.hasModifierProperty(PsiModifier.DEFAULT); + boolean isAbstract = method.hasModifierProperty(PsiModifier.ABSTRACT); if (isDefault) { if (defaults == null) defaults = new ArrayList<>(2); defaults.add(method); @@ -477,11 +477,11 @@ public final class GenericsHighlightUtil { } if (!hasConcrete && defaults != null) { - final PsiMethod defaultMethod = defaults.get(0); + PsiMethod defaultMethod = defaults.get(0); if (!skipMethodInSelf && MethodSignatureUtil.findMethodBySuperMethod(aClass, defaultMethod, false) != null) return null; - final PsiClass defaultMethodContainingClass = defaultMethod.getContainingClass(); + PsiClass defaultMethodContainingClass = defaultMethod.getContainingClass(); if (defaultMethodContainingClass == null) return null; - final PsiMethod unrelatedMethod; + PsiMethod unrelatedMethod; if (abstracts != null) { unrelatedMethod = abstracts.get(0); } @@ -491,7 +491,7 @@ public final class GenericsHighlightUtil { else { return null; } - final PsiClass unrelatedMethodContainingClass = unrelatedMethod.getContainingClass(); + PsiClass unrelatedMethodContainingClass = unrelatedMethod.getContainingClass(); if (unrelatedMethodContainingClass == null) return null; if (!aClass.hasModifierProperty(PsiModifier.ABSTRACT) && !(aClass instanceof PsiTypeParameter) && abstracts != null && unrelatedMethodContainingClass.isInterface()) { @@ -500,7 +500,7 @@ public final class GenericsHighlightUtil { defaultMethod.getSignature(PsiSubstitutor.EMPTY))) { return null; } - final String key = aClass instanceof PsiEnumConstantInitializer || aClass.isRecord() ? + String key = aClass instanceof PsiEnumConstantInitializer || aClass.isRecord() ? "class.must.implement.method" : "class.must.be.abstract"; return JavaErrorBundle.message(key, HighlightUtil.formatClass(aClass, false), @@ -508,8 +508,8 @@ public final class GenericsHighlightUtil { HighlightUtil.formatClass(unrelatedMethodContainingClass, false)); } if (isInterface || abstracts == null || unrelatedMethodContainingClass.isInterface()) { - final List defaultContainingClasses = ContainerUtil.mapNotNull(defaults, PsiMethod::getContainingClass); - final String unrelatedDefaults = hasUnrelatedDefaults(defaultContainingClasses); + List defaultContainingClasses = ContainerUtil.mapNotNull(defaults, PsiMethod::getContainingClass); + String unrelatedDefaults = hasUnrelatedDefaults(defaultContainingClasses); if (unrelatedDefaults == null && (abstracts == null || !hasNotOverriddenAbstract(defaultContainingClasses, unrelatedMethodContainingClass))) { return null; @@ -533,12 +533,12 @@ public final class GenericsHighlightUtil { } static HighlightInfo checkUnrelatedDefaultMethods(@NotNull PsiClass aClass, @NotNull PsiIdentifier classIdentifier) { - final Map> overrideEquivalent = PsiSuperMethodUtil.collectOverrideEquivalents(aClass); + Map> overrideEquivalent = PsiSuperMethodUtil.collectOverrideEquivalents(aClass); for (Set overrideEquivalentMethods : overrideEquivalent.values()) { String errorMessage = getUnrelatedDefaultsMessage(aClass, overrideEquivalentMethods, false); if (errorMessage != null) { - final HighlightInfo info = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) + HighlightInfo info = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(classIdentifier) .descriptionAndTooltip(errorMessage) .create(); @@ -562,7 +562,7 @@ public final class GenericsHighlightUtil { if (defaults.size() > 1) { PsiClass[] defaultClasses = defaults.toArray(PsiClass.EMPTY_ARRAY); ArrayList classes = new ArrayList<>(defaults); - for (final PsiClass aClass1 : defaultClasses) { + for (PsiClass aClass1 : defaultClasses) { classes.removeIf(aClass2 -> aClass1.isInheritor(aClass2, true)); } @@ -577,34 +577,34 @@ public final class GenericsHighlightUtil { static HighlightInfo checkUnrelatedConcrete(@NotNull PsiClass psiClass, @NotNull PsiIdentifier classIdentifier) { - final PsiClass superClass = psiClass.getSuperClass(); + PsiClass superClass = psiClass.getSuperClass(); if (superClass != null && superClass.hasTypeParameters()) { - final Collection visibleSignatures = superClass.getVisibleSignatures(); - final Map overrideEquivalent = MethodSignatureUtil.createErasedMethodSignatureMap(); + Collection visibleSignatures = superClass.getVisibleSignatures(); + Map overrideEquivalent = MethodSignatureUtil.createErasedMethodSignatureMap(); for (HierarchicalMethodSignature hms : visibleSignatures) { - final PsiMethod method = hms.getMethod(); + PsiMethod method = hms.getMethod(); if (method.isConstructor()) continue; if (method.hasModifierProperty(PsiModifier.ABSTRACT) || method.hasModifierProperty(PsiModifier.DEFAULT) || method.hasModifierProperty(PsiModifier.STATIC)) continue; if (psiClass.findMethodsBySignature(method, false).length > 0) continue; - final PsiClass containingClass = method.getContainingClass(); + PsiClass containingClass = method.getContainingClass(); if (containingClass == null) continue; - final PsiSubstitutor containingClassSubstitutor = TypeConversionUtil.getSuperClassSubstitutor(containingClass, psiClass, PsiSubstitutor.EMPTY); - final PsiSubstitutor finalSubstitutor = PsiSuperMethodUtil + PsiSubstitutor containingClassSubstitutor = TypeConversionUtil.getSuperClassSubstitutor(containingClass, psiClass, PsiSubstitutor.EMPTY); + PsiSubstitutor finalSubstitutor = PsiSuperMethodUtil .obtainFinalSubstitutor(containingClass, containingClassSubstitutor, hms.getSubstitutor(), false); - final MethodSignatureBackedByPsiMethod signature = MethodSignatureBackedByPsiMethod.create(method, finalSubstitutor, false); - final PsiMethod foundMethod = overrideEquivalent.get(signature); + MethodSignatureBackedByPsiMethod signature = MethodSignatureBackedByPsiMethod.create(method, finalSubstitutor, false); + PsiMethod foundMethod = overrideEquivalent.get(signature); PsiClass foundMethodContainingClass; if (foundMethod != null && !foundMethod.hasModifierProperty(PsiModifier.ABSTRACT) && !foundMethod.hasModifierProperty(PsiModifier.DEFAULT) && (foundMethodContainingClass = foundMethod.getContainingClass()) != null) { - final String description = + String description = JavaErrorBundle.message("two.methods.are.inherited.with.same.signature", JavaHighlightUtil.formatMethod(foundMethod), HighlightUtil.formatClass(foundMethodContainingClass), JavaHighlightUtil.formatMethod(method), HighlightUtil.formatClass(containingClass)); - final HighlightInfo info = HighlightInfo + HighlightInfo info = HighlightInfo .newHighlightInfo(HighlightInfoType.ERROR).range(classIdentifier).descriptionAndTooltip( description) .create(); @@ -645,7 +645,7 @@ public final class GenericsHighlightUtil { if (info != null) return info; if (superSignature.isRaw() && !signature.isRaw()) { - final PsiType[] parameterTypes = signature.getParameterTypes(); + PsiType[] parameterTypes = signature.getParameterTypes(); PsiType[] erasedTypes = superSignature.getErasedParameterTypes(); for (int i = 0; i < erasedTypes.length; i++) { if (!Comparing.equal(parameterTypes[i], erasedTypes[i])) { @@ -663,7 +663,7 @@ public final class GenericsHighlightUtil { @NotNull HierarchicalMethodSignature superSignature, @NotNull PsiClass aClass, @NotNull PsiMethod superMethod) { - final PsiMethod checkMethod = signatureToCheck.getMethod(); + PsiMethod checkMethod = signatureToCheck.getMethod(); if (superMethod.equals(checkMethod)) return null; PsiClass checkContainingClass = checkMethod.getContainingClass(); LOG.assertTrue(checkContainingClass != null); @@ -675,7 +675,7 @@ public final class GenericsHighlightUtil { else if (superMethod.isConstructor()) return null; JavaVersionService javaVersionService = JavaVersionService.getInstance(); - final boolean atLeast17 = javaVersionService.isAtLeast(aClass, JavaSdkVersion.JDK_1_7); + boolean atLeast17 = javaVersionService.isAtLeast(aClass, JavaSdkVersion.JDK_1_7); if (checkMethod.hasModifierProperty(PsiModifier.STATIC) && !checkEqualsSuper && !atLeast17) { return null; } @@ -685,8 +685,8 @@ public final class GenericsHighlightUtil { return null; } - final PsiType retErasure1 = TypeConversionUtil.erasure(checkMethod.getReturnType()); - final PsiType retErasure2 = TypeConversionUtil.erasure(superMethod.getReturnType()); + PsiType retErasure1 = TypeConversionUtil.erasure(checkMethod.getReturnType()); + PsiType retErasure2 = TypeConversionUtil.erasure(superMethod.getReturnType()); boolean differentReturnTypeErasure = !Comparing.equal(retErasure1, retErasure2); if (checkEqualsSuper && atLeast17 && retErasure1 != null && retErasure2 != null) { @@ -699,7 +699,7 @@ public final class GenericsHighlightUtil { !(checkEqualsSuper && Arrays.equals(superSignature.getParameterTypes(), signatureToCheck.getParameterTypes())) && !atLeast17) { int idx = 0; - final PsiType[] erasedTypes = signatureToCheck.getErasedParameterTypes(); + PsiType[] erasedTypes = signatureToCheck.getErasedParameterTypes(); boolean erasure = erasedTypes.length > 0; for (PsiType type : superSignature.getParameterTypes()) { erasure &= Comparing.equal(type, erasedTypes[idx]); @@ -725,9 +725,9 @@ public final class GenericsHighlightUtil { } } - private static HighlightInfo getSameErasureMessage(final boolean sameClass, @NotNull PsiMethod method, @NotNull PsiMethod superMethod, + private static HighlightInfo getSameErasureMessage(boolean sameClass, @NotNull PsiMethod method, @NotNull PsiMethod superMethod, @NotNull TextRange textRange) { - @NonNls final String key = sameClass ? "generics.methods.have.same.erasure" : + @NonNls String key = sameClass ? "generics.methods.have.same.erasure" : method.hasModifierProperty(PsiModifier.STATIC) ? "generics.methods.have.same.erasure.hide" : "generics.methods.have.same.erasure.override"; @@ -742,8 +742,8 @@ public final class GenericsHighlightUtil { static HighlightInfo checkTypeParameterInstantiation(@NotNull PsiNewExpression expression) { PsiJavaCodeReferenceElement classReference = expression.getClassOrAnonymousClassReference(); if (classReference == null) return null; - final JavaResolveResult result = classReference.advancedResolve(false); - final PsiElement element = result.getElement(); + JavaResolveResult result = classReference.advancedResolve(false); + PsiElement element = result.getElement(); if (element instanceof PsiTypeParameter) { String description = JavaErrorBundle.message("generics.type.parameter.cannot.be.instantiated", HighlightUtil.formatClass((PsiTypeParameter)element)); @@ -785,10 +785,10 @@ public final class GenericsHighlightUtil { } static HighlightInfo checkReferenceTypeUsedAsTypeArgument(@NotNull PsiTypeElement typeElement, @NotNull LanguageLevel level) { - final PsiType type = typeElement.getType(); + PsiType type = typeElement.getType(); if (type != PsiType.NULL && type instanceof PsiPrimitiveType || type instanceof PsiWildcardType && ((PsiWildcardType)type).getBound() instanceof PsiPrimitiveType) { - final PsiElement element = new PsiMatcherImpl(typeElement) + PsiElement element = new PsiMatcherImpl(typeElement) .parent(PsiMatchers.hasClass(PsiReferenceParameterList.class)) .parent(PsiMatchers.hasClass(PsiJavaCodeReferenceElement.class, PsiNewExpression.class)) .getElement(); @@ -804,7 +804,7 @@ public final class GenericsHighlightUtil { toConvert = ((PsiWildcardType)type).getBound(); } if (toConvert instanceof PsiPrimitiveType) { - final PsiClassType boxedType = ((PsiPrimitiveType)toConvert).getBoxedType(typeElement); + PsiClassType boxedType = ((PsiPrimitiveType)toConvert).getBoxedType(typeElement); if (boxedType != null) { QuickFixAction.registerQuickFixAction(highlightInfo, QUICK_FIX_FACTORY.createReplacePrimitiveWithBoxedTypeAction( typeElement, toConvert.getPresentableText(), ((PsiPrimitiveType)toConvert).getBoxedTypeName())); @@ -818,11 +818,11 @@ public final class GenericsHighlightUtil { static HighlightInfo checkForeachExpressionTypeIsIterable(@NotNull PsiExpression expression) { if (expression.getType() == null) return null; - final PsiType itemType = JavaGenericsUtil.getCollectionItemType(expression); + PsiType itemType = JavaGenericsUtil.getCollectionItemType(expression); if (itemType == null) { String description = JavaErrorBundle.message("foreach.not.applicable", JavaHighlightUtil.formatType(expression.getType())); - final HighlightInfo highlightInfo = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(expression).descriptionAndTooltip(description).create(); + HighlightInfo highlightInfo = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(expression).descriptionAndTooltip(description).create(); QuickFixAction.registerQuickFixAction(highlightInfo, QUICK_FIX_FACTORY.createNotIterableForEachLoopFix(expression)); return highlightInfo; } @@ -830,11 +830,11 @@ public final class GenericsHighlightUtil { } static HighlightInfo checkForEachParameterType(@NotNull PsiForeachStatement statement, @NotNull PsiParameter parameter) { - final PsiExpression expression = statement.getIteratedValue(); - final PsiType itemType = expression == null ? null : JavaGenericsUtil.getCollectionItemType(expression); + PsiExpression expression = statement.getIteratedValue(); + PsiType itemType = expression == null ? null : JavaGenericsUtil.getCollectionItemType(expression); if (itemType == null) return null; - final PsiType parameterType = parameter.getType(); + PsiType parameterType = parameter.getType(); if (TypeConversionUtil.isAssignable(parameterType, itemType)) { return null; } @@ -869,7 +869,7 @@ public final class GenericsHighlightUtil { if (field.getContainingClass() != enumClass) return false; if (!JavaVersionService.getInstance().isAtLeast(field, JavaSdkVersion.JDK_1_6)) { - final PsiType type = field.getType(); + PsiType type = field.getType(); if (type instanceof PsiClassType && ((PsiClassType)type).resolve() == enumClass) return false; } @@ -883,7 +883,7 @@ public final class GenericsHighlightUtil { */ public static @Nullable PsiClass getEnumClassForExpressionInInitializer(@NotNull PsiExpression expr) { if (PsiImplUtil.getSwitchLabel(expr) != null) return null; - final PsiMember constructorOrInitializer = PsiUtil.findEnclosingConstructorOrInitializer(expr); + PsiMember constructorOrInitializer = PsiUtil.findEnclosingConstructorOrInitializer(expr); if (constructorOrInitializer == null) return null; if (constructorOrInitializer.hasModifierProperty(PsiModifier.STATIC)) return null; PsiClass enumClass = constructorOrInitializer instanceof PsiEnumConstantInitializer ? @@ -927,14 +927,14 @@ public final class GenericsHighlightUtil { static boolean isEnumSyntheticMethod(@NotNull MethodSignature methodSignature, @NotNull Project project) { if (methodSignature.equals(ourValuesEnumSyntheticMethod)) return true; - final PsiType javaLangString = PsiType.getJavaLangString(PsiManager.getInstance(project), GlobalSearchScope.allScope(project)); - final MethodSignature valueOfMethod = MethodSignatureUtil.createMethodSignature("valueOf", new PsiType[]{javaLangString}, PsiTypeParameter.EMPTY_ARRAY, + PsiType javaLangString = PsiType.getJavaLangString(PsiManager.getInstance(project), GlobalSearchScope.allScope(project)); + MethodSignature valueOfMethod = MethodSignatureUtil.createMethodSignature("valueOf", new PsiType[]{javaLangString}, PsiTypeParameter.EMPTY_ARRAY, PsiSubstitutor.EMPTY); return MethodSignatureUtil.areSignaturesErasureEqual(valueOfMethod, methodSignature); } static HighlightInfo checkTypeParametersList(@NotNull PsiTypeParameterList list, PsiTypeParameter @NotNull [] parameters, @NotNull LanguageLevel level) { - final PsiElement parent = list.getParent(); + PsiElement parent = list.getParent(); if (parent instanceof PsiClass && ((PsiClass)parent).isEnum()) { String description = JavaErrorBundle.message("generics.enum.may.not.have.type.parameters"); return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(list).descriptionAndTooltip(description).create(); @@ -949,12 +949,12 @@ public final class GenericsHighlightUtil { } for (int i = 0; i < parameters.length; i++) { - final PsiTypeParameter typeParameter1 = parameters[i]; - final HighlightInfo cyclicInheritance = HighlightClassUtil.checkCyclicInheritance(typeParameter1); + PsiTypeParameter typeParameter1 = parameters[i]; + HighlightInfo cyclicInheritance = HighlightClassUtil.checkCyclicInheritance(typeParameter1); if (cyclicInheritance != null) return cyclicInheritance; String name1 = typeParameter1.getName(); for (int j = i + 1; j < parameters.length; j++) { - final PsiTypeParameter typeParameter2 = parameters[j]; + PsiTypeParameter typeParameter2 = parameters[j]; String name2 = typeParameter2.getName(); if (Comparing.strEqual(name1, name2)) { String message = JavaErrorBundle.message("generics.duplicate.type.parameter", name1); @@ -963,7 +963,7 @@ public final class GenericsHighlightUtil { } if (!level.isAtLeast(LanguageLevel.JDK_1_7)) { for (PsiJavaCodeReferenceElement referenceElement : typeParameter1.getExtendsList().getReferenceElements()) { - final PsiElement resolve = referenceElement.resolve(); + PsiElement resolve = referenceElement.resolve(); if (resolve instanceof PsiTypeParameter && ArrayUtilRt.find(parameters, resolve) > i) { return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(referenceElement).descriptionAndTooltip( JavaErrorBundle.message("illegal.forward.reference")).create(); @@ -978,12 +978,12 @@ public final class GenericsHighlightUtil { static Collection checkCatchParameterIsClass(@NotNull PsiParameter parameter) { if (!(parameter.getDeclarationScope() instanceof PsiCatchSection)) return Collections.emptyList(); - final List typeElements = PsiUtil.getParameterTypeElements(parameter); - final Collection result = new ArrayList<>(typeElements.size()); + List typeElements = PsiUtil.getParameterTypeElements(parameter); + Collection result = new ArrayList<>(typeElements.size()); for (PsiTypeElement typeElement : typeElements) { - final PsiClass aClass = PsiUtil.resolveClassInClassTypeOnly(typeElement.getType()); + PsiClass aClass = PsiUtil.resolveClassInClassTypeOnly(typeElement.getType()); if (aClass instanceof PsiTypeParameter) { - final String message = JavaErrorBundle.message("generics.cannot.catch.type.parameters"); + String message = JavaErrorBundle.message("generics.cannot.catch.type.parameters"); result.add(HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(typeElement).descriptionAndTooltip(message).create()); } } @@ -992,7 +992,7 @@ public final class GenericsHighlightUtil { } static HighlightInfo checkInstanceOfGenericType(@NotNull LanguageLevel languageLevel, @NotNull PsiInstanceOfExpression expression) { - final PsiTypeElement checkTypeElement = expression.getCheckType(); + PsiTypeElement checkTypeElement = expression.getCheckType(); if (checkTypeElement == null) return null; PsiType checkType = checkTypeElement.getType(); if (HighlightingFeature.PATTERNS.isSufficient(languageLevel)) { @@ -1015,7 +1015,7 @@ public final class GenericsHighlightUtil { * ReferenceType mentioned after the instanceof operator is reifiable */ private static HighlightInfo isIllegalForInstanceOf(@Nullable PsiType type, @NotNull PsiTypeElement typeElement) { - final PsiClass resolved = PsiUtil.resolveClassInClassTypeOnly(type); + PsiClass resolved = PsiUtil.resolveClassInClassTypeOnly(type); if (resolved instanceof PsiTypeParameter) { String description = JavaErrorBundle.message("generics.cannot.instanceof.type.parameters"); return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(typeElement).descriptionAndTooltip(description).create(); @@ -1035,7 +1035,7 @@ public final class GenericsHighlightUtil { return canSelectFrom((PsiClassType)type, expression.getOperand()); } if (type instanceof PsiArrayType) { - final PsiType arrayComponentType = type.getDeepComponentType(); + PsiType arrayComponentType = type.getDeepComponentType(); if (arrayComponentType instanceof PsiClassType) { return canSelectFrom((PsiClassType)arrayComponentType, expression.getOperand()); } @@ -1063,8 +1063,8 @@ public final class GenericsHighlightUtil { try { MethodSignatureBackedByPsiMethod superMethod = SuperMethodsSearch.search(method, null, true, false).findFirst(); if (superMethod != null && method.getContainingClass().isInterface()) { - final PsiMethod psiMethod = superMethod.getMethod(); - final PsiClass containingClass = psiMethod.getContainingClass(); + PsiMethod psiMethod = superMethod.getMethod(); + PsiClass containingClass = psiMethod.getContainingClass(); if (containingClass != null && CommonClassNames.JAVA_LANG_OBJECT.equals(containingClass.getQualifiedName()) && psiMethod.hasModifierProperty(PsiModifier.PROTECTED)) { @@ -1102,7 +1102,7 @@ public final class GenericsHighlightUtil { static HighlightInfo checkSafeVarargsAnnotation(@NotNull PsiMethod method, @NotNull LanguageLevel languageLevel) { PsiModifierList list = method.getModifierList(); - final PsiAnnotation safeVarargsAnnotation = list.findAnnotation(CommonClassNames.JAVA_LANG_SAFE_VARARGS); + PsiAnnotation safeVarargsAnnotation = list.findAnnotation(CommonClassNames.JAVA_LANG_SAFE_VARARGS); if (safeVarargsAnnotation == null) { return null; } @@ -1119,7 +1119,7 @@ public final class GenericsHighlightUtil { } PsiParameterList parameterList = method.getParameterList(); - final PsiParameter varParameter = Objects.requireNonNull(parameterList.getParameter(parameterList.getParametersCount() - 1)); + PsiParameter varParameter = Objects.requireNonNull(parameterList.getParameter(parameterList.getParametersCount() - 1)); for (PsiReferenceExpression element : VariableAccessUtils.getVariableReferences(varParameter, method.getBody())) { if (!PsiUtil.isAccessedForReading(element)) { @@ -1130,8 +1130,8 @@ public final class GenericsHighlightUtil { LOG.assertTrue(varParameter.isVarArgs()); - final PsiEllipsisType ellipsisType = (PsiEllipsisType)varParameter.getType(); - final PsiType componentType = ellipsisType.getComponentType(); + PsiEllipsisType ellipsisType = (PsiEllipsisType)varParameter.getType(); + PsiType componentType = ellipsisType.getComponentType(); if (JavaGenericsUtil.isReifiableType(componentType)) { PsiElement element = varParameter.getTypeElement(); return HighlightInfo.newHighlightInfo(HighlightInfoType.WARNING).range(element).descriptionAndTooltip( @@ -1176,13 +1176,13 @@ public final class GenericsHighlightUtil { static HighlightInfo checkEnumSuperConstructorCall(@NotNull PsiMethodCallExpression expr) { PsiReferenceExpression methodExpression = expr.getMethodExpression(); - final PsiElement refNameElement = methodExpression.getReferenceNameElement(); + PsiElement refNameElement = methodExpression.getReferenceNameElement(); if (refNameElement != null && PsiKeyword.SUPER.equals(refNameElement.getText())) { - final PsiMember constructor = PsiUtil.findEnclosingConstructorOrInitializer(expr); + PsiMember constructor = PsiUtil.findEnclosingConstructorOrInitializer(expr); if (constructor instanceof PsiMethod) { - final PsiClass aClass = constructor.getContainingClass(); + PsiClass aClass = constructor.getContainingClass(); if (aClass != null && aClass.isEnum()) { - final String message = JavaErrorBundle.message("call.to.super.is.not.allowed.in.enum.constructor"); + String message = JavaErrorBundle.message("call.to.super.is.not.allowed.in.enum.constructor"); return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(expr).descriptionAndTooltip(message).create(); } } @@ -1221,11 +1221,11 @@ public final class GenericsHighlightUtil { } static HighlightInfo checkParametersAllowed(@NotNull PsiReferenceParameterList refParamList) { - final PsiElement parent = refParamList.getParent(); + PsiElement parent = refParamList.getParent(); if (parent instanceof PsiReferenceExpression) { - final PsiElement grandParent = parent.getParent(); + PsiElement grandParent = parent.getParent(); if (!(grandParent instanceof PsiMethodCallExpression) && !(parent instanceof PsiMethodReferenceExpression)) { - final String message = JavaErrorBundle.message("generics.reference.parameters.not.allowed"); + String message = JavaErrorBundle.message("generics.reference.parameters.not.allowed"); return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(refParamList).descriptionAndTooltip(message).create(); } } @@ -1245,7 +1245,7 @@ public final class GenericsHighlightUtil { else if (parent instanceof PsiCallExpression) { resolveResult = ((PsiCallExpression)parent).resolveMethodGenerics(); if (parent instanceof PsiMethodCallExpression) { - final PsiReferenceExpression methodExpression = ((PsiMethodCallExpression)parent).getMethodExpression(); + PsiReferenceExpression methodExpression = ((PsiMethodCallExpression)parent).getMethodExpression(); qualifier = methodExpression.getQualifier(); } } @@ -1260,16 +1260,16 @@ public final class GenericsHighlightUtil { if (languageLevel.isAtLeast(LanguageLevel.JDK_1_7)) return null; if (((PsiMethod)element).findSuperMethods().length > 0) return null; if (qualifier instanceof PsiReferenceExpression) { - final PsiType type = ((PsiReferenceExpression)qualifier).getType(); - final boolean isJavac7 = JavaVersionService.getInstance().isAtLeast(containingClass, JavaSdkVersion.JDK_1_7); + PsiType type = ((PsiReferenceExpression)qualifier).getType(); + boolean isJavac7 = JavaVersionService.getInstance().isAtLeast(containingClass, JavaSdkVersion.JDK_1_7); if (type instanceof PsiClassType && isJavac7 && ((PsiClassType)type).isRaw()) return null; - final PsiClass typeParameter = PsiUtil.resolveClassInType(type); + PsiClass typeParameter = PsiUtil.resolveClassInType(type); if (typeParameter instanceof PsiTypeParameter) { if (isJavac7) return null; for (PsiClassType classType : typeParameter.getExtendsListTypes()) { - final PsiClass resolve = classType.resolve(); + PsiClass resolve = classType.resolve(); if (resolve != null) { - final PsiMethod[] superMethods = resolve.findMethodsBySignature((PsiMethod)element, true); + PsiMethod[] superMethods = resolve.findMethodsBySignature((PsiMethod)element, true); for (PsiMethod superMethod : superMethods) { if (!PsiUtil.isRawSubstitutor(superMethod, resolveResult.getSubstitutor())) { return null; @@ -1280,7 +1280,7 @@ public final class GenericsHighlightUtil { } } } - final String message = element instanceof PsiClass + String message = element instanceof PsiClass ? JavaErrorBundle.message("generics.type.arguments.on.raw.type") : JavaErrorBundle.message("generics.type.arguments.on.raw.method"); @@ -1349,11 +1349,11 @@ public final class GenericsHighlightUtil { static HighlightInfo checkSelectStaticClassFromParameterizedType(@Nullable PsiElement resolved, @NotNull PsiJavaCodeReferenceElement ref) { if (resolved instanceof PsiClass && ((PsiClass)resolved).hasModifierProperty(PsiModifier.STATIC)) { - final PsiElement qualifier = ref.getQualifier(); + PsiElement qualifier = ref.getQualifier(); if (qualifier instanceof PsiJavaCodeReferenceElement) { - final PsiReferenceParameterList parameterList = ((PsiJavaCodeReferenceElement)qualifier).getParameterList(); + PsiReferenceParameterList parameterList = ((PsiJavaCodeReferenceElement)qualifier).getParameterList(); if (parameterList != null && parameterList.getTypeArguments().length > 0) { - final String message = JavaErrorBundle.message("generics.select.static.class.from.parameterized.type", + String message = JavaErrorBundle.message("generics.select.static.class.from.parameterized.type", HighlightUtil.formatClass((PsiClass)resolved)); return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(parameterList).descriptionAndTooltip(message).create(); } @@ -1376,13 +1376,13 @@ public final class GenericsHighlightUtil { static HighlightInfo checkRawOnParameterizedType(@NotNull PsiJavaCodeReferenceElement parent, @Nullable PsiElement resolved) { PsiReferenceParameterList list = parent.getParameterList(); if (list == null || list.getTypeArguments().length > 0) return null; - final PsiElement qualifier = parent.getQualifier(); + PsiElement qualifier = parent.getQualifier(); if (qualifier instanceof PsiJavaCodeReferenceElement && ((PsiJavaCodeReferenceElement)qualifier).getTypeParameters().length > 0 && resolved instanceof PsiTypeParameterListOwner && ((PsiTypeParameterListOwner)resolved).hasTypeParameters() && !((PsiTypeParameterListOwner)resolved).hasModifierProperty(PsiModifier.STATIC)) { - final String message = JavaErrorBundle.message("text.improper.formed.type"); + String message = JavaErrorBundle.message("text.improper.formed.type"); return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(parent).descriptionAndTooltip(message).create(); } return null; @@ -1399,7 +1399,7 @@ public final class GenericsHighlightUtil { String shortName = ((PsiClassType)type).getClassName(); PsiManager manager = parameterList.getManager(); - final JavaPsiFacade facade = JavaPsiFacade.getInstance(manager.getProject()); + JavaPsiFacade facade = JavaPsiFacade.getInstance(manager.getProject()); PsiShortNamesCache shortNamesCache = PsiShortNamesCache.getInstance(parameterList.getProject()); PsiClass[] classes = shortNamesCache.getClassesByName(shortName, GlobalSearchScope.allScope(manager.getProject())); PsiElementFactory factory = facade.getElementFactory(); @@ -1426,10 +1426,10 @@ public final class GenericsHighlightUtil { static HighlightInfo checkInferredIntersections(@NotNull PsiSubstitutor substitutor, @NotNull PsiMethodCallExpression call) { for (Map.Entry typeEntry : substitutor.getSubstitutionMap().entrySet()) { - final String parameterName = typeEntry.getKey().getName(); - final PsiType type = typeEntry.getValue(); + String parameterName = typeEntry.getKey().getName(); + PsiType type = typeEntry.getValue(); if (type instanceof PsiIntersectionType) { - final String conflictingConjunctsMessage = ((PsiIntersectionType)type).getConflictingConjunctsMessage(); + String conflictingConjunctsMessage = ((PsiIntersectionType)type).getConflictingConjunctsMessage(); if (conflictingConjunctsMessage != null) { return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .descriptionAndTooltip( @@ -1454,11 +1454,11 @@ public final class GenericsHighlightUtil { private static HighlightInfo.Builder checkClassSupersAccessibility(@NotNull PsiClass aClass, @NotNull GlobalSearchScope resolveScope, boolean checkParameters) { - final JavaPsiFacade factory = JavaPsiFacade.getInstance(aClass.getProject()); + JavaPsiFacade factory = JavaPsiFacade.getInstance(aClass.getProject()); for (PsiClassType superType : aClass.getSuperTypes()) { HashSet checked = new HashSet<>(); checked.add(aClass); - final String notAccessibleErrorMessage = isTypeAccessible(superType, checked, checkParameters, resolveScope, factory); + String notAccessibleErrorMessage = isTypeAccessible(superType, checked, checkParameters, resolveScope, factory); if (notAccessibleErrorMessage != null) { return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .descriptionAndTooltip(notAccessibleErrorMessage); @@ -1470,15 +1470,15 @@ public final class GenericsHighlightUtil { static HighlightInfo checkMemberSignatureTypesAccessibility(@NotNull PsiReferenceExpression ref) { String message = null; - final PsiElement parent = ref.getParent(); + PsiElement parent = ref.getParent(); if (parent instanceof PsiMethodCallExpression) { - final JavaResolveResult resolveResult = ((PsiMethodCallExpression)parent).resolveMethodGenerics(); - final PsiMethod method = (PsiMethod)resolveResult.getElement(); + JavaResolveResult resolveResult = ((PsiMethodCallExpression)parent).resolveMethodGenerics(); + PsiMethod method = (PsiMethod)resolveResult.getElement(); if (method != null) { - final Set classes = new HashSet<>(); - final JavaPsiFacade facade = JavaPsiFacade.getInstance(ref.getProject()); - final PsiSubstitutor substitutor = resolveResult.getSubstitutor(); - final GlobalSearchScope resolveScope = ref.getResolveScope(); + Set classes = new HashSet<>(); + JavaPsiFacade facade = JavaPsiFacade.getInstance(ref.getProject()); + PsiSubstitutor substitutor = resolveResult.getSubstitutor(); + GlobalSearchScope resolveScope = ref.getResolveScope(); message = isTypeAccessible(substitutor.substitute(method.getReturnType()), classes, false, resolveScope, facade); if (message == null) { @@ -1492,10 +1492,10 @@ public final class GenericsHighlightUtil { } } else { - final PsiElement resolve = ref.resolve(); + PsiElement resolve = ref.resolve(); if (resolve instanceof PsiField) { - final GlobalSearchScope resolveScope = ref.getResolveScope(); - final JavaPsiFacade facade = JavaPsiFacade.getInstance(ref.getProject()); + GlobalSearchScope resolveScope = ref.getResolveScope(); + JavaPsiFacade facade = JavaPsiFacade.getInstance(ref.getProject()); message = isTypeAccessible(((PsiField)resolve).getType(), new HashSet<>(), false, resolveScope, facade); } } @@ -1518,7 +1518,7 @@ public final class GenericsHighlightUtil { @NotNull JavaPsiFacade factory) { type = PsiClassImplUtil.correctType(type, resolveScope); - final PsiClass aClass = PsiUtil.resolveClassInType(type); + PsiClass aClass = PsiUtil.resolveClassInType(type); if (aClass != null && classes.add(aClass)) { VirtualFile vFile = PsiUtilCore.getVirtualFile(aClass); if (vFile == null) { @@ -1529,7 +1529,7 @@ public final class GenericsHighlightUtil { return null; } - final String qualifiedName = aClass.getQualifiedName(); + String qualifiedName = aClass.getQualifiedName(); if (qualifiedName != null && factory.findClass(qualifiedName, resolveScope) == null) { return JavaErrorBundle.message("text.class.cannot.access", HighlightUtil.formatClass(aClass)); } @@ -1540,7 +1540,7 @@ public final class GenericsHighlightUtil { if (type instanceof PsiClassType) { for (PsiType parameterType : ((PsiClassType)type).getParameters()) { - final String notAccessibleMessage = isTypeAccessible(parameterType, classes, true, resolveScope, factory); + String notAccessibleMessage = isTypeAccessible(parameterType, classes, true, resolveScope, factory); if (notAccessibleMessage != null) { return notAccessibleMessage; } @@ -1549,7 +1549,7 @@ public final class GenericsHighlightUtil { boolean isInLibrary = !index.isInContent(vFile); for (PsiClassType superType : aClass.getSuperTypes()) { - final String notAccessibleMessage = isTypeAccessible(superType, classes, !isInLibrary, resolveScope, factory); + String notAccessibleMessage = isTypeAccessible(superType, classes, !isInLibrary, resolveScope, factory); if (notAccessibleMessage != null) { return notAccessibleMessage; } @@ -1561,10 +1561,10 @@ public final class GenericsHighlightUtil { static HighlightInfo checkTypeParameterOverrideEquivalentMethods(@NotNull PsiClass aClass, @NotNull LanguageLevel level) { if (aClass instanceof PsiTypeParameter && level.isAtLeast(LanguageLevel.JDK_1_7)) { - final PsiReferenceList extendsList = aClass.getExtendsList(); + PsiReferenceList extendsList = aClass.getExtendsList(); if (extendsList != null && extendsList.getReferenceElements().length > 1) { //todo suppress erased methods which come from the same class - final Collection result = checkOverrideEquivalentMethods(aClass); + Collection result = checkOverrideEquivalentMethods(aClass); if (!result.isEmpty()) { return result.iterator().next(); } diff --git a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightControlFlowUtil.java b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightControlFlowUtil.java index e7ede9d6faaf..2ea24e829d66 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightControlFlowUtil.java +++ b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightControlFlowUtil.java @@ -85,7 +85,7 @@ public final class HighlightControlFlowUtil { // see JLS 14.20 Unreachable Statements try { AllVariablesControlFlowPolicy policy = AllVariablesControlFlowPolicy.getInstance(); - final ControlFlow controlFlow = ControlFlowFactory.getControlFlow(codeBlock, policy, ControlFlowOptions.NO_CONST_EVALUATE); + ControlFlow controlFlow = ControlFlowFactory.getControlFlow(codeBlock, policy, ControlFlowOptions.NO_CONST_EVALUATE); PsiElement unreachableStatement = ControlFlowUtil.getUnreachableStatement(controlFlow); if (unreachableStatement != null) { if (unreachableStatement instanceof PsiCodeBlock && unreachableStatement.getParent() instanceof PsiBlockStatement) { @@ -117,8 +117,8 @@ public final class HighlightControlFlowUtil { unreachableStatement instanceof PsiLabeledStatement) { keyword = unreachableStatement.getFirstChild(); } - final PsiElement element = keyword != null ? keyword : unreachableStatement; - final HighlightInfo info = + PsiElement element = keyword != null ? keyword : unreachableStatement; + HighlightInfo info = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(element).descriptionAndTooltip(description).create(); QuickFixAction.registerQuickFixAction( info, QUICK_FIX_FACTORY.createDeleteFix(unreachableStatement, QuickFixBundle.message("delete.unreachable.statement.fix.text"))); @@ -133,13 +133,13 @@ public final class HighlightControlFlowUtil { public static boolean isFieldInitializedAfterObjectConstruction(@NotNull PsiField field) { if (field.hasInitializer()) return true; - final boolean isFieldStatic = field.hasModifierProperty(PsiModifier.STATIC); - final PsiClass aClass = field.getContainingClass(); + boolean isFieldStatic = field.hasModifierProperty(PsiModifier.STATIC); + PsiClass aClass = field.getContainingClass(); if (aClass != null) { // field might be assigned in the other field initializers if (isFieldInitializedInOtherFieldInitializer(aClass, field, isFieldStatic, __->true)) return true; } - final PsiClassInitializer[] initializers; + PsiClassInitializer[] initializers; if (aClass != null) { initializers = aClass.getInitializers(); } @@ -152,16 +152,16 @@ public final class HighlightControlFlowUtil { } else { // instance field should be initialized at the end of each constructor - final PsiMethod[] constructors = aClass.getConstructors(); + PsiMethod[] constructors = aClass.getConstructors(); if (constructors.length == 0) return false; nextConstructor: for (PsiMethod constructor : constructors) { PsiCodeBlock ctrBody = constructor.getBody(); if (ctrBody == null) return false; - final List redirectedConstructors = JavaHighlightUtil.getChainedConstructors(constructor); + List redirectedConstructors = JavaHighlightUtil.getChainedConstructors(constructor); for (PsiMethod redirectedConstructor : redirectedConstructors) { - final PsiCodeBlock body = redirectedConstructor.getBody(); + PsiCodeBlock body = redirectedConstructor.getBody(); if (body != null && variableDefinitelyAssignedIn(field, body)) continue nextConstructor; } if (!ctrBody.isValid() || variableDefinitelyAssignedIn(field, ctrBody)) { @@ -182,7 +182,7 @@ public final class HighlightControlFlowUtil { private static boolean isFieldInitializedInOtherFieldInitializer(@NotNull PsiClass aClass, @NotNull PsiField field, - final boolean fieldStatic, + boolean fieldStatic, @NotNull Predicate condition) { PsiField[] fields = aClass.getFields(); for (PsiField psiField : fields) { @@ -197,7 +197,7 @@ public final class HighlightControlFlowUtil { } static boolean isRecursivelyCalledConstructor(@NotNull PsiMethod constructor) { - final JavaHighlightUtil.ConstructorVisitorInfo info = new JavaHighlightUtil.ConstructorVisitorInfo(); + JavaHighlightUtil.ConstructorVisitorInfo info = new JavaHighlightUtil.ConstructorVisitorInfo(); JavaHighlightUtil.visitConstructorChain(constructor, info); if (info.recursivelyCalledConstructor == null) return false; // our constructor is reached from some other constructor by constructor chain @@ -215,7 +215,7 @@ public final class HighlightControlFlowUtil { private volatile boolean myIsWriteRefFound; @Override public boolean process(PsiReference reference) { - final PsiElement element = reference.getElement(); + PsiElement element = reference.getElement(); if (element instanceof PsiReferenceExpression && PsiUtil.isAccessedForWriting((PsiExpression)element)) { myIsWriteRefFound = true; return false; @@ -279,7 +279,7 @@ public final class HighlightControlFlowUtil { QuickFixAction.registerQuickFixAction(highlightInfo, HighlightMethodUtil.getFixRange(field), QUICK_FIX_FACTORY.createCreateConstructorParameterFromFieldFix(field)); QuickFixAction.registerQuickFixAction(highlightInfo, HighlightMethodUtil.getFixRange(field), QUICK_FIX_FACTORY.createInitializeFinalFieldInConstructorFix(field)); QuickFixAction.registerQuickFixAction(highlightInfo, QUICK_FIX_FACTORY.createAddVariableInitializerFix(field)); - final PsiClass containingClass = field.getContainingClass(); + PsiClass containingClass = field.getContainingClass(); if (containingClass != null && !containingClass.isInterface()) { QuickFixAction.registerQuickFixAction(highlightInfo, QUICK_FIX_FACTORY.createModifierListFix(field, PsiModifier.FINAL, false, false)); } @@ -302,7 +302,7 @@ public final class HighlightControlFlowUtil { if (variable instanceof ImplicitVariable) return null; if (!PsiUtil.isAccessedForReading(expression)) return null; int startOffset = expression.getTextRange().getStartOffset(); - final PsiElement topBlock; + PsiElement topBlock; if (variable.hasInitializer()) { topBlock = PsiUtil.getVariableCodeBlock(variable, variable); if (topBlock == null) return null; @@ -326,18 +326,18 @@ public final class HighlightControlFlowUtil { return null; } if (topBlock == null) return null; - final PsiElement parent = topBlock.getParent(); + PsiElement parent = topBlock.getParent(); // access to final fields from inner classes always allowed if (inInnerClass(expression, ((PsiField)variable).getContainingClass())) return null; - final PsiCodeBlock block; - final PsiClass aClass; + PsiCodeBlock block; + PsiClass aClass; if (parent instanceof PsiMethod) { PsiMethod constructor = (PsiMethod)parent; if (!containingFile.getManager().areElementsEquivalent(constructor.getContainingClass(), ((PsiField)variable).getContainingClass())) return null; // static variables already initialized in class initializers if (variable.hasModifierProperty(PsiModifier.STATIC)) return null; // as a last chance, field may be initialized in this() call - final List redirectedConstructors = JavaHighlightUtil.getChainedConstructors(constructor); + List redirectedConstructors = JavaHighlightUtil.getChainedConstructors(constructor); for (PsiMethod redirectedConstructor : redirectedConstructors) { // variable must be initialized before its usage //??? @@ -352,7 +352,7 @@ public final class HighlightControlFlowUtil { aClass = constructor.getContainingClass(); } else if (parent instanceof PsiClassInitializer) { - final PsiClassInitializer classInitializer = (PsiClassInitializer)parent; + PsiClassInitializer classInitializer = (PsiClassInitializer)parent; if (!containingFile.getManager().areElementsEquivalent(classInitializer.getContainingClass(), ((PsiField)variable).getContainingClass())) return null; block = classInitializer.getBody(); aClass = classInitializer.getContainingClass(); @@ -362,10 +362,10 @@ public final class HighlightControlFlowUtil { else { // field reference outside code block // check variable initialized before its usage - final PsiField field = (PsiField)variable; + PsiField field = (PsiField)variable; aClass = field.getContainingClass(); - final PsiField anotherField = PsiTreeUtil.getTopmostParentOfType(expression, PsiField.class); + PsiField anotherField = PsiTreeUtil.getTopmostParentOfType(expression, PsiField.class); if (aClass == null || isFieldInitializedInOtherFieldInitializer(aClass, field, field.hasModifierProperty(PsiModifier.STATIC), psiField -> startOffset > psiField.getTextOffset())) { return null; @@ -381,7 +381,7 @@ public final class HighlightControlFlowUtil { } block = null; // initializers will be checked later - final PsiMethod[] constructors = aClass.getConstructors(); + PsiMethod[] constructors = aClass.getConstructors(); for (PsiMethod constructor : constructors) { // variable must be initialized before its usage if (offset < constructor.getTextRange().getStartOffset()) continue; @@ -390,7 +390,7 @@ public final class HighlightControlFlowUtil { return null; } // as a last chance, field may be initialized in this() call - final List redirectedConstructors = JavaHighlightUtil.getChainedConstructors(constructor); + List redirectedConstructors = JavaHighlightUtil.getChainedConstructors(constructor); for (PsiMethod redirectedConstructor : redirectedConstructors) { // variable must be initialized before its usage if (offset < redirectedConstructor.getTextRange().getStartOffset()) continue; @@ -404,7 +404,7 @@ public final class HighlightControlFlowUtil { if (aClass != null) { // field may be initialized in class initializer - final PsiClassInitializer[] initializers = aClass.getInitializers(); + PsiClassInitializer[] initializers = aClass.getInitializers(); for (PsiClassInitializer initializer : initializers) { PsiCodeBlock body = initializer.getBody(); if (body == block) break; @@ -424,7 +424,7 @@ public final class HighlightControlFlowUtil { Collection codeBlockProblems = uninitializedVarProblems.get(topBlock); if (codeBlockProblems == null) { try { - final ControlFlow controlFlow = getControlFlow(topBlock); + ControlFlow controlFlow = getControlFlow(topBlock); codeBlockProblems = ControlFlowUtil.getReadBeforeWriteLocals(controlFlow); } catch (AnalysisCanceledException | IndexNotReadyException e) { @@ -433,7 +433,7 @@ public final class HighlightControlFlowUtil { uninitializedVarProblems.put(topBlock, codeBlockProblems); } if (codeBlockProblems.contains(expression)) { - final String name = expression.getElement().getText(); + String name = expression.getElement().getText(); String description = JavaErrorBundle.message("variable.not.initialized", name); HighlightInfo highlightInfo = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(expression).descriptionAndTooltip(description).create(); @@ -454,7 +454,7 @@ public final class HighlightControlFlowUtil { private static boolean inInnerClass(@NotNull PsiElement psiElement, @Nullable PsiClass containingClass) { for (PsiElement element = psiElement;element != null;element = element.getParent()) { if (element instanceof PsiClass) { - final boolean innerClass = !psiElement.getManager().areElementsEquivalent(element, containingClass); + boolean innerClass = !psiElement.getManager().areElementsEquivalent(element, containingClass); if (innerClass) { if (element instanceof PsiAnonymousClass) { if (PsiTreeUtil.isAncestor(((PsiAnonymousClass)element).getArgumentList(), psiElement, false)) { @@ -462,7 +462,7 @@ public final class HighlightControlFlowUtil { } return !insideClassInitialization(containingClass, (PsiClass)element); } - final PsiLambdaExpression lambdaExpression = PsiTreeUtil.getParentOfType(psiElement, PsiLambdaExpression.class); + PsiLambdaExpression lambdaExpression = PsiTreeUtil.getParentOfType(psiElement, PsiLambdaExpression.class); return lambdaExpression == null || !insideClassInitialization(containingClass, (PsiClass)element); } return false; @@ -487,15 +487,15 @@ public final class HighlightControlFlowUtil { public static boolean isReassigned(@NotNull PsiVariable variable, @NotNull Map> finalVarProblems) { if (variable instanceof PsiLocalVariable) { - final PsiElement parent = variable.getParent(); + PsiElement parent = variable.getParent(); if (parent == null) return false; - final PsiElement declarationScope = parent.getParent(); + PsiElement declarationScope = parent.getParent(); if (declarationScope == null) return false; Collection codeBlockProblems = getFinalVariableProblemsInBlock(finalVarProblems, declarationScope); return codeBlockProblems.contains(new ControlFlowUtil.VariableInfo(variable, null)); } if (variable instanceof PsiParameter) { - final PsiParameter parameter = (PsiParameter)variable; + PsiParameter parameter = (PsiParameter)variable; return isAssigned(parameter); } return false; @@ -507,7 +507,7 @@ public final class HighlightControlFlowUtil { @NotNull Map> finalVarProblems) { if (!PsiUtil.isAccessedForWriting(expression)) return null; - final PsiElement scope = variable instanceof PsiField ? variable.getParent() : + PsiElement scope = variable instanceof PsiField ? variable.getParent() : variable.getParent() == null ? null : variable.getParent().getParent(); PsiElement codeBlock = PsiUtil.getTopLevelEnclosingCodeBlock(expression, scope); if (codeBlock == null) return null; @@ -526,7 +526,7 @@ public final class HighlightControlFlowUtil { String description = JavaErrorBundle.message(inLoop ? "variable.assigned.in.loop" : "variable.already.assigned", variable.getName()); - final HighlightInfo highlightInfo = + HighlightInfo highlightInfo = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(expression).descriptionAndTooltip(description).create(); if (canDefer) { QuickFixAction.registerQuickFixAction(highlightInfo, QUICK_FIX_FACTORY.createDeferFinalAssignmentFix(variable, expression)); @@ -538,10 +538,10 @@ public final class HighlightControlFlowUtil { private static boolean isFieldInitializedInAnotherMember(@NotNull PsiField field, @NotNull PsiReferenceExpression expression, @NotNull PsiElement codeBlock) { - final PsiClass aClass = field.getContainingClass(); + PsiClass aClass = field.getContainingClass(); if (aClass == null) return false; boolean isFieldStatic = field.hasModifierProperty(PsiModifier.STATIC); - final PsiMember enclosingConstructorOrInitializer = PsiUtil.findEnclosingConstructorOrInitializer(expression); + PsiMember enclosingConstructorOrInitializer = PsiUtil.findEnclosingConstructorOrInitializer(expression); if (!isFieldStatic) { // constructor that delegates to another constructor cannot assign final fields @@ -581,7 +581,7 @@ public final class HighlightControlFlowUtil { Collection codeBlockProblems = finalVarProblems.get(codeBlock); if (codeBlockProblems == null) { try { - final ControlFlow controlFlow = getControlFlow(codeBlock); + ControlFlow controlFlow = getControlFlow(codeBlock); codeBlockProblems = ControlFlowUtil.getInitializedTwice(controlFlow); codeBlockProblems = addReassignedInLoopProblems(codeBlockProblems, controlFlow); } @@ -632,13 +632,13 @@ public final class HighlightControlFlowUtil { PsiReferenceExpression reference = ObjectUtils.tryCast(PsiUtil.skipParenthesizedExprDown(operand), PsiReferenceExpression.class); PsiVariable variable = reference == null ? null : ObjectUtils.tryCast(reference.resolve(), PsiVariable.class); if (variable == null || !variable.hasModifierProperty(PsiModifier.FINAL)) return null; - final boolean canWrite = canWriteToFinal(variable, expression, reference, containingFile) && checkWriteToFinalInsideLambda(variable, reference) == null; + boolean canWrite = canWriteToFinal(variable, expression, reference, containingFile) && checkWriteToFinalInsideLambda(variable, reference) == null; if (canWrite) return null; - final String name = variable.getName(); + String name = variable.getName(); String description = JavaErrorBundle.message("assignment.to.final.variable", name); - final HighlightInfo highlightInfo = + HighlightInfo highlightInfo = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(reference).descriptionAndTooltip(description).create(); - final PsiElement innerClass = getInnerClassVariableReferencedFrom(variable, expression); + PsiElement innerClass = getInnerClassVariableReferencedFrom(variable, expression); if (innerClass == null || variable instanceof PsiField) { HighlightFixUtil.registerMakeNotFinalAction(variable, highlightInfo); } @@ -661,7 +661,7 @@ public final class HighlightControlFlowUtil { // assignment from within inner class is illegal always PsiField field = (PsiField)variable; if (innerClass != null && !containingFile.getManager().areElementsEquivalent(innerClass, field.getContainingClass())) return false; - final PsiMember enclosingCtrOrInitializer = PsiUtil.findEnclosingConstructorOrInitializer(expression); + PsiMember enclosingCtrOrInitializer = PsiUtil.findEnclosingConstructorOrInitializer(expression); return enclosingCtrOrInitializer != null && !(enclosingCtrOrInitializer instanceof PsiMethod && JavaPsiRecordUtil.isCompactConstructor((PsiMethod)enclosingCtrOrInitializer)) && @@ -689,23 +689,23 @@ public final class HighlightControlFlowUtil { @NotNull PsiJavaCodeReferenceElement context, @NotNull LanguageLevel languageLevel) { if (variable.hasModifierProperty(PsiModifier.FINAL)) return null; - final PsiElement innerClass = getInnerClassVariableReferencedFrom(variable, context); + PsiElement innerClass = getInnerClassVariableReferencedFrom(variable, context); if (innerClass instanceof PsiClass) { if (variable instanceof PsiParameter) { - final PsiElement parent = variable.getParent(); + PsiElement parent = variable.getParent(); if (parent instanceof PsiParameterList && parent.getParent() instanceof PsiLambdaExpression && !VariableAccessUtils.variableIsAssigned(variable, ((PsiParameter)variable).getDeclarationScope())) { return null; } } - final boolean isToBeEffectivelyFinal = languageLevel.isAtLeast(LanguageLevel.JDK_1_8); + boolean isToBeEffectivelyFinal = languageLevel.isAtLeast(LanguageLevel.JDK_1_8); if (isToBeEffectivelyFinal && isEffectivelyFinal(variable, innerClass, context)) { return null; } - final String description = JavaErrorBundle + String description = JavaErrorBundle .message(isToBeEffectivelyFinal ? "variable.must.be.final.or.effectively.final" : "variable.must.be.final", context.getText()); - final HighlightInfo highlightInfo = + HighlightInfo highlightInfo = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(context).descriptionAndTooltip(description).create(); QuickFixAction.registerQuickFixAction(highlightInfo, QUICK_FIX_FACTORY.createVariableAccessFromInnerClassFix(variable, innerClass)); return highlightInfo; @@ -719,9 +719,9 @@ public final class HighlightControlFlowUtil { @Nullable private static HighlightInfo checkWriteToFinalInsideLambda(@NotNull PsiVariable variable, @NotNull PsiJavaCodeReferenceElement context) { - final PsiLambdaExpression lambdaExpression = PsiTreeUtil.getParentOfType(context, PsiLambdaExpression.class); + PsiLambdaExpression lambdaExpression = PsiTreeUtil.getParentOfType(context, PsiLambdaExpression.class); if (lambdaExpression != null && !PsiTreeUtil.isAncestor(lambdaExpression, variable, true)) { - final PsiElement parent = variable.getParent(); + PsiElement parent = variable.getParent(); if (parent instanceof PsiParameterList && parent.getParent() == lambdaExpression) { return null; } @@ -763,7 +763,7 @@ public final class HighlightControlFlowUtil { effectivelyFinal = !VariableAccessUtils.variableIsAssigned(variable, ((PsiParameter)variable).getDeclarationScope()); } else { - final ControlFlow controlFlow; + ControlFlow controlFlow; try { PsiElement codeBlock = PsiUtil.getVariableCodeBlock(variable, context); if (codeBlock == null) return true; @@ -773,10 +773,10 @@ public final class HighlightControlFlowUtil { return true; } - final Collection initializedTwice = ControlFlowUtil.getInitializedTwice(controlFlow); + Collection initializedTwice = ControlFlowUtil.getInitializedTwice(controlFlow); effectivelyFinal = !initializedTwice.contains(new ControlFlowUtil.VariableInfo(variable, null)); if (effectivelyFinal) { - final List readBeforeWriteLocals = ControlFlowUtil.getReadBeforeWriteLocals(controlFlow); + List readBeforeWriteLocals = ControlFlowUtil.getReadBeforeWriteLocals(controlFlow); for (PsiReferenceExpression expression : readBeforeWriteLocals) { if (expression.resolve() == variable) { return PsiUtil.isAccessedForReading(expression); @@ -798,12 +798,12 @@ public final class HighlightControlFlowUtil { } public static PsiElement getInnerClassVariableReferencedFrom(@NotNull PsiVariable variable, @NotNull PsiElement context) { - final PsiElement[] scope; + PsiElement[] scope; if (variable instanceof PsiResourceVariable) { scope = ((PsiResourceVariable)variable).getDeclarationScope(); } else if (variable instanceof PsiLocalVariable) { - final PsiElement parent = variable.getParent(); + PsiElement parent = variable.getParent(); scope = new PsiElement[]{parent != null ? parent.getParent() : null}; // code block or for statement } else if (variable instanceof PsiParameter) { @@ -833,11 +833,11 @@ public final class HighlightControlFlowUtil { } static HighlightInfo checkInitializerCompleteNormally(@NotNull PsiClassInitializer initializer) { - final PsiCodeBlock body = initializer.getBody(); + PsiCodeBlock body = initializer.getBody(); // unhandled exceptions already reported try { - final ControlFlow controlFlow = getControlFlowNoConstantEvaluate(body); - final int completionReasons = ControlFlowUtil.getCompletionReasons(controlFlow, 0, controlFlow.getSize()); + ControlFlow controlFlow = getControlFlowNoConstantEvaluate(body); + int completionReasons = ControlFlowUtil.getCompletionReasons(controlFlow, 0, controlFlow.getSize()); if (!BitUtil.isSet(completionReasons, ControlFlowUtil.NORMAL_COMPLETION_REASON)) { String description = JavaErrorBundle.message("initializer.must.be.able.to.complete.normally"); return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(body).descriptionAndTooltip(description).create(); diff --git a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightMethodUtil.java b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightMethodUtil.java index 0eabb82171a1..42426891d1f1 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightMethodUtil.java +++ b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightMethodUtil.java @@ -188,18 +188,18 @@ public final class HighlightMethodUtil { @NotNull @Nls String detailMessage, @NotNull TextRange range, @NotNull LanguageLevel languageLevel) { - final PsiClass superContainingClass = superMethod.getContainingClass(); + PsiClass superContainingClass = superMethod.getContainingClass(); if (superContainingClass != null && CommonClassNames.JAVA_LANG_OBJECT.equals(superContainingClass.getQualifiedName()) && !superMethod.hasModifierProperty(PsiModifier.PUBLIC)) { - final PsiClass containingClass = method.getContainingClass(); + PsiClass containingClass = method.getContainingClass(); if (containingClass != null && containingClass.isInterface() && !superContainingClass.isInterface()) { return null; } } PsiType substitutedSuperReturnType; - final boolean isJdk15 = languageLevel.isAtLeast(LanguageLevel.JDK_1_5); + boolean isJdk15 = languageLevel.isAtLeast(LanguageLevel.JDK_1_5); if (isJdk15 && !superMethodSignature.isRaw() && superMethodSignature.equals(methodSignature)) { //see 8.4.5 PsiSubstitutor unifyingSubstitutor = MethodSignatureUtil.getSuperMethodSignatureSubstitutor(methodSignature, superMethodSignature); @@ -242,7 +242,7 @@ public final class HighlightMethodUtil { QuickFixAction.registerQuickFixAction(errorResult, QUICK_FIX_FACTORY.createMethodReturnFix(method, substitutedSuperReturnType, false)); } QuickFixAction.registerQuickFixAction(errorResult, QUICK_FIX_FACTORY.createSuperMethodReturnFix(superMethod, returnType)); - final PsiClass returnClass = PsiUtil.resolveClassInClassTypeOnly(returnType); + PsiClass returnClass = PsiUtil.resolveClassInClassTypeOnly(returnType); if (returnClass != null && substitutedSuperReturnType instanceof PsiClassType) { QuickFixAction.registerQuickFixAction(errorResult, QUICK_FIX_FACTORY.createChangeParameterClassFix(returnClass, (PsiClassType)substitutedSuperReturnType)); } @@ -316,7 +316,7 @@ public final class HighlightMethodUtil { int index = getExtraExceptionNum(methodSignature, superMethodSignature, checkedExceptions, superSubstitutor); if (index != -1) { if (aClass.isInterface()) { - final PsiClass superContainingClass = superMethod.getContainingClass(); + PsiClass superContainingClass = superMethod.getContainingClass(); if (superContainingClass != null && !superContainingClass.isInterface()) continue; if (superContainingClass != null && !aClass.isInheritor(superContainingClass, true)) continue; } @@ -349,8 +349,8 @@ public final class HighlightMethodUtil { PsiMethod superMethod = superSignature.getMethod(); PsiSubstitutor substitutorForMethod = MethodSignatureUtil.getSuperMethodSignatureSubstitutor(methodSignature, superSignature); for (int i = 0; i < checkedExceptions.size(); i++) { - final PsiClassType checkedEx = checkedExceptions.get(i); - final PsiType substituted = substitutorForMethod == null ? TypeConversionUtil.erasure(checkedEx) : substitutorForMethod.substitute(checkedEx); + PsiClassType checkedEx = checkedExceptions.get(i); + PsiType substituted = substitutorForMethod == null ? TypeConversionUtil.erasure(checkedEx) : substitutorForMethod.substitute(checkedEx); PsiType exception = substitutorForDerivedClass.substitute(substituted); if (!isMethodThrows(superMethod, substitutorForMethod, exception, substitutorForDerivedClass)) { return i; @@ -388,7 +388,7 @@ public final class HighlightMethodUtil { if (isDummy) return; HighlightInfo highlightInfo; - final PsiSubstitutor substitutor = resolveResult.getSubstitutor(); + PsiSubstitutor substitutor = resolveResult.getSubstitutor(); if (resolved instanceof PsiMethod && resolveResult.isValidResult()) { highlightInfo = HighlightUtil.checkUnhandledExceptions(methodCall); @@ -495,8 +495,8 @@ public final class HighlightMethodUtil { String toolTip = null; List mismatchedExpressions; if (parent != null) { - final PsiExpression[] expressions = list.getExpressions(); - final PsiParameter[] parameters = resolvedMethod.getParameterList().getParameters(); + PsiExpression[] expressions = list.getExpressions(); + PsiParameter[] parameters = resolvedMethod.getParameterList().getParameters(); mismatchedExpressions = mismatchedArgs(expressions, substitutor, parameters, candidateInfo.isVarargs()); if (mismatchedExpressions.size() == 1) { toolTip = createOneArgMismatchTooltip(candidateInfo, mismatchedExpressions, expressions, parameters); @@ -540,8 +540,8 @@ public final class HighlightMethodUtil { @NotNull List mismatchedExpressions, PsiExpression[] expressions, PsiParameter[] parameters) { - final PsiExpression wrongArg = mismatchedExpressions.get(0); - final PsiType argType = wrongArg.getType(); + PsiExpression wrongArg = mismatchedExpressions.get(0); + PsiType argType = wrongArg.getType(); if (argType != null) { if ((parameters.length == 0 || !parameters[parameters.length - 1].isVarArgs()) && parameters.length != expressions.length) { return createMismatchedArgumentCountTooltip(parameters, expressions); @@ -691,10 +691,10 @@ public final class HighlightMethodUtil { @NotNull MethodCandidateInfo candidate, @NotNull PsiCall methodCall) { if (candidate.getInferenceErrorMessage() != null && methodCall.getParent() instanceof PsiReturnStatement) { - final PsiMethod containerMethod = PsiTreeUtil.getParentOfType(methodCall, PsiMethod.class, true, PsiLambdaExpression.class); + PsiMethod containerMethod = PsiTreeUtil.getParentOfType(methodCall, PsiMethod.class, true, PsiLambdaExpression.class); if (containerMethod != null) { - final PsiMethod method = candidate.getElement(); - final PsiExpression methodCallCopy = + PsiMethod method = candidate.getElement(); + PsiExpression methodCallCopy = JavaPsiFacade.getElementFactory(method.getProject()).createExpressionFromText(methodCall.getText(), methodCall); PsiType methodCallTypeByArgs = methodCallCopy.getType(); //ensure type params are not included @@ -816,7 +816,7 @@ public final class HighlightMethodUtil { static HighlightInfo checkAmbiguousMethodCallArguments(@NotNull PsiReferenceExpression referenceToMethod, JavaResolveResult @NotNull [] resolveResults, @NotNull PsiExpressionList list, - final PsiElement element, + PsiElement element, @NotNull JavaResolveResult resolveResult, @NotNull PsiMethodCallExpression methodCall, @NotNull PsiResolveHelper resolveHelper, @@ -921,9 +921,9 @@ public final class HighlightMethodUtil { @NotNull PsiExpressionList list, @NotNull PsiResolveHelper resolveHelper) { TextRange fixRange = getFixRange(methodCall); - final PsiExpression qualifierExpression = methodCall.getMethodExpression().getQualifierExpression(); + PsiExpression qualifierExpression = methodCall.getMethodExpression().getQualifierExpression(); if (qualifierExpression instanceof PsiReferenceExpression) { - final PsiElement resolve = ((PsiReferenceExpression)qualifierExpression).resolve(); + PsiElement resolve = ((PsiReferenceExpression)qualifierExpression).resolve(); if (resolve instanceof PsiClass && ((PsiClass)resolve).getContainingClass() != null && !((PsiClass)resolve).hasModifierProperty(PsiModifier.STATIC)) { @@ -1263,7 +1263,7 @@ public final class HighlightMethodUtil { boolean isPrivate = method.hasModifierProperty(PsiModifier.PRIVATE); boolean isConstructor = method.isConstructor(); - final List additionalFixes = new ArrayList<>(); + List additionalFixes = new ArrayList<>(); String description = null; if (hasNoBody) { if (isExtension) { @@ -1408,18 +1408,18 @@ public final class HighlightMethodUtil { PsiClass aClass = method.getContainingClass(); if (aClass == null) return null; - final HierarchicalMethodSignature methodSignature = PsiSuperMethodImplUtil.getHierarchicalMethodSignature(method); - final List superSignatures = methodSignature.getSuperSignatures(); + HierarchicalMethodSignature methodSignature = PsiSuperMethodImplUtil.getHierarchicalMethodSignature(method); + List superSignatures = methodSignature.getSuperSignatures(); if (superSignatures.isEmpty()) { return null; } boolean isStatic = method.hasModifierProperty(PsiModifier.STATIC); for (HierarchicalMethodSignature signature : superSignatures) { - final PsiMethod superMethod = signature.getMethod(); - final PsiClass superClass = superMethod.getContainingClass(); + PsiMethod superMethod = signature.getMethod(); + PsiClass superClass = superMethod.getContainingClass(); if (superClass == null) continue; - final HighlightInfo highlightInfo = checkStaticMethodOverride(aClass, method, isStatic, superClass, superMethod, containingFile); + HighlightInfo highlightInfo = checkStaticMethodOverride(aClass, method, isStatic, superClass, superMethod, containingFile); if (highlightInfo != null) { return highlightInfo; } @@ -1445,7 +1445,7 @@ public final class HighlightMethodUtil { boolean isSuperMethodStatic = superModifierList.hasModifierProperty(PsiModifier.STATIC); if (isMethodStatic != isSuperMethodStatic) { TextRange textRange = HighlightNamesUtil.getMethodDeclarationTextRange(method); - final String messageKey = isMethodStatic + String messageKey = isMethodStatic ? "static.method.cannot.override.instance.method" : "instance.method.cannot.override.static.method"; @@ -1482,7 +1482,7 @@ public final class HighlightMethodUtil { private static HighlightInfo checkInterfaceInheritedMethodsReturnTypes(@NotNull List superMethodSignatures, @NotNull LanguageLevel languageLevel) { if (superMethodSignatures.size() < 2) return null; - final MethodSignatureBackedByPsiMethod[] returnTypeSubstitutable = {superMethodSignatures.get(0)}; + MethodSignatureBackedByPsiMethod[] returnTypeSubstitutable = {superMethodSignatures.get(0)}; for (int i = 1; i < superMethodSignatures.size(); i++) { PsiMethod currentMethod = returnTypeSubstitutable[0].getMethod(); PsiType currentType = returnTypeSubstitutable[0].getSubstitutor().substitute(currentMethod.getReturnType()); @@ -1501,7 +1501,7 @@ public final class HighlightMethodUtil { if (otherSuperReturnType == null || currentType == null || otherSuperReturnType.equals(currentType)) continue; PsiType otherReturnType = otherSuperReturnType; PsiType curType = currentType; - final HighlightInfo info = + HighlightInfo info = LambdaUtil.performWithSubstitutedParameterBounds(otherSuperMethod.getTypeParameters(), otherSubstitutor, () -> { if (languageLevel.isAtLeast(LanguageLevel.JDK_1_5)) { //http://docs.oracle.com/javase/specs/jls/se7/html/jls-8.html#jls-8.4.8 Example 8.1.5-3 @@ -1527,7 +1527,7 @@ public final class HighlightMethodUtil { @NotNull LanguageLevel languageLevel) { String description = null; boolean appendImplementMethodFix = true; - final Collection visibleSignatures = aClass.getVisibleSignatures(); + Collection visibleSignatures = aClass.getVisibleSignatures(); PsiResolveHelper resolveHelper = JavaPsiFacade.getInstance(aClass.getProject()).getResolveHelper(); Ultimate: @@ -1586,7 +1586,7 @@ public final class HighlightMethodUtil { if (description != null) { // show error info at the class level TextRange textRange = HighlightNamesUtil.getClassDeclarationTextRange(aClass); - final HighlightInfo highlightInfo = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(textRange).descriptionAndTooltip(description).create(); + HighlightInfo highlightInfo = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(textRange).descriptionAndTooltip(description).create(); if (appendImplementMethodFix) { QuickFixAction.registerQuickFixAction(highlightInfo, QUICK_FIX_FACTORY.createImplementMethodsFix(aClass)); } @@ -1688,7 +1688,7 @@ public final class HighlightMethodUtil { if (list == null) return; PsiClass aClass = typeResolveResult.getElement(); if (aClass == null) return; - final PsiResolveHelper resolveHelper = JavaPsiFacade.getInstance(holder.getProject()).getResolveHelper(); + PsiResolveHelper resolveHelper = JavaPsiFacade.getInstance(holder.getProject()).getResolveHelper(); PsiClass accessObjectClass = null; if (constructorCall instanceof PsiNewExpression) { PsiExpression qualifier = ((PsiNewExpression)constructorCall).getQualifier(); @@ -1725,7 +1725,7 @@ public final class HighlightMethodUtil { if (classReference != null && aClass.hasModifierProperty(PsiModifier.PROTECTED) && callingProtectedConstructorFromDerivedClass(constructorCall, aClass)) { holder.add(buildAccessProblem(classReference, aClass, typeResolveResult)); } else if (aClass.isInterface() && constructorCall instanceof PsiNewExpression) { - final PsiReferenceParameterList typeArgumentList = ((PsiNewExpression)constructorCall).getTypeArgumentList(); + PsiReferenceParameterList typeArgumentList = ((PsiNewExpression)constructorCall).getTypeArgumentList(); if (typeArgumentList.getTypeArguments().length > 0) { holder.add(HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(typeArgumentList) .descriptionAndTooltip(JavaErrorBundle.message("anonymous.class.implements.interface.cannot.have.type.arguments")).create()); @@ -1735,7 +1735,7 @@ public final class HighlightMethodUtil { else { PsiElement place = list; if (constructorCall instanceof PsiNewExpression) { - final PsiAnonymousClass anonymousClass = ((PsiNewExpression)constructorCall).getAnonymousClass(); + PsiAnonymousClass anonymousClass = ((PsiNewExpression)constructorCall).getAnonymousClass(); if (anonymousClass != null) place = anonymousClass; } @@ -1747,8 +1747,8 @@ public final class HighlightMethodUtil { boolean applicable = true; try { - final PsiDiamondType diamondType = constructorCall instanceof PsiNewExpression ? PsiDiamondType.getDiamondType((PsiNewExpression)constructorCall) : null; - final JavaResolveResult staticFactory = diamondType != null ? diamondType.getStaticFactory() : null; + PsiDiamondType diamondType = constructorCall instanceof PsiNewExpression ? PsiDiamondType.getDiamondType((PsiNewExpression)constructorCall) : null; + JavaResolveResult staticFactory = diamondType != null ? diamondType.getStaticFactory() : null; if (staticFactory instanceof MethodCandidateInfo) { if (((MethodCandidateInfo)staticFactory).isApplicable()) { result = (MethodCandidateInfo)staticFactory; @@ -1820,14 +1820,14 @@ public final class HighlightMethodUtil { * it is a compile-time error if the type which is the erasure of Fn is not accessible at the point of invocation. */ private static HighlightInfo checkVarargParameterErasureToBeAccessible(@NotNull MethodCandidateInfo info, @NotNull PsiCall place) { - final PsiMethod method = info.getElement(); + PsiMethod method = info.getElement(); if (info.isVarargs() || method.isVarArgs() && !PsiUtil.isLanguageLevel8OrHigher(place)) { - final PsiParameter[] parameters = method.getParameterList().getParameters(); - final PsiType componentType = ((PsiEllipsisType)parameters[parameters.length - 1].getType()).getComponentType(); - final PsiType substitutedTypeErasure = TypeConversionUtil.erasure(info.getSubstitutor().substitute(componentType)); - final PsiClass targetClass = PsiUtil.resolveClassInClassTypeOnly(substitutedTypeErasure); + PsiParameter[] parameters = method.getParameterList().getParameters(); + PsiType componentType = ((PsiEllipsisType)parameters[parameters.length - 1].getType()).getComponentType(); + PsiType substitutedTypeErasure = TypeConversionUtil.erasure(info.getSubstitutor().substitute(componentType)); + PsiClass targetClass = PsiUtil.resolveClassInClassTypeOnly(substitutedTypeErasure); if (targetClass != null && !PsiUtil.isAccessible(targetClass, place, null)) { - final PsiExpressionList argumentList = place.getArgumentList(); + PsiExpressionList argumentList = place.getArgumentList(); return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .descriptionAndTooltip(JavaErrorBundle.message("formal.varargs.element.type.inaccessible.here", PsiFormatUtil.formatClass(targetClass, PsiFormatUtilBase.SHOW_FQ_NAME))) @@ -1844,7 +1844,7 @@ public final class HighlightMethodUtil { @NotNull PsiClass aClass, PsiMethod @NotNull [] constructors, JavaResolveResult @NotNull [] results, - @NotNull final HighlightInfo info, + @NotNull HighlightInfo info, TextRange fixRange) { if (classReference != null) { ConstructorParametersFixer.registerFixActions(classReference, constructorCall, info, fixRange); @@ -1906,18 +1906,18 @@ public final class HighlightMethodUtil { private static void registerChangeParameterClassFix(@NotNull PsiCall methodCall, @NotNull PsiExpressionList list, @Nullable HighlightInfo highlightInfo, TextRange fixRange) { - final JavaResolveResult result = methodCall.resolveMethodGenerics(); + JavaResolveResult result = methodCall.resolveMethodGenerics(); PsiMethod method = (PsiMethod)result.getElement(); - final PsiSubstitutor substitutor = result.getSubstitutor(); + PsiSubstitutor substitutor = result.getSubstitutor(); PsiExpression[] expressions = list.getExpressions(); if (method == null) return; - final PsiParameter[] parameters = method.getParameterList().getParameters(); + PsiParameter[] parameters = method.getParameterList().getParameters(); if (parameters.length != expressions.length) return; for (int i = 0; i < expressions.length; i++) { - final PsiExpression expression = expressions[i]; - final PsiParameter parameter = parameters[i]; - final PsiType expressionType = expression.getType(); - final PsiType parameterType = substitutor.substitute(parameter.getType()); + PsiExpression expression = expressions[i]; + PsiParameter parameter = parameters[i]; + PsiType expressionType = expression.getType(); + PsiType parameterType = substitutor.substitute(parameter.getType()); if (expressionType == null || expressionType instanceof PsiPrimitiveType || TypeConversionUtil.isNullType(expressionType) || expressionType instanceof PsiArrayType) continue; if (parameterType instanceof PsiPrimitiveType || TypeConversionUtil.isNullType(parameterType) || parameterType instanceof PsiArrayType) continue; if (parameterType.isAssignableFrom(expressionType)) continue; diff --git a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightNamesUtil.java b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightNamesUtil.java index e7f1d7bc4016..43fae487528e 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightNamesUtil.java +++ b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightNamesUtil.java @@ -39,7 +39,7 @@ public final class HighlightNamesUtil { @Nullable static HighlightInfo highlightMethodName(@NotNull PsiMember methodOrClass, @NotNull PsiElement elementToHighlight, - final boolean isDeclaration, + boolean isDeclaration, @NotNull TextAttributesScheme colorsScheme) { boolean isInherited = false; boolean isStaticallyImported = false; @@ -47,7 +47,7 @@ public final class HighlightNamesUtil { if (!isDeclaration) { isStaticallyImported = isStaticallyImported(elementToHighlight); if (isCalledOnThis(elementToHighlight)) { - final PsiClass containingClass = methodOrClass instanceof PsiMethod ? methodOrClass.getContainingClass() : null; + PsiClass containingClass = methodOrClass instanceof PsiMethod ? methodOrClass.getContainingClass() : null; PsiClass enclosingClass = containingClass == null ? null : PsiTreeUtil.getParentOfType(elementToHighlight, PsiClass.class); while (enclosingClass != null) { isInherited = enclosingClass.isInheritor(containingClass, true); @@ -126,7 +126,7 @@ public final class HighlightNamesUtil { static HighlightInfo highlightClassName(@Nullable PsiClass aClass, @NotNull PsiElement elementToHighlight, @NotNull TextAttributesScheme colorsScheme) { TextRange range = elementToHighlight.getTextRange(); if (elementToHighlight instanceof PsiJavaCodeReferenceElement) { - final PsiJavaCodeReferenceElement referenceElement = (PsiJavaCodeReferenceElement)elementToHighlight; + PsiJavaCodeReferenceElement referenceElement = (PsiJavaCodeReferenceElement)elementToHighlight; PsiElement identifier = referenceElement.getReferenceNameElement(); if (identifier != null) { range = identifier.getTextRange(); @@ -134,9 +134,9 @@ public final class HighlightNamesUtil { } // This will highlight @ sign in annotation as well. - final PsiElement parent = elementToHighlight.getParent(); + PsiElement parent = elementToHighlight.getParent(); if (parent instanceof PsiAnnotation) { - final PsiAnnotation psiAnnotation = (PsiAnnotation)parent; + PsiAnnotation psiAnnotation = (PsiAnnotation)parent; range = new TextRange(psiAnnotation.getTextRange().getStartOffset(), range.getEndOffset()); } @@ -233,7 +233,7 @@ public final class HighlightNamesUtil { if (aClass.isInterface()) return JavaHighlightInfoTypes.INTERFACE_NAME; if (aClass.isEnum()) return JavaHighlightInfoTypes.ENUM_NAME; if (aClass instanceof PsiTypeParameter) return JavaHighlightInfoTypes.TYPE_PARAMETER_NAME; - final PsiModifierList modList = aClass.getModifierList(); + PsiModifierList modList = aClass.getModifierList(); if (modList != null && modList.hasModifierProperty(PsiModifier.ABSTRACT)) return JavaHighlightInfoTypes.ABSTRACT_CLASS_NAME; } // use class by default @@ -276,13 +276,13 @@ public final class HighlightNamesUtil { DependencyValidationManagerImpl validationManager = (DependencyValidationManagerImpl)DependencyValidationManager.getInstance(file.getProject()); List> scopes = validationManager.getScopeBasedHighlightingCachedScopes(); for (Pair scope : scopes) { - final NamedScope namedScope = scope.getFirst(); - final TextAttributesKey scopeKey = ScopeAttributesUtil.getScopeTextAttributeKey(namedScope.getScopeId()); - final TextAttributes attributes = colorsScheme.getAttributes(scopeKey); + NamedScope namedScope = scope.getFirst(); + TextAttributesKey scopeKey = ScopeAttributesUtil.getScopeTextAttributeKey(namedScope.getScopeId()); + TextAttributes attributes = colorsScheme.getAttributes(scopeKey); if (attributes == null || attributes.isEmpty()) { continue; } - final PackageSet packageSet = namedScope.getValue(); + PackageSet packageSet = namedScope.getValue(); if (packageSet != null && packageSet.contains(file, scope.getSecond())) { result = TextAttributes.merge(attributes, result); } @@ -294,7 +294,7 @@ public final class HighlightNamesUtil { public static TextRange getMethodDeclarationTextRange(@NotNull PsiMethod method) { if (method instanceof SyntheticElement) return TextRange.EMPTY_RANGE; int start = stripAnnotationsFromModifierList(method.getModifierList()); - final TextRange throwsRange = method.getThrowsList().getTextRange(); + TextRange throwsRange = method.getThrowsList().getTextRange(); LOG.assertTrue(throwsRange != null, method); int end = throwsRange.getEndOffset(); return new TextRange(start, end); @@ -312,7 +312,7 @@ public final class HighlightNamesUtil { if (aClass instanceof PsiEnumConstantInitializer) { return ((PsiEnumConstantInitializer)aClass).getEnumConstant().getNameIdentifier().getTextRange(); } - final PsiElement psiElement = aClass instanceof PsiAnonymousClass + PsiElement psiElement = aClass instanceof PsiAnonymousClass ? ((PsiAnonymousClass)aClass).getBaseClassReference() : aClass.getModifierList() == null ? aClass.getNameIdentifier() : aClass.getModifierList(); if(psiElement == null) return new TextRange(aClass.getTextRange().getStartOffset(), aClass.getTextRange().getStartOffset()); diff --git a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightUtil.java b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightUtil.java index 5b539f3d0086..c8360a2e46f9 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightUtil.java +++ b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightUtil.java @@ -174,9 +174,9 @@ public final class HighlightUtil { Set incompatibles = incompatibleModifiersHash.get(modifier); if (incompatibles == null) return null; - final PsiElement parent = modifierList.getParent(); - final boolean level8OrHigher = PsiUtil.isLanguageLevel8OrHigher(modifierList); - final boolean level9OrHigher = PsiUtil.isLanguageLevel9OrHigher(modifierList); + PsiElement parent = modifierList.getParent(); + boolean level8OrHigher = PsiUtil.isLanguageLevel8OrHigher(modifierList); + boolean level9OrHigher = PsiUtil.isLanguageLevel9OrHigher(modifierList); for (@PsiModifier.ModifierConstant String incompatible : incompatibles) { if (level8OrHigher) { if (modifier.equals(PsiModifier.STATIC) && incompatible.equals(PsiModifier.ABSTRACT)) { @@ -189,7 +189,7 @@ public final class HighlightUtil { } if (modifier.equals(PsiModifier.STATIC) && incompatible.equals(PsiModifier.FINAL)) { - final PsiClass containingClass = ((PsiMethod)parent).getContainingClass(); + PsiClass containingClass = ((PsiMethod)parent).getContainingClass(); if (containingClass == null || !containingClass.isInterface()) { continue; } @@ -245,18 +245,18 @@ public final class HighlightUtil { HighlightInfo info = checkFeature(expression, HighlightingFeature.INTERSECTION_CASTS, languageLevel, file); if (info != null) return info; - final PsiTypeElement[] conjuncts = PsiTreeUtil.getChildrenOfType(castTypeElement, PsiTypeElement.class); + PsiTypeElement[] conjuncts = PsiTreeUtil.getChildrenOfType(castTypeElement, PsiTypeElement.class); if (conjuncts != null) { - final Set erasures = new HashSet<>(conjuncts.length); + Set erasures = new HashSet<>(conjuncts.length); erasures.add(TypeConversionUtil.erasure(conjuncts[0].getType())); - final List conjList = new ArrayList<>(Arrays.asList(conjuncts)); + List conjList = new ArrayList<>(Arrays.asList(conjuncts)); for (int i = 1; i < conjuncts.length; i++) { - final PsiTypeElement conjunct = conjuncts[i]; - final PsiType conjType = conjunct.getType(); + PsiTypeElement conjunct = conjuncts[i]; + PsiType conjType = conjunct.getType(); if (conjType instanceof PsiClassType) { - final PsiClass aClass = ((PsiClassType)conjType).resolve(); + PsiClass aClass = ((PsiClassType)conjType).resolve(); if (aClass != null && !aClass.isInterface()) { - final HighlightInfo errorResult = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) + HighlightInfo errorResult = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(conjunct) .descriptionAndTooltip(JavaErrorBundle.message("interface.expected")).create(); QuickFixAction @@ -271,7 +271,7 @@ public final class HighlightUtil { .descriptionAndTooltip(JavaErrorBundle.message("unexpected.type.class.expected")).create(); } if (!erasures.add(TypeConversionUtil.erasure(conjType))) { - final HighlightInfo highlightInfo = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) + HighlightInfo highlightInfo = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(conjunct) .descriptionAndTooltip(JavaErrorBundle.message("repeated.interface")).create(); QuickFixAction.registerQuickFixAction(highlightInfo, new DeleteRepeatedInterfaceFix(conjunct, conjList), null); @@ -279,9 +279,9 @@ public final class HighlightUtil { } } - final List typeList = ContainerUtil.map(conjList, PsiTypeElement::getType); - final Ref<@Nls String> differentArgumentsMessage = new Ref<>(); - final PsiClass sameGenericParameterization = + List typeList = ContainerUtil.map(conjList, PsiTypeElement::getType); + Ref<@Nls String> differentArgumentsMessage = new Ref<>(); + PsiClass sameGenericParameterization = InferenceSession.findParameterizationOfTheSameGenericClass(typeList, pair -> { if (!TypesDistinctProver.provablyDistinct(pair.first, pair.second)) { return true; @@ -291,7 +291,7 @@ public final class HighlightUtil { return false; }); if (sameGenericParameterization != null) { - final String message = JavaErrorBundle + String message = JavaErrorBundle .message("class.cannot.be.inherited.with.different.arguments", formatClass(sameGenericParameterization), differentArgumentsMessage.get()); return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) @@ -310,7 +310,7 @@ public final class HighlightUtil { } static HighlightInfo checkInconvertibleTypeCast(@NotNull PsiTypeCastExpression expression) { - final PsiTypeElement castTypeElement = expression.getCastType(); + PsiTypeElement castTypeElement = expression.getCastType(); if (castTypeElement == null) return null; PsiType castType = castTypeElement.getType(); @@ -357,10 +357,10 @@ public final class HighlightUtil { IElementType eqOpSign = operationSign.getTokenType(); IElementType opSign = TypeConversionUtil.convertEQtoOperation(eqOpSign); if (opSign == null) return null; - final PsiType lType = assignment.getLExpression().getType(); - final PsiExpression rExpression = assignment.getRExpression(); + PsiType lType = assignment.getLExpression().getType(); + PsiExpression rExpression = assignment.getRExpression(); if (rExpression == null) return null; - final PsiType rType = rExpression.getType(); + PsiType rType = rExpression.getType(); HighlightInfo errorResult = null; if (!TypeConversionUtil.isBinaryOperatorApplicable(opSign, lType, rType, true)) { String operatorText = operationSign.getText().substring(0, operationSign.getText().length() - 1); @@ -382,15 +382,15 @@ public final class HighlightUtil { PsiType rType = rExpr.getType(); if (rType == null) return null; - final IElementType sign = assignment.getOperationTokenType(); + IElementType sign = assignment.getOperationTokenType(); HighlightInfo highlightInfo; if (JavaTokenType.EQ.equals(sign)) { highlightInfo = checkAssignability(lType, rType, rExpr, assignment); } else { // 15.26.2. Compound Assignment Operators - final IElementType opSign = TypeConversionUtil.convertEQtoOperation(sign); - final PsiType type = TypeConversionUtil.calcTypeForBinaryExpression(lType, rType, opSign, true); + IElementType opSign = TypeConversionUtil.convertEQtoOperation(sign); + PsiType type = TypeConversionUtil.calcTypeForBinaryExpression(lType, rType, opSign, true); if (type == null || lType == null || TypeConversionUtil.areTypesConvertible(type, lType)) { return null; } @@ -586,7 +586,7 @@ public final class HighlightUtil { else { PsiType returnType = method != null ? method.getReturnType() : null/*JSP page returns void*/; boolean isMethodVoid = returnType == null || PsiType.VOID.equals(returnType); - final PsiExpression returnValue = statement.getReturnValue(); + PsiExpression returnValue = statement.getReturnValue(); if (returnValue != null) { PsiType valueType = RefactoringChangeUtil.getTypeByExpression(returnValue); if (isMethodVoid) { @@ -603,7 +603,7 @@ public final class HighlightUtil { errorResult = checkAssignability(returnType, valueType, returnValue, textRange, returnValue.getStartOffsetInParent()); if (errorResult != null && valueType != null) { if (returnType instanceof PsiArrayType) { - final PsiType erasedValueType = TypeConversionUtil.erasure(valueType); + PsiType erasedValueType = TypeConversionUtil.erasure(valueType); if (erasedValueType != null && TypeConversionUtil.isAssignable(((PsiArrayType)returnType).getComponentType(), erasedValueType)) { QuickFixAction.registerQuickFixAction(errorResult, getFixFactory().createSurroundWithArrayFix(null, returnValue)); @@ -639,7 +639,7 @@ public final class HighlightUtil { @NotNull private static @NlsContexts.DetailedDescription String getUnhandledExceptionsDescriptor(@NotNull Collection unhandled, @Nullable @Nls String source) { - final String exceptions = formatTypes(unhandled); + String exceptions = formatTypes(unhandled); return source == null ? JavaErrorBundle.message("unhandled.exceptions", exceptions, unhandled.size()) : JavaErrorBundle.message("unhandled.close.exceptions", exceptions, unhandled.size(), source); @@ -663,7 +663,7 @@ public final class HighlightUtil { PsiTreeUtil.getParentOfType(variable, PsiFile.class, PsiMethod.class, PsiClassInitializer.class, PsiResourceList.class); VariablesNotProcessor proc = new VariablesNotProcessor(variable, false) { @Override - protected boolean check(final PsiVariable var, final ResolveState state) { + protected boolean check(PsiVariable var, ResolveState state) { return PsiUtil.isJvmLocalVariable(var) && super.check(var, state); } }; @@ -707,7 +707,7 @@ public final class HighlightUtil { VirtualFile vFile = PsiUtilCore.getVirtualFile(identifier); HighlightInfo.Builder builder = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(identifier); if (vFile != null) { - final String path = FileUtil.toSystemIndependentName(vFile.getPath()); + String path = FileUtil.toSystemIndependentName(vFile.getPath()); String linkText = "" + variable.getName() + ""; builder = builder.description(description) .escapedToolTip("" + JavaErrorBundle.message("variable.already.defined", linkText) + ""); @@ -730,7 +730,7 @@ public final class HighlightUtil { PatternResolveState hint = PatternResolveState.WHEN_TRUE; VariablesNotProcessor proc = new VariablesNotProcessor(variable, false) { @Override - protected boolean check(final PsiVariable var, final ResolveState state) { + protected boolean check(PsiVariable var, ResolveState state) { return var instanceof PsiPatternVariable && super.check(var, state); } }; @@ -1147,13 +1147,13 @@ public final class HighlightUtil { if (file != null) { if (isFP) { if (text.startsWith(PsiLiteralUtil.HEX_PREFIX)) { - final HighlightInfo info = checkFeature(expression, HighlightingFeature.HEX_FP_LITERALS, level, file); + HighlightInfo info = checkFeature(expression, HighlightingFeature.HEX_FP_LITERALS, level, file); if (info != null) return info; } } if (isInt) { if (text.startsWith(PsiLiteralUtil.BIN_PREFIX)) { - final HighlightInfo info = checkFeature(expression, HighlightingFeature.BIN_LITERALS, level, file); + HighlightInfo info = checkFeature(expression, HighlightingFeature.BIN_LITERALS, level, file); if (info != null) return info; } } @@ -1167,7 +1167,7 @@ public final class HighlightUtil { } } - final PsiElement parent = expression.getParent(); + PsiElement parent = expression.getParent(); if (type == JavaTokenType.INTEGER_LITERAL) { String cleanText = StringUtil.replace(text, "_", ""); //literal 2147483648 may appear only as the operand of the unary negation operator -. @@ -1302,13 +1302,13 @@ public final class HighlightUtil { } else { if (file != null && containsUnescaped(text, "\\\n")) { - final HighlightInfo info = checkFeature(expression, HighlightingFeature.TEXT_BLOCK_ESCAPES, level, file); + HighlightInfo info = checkFeature(expression, HighlightingFeature.TEXT_BLOCK_ESCAPES, level, file); if (info != null) return info; } } } if (file != null && containsUnescaped(text, "\\s")) { - final HighlightInfo info = checkFeature(expression, HighlightingFeature.TEXT_BLOCK_ESCAPES, level, file); + HighlightInfo info = checkFeature(expression, HighlightingFeature.TEXT_BLOCK_ESCAPES, level, file); if (info != null) return info; } } @@ -1404,10 +1404,10 @@ public final class HighlightUtil { } private static HighlightInfo createMustBeBooleanInfo(@NotNull PsiExpression expr, @Nullable PsiType type) { - final HighlightInfo info = createIncompatibleTypeHighlightInfo(PsiType.BOOLEAN, type, expr.getTextRange(), 0); + HighlightInfo info = createIncompatibleTypeHighlightInfo(PsiType.BOOLEAN, type, expr.getTextRange(), 0); if (expr instanceof PsiMethodCallExpression) { - final PsiMethodCallExpression methodCall = (PsiMethodCallExpression)expr; - final PsiMethod method = methodCall.resolveMethod(); + PsiMethodCallExpression methodCall = (PsiMethodCallExpression)expr; + PsiMethod method = methodCall.resolveMethod(); if (method != null) { QuickFixAction.registerQuickFixAction(info, getFixFactory().createMethodReturnFix(method, PsiType.BOOLEAN, true)); } @@ -1420,15 +1420,15 @@ public final class HighlightUtil { @NotNull - static Set collectUnhandledExceptions(@NotNull final PsiTryStatement statement) { - final Set thrownTypes = new HashSet<>(); + static Set collectUnhandledExceptions(@NotNull PsiTryStatement statement) { + Set thrownTypes = new HashSet<>(); - final PsiCodeBlock tryBlock = statement.getTryBlock(); + PsiCodeBlock tryBlock = statement.getTryBlock(); if (tryBlock != null) { thrownTypes.addAll(ExceptionUtil.collectUnhandledExceptions(tryBlock, tryBlock)); } - final PsiResourceList resources = statement.getResourceList(); + PsiResourceList resources = statement.getResourceList(); if (resources != null) { thrownTypes.addAll(ExceptionUtil.collectUnhandledExceptions(resources, resources)); } @@ -1437,12 +1437,12 @@ public final class HighlightUtil { } @NotNull - static List checkExceptionThrownInTry(@NotNull final PsiParameter parameter, - @NotNull final Set thrownTypes) { - final PsiElement declarationScope = parameter.getDeclarationScope(); + static List checkExceptionThrownInTry(@NotNull PsiParameter parameter, + @NotNull Set thrownTypes) { + PsiElement declarationScope = parameter.getDeclarationScope(); if (!(declarationScope instanceof PsiCatchSection)) return Collections.emptyList(); - final PsiType caughtType = parameter.getType(); + PsiType caughtType = parameter.getType(); if (caughtType instanceof PsiClassType) { HighlightInfo info = checkSimpleCatchParameter(parameter, thrownTypes, (PsiClassType)caughtType); return info == null ? Collections.emptyList() : Collections.singletonList(info); @@ -1454,30 +1454,30 @@ public final class HighlightUtil { return Collections.emptyList(); } - private static HighlightInfo checkSimpleCatchParameter(@NotNull final PsiParameter parameter, - @NotNull final Collection thrownTypes, - @NotNull final PsiClassType caughtType) { + private static HighlightInfo checkSimpleCatchParameter(@NotNull PsiParameter parameter, + @NotNull Collection thrownTypes, + @NotNull PsiClassType caughtType) { if (ExceptionUtil.isUncheckedExceptionOrSuperclass(caughtType)) return null; for (PsiClassType exceptionType : thrownTypes) { if (exceptionType.isAssignableFrom(caughtType) || caughtType.isAssignableFrom(exceptionType)) return null; } - final String description = JavaErrorBundle.message("exception.never.thrown.try", JavaHighlightUtil.formatType(caughtType)); - final HighlightInfo errorResult = + String description = JavaErrorBundle.message("exception.never.thrown.try", JavaHighlightUtil.formatType(caughtType)); + HighlightInfo errorResult = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(parameter).descriptionAndTooltip(description).create(); QuickFixAction.registerQuickFixAction(errorResult, getFixFactory().createDeleteCatchFix(parameter)); return errorResult; } @NotNull - private static List checkMultiCatchParameter(@NotNull final PsiParameter parameter, - @NotNull final Collection thrownTypes) { - final List typeElements = PsiUtil.getParameterTypeElements(parameter); - final List highlights = new ArrayList<>(typeElements.size()); + private static List checkMultiCatchParameter(@NotNull PsiParameter parameter, + @NotNull Collection thrownTypes) { + List typeElements = PsiUtil.getParameterTypeElements(parameter); + List highlights = new ArrayList<>(typeElements.size()); - for (final PsiTypeElement typeElement : typeElements) { - final PsiType catchType = typeElement.getType(); + for (PsiTypeElement typeElement : typeElements) { + PsiType catchType = typeElement.getType(); if (catchType instanceof PsiClassType && ExceptionUtil.isUncheckedExceptionOrSuperclass((PsiClassType)catchType)) continue; boolean used = false; @@ -1488,8 +1488,8 @@ public final class HighlightUtil { } } if (!used) { - final String description = JavaErrorBundle.message("exception.never.thrown.try", JavaHighlightUtil.formatType(catchType)); - final HighlightInfo highlight = + String description = JavaErrorBundle.message("exception.never.thrown.try", JavaHighlightUtil.formatType(catchType)); + HighlightInfo highlight = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(typeElement).descriptionAndTooltip(description).create(); QuickFixAction.registerQuickFixAction(highlight, getFixFactory().createDeleteMultiCatchFix(typeElement)); highlights.add(highlight); @@ -1504,39 +1504,39 @@ public final class HighlightUtil { static Collection checkWithImprovedCatchAnalysis(@NotNull PsiParameter parameter, @NotNull Collection thrownInTryStatement, @NotNull PsiFile containingFile) { - final PsiElement scope = parameter.getDeclarationScope(); + PsiElement scope = parameter.getDeclarationScope(); if (!(scope instanceof PsiCatchSection)) return Collections.emptyList(); - final PsiCatchSection catchSection = (PsiCatchSection)scope; - final PsiCatchSection[] allCatchSections = catchSection.getTryStatement().getCatchSections(); - final int idx = ArrayUtilRt.find(allCatchSections, catchSection); + PsiCatchSection catchSection = (PsiCatchSection)scope; + PsiCatchSection[] allCatchSections = catchSection.getTryStatement().getCatchSections(); + int idx = ArrayUtilRt.find(allCatchSections, catchSection); if (idx <= 0) return Collections.emptyList(); - final Collection thrownTypes = new HashSet<>(thrownInTryStatement); - final PsiManager manager = containingFile.getManager(); - final GlobalSearchScope parameterResolveScope = parameter.getResolveScope(); + Collection thrownTypes = new HashSet<>(thrownInTryStatement); + PsiManager manager = containingFile.getManager(); + GlobalSearchScope parameterResolveScope = parameter.getResolveScope(); thrownTypes.add(PsiType.getJavaLangError(manager, parameterResolveScope)); thrownTypes.add(PsiType.getJavaLangRuntimeException(manager, parameterResolveScope)); - final Collection result = new ArrayList<>(); + Collection result = new ArrayList<>(); - final List parameterTypeElements = PsiUtil.getParameterTypeElements(parameter); - final boolean isMultiCatch = parameterTypeElements.size() > 1; + List parameterTypeElements = PsiUtil.getParameterTypeElements(parameter); + boolean isMultiCatch = parameterTypeElements.size() > 1; for (PsiTypeElement catchTypeElement : parameterTypeElements) { - final PsiType catchType = catchTypeElement.getType(); + PsiType catchType = catchTypeElement.getType(); if (ExceptionUtil.isGeneralExceptionType(catchType)) continue; // collect exceptions caught by this type - final Collection caught = + Collection caught = ContainerUtil.findAll(thrownTypes, type -> catchType.isAssignableFrom(type) || type.isAssignableFrom(catchType)); if (caught.isEmpty()) continue; - final Collection caughtCopy = new HashSet<>(caught); + Collection caughtCopy = new HashSet<>(caught); // exclude all caught by previous catch sections for (int i = 0; i < idx; i++) { - final PsiParameter prevCatchParameter = allCatchSections[i].getParameter(); + PsiParameter prevCatchParameter = allCatchSections[i].getParameter(); if (prevCatchParameter == null) continue; for (PsiTypeElement prevCatchTypeElement : PsiUtil.getParameterTypeElements(prevCatchParameter)) { - final PsiType prevCatchType = prevCatchTypeElement.getType(); + PsiType prevCatchType = prevCatchTypeElement.getType(); caught.removeIf(prevCatchType::isAssignableFrom); if (caught.isEmpty()) break; } @@ -1544,8 +1544,8 @@ public final class HighlightUtil { // check & warn if (caught.isEmpty()) { - final String message = JavaErrorBundle.message("exception.already.caught.warn", formatTypes(caughtCopy), caughtCopy.size()); - final HighlightInfo highlightInfo = + String message = JavaErrorBundle.message("exception.already.caught.warn", formatTypes(caughtCopy), caughtCopy.size()); + HighlightInfo highlightInfo = HighlightInfo.newHighlightInfo(HighlightInfoType.WARNING).range(catchSection).descriptionAndTooltip(message).create(); if (isMultiCatch) { QuickFixAction.registerQuickFixAction(highlightInfo, getFixFactory().createDeleteMultiCatchFix(catchTypeElement)); @@ -1603,7 +1603,7 @@ public final class HighlightUtil { PsiType switchExpressionType = switchExpression.getType(); if (switchExpressionType != null) { for (PsiExpression expression : PsiUtil.getSwitchResultExpressions(switchExpression)) { - final PsiType expressionType = expression.getType(); + PsiType expressionType = expression.getType(); if (expressionType != null && !TypeConversionUtil.areTypesAssignmentCompatible(switchExpressionType, expression)) { String text = JavaErrorBundle .message("bad.type.in.switch.expression", expressionType.getCanonicalText(), switchExpressionType.getCanonicalText()); @@ -1712,19 +1712,19 @@ public final class HighlightUtil { @Contract(value = "null -> null", pure = true) private static @Nullable PsiTypeTestPattern getTypeTestPattern(@Nullable PsiPattern expressionPattern) { - final PsiPattern innerMostPattern = JavaPsiPatternUtil.skipParenthesizedPatternDown(expressionPattern); + PsiPattern innerMostPattern = JavaPsiPatternUtil.skipParenthesizedPatternDown(expressionPattern); if (innerMostPattern == null) return null; - final PsiTypeTestPattern pattern = tryCast(innerMostPattern, PsiTypeTestPattern.class); + PsiTypeTestPattern pattern = tryCast(innerMostPattern, PsiTypeTestPattern.class); if (pattern != null) return pattern; - final PsiGuardedPattern guardedPattern = tryCast(innerMostPattern, PsiGuardedPattern.class); + PsiGuardedPattern guardedPattern = tryCast(innerMostPattern, PsiGuardedPattern.class); if (guardedPattern == null) return null; - final Object condition = ExpressionUtils.computeConstantExpression(guardedPattern.getGuardingExpression()); + Object condition = ExpressionUtils.computeConstantExpression(guardedPattern.getGuardingExpression()); if (!Boolean.TRUE.equals(condition)) return null; - final PsiPattern patternInGuard = JavaPsiPatternUtil.skipParenthesizedPatternDown(guardedPattern.getPrimaryPattern()); + PsiPattern patternInGuard = JavaPsiPatternUtil.skipParenthesizedPatternDown(guardedPattern.getPrimaryPattern()); if (patternInGuard == null || patternInGuard instanceof PsiTypeTestPattern) return (PsiTypeTestPattern)patternInGuard; return getTypeTestPattern(patternInGuard); @@ -1780,10 +1780,10 @@ public final class HighlightUtil { @Nullable PsiJavaCodeReferenceElement qualifier, @NotNull LanguageLevel languageLevel) { if (expr instanceof PsiSuperExpression) { - final PsiElement parent = expr.getParent(); + PsiElement parent = expr.getParent(); if (!(parent instanceof PsiReferenceExpression)) { // like in 'Object o = super;' - final int o = expr.getTextRange().getEndOffset(); + int o = expr.getTextRange().getEndOffset(); String description = JavaErrorBundle.message("dot.expected.after.super.or.this"); return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(o, o + 1).descriptionAndTooltip(description).create(); } @@ -1808,7 +1808,7 @@ public final class HighlightUtil { return HighlightClassUtil.reportIllegalEnclosingUsage(expr, null, aClass, expr); } if (expr instanceof PsiSuperExpression) { - final PsiElement resolved = ((PsiReferenceExpression)expr.getParent()).resolve(); + PsiElement resolved = ((PsiReferenceExpression)expr.getParent()).resolve(); //15.11.2 //The form T.super.Identifier refers to the field named Identifier of the lexically enclosing instance corresponding to T, //but with that instance viewed as an instance of the superclass of T. @@ -1826,8 +1826,8 @@ public final class HighlightUtil { //or if there exists some other direct superclass or direct superinterface of T, J, such that J is a subtype of I. PsiClass classT = getContainingClass(expr); if (classT != null) { - final PsiElement parent = expr.getParent(); - final PsiElement resolved = parent instanceof PsiReferenceExpression ? ((PsiReferenceExpression)parent).resolve() : null; + PsiElement parent = expr.getParent(); + PsiElement resolved = parent instanceof PsiReferenceExpression ? ((PsiReferenceExpression)parent).resolve() : null; PsiClass containingClass = ObjectUtils.notNull(resolved instanceof PsiMethod ? ((PsiMethod)resolved).getContainingClass() : null, aClass); @@ -1875,7 +1875,7 @@ public final class HighlightUtil { @NotNull PsiReferenceExpression expr, @Nullable PsiExpression qualifier) { if (languageLevel.isAtLeast(LanguageLevel.JDK_1_8) && qualifier instanceof PsiSuperExpression) { - final PsiMethod method = PsiTreeUtil.getParentOfType(expr, PsiMethod.class); + PsiMethod method = PsiTreeUtil.getParentOfType(expr, PsiMethod.class); if (method != null && method.hasModifierProperty(PsiModifier.DEFAULT) && ((PsiSuperExpression)qualifier).getQualifier() == null) { String description = JavaErrorBundle.message("unqualified.super.disallowed"); HighlightInfo info = @@ -1892,9 +1892,9 @@ public final class HighlightUtil { @NotNull PsiClass aClass, @NotNull LanguageLevel languageLevel) { if (!(expr instanceof PsiSuperExpression) || qualifier == null || !languageLevel.isAtLeast(LanguageLevel.JDK_1_8)) return false; - final PsiType superType = expr.getType(); + PsiType superType = expr.getType(); if (!(superType instanceof PsiClassType)) return false; - final PsiClass superClass = ((PsiClassType)superType).resolve(); + PsiClass superClass = ((PsiClassType)superType).resolve(); return aClass.equals(superClass) && PsiUtil.getEnclosingStaticElement(expr, PsiTreeUtil.getParentOfType(expr, PsiClass.class)) == null; } @@ -1982,37 +1982,37 @@ public final class HighlightUtil { private static PsiElement getContainer(@NotNull PsiModifierListOwner refElement) { for (ContainerProvider provider : ContainerProvider.EP_NAME.getExtensions()) { - final PsiElement container = provider.getContainer(refElement); + PsiElement container = provider.getContainer(refElement); if (container != null) return container; } return refElement.getParent(); } private static String getContainerName(@NotNull PsiModifierListOwner refElement, @NotNull PsiSubstitutor substitutor) { - final PsiElement container = getContainer(refElement); + PsiElement container = getContainer(refElement); return container == null ? "?" : HighlightMessageUtil.getSymbolName(container, substitutor); } static HighlightInfo checkValidArrayAccessExpression(@NotNull PsiArrayAccessExpression arrayAccessExpression) { - final PsiExpression arrayExpression = arrayAccessExpression.getArrayExpression(); - final PsiType arrayExpressionType = arrayExpression.getType(); + PsiExpression arrayExpression = arrayAccessExpression.getArrayExpression(); + PsiType arrayExpressionType = arrayExpression.getType(); if (arrayExpressionType != null && !(arrayExpressionType instanceof PsiArrayType)) { - final String description = JavaErrorBundle.message("array.type.expected", JavaHighlightUtil.formatType(arrayExpressionType)); - final HighlightInfo info = + String description = JavaErrorBundle.message("array.type.expected", JavaHighlightUtil.formatType(arrayExpressionType)); + HighlightInfo info = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(arrayExpression).descriptionAndTooltip(description).create(); QuickFixAction.registerQuickFixAction(info, getFixFactory().createReplaceWithListAccessFix(arrayAccessExpression)); return info; } - final PsiExpression indexExpression = arrayAccessExpression.getIndexExpression(); + PsiExpression indexExpression = arrayAccessExpression.getIndexExpression(); return indexExpression != null ? checkAssignability(PsiType.INT, indexExpression.getType(), indexExpression, indexExpression) : null; } - static HighlightInfo checkCatchParameterIsThrowable(@NotNull final PsiParameter parameter) { + static HighlightInfo checkCatchParameterIsThrowable(@NotNull PsiParameter parameter) { if (parameter.getDeclarationScope() instanceof PsiCatchSection) { - final PsiType type = parameter.getType(); + PsiType type = parameter.getType(); return checkMustBeThrowable(type, parameter, true); } return null; @@ -2063,21 +2063,21 @@ public final class HighlightUtil { if (!(initializer instanceof PsiArrayInitializerExpression)) return Collections.emptyList(); if (!(type instanceof PsiArrayType)) return Collections.emptyList(); - final PsiType componentType = ((PsiArrayType)type).getComponentType(); - final PsiArrayInitializerExpression arrayInitializer = (PsiArrayInitializerExpression)initializer; + PsiType componentType = ((PsiArrayType)type).getComponentType(); + PsiArrayInitializerExpression arrayInitializer = (PsiArrayInitializerExpression)initializer; boolean arrayTypeFixChecked = false; VariableArrayTypeFix fix = null; - final PsiExpression[] initializers = arrayInitializer.getInitializers(); - final Collection result = new ArrayList<>(initializers.length); + PsiExpression[] initializers = arrayInitializer.getInitializers(); + Collection result = new ArrayList<>(initializers.length); for (PsiExpression expression : initializers) { - final HighlightInfo info = checkArrayInitializerCompatibleTypes(expression, componentType); + HighlightInfo info = checkArrayInitializerCompatibleTypes(expression, componentType); if (info != null) { result.add(info); if (!arrayTypeFixChecked) { - final PsiType checkResult = JavaHighlightUtil.sameType(initializers); + PsiType checkResult = JavaHighlightUtil.sameType(initializers); fix = checkResult != null ? VariableArrayTypeFix.createFix(arrayInitializer, checkResult) : null; arrayTypeFixChecked = true; } @@ -2538,12 +2538,12 @@ public final class HighlightUtil { return null; } - final HighlightInfo highlightInfo = createMemberReferencedError(resolvedName, expression.getTextRange()); + HighlightInfo highlightInfo = createMemberReferencedError(resolvedName, expression.getTextRange()); if (expression instanceof PsiReferenceExpression && PsiUtil.isInnerClass(parentClass)) { - final String referenceName = ((PsiReferenceExpression)expression).getReferenceName(); - final PsiClass containingClass = parentClass.getContainingClass(); + String referenceName = ((PsiReferenceExpression)expression).getReferenceName(); + PsiClass containingClass = parentClass.getContainingClass(); LOG.assertTrue(containingClass != null); - final PsiField fieldInContainingClass = containingClass.findFieldByName(referenceName, true); + PsiField fieldInContainingClass = containingClass.findFieldByName(referenceName, true); if (fieldInContainingClass != null && ((PsiReferenceExpression)expression).getQualifierExpression() == null) { QuickFixAction.registerQuickFixAction(highlightInfo, new QualifyWithThisFix(containingClass, expression)); } @@ -2553,7 +2553,7 @@ public final class HighlightUtil { } if (element instanceof PsiReferenceExpression) { - final PsiElement resolve; + PsiElement resolve; if (element instanceof PsiReferenceExpressionImpl) { PsiReferenceExpressionImpl referenceExpression = (PsiReferenceExpressionImpl)element; JavaResolveResult[] results = JavaResolveUtil @@ -2661,25 +2661,25 @@ public final class HighlightUtil { @NotNull - static Collection checkCatchTypeIsDisjoint(@NotNull final PsiParameter parameter) { + static Collection checkCatchTypeIsDisjoint(@NotNull PsiParameter parameter) { if (!(parameter.getType() instanceof PsiDisjunctionType)) return Collections.emptyList(); - final List typeElements = PsiUtil.getParameterTypeElements(parameter); - final Collection result = new ArrayList<>(typeElements.size()); + List typeElements = PsiUtil.getParameterTypeElements(parameter); + Collection result = new ArrayList<>(typeElements.size()); for (int i = 0, size = typeElements.size(); i < size; i++) { - final PsiClass class1 = PsiUtil.resolveClassInClassTypeOnly(typeElements.get(i).getType()); + PsiClass class1 = PsiUtil.resolveClassInClassTypeOnly(typeElements.get(i).getType()); if (class1 == null) continue; for (int j = i + 1; j < size; j++) { - final PsiClass class2 = PsiUtil.resolveClassInClassTypeOnly(typeElements.get(j).getType()); + PsiClass class2 = PsiUtil.resolveClassInClassTypeOnly(typeElements.get(j).getType()); if (class2 == null) continue; - final boolean sub = InheritanceUtil.isInheritorOrSelf(class1, class2, true); - final boolean sup = InheritanceUtil.isInheritorOrSelf(class2, class1, true); + boolean sub = InheritanceUtil.isInheritorOrSelf(class1, class2, true); + boolean sup = InheritanceUtil.isInheritorOrSelf(class2, class1, true); if (sub || sup) { - final String name1 = PsiFormatUtil.formatClass(class1, PsiFormatUtilBase.SHOW_NAME | PsiFormatUtilBase.SHOW_FQ_NAME); - final String name2 = PsiFormatUtil.formatClass(class2, PsiFormatUtilBase.SHOW_NAME | PsiFormatUtilBase.SHOW_FQ_NAME); - final String message = JavaErrorBundle.message("exception.must.be.disjoint", sub ? name1 : name2, sub ? name2 : name1); - final PsiTypeElement element = typeElements.get(sub ? i : j); - final HighlightInfo highlight = + String name1 = PsiFormatUtil.formatClass(class1, PsiFormatUtilBase.SHOW_NAME | PsiFormatUtilBase.SHOW_FQ_NAME); + String name2 = PsiFormatUtil.formatClass(class2, PsiFormatUtilBase.SHOW_NAME | PsiFormatUtilBase.SHOW_FQ_NAME); + String message = JavaErrorBundle.message("exception.must.be.disjoint", sub ? name1 : name2, sub ? name2 : name1); + PsiTypeElement element = typeElements.get(sub ? i : j); + HighlightInfo highlight = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(element).descriptionAndTooltip(message).create(); QuickFixAction.registerQuickFixAction(highlight, getFixFactory().createDeleteMultiCatchFix(element)); result.add(highlight); @@ -2693,34 +2693,34 @@ public final class HighlightUtil { @NotNull - static Collection checkExceptionAlreadyCaught(@NotNull final PsiParameter parameter) { - final PsiElement scope = parameter.getDeclarationScope(); + static Collection checkExceptionAlreadyCaught(@NotNull PsiParameter parameter) { + PsiElement scope = parameter.getDeclarationScope(); if (!(scope instanceof PsiCatchSection)) return Collections.emptyList(); - final PsiCatchSection catchSection = (PsiCatchSection)scope; - final PsiCatchSection[] allCatchSections = catchSection.getTryStatement().getCatchSections(); - final int startFrom = ArrayUtilRt.find(allCatchSections, catchSection) - 1; + PsiCatchSection catchSection = (PsiCatchSection)scope; + PsiCatchSection[] allCatchSections = catchSection.getTryStatement().getCatchSections(); + int startFrom = ArrayUtilRt.find(allCatchSections, catchSection) - 1; if (startFrom < 0) return Collections.emptyList(); - final List typeElements = PsiUtil.getParameterTypeElements(parameter); - final boolean isInMultiCatch = typeElements.size() > 1; - final Collection result = new ArrayList<>(); + List typeElements = PsiUtil.getParameterTypeElements(parameter); + boolean isInMultiCatch = typeElements.size() > 1; + Collection result = new ArrayList<>(); for (PsiTypeElement typeElement : typeElements) { - final PsiClass catchClass = PsiUtil.resolveClassInClassTypeOnly(typeElement.getType()); + PsiClass catchClass = PsiUtil.resolveClassInClassTypeOnly(typeElement.getType()); if (catchClass == null) continue; for (int i = startFrom; i >= 0; i--) { - final PsiCatchSection upperCatchSection = allCatchSections[i]; - final PsiType upperCatchType = upperCatchSection.getCatchType(); + PsiCatchSection upperCatchSection = allCatchSections[i]; + PsiType upperCatchType = upperCatchSection.getCatchType(); - final boolean highlight = upperCatchType instanceof PsiDisjunctionType + boolean highlight = upperCatchType instanceof PsiDisjunctionType ? checkMultipleTypes(catchClass, ((PsiDisjunctionType)upperCatchType).getDisjunctions()) : checkSingleType(catchClass, upperCatchType); if (highlight) { - final String className = PsiFormatUtil.formatClass(catchClass, PsiFormatUtilBase.SHOW_NAME | PsiFormatUtilBase.SHOW_FQ_NAME); - final String description = JavaErrorBundle.message("exception.already.caught", className); - final HighlightInfo highlightInfo = + String className = PsiFormatUtil.formatClass(catchClass, PsiFormatUtilBase.SHOW_NAME | PsiFormatUtilBase.SHOW_FQ_NAME); + String description = JavaErrorBundle.message("exception.already.caught", className); + HighlightInfo highlightInfo = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(typeElement).descriptionAndTooltip(description).create(); result.add(highlightInfo); @@ -2738,7 +2738,7 @@ public final class HighlightUtil { return result; } - private static boolean checkMultipleTypes(@NotNull PsiClass catchClass, @NotNull final List upperCatchTypes) { + private static boolean checkMultipleTypes(@NotNull PsiClass catchClass, @NotNull List upperCatchTypes) { for (int i = upperCatchTypes.size() - 1; i >= 0; i--) { if (checkSingleType(catchClass, upperCatchTypes.get(i))) return true; } @@ -2746,7 +2746,7 @@ public final class HighlightUtil { } private static boolean checkSingleType(@NotNull PsiClass catchClass, @Nullable PsiType upperCatchType) { - final PsiClass upperCatchClass = PsiUtil.resolveClassInType(upperCatchType); + PsiClass upperCatchClass = PsiUtil.resolveClassInType(upperCatchType); return upperCatchClass != null && InheritanceUtil.isInheritorOrSelf(catchClass, upperCatchClass, true); } @@ -2798,7 +2798,7 @@ public final class HighlightUtil { return null; } - static HighlightInfo checkConditionalExpressionBranchTypesMatch(@NotNull final PsiExpression expression, @Nullable PsiType type) { + static HighlightInfo checkConditionalExpressionBranchTypesMatch(@NotNull PsiExpression expression, @Nullable PsiType type) { PsiElement parent = expression.getParent(); if (!(parent instanceof PsiConditionalExpression)) { return null; @@ -2806,7 +2806,7 @@ public final class HighlightUtil { PsiConditionalExpression conditionalExpression = (PsiConditionalExpression)parent; // check else branches only if (conditionalExpression.getElseExpression() != expression) return null; - final PsiExpression thenExpression = conditionalExpression.getThenExpression(); + PsiExpression thenExpression = conditionalExpression.getThenExpression(); assert thenExpression != null; PsiType thenType = thenExpression.getType(); if (thenType == null || type == null) return null; @@ -2991,7 +2991,7 @@ public final class HighlightUtil { } } - final PsiClass aClass = PsiUtil.resolveClassInClassTypeOnly(type); + PsiClass aClass = PsiUtil.resolveClassInClassTypeOnly(type); if (aClass != null) { QuickFixAction.registerQuickFixAction(highlightInfo, getFixFactory().createExtendsListFix(aClass, throwable, true)); } @@ -3135,25 +3135,25 @@ public final class HighlightUtil { static boolean isCallToStaticMember(@Nullable PsiElement element) { if (!(element instanceof PsiNewExpression)) return false; - final PsiNewExpression newExpression = (PsiNewExpression)element; - final PsiJavaCodeReferenceElement reference = newExpression.getClassOrAnonymousClassReference(); + PsiNewExpression newExpression = (PsiNewExpression)element; + PsiJavaCodeReferenceElement reference = newExpression.getClassOrAnonymousClassReference(); if (reference == null) return false; - final PsiElement qualifier = reference.getQualifier(); - final PsiElement memberName = reference.getReferenceNameElement(); + PsiElement qualifier = reference.getQualifier(); + PsiElement memberName = reference.getReferenceNameElement(); if (!(qualifier instanceof PsiJavaCodeReferenceElement) || memberName == null) return false; - final PsiJavaCodeReferenceElement psiReference = (PsiJavaCodeReferenceElement)qualifier; + PsiJavaCodeReferenceElement psiReference = (PsiJavaCodeReferenceElement)qualifier; if (psiReference.getTypeParameterCount() > 0) return false; - final PsiClass clazz = tryCast(psiReference.resolve(), PsiClass.class); + PsiClass clazz = tryCast(psiReference.resolve(), PsiClass.class); if (clazz == null) return false; if (newExpression.getArgumentList() == null) { - final PsiField field = clazz.findFieldByName(memberName.getText(), true); + PsiField field = clazz.findFieldByName(memberName.getText(), true); if (field != null && field.hasModifierProperty(PsiModifier.STATIC)) return true; } else { - final PsiMethod[] methods = clazz.findMethodsByName(memberName.getText(), true); + PsiMethod[] methods = clazz.findMethodsByName(memberName.getText(), true); if (methods.length == 0) return false; for (PsiMethod method : methods) { if (method.hasModifierProperty(PsiModifier.STATIC)) return true; @@ -3256,16 +3256,16 @@ public final class HighlightUtil { public static boolean isSerializationImplicitlyUsedField(@NotNull PsiField field) { - final String name = field.getName(); + String name = field.getName(); if (!CommonClassNames.SERIAL_VERSION_UID_FIELD_NAME.equals(name) && !SERIAL_PERSISTENT_FIELDS_FIELD_NAME.equals(name)) return false; if (!field.hasModifierProperty(PsiModifier.STATIC)) return false; PsiClass aClass = field.getContainingClass(); return aClass == null || JavaHighlightUtil.isSerializable(aClass); } - static HighlightInfo checkClassReferenceAfterQualifier(@NotNull final PsiReferenceExpression expression, @Nullable PsiElement resolved) { + static HighlightInfo checkClassReferenceAfterQualifier(@NotNull PsiReferenceExpression expression, @Nullable PsiElement resolved) { if (!(resolved instanceof PsiClass)) return null; - final PsiExpression qualifier = expression.getQualifierExpression(); + PsiExpression qualifier = expression.getQualifierExpression(); if (qualifier == null) return null; if (qualifier instanceof PsiReferenceExpression) { PsiElement qualifierResolved = ((PsiReferenceExpression)qualifier).resolve(); @@ -3295,11 +3295,11 @@ public final class HighlightUtil { } static HighlightInfo checkAnnotationMethodParameters(@NotNull PsiParameterList list) { - final PsiElement parent = list.getParent(); + PsiElement parent = list.getParent(); if (PsiUtil.isAnnotationMethod(parent) && (!list.isEmpty() || PsiTreeUtil.getChildOfType(list, PsiReceiverParameter.class) != null)) { - final String message = JavaErrorBundle.message("annotation.interface.members.may.not.have.parameters"); - final HighlightInfo highlightInfo = + String message = JavaErrorBundle.message("annotation.interface.members.may.not.have.parameters"); + HighlightInfo highlightInfo = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(list).descriptionAndTooltip(message).create(); QuickFixAction.registerQuickFixAction(highlightInfo, getFixFactory().createRemoveParameterListFix((PsiMethod)parent)); return highlightInfo; diff --git a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightingFeature.java b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightingFeature.java index b95252ffcdbc..7ba8cbe429e2 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightingFeature.java +++ b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightingFeature.java @@ -97,20 +97,20 @@ public enum HighlightingFeature { @Nullable @Contract(value = "null -> null", pure = true) - public static HighlightingFeature fromPreviewFeatureAnnotation(@Nullable final PsiAnnotation annotation) { + public static HighlightingFeature fromPreviewFeatureAnnotation(@Nullable PsiAnnotation annotation) { if (annotation == null) return null; if (!annotation.hasQualifiedName(JDK_INTERNAL_PREVIEW_FEATURE) && !annotation.hasQualifiedName(JDK_INTERNAL_JAVAC_PREVIEW_FEATURE)) { return null; } - final PsiNameValuePair feature = AnnotationUtil.findDeclaredAttribute(annotation, "feature"); + PsiNameValuePair feature = AnnotationUtil.findDeclaredAttribute(annotation, "feature"); if (feature == null) return null; - final PsiReferenceExpression referenceExpression = tryCast(feature.getDetachedValue(), PsiReferenceExpression.class); + PsiReferenceExpression referenceExpression = tryCast(feature.getDetachedValue(), PsiReferenceExpression.class); if (referenceExpression == null) return null; - final PsiEnumConstant enumConstant = tryCast(referenceExpression.resolve(), PsiEnumConstant.class); + PsiEnumConstant enumConstant = tryCast(referenceExpression.resolve(), PsiEnumConstant.class); if (enumConstant == null) return null; return convertFromPreviewFeatureName(enumConstant.getName()); @@ -118,7 +118,7 @@ public enum HighlightingFeature { @Nullable @Contract(pure = true) - private static HighlightingFeature convertFromPreviewFeatureName(@NotNull @NonNls final String feature) { + private static HighlightingFeature convertFromPreviewFeatureName(@NotNull @NonNls String feature) { switch (feature) { case "PATTERN_MATCHING_IN_INSTANCEOF": return PATTERNS; @@ -135,32 +135,32 @@ public enum HighlightingFeature { @Nullable @Contract(value = "null -> null", pure = true) - public static PsiAnnotation getPreviewFeatureAnnotation(@Nullable final PsiModifierListOwner owner) { + public static PsiAnnotation getPreviewFeatureAnnotation(@Nullable PsiModifierListOwner owner) { if (owner == null) return null; - final PsiAnnotation annotation = getAnnotation(owner); + PsiAnnotation annotation = getAnnotation(owner); if (annotation != null) return annotation; if (owner instanceof PsiMember && !owner.hasModifier(JvmModifier.STATIC)) { - final PsiMember member = (PsiMember)owner; - final PsiAnnotation result = getPreviewFeatureAnnotation(member.getContainingClass()); + PsiMember member = (PsiMember)owner; + PsiAnnotation result = getPreviewFeatureAnnotation(member.getContainingClass()); if (result != null) return result; } - final PsiPackage psiPackage = JavaResolveUtil.getContainingPackage(owner); + PsiPackage psiPackage = JavaResolveUtil.getContainingPackage(owner); if (psiPackage == null) return null; - final PsiAnnotation packageAnnotation = getAnnotation(psiPackage); + PsiAnnotation packageAnnotation = getAnnotation(psiPackage); if (packageAnnotation != null) return packageAnnotation; - final PsiJavaModule module = JavaModuleGraphUtil.findDescriptorByElement(owner); + PsiJavaModule module = JavaModuleGraphUtil.findDescriptorByElement(owner); if (module == null) return null; return getAnnotation(module); } private static PsiAnnotation getAnnotation(@NotNull PsiModifierListOwner owner) { - final PsiAnnotation annotation = owner.getAnnotation(JDK_INTERNAL_JAVAC_PREVIEW_FEATURE); + PsiAnnotation annotation = owner.getAnnotation(JDK_INTERNAL_JAVAC_PREVIEW_FEATURE); if (annotation != null) return annotation; return owner.getAnnotation(JDK_INTERNAL_PREVIEW_FEATURE); diff --git a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/JavaHighlightUtil.java b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/JavaHighlightUtil.java index 70712ceca092..7570d5e647ef 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/JavaHighlightUtil.java +++ b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/JavaHighlightUtil.java @@ -6,7 +6,10 @@ import com.intellij.openapi.module.Module; import com.intellij.openapi.module.ModuleUtilCore; import com.intellij.openapi.project.Project; import com.intellij.openapi.util.NlsSafe; +import com.intellij.openapi.vfs.VfsUtilCore; +import com.intellij.openapi.vfs.VirtualFile; import com.intellij.psi.*; +import com.intellij.psi.impl.PsiFileEx; import com.intellij.psi.search.GlobalSearchScope; import com.intellij.psi.util.PsiFormatUtil; import com.intellij.psi.util.PsiFormatUtilBase; @@ -19,6 +22,7 @@ import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import java.io.IOException; import java.util.ArrayList; import java.util.Collections; import java.util.List; @@ -37,12 +41,9 @@ public final class JavaHighlightUtil { public static boolean isSerializationRelatedMethod(@NotNull PsiMethod method, @Nullable PsiClass containingClass) { if (containingClass == null) return false; if (method.isConstructor()) { - if (isSerializable(containingClass, "java.io.Externalizable") && - method.getParameterList().isEmpty() && - method.hasModifierProperty(PsiModifier.PUBLIC)) { - return true; - } - return false; + return isSerializable(containingClass, "java.io.Externalizable") && + method.getParameterList().isEmpty() && + method.hasModifierProperty(PsiModifier.PUBLIC); } if (method.hasModifierProperty(PsiModifier.STATIC)) return false; @NonNls String name = method.getName(); @@ -98,7 +99,7 @@ public final class JavaHighlightUtil { public static PsiType sameType(PsiExpression @NotNull [] expressions) { PsiType type = null; for (PsiExpression expression : expressions) { - final PsiType currentType; + PsiType currentType; if (expression instanceof PsiArrayInitializerExpression) { currentType = getArrayInitializerType((PsiArrayInitializerExpression)expression); } @@ -125,15 +126,11 @@ public final class JavaHighlightUtil { if (!(statement instanceof PsiExpressionStatement)) return false; PsiExpression expression = ((PsiExpressionStatement)statement).getExpression(); if (!(expression instanceof PsiMethodCallExpression)) return false; - final PsiReferenceExpression methodExpression = ((PsiMethodCallExpression)expression).getMethodExpression(); + PsiReferenceExpression methodExpression = ((PsiMethodCallExpression)expression).getMethodExpression(); if (testForSuper) { if ("super".equals(methodExpression.getText())) return true; } - if (testForThis) { - if ("this".equals(methodExpression.getText())) return true; - } - - return false; + return testForThis && "this".equals(methodExpression.getText()); } /** @@ -143,7 +140,7 @@ public final class JavaHighlightUtil { */ @NotNull public static List getChainedConstructors(@NotNull PsiMethod constructor) { - final ConstructorVisitorInfo info = new ConstructorVisitorInfo(); + ConstructorVisitorInfo info = new ConstructorVisitorInfo(); visitConstructorChain(constructor, info); if (info.visitedConstructors != null) info.visitedConstructors.remove(constructor); return ObjectUtils.notNull(info.visitedConstructors, Collections.emptyList()); @@ -204,6 +201,35 @@ public final class JavaHighlightUtil { return JavaAnalysisBundle.message("message.class.inaccessible.from.module", className, module.getName()); } + /** + * @return true if file correspond to the shebang script + */ + public static boolean isJavaHashBangScript(@NotNull PsiFile containingFile) { + if (!(containingFile instanceof PsiJavaFile)) return false; + if (containingFile instanceof PsiFileEx && !((PsiFileEx)containingFile).isContentsLoaded()) { + VirtualFile vFile = containingFile.getVirtualFile(); + if (vFile.isInLocalFileSystem()) { + try { + // don't build PSI when not yet loaded -> time for scanning scope from 18 seconds to 8 seconds on IntelliJ project + return VfsUtilCore.loadText(vFile, 5).startsWith("#!"); + } + catch (IOException e) { + return false; + } + } + } + PsiElement firstChild = containingFile.getFirstChild(); + if (firstChild instanceof PsiImportList && firstChild.getTextLength() == 0) { + PsiElement sibling = firstChild.getNextSibling(); + if (sibling instanceof PsiClass) { + firstChild = sibling.getFirstChild(); + } + } + return firstChild instanceof PsiComment && + ((PsiComment)firstChild).getTokenType() == JavaTokenType.END_OF_LINE_COMMENT && + firstChild.getText().startsWith("#!"); + } + static class ConstructorVisitorInfo { List visitedConstructors; PsiMethod recursivelyCalledConstructor; diff --git a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/LambdaHighlightingUtil.java b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/LambdaHighlightingUtil.java index 05a9b02cd77d..e5056656216c 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/LambdaHighlightingUtil.java +++ b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/LambdaHighlightingUtil.java @@ -27,7 +27,7 @@ public final class LambdaHighlightingUtil { static @NlsContexts.DetailedDescription String checkInterfaceFunctional(@NotNull PsiClass psiClass, @NotNull @Nls String interfaceNonFunctionalMessage) { if (psiClass instanceof PsiTypeParameter) return null; //should be logged as cyclic inference - final List signatures = LambdaUtil.findFunctionCandidates(psiClass); + List signatures = LambdaUtil.findFunctionCandidates(psiClass); if (signatures == null) return interfaceNonFunctionalMessage; if (signatures.isEmpty()) return JavaErrorBundle.message("no.target.method.found"); if (signatures.size() == 1) { @@ -39,7 +39,7 @@ public final class LambdaHighlightingUtil { static HighlightInfo checkParametersCompatible(@NotNull PsiLambdaExpression expression, PsiParameter @NotNull [] methodParameters, @NotNull PsiSubstitutor substitutor) { - final PsiParameter[] lambdaParameters = expression.getParameterList().getParameters(); + PsiParameter[] lambdaParameters = expression.getParameterList().getParameters(); if (lambdaParameters.length != methodParameters.length) { return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(expression.getParameterList()) @@ -53,8 +53,8 @@ public final class LambdaHighlightingUtil { PsiType substitutedParamType = substitutor.substitute(methodParameters[i].getType()); if (hasFormalParameterTypes &&!PsiTypesUtil.compareTypes(lambdaParameterType, substitutedParamType, true) || !TypeConversionUtil.isAssignable(substitutedParamType, lambdaParameterType)) { - final String expectedType = substitutedParamType != null ? substitutedParamType.getPresentableText() : null; - final String actualType = lambdaParameterType.getPresentableText(); + String expectedType = substitutedParamType != null ? substitutedParamType.getPresentableText() : null; + String actualType = lambdaParameterType.getPresentableText(); return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(expression.getParameterList()) .descriptionAndTooltip( @@ -75,10 +75,10 @@ public final class LambdaHighlightingUtil { public static @NlsContexts.DetailedDescription String checkInterfaceFunctional(@NotNull PsiType functionalInterfaceType) { if (functionalInterfaceType instanceof PsiIntersectionType) { - final Set signatures = new HashSet<>(); + Set signatures = new HashSet<>(); for (PsiType type : ((PsiIntersectionType)functionalInterfaceType).getConjuncts()) { if (checkInterfaceFunctional(type) == null) { - final MethodSignature signature = LambdaUtil.getFunction(PsiUtil.resolveClassInType(type)); + MethodSignature signature = LambdaUtil.getFunction(PsiUtil.resolveClassInType(type)); LOG.assertTrue(signature != null, type.getCanonicalText()); signatures.add(signature); } @@ -89,8 +89,8 @@ public final class LambdaHighlightingUtil { } return null; } - final PsiClassType.ClassResolveResult resolveResult = PsiUtil.resolveGenericsClassInType(functionalInterfaceType); - final PsiClass aClass = resolveResult.getElement(); + PsiClassType.ClassResolveResult resolveResult = PsiUtil.resolveGenericsClassInType(functionalInterfaceType); + PsiClass aClass = resolveResult.getElement(); if (aClass != null) { if (aClass instanceof PsiTypeParameter) return null; //should be logged as cyclic inference MethodSignature functionalMethod = LambdaUtil.getFunction(aClass); diff --git a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/PostHighlightingVisitor.java b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/PostHighlightingVisitor.java index 2535e889f511..f8d487841e73 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/PostHighlightingVisitor.java +++ b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/PostHighlightingVisitor.java @@ -65,7 +65,7 @@ class PostHighlightingVisitor { private final HighlightInfoType myDeadCodeInfoType; private final UnusedDeclarationInspectionBase myDeadCodeInspection; - private void optimizeImportsOnTheFlyLater(@NotNull final ProgressIndicator progress) { + private void optimizeImportsOnTheFlyLater(@NotNull ProgressIndicator progress) { if ((myHasRedundantImports || myHasMisSortedImports) && !progress.isCanceled()) { // schedule optimise action at the time of session disposal, which is after all applyInformation() calls Disposable invokeFixLater = () -> { @@ -126,8 +126,8 @@ class PostHighlightingVisitor { if (isToolEnabled(myDeadCodeKey)) { GlobalUsageHelper globalUsageHelper = myRefCountHolder.getGlobalUsageHelper(myFile, myDeadCodeInspection, true); - final FileViewProvider viewProvider = myFile.getViewProvider(); - final Set relevantLanguages = viewProvider.getLanguages(); + FileViewProvider viewProvider = myFile.getViewProvider(); + Set relevantLanguages = viewProvider.getLanguages(); for (Language language : relevantLanguages) { ProgressManager.checkCanceled(); PsiElement psiRoot = viewProvider.getPsi(language); @@ -153,10 +153,10 @@ class PostHighlightingVisitor { if (isUnusedImportEnabled(unusedImportKey)) { PsiImportList importList = ((PsiJavaFile)myFile).getImportList(); if (importList != null) { - final PsiImportStatementBase[] imports = importList.getAllImportStatements(); + PsiImportStatementBase[] imports = importList.getAllImportStatements(); for (PsiImportStatementBase statement : imports) { ProgressManager.checkCanceled(); - final HighlightInfo info = processImport(statement, unusedImportKey); + HighlightInfo info = processImport(statement, unusedImportKey); if (info != null) { errorFound |= info.getSeverity() == HighlightSeverity.ERROR; result.add(info); @@ -206,7 +206,7 @@ class PostHighlightingVisitor { } if (parent instanceof PsiParameter) { PsiElement declarationScope = ((PsiParameter)parent).getDeclarationScope(); - final boolean needToProcessParameter; + boolean needToProcessParameter; if (declarationScope instanceof PsiMethod || declarationScope instanceof PsiLambdaExpression) { if (declarationScope instanceof PsiLambdaExpression) { declarationScope = PsiTreeUtil.getParentOfType(declarationScope, PsiModifierListOwner.class); @@ -230,7 +230,7 @@ class PostHighlightingVisitor { } } if (parent instanceof PsiClass) { - final String acceptedVisibility = ((PsiClass)parent).getContainingClass() == null ? myUnusedSymbolInspection.getClassVisibility() + String acceptedVisibility = ((PsiClass)parent).getContainingClass() == null ? myUnusedSymbolInspection.getClassVisibility() : myUnusedSymbolInspection.getInnerClassVisibility(); if (compareVisibilities((PsiModifierListOwner)parent, acceptedVisibility)) { return processClass(myProject, (PsiClass)parent, identifier, progress, helper); @@ -239,7 +239,7 @@ class PostHighlightingVisitor { return null; } - private static boolean compareVisibilities(PsiModifierListOwner listOwner, final String visibility) { + private static boolean compareVisibilities(PsiModifierListOwner listOwner, String visibility) { if (visibility != null) { while (listOwner != null) { if (VisibilityUtil.compare(VisibilityUtil.getVisibilityModifier(listOwner.getModifierList()), visibility) >= 0) { @@ -278,7 +278,7 @@ class PostHighlightingVisitor { } if (message != null) { - final HighlightInfo highlightInfo = UnusedSymbolUtil.createUnusedSymbolInfo(identifier, message, myDeadCodeInfoType, UnusedDeclarationInspectionBase.SHORT_NAME); + HighlightInfo highlightInfo = UnusedSymbolUtil.createUnusedSymbolInfo(identifier, message, myDeadCodeInfoType, UnusedDeclarationInspectionBase.SHORT_NAME); QuickFixAction.registerQuickFixAction(highlightInfo, fix, myDeadCodeKey); return highlightInfo; } @@ -287,8 +287,8 @@ class PostHighlightingVisitor { } @Nullable - private HighlightInfo processField(@NotNull final Project project, - @NotNull final PsiField field, + private HighlightInfo processField(@NotNull Project project, + @NotNull PsiField field, @NotNull PsiIdentifier identifier, @NotNull ProgressIndicator progress, @NotNull GlobalUsageHelper helper) { @@ -296,7 +296,7 @@ class PostHighlightingVisitor { return null; } if (field.hasModifierProperty(PsiModifier.PRIVATE)) { - final QuickFixFactory quickFixFactory = QuickFixFactory.getInstance(); + QuickFixFactory quickFixFactory = QuickFixFactory.getInstance(); if (!myRefCountHolder.isReferenced(field) && !UnusedSymbolUtil.isImplicitUsage(myProject, field)) { String message = JavaErrorBundle.message("private.field.is.not.used", identifier.getText()); @@ -308,7 +308,7 @@ class PostHighlightingVisitor { return highlightInfo; } - final boolean readReferenced = myRefCountHolder.isReferencedForRead(field); + boolean readReferenced = myRefCountHolder.isReferencedForRead(field); if (!readReferenced && !UnusedSymbolUtil.isImplicitRead(project, field)) { String message = getNotUsedForReadingMessage(field, identifier); return suggestionsToMakeFieldUsed(field, identifier, message); @@ -317,10 +317,10 @@ class PostHighlightingVisitor { if (field.hasInitializer()) { return null; } - final boolean writeReferenced = myRefCountHolder.isReferencedForWrite(field); + boolean writeReferenced = myRefCountHolder.isReferencedForWrite(field); if (!writeReferenced && !UnusedSymbolUtil.isImplicitWrite(project, field)) { String message = JavaErrorBundle.message("private.field.is.not.assigned", identifier.getText()); - final HighlightInfo info = UnusedSymbolUtil.createUnusedSymbolInfo(identifier, message, myDeadCodeInfoType, UnusedDeclarationInspectionBase.SHORT_NAME); + HighlightInfo info = UnusedSymbolUtil.createUnusedSymbolInfo(identifier, message, myDeadCodeInfoType, UnusedDeclarationInspectionBase.SHORT_NAME); QuickFixAction.registerQuickFixAction(info, quickFixFactory.createCreateGetterOrSetterFix(false, true, field), myDeadCodeKey); if (!field.hasModifierProperty(PsiModifier.FINAL)) { @@ -350,10 +350,10 @@ class PostHighlightingVisitor { } @NotNull - private static @NlsContexts.DetailedDescription String getNotUsedForReadingMessage(@NotNull final PsiField field, @NotNull final PsiIdentifier identifier) { - final String visibility = VisibilityUtil.getVisibilityStringToDisplay(field); + private static @NlsContexts.DetailedDescription String getNotUsedForReadingMessage(@NotNull PsiField field, @NotNull PsiIdentifier identifier) { + String visibility = VisibilityUtil.getVisibilityStringToDisplay(field); - final String message = JavaErrorBundle.message("field.is.not.used.for.reading", visibility, identifier.getText()); + String message = JavaErrorBundle.message("field.is.not.used.for.reading", visibility, identifier.getText()); return StringUtil.capitalize(message); } @@ -465,8 +465,8 @@ class PostHighlightingVisitor { } @Nullable - private HighlightInfo processMethod(@NotNull final Project project, - @NotNull final PsiMethod method, + private HighlightInfo processMethod(@NotNull Project project, + @NotNull PsiMethod method, @NotNull PsiIdentifier identifier, @NotNull ProgressIndicator progress, @NotNull GlobalUsageHelper helper) { @@ -481,7 +481,7 @@ class PostHighlightingVisitor { int options = PsiFormatUtilBase.SHOW_TYPE | PsiFormatUtilBase.SHOW_FQ_CLASS_NAMES; String symbolName = HighlightMessageUtil.getSymbolName(method, PsiSubstitutor.EMPTY, options); String message = JavaErrorBundle.message(key, symbolName); - final HighlightInfo highlightInfo = UnusedSymbolUtil.createUnusedSymbolInfo(identifier, message, myDeadCodeInfoType, UnusedDeclarationInspectionBase.SHORT_NAME); + HighlightInfo highlightInfo = UnusedSymbolUtil.createUnusedSymbolInfo(identifier, message, myDeadCodeInfoType, UnusedDeclarationInspectionBase.SHORT_NAME); QuickFixAction.registerQuickFixAction(highlightInfo, QuickFixFactory.getInstance().createSafeDeleteFix(method), myDeadCodeKey); SpecialAnnotationsUtilBase.createAddToSpecialAnnotationFixes(method, annoName -> { IntentionAction fix = QuickFixFactory.getInstance().createAddToDependencyInjectionAnnotationsFix(project, annoName); @@ -524,15 +524,15 @@ class PostHighlightingVisitor { } - private static HighlightInfo formatUnusedSymbolHighlightInfo(@NotNull final Project project, + private static HighlightInfo formatUnusedSymbolHighlightInfo(@NotNull Project project, @NotNull @PropertyKey(resourceBundle = JavaErrorBundle.BUNDLE) String pattern, - @NotNull final PsiNameIdentifierOwner aClass, + @NotNull PsiNameIdentifierOwner aClass, HighlightDisplayKey highlightDisplayKey, @NotNull HighlightInfoType highlightInfoType, @NotNull PsiElement identifier) { String symbolName = aClass.getName(); String message = JavaErrorBundle.message(pattern, symbolName); - final HighlightInfo highlightInfo = UnusedSymbolUtil.createUnusedSymbolInfo(identifier, message, highlightInfoType, UnusedDeclarationInspectionBase.SHORT_NAME); + HighlightInfo highlightInfo = UnusedSymbolUtil.createUnusedSymbolInfo(identifier, message, highlightInfoType, UnusedDeclarationInspectionBase.SHORT_NAME); QuickFixAction.registerQuickFixAction(highlightInfo, QuickFixFactory.getInstance().createSafeDeleteFix(aClass), highlightDisplayKey); SpecialAnnotationsUtilBase.createAddToSpecialAnnotationFixes((PsiModifierListOwner)aClass, annoName -> { QuickFixAction diff --git a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/PreviewFeatureVisitorBase.java b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/PreviewFeatureVisitorBase.java index 80e3231c030c..d7ed5f86d06e 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/PreviewFeatureVisitorBase.java +++ b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/PreviewFeatureVisitorBase.java @@ -21,22 +21,22 @@ public abstract class PreviewFeatureVisitorBase extends JavaElementVisitor { @Override public void visitReferenceElement(PsiJavaCodeReferenceElement reference) { - final PsiElement resolved = reference.resolve(); + PsiElement resolved = reference.resolve(); if (!(resolved instanceof PsiModifierListOwner)) return; - final PsiModifierListOwner owner = (PsiModifierListOwner)resolved; + PsiModifierListOwner owner = (PsiModifierListOwner)resolved; checkPreviewFeature(reference, reference, owner); } @Override public void visitReferenceExpression(PsiReferenceExpression expression) { - final PsiElement resolved = expression.resolve(); + PsiElement resolved = expression.resolve(); if (!(resolved instanceof PsiModifierListOwner)) return; - final PsiModifierListOwner owner = (PsiModifierListOwner)resolved; + PsiModifierListOwner owner = (PsiModifierListOwner)resolved; checkPreviewFeature(expression, expression, owner); } @@ -44,30 +44,30 @@ public abstract class PreviewFeatureVisitorBase extends JavaElementVisitor { @Override public void visitModuleStatement(PsiStatement statement) { if (statement instanceof PsiRequiresStatement) { - final PsiRequiresStatement requiresStatement = (PsiRequiresStatement)statement; - final PsiJavaModule module = requiresStatement.resolve(); + PsiRequiresStatement requiresStatement = (PsiRequiresStatement)statement; + PsiJavaModule module = requiresStatement.resolve(); if (module == null) return; - final PsiAnnotation annotation = getPreviewFeatureAnnotation(module); - final HighlightingFeature feature = HighlightingFeature.fromPreviewFeatureAnnotation(annotation); + PsiAnnotation annotation = getPreviewFeatureAnnotation(module); + HighlightingFeature feature = HighlightingFeature.fromPreviewFeatureAnnotation(annotation); if (feature == null) return; - final String description = JavaBundle.message("inspection.preview.feature.0.is.preview.api.message", module.getName()); + String description = JavaBundle.message("inspection.preview.feature.0.is.preview.api.message", module.getName()); registerProblem(requiresStatement.getReferenceElement(), description, feature, annotation); } else if (statement instanceof PsiProvidesStatement) { - final PsiProvidesStatement providesStatement = (PsiProvidesStatement)statement; - final PsiReferenceList list = providesStatement.getImplementationList(); + PsiProvidesStatement providesStatement = (PsiProvidesStatement)statement; + PsiReferenceList list = providesStatement.getImplementationList(); if (list == null) return; for (PsiJavaCodeReferenceElement element : list.getReferenceElements()) { - final PsiElement resolved = element.resolve(); + PsiElement resolved = element.resolve(); if (resolved instanceof PsiClass) { - final PsiClass psiClass = (PsiClass)resolved; - final PsiAnnotation annotation = getPreviewFeatureAnnotation(psiClass); - final HighlightingFeature feature = HighlightingFeature.fromPreviewFeatureAnnotation(annotation); + PsiClass psiClass = (PsiClass)resolved; + PsiAnnotation annotation = getPreviewFeatureAnnotation(psiClass); + HighlightingFeature feature = HighlightingFeature.fromPreviewFeatureAnnotation(annotation); if (feature == null) continue; - final String description = + String description = JavaBundle.message("inspection.preview.feature.0.is.preview.api.message", psiClass.getQualifiedName()); registerProblem(element, description, feature, annotation); } @@ -96,18 +96,18 @@ public abstract class PreviewFeatureVisitorBase extends JavaElementVisitor { * @param owner an element that should be checked if it's a preview feature */ private void checkPreviewFeature(PsiElement context, PsiJavaCodeReferenceElement reference, PsiModifierListOwner owner) { - final PsiAnnotation annotation = getPreviewFeatureAnnotation(owner); - final HighlightingFeature feature = HighlightingFeature.fromPreviewFeatureAnnotation(annotation); + PsiAnnotation annotation = getPreviewFeatureAnnotation(owner); + HighlightingFeature feature = HighlightingFeature.fromPreviewFeatureAnnotation(annotation); if (feature == null) return; if (isParticipating(reference, owner)) return; - @NotNull final String name; + @NotNull String name; if (owner instanceof PsiMember) { - final PsiMember member = (PsiMember)owner; - final PsiClass className = member.getContainingClass(); - final String methodName = member.getName(); + PsiMember member = (PsiMember)owner; + PsiClass className = member.getContainingClass(); + String methodName = member.getName(); if (member instanceof PsiClass) { - final PsiClass psiClass = (PsiClass)member; + PsiClass psiClass = (PsiClass)member; name = Objects.requireNonNull(psiClass.getQualifiedName()); } else if (member instanceof PsiMethod && ((PsiMethod)member).isConstructor()) { @@ -121,7 +121,7 @@ public abstract class PreviewFeatureVisitorBase extends JavaElementVisitor { name = reference.getQualifiedName(); } - final String description = JavaBundle.message("inspection.preview.feature.0.is.preview.api.message", name); + String description = JavaBundle.message("inspection.preview.feature.0.is.preview.api.message", name); registerProblem(context, description, feature, annotation); } @@ -147,8 +147,8 @@ public abstract class PreviewFeatureVisitorBase extends JavaElementVisitor { if (element == null) return Optional.empty(); if (element instanceof PsiPackage) return Optional.empty(); - final Supplier containingClass = () -> element instanceof PsiMember ? ((PsiMember)element).getContainingClass() : null; - final Supplier javaModule = () -> element instanceof PsiJavaModule ? null : JavaModuleGraphUtil.findDescriptorByElement(element); + Supplier containingClass = () -> element instanceof PsiMember ? ((PsiMember)element).getContainingClass() : null; + Supplier javaModule = () -> element instanceof PsiJavaModule ? null : JavaModuleGraphUtil.findDescriptorByElement(element); return Optional.ofNullable(element.getAnnotation(JDK_INTERNAL_JAVAC_PREVIEW_FEATURE)) .or(() -> Optional.ofNullable(element.getAnnotation(JDK_INTERNAL_PREVIEW_FEATURE))) diff --git a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/PsiMethodReferenceHighlightingUtil.java b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/PsiMethodReferenceHighlightingUtil.java index d8c38515e36e..66a613daa642 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/PsiMethodReferenceHighlightingUtil.java +++ b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/PsiMethodReferenceHighlightingUtil.java @@ -29,7 +29,7 @@ public final class PsiMethodReferenceHighlightingUtil { } static @NlsContexts.DetailedDescription String checkMethodReferenceContext(@NotNull PsiMethodReferenceExpression methodRef) { - final PsiElement resolve = methodRef.resolve(); + PsiElement resolve = methodRef.resolve(); if (resolve == null) return null; return checkMethodReferenceContext(methodRef, resolve, methodRef.getFunctionalInterfaceType()); @@ -38,22 +38,22 @@ public final class PsiMethodReferenceHighlightingUtil { public static @NlsContexts.DetailedDescription String checkMethodReferenceContext(@NotNull PsiMethodReferenceExpression methodRef, @NotNull PsiElement resolve, PsiType functionalInterfaceType) { - final PsiClass containingClass = resolve instanceof PsiMethod ? ((PsiMethod)resolve).getContainingClass() : (PsiClass)resolve; - final boolean isStaticSelector = PsiMethodReferenceUtil.isStaticallyReferenced(methodRef); - final PsiElement qualifier = methodRef.getQualifier(); + PsiClass containingClass = resolve instanceof PsiMethod ? ((PsiMethod)resolve).getContainingClass() : (PsiClass)resolve; + boolean isStaticSelector = PsiMethodReferenceUtil.isStaticallyReferenced(methodRef); + PsiElement qualifier = methodRef.getQualifier(); boolean isMethodStatic = false; boolean receiverReferenced = false; boolean isConstructor = true; if (resolve instanceof PsiMethod) { - final PsiMethod method = (PsiMethod)resolve; + PsiMethod method = (PsiMethod)resolve; isMethodStatic = method.hasModifierProperty(PsiModifier.STATIC); isConstructor = method.isConstructor(); - final PsiClassType.ClassResolveResult resolveResult = PsiUtil.resolveGenericsClassInType(functionalInterfaceType); - final PsiMethod interfaceMethod = LambdaUtil.getFunctionalInterfaceMethod(resolveResult); + PsiClassType.ClassResolveResult resolveResult = PsiUtil.resolveGenericsClassInType(functionalInterfaceType); + PsiMethod interfaceMethod = LambdaUtil.getFunctionalInterfaceMethod(resolveResult); receiverReferenced = PsiMethodReferenceUtil.isResolvedBySecondSearch(methodRef, interfaceMethod != null ? interfaceMethod.getSignature(LambdaUtil.getSubstitutor(interfaceMethod, resolveResult)) : null, method.isVarArgs(), @@ -78,9 +78,9 @@ public final class PsiMethodReferenceHighlightingUtil { } if (isMethodStatic && isStaticSelector && qualifier instanceof PsiTypeElement) { - final PsiJavaCodeReferenceElement referenceElement = PsiTreeUtil.getChildOfType(qualifier, PsiJavaCodeReferenceElement.class); + PsiJavaCodeReferenceElement referenceElement = PsiTreeUtil.getChildOfType(qualifier, PsiJavaCodeReferenceElement.class); if (referenceElement != null) { - final PsiReferenceParameterList parameterList = referenceElement.getParameterList(); + PsiReferenceParameterList parameterList = referenceElement.getParameterList(); if (parameterList != null && parameterList.getTypeArguments().length > 0) { return JavaErrorBundle.message("parameterized.qualifier.on.static.method.reference.context"); } diff --git a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/RefCountHolder.java b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/RefCountHolder.java index ee0e5fc1200f..4217c9a69e9b 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/RefCountHolder.java +++ b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/RefCountHolder.java @@ -72,7 +72,7 @@ final class RefCountHolder { @NotNull GlobalUsageHelper getGlobalUsageHelper(@NotNull PsiFile file, - @Nullable final UnusedDeclarationInspectionBase deadCodeInspection, + @Nullable UnusedDeclarationInspectionBase deadCodeInspection, boolean isUnusedToolEnabled) { FileViewProvider viewProvider = file.getViewProvider(); Project project = file.getProject(); diff --git a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/RemoveNewKeywordFix.java b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/RemoveNewKeywordFix.java index 1a8622a21d5f..ed351e6f881d 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/RemoveNewKeywordFix.java +++ b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/RemoveNewKeywordFix.java @@ -33,18 +33,18 @@ final class RemoveNewKeywordFix extends LocalQuickFixAndIntentionActionOnPsiElem @Nullable Editor editor, @NotNull PsiElement startElement, @NotNull PsiElement endElement) { - final PsiNewExpression newDeclaration = tryCast(startElement, PsiNewExpression.class); + PsiNewExpression newDeclaration = tryCast(startElement, PsiNewExpression.class); if (newDeclaration == null) return; - final PsiJavaCodeReferenceElement reference = newDeclaration.getClassOrAnonymousClassReference(); + PsiJavaCodeReferenceElement reference = newDeclaration.getClassOrAnonymousClassReference(); if (reference == null) return; - final PsiExpressionList arguments = newDeclaration.getArgumentList(); + PsiExpressionList arguments = newDeclaration.getArgumentList(); - final CommentTracker ct = new CommentTracker(); + CommentTracker ct = new CommentTracker(); ct.markRangeUnchanged(reference, Objects.requireNonNullElse(arguments, reference)); - final String methodCallExpression = newDeclaration.getText().substring(reference.getStartOffsetInParent()); + String methodCallExpression = newDeclaration.getText().substring(reference.getStartOffsetInParent()); ct.replaceAndRestoreComments(newDeclaration, methodCallExpression); } } diff --git a/java/java-analysis-impl/src/com/intellij/psi/impl/file/impl/JavaOutOfSourcesResolveScopeProvider.java b/java/java-analysis-impl/src/com/intellij/psi/impl/file/impl/JavaOutOfSourcesResolveScopeProvider.java index 8c838a386eb0..f828219b39f5 100644 --- a/java/java-analysis-impl/src/com/intellij/psi/impl/file/impl/JavaOutOfSourcesResolveScopeProvider.java +++ b/java/java-analysis-impl/src/com/intellij/psi/impl/file/impl/JavaOutOfSourcesResolveScopeProvider.java @@ -1,7 +1,7 @@ // Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. package com.intellij.psi.impl.file.impl; -import com.intellij.codeInsight.daemon.impl.analysis.HighlightClassUtil; +import com.intellij.codeInsight.daemon.impl.analysis.JavaHighlightUtil; import com.intellij.lang.java.JavaLanguage; import com.intellij.openapi.fileTypes.FileType; import com.intellij.openapi.fileTypes.LanguageFileType; @@ -26,15 +26,15 @@ public final class JavaOutOfSourcesResolveScopeProvider extends ResolveScopeProv @Override public GlobalSearchScope getResolveScope(@NotNull VirtualFile file, @NotNull Project project) { // For java only! For other languages resolve may be implemented with different rules, requiring larger scope. - final FileType type = file.getFileType(); + FileType type = file.getFileType(); if (type instanceof LanguageFileType && ((LanguageFileType)type).getLanguage() == JavaLanguage.INSTANCE) { ProjectFileIndex index = project.isDefault() ? null : ProjectRootManager.getInstance(project).getFileIndex(); if (index == null) { return GlobalSearchScope.fileScope(project, file); } if (index.isInContent(file) && !index.isInSource(file)) { - final PsiFile psi = PsiManager.getInstance(project).findFile(file); - if (!HighlightClassUtil.isJavaHashBangScript(psi)) { + PsiFile psi = PsiManager.getInstance(project).findFile(file); + if (psi == null || !JavaHighlightUtil.isJavaHashBangScript(psi)) { return GlobalSearchScope.fileScope(project, file); } } diff --git a/java/java-impl-inspections/src/com/intellij/codeInspection/wrongPackageStatement/WrongPackageStatementInspection.java b/java/java-impl-inspections/src/com/intellij/codeInspection/wrongPackageStatement/WrongPackageStatementInspection.java index daf7f28d7011..3db9e6823b3a 100644 --- a/java/java-impl-inspections/src/com/intellij/codeInspection/wrongPackageStatement/WrongPackageStatementInspection.java +++ b/java/java-impl-inspections/src/com/intellij/codeInspection/wrongPackageStatement/WrongPackageStatementInspection.java @@ -3,7 +3,7 @@ package com.intellij.codeInspection.wrongPackageStatement; import com.intellij.codeHighlighting.HighlightDisplayLevel; import com.intellij.codeInsight.daemon.JavaErrorBundle; -import com.intellij.codeInsight.daemon.impl.analysis.HighlightClassUtil; +import com.intellij.codeInsight.daemon.impl.analysis.JavaHighlightUtil; import com.intellij.codeInspection.*; import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.util.Comparing; @@ -33,7 +33,7 @@ public class WrongPackageStatementInspection extends AbstractBaseJavaLocalInspec if (FileTypeUtils.isInServerPageFile(file)) return null; PsiJavaFile javaFile = (PsiJavaFile)file; - if (HighlightClassUtil.isJavaHashBangScript(javaFile)) return null; + if (JavaHighlightUtil.isJavaHashBangScript(javaFile)) return null; PsiDirectory directory = javaFile.getContainingDirectory(); if (directory == null) return null; diff --git a/java/java-impl/src/com/intellij/codeInsight/daemon/JavaProblemHighlightFilter.java b/java/java-impl/src/com/intellij/codeInsight/daemon/JavaProblemHighlightFilter.java index 78a84c0cf014..1cadd7f431be 100644 --- a/java/java-impl/src/com/intellij/codeInsight/daemon/JavaProblemHighlightFilter.java +++ b/java/java-impl/src/com/intellij/codeInsight/daemon/JavaProblemHighlightFilter.java @@ -1,7 +1,7 @@ // Copyright 2000-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. package com.intellij.codeInsight.daemon; -import com.intellij.codeInsight.daemon.impl.analysis.HighlightClassUtil; +import com.intellij.codeInsight.daemon.impl.analysis.JavaHighlightUtil; import com.intellij.ide.highlighter.JavaFileType; import com.intellij.ide.scratch.ScratchUtil; import com.intellij.openapi.roots.JavaProjectRootsUtil; @@ -18,7 +18,7 @@ public class JavaProblemHighlightFilter extends ProblemHighlightFilter { return psiFile.getFileType() != JavaFileType.INSTANCE || !JavaProjectRootsUtil.isOutsideJavaSourceRoot(psiFile) || ScratchUtil.isScratch(psiFile.getVirtualFile()) || - HighlightClassUtil.isJavaHashBangScript(psiFile); + JavaHighlightUtil.isJavaHashBangScript(psiFile); } @Override diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/LightJava11HighlightingTest.kt b/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/LightJava11HighlightingTest.kt index ce404bc7da77..4d443cd53203 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/LightJava11HighlightingTest.kt +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/LightJava11HighlightingTest.kt @@ -2,7 +2,7 @@ package com.intellij.java.codeInsight.daemon import com.intellij.JavaTestUtil -import com.intellij.codeInsight.daemon.impl.analysis.HighlightClassUtil +import com.intellij.codeInsight.daemon.impl.analysis.JavaHighlightUtil import com.intellij.codeInsight.navigation.actions.GotoDeclarationAction import com.intellij.psi.CommonClassNames import com.intellij.psi.PsiClass @@ -38,7 +38,7 @@ class LightJava11HighlightingTest : LightJavaCodeInsightFixtureTestCase() { |i**; |}}""".trimMargin()) myFixture.checkHighlighting() - Assert.assertTrue(HighlightClassUtil.isJavaHashBangScript(file)) + Assert.assertTrue(JavaHighlightUtil.isJavaHashBangScript(file)) } private fun doTest() {