diff --git a/java/java-analysis-api/resources/messages/JavaAnalysisBundle.properties b/java/java-analysis-api/resources/messages/JavaAnalysisBundle.properties index c1f5e2c5e9b4..6568afcdd719 100644 --- a/java/java-analysis-api/resources/messages/JavaAnalysisBundle.properties +++ b/java/java-analysis-api/resources/messages/JavaAnalysisBundle.properties @@ -1,10 +1,117 @@ add.explicit.type.arguments=Add explicit type arguments + +# suppress inspection "UnusedProperty" +annotation.target.ANNOTATION_TYPE=annotation type +# suppress inspection "UnusedProperty" +annotation.target.CONSTRUCTOR=constructor +# suppress inspection "UnusedProperty" +annotation.target.FIELD=field +# suppress inspection "UnusedProperty" +annotation.target.LOCAL_VARIABLE=local variable +# suppress inspection "UnusedProperty" +annotation.target.METHOD=method +# suppress inspection "UnusedProperty" +annotation.target.MODULE=module +# suppress inspection "UnusedProperty" +annotation.target.PACKAGE=package +# suppress inspection "UnusedProperty" +annotation.target.PARAMETER=parameter +# suppress inspection "UnusedProperty" +annotation.target.RECORD_COMPONENT=record component +# suppress inspection "UnusedProperty" +annotation.target.TYPE=type +# suppress inspection "UnusedProperty" +annotation.target.TYPE_PARAMETER=type parameter +# suppress inspection "UnusedProperty" +annotation.target.TYPE_USE=type use + change.type.arguments=Change type arguments change.type.arguments.to.0=Change type arguments to <{0}> convert.0.to.float=Convert ''{0}'' to float + +dataflow.message.array.index.out.of.bounds=Array index is out of bounds +dataflow.message.arraystore=Storing element of type {0} to array of {1} elements may produce ArrayStoreException +dataflow.message.assigning.null.notannotated=Assigning null value to non-annotated field +dataflow.message.assigning.null=null is assigned to a variable that is annotated with @NotNull +dataflow.message.assigning.nullable.notannotated=Expression #ref #loc might be null but is assigned to non-annotated field +dataflow.message.assigning.nullable=Expression #ref might evaluate to null but is assigned to a variable that is annotated with @NotNull +dataflow.message.cce.always=Casting {0} to #ref #loc will produce ClassCastException for any non-null value +dataflow.message.cce=Casting {0} to #ref #loc may produce ClassCastException +dataflow.message.constant.condition.when.reached=Condition #ref #loc is always {0, choice, 0#false|1#true} when reached +dataflow.message.constant.condition=Condition #ref #loc is always {0, choice, 0#false|1#true} +dataflow.message.constant.method.reference=Method reference result is always ''{0}'' +dataflow.message.constant.no.ref=Condition is always {0, choice, 0#false|1#true} +dataflow.message.contract.fail.index=The call to '#ref' always fails as index is out of bounds +dataflow.message.contract.fail=The call to '#ref' always fails, according to its method contracts +dataflow.message.immutable.modified=Immutable object is modified +dataflow.message.immutable.passed=Immutable object is passed where mutable is expected +dataflow.message.npe.array.access.sure=Array access #ref #loc will produce NullPointerException +dataflow.message.npe.array.access=Array access #ref #loc may produce NullPointerException +dataflow.message.npe.field.access.sure=Dereference of #ref #loc will produce NullPointerException +dataflow.message.npe.field.access=Dereference of #ref #loc may produce NullPointerException +dataflow.message.npe.inner.class.construction.sure=Inner class construction will produce NullPointerException +dataflow.message.npe.inner.class.construction=Inner class construction may produce NullPointerException +dataflow.message.npe.method.invocation.sure=Method invocation #ref #loc will produce NullPointerException +dataflow.message.npe.method.invocation=Method invocation #ref #loc may produce NullPointerException +dataflow.message.npe.methodref.invocation=Method reference invocation #ref #loc may produce NullPointerException +dataflow.message.only.switch.label=Switch label #ref #loc is the only reachable in the whole switch +dataflow.message.passing.null.argument.nonannotated=Passing null argument to non-annotated parameter +dataflow.message.passing.null.argument=Passing null argument to parameter annotated as @NotNull +dataflow.message.passing.nullable.argument.methodref.nonannotated=Method reference argument might be null but passed to non-annotated parameter +dataflow.message.passing.nullable.argument.methodref=Method reference argument might be null +dataflow.message.passing.nullable.argument.nonannotated=Argument #ref #loc might be null but passed to non-annotated parameter +dataflow.message.passing.nullable.argument=Argument #ref #loc might be null +dataflow.message.pointless.assignment.expression=Condition #ref #loc at the left side of assignment expression is always {0}. Can be simplified +dataflow.message.pointless.same.arguments=Arguments of '#ref' are the same. Calling this method with the same arguments is meaningless. +dataflow.message.redundant.assignment=Variable is already assigned to this value +dataflow.message.redundant.instanceof=Condition #ref #loc is redundant and can be replaced with a null check +dataflow.message.redundant.update=Variable update does nothing +dataflow.message.return.null.from.notnull=null is returned by the method declared as @{0} +dataflow.message.return.null.from.notnullable=null is returned by the method which is not declared as @{0} +dataflow.message.return.nullable.from.notnull.function=Function may return null, but it's not allowed here +dataflow.message.return.nullable.from.notnull=Expression #ref might evaluate to null but is returned by the method declared as @{0} +dataflow.message.return.nullable.from.notnullable=Expression #ref might evaluate to null but is returned by the method which is not declared as @{0} +dataflow.message.storing.array.null=null is stored to an array of @NotNull elements +dataflow.message.storing.array.nullable=Expression #ref might evaluate to null but is stored to an array of @NotNull elements +dataflow.message.unboxing.method.reference=Use of #ref #loc would need unboxing which may produce NullPointerException +dataflow.message.unboxing=Unboxing of #ref #loc may produce NullPointerException +dataflow.message.unreachable.switch.label=Switch label #ref #loc is unreachable +dataflow.method.fails.with.null.argument=Method will throw an exception when parameter is null +dataflow.not.precise={0} is complex: data flow results could be imprecise +dataflow.too.complex={0} is too complex to analyze by data flow algorithm + delete.repeated.0=Delete repeated ''{0}'' delete.repeated.interface=Delete repeated interface exception.removal.will.break.source.code.proceed.anyway=Exception removal will break source code. Proceed anyway? + +feature.generics=Generics +feature.annotations=Annotations +feature.static.imports=Static imports +feature.for.each=For-each loops +feature.varargs=Variable arity methods +feature.hex.fp.literals=Hexadecimal floating point literals +feature.diamond.types=Diamond types +feature.multi.catch=Multi-catches +feature.try.with.resources=Try-with-resources +feature.binary.literals=Binary literals +feature.underscores.in.literals=Underscores in literals +feature.extension.methods=Extension methods +feature.method.references=Method references +feature.lambda.expressions=Lambda expressions +feature.type.annotations=Type annotations +feature.type.receivers=Receiver parameters +feature.intersections.in.casts=Intersection types in casts +feature.static.interface.calls=Static interface method calls +feature.try.with.resources.refs=Resource references +feature.modules=Modules +feature.lvti=Local variable type inference +feature.text.blocks=Text block literals +feature.enhanced.switch=Enhanced 'switch' blocks +feature.switch.expressions='switch' expressions +feature.records=Records +feature.patterns.instanceof=Patterns in 'instanceof' +feature.text.block.escape.sequences='\\s' and '\\' escape sequences + find.searching.for.references.to.class.progress=Searching for references to class {0}... find.usages.panel.title.derived.classes=Derived Classes find.usages.panel.title.derived.interfaces=Derived Interfaces diff --git a/java/java-analysis-api/src/com/intellij/java/analysis/JavaAnalysisBundle.java b/java/java-analysis-api/src/com/intellij/java/analysis/JavaAnalysisBundle.java index 97edad416a40..c4392b1b47c2 100644 --- a/java/java-analysis-api/src/com/intellij/java/analysis/JavaAnalysisBundle.java +++ b/java/java-analysis-api/src/com/intellij/java/analysis/JavaAnalysisBundle.java @@ -9,7 +9,7 @@ import org.jetbrains.annotations.PropertyKey; import java.util.function.Supplier; public class JavaAnalysisBundle extends DynamicBundle { - @NonNls private static final String BUNDLE = "messages.JavaAnalysisBundle"; + @NonNls public static final String BUNDLE = "messages.JavaAnalysisBundle"; private static final JavaAnalysisBundle INSTANCE = new JavaAnalysisBundle(); private JavaAnalysisBundle() { diff --git a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/AnnotationsHighlightUtil.java b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/AnnotationsHighlightUtil.java index 96b340b5d0cb..0b976f2d1c26 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/AnnotationsHighlightUtil.java +++ b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/AnnotationsHighlightUtil.java @@ -10,6 +10,7 @@ import com.intellij.codeInsight.daemon.impl.quickfix.QuickFixAction; import com.intellij.codeInsight.intention.IntentionAction; import com.intellij.codeInsight.intention.QuickFixFactory; import com.intellij.codeInsight.intention.impl.BaseIntentionAction; +import com.intellij.java.analysis.JavaAnalysisBundle; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.editor.Editor; import com.intellij.openapi.project.Project; @@ -220,7 +221,7 @@ public class AnnotationsHighlightUtil { PsiAnnotation.TargetType[] targets = AnnotationTargetUtil.getTargetsForLocation(owner); PsiAnnotation.TargetType applicable = AnnotationTargetUtil.findAnnotationTarget(container, targets); if (applicable == null) { - String target = JavaErrorBundle.message("annotation.target." + targets[0]); + String target = JavaAnalysisBundle.message("annotation.target." + targets[0]); String message = JavaErrorBundle.message("annotation.container.not.applicable", container.getName(), target); return annotationError(annotationToCheck, message); } @@ -361,7 +362,7 @@ public class AnnotationsHighlightUtil { if (applicable == PsiAnnotation.TargetType.UNKNOWN) return null; if (applicable == null) { - String target = JavaErrorBundle.message("annotation.target." + targets[0]); + String target = JavaAnalysisBundle.message("annotation.target." + targets[0]); String message = JavaErrorBundle.message("annotation.not.applicable", nameRef.getText(), target); return annotationError(annotation, message); } 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 1ff09fa191b7..c3f20abe15ce 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 @@ -15,6 +15,7 @@ import com.intellij.codeInsight.intention.IntentionAction; import com.intellij.codeInsight.intention.QuickFixFactory; import com.intellij.codeInsight.quickfix.UnresolvedReferenceQuickFixProvider; import com.intellij.codeInspection.LocalQuickFixOnPsiElementAsIntentionAdapter; +import com.intellij.java.analysis.JavaAnalysisBundle; import com.intellij.lang.findUsages.LanguageFindUsages; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.module.EffectiveLanguageLevelUtil; @@ -3255,7 +3256,7 @@ public class HighlightUtil extends HighlightUtilBase { @PropertyKey(resourceBundle = JavaErrorBundle.BUNDLE) private final String key; - Feature(LanguageLevel level, @PropertyKey(resourceBundle = JavaErrorBundle.BUNDLE) String key) { + Feature(LanguageLevel level, @PropertyKey(resourceBundle = JavaAnalysisBundle.BUNDLE) String key) { this.level = level; this.key = key; } @@ -3310,7 +3311,7 @@ public class HighlightUtil extends HighlightUtilBase { @NotNull Feature feature, @NotNull LanguageLevel level, @NotNull PsiFile file) { - String name = JavaErrorBundle.message(feature.key); + String name = JavaAnalysisBundle.message(feature.key); String version = JavaSdkVersion.fromLanguageLevel(level).getDescription(); String message = JavaErrorBundle.message("insufficient.language.level", name, version); diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DataFlowInspectionBase.java b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DataFlowInspectionBase.java index 926b11256868..ca1ededdf4f2 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DataFlowInspectionBase.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/DataFlowInspectionBase.java @@ -14,6 +14,7 @@ import com.intellij.codeInspection.dataFlow.types.DfType; import com.intellij.codeInspection.dataFlow.types.DfTypes; import com.intellij.codeInspection.dataFlow.value.DfaValue; import com.intellij.codeInspection.nullable.NullableStuffInspectionBase; +import com.intellij.java.analysis.JavaAnalysisBundle; import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.project.Project; @@ -139,7 +140,7 @@ public abstract class DataFlowInspectionBase extends AbstractBaseJavaLocalInspec if (TypeConversionUtil.isPrimitiveWrapper(methodReturnType) && NullableNotNullManager.isNullable((PsiMethod)resolve)) { final PsiType returnType = LambdaUtil.getFunctionalInterfaceReturnType(expression); if (TypeConversionUtil.isPrimitiveAndNotNull(returnType)) { - holder.registerProblem(expression, InspectionsBundle.message("dataflow.message.unboxing.method.reference")); + holder.registerProblem(expression, JavaAnalysisBundle.message("dataflow.message.unboxing.method.reference")); } } } @@ -150,7 +151,7 @@ public abstract class DataFlowInspectionBase extends AbstractBaseJavaLocalInspec PsiExpression condition = PsiUtil.skipParenthesizedExprDown(statement.getCondition()); if (BoolUtils.isBooleanLiteral(condition)) { LocalQuickFix fix = createSimplifyBooleanExpressionFix(condition, condition.textMatches(PsiKeyword.TRUE)); - holder.registerProblem(condition, InspectionsBundle + holder.registerProblem(condition, JavaAnalysisBundle .message("dataflow.message.constant.no.ref", condition.textMatches(PsiKeyword.TRUE) ? 1 : 0), fix); } } @@ -173,7 +174,7 @@ public abstract class DataFlowInspectionBase extends AbstractBaseJavaLocalInspec private void checkLoopCondition(PsiExpression condition) { condition = PsiUtil.skipParenthesizedExprDown(condition); if (condition != null && condition.textMatches(PsiKeyword.FALSE)) { - holder.registerProblem(condition, InspectionsBundle.message("dataflow.message.constant.no.ref", 0), createSimplifyBooleanExpressionFix(condition, false)); + holder.registerProblem(condition, JavaAnalysisBundle.message("dataflow.message.constant.no.ref", 0), createSimplifyBooleanExpressionFix(condition, false)); } } }; @@ -188,7 +189,7 @@ public abstract class DataFlowInspectionBase extends AbstractBaseJavaLocalInspec for (PsiParameter parameter : NullParameterConstraintChecker.checkMethodParameters(method)) { PsiIdentifier name = parameter.getNameIdentifier(); if (name != null) { - holder.registerProblem(name, InspectionsBundle.message("dataflow.method.fails.with.null.argument"), + holder.registerProblem(name, JavaAnalysisBundle.message("dataflow.method.fails.with.null.argument"), ProblemHighlightType.GENERIC_ERROR_OR_WARNING, createNavigateToNullParameterUsagesFix(parameter)); } } @@ -215,15 +216,15 @@ public abstract class DataFlowInspectionBase extends AbstractBaseJavaLocalInspec return visitor; } - private static void reportAnalysisQualityProblem(ProblemsHolder holder, PsiElement scope, @PropertyKey(resourceBundle = InspectionsBundle.BUNDLE) String problemKey) { + private static void reportAnalysisQualityProblem(ProblemsHolder holder, PsiElement scope, @PropertyKey(resourceBundle = JavaAnalysisBundle.BUNDLE) String problemKey) { PsiIdentifier name = null; String message = null; if(scope.getParent() instanceof PsiMethod) { name = ((PsiMethod)scope.getParent()).getNameIdentifier(); - message = InspectionsBundle.message(problemKey, "Method #ref"); + message = JavaAnalysisBundle.message(problemKey, "Method #ref"); } else if(scope instanceof PsiClass) { name = ((PsiClass)scope).getNameIdentifier(); - message = InspectionsBundle.message(problemKey, "Class initializer"); + message = JavaAnalysisBundle.message(problemKey, "Class initializer"); } if (name != null) { // Might be null for synthetic methods like JSP page. holder.registerProblem(name, message, ProblemHighlightType.WEAK_WARNING); @@ -294,9 +295,9 @@ public abstract class DataFlowInspectionBase extends AbstractBaseJavaLocalInspec } reportMutabilityViolations(holder, visitor.getMutabilityViolations(true), - InspectionsBundle.message("dataflow.message.immutable.modified")); + JavaAnalysisBundle.message("dataflow.message.immutable.modified")); reportMutabilityViolations(holder, visitor.getMutabilityViolations(false), - InspectionsBundle.message("dataflow.message.immutable.passed")); + JavaAnalysisBundle.message("dataflow.message.immutable.passed")); reportDuplicateAssignments(reporter, visitor); reportPointlessSameArguments(reporter, visitor); @@ -312,7 +313,7 @@ public abstract class DataFlowInspectionBase extends AbstractBaseJavaLocalInspec PsiExpression expression = instanceOf.getExpression(); if (expression != null && !JavaPsiPatternUtil.getExposedPatternVariables(expression).isEmpty()) continue; reporter.registerProblem(expression, - InspectionsBundle.message("dataflow.message.redundant.instanceof"), + JavaAnalysisBundle.message("dataflow.message.redundant.instanceof"), new RedundantInstanceofFix()); } } @@ -334,7 +335,7 @@ public abstract class DataFlowInspectionBase extends AbstractBaseJavaLocalInspec continue; } coveredSwitches.add(statement); - holder.registerProblem(label, InspectionsBundle.message("dataflow.message.only.switch.label"), + holder.registerProblem(label, JavaAnalysisBundle.message("dataflow.message.only.switch.label"), createUnwrapSwitchLabelFix()); } for (Map.Entry entry : labelReachability.entrySet()) { @@ -342,7 +343,7 @@ public abstract class DataFlowInspectionBase extends AbstractBaseJavaLocalInspec PsiExpression label = entry.getKey(); PsiSwitchLabelStatementBase labelStatement = Objects.requireNonNull(PsiImplUtil.getSwitchLabel(label)); if (!coveredSwitches.contains(labelStatement.getEnclosingSwitchBlock())) { - holder.registerProblem(label, InspectionsBundle.message("dataflow.message.unreachable.switch.label"), + holder.registerProblem(label, JavaAnalysisBundle.message("dataflow.message.unreachable.switch.label"), new DeleteSwitchLabelFix(label)); } } @@ -370,7 +371,7 @@ public abstract class DataFlowInspectionBase extends AbstractBaseJavaLocalInspec if (chunk.myRange != null) { if (result.value() instanceof Boolean) { // report rare cases like a == b == c where "a == b" part is constant - String message = InspectionsBundle.message("dataflow.message.constant.condition", + String message = JavaAnalysisBundle.message("dataflow.message.constant.condition", ((Boolean)result.value()).booleanValue() ? 1 : 0); reporter.registerProblem(expression, chunk.myRange, message); // do not add to reported anchors if only part of expression was reported @@ -454,7 +455,7 @@ public abstract class DataFlowInspectionBase extends AbstractBaseJavaLocalInspec visitor.pointlessSameArguments().forEach(expr -> { PsiElement name = expr.getReferenceNameElement(); if (name != null) { - reporter.registerProblem(name, InspectionsBundle.message("dataflow.message.pointless.same.arguments")); + reporter.registerProblem(name, JavaAnalysisBundle.message("dataflow.message.pointless.same.arguments")); } }); } @@ -483,8 +484,8 @@ public abstract class DataFlowInspectionBase extends AbstractBaseJavaLocalInspec } } String message = assignment != null && !assignment.getOperationTokenType().equals(JavaTokenType.EQ) - ? InspectionsBundle.message("dataflow.message.redundant.update") - : InspectionsBundle.message("dataflow.message.redundant.assignment"); + ? JavaAnalysisBundle.message("dataflow.message.redundant.update") + : JavaAnalysisBundle.message("dataflow.message.redundant.assignment"); reporter.registerProblem(expr, message, createRemoveAssignmentFix(assignment)); }); } @@ -517,7 +518,7 @@ public abstract class DataFlowInspectionBase extends AbstractBaseJavaLocalInspec .registerProblem(getElementToHighlight(newExpression), problem.getMessage(expressions), fixes.toArray(LocalQuickFix.EMPTY_ARRAY)); }); NullabilityProblemKind.callMethodRefNPE.ifMyProblem(problem, methodRef -> - reporter.registerProblem(methodRef, InspectionsBundle.message("dataflow.message.npe.methodref.invocation"), + reporter.registerProblem(methodRef, JavaAnalysisBundle.message("dataflow.message.npe.methodref.invocation"), createMethodReferenceNPEFixes(methodRef, reporter.isOnTheFly()).toArray(LocalQuickFix.EMPTY_ARRAY))); NullabilityProblemKind.callNPE.ifMyProblem(problem, call -> reportCallMayProduceNpe(reporter, problem.getMessage(expressions), call)); NullabilityProblemKind.passingToNotNullParameter.ifMyProblem(problem, expr -> { @@ -526,7 +527,7 @@ public abstract class DataFlowInspectionBase extends AbstractBaseJavaLocalInspec }); NullabilityProblemKind.passingToNotNullMethodRefParameter.ifMyProblem(problem, methodRef -> { LocalQuickFix[] fixes = createMethodReferenceNPEFixes(methodRef, reporter.isOnTheFly()).toArray(LocalQuickFix.EMPTY_ARRAY); - reporter.registerProblem(methodRef, InspectionsBundle.message("dataflow.message.passing.nullable.argument.methodref"), fixes); + reporter.registerProblem(methodRef, JavaAnalysisBundle.message("dataflow.message.passing.nullable.argument.methodref"), fixes); }); NullabilityProblemKind.arrayAccessNPE.ifMyProblem(problem, arrayAccess -> { LocalQuickFix[] fixes = @@ -574,14 +575,14 @@ public abstract class DataFlowInspectionBase extends AbstractBaseJavaLocalInspec visitor.outOfBoundsArrayAccesses().forEach(access -> { PsiExpression indexExpression = access.getIndexExpression(); if (indexExpression != null) { - holder.registerProblem(indexExpression, InspectionsBundle.message("dataflow.message.array.index.out.of.bounds")); + holder.registerProblem(indexExpression, JavaAnalysisBundle.message("dataflow.message.array.index.out.of.bounds")); } }); } private static void reportArrayStoreProblems(ProblemsHolder holder, DataFlowInstructionVisitor visitor) { visitor.getArrayStoreProblems().forEach( - (assignment, types) -> holder.registerProblem(assignment.getOperationSign(), InspectionsBundle + (assignment, types) -> holder.registerProblem(assignment.getOperationSign(), JavaAnalysisBundle .message("dataflow.message.arraystore", types.getFirst().getCanonicalText(), types.getSecond().getCanonicalText()))); } @@ -589,7 +590,7 @@ public abstract class DataFlowInspectionBase extends AbstractBaseJavaLocalInspec visitor.getMethodReferenceResults().forEach((methodRef, result) -> { if (result != ConstantResult.UNKNOWN) { Object value = result.value(); - holder.registerProblem(methodRef, InspectionsBundle.message("dataflow.message.constant.method.reference", value), + holder.registerProblem(methodRef, JavaAnalysisBundle.message("dataflow.message.constant.method.reference", value), createReplaceWithTrivialLambdaFix(value)); } }); @@ -636,9 +637,9 @@ public abstract class DataFlowInspectionBase extends AbstractBaseJavaLocalInspec private static @NotNull String getContractMessage(List contracts) { if (contracts.stream().allMatch(mc -> mc.getConditions().stream().allMatch(ContractValue::isBoundCheckingCondition))) { - return InspectionsBundle.message("dataflow.message.contract.fail.index"); + return JavaAnalysisBundle.message("dataflow.message.contract.fail.index"); } - return InspectionsBundle.message("dataflow.message.contract.fail"); + return JavaAnalysisBundle.message("dataflow.message.contract.fail"); } private static @NotNull PsiElement getElementToHighlight(@NotNull PsiCall call) { @@ -731,8 +732,8 @@ public abstract class DataFlowInspectionBase extends AbstractBaseJavaLocalInspec } String text = PsiExpressionTrimRenderer.render(operand); String message = alwaysFails ? - InspectionsBundle.message("dataflow.message.cce.always", text) : - InspectionsBundle.message("dataflow.message.cce", text); + JavaAnalysisBundle.message("dataflow.message.cce.always", text) : + JavaAnalysisBundle.message("dataflow.message.cce", text); reporter.registerProblem(castType, message, fixes.toArray(LocalQuickFix.EMPTY_ARRAY)); }); } @@ -750,7 +751,7 @@ public abstract class DataFlowInspectionBase extends AbstractBaseJavaLocalInspec PsiTreeUtil.isAncestor(((PsiAssignmentExpression)parent).getLExpression(), psiAnchor, false)) { reporter.registerProblem( psiAnchor, - InspectionsBundle.message("dataflow.message.pointless.assignment.expression", Boolean.toString(evaluatesToTrue)), + JavaAnalysisBundle.message("dataflow.message.pointless.assignment.expression", Boolean.toString(evaluatesToTrue)), createConditionalAssignmentFixes(evaluatesToTrue, (PsiAssignmentExpression)parent, reporter.isOnTheFly()) ); return; @@ -769,7 +770,7 @@ public abstract class DataFlowInspectionBase extends AbstractBaseJavaLocalInspec ContainerUtil.addIfNotNull(fixes, createExplainFix( (PsiExpression)psiAnchor, new TrackingRunner.ValueDfaProblemType(evaluatesToTrue))); } - String message = InspectionsBundle.message(isAtRHSOfBooleanAnd(psiAnchor) ? + String message = JavaAnalysisBundle.message(isAtRHSOfBooleanAnd(psiAnchor) ? "dataflow.message.constant.condition.when.reached" : "dataflow.message.constant.condition", evaluatesToTrue ? 1 : 0); reporter.registerProblem(psiAnchor, message, fixes.toArray(LocalQuickFix.EMPTY_ARRAY)); @@ -907,16 +908,16 @@ public abstract class DataFlowInspectionBase extends AbstractBaseJavaLocalInspec if (nullability == Nullability.NOT_NULL) { String presentable = NullableStuffInspectionBase.getPresentableAnnoName(anno); final String text = exactlyNull - ? InspectionsBundle.message("dataflow.message.return.null.from.notnull", presentable) - : InspectionsBundle.message("dataflow.message.return.nullable.from.notnull", presentable); + ? JavaAnalysisBundle.message("dataflow.message.return.null.from.notnull", presentable) + : JavaAnalysisBundle.message("dataflow.message.return.nullable.from.notnull", presentable); reporter.registerProblem(expr, text, createNPEFixes(expr, expr, reporter.isOnTheFly()).toArray(LocalQuickFix.EMPTY_ARRAY)); } else if (AnnotationUtil.isAnnotatingApplicable(anchor)) { final String defaultNullable = manager.getDefaultNullable(); final String presentableNullable = StringUtil.getShortName(defaultNullable); final String text = exactlyNull - ? InspectionsBundle.message("dataflow.message.return.null.from.notnullable", presentableNullable) - : InspectionsBundle.message("dataflow.message.return.nullable.from.notnullable", presentableNullable); + ? JavaAnalysisBundle.message("dataflow.message.return.null.from.notnullable", presentableNullable) + : JavaAnalysisBundle.message("dataflow.message.return.nullable.from.notnullable", presentableNullable); final LocalQuickFix[] fixes = PsiTreeUtil.getParentOfType(anchor, PsiMethod.class, PsiLambdaExpression.class) instanceof PsiLambdaExpression ? LocalQuickFix.EMPTY_ARRAY diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/NullabilityProblemKind.java b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/NullabilityProblemKind.java index 6f286b657ffb..b793c24b870d 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/NullabilityProblemKind.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/NullabilityProblemKind.java @@ -3,6 +3,7 @@ package com.intellij.codeInspection.dataFlow; import com.intellij.codeInsight.Nullability; import com.intellij.codeInspection.InspectionsBundle; +import com.intellij.java.analysis.JavaAnalysisBundle; import com.intellij.psi.*; import com.intellij.psi.tree.IElementType; import com.intellij.psi.util.PsiTypesUtil; @@ -22,7 +23,7 @@ import java.util.*; import java.util.function.Consumer; import java.util.function.Function; -import static com.intellij.codeInspection.InspectionsBundle.BUNDLE; +import static com.intellij.java.analysis.JavaAnalysisBundle.BUNDLE; import static com.intellij.psi.CommonClassNames.JAVA_LANG_NULL_POINTER_EXCEPTION; import static com.intellij.psi.CommonClassNames.JAVA_LANG_RUNTIME_EXCEPTION; import static com.intellij.util.ObjectUtils.tryCast; @@ -57,8 +58,8 @@ public class NullabilityProblemKind { @NotNull @PropertyKey(resourceBundle = BUNDLE) String normalMessage) { myException = exception; myName = name; - myAlwaysNullMessage = InspectionsBundle.message(alwaysNullMessage); - myNormalMessage = InspectionsBundle.message(normalMessage); + myAlwaysNullMessage = JavaAnalysisBundle.message(alwaysNullMessage); + myNormalMessage = JavaAnalysisBundle.message(normalMessage); } public static final NullabilityProblemKind callNPE = diff --git a/java/java-psi-impl/src/messages/JavaErrorBundle.properties b/java/java-psi-impl/src/messages/JavaErrorBundle.properties index 3f71be05b18a..a0c0401832b3 100644 --- a/java/java-psi-impl/src/messages/JavaErrorBundle.properties +++ b/java/java-psi-impl/src/messages/JavaErrorBundle.properties @@ -35,32 +35,6 @@ receiver.wrong.position=The receiver should be the first parameter receiver.type.mismatch=The receiver type does not match the enclosing class type receiver.name.mismatch=The receiver name does not match the enclosing class type -# These aren't unused. -# suppress inspection "UnusedProperty" -annotation.target.ANNOTATION_TYPE=annotation type -# suppress inspection "UnusedProperty" -annotation.target.TYPE=type -# suppress inspection "UnusedProperty" -annotation.target.TYPE_USE=type use -# suppress inspection "UnusedProperty" -annotation.target.TYPE_PARAMETER=type parameter -# suppress inspection "UnusedProperty" -annotation.target.CONSTRUCTOR=constructor -# suppress inspection "UnusedProperty" -annotation.target.METHOD=method -# suppress inspection "UnusedProperty" -annotation.target.FIELD=field -# suppress inspection "UnusedProperty" -annotation.target.PARAMETER=parameter -# suppress inspection "UnusedProperty" -annotation.target.LOCAL_VARIABLE=local variable -# suppress inspection "UnusedProperty" -annotation.target.PACKAGE=package -# suppress inspection "UnusedProperty" -annotation.target.MODULE=module -# suppress inspection "UnusedProperty" -annotation.target.RECORD_COMPONENT=record component - # generics related messages generics.holder.type=Type generics.holder.method=Method @@ -455,31 +429,4 @@ record.component.not.initialized=Record component ''{0}'' might not be initializ compact.constructor.in.regular.class=Parameter list expected record.compact.constructor.return='return' statement is not allowed in compact constructor -feature.generics=Generics -feature.annotations=Annotations -feature.static.imports=Static imports -feature.for.each=For-each loops -feature.varargs=Variable arity methods -feature.hex.fp.literals=Hexadecimal floating point literals -feature.diamond.types=Diamond types -feature.multi.catch=Multi-catches -feature.try.with.resources=Try-with-resources -feature.binary.literals=Binary literals -feature.underscores.in.literals=Underscores in literals -feature.extension.methods=Extension methods -feature.method.references=Method references -feature.lambda.expressions=Lambda expressions -feature.type.annotations=Type annotations -feature.type.receivers=Receiver parameters -feature.intersections.in.casts=Intersection types in casts -feature.static.interface.calls=Static interface method calls -feature.try.with.resources.refs=Resource references -feature.modules=Modules -feature.lvti=Local variable type inference -feature.text.blocks=Text block literals -feature.enhanced.switch=Enhanced 'switch' blocks -feature.switch.expressions='switch' expressions -feature.records=Records -feature.patterns.instanceof=Patterns in 'instanceof' -feature.text.block.escape.sequences='\\s' and '\\' escape sequences insufficient.language.level={0} are not supported at language level ''{1}'' diff --git a/platform/analysis-api/resources/messages/InspectionsBundle.properties b/platform/analysis-api/resources/messages/InspectionsBundle.properties index 78ea06b6adfd..7e55199e5c42 100644 --- a/platform/analysis-api/resources/messages/InspectionsBundle.properties +++ b/platform/analysis-api/resources/messages/InspectionsBundle.properties @@ -48,57 +48,6 @@ inspection.data.flow.use.computeifpresent.quickfix=Replace 'compute' with 'compu configure.annotations.option=Configure Annotations #messages from dataflow inspection -dataflow.message.npe.method.invocation=Method invocation #ref #loc may produce NullPointerException -dataflow.message.npe.method.invocation.sure=Method invocation #ref #loc will produce NullPointerException -dataflow.message.npe.inner.class.construction=Inner class construction may produce NullPointerException -dataflow.message.npe.inner.class.construction.sure=Inner class construction will produce NullPointerException -dataflow.message.npe.methodref.invocation=Method reference invocation #ref #loc may produce NullPointerException -dataflow.message.npe.array.access=Array access #ref #loc may produce NullPointerException -dataflow.message.npe.array.access.sure=Array access #ref #loc will produce NullPointerException -dataflow.message.npe.field.access.sure=Dereference of #ref #loc will produce NullPointerException -dataflow.message.npe.field.access=Dereference of #ref #loc may produce NullPointerException -dataflow.message.cce=Casting {0} to #ref #loc may produce ClassCastException -dataflow.message.cce.always=Casting {0} to #ref #loc will produce ClassCastException for any non-null value -dataflow.message.arraystore=Storing element of type {0} to array of {1} elements may produce ArrayStoreException -dataflow.message.redundant.instanceof=Condition #ref #loc is redundant and can be replaced with a null check -dataflow.message.contract.fail=The call to '#ref' always fails, according to its method contracts -dataflow.message.contract.fail.index=The call to '#ref' always fails as index is out of bounds -dataflow.message.constant.condition=Condition #ref #loc is always {0, choice, 0#false|1#true} -dataflow.message.constant.condition.when.reached=Condition #ref #loc is always {0, choice, 0#false|1#true} when reached -dataflow.message.constant.no.ref=Condition is always {0, choice, 0#false|1#true} -dataflow.message.unreachable.switch.label=Switch label #ref #loc is unreachable -dataflow.message.only.switch.label=Switch label #ref #loc is the only reachable in the whole switch -dataflow.message.pointless.assignment.expression=Condition #ref #loc at the left side of assignment expression is always {0}. Can be simplified -dataflow.message.passing.null.argument=Passing null argument to parameter annotated as @NotNull -dataflow.message.passing.nullable.argument=Argument #ref #loc might be null -dataflow.message.passing.nullable.argument.methodref=Method reference argument might be null -dataflow.message.passing.null.argument.nonannotated=Passing null argument to non-annotated parameter -dataflow.message.passing.nullable.argument.nonannotated=Argument #ref #loc might be null but passed to non-annotated parameter -dataflow.message.passing.nullable.argument.methodref.nonannotated=Method reference argument might be null but passed to non-annotated parameter -dataflow.message.assigning.null=null is assigned to a variable that is annotated with @NotNull -dataflow.message.assigning.nullable=Expression #ref might evaluate to null but is assigned to a variable that is annotated with @NotNull -dataflow.message.assigning.null.notannotated=Assigning null value to non-annotated field -dataflow.message.assigning.nullable.notannotated=Expression #ref #loc might be null but is assigned to non-annotated field -dataflow.message.storing.array.null=null is stored to an array of @NotNull elements -dataflow.message.storing.array.nullable=Expression #ref might evaluate to null but is stored to an array of @NotNull elements -dataflow.message.return.null.from.notnull=null is returned by the method declared as @{0} -dataflow.message.return.nullable.from.notnull=Expression #ref might evaluate to null but is returned by the method declared as @{0} -dataflow.message.return.null.from.notnullable=null is returned by the method which is not declared as @{0} -dataflow.message.return.nullable.from.notnullable=Expression #ref might evaluate to null but is returned by the method which is not declared as @{0} -dataflow.message.return.nullable.from.notnull.function=Function may return null, but it's not allowed here -dataflow.message.unboxing=Unboxing of #ref #loc may produce NullPointerException -dataflow.message.unboxing.method.reference=Use of #ref #loc would need unboxing which may produce NullPointerException -dataflow.too.complex={0} is too complex to analyze by data flow algorithm -dataflow.not.precise={0} is complex: data flow results could be imprecise -dataflow.method.fails.with.null.argument=Method will throw an exception when parameter is null -dataflow.message.constant.method.reference=Method reference result is always ''{0}'' -dataflow.message.array.index.out.of.bounds=Array index is out of bounds -dataflow.message.immutable.modified=Immutable object is modified -dataflow.message.immutable.passed=Immutable object is passed where mutable is expected -dataflow.message.redundant.update=Variable update does nothing -dataflow.message.redundant.assignment=Variable is already assigned to this value -dataflow.message.pointless.same.arguments=Arguments of '#ref' are the same. Calling this method with the same arguments is meaningless. - inspection.optional.get.without.is.present.message={0}.#ref() without ''isPresent()'' check #deprecated diff --git a/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/annotator/checkers/CustomAnnotationChecker.java b/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/annotator/checkers/CustomAnnotationChecker.java index 46fa740ae834..f29bc0f22673 100644 --- a/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/annotator/checkers/CustomAnnotationChecker.java +++ b/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/annotator/checkers/CustomAnnotationChecker.java @@ -2,6 +2,7 @@ package org.jetbrains.plugins.groovy.annotator.checkers; import com.intellij.codeInsight.daemon.JavaErrorBundle; +import com.intellij.java.analysis.JavaAnalysisBundle; import com.intellij.lang.annotation.AnnotationHolder; import com.intellij.openapi.extensions.ExtensionPointName; import com.intellij.openapi.util.Pair; @@ -43,7 +44,7 @@ public abstract class CustomAnnotationChecker { PsiElement ownerToUse = owner instanceof PsiModifierList ? ((PsiElement)owner).getParent() : (PsiElement)owner; PsiAnnotation.TargetType[] elementTypeFields = GrAnnotationImpl.getApplicableElementTypeFields(ownerToUse); if (elementTypeFields.length != 0 && !GrAnnotationImpl.isAnnotationApplicableTo(annotation, elementTypeFields)) { - String annotationTargetText = JavaErrorBundle.message("annotation.target." + elementTypeFields[0]); + String annotationTargetText = JavaAnalysisBundle.message("annotation.target." + elementTypeFields[0]); GrCodeReferenceElement ref = annotation.getClassReference(); return JavaErrorBundle.message("annotation.not.applicable", ref.getText(), annotationTargetText); } diff --git a/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/annotator/checkers/FieldAnnotationChecker.java b/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/annotator/checkers/FieldAnnotationChecker.java index c7e35338126d..96d82e665e2a 100644 --- a/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/annotator/checkers/FieldAnnotationChecker.java +++ b/plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/annotator/checkers/FieldAnnotationChecker.java @@ -16,6 +16,7 @@ package org.jetbrains.plugins.groovy.annotator.checkers; import com.intellij.codeInsight.daemon.JavaErrorBundle; +import com.intellij.java.analysis.JavaAnalysisBundle; import com.intellij.lang.annotation.AnnotationHolder; import com.intellij.lang.annotation.HighlightSeverity; import com.intellij.psi.PsiAnnotation; @@ -60,7 +61,7 @@ public class FieldAnnotationChecker extends CustomAnnotationChecker { if (!GrAnnotationImpl.isAnnotationApplicableTo(annotation, PsiAnnotation.TargetType.LOCAL_VARIABLE)) { GrCodeReferenceElement ref = annotation.getClassReference(); - String target = JavaErrorBundle.message("annotation.target.LOCAL_VARIABLE"); + String target = JavaAnalysisBundle.message("annotation.target.LOCAL_VARIABLE"); String description = JavaErrorBundle.message("annotation.not.applicable", ref.getText(), target); holder.newAnnotation(HighlightSeverity.ERROR, description).range(ref).create(); }