From 197f0bd54637ae3fa2425b20e960f29a7704e0c3 Mon Sep 17 00:00:00 2001 From: "Dmitry.Krasilschikov" Date: Tue, 4 Feb 2020 16:30:53 +0200 Subject: [PATCH] localize "Inspections" hardcoded literals GitOrigin-RevId: 274c389075024728618e18c2a79804f31895c7c2 --- .../codeInspection/AnnotateMethodFix.java | 2 +- .../AnonymousCanBeLambdaInspection.java | 6 +- ...onymousHasLambdaAlternativeInspection.java | 7 +- .../BlockMarkerCommentsInspection.java | 4 +- .../DeprecatedIsStillUsedInspection.java | 2 +- .../ExplicitTypeCanBeDiamondInspection.java | 4 +- ...idComparatorMethodReferenceInspection.java | 5 +- .../NumericOverflowInspection.java | 2 +- ...ossibleHeapPollutionVarargsInspection.java | 8 +-- .../RedundantLambdaCodeBlockInspection.java | 4 +- .../StringTokenizerDelimiterInspection.java | 4 +- .../VariableTypeCanBeExplicitInspection.java | 4 +- .../JavacQuirksInspectionVisitor.java | 10 +-- .../FieldAccessNotGuardedInspection.java | 3 +- .../InstanceGuardedByStaticInspection.java | 5 +- .../NonFinalFieldInImmutableInspection.java | 4 +- .../NonFinalGuardInspection.java | 6 +- .../StaticGuardedByInstanceInspection.java | 5 +- .../UnknownGuardInspection.java | 5 +- .../dataFlow/fix/DeleteSwitchLabelFix.java | 7 +- .../fix/ReplaceWithConstantValueFix.java | 3 +- .../deprecation/DeprecationInspection.java | 9 +-- .../DeprecationInspectionBase.java | 7 +- .../InconsistentLanguageLevelInspection.java | 5 +- .../java19modules/Java9ModuleEntryPoint.java | 3 +- .../nullable/ChangeNullableDefaultsFix.java | 3 +- .../nullable/NullableStuffInspectionBase.java | 19 +++--- .../RedundantCastInspection.java | 2 +- .../testOnly/TestOnlyInspection.java | 2 +- ...UnnecessaryModuleDependencyInspection.java | 2 +- .../RedundantThrowsDeclarationInspection.java | 2 +- .../UnusedLibrariesInspection.java | 2 +- .../AccessCanBeTightenedInspection.java | 4 +- .../xml/DeprecatedClassUsageInspection.java | 7 +- .../messages/InspectionsBundle.properties | 66 ++++++++++++++++++- 35 files changed, 156 insertions(+), 77 deletions(-) diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/AnnotateMethodFix.java b/java/java-analysis-impl/src/com/intellij/codeInspection/AnnotateMethodFix.java index ed6a8de7aa97..1b0d07f268d4 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/AnnotateMethodFix.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/AnnotateMethodFix.java @@ -118,6 +118,6 @@ public class AnnotateMethodFix implements LocalQuickFix { } }); } - }, "Searching for Overriding Methods", true, method.getProject()); + }, InspectionsBundle.message("searching.for.overriding.methods"), true, method.getProject()); } } diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/AnonymousCanBeLambdaInspection.java b/java/java-analysis-impl/src/com/intellij/codeInspection/AnonymousCanBeLambdaInspection.java index 56115f7f0d5e..020337d06293 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/AnonymousCanBeLambdaInspection.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/AnonymousCanBeLambdaInspection.java @@ -60,7 +60,7 @@ public class AnonymousCanBeLambdaInspection extends AbstractBaseJavaLocalInspect @Nullable @Override public JComponent createOptionsPanel() { - return new SingleCheckboxOptionsPanel("Report when interface is not annotated with @FunctionalInterface", this, "reportNotAnnotatedInterfaces"); + return new SingleCheckboxOptionsPanel(InspectionsBundle.message("report.when.interface.is.not.annotated.with.functional.interface"), this, "reportNotAnnotatedInterfaces"); } @NotNull @@ -83,7 +83,7 @@ public class AnonymousCanBeLambdaInspection extends AbstractBaseJavaLocalInspect type = ProblemHighlightType.INFORMATION; } } - holder.registerProblem(parent, "Anonymous #ref #loc can be replaced with lambda", + holder.registerProblem(parent, InspectionsBundle.message("anonymous.ref.loc.can.be.replaced.with.lambda"), type, rangeInElement, new ReplaceWithLambdaFix()); } } @@ -381,7 +381,7 @@ public class AnonymousCanBeLambdaInspection extends AbstractBaseJavaLocalInspect @NotNull @Override public String getFamilyName() { - return "Replace with lambda"; + return InspectionsBundle.message("replace.with.lambda"); } @Override diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/AnonymousHasLambdaAlternativeInspection.java b/java/java-analysis-impl/src/com/intellij/codeInspection/AnonymousHasLambdaAlternativeInspection.java index 28b4681adc73..b915c649edeb 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/AnonymousHasLambdaAlternativeInspection.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/AnonymousHasLambdaAlternativeInspection.java @@ -58,7 +58,8 @@ public class AnonymousHasLambdaAlternativeInspection extends AbstractBaseJavaLoc final PsiElement lBrace = aClass.getLBrace(); LOG.assertTrue(lBrace != null); final TextRange rangeInElement = new TextRange(0, lBrace.getStartOffsetInParent() + aClass.getStartOffsetInParent() - 1); - holder.registerProblem(aClass.getParent(), "Anonymous #ref #loc can be replaced with "+alternative.myReplacementMessage, + holder.registerProblem(aClass.getParent(), + InspectionsBundle.message("anonymous.ref.loc.can.be.replaced.with.0", alternative.myReplacementMessage), ProblemHighlightType.LIKE_UNUSED_SYMBOL, rangeInElement, new ReplaceWithLambdaAlternativeFix(alternative)); } } @@ -88,14 +89,14 @@ public class AnonymousHasLambdaAlternativeInspection extends AbstractBaseJavaLoc @NotNull @Override public String getName() { - return "Replace with "+myAlternative.myReplacementMessage; + return InspectionsBundle.message("replace.with.0", myAlternative.myReplacementMessage); } @Nls @NotNull @Override public String getFamilyName() { - return "Replace anonymous class with lambda alternative"; + return InspectionsBundle.message("replace.anonymous.class.with.lambda.alternative"); } @Override diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/BlockMarkerCommentsInspection.java b/java/java-analysis-impl/src/com/intellij/codeInspection/BlockMarkerCommentsInspection.java index b56d3687ee10..14499226f95b 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/BlockMarkerCommentsInspection.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/BlockMarkerCommentsInspection.java @@ -77,11 +77,11 @@ public class BlockMarkerCommentsInspection extends AbstractBaseJavaLocalInspecti return; } if (MARKER_PATTERN.accepts(element)) { - holder.registerProblem(element, "Redundant block marker", new LocalQuickFix() { + holder.registerProblem(element, InspectionsBundle.message("redundant.block.marker"), new LocalQuickFix() { @NotNull @Override public String getFamilyName() { - return "Remove block marker comments"; + return InspectionsBundle.message("remove.block.marker.comments"); } @Override diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/DeprecatedIsStillUsedInspection.java b/java/java-analysis-impl/src/com/intellij/codeInspection/DeprecatedIsStillUsedInspection.java index 297ae3b03a5f..70ce041aa9c5 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/DeprecatedIsStillUsedInspection.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/DeprecatedIsStillUsedInspection.java @@ -38,7 +38,7 @@ public class DeprecatedIsStillUsedInspection extends LocalInspectionTool { PsiSearchHelper searchHelper = PsiSearchHelper.getInstance(member.getProject()); String name = member.getName(); if (name != null && hasUsages(member, name, searchHelper, member.getResolveScope())) { - holder.registerProblem(identifier, "Deprecated member '" + name + "' is still used"); + holder.registerProblem(identifier, InspectionsBundle.message("deprecated.member.0.is.still.used", name)); } } diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/ExplicitTypeCanBeDiamondInspection.java b/java/java-analysis-impl/src/com/intellij/codeInspection/ExplicitTypeCanBeDiamondInspection.java index f3ce25f235a2..53c7521cb9c6 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/ExplicitTypeCanBeDiamondInspection.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/ExplicitTypeCanBeDiamondInspection.java @@ -54,7 +54,7 @@ public class ExplicitTypeCanBeDiamondInspection extends AbstractBaseJavaLocalIns final PsiElement lastChild = parameterList.getLastChild(); final TextRange range = new TextRange(firstChild != null && firstChild.getNode().getElementType() == JavaTokenType.LT ? 1 : 0, parameterList.getTextLength() - (lastChild != null && lastChild.getNode().getElementType() == JavaTokenType.GT ? 1 : 0)); - holder.registerProblem(parameterList, "Explicit type argument #ref #loc can be replaced with <>", ProblemHighlightType.LIKE_UNUSED_SYMBOL, range, new ReplaceWithDiamondFix()); + holder.registerProblem(parameterList, InspectionsBundle.message("explicit.type.argument.ref.loc.can.be.replaced.with"), ProblemHighlightType.LIKE_UNUSED_SYMBOL, range, new ReplaceWithDiamondFix()); } } }; @@ -64,7 +64,7 @@ public class ExplicitTypeCanBeDiamondInspection extends AbstractBaseJavaLocalIns @NotNull @Override public String getFamilyName() { - return "Replace with <>"; + return InspectionsBundle.message("replace.with"); } @Override diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/InvalidComparatorMethodReferenceInspection.java b/java/java-analysis-impl/src/com/intellij/codeInspection/InvalidComparatorMethodReferenceInspection.java index a4d433b34d87..5ff7e4d819e8 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/InvalidComparatorMethodReferenceInspection.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/InvalidComparatorMethodReferenceInspection.java @@ -29,7 +29,8 @@ public class InvalidComparatorMethodReferenceInspection extends AbstractBaseJava holder .registerProblem(expression, - "Method reference mapped to Comparator interface does not fulfill the Comparator contract", + InspectionsBundle + .message("method.reference.mapped.to.comparator"), new ReplaceWithComparatorQuickFix(name.equals("min"))); } }; @@ -69,7 +70,7 @@ public class InvalidComparatorMethodReferenceInspection extends AbstractBaseJava @NotNull @Override public String getFamilyName() { - return "Replace with comparator"; + return InspectionsBundle.message("replace.with.comparator"); } @Override diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/NumericOverflowInspection.java b/java/java-analysis-impl/src/com/intellij/codeInspection/NumericOverflowInspection.java index be7fc9e85a7c..3e315f4388eb 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/NumericOverflowInspection.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/NumericOverflowInspection.java @@ -28,7 +28,7 @@ public class NumericOverflowInspection extends AbstractBaseJavaLocalInspectionTo @Nullable @Override public JComponent createOptionsPanel() { - return new SingleCheckboxOptionsPanel("Ignore '<<' operation which results in negative value", this, + return new SingleCheckboxOptionsPanel(InspectionsBundle.message("ignore.operation.which.results.in.negative.value"), this, "ignoreLeftShiftWithNegativeResult"); } diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/PossibleHeapPollutionVarargsInspection.java b/java/java-analysis-impl/src/com/intellij/codeInspection/PossibleHeapPollutionVarargsInspection.java index abe00dbfaab0..348afcf358b9 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/PossibleHeapPollutionVarargsInspection.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/PossibleHeapPollutionVarargsInspection.java @@ -59,7 +59,7 @@ public class PossibleHeapPollutionVarargsInspection extends AbstractBaseJavaLoca @NotNull @Override public String getFamilyName() { - return "Annotate as @SafeVarargs"; + return InspectionsBundle.message("annotate.as.safevarargs"); } @Override @@ -91,7 +91,7 @@ public class PossibleHeapPollutionVarargsInspection extends AbstractBaseJavaLoca @NotNull @Override public String getFamilyName() { - return "Make final and annotate as @SafeVarargs"; + return InspectionsBundle.message("make.final.and.annotate.as.safevarargs"); } @Nullable @@ -158,7 +158,7 @@ public class PossibleHeapPollutionVarargsInspection extends AbstractBaseJavaLoca final PsiElement nameIdentifier = ((PsiNameIdentifierOwner)aClass).getNameIdentifier(); if (nameIdentifier != null) { final LocalQuickFix quickFix = new AnnotateAsSafeVarargsQuickFix(); - myHolder.registerProblem(nameIdentifier, "Possible heap pollution from parameterized vararg type #loc", quickFix); + myHolder.registerProblem(nameIdentifier, InspectionsBundle.message("possible.heap.pollution.from.parameterized.vararg.type.loc"), quickFix); } } @@ -198,7 +198,7 @@ public class PossibleHeapPollutionVarargsInspection extends AbstractBaseJavaLoca OverridingMethodsSearch.search(method).findFirst() == null; quickFix = canBeFinal ? new MakeFinalAndAnnotateQuickFix() : null; } - myHolder.registerProblem(nameIdentifier, "Possible heap pollution from parameterized vararg type #loc", quickFix); + myHolder.registerProblem(nameIdentifier, InspectionsBundle.message("possible.heap.pollution.from.parameterized.vararg.type.loc"), quickFix); } } } diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/RedundantLambdaCodeBlockInspection.java b/java/java-analysis-impl/src/com/intellij/codeInspection/RedundantLambdaCodeBlockInspection.java index 7dfc682f4816..29a24bcef10e 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/RedundantLambdaCodeBlockInspection.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/RedundantLambdaCodeBlockInspection.java @@ -54,7 +54,7 @@ public class RedundantLambdaCodeBlockInspection extends AbstractBaseJavaLocalIns } else { errorElement = body.getFirstChild(); } - holder.registerProblem(errorElement, "Statement lambda can be replaced with expression lambda", + holder.registerProblem(errorElement, InspectionsBundle.message("statement.lambda.can.be.replaced.with.expression.lambda"), ProblemHighlightType.LIKE_UNUSED_SYMBOL, new ReplaceWithExprFix()); } } @@ -100,7 +100,7 @@ public class RedundantLambdaCodeBlockInspection extends AbstractBaseJavaLocalIns @NotNull @Override public String getFamilyName() { - return "Replace with expression lambda"; + return InspectionsBundle.message("replace.with.expression.lambda"); } @Override diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/StringTokenizerDelimiterInspection.java b/java/java-analysis-impl/src/com/intellij/codeInspection/StringTokenizerDelimiterInspection.java index 67c2e068551b..96c681a47f28 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/StringTokenizerDelimiterInspection.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/StringTokenizerDelimiterInspection.java @@ -55,7 +55,7 @@ public class StringTokenizerDelimiterInspection extends AbstractBaseJavaLocalIns final Set chars = new THashSet<>(); for (char c : delimiters.toCharArray()) { if (!chars.add(c)) { - holder.registerProblem(delimiterArgument, "Delimiters argument contains duplicated characters", + holder.registerProblem(delimiterArgument, InspectionsBundle.message("delimiters.argument.contains.duplicated.characters"), new ReplaceDelimitersWithUnique(delimiterArgument)); return; } @@ -78,7 +78,7 @@ public class StringTokenizerDelimiterInspection extends AbstractBaseJavaLocalIns @NotNull @Override public String getFamilyName() { - return "Replace StringTokenizer delimiters parameter with unique symbols"; + return InspectionsBundle.message("replace.stringtokenizer.delimiters.parameter.with.unique.symbols"); } @Override diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/VariableTypeCanBeExplicitInspection.java b/java/java-analysis-impl/src/com/intellij/codeInspection/VariableTypeCanBeExplicitInspection.java index a0a25a56524f..39efdb055ebb 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/VariableTypeCanBeExplicitInspection.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/VariableTypeCanBeExplicitInspection.java @@ -47,7 +47,7 @@ public class VariableTypeCanBeExplicitInspection extends AbstractBaseJavaLocalIn private void registerTypeElementProblem(PsiTypeElement typeElement) { holder.registerProblem(typeElement, - "'var' can be replaced with explicit type", + InspectionsBundle.message("var.can.be.replaced.with.explicit.type"), ProblemHighlightType.GENERIC_ERROR_OR_WARNING, new ReplaceVarWithExplicitTypeFix()); } @@ -70,7 +70,7 @@ public class VariableTypeCanBeExplicitInspection extends AbstractBaseJavaLocalIn @NotNull @Override public String getFamilyName() { - return "Replace 'var' with explicit type"; + return InspectionsBundle.message("replace.var.with.explicit.type"); } @Override diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/compiler/JavacQuirksInspectionVisitor.java b/java/java-analysis-impl/src/com/intellij/codeInspection/compiler/JavacQuirksInspectionVisitor.java index 9e8754f7a5c9..9c2bc9252d18 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/compiler/JavacQuirksInspectionVisitor.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/compiler/JavacQuirksInspectionVisitor.java @@ -147,7 +147,8 @@ public class JavacQuirksInspectionVisitor extends JavaElementVisitor { for (int i = method.getParameterList().getParametersCount(); i < args.length; i++) { if (PsiPolyExpressionUtil.isPolyExpression(args[i]) && ++ count > 50) { myHolder.registerProblem(expression.getMethodExpression(), - "Vararg method call with 50+ poly arguments may cause compilation and analysis slowdown", + InspectionsBundle + .message("vararg.method.call.with.50.poly.arguments"), new MyAddExplicitTypeArgumentsFix()); break; } @@ -170,7 +171,8 @@ public class JavacQuirksInspectionVisitor extends JavaElementVisitor { (TypeConversionUtil.isPrimitiveAndNotNull(ltype) ^ TypeConversionUtil.isPrimitiveAndNotNull(rtype)) && TypeConversionUtil.isBinaryOperatorApplicable(expression.getOperationTokenType(), ltype, rtype, false) && TypeConversionUtil.areTypesConvertible(rtype, ltype)) { - myHolder.registerProblem(expression.getOperationSign(), "Comparision between Object and primitive is illegal and is accepted in java 7 only", ProblemHighlightType.GENERIC_ERROR_OR_WARNING); + myHolder.registerProblem(expression.getOperationSign(), InspectionsBundle + .message("comparision.between.object.and.primitive"), ProblemHighlightType.GENERIC_ERROR_OR_WARNING); } } } @@ -187,14 +189,14 @@ public class JavacQuirksInspectionVisitor extends JavaElementVisitor { @NotNull @Override public String getName() { - return "Replace ''" + myOperationSign + "'' with ''=''"; + return InspectionsBundle.message("replace.0.with", myOperationSign); } @Nls @NotNull @Override public String getFamilyName() { - return "Replace Operator Assignment with Assignment"; + return InspectionsBundle.message("replace.operator.assignment.with.assignment"); } @Override diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/concurrencyAnnotations/FieldAccessNotGuardedInspection.java b/java/java-analysis-impl/src/com/intellij/codeInspection/concurrencyAnnotations/FieldAccessNotGuardedInspection.java index 2152b06cffea..69231282fdab 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/concurrencyAnnotations/FieldAccessNotGuardedInspection.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/concurrencyAnnotations/FieldAccessNotGuardedInspection.java @@ -4,6 +4,7 @@ package com.intellij.codeInspection.concurrencyAnnotations; import com.intellij.codeInsight.PsiEquivalenceUtil; import com.intellij.codeInsight.daemon.GroupNames; import com.intellij.codeInspection.AbstractBaseJavaLocalInspectionTool; +import com.intellij.codeInspection.InspectionsBundle; import com.intellij.codeInspection.ProblemsHolder; import com.intellij.psi.*; import com.intellij.psi.util.InheritanceUtil; @@ -182,7 +183,7 @@ public class FieldAccessNotGuardedInspection extends AbstractBaseJavaLocalInspec } check = syncStatement; } - myHolder.registerProblem(expression, "Access to field #ref outside of declared guards #loc"); + myHolder.registerProblem(expression, InspectionsBundle.message("access.to.field.code.ref.code.outside.of.declared.guards.loc")); } private static PsiClass getClassFromThisExpression(PsiThisExpression thisExpression, PsiElement context) { diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/concurrencyAnnotations/InstanceGuardedByStaticInspection.java b/java/java-analysis-impl/src/com/intellij/codeInspection/concurrencyAnnotations/InstanceGuardedByStaticInspection.java index 252ef9528069..5c4848d1044f 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/concurrencyAnnotations/InstanceGuardedByStaticInspection.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/concurrencyAnnotations/InstanceGuardedByStaticInspection.java @@ -3,6 +3,7 @@ package com.intellij.codeInspection.concurrencyAnnotations; import com.intellij.codeInsight.daemon.GroupNames; import com.intellij.codeInspection.AbstractBaseJavaLocalInspectionTool; +import com.intellij.codeInspection.InspectionsBundle; import com.intellij.codeInspection.ProblemsHolder; import com.intellij.psi.*; import com.intellij.psi.javadoc.PsiDocTag; @@ -64,7 +65,7 @@ public class InstanceGuardedByStaticInspection extends AbstractBaseJavaLocalInsp if (!guardField.hasModifierProperty(PsiModifier.STATIC)) { return; } - myHolder.registerProblem(psiDocTag, "Instance member guarded by static \"" + guardValue + "\" #loc"); + myHolder.registerProblem(psiDocTag, InspectionsBundle.message("instance.member.guarded.by.static.0.loc", guardValue)); } @Override @@ -100,7 +101,7 @@ public class InstanceGuardedByStaticInspection extends AbstractBaseJavaLocalInsp if (!guardField.hasModifierProperty(PsiModifier.STATIC)) { return; } - myHolder.registerProblem(guardRef, "Instance member guarded by static #ref #loc"); + myHolder.registerProblem(guardRef, InspectionsBundle.message("instance.member.guarded.by.static.ref.loc")); } } } diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/concurrencyAnnotations/NonFinalFieldInImmutableInspection.java b/java/java-analysis-impl/src/com/intellij/codeInspection/concurrencyAnnotations/NonFinalFieldInImmutableInspection.java index 260ed393bb96..b1c6e681c71a 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/concurrencyAnnotations/NonFinalFieldInImmutableInspection.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/concurrencyAnnotations/NonFinalFieldInImmutableInspection.java @@ -3,6 +3,7 @@ package com.intellij.codeInspection.concurrencyAnnotations; import com.intellij.codeInsight.daemon.GroupNames; import com.intellij.codeInspection.AbstractBaseJavaLocalInspectionTool; +import com.intellij.codeInspection.InspectionsBundle; import com.intellij.codeInspection.ProblemsHolder; import com.intellij.psi.*; import org.jetbrains.annotations.Nls; @@ -38,7 +39,8 @@ public class NonFinalFieldInImmutableInspection extends AbstractBaseJavaLocalIns if (!JCiPUtil.isImmutable(containingClass)) { return; } - holder.registerProblem(field.getNameIdentifier(), "Non-final field #ref in @Immutable class #loc"); + holder.registerProblem(field.getNameIdentifier(), + InspectionsBundle.message("non.final.field.code.ref.code.in.immutable.class.loc")); } } }; diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/concurrencyAnnotations/NonFinalGuardInspection.java b/java/java-analysis-impl/src/com/intellij/codeInspection/concurrencyAnnotations/NonFinalGuardInspection.java index 230264f87eec..2b4637562c75 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/concurrencyAnnotations/NonFinalGuardInspection.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/concurrencyAnnotations/NonFinalGuardInspection.java @@ -3,11 +3,11 @@ package com.intellij.codeInspection.concurrencyAnnotations; import com.intellij.codeInsight.daemon.GroupNames; import com.intellij.codeInspection.AbstractBaseJavaLocalInspectionTool; +import com.intellij.codeInspection.InspectionsBundle; import com.intellij.codeInspection.ProblemsHolder; import com.intellij.psi.*; import com.intellij.psi.javadoc.PsiDocTag; import com.intellij.psi.util.PsiTreeUtil; -import org.jetbrains.annotations.Nls; import org.jetbrains.annotations.NotNull; public class NonFinalGuardInspection extends AbstractBaseJavaLocalInspectionTool { @@ -64,7 +64,7 @@ public class NonFinalGuardInspection extends AbstractBaseJavaLocalInspectionTool if (member == null) { return; } - myHolder.registerProblem(member, "Non-final @GuardedBy field #ref #loc"); + myHolder.registerProblem(member, InspectionsBundle.message("non.final.guarded.by.field.ref.loc")); } @Override @@ -88,7 +88,7 @@ public class NonFinalGuardInspection extends AbstractBaseJavaLocalInspectionTool if (guardField.hasModifierProperty(PsiModifier.FINAL)) { return; } - myHolder.registerProblem(psiDocTag, "Non-final @GuardedBy field \"" + guardValue + "\" #loc"); + myHolder.registerProblem(psiDocTag, InspectionsBundle.message("non.final.guarded.by.field.0.loc", guardValue)); } } } \ No newline at end of file diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/concurrencyAnnotations/StaticGuardedByInstanceInspection.java b/java/java-analysis-impl/src/com/intellij/codeInspection/concurrencyAnnotations/StaticGuardedByInstanceInspection.java index 638bb2318d05..a1992b12671f 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/concurrencyAnnotations/StaticGuardedByInstanceInspection.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/concurrencyAnnotations/StaticGuardedByInstanceInspection.java @@ -3,6 +3,7 @@ package com.intellij.codeInspection.concurrencyAnnotations; import com.intellij.codeInsight.daemon.GroupNames; import com.intellij.codeInspection.AbstractBaseJavaLocalInspectionTool; +import com.intellij.codeInspection.InspectionsBundle; import com.intellij.codeInspection.ProblemsHolder; import com.intellij.psi.*; import com.intellij.psi.javadoc.PsiDocTag; @@ -105,11 +106,11 @@ public class StaticGuardedByInstanceInspection extends AbstractBaseJavaLocalInsp if (guardField.hasModifierProperty(PsiModifier.STATIC)) { return; } - myHolder.registerProblem(psiDocTag, "Static member guarded by instance \"" + guardValue + "\" #loc"); + myHolder.registerProblem(psiDocTag, InspectionsBundle.message("static.member.guarded.by.instance.0.loc", guardValue)); } private void registerError(PsiElement element) { - myHolder.registerProblem(element, "Static member guarded by instance #ref #loc"); + myHolder.registerProblem(element, InspectionsBundle.message("static.member.guarded.by.instance.ref.loc")); } } } \ No newline at end of file diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/concurrencyAnnotations/UnknownGuardInspection.java b/java/java-analysis-impl/src/com/intellij/codeInspection/concurrencyAnnotations/UnknownGuardInspection.java index 6a3101d24738..b5e79594d9ad 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/concurrencyAnnotations/UnknownGuardInspection.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/concurrencyAnnotations/UnknownGuardInspection.java @@ -3,6 +3,7 @@ package com.intellij.codeInspection.concurrencyAnnotations; import com.intellij.codeInsight.daemon.GroupNames; import com.intellij.codeInspection.AbstractBaseJavaLocalInspectionTool; +import com.intellij.codeInspection.InspectionsBundle; import com.intellij.codeInspection.ProblemsHolder; import com.intellij.psi.*; import com.intellij.psi.impl.source.DummyHolder; @@ -57,7 +58,7 @@ public class UnknownGuardInspection extends AbstractBaseJavaLocalInspectionTool if (member == null) { return; } - myHolder.registerProblem(member, "Unknown @GuardedBy reference #ref #loc"); + myHolder.registerProblem(member, InspectionsBundle.message("unknown.guardedby.reference.ref.loc")); } private static boolean isValidGuardText(@Nullable String guardText, @NotNull PsiElement context) { @@ -161,7 +162,7 @@ public class UnknownGuardInspection extends AbstractBaseJavaLocalInspectionTool if (isValidGuardText(guardValue, psiDocTag)) { return; } - myHolder.registerProblem(psiDocTag, "Unknown @GuardedBy reference \"" + guardValue + "\" #loc"); + myHolder.registerProblem(psiDocTag, InspectionsBundle.message("unknown.guardedby.reference.0.loc", guardValue)); } } } diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/fix/DeleteSwitchLabelFix.java b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/fix/DeleteSwitchLabelFix.java index 8e43017c6700..55837f1e853d 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/fix/DeleteSwitchLabelFix.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/fix/DeleteSwitchLabelFix.java @@ -1,6 +1,7 @@ // Copyright 2000-2018 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.codeInspection.dataFlow.fix; +import com.intellij.codeInspection.InspectionsBundle; import com.intellij.codeInspection.LocalQuickFix; import com.intellij.codeInspection.ProblemDescriptor; import com.intellij.openapi.project.Project; @@ -48,15 +49,15 @@ public class DeleteSwitchLabelFix implements LocalQuickFix { @Override public String getName() { return myBranch ? - "Remove switch branch '" + myName + "'" : - "Remove switch label '" + myName + "'"; + InspectionsBundle.message("remove.switch.branch.0", myName) : + InspectionsBundle.message("remove.switch.label.0", myName); } @Nls(capitalization = Nls.Capitalization.Sentence) @NotNull @Override public String getFamilyName() { - return "Remove switch label"; + return InspectionsBundle.message("remove.switch.label"); } @Override diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/fix/ReplaceWithConstantValueFix.java b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/fix/ReplaceWithConstantValueFix.java index 5606286d0a20..01936a956594 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/fix/ReplaceWithConstantValueFix.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/dataFlow/fix/ReplaceWithConstantValueFix.java @@ -16,6 +16,7 @@ package com.intellij.codeInspection.dataFlow.fix; import com.intellij.codeInspection.CommonQuickFixBundle; +import com.intellij.codeInspection.InspectionsBundle; import com.intellij.codeInspection.LocalQuickFix; import com.intellij.codeInspection.ProblemDescriptor; import com.intellij.openapi.project.Project; @@ -44,7 +45,7 @@ public class ReplaceWithConstantValueFix implements LocalQuickFix { @NotNull @Override public String getFamilyName() { - return "Replace with constant value"; + return InspectionsBundle.message("replace.with.constant.value"); } @Override diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/deprecation/DeprecationInspection.java b/java/java-analysis-impl/src/com/intellij/codeInspection/deprecation/DeprecationInspection.java index 37f1088f0073..ca7e870f0026 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/deprecation/DeprecationInspection.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/deprecation/DeprecationInspection.java @@ -2,6 +2,7 @@ package com.intellij.codeInspection.deprecation; import com.intellij.codeInspection.DeprecationUtil; +import com.intellij.codeInspection.InspectionsBundle; import com.intellij.codeInspection.ProblemsHolder; import com.intellij.codeInspection.apiUsage.ApiUsageUastVisitor; import com.intellij.codeInspection.ui.MultipleCheckboxOptionsPanel; @@ -56,10 +57,10 @@ public class DeprecationInspection extends DeprecationInspectionBase { @Override public JComponent createOptionsPanel() { final MultipleCheckboxOptionsPanel panel = new MultipleCheckboxOptionsPanel(this); - panel.addCheckbox("Ignore inside deprecated members", "IGNORE_INSIDE_DEPRECATED"); - panel.addCheckbox("Ignore inside non-static imports", "IGNORE_IMPORT_STATEMENTS"); - panel.addCheckbox("Ignore overrides of deprecated abstract methods from non-deprecated supers", "IGNORE_ABSTRACT_DEPRECATED_OVERRIDES"); - panel.addCheckbox("Ignore members of deprecated classes", IGNORE_METHODS_OF_DEPRECATED_NAME); + panel.addCheckbox(InspectionsBundle.message("ignore.inside.deprecated.members"), "IGNORE_INSIDE_DEPRECATED"); + panel.addCheckbox(InspectionsBundle.message("ignore.inside.non.static.imports"), "IGNORE_IMPORT_STATEMENTS"); + panel.addCheckbox(InspectionsBundle.message("html.ignore.overrides.of.deprecated.abstract.methods"), "IGNORE_ABSTRACT_DEPRECATED_OVERRIDES"); + panel.addCheckbox(InspectionsBundle.message("ignore.members.of.deprecated.classes"), IGNORE_METHODS_OF_DEPRECATED_NAME); addSameOutermostClassCheckBox(panel); return panel; } diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/deprecation/DeprecationInspectionBase.java b/java/java-analysis-impl/src/com/intellij/codeInspection/deprecation/DeprecationInspectionBase.java index 0abc1b351062..92658e7a18a9 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/deprecation/DeprecationInspectionBase.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/deprecation/DeprecationInspectionBase.java @@ -4,10 +4,7 @@ package com.intellij.codeInspection.deprecation; import com.intellij.codeInsight.AnnotationUtil; import com.intellij.codeInsight.daemon.JavaErrorBundle; import com.intellij.codeInsight.daemon.impl.analysis.HighlightMessageUtil; -import com.intellij.codeInspection.LocalInspectionTool; -import com.intellij.codeInspection.LocalQuickFix; -import com.intellij.codeInspection.ProblemHighlightType; -import com.intellij.codeInspection.ProblemsHolder; +import com.intellij.codeInspection.*; import com.intellij.codeInspection.ui.MultipleCheckboxOptionsPanel; import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.util.TextRange; @@ -150,7 +147,7 @@ public abstract class DeprecationInspectionBase extends LocalInspectionTool { } static void addSameOutermostClassCheckBox(MultipleCheckboxOptionsPanel panel) { - panel.addCheckbox("Ignore in the same outermost class", "IGNORE_IN_SAME_OUTERMOST_CLASS"); + panel.addCheckbox(InspectionsBundle.message("ignore.in.the.same.outermost.class"), "IGNORE_IN_SAME_OUTERMOST_CLASS"); } protected static String getDescription(@NotNull String description, boolean forRemoval, ProblemHighlightType highlightType) { diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/inconsistentLanguageLevel/InconsistentLanguageLevelInspection.java b/java/java-analysis-impl/src/com/intellij/codeInspection/inconsistentLanguageLevel/InconsistentLanguageLevelInspection.java index a13d2ae4c240..8c7014d22f9c 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/inconsistentLanguageLevel/InconsistentLanguageLevelInspection.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/inconsistentLanguageLevel/InconsistentLanguageLevelInspection.java @@ -62,8 +62,9 @@ public class InconsistentLanguageLevelInspection extends GlobalInspectionTool { LanguageLevel dependantLanguageLevel = EffectiveLanguageLevelUtil.getEffectiveLanguageLevel(dependantModule); if (languageLevel.compareTo(dependantLanguageLevel) < 0) { final CommonProblemDescriptor problemDescriptor = manager.createProblemDescriptor( - "Module " + module.getName() + " with language level " + languageLevel + - " depends on module " + dependantModule.getName() +" with language level " + dependantLanguageLevel, + InspectionsBundle + .message("module.0.with.language.level.1.depends.on.module.2.with.language.level.3", module.getName(), languageLevel, + dependantModule.getName(), dependantLanguageLevel), module, new UnnecessaryModuleDependencyInspection.RemoveModuleDependencyFix(dependantModule.getName()), (QuickFix)QuickFixFactory.getInstance().createShowModulePropertiesFix(module)); diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/java19modules/Java9ModuleEntryPoint.java b/java/java-analysis-impl/src/com/intellij/codeInspection/java19modules/Java9ModuleEntryPoint.java index b09bb7790ece..b22415392f2a 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/java19modules/Java9ModuleEntryPoint.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/java19modules/Java9ModuleEntryPoint.java @@ -2,6 +2,7 @@ package com.intellij.codeInspection.java19modules; import com.intellij.codeInsight.daemon.impl.analysis.JavaModuleGraphUtil; +import com.intellij.codeInspection.InspectionsBundle; import com.intellij.codeInspection.reference.*; import com.intellij.codeInspection.visibility.EntryPointWithVisibilityLevel; import com.intellij.openapi.util.InvalidDataException; @@ -38,7 +39,7 @@ public class Java9ModuleEntryPoint extends EntryPointWithVisibilityLevel { @NotNull @Override public String getDisplayName() { - return "Classes exposed with module-info"; + return InspectionsBundle.message("html.classes.exposed.with.code.module.info.code.html"); } @Override diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/nullable/ChangeNullableDefaultsFix.java b/java/java-analysis-impl/src/com/intellij/codeInspection/nullable/ChangeNullableDefaultsFix.java index bdcf02de1867..39edaf9eb62c 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/nullable/ChangeNullableDefaultsFix.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/nullable/ChangeNullableDefaultsFix.java @@ -16,6 +16,7 @@ package com.intellij.codeInspection.nullable; import com.intellij.codeInsight.NullableNotNullManager; +import com.intellij.codeInspection.InspectionsBundle; import com.intellij.codeInspection.LocalQuickFix; import com.intellij.codeInspection.ProblemDescriptor; import com.intellij.openapi.project.Project; @@ -43,7 +44,7 @@ class ChangeNullableDefaultsFix implements LocalQuickFix { @NotNull @Override public String getFamilyName() { - return "Make \"" + (myNotNullName != null ? myNotNullName : myNullableName) + "\" default annotation"; + return InspectionsBundle.message("make.0.default.annotation", myNotNullName != null ? myNotNullName : myNullableName); } @Override diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/nullable/NullableStuffInspectionBase.java b/java/java-analysis-impl/src/com/intellij/codeInspection/nullable/NullableStuffInspectionBase.java index c1aed974d3c8..62541c34b532 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/nullable/NullableStuffInspectionBase.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/nullable/NullableStuffInspectionBase.java @@ -8,7 +8,6 @@ import com.intellij.codeInsight.intention.AddAnnotationPsiFix; import com.intellij.codeInspection.*; import com.intellij.codeInspection.dataFlow.DfaPsiUtil; import com.intellij.codeInspection.dataFlow.instructions.MethodCallInstruction; -import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.project.Project; import com.intellij.openapi.roots.GeneratedSourcesFilter; @@ -159,7 +158,8 @@ public class NullableStuffInspectionBase extends AbstractBaseJavaLocalInspection PsiClass psiClass = PsiUtil.resolveClassInClassTypeOnly(((PsiClassObjectAccessExpression)value).getOperand().getType()); if (psiClass != null && !hasStringConstructor(psiClass)) { holder.registerProblem(value, - "Custom exception class should have a constructor with a single message parameter of String type", + InspectionsBundle.message( + "custom.exception.class.should.have.a.constructor"), ProblemHighlightType.GENERIC_ERROR_OR_WARNING); } @@ -205,7 +205,7 @@ public class NullableStuffInspectionBase extends AbstractBaseJavaLocalInspection if (DfaPsiUtil.getTypeNullability(JavaPsiFacade.getElementFactory(element.getProject()).createType(typeParameters[i])) == Nullability.NOT_NULL && DfaPsiUtil.getTypeNullability(typeArguments[i].getType()) != Nullability.NOT_NULL) { holder.registerProblem(typeArguments[i], - "Non-null type argument is expected", + InspectionsBundle.message("non.null.type.argument.is.expected"), ProblemHighlightType.GENERIC_ERROR_OR_WARNING); } } @@ -280,7 +280,8 @@ public class NullableStuffInspectionBase extends AbstractBaseJavaLocalInspection @Nullable PsiType assignedType) { if (isNullableNotNullCollectionConflict(expectedType, assignedType, new HashSet<>())) { holder.registerProblem(errorElement, - "Assigning a collection of nullable elements into a collection of non-null elements", + InspectionsBundle + .message("assigning.a.collection.of.nullable.elements"), ProblemHighlightType.GENERIC_ERROR_OR_WARNING); } @@ -392,7 +393,8 @@ public class NullableStuffInspectionBase extends AbstractBaseJavaLocalInspection } else if (isNonAnnotatedOverridingNotNull(targetMethod, superMethod)) { holder.registerProblem(refName, - "Not annotated method is used as an override for a method annotated with " + getPresentableAnnoName(superMethod), + InspectionsBundle.message("not.annotated.method.is.used.as.an.override.for.a.method.annotated.with.0", + getPresentableAnnoName(superMethod)), ProblemHighlightType.GENERIC_ERROR_OR_WARNING, createFixForNonAnnotatedOverridesNotNull(targetMethod, superMethod)); } @@ -540,7 +542,8 @@ public class NullableStuffInspectionBase extends AbstractBaseJavaLocalInspection PsiIdentifier nameIdentifier = field.getNameIdentifier(); if (nameIdentifier.isPhysical()) { - holder.registerProblem(nameIdentifier, "@" + getPresentableAnnoName(field) + " field is always initialized not-null", + holder.registerProblem(nameIdentifier, + InspectionsBundle.message("0.field.is.always.initialized.not.null", getPresentableAnnoName(field)), ProblemHighlightType.GENERIC_ERROR_OR_WARNING, AddAnnotationPsiFix.createAddNotNullFix(field)); } } @@ -610,11 +613,11 @@ public class NullableStuffInspectionBase extends AbstractBaseJavaLocalInspection private static void checkLoopParameterNullability(ProblemsHolder holder, @Nullable PsiAnnotation notNull, @Nullable PsiAnnotation nullable, Nullability expectedNullability) { if (notNull != null && expectedNullability == Nullability.NULLABLE) { - holder.registerProblem(notNull, "Parameter can be null", + holder.registerProblem(notNull, InspectionsBundle.message("parameter.can.be.null"), new RemoveAnnotationQuickFix(notNull, null)); } else if (nullable != null && expectedNullability == Nullability.NOT_NULL) { - holder.registerProblem(nullable, "Parameter is always not-null", + holder.registerProblem(nullable, InspectionsBundle.message("parameter.is.always.not.null"), new RemoveAnnotationQuickFix(nullable, null)); } } diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/redundantCast/RedundantCastInspection.java b/java/java-analysis-impl/src/com/intellij/codeInspection/redundantCast/RedundantCastInspection.java index 36ae62f063ab..9adb17b505a8 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/redundantCast/RedundantCastInspection.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/redundantCast/RedundantCastInspection.java @@ -62,7 +62,7 @@ public class RedundantCastInspection extends GenericsInspectionToolBase { @Override public JComponent createOptionsPanel() { final MultipleCheckboxOptionsPanel optionsPanel = new MultipleCheckboxOptionsPanel(this); - optionsPanel.addCheckbox("Ignore casts in suspicious collections method calls", "IGNORE_SUSPICIOUS_METHOD_CALLS"); + optionsPanel.addCheckbox(InspectionsBundle.message("ignore.casts.in.suspicious.collections.method.calls"), "IGNORE_SUSPICIOUS_METHOD_CALLS"); return optionsPanel; } diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/testOnly/TestOnlyInspection.java b/java/java-analysis-impl/src/com/intellij/codeInspection/testOnly/TestOnlyInspection.java index c85d82828d44..5f83dd1bfbd2 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/testOnly/TestOnlyInspection.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/testOnly/TestOnlyInspection.java @@ -91,7 +91,7 @@ public class TestOnlyInspection extends AbstractBaseJavaLocalInspectionTool { if (toHighlight == null) { toHighlight = element; } - h.registerProblem(toHighlight, "@VisibleForTesting makes little sense on @TestOnly code", new RemoveAnnotationQuickFix(vft, (PsiModifierListOwner)element)); + h.registerProblem(toHighlight, InspectionsBundle.message("visible.for.testing.makes.little.sense.on.test.only.code"), new RemoveAnnotationQuickFix(vft, (PsiModifierListOwner)element)); } } super.visitElement(element); diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/unnecessaryModuleDependency/UnnecessaryModuleDependencyInspection.java b/java/java-analysis-impl/src/com/intellij/codeInspection/unnecessaryModuleDependency/UnnecessaryModuleDependencyInspection.java index 3905b0ca5916..199694d68e87 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/unnecessaryModuleDependency/UnnecessaryModuleDependencyInspection.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/unnecessaryModuleDependency/UnnecessaryModuleDependencyInspection.java @@ -135,7 +135,7 @@ public class UnnecessaryModuleDependencyInspection extends GlobalInspectionTool @Override @NotNull public String getFamilyName() { - return "Remove dependency"; + return InspectionsBundle.message("remove.dependency"); } @Override diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/unneededThrows/RedundantThrowsDeclarationInspection.java b/java/java-analysis-impl/src/com/intellij/codeInspection/unneededThrows/RedundantThrowsDeclarationInspection.java index 378ba91d35d8..2962932acd89 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/unneededThrows/RedundantThrowsDeclarationInspection.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/unneededThrows/RedundantThrowsDeclarationInspection.java @@ -39,7 +39,7 @@ public class RedundantThrowsDeclarationInspection extends GlobalJavaBatchInspect @Nullable @Override public JComponent createOptionsPanel() { - return new SingleCheckboxOptionsPanel("Ignore exceptions thrown by entry points methods", this, "IGNORE_ENTRY_POINTS"); + return new SingleCheckboxOptionsPanel(InspectionsBundle.message("ignore.exceptions.thrown.by.entry.points.methods"), this, "IGNORE_ENTRY_POINTS"); } @Override diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/unusedLibraries/UnusedLibrariesInspection.java b/java/java-analysis-impl/src/com/intellij/codeInspection/unusedLibraries/UnusedLibrariesInspection.java index eef82af11262..216ee36cf45f 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/unusedLibraries/UnusedLibrariesInspection.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/unusedLibraries/UnusedLibrariesInspection.java @@ -63,7 +63,7 @@ public class UnusedLibrariesInspection extends GlobalInspectionTool { @Nullable @Override public JComponent createOptionsPanel() { - return new SingleCheckboxOptionsPanel("Don't report unused jars inside used library", this, "IGNORE_LIBRARY_PARTS"); + return new SingleCheckboxOptionsPanel(InspectionsBundle.message("don.t.report.unused.jars.inside.used.library"), this, "IGNORE_LIBRARY_PARTS"); } @Nullable diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/visibility/AccessCanBeTightenedInspection.java b/java/java-analysis-impl/src/com/intellij/codeInspection/visibility/AccessCanBeTightenedInspection.java index e15f0d1c9cdd..571e38a19adb 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/visibility/AccessCanBeTightenedInspection.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/visibility/AccessCanBeTightenedInspection.java @@ -4,6 +4,7 @@ package com.intellij.codeInspection.visibility; import com.intellij.codeInsight.daemon.GroupNames; import com.intellij.codeInsight.daemon.impl.UnusedSymbolUtil; import com.intellij.codeInspection.AbstractBaseJavaLocalInspectionTool; +import com.intellij.codeInspection.InspectionsBundle; import com.intellij.codeInspection.ProblemsHolder; import com.intellij.codeInspection.deadCode.UnusedDeclarationInspectionBase; import com.intellij.codeInspection.inheritance.ImplicitSubclassProvider; @@ -124,7 +125,8 @@ class AccessCanBeTightenedInspection extends AbstractBaseJavaLocalInspectionTool // can be null in some strange cases of malbuilt PSI, like in EA-95877 if (toHighlight != null) { String suggestedModifier = PsiUtil.getAccessModifier(suggestedLevel); - myHolder.registerProblem(toHighlight, "Access can be " + VisibilityUtil.toPresentableText(suggestedModifier), new ChangeModifierFix(suggestedModifier)); + myHolder.registerProblem(toHighlight, + InspectionsBundle.message("access.can.be.0", VisibilityUtil.toPresentableText(suggestedModifier)), new ChangeModifierFix(suggestedModifier)); } } } diff --git a/java/java-analysis-impl/src/com/intellij/codeInspection/xml/DeprecatedClassUsageInspection.java b/java/java-analysis-impl/src/com/intellij/codeInspection/xml/DeprecatedClassUsageInspection.java index 30099b54199f..ddb228f92711 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInspection/xml/DeprecatedClassUsageInspection.java +++ b/java/java-analysis-impl/src/com/intellij/codeInspection/xml/DeprecatedClassUsageInspection.java @@ -1,10 +1,7 @@ // Copyright 2000-2018 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.codeInspection.xml; -import com.intellij.codeInspection.LocalInspectionToolSession; -import com.intellij.codeInspection.ProblemHighlightType; -import com.intellij.codeInspection.ProblemsHolder; -import com.intellij.codeInspection.XmlSuppressableInspectionTool; +import com.intellij.codeInspection.*; import com.intellij.codeInspection.deprecation.DeprecationInspectionBase; import com.intellij.psi.*; import com.intellij.psi.xml.XmlAttributeValue; @@ -59,7 +56,7 @@ public class DeprecatedClassUsageInspection extends XmlSuppressableInspectionToo @NotNull @Override public String getGroupDisplayName() { - return "XML"; + return InspectionsBundle.message("deprecated.class.usage.group.xml"); } @NotNull diff --git a/platform/analysis-api/resources/messages/InspectionsBundle.properties b/platform/analysis-api/resources/messages/InspectionsBundle.properties index f480822d9b4f..f10854dfb42a 100644 --- a/platform/analysis-api/resources/messages/InspectionsBundle.properties +++ b/platform/analysis-api/resources/messages/InspectionsBundle.properties @@ -1123,4 +1123,68 @@ inspection.redundant.record.constructor.statement.message=Redundant field assign inspection.redundant.record.constructor.canonical.message=Redundant canonical constructor inspection.redundant.record.constructor.can.be.compact.message=Canonical constructor can be converted to compact form inspection.redundant.record.constructor.fix.family.name=Convert canonical constructor to compact form -action.presentation.ScopesChooser.text=In All Scopes \ No newline at end of file +action.presentation.ScopesChooser.text=In All Scopes +non.final.guarded.by.field.0.loc=Non-final @GuardedBy field \\"{0}\\" #loc +non.final.guarded.by.field.ref.loc=Non-final @GuardedBy field #ref #loc +access.can.be.0=Access can be {0} +don.t.report.unused.jars.inside.used.library=Don't report unused jars inside used library +non.final.field.code.ref.code.in.immutable.class.loc=Non-final field #ref in @Immutable class #loc +deprecated.class.usage.group.xml=XML +replace.with.comparator=Replace with comparator +method.reference.mapped.to.comparator=Method reference mapped to Comparator interface does not fulfill the Comparator contract +static.member.guarded.by.instance.ref.loc=Static member guarded by instance #ref #loc +static.member.guarded.by.instance.0.loc=Static member guarded by instance \\"{0}\\" #loc +deprecated.member.0.is.still.used=Deprecated member ''{0}'' is still used +access.to.field.code.ref.code.outside.of.declared.guards.loc=Access to field #ref outside of declared guards #loc +replace.stringtokenizer.delimiters.parameter.with.unique.symbols=Replace StringTokenizer delimiters parameter with unique symbols +delimiters.argument.contains.duplicated.characters=Delimiters argument contains duplicated characters +make.0.default.annotation=Make \\"{0}\\" default annotation +remove.block.marker.comments=Remove block marker comments +redundant.block.marker=Redundant block marker +parameter.is.always.not.null=Parameter is always not-null +parameter.can.be.null=Parameter can be null +0.field.is.always.initialized.not.null=@{0} field is always initialized not-null +not.annotated.method.is.used.as.an.override.for.a.method.annotated.with.0=Not annotated method is used as an override for a method annotated with {0} +assigning.a.collection.of.nullable.elements=Assigning a collection of nullable elements into a collection of non-null elements +non.null.type.argument.is.expected=Non-null type argument is expected +custom.exception.class.should.have.a.constructor=Custom exception class should have a constructor with a single message parameter of String type +html.classes.exposed.with.code.module.info.code.html=Classes exposed with module-info +ignore.operation.which.results.in.negative.value=Ignore '<<' operation which results in negative value +visible.for.testing.makes.little.sense.on.test.only.code=@VisibleForTesting makes little sense on @TestOnly code +ignore.in.the.same.outermost.class=Ignore in the same outermost class +replace.anonymous.class.with.lambda.alternative=Replace anonymous class with lambda alternative +replace.with.0=Replace with {0} +anonymous.ref.loc.can.be.replaced.with.0=Anonymous #ref #loc can be replaced with {0} +replace.with=Replace with <> +explicit.type.argument.ref.loc.can.be.replaced.with=Explicit type argument #ref #loc can be replaced with <> +replace.with.constant.value=Replace with constant value +possible.heap.pollution.from.parameterized.vararg.type.loc=Possible heap pollution from parameterized vararg type #loc +make.final.and.annotate.as.safevarargs=Make final and annotate as @SafeVarargs +annotate.as.safevarargs=Annotate as @SafeVarargs +ignore.members.of.deprecated.classes=Ignore members of deprecated classes +html.ignore.overrides.of.deprecated.abstract.methods=Ignore overrides of deprecated abstract methods from non-deprecated supers +ignore.inside.non.static.imports=Ignore inside non-static imports +ignore.inside.deprecated.members=Ignore inside deprecated members +module.0.with.language.level.1.depends.on.module.2.with.language.level.3=Module {0} with language level {1} depends on module {2} with language level {3} +ignore.casts.in.suspicious.collections.method.calls=Ignore casts in suspicious collections method calls +replace.with.lambda=Replace with lambda +anonymous.ref.loc.can.be.replaced.with.lambda=Anonymous #ref #loc can be replaced with lambda +report.when.interface.is.not.annotated.with.functional.interface=Report when interface is not annotated with @FunctionalInterface +instance.member.guarded.by.static.ref.loc=Instance member guarded by static #ref #loc +instance.member.guarded.by.static.0.loc=Instance member guarded by static \\"{0}\\" #loc +replace.var.with.explicit.type=Replace 'var' with explicit type +var.can.be.replaced.with.explicit.type='var' can be replaced with explicit type +replace.operator.assignment.with.assignment=Replace Operator Assignment with Assignment +replace.0.with=Replace ''''{0}'''' with ''''='''' +comparision.between.object.and.primitive=Comparision between Object and primitive is illegal and is accepted in java 7 only +vararg.method.call.with.50.poly.arguments=Vararg method call with 50+ poly arguments may cause compilation and analysis slowdown +replace.with.expression.lambda=Replace with expression lambda +statement.lambda.can.be.replaced.with.expression.lambda=Statement lambda can be replaced with expression lambda +unknown.guardedby.reference.0.loc=Unknown @GuardedBy reference \\"{0}\\" #loc +unknown.guardedby.reference.ref.loc=Unknown @GuardedBy reference #ref #loc +ignore.exceptions.thrown.by.entry.points.methods=Ignore exceptions thrown by entry points methods +remove.dependency=Remove dependency +searching.for.overriding.methods=Searching for Overriding Methods +remove.switch.label=Remove switch label +remove.switch.label.0=Remove switch label ''{0}'' +remove.switch.branch.0=Remove switch branch ''{0}'' \ No newline at end of file