diff --git a/java/java-analysis-api/resources/messages/JavaAnalysisBundle.properties b/java/java-analysis-api/resources/messages/JavaAnalysisBundle.properties index 99f30a38feaa..b73d58745138 100644 --- a/java/java-analysis-api/resources/messages/JavaAnalysisBundle.properties +++ b/java/java-analysis-api/resources/messages/JavaAnalysisBundle.properties @@ -10,12 +10,12 @@ dataflow.message.negative.array.size=Negative array size dataflow.message.arraystore=Storing element of type {0} to array of {1} elements will produce ArrayStoreException dataflow.message.assigning.null.notannotated=Assigning null value to non-annotated field dataflow.message.assigning.null=null is assigned to a non-null variable -dataflow.message.assigning.nullable.notannotated=Expression #ref #loc might be null but is assigned to non-annotated field +dataflow.message.assigning.nullable.notannotated=Expression #ref 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 non-null variable -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.cce.always=Casting {0} to #ref will produce ClassCastException for any non-null value +dataflow.message.cce=Casting {0} to #ref may produce ClassCastException +dataflow.message.constant.condition.when.reached=Condition #ref is always {0, choice, 0#false|1#true} when reached +dataflow.message.constant.condition=Condition #ref 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.fail=The call to '#ref' always fails with an exception @@ -23,31 +23,31 @@ dataflow.message.contract.fail.index=The call to '#ref' always fails as an argum 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.array.access.sure=Array access #ref will produce NullPointerException +dataflow.message.npe.array.access=Array access #ref may produce NullPointerException +dataflow.message.npe.field.access.sure=Dereference of #ref will produce NullPointerException +dataflow.message.npe.field.access=Dereference of #ref 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.method.invocation.sure=Method invocation #ref will produce NullPointerException +dataflow.message.npe.method.invocation=Method invocation #ref may produce NullPointerException dataflow.message.npe.template.invocation.sure=Template processor invocation will produce NullPointerException dataflow.message.npe.template.invocation=Template processor invocation 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.npe.methodref.invocation=Method reference invocation #ref may produce NullPointerException +dataflow.message.only.switch.label=Switch label #ref 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.passing.nullable.argument.nonannotated=Argument #ref might be null but passed to non-annotated parameter +dataflow.message.passing.nullable.argument=Argument #ref might be null dataflow.message.passing.non.null.argument.to.optional='Optional.ofNullable()' with non-null argument should be replaced with 'Optional.of()' dataflow.message.passing.null.argument.to.optional='Optional.ofNullable()' with null argument should be replaced with 'Optional.empty()' -dataflow.message.pointless.assignment.expression=Condition #ref #loc at the left side of assignment expression is always {0}. Can be simplified +dataflow.message.pointless.assignment.expression=Condition #ref 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.pointless.same.argument.and.result=Result of ''#ref'' is the same as the {0,choice,1#first|2#second} argument making the call 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.instanceof=Condition #ref is redundant and can be replaced with a null check dataflow.message.redundant.update=Variable update does nothing dataflow.message.return.notnull.from.nullable=@{0} method ''{1}'' always returns a non-null value dataflow.message.return.null.from.notnull=null is returned by the method declared as @{0} @@ -58,11 +58,11 @@ dataflow.message.return.nullable.from.notnullable=Expression #ref m 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.nullable.argument.methodref=Passing an argument to the method reference requires unboxing which may produce NullPointerException -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.message.constant.expression=Result of #ref #loc is always ''{0}'' -dataflow.message.constant.value=Value #ref #loc is always ''{0}'' +dataflow.message.unboxing.method.reference=Use of #ref would need unboxing which may produce NullPointerException +dataflow.message.unboxing=Unboxing of #ref may produce NullPointerException +dataflow.message.unreachable.switch.label=Switch label #ref is unreachable +dataflow.message.constant.expression=Result of #ref is always ''{0}'' +dataflow.message.constant.value=Value #ref is always ''{0}'' dataflow.method.fails.with.null.argument=Method will throw an exception when parameter is null dataflow.message.unknown.nullability=\ (unknown nullability) dataflow.message.stream.consumed.always=Stream has already been linked or consumed @@ -124,13 +124,13 @@ scope.package=Package {0} 0.field.is.always.initialized.not.null=@{0} field is always initialized non-null access.can.be.0=Access can be ''{0}'' access.can.be.package.private=Access can be package-private -access.to.field.code.ref.code.outside.of.declared.guards.loc=Access to field #ref outside of declared guards #loc -call.to.method.code.ref.code.outside.of.declared.guards.loc=Call to method #ref() outside of declared guards #loc +access.to.field.code.ref.code.outside.of.declared.guards.loc=Access to field #ref outside of declared guards +call.to.method.code.ref.code.outside.of.declared.guards.loc=Call to method #ref() outside of declared guards annotate.as.safevarargs=Annotate as '@SafeVarargs' annotate.overridden.methods.parameters.family.name=Annotate overriding method parameters annotate.overridden.methods.parameters=Annotate overriding method parameters as ''@{0}'' -anonymous.ref.loc.can.be.replaced.with.0=Anonymous #ref #loc can be replaced with {0} -anonymous.ref.loc.can.be.replaced.with.lambda=Anonymous #ref #loc can be replaced with lambda +anonymous.ref.loc.can.be.replaced.with.0=Anonymous #ref can be replaced with {0} +anonymous.ref.loc.can.be.replaced.with.lambda=Anonymous #ref can be replaced with lambda assigning.a.collection.of.nullable.elements=Assigning a collection of nullable elements into a collection of non-null elements returning.a.class.with.nullable.arguments=\ \ @@ -152,7 +152,7 @@ deprecated.member.0.is.still.used=Deprecated member ''{0}'' is still used detach.library.quickfix.name=Detach library detach.library.roots.quickfix.name=Detach unused library roots don.t.report.unused.jars.inside.used.library=Don't report unused jars inside used library -explicit.type.argument.ref.loc.can.be.replaced.with=Explicit type argument #ref #loc can be replaced with <> +explicit.type.argument.ref.loc.can.be.replaced.with=Explicit type argument #ref can be replaced with <> exports.to.itself.delete.module.ref.fix=Delete reference to module ''{0}'' exports.to.itself.delete.statement.fix=Delete directive html.classes.exposed.with.code.module.info.code.html=Classes exposed with module-info @@ -272,7 +272,7 @@ inspection.nullable.problems.at.reference.list=Nullability annotation is not app inspection.nullable.problems.at.throws=Nullability annotation is not applicable to 'throws' clause inspection.nullable.problems.constructor.not.compatible.non.null.type.argument=Constructor is not compatible with a non-null type argument inspection.objects.equals.can.be.simplified.display.name='Objects.equals()' can be replaced with 'equals()' -inspection.redundant.cast.problem.descriptor=Casting {0} to #ref #loc is redundant +inspection.redundant.cast.problem.descriptor=Casting {0} to #ref is redundant inspection.redundant.cast.methodref.descriptor=Cast is redundant inspection.redundant.cast.remove.quickfix=Remove redundant cast inspection.redundant.field.initialization.option=Only warn on initialization to null @@ -325,21 +325,21 @@ inspection.visibility.option.constants=Suggest weaker visibility for constants inspection.visibility.option.package.private.members=Suggest package-private visibility level for class members inspection.visibility.package.private.top.level.classes=Suggest package-private visibility level for top-level classes inspection.visibility.private.inner.members=Suggest 'private' for inner class members when referenced from outer class only -instance.member.guarded.by.static.0.loc=Instance member guarded by static "{0}" #loc -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}" +instance.member.guarded.by.static.ref.loc=Instance member guarded by static #ref make.default.the.last.case.family.name=Make 'default' the last case make.final.and.annotate.as.safevarargs=Make final and annotate as '@SafeVarargs' method.reference.mapped.to.comparator=Method reference mapped to 'Comparator' interface does not fulfill the 'Comparator' contract 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} -non.final.field.code.ref.code.in.immutable.class.loc=Non-final field #ref in @Immutable class #loc -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 +non.final.field.code.ref.code.in.immutable.class.loc=Non-final field #ref in @Immutable class +non.final.guarded.by.field.0.loc=Non-final @GuardedBy field "{0}" +non.final.guarded.by.field.ref.loc=Non-final @GuardedBy field #ref non.null.type.argument.is.expected=Non-null type argument is expected nullable.stuff.problems.overridden.method.parameters.are.not.annotated=Overriding method parameters are not annotated nullable.stuff.problems.overridden.methods.are.not.annotated=Overriding methods are not annotated parameter.can.be.null=Parameter can be null parameter.is.always.not.null=Parameter is always non-null -possible.heap.pollution.from.parameterized.vararg.type.loc=Possible heap pollution from parameterized vararg type #loc +possible.heap.pollution.from.parameterized.vararg.type.loc=Possible heap pollution from parameterized vararg type redundant.block.marker=Redundant block marker remove.block.marker.comments=Remove block marker comment remove.dependency=Remove dependency @@ -364,8 +364,8 @@ report.when.interface.is.not.annotated.with.functional.interface=Report when int searching.for.overriding.methods=Searching for Overriding Methods statement.lambda.can.be.replaced.with.expression.lambda=Statement lambda can be replaced with expression lambda static.inheritrance.fix.replace.progress=Replacing usages of {0} -static.member.guarded.by.instance.0.loc=Static member guarded by instance "{0}" #loc -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}" +static.member.guarded.by.instance.ref.loc=Static member guarded by instance #ref suppress.all.for.class=Suppress all inspections for class suppress.inspection.class=Suppress for class suppress.inspection.field=Suppress for field @@ -373,8 +373,8 @@ suppress.inspection.member=Suppress for member suppress.inspection.method=Suppress for method suppress.inspection.module=Suppress for module declaration suspected.module.dependency.problem.descriptor=Module ''{0}'' does not depend on module ''{1}''. Though ''{1}'' was not inspected for exported dependencies needed for scope ''{2}'' -unknown.guardedby.reference.0.loc=Unknown @GuardedBy reference "{0}" #loc -unknown.guardedby.reference.ref.loc=Unknown @GuardedBy reference #ref #loc +unknown.guardedby.reference.0.loc=Unknown @GuardedBy reference "{0}" +unknown.guardedby.reference.ref.loc=Unknown @GuardedBy reference #ref unnecessary.module.dependency.display.name=Unnecessary module dependency unnecessary.module.dependency.problem.descriptor=Module ''{0}'' sources do not depend on module ''{1}'' sources unused.import.display.name=Unused import diff --git a/java/java-analysis-impl/resources/messages/InspectionGadgetsBundle.properties b/java/java-analysis-impl/resources/messages/InspectionGadgetsBundle.properties index d41fe04481ff..578223900e55 100644 --- a/java/java-analysis-impl/resources/messages/InspectionGadgetsBundle.properties +++ b/java/java-analysis-impl/resources/messages/InspectionGadgetsBundle.properties @@ -1,111 +1,111 @@ -cast.to.concrete.class.problem.descriptor=Cast to concrete class {0} #loc +cast.to.concrete.class.problem.descriptor=Cast to concrete class {0} class.references.subclass.display.name=Class references one of its subclasses -class.references.subclass.problem.descriptor=Class ''{0}'' references subclass #ref #loc -class.references.subclass.problem.descriptor.anonymous=Anonymous class references subclass #ref #loc +class.references.subclass.problem.descriptor=Class ''{0}'' references subclass #ref +class.references.subclass.problem.descriptor.anonymous=Anonymous class references subclass #ref collection.declared.by.class.display.name=Collection declared by class, not interface -collection.declared.by.class.problem.descriptor=Declaration of #ref should probably be weakened to ''{0}'' #loc +collection.declared.by.class.problem.descriptor=Declaration of #ref should probably be weakened to ''{0}'' collection.declared.by.class.ignore.locals.option=Ignore local variables collection.declared.by.class.ignore.private.members.option=Ignore 'private' fields and methods feature.envy.display.name=Feature envy -feature.envy.problem.descriptor=Class ''{0}'' accessed repeatedly in method #ref() #loc +feature.envy.problem.descriptor=Class ''{0}'' accessed repeatedly in method #ref() bounded.wildcard.display.name=Can use bounded wildcard -bounded.wildcard.contravariant.descriptor=Can generalize to ? super #ref #loc -bounded.wildcard.covariant.descriptor=Can generalize to ? extends #ref #loc +bounded.wildcard.contravariant.descriptor=Can generalize to ? super #ref +bounded.wildcard.covariant.descriptor=Can generalize to ? extends #ref bounded.wildcard.report.invariant.option=Report invariant classes bounded.wildcard.report.private.option=Report private methods bounded.wildcard.report.instance.option=Report instance methods -instance.variable.of.concrete.class.problem.descriptor=Instance field ''{0}'' of concrete class #ref #loc +instance.variable.of.concrete.class.problem.descriptor=Instance field ''{0}'' of concrete class #ref chain.of.instanceof.checks.display.name=Chain of 'instanceof' checks -chain.of.instanceof.checks.problem.descriptor=Chain of 'instanceof' checks indicates abstraction failure #loc -chain.of.class.equality.checks.problem.descriptor=Chain of class equality checks indicates abstraction failure #loc -instanceof.concrete.class.problem.descriptor='instanceof' concrete class #ref #loc -instanceof.concrete.class.pattern.problem.descriptor=Pattern test against a concrete class #ref #loc -instanceof.concrete.class.equality.problem.descriptor=Class comparison against concrete class #ref #loc +chain.of.instanceof.checks.problem.descriptor=Chain of 'instanceof' checks indicates abstraction failure +chain.of.class.equality.checks.problem.descriptor=Chain of class equality checks indicates abstraction failure +instanceof.concrete.class.problem.descriptor='instanceof' concrete class #ref +instanceof.concrete.class.pattern.problem.descriptor=Pattern test against a concrete class #ref +instanceof.concrete.class.equality.problem.descriptor=Class comparison against concrete class #ref instanceof.check.for.this.display.name='instanceof' check for 'this' -instanceof.check.for.this.problem.descriptor='instanceof' check for #ref #loc -instanceof.check.for.this.equality.problem.descriptor=Class comparison for 'this' #loc -local.variable.of.concrete.class.problem.descriptor=Local variable ''{0}'' of concrete class #ref #loc +instanceof.check.for.this.problem.descriptor='instanceof' check for #ref +instanceof.check.for.this.equality.problem.descriptor=Class comparison for 'this' +local.variable.of.concrete.class.problem.descriptor=Local variable ''{0}'' of concrete class #ref magic.number.display.name=Magic number -magic.number.problem.descriptor=Magic number #ref #loc +magic.number.problem.descriptor=Magic number #ref concrete.class.use.display.name=Use of concrete class -method.return.concrete.class.problem.descriptor=Method returns a concrete class #ref #loc +method.return.concrete.class.problem.descriptor=Method returns a concrete class #ref overly.strong.type.cast.display.name=Overly strong type cast overly.strong.type.cast.weaken.quickfix=Weaken overly strong cast -concrete.class.method.parameter.problem.descriptor=Parameter ''{0}'' of concrete class #ref #loc +concrete.class.method.parameter.problem.descriptor=Parameter ''{0}'' of concrete class #ref public.method.not.in.interface.display.name='public' method not exposed in interface -public.method.not.in.interface.problem.descriptor='public' method #ref() is not exposed via an interface #loc +public.method.not.in.interface.problem.descriptor='public' method #ref() is not exposed via an interface public.method.not.in.interface.option=Ignore if the containing class does not implement a non-library interface -static.variable.of.concrete.class.problem.descriptor=Static field ''{0}'' of concrete class #ref #loc +static.variable.of.concrete.class.problem.descriptor=Static field ''{0}'' of concrete class #ref incompatible.mask.operation.display.name=Incompatible bitwise mask operation -incompatible.mask.operation.problem.descriptor.always.false=#ref is always false #loc -incompatible.mask.operation.problem.descriptor.always.true=#ref is always true #loc +incompatible.mask.operation.problem.descriptor.always.false=#ref is always false +incompatible.mask.operation.problem.descriptor.always.true=#ref is always true pointless.bitwise.expression.display.name=Pointless bitwise expression pointless.bitwise.expression.simplify.quickfix=Simplify shift.operation.by.inappropriate.constant.display.name=Shift operation by inappropriate constant -shift.operation.by.inappropriate.constant.problem.descriptor.too.large=Shift operation #ref by overly large constant value {0} #loc -shift.operation.by.inappropriate.constant.problem.descriptor.negative=Shift operation #ref by negative constant value {0} #loc -shift.operation.by.inappropriate.constant.problem.descriptor.out.of.bounds=Shift operation #ref by out-of-bounds value {0}#loc +shift.operation.by.inappropriate.constant.problem.descriptor.too.large=Shift operation #ref by overly large constant value {0} +shift.operation.by.inappropriate.constant.problem.descriptor.negative=Shift operation #ref by negative constant value {0} +shift.operation.by.inappropriate.constant.problem.descriptor.out.of.bounds=Shift operation #ref by out-of-bounds value {0} equals.called.on.array.display.name='equals()' called on array -equals.called.on.array.problem.descriptor=#ref() between arrays should probably be 'Arrays.equals()' #loc +equals.called.on.array.problem.descriptor=#ref() between arrays should probably be 'Arrays.equals()' assignment.to.null.display.name='null' assignment -assignment.to.null.problem.descriptor='null' assigned to variable #ref #loc +assignment.to.null.problem.descriptor='null' assigned to variable #ref assignment.to.null.option=Ignore assignments to fields assignment.to.static.field.from.instance.method.display.name=Assignment to static field from instance context -assignment.to.static.field.from.instance.method.problem.descriptor=Assignment to static field #ref from instance context #loc +assignment.to.static.field.from.instance.method.problem.descriptor=Assignment to static field #ref from instance context assignment.used.as.condition.display.name=Assignment used as condition -assignment.used.as.condition.problem.descriptor=Assignment #ref used as condition #loc +assignment.used.as.condition.problem.descriptor=Assignment #ref used as condition cast.conflicts.with.instanceof.display.name=Cast conflicts with 'instanceof' cast.conflicts.with.instanceof.problem.descriptor=Cast to ''{0}'' type conflicts with preceding ''instanceof {1}'' check casting.to.incompatible.interface.display.name=Cast to incompatible type -casting.to.incompatible.interface.problem.descriptor=Cast of expression with type ''{1}'' to incompatible {0, choice, 1#interface|2#class} #ref #loc +casting.to.incompatible.interface.problem.descriptor=Cast of expression with type ''{1}'' to incompatible {0, choice, 1#interface|2#class} #ref collection.added.to.self.display.name=Collection added to itself -collection.added.to.self.problem.descriptor=''{0}()'' called on collection #ref with itself as argument #loc +collection.added.to.self.problem.descriptor=''{0}()'' called on collection #ref with itself as argument non.final.field.compareto.display.name=Non-final field referenced in 'compareTo()' -non.final.field.compareto.problem.descriptor=Non-final field #ref accessed in 'compareTo()' #loc +non.final.field.compareto.problem.descriptor=Non-final field #ref accessed in 'compareTo()' covariant.equals.display.name=Covariant 'equals()' -covariant.equals.problem.descriptor=#ref() should take 'Object' as its argument #loc +covariant.equals.problem.descriptor=#ref() should take 'Object' as its argument empty.class.initializer.display.name=Empty class initializer -empty.class.initializer.problem.descriptor=Empty class initializer #loc +empty.class.initializer.problem.descriptor=Empty class initializer empty.class.initializer.delete.quickfix=Delete empty class initializer statement.with.empty.body.display.name=Statement with empty body -statement.with.empty.body.problem.descriptor=#ref statement has empty body #loc +statement.with.empty.body.problem.descriptor=#ref statement has empty body statement.with.empty.body.include.option=Include statement bodies that are empty code blocks equals.between.inconvertible.types.display.name='equals()' between objects of inconvertible types -equals.between.inconvertible.types.problem.descriptor=#ref between objects of inconvertible types ''{0}'' and ''{1}'' #loc -equals.between.inconvertible.types.no.mutual.subclass.problem.descriptor=No class found which is a subtype of both ''{0}'' and ''{1}'' #loc +equals.between.inconvertible.types.problem.descriptor=#ref between objects of inconvertible types ''{0}'' and ''{1}'' +equals.between.inconvertible.types.no.mutual.subclass.problem.descriptor=No class found which is a subtype of both ''{0}'' and ''{1}'' equals.between.inconvertible.types.mutual.subclass.option=Warn if no mutual subclass found equals.called.on.suspicious.object.display.name='equals()' called on classes which don't override it equals.called.on.suspicious.object.problem.descriptor=Suspicious call to ''equals()'' on ''{0}'' object equals.called.on.suspicious.object.fix.family.name=Replace with a comparison of representative values equals.called.on.suspicious.object.fix.name=Replace with a comparison of ''{0}()'' call results non.final.field.in.equals.display.name=Non-final field referenced in 'equals()' -non.final.field.in.equals.problem.descriptor=Non-final field #ref accessed in 'equals()' #loc +non.final.field.in.equals.problem.descriptor=Non-final field #ref accessed in 'equals()' equals.doesnt.check.class.parameter.display.name='equals()' method that does not check the class of its parameter -equals.doesnt.check.class.parameter.problem.descriptor=#ref() should check the class of its parameter #loc +equals.doesnt.check.class.parameter.problem.descriptor=#ref() should check the class of its parameter non.final.field.in.hashcode.display.name=Non-final field referenced in 'hashCode()' -non.final.field.in.hashcode.problem.descriptor=Non-final field #ref accessed in 'hashCode()' #loc +non.final.field.in.hashcode.problem.descriptor=Non-final field #ref accessed in 'hashCode()' result.of.method.call.ignored.display.name=Result of method call ignored write.only.object.display.name=Write-only object write.only.object.option.ignore.impure.constructors=Ignore impure constructors -result.of.method.call.ignored.problem.descriptor=Result of {0}.#ref() is ignored #loc +result.of.method.call.ignored.problem.descriptor=Result of {0}.#ref() is ignored result.of.method.call.ignored.class.column.title=Class Name result.of.method.call.ignored.non.library.option=Report all ignored non-library calls infinite.recursion.display.name=Infinite recursion -infinite.recursion.problem.descriptor=Method #ref() recurses infinitely, and can only end by throwing an exception #loc +infinite.recursion.problem.descriptor=Method #ref() recurses infinitely, and can only end by throwing an exception instanceof.with.incompatible.interface.display.name='instanceof' with incompatible type -instanceof.with.incompatible.interface.problem.descriptor=''instanceof'' of expression with type ''{1}'' with incompatible {0, choice, 1#interface|2#class} #ref #loc +instanceof.with.incompatible.interface.problem.descriptor=''instanceof'' of expression with type ''{1}'' with incompatible {0, choice, 1#interface|2#class} #ref instantiation.utility.class.display.name=Instantiation of utility class -instantiation.utility.class.problem.descriptor=Instantiation of utility class #ref #loc +instantiation.utility.class.problem.descriptor=Instantiation of utility class #ref iterator.hasnext.which.calls.next.display.name='Iterator.hasNext()' which calls 'next()' -iterator.hasnext.which.calls.next.problem.descriptor=Iterator.{0}() contains call to ''#ref()'' #loc +iterator.hasnext.which.calls.next.problem.descriptor=Iterator.{0}() contains call to ''#ref()'' iterator.next.does.not.throw.nosuchelementexception.display.name='Iterator.next()' which can't throw 'NoSuchElementException' malformed.format.string.display.name=Malformed format string -malformed.format.string.problem.descriptor.malformed=Format string #ref is malformed #loc -malformed.format.string.problem.descriptor.illegal=Illegal format string specifier: {0} #loc -malformed.format.string.problem.descriptor.too.many.arguments=Too many arguments for format string (found: {0}, expected: {1}) #loc -malformed.format.string.problem.descriptor.too.few.arguments=Too few arguments for format string (found: {0}, expected: {1}) #loc -malformed.format.string.problem.descriptor.at.least.too.few.arguments=Too few arguments for format string (found: {0}, expected at least: {1}) #loc -malformed.format.string.problem.descriptor.arguments.do.not.match.type=Argument type ''{0}'' does not match the type of the format specifier ''{1}'' #loc +malformed.format.string.problem.descriptor.malformed=Format string #ref is malformed +malformed.format.string.problem.descriptor.illegal=Illegal format string specifier: {0} +malformed.format.string.problem.descriptor.too.many.arguments=Too many arguments for format string (found: {0}, expected: {1}) +malformed.format.string.problem.descriptor.too.few.arguments=Too few arguments for format string (found: {0}, expected: {1}) +malformed.format.string.problem.descriptor.at.least.too.few.arguments=Too few arguments for format string (found: {0}, expected at least: {1}) +malformed.format.string.problem.descriptor.arguments.do.not.match.type=Argument type ''{0}'' does not match the type of the format specifier ''{1}'' format.string.error.flags.not.allowed={2, choice, 1#flag|1#ref are written to, but never read #loc -mismatched.read.write.array.problem.descriptor.read.not.write=Contents of array #ref are read, but never written to #loc +mismatched.read.write.array.problem.descriptor.write.not.read=Contents of array #ref are written to, but never read +mismatched.read.write.array.problem.descriptor.read.not.write=Contents of array #ref are read, but never written to mismatched.update.collection.display.name=Mismatched query and update of collection -mismatched.update.collection.problem.description.no.effect.updates=Update operations on empty collection #ref have no effect #loc -mismatched.update.collection.problem.description.updated.not.queried=Contents of collection #ref are updated, but never queried #loc -mismatched.update.collection.problem.description.queried.empty=Contents of empty collection #ref are queried, but it's never populated #loc -mismatched.update.collection.problem.description.queried.not.updated=Contents of collection #ref are queried, but never updated #loc +mismatched.update.collection.problem.description.no.effect.updates=Update operations on empty collection #ref have no effect +mismatched.update.collection.problem.description.updated.not.queried=Contents of collection #ref are updated, but never queried +mismatched.update.collection.problem.description.queried.empty=Contents of empty collection #ref are queried, but it's never populated +mismatched.update.collection.problem.description.queried.not.updated=Contents of collection #ref are queried, but never updated rename.quickfix=Rename renameto.quickfix=Rename to ''{0}'' misspelled.equals.display.name='equal()' instead of 'equals()' -misspelled.equals.problem.descriptor=#ref() method should probably be 'equals()' #loc +misspelled.equals.problem.descriptor=#ref() method should probably be 'equals()' non.short.circuit.boolean.expression.display.name=Non-short-circuit boolean expression -non.short.circuit.boolean.expression.problem.descriptor=Non-short-circuit boolean expression #ref #loc +non.short.circuit.boolean.expression.problem.descriptor=Non-short-circuit boolean expression #ref non.short.circuit.boolean.expression.replace.quickfix=Replace with short circuit expression null.argument.to.var.arg.method.display.name=Confusing argument to varargs method -null.argument.to.var.arg.method.problem.descriptor=Confusing argument #ref, unclear if a varargs or non-varargs call is desired #loc +null.argument.to.var.arg.method.problem.descriptor=Confusing argument #ref, unclear if a varargs or non-varargs call is desired primitive.array.argument.to.var.arg.method.display.name=Confusing primitive array argument to varargs method -primitive.array.argument.to.var.arg.method.problem.descriptor=Confusing primitive array argument to varargs method #loc +primitive.array.argument.to.var.arg.method.problem.descriptor=Confusing primitive array argument to varargs method object.comparison.display.name=Object comparison using '==', instead of 'equals()' object.comparison.enumerated.ignore.option=Ignore '==' between enum variables object.comparison.klass.ignore.option=Ignore '==' between final class types without 'equals()' implementation -object.comparison.problem.description=Object values are compared using #ref, not 'equals()' #loc +object.comparison.problem.description=Object values are compared using #ref, not 'equals()' equality.to.safe.equals.quickfix=Replace '==' with null-safe 'equals()' inequality.to.safe.not.equals.quickfix=Replace '!=' with null-safe '!equals()' default.tostring.call.display.name=Call to default 'toString()' -default.tostring.call.problem.descriptor=Call to default 'toString()' on #ref #loc +default.tostring.call.problem.descriptor=Call to default 'toString()' on #ref octal.and.decimal.integers.in.same.array.display.name=Octal and decimal integers in same array -octal.and.decimal.integers.in.same.array.problem.descriptor=Octal and decimal integers in the same array initializer #loc +octal.and.decimal.integers.in.same.array.problem.descriptor=Octal and decimal integers in the same array initializer result.of.object.allocation.ignored.display.name=Result of object allocation ignored -result.of.object.allocation.ignored.problem.descriptor=Result of new #ref() is ignored #loc -result.of.object.allocation.ignored.problem.descriptor.methodRef=Object allocated inside #ref is discarded #loc +result.of.object.allocation.ignored.problem.descriptor=Result of new #ref() is ignored +result.of.object.allocation.ignored.problem.descriptor.methodRef=Object allocated inside #ref is discarded result.of.object.allocation.ignored.options.chooserTitle=Choose Class for Which Object Allocation Can Be Ignored result.of.object.allocation.fix.name=Ignore allocations of objects with type ''{0}'' use.0index.in.jdbc.resultset.display.name=Use of index 0 in JDBC ResultSet -use.0index.in.jdbc.resultset.problem.descriptor=Use of index '0' in JDBC ResultSet #loc -use.0index.in.jdbc.prepared.statement.problem.descriptor=Use of index '0' in JDBC PreparedStatement #loc +use.0index.in.jdbc.resultset.problem.descriptor=Use of index '0' in JDBC ResultSet +use.0index.in.jdbc.prepared.statement.problem.descriptor=Use of index '0' in JDBC PreparedStatement return.of.null.display.name=Return of 'null' -return.of.null.problem.descriptor=Return of #ref #loc +return.of.null.problem.descriptor=Return of #ref return.of.null.arrays.option=Report methods that return arrays return.of.null.objects.option=Report methods that return objects return.of.null.collections.option=Report methods that return collection objects return.of.null.ignore.private.option=Ignore 'private' methods, anonymous classes \\& lambda's static.method.via.subclass.display.name=Static method referenced via subclass -static.method.via.subclass.problem.descriptor=Static method #ref() declared in class ''{0}'' but referenced via subclass ''{1}'' #loc +static.method.via.subclass.problem.descriptor=Static method #ref() declared in class ''{0}'' but referenced via subclass ''{1}'' static.method.via.subclass.rationalize.quickfix=Rationalize static method call static.field.via.subclass.display.name=Static field referenced via subclass -static.field.via.subclass.problem.descriptor=Static field #ref declared in class ''{0}'' but referenced via subclass ''{1}'' #loc +static.field.via.subclass.problem.descriptor=Static field #ref declared in class ''{0}'' but referenced via subclass ''{1}'' static.field.via.subclass.rationalize.quickfix=Rationalize static field access string.comparison.display.name=String comparison using '==', instead of 'equals()' number.comparison.display.name=Number comparison using '==', instead of 'equals()' -string.comparison.problem.descriptor=String values are compared using #ref, not 'equals()' #loc -number.comparison.problem.descriptor=Number objects are compared using #ref, not 'equals()' #loc +string.comparison.problem.descriptor=String values are compared using #ref, not 'equals()' +number.comparison.problem.descriptor=Number objects are compared using #ref, not 'equals()' subtraction.in.compareto.display.name=Subtraction in 'compareTo()' -subtraction.in.compareto.problem.descriptor=Subtraction #ref in 'compareTo()' may result in overflow or precision loss #loc +subtraction.in.compareto.problem.descriptor=Subtraction #ref in 'compareTo()' may result in overflow or precision loss text.label.in.switch.statement.display.name=Text label in 'switch' statement -text.label.in.switch.statement.problem.descriptor=Text label #ref: in ''switch'' {0, choice, 1#statement|2#expression} #loc +text.label.in.switch.statement.problem.descriptor=Text label #ref: in ''switch'' {0, choice, 1#statement|2#expression} properties.object.as.hashtable.display.name=Use of 'Properties' object as a 'Hashtable' -properties.object.as.hashtable.problem.descriptor=Call to Hashtable.#ref() on properties object #loc +properties.object.as.hashtable.problem.descriptor=Call to Hashtable.#ref() on properties object assignment.replaceable.with.operator.assignment.display.name=Assignment can be replaced with operator assignment unnecessary.code.block.display.name=Unnecessary code block unnecessary.code.block.unwrap.quickfix=Unwrap block @@ -185,145 +185,145 @@ redundant.local.variable.display.name=Redundant local variable redundant.local.variable.ignore.option=Ignore immediately returned or thrown variables redundant.local.variable.annotation.option=Ignore variables which have an annotation static.collection.display.name=Static collection -static.collection.problem.descriptor=Static collection #ref #loc +static.collection.problem.descriptor=Static collection #ref static.collection.ignore.option=Ignore weak static collections or maps stringbuffer.field.display.name='StringBuilder' field -stringbuffer.field.problem.descriptor=''{0}'' field #ref #loc +stringbuffer.field.problem.descriptor=''{0}'' field #ref gc.call.display.name=Call to 'System.gc()' or 'Runtime.gc()' -gc.call.problem.descriptor=#ref should not be called in production code #loc +gc.call.problem.descriptor=#ref should not be called in production code array.allocation.zero.length.display.name=Zero-length array allocation -array.allocation.zero.length.problem.descriptor=Allocation of zero length array #loc +array.allocation.zero.length.problem.descriptor=Allocation of zero length array constant.for.zero.length.array.display.name=Unnecessary zero length array usage -constant.for.zero.length.array.problem.descriptor=Zero length array can be changed to constant #loc +constant.for.zero.length.array.problem.descriptor=Zero length array can be changed to constant constant.for.zero.length.array.quickfix.family=Replace with constant multiple.loggers.display.name=Class with multiple loggers logger.name.option=Logger &class name: -multiple.loggers.problem.descriptor=Class #ref declares multiple loggers #loc +multiple.loggers.problem.descriptor=Class #ref declares multiple loggers no.logger.display.name=Class without logger -no.logger.problem.descriptor=Class #ref does not declare a logger #loc +no.logger.problem.descriptor=Class #ref does not declare a logger non.constant.logger.display.name=Non-constant logger -non.constant.logger.problem.descriptor=Non-constant logger field #ref #loc +non.constant.logger.problem.descriptor=Non-constant logger field #ref public.method.without.logging.display.name='public' method without logging -public.method.without.logging.problem.descriptor='public' method #ref() has no logging call #loc +public.method.without.logging.problem.descriptor='public' method #ref() has no logging call ignore.trivial.finalizers.option=Ignore for trivial 'finalize()' implementations finalize.declaration.display.name='finalize()' should not be overridden -finalize.declaration.problem.descriptor='finalize()' should not be overridden #loc +finalize.declaration.problem.descriptor='finalize()' should not be overridden finalize.not.declared.protected.display.name='finalize()' should be protected, not public -finalize.not.declared.protected.problem.descriptor='finalize()' should have protected access, not public #loc +finalize.not.declared.protected.problem.descriptor='finalize()' should have protected access, not public finalize.called.explicitly.display.name='finalize()' called explicitly -finalize.called.explicitly.problem.descriptor=#ref() called explicitly #loc +finalize.called.explicitly.problem.descriptor=#ref() called explicitly java.lang.import.display.name=Unnecessary import from the 'java.lang' package -java.lang.import.problem.descriptor=Unnecessary import from the 'java.lang' package #loc +java.lang.import.problem.descriptor=Unnecessary import from the 'java.lang' package import.display.name='*' import -import.problem.descriptor=Package import #ref #loc +import.problem.descriptor=Package import #ref import.from.same.package.display.name=Unnecessary import from the same package -import.from.same.package.problem.descriptor=Unnecessary import from the same package #ref #loc +import.from.same.package.problem.descriptor=Unnecessary import from the same package #ref single.class.import.display.name=Single class import -single.class.import.problem.descriptor=Single class import #ref #loc +single.class.import.problem.descriptor=Single class import #ref static.import.display.name=Static import -static.import.problem.descriptor=Static import #ref #loc +static.import.problem.descriptor=Static import #ref static.import.replace.quickfix=Replace with non-static import static.import.fix.ignore.class=Allow static imports for class ''{0}'' static.import.options.border.title=Statically importable classes: static.import.options.chooserTitle=Choose Statically Importable Class -unused.import.problem.descriptor=Unused import #ref #loc +unused.import.problem.descriptor=Unused import #ref clone.instantiates.objects.with.constructor.display.name='clone()' instantiates objects with constructor -clone.instantiates.objects.with.constructor.problem.descriptor='clone()' creates new #ref instances #loc -clone.instantiates.new.array.problem.descriptor=''clone()'' creates new {0} array #loc +clone.instantiates.objects.with.constructor.problem.descriptor='clone()' creates new #ref instances +clone.instantiates.new.array.problem.descriptor=''clone()'' creates new {0} array clone.doesnt.declare.clonenotsupportedexception.display.name='clone()' does not declare 'CloneNotSupportedException' -clone.doesnt.declare.clonenotsupportedexception.problem.descriptor=#ref() #loc does not declare 'CloneNotSupportedException' +clone.doesnt.declare.clonenotsupportedexception.problem.descriptor=#ref() does not declare 'CloneNotSupportedException' clone.doesnt.declare.clonenotsupportedexception.declare.quickfix=Add 'CloneNotSupportedException' to throws clause clone.method.in.non.cloneable.class.display.name='clone()' method in non-Cloneable class -clone.method.in.non.cloneable.class.problem.descriptor=#ref() defined in non-Cloneable class ''{0}'' #loc -clone.method.in.non.cloneable.anonymous.class.problem.descriptor=#ref() defined in non-Cloneable anonymous class derived from ''{0}'' #loc -clone.method.in.non.cloneable.interface.problem.descriptor=#ref() defined in non-Cloneable interface ''{0}'' #loc +clone.method.in.non.cloneable.class.problem.descriptor=#ref() defined in non-Cloneable class ''{0}'' +clone.method.in.non.cloneable.anonymous.class.problem.descriptor=#ref() defined in non-Cloneable anonymous class derived from ''{0}'' +clone.method.in.non.cloneable.interface.problem.descriptor=#ref() defined in non-Cloneable interface ''{0}'' cloneable.class.without.clone.display.name=Cloneable class without 'clone()' method -cloneable.class.without.clone.problem.descriptor=#ref is 'Cloneable' but does not define 'clone()' method #loc +cloneable.class.without.clone.problem.descriptor=#ref is 'Cloneable' but does not define 'clone()' method cloneable.class.without.clone.ignore.option=Ignore classes cloneable due to inheritance cloneable.class.without.clone.ignore.when.clone.called.option=Ignore if Cloneable is necessary to call the clone() method of a superclass cloneable.class.without.clone.quickfix=Generate 'clone()' method cloneable.class.without.clone.todo.message=TODO: copy mutable state here, so the clone can't change the internals of the original use.obsolete.collection.type.display.name=Use of obsolete collection type -use.obsolete.collection.type.problem.descriptor=Obsolete collection type #ref used #loc +use.obsolete.collection.type.problem.descriptor=Obsolete collection type #ref used use.obsolete.collection.type.ignore.library.arguments.option=Ignore obsolete collection types where they are required use.system.out.err.display.name=Use of 'System.out' or 'System.err' -use.system.out.err.problem.descriptor=Uses of #ref should probably be replaced with more robust logging #loc +use.system.out.err.problem.descriptor=Uses of #ref should probably be replaced with more robust logging use.system.out.err.problem.fix.err.option=Log method for 'System.err': use.system.out.err.problem.fix.out.option=Log method for 'System.out': dumpstack.call.display.name=Call to 'Thread.dumpStack()' -dumpstack.call.problem.descriptor=Call to Thread.#ref() should probably be replaced with more robust logging #loc +dumpstack.call.problem.descriptor=Call to Thread.#ref() should probably be replaced with more robust logging printstacktrace.call.display.name=Call to 'printStackTrace()' -printstacktrace.call.problem.descriptor=Call to #ref() should probably be replaced with more robust logging #loc +printstacktrace.call.problem.descriptor=Call to #ref() should probably be replaced with more robust logging abstract.method.call.in.constructor.display.name=Abstract method called during object construction -abstract.method.call.in.constructor.problem.descriptor=Call to 'abstract' method #ref() during object construction #loc +abstract.method.call.in.constructor.problem.descriptor=Call to 'abstract' method #ref() during object construction instance.variable.may.not.be.initialized.display.name=Instance field may not be initialized -instance.variable.may.not.be.initialized.problem.descriptor=Instance field #ref may not be initialized during object construction #loc -instance.Variable.may.not.be.initialized.problem.descriptor.junit=Instance field #ref may not be initialized during object construction or 'setUp()' call #loc +instance.variable.may.not.be.initialized.problem.descriptor=Instance field #ref may not be initialized during object construction +instance.Variable.may.not.be.initialized.problem.descriptor.junit=Instance field #ref may not be initialized during object construction or 'setUp()' call primitive.fields.ignore.option=Ignore primitive fields instance.variable.used.before.initialized.display.name=Instance field used before initialization -instance.variable.used.before.initialized.problem.descriptor=Instance field #ref used before initialized #loc +instance.variable.used.before.initialized.problem.descriptor=Instance field #ref used before initialized non.final.static.variable.initialization.display.name=Non-final static field is used during class initialization -non.final.static.variable.initialization.problem.descriptor=Non-final static field #ref used during class initialization #loc +non.final.static.variable.initialization.problem.descriptor=Non-final static field #ref used during class initialization overridable.method.call.in.constructor.display.name=Overridable method called during object construction -overridable.method.call.in.constructor.problem.descriptor=Call to overridable method #ref() during object construction #loc +overridable.method.call.in.constructor.problem.descriptor=Call to overridable method #ref() during object construction overridden.method.call.in.constructor.display.name=Overridden method called during object construction -overridden.method.call.in.constructor.problem.descriptor=Call to overridden method #ref() during object construction #loc +overridden.method.call.in.constructor.problem.descriptor=Call to overridden method #ref() during object construction static.variable.may.not.be.initialized.display.name=Static field may not be initialized -static.variable.may.not.be.initialized.problem.descriptor=Static field #ref may not be initialized during class initialization #loc +static.variable.may.not.be.initialized.problem.descriptor=Static field #ref may not be initialized during class initialization static.variable.used.before.initialization.display.name=Static field used before initialization -static.variable.used.before.initialization.problem.descriptor=Static field #ref used before initialization #loc +static.variable.used.before.initialization.problem.descriptor=Static field #ref used before initialization this.reference.escaped.in.construction.display.name='this' reference escaped in object construction -this.reference.escaped.in.construction.problem.descriptor=Escape of #ref during object construction #loc +this.reference.escaped.in.construction.problem.descriptor=Escape of #ref during object construction assignment.to.catch.block.parameter.display.name=Assignment to 'catch' block parameter extract.parameter.as.local.variable.quickfix=Extract parameter as local variable assignment.to.for.loop.parameter.display.name=Assignment to 'for' loop parameter assignment.to.for.loop.parameter.check.foreach.option=Check enhanced 'for' loop parameters -assignment.to.for.loop.parameter.problem.descriptor=Assignment to for-loop parameter #ref #loc +assignment.to.for.loop.parameter.problem.descriptor=Assignment to for-loop parameter #ref assignment.to.method.parameter.display.name=Assignment to method parameter chained.equality.comparisons.display.name=Chained equality comparisons confusing.octal.escape.sequence.display.name=Confusing octal escape sequence increment.decrement.display.name=Result of '++' or '--' used nested.assignment.display.name=Nested assignment -nested.assignment.problem.descriptor=Result of assignment expression used #loc +nested.assignment.problem.descriptor=Result of assignment expression used overloaded.methods.with.same.number.parameters.display.name=Overloaded methods with same number of parameters overloaded.vararg.method.display.name=Overloaded varargs method refused.bequest.display.name=Method does not call super method reuse.of.local.variable.display.name=Reuse of local variable reuse.of.local.variable.split.quickfix=Split local variable character.comparison.display.name=Character comparison -character.comparison.problem.descriptor=Character comparison #ref in an internationalized context #loc +character.comparison.problem.descriptor=Character comparison #ref in an internationalized context package.visible.field.display.name=Package-visible field -package.visible.field.problem.descriptor=Package-visible field #ref #loc +package.visible.field.problem.descriptor=Package-visible field #ref package.visible.inner.class.display.name=Package-visible nested class -package.visible.inner.class.problem.descriptor=Package-visible nested class #ref #loc +package.visible.inner.class.problem.descriptor=Package-visible nested class #ref package.visible.inner.class.ignore.enum.option=Ignore package-visible inner enums package.visible.inner.class.ignore.interface.option=Ignore package-visible inner interfaces protected.field.display.name=Protected field -protected.field.problem.descriptor=Protected field #ref #loc +protected.field.problem.descriptor=Protected field #ref protected.inner.class.display.name=Protected nested class -protected.inner.class.problem.descriptor=Protected nested class #ref #loc +protected.inner.class.problem.descriptor=Protected nested class #ref protected.inner.class.ignore.enum.option=Ignore 'protected' inner enums protected.inner.class.ignore.interface.option=Ignore 'protected' inner interfaces public.field.display.name='public' field -public.field.problem.descriptor='public' field #ref #loc +public.field.problem.descriptor='public' field #ref public.field.ignore.enum.type.fields.option=Ignore 'public final' fields of an enum type public.inner.class.display.name='public' nested class -public.inner.class.problem.descriptor='public' nested class #ref #loc +public.inner.class.problem.descriptor='public' nested class #ref public.inner.class.ignore.enum.option=Ignore 'public' inner enums public.inner.class.ignore.interface.option=Ignore 'public' inner interfaces accessing.non.public.field.of.another.object.display.name=Accessing a non-public field of another object -accessing.non.public.field.of.another.object.problem.descriptor=Direct access to non-public field #ref of another object #loc +accessing.non.public.field.of.another.object.problem.descriptor=Direct access to non-public field #ref of another object call.to.date.tostring.display.name=Call to 'Date.toString()' -call.to.date.tostring.problem.descriptor=Date.#ref() used in an internationalized context #loc +call.to.date.tostring.problem.descriptor=Date.#ref() used in an internationalized context magic.character.display.name=Magic character -magic.character.problem.descriptor=Magic character #ref in an internationalized context #loc +magic.character.problem.descriptor=Magic character #ref in an internationalized context call.to.numeric.tostring.display.name=Call to 'Number.toString()' -call.to.numeric.tostring.problem.descriptor=Number.#ref() called in an internationalized context #loc +call.to.numeric.tostring.problem.descriptor=Number.#ref() called in an internationalized context instantiating.simpledateformat.without.locale.display.name='SimpleDateFormat' without locale -instantiating.simpledateformat.without.locale.problem.descriptor=Instantiating a #ref without specifying a Locale in an internationalized context #loc -instantiating.datetimeformatter.without.locale.problem.descriptor=Calling DateTimeFormatter.#ref() without specifying a Locale in an internationalized context #loc +instantiating.simpledateformat.without.locale.problem.descriptor=Instantiating a #ref without specifying a Locale in an internationalized context +instantiating.datetimeformatter.without.locale.problem.descriptor=Calling DateTimeFormatter.#ref() without specifying a Locale in an internationalized context string.concatenation.display.name=String concatenation -string.concatenation.problem.descriptor=String concatenation #ref in an internationalized context #loc +string.concatenation.problem.descriptor=String concatenation #ref in an internationalized context inspection.option.ignore.system.out=Ignore for 'System.out.print' arguments inspection.option.ignore.system.err=Ignore for 'System.err.print' arguments inspection.option.ignore.assert=Ignore for assert statement description arguments @@ -335,169 +335,169 @@ inspection.option.ignore.in.tostring=Ignore inside toString() methods inspection.option.ignore.as.initial.capacity=Ignore initial capacity for StringBuilders and Collections inspection.option.ignore.in.hashcode=Ignore constants in 'hashCode()' methods string.touppercase.tolowercase.without.locale.display.name=Call to 'String.toUpperCase()' or 'toLowerCase()' without locale -string.touppercase.tolowercase.without.locale.problem.descriptor=String.#ref() called without specifying a Locale using internationalized strings #loc +string.touppercase.tolowercase.without.locale.problem.descriptor=String.#ref() called without specifying a Locale using internationalized strings use.stringtokenizer.display.name=Use of 'StringTokenizer' -use.stringtokenizer.problem.descriptor=#ref in an internationalized context #loc +use.stringtokenizer.problem.descriptor=#ref in an internationalized context time.tostring.call.display.name=Call to 'Time.toString()' -time.tostring.call.problem.descriptor=Time.#ref() in an internationalized context #loc +time.tostring.call.problem.descriptor=Time.#ref() in an internationalized context class.escapes.defined.scope.display.name=Class is exposed outside of its visibility scope class.escapes.defined.scope.display.module.option=Report non-exported classes exposed in module API (Java 9+) class.escapes.defined.scope.display.public.option=Report non-accessible classes exposed in public API class.escapes.defined.scope.display.package.option=Report private classes exposed in package-local API -class.escapes.defined.scope.problem.descriptor=Class #ref is exposed outside its defined visibility scope #loc +class.escapes.defined.scope.problem.descriptor=Class #ref is exposed outside its defined visibility scope class.escapes.defined.scope.java9.modules.descriptor=Class #ref is not exported from module ''{0}'' field.name.hides.in.superclass.display.name=Subclass field hides superclass field -field.name.hides.in.superclass.problem.descriptor=Field #ref hides field in superclass #loc +field.name.hides.in.superclass.problem.descriptor=Field #ref hides field in superclass field.name.hides.in.superclass.ignore.option=Ignore non-accessible fields field.name.hides.in.superclass.ignore.static.field.option=Ignore static fields hiding static fields inner.class.field.hides.outer.display.name=Inner class field hides outer class field inner.class.field.hides.outer.ignore.option=Ignore outer fields not visible from inner class -inner.class.field.hides.outer.problem.descriptor=Inner class field #ref hides outer class field #loc +inner.class.field.hides.outer.problem.descriptor=Inner class field #ref hides outer class field local.variable.hides.member.variable.display.name=Local variable hides field -local.variable.hides.member.variable.problem.descriptor=Local variable #ref hides field in class ''{0}'' #loc +local.variable.hides.member.variable.problem.descriptor=Local variable #ref hides field in class ''{0}'' local.variable.hides.member.variable.ignore.option=Ignore local variables in a static context hiding non-static fields pattern.variable.hides.field.display.name=Pattern variable hides field -pattern.variable.hides.field.problem.descriptor=Pattern variable #ref hides field in class ''{0}'' #loc +pattern.variable.hides.field.problem.descriptor=Pattern variable #ref hides field in class ''{0}'' method.overloads.display.name=Possibly unintended overload of method from superclass -method.overloads.problem.descriptor=Method #ref() overloads a compatible method of a superclass, when overriding might have been intended #loc +method.overloads.problem.descriptor=Method #ref() overloads a compatible method of a superclass, when overriding might have been intended method.overloads.report.incompatible.option=Report even if parameter types are not compatible -method.overrides.private.display.name.problem.descriptor=Method #ref() overrides a 'private' method of a superclass #loc +method.overrides.private.display.name.problem.descriptor=Method #ref() overrides a 'private' method of a superclass method.overrides.static.display.name=Method tries to override 'static' method of superclass -method.overrides.static.problem.descriptor=Method #ref() tries to override a static method of a superclass #loc +method.overrides.static.problem.descriptor=Method #ref() tries to override a static method of a superclass parameter.hides.member.variable.display.name=Parameter hides field -parameter.hides.member.variable.problem.descriptor=Parameter #ref hides field in class ''{0}'' #loc +parameter.hides.member.variable.problem.descriptor=Parameter #ref hides field in class ''{0}'' parameter.hides.member.variable.ignore.setters.option=Ignore for property setters parameter.hides.member.variable.ignore.superclass.option=Ignore superclass fields not visible from subclass parameter.hides.member.variable.ignore.constructors.option=Ignore for constructors parameter.hides.member.variable.ignore.abstract.methods.option=Ignore for abstract methods parameter.hides.member.variable.ignore.static.parameters.option=Ignore for static method parameters hiding instance fields type.parameter.hides.visible.type.display.name=Type parameter hides visible type -type.parameter.hides.visible.type.problem.descriptor=Type parameter #ref hides visible type ''{0}'' #loc -type.parameter.hides.type.parameter.problem.descriptor=Type parameter #ref hides type parameter ''{0}'' #loc +type.parameter.hides.visible.type.problem.descriptor=Type parameter #ref hides visible type ''{0}'' +type.parameter.hides.type.parameter.problem.descriptor=Type parameter #ref hides type parameter ''{0}'' anonymous.class.variable.hides.containing.method.variable.display.name=Anonymous class variable hides variable in containing method -anonymous.class.parameter.hides.containing.method.variable.problem.descriptor=Anonymous class parameter #ref hides variable in containing method #loc -anonymous.class.field.hides.containing.method.variable.problem.descriptor=Anonymous class field #ref hides variable in containing method #loc -anonymous.class.variable.hides.containing.method.variable.problem.descriptor=Anonymous class local variable #ref hides variable in containing method #loc +anonymous.class.parameter.hides.containing.method.variable.problem.descriptor=Anonymous class parameter #ref hides variable in containing method +anonymous.class.field.hides.containing.method.variable.problem.descriptor=Anonymous class field #ref hides variable in containing method +anonymous.class.variable.hides.containing.method.variable.problem.descriptor=Anonymous class local variable #ref hides variable in containing method channel.opened.not.closed.display.name='Channel' opened but not safely closed drivermanager.call.display.name=Use of 'DriverManager' to get JDBC connection -drivermanager.call.problem.descriptor=Call to DriverManager.#ref() #loc +drivermanager.call.problem.descriptor=Call to DriverManager.#ref() hibernate.resource.opened.not.closed.display.name=Hibernate resource opened but not safely closed i.o.resource.opened.not.closed.display.name=I/O resource opened but not safely closed -resource.opened.not.closed.problem.descriptor=''{0}'' should be opened in front of a ''try'' block and closed in the corresponding ''finally'' block #loc +resource.opened.not.closed.problem.descriptor=''{0}'' should be opened in front of a ''try'' block and closed in the corresponding ''finally'' block jdbc.resource.opened.not.closed.display.name=JDBC resource opened but not safely closed jndi.resource.opened.not.closed.display.name=JNDI resource opened but not safely closed socket.opened.not.closed.display.name=Socket opened but not safely closed annotation.class.display.name=Annotation interface -annotation.class.problem.descriptor=Annotation interface #ref #loc +annotation.class.problem.descriptor=Annotation interface #ref annotation.display.name=Annotation -annotation.problem.descriptor=Annotation #ref #loc +annotation.problem.descriptor=Annotation #ref assert.statement.display.name='assert' statement -statement.problem.descriptor=#ref statement #loc +statement.problem.descriptor=#ref statement auto.boxing.display.name=Auto-boxing -auto.boxing.problem.descriptor=Auto-boxing #ref #loc +auto.boxing.problem.descriptor=Auto-boxing #ref auto.boxing.make.boxing.explicit.quickfix=Make boxing explicit auto.boxing.ignore.added.to.collection.option=Ignore expressions added to a collection auto.unboxing.display.name=Auto-unboxing -auto.unboxing.problem.descriptor=Auto-unboxing #ref #loc +auto.unboxing.problem.descriptor=Auto-unboxing #ref auto.unboxing.make.unboxing.explicit.quickfix=Make unboxing explicit enumerated.class.display.name=Enumerated class -enumerated.class.problem.descriptor=Enumerated class #ref #loc +enumerated.class.problem.descriptor=Enumerated class #ref extended.for.statement.display.name=Enhanced 'for' statement extended.for.statement.replace.quickfix=Replace with old-style 'for' statement variable.argument.method.display.name=Varargs method -variable.argument.method.problem.descriptor=Varargs method #ref() #loc +variable.argument.method.problem.descriptor=Varargs method #ref() variable.argument.method.quickfix=Convert varargs parameter to array hardcoded.file.separator.display.name=Hardcoded file separator -hardcoded.file.separator.problem.descriptor=Hardcoded file separator #ref #loc +hardcoded.file.separator.problem.descriptor=Hardcoded file separator #ref hardcoded.file.separator.include.option=Include 'example/*' in recognized MIME media types hardcoded.line.separator.display.name=Hardcoded line separator hardcoded.file.separator.ignore.methods.option=Ignore arguments for the following methods: -hardcoded.line.separator.problem.descriptor=Hardcoded line separator #ref #loc +hardcoded.line.separator.problem.descriptor=Hardcoded line separator #ref native.method.display.name=Native method -native.method.problem.descriptor=Methods declared #ref are non-portable #loc +native.method.problem.descriptor=Methods declared #ref are non-portable runtime.exec.call.display.name=Call to 'Runtime.exec()' -runtime.exec.call.problem.descriptor=Call to Runtime.#ref() is non-portable #loc +runtime.exec.call.problem.descriptor=Call to Runtime.#ref() is non-portable system.exit.call.display.name=Call to 'System.exit()' or related methods -system.exit.call.problem.descriptor=Call to {0}.#ref() is non-portable #loc +system.exit.call.problem.descriptor=Call to {0}.#ref() is non-portable system.exit.call.ignore.option=Ignore in main method system.getenv.call.display.name=Call to 'System.getenv()' -system.getenv.call.problem.descriptor=Call to System.#ref() is non-portable #loc +system.getenv.call.problem.descriptor=Call to System.#ref() is non-portable use.of.awt.peer.class.display.name=Use of AWT peer class -use.of.awt.peer.class.problem.descriptor=Use of AWT peer class #ref is non-portable #loc +use.of.awt.peer.class.problem.descriptor=Use of AWT peer class #ref is non-portable use.of.concrete.jdbc.driver.class.display.name=Use of concrete JDBC driver class -use.of.concrete.jdbc.driver.class.problem.descriptor=Use of concrete JDBC driver class #ref is non-portable #loc +use.of.concrete.jdbc.driver.class.problem.descriptor=Use of concrete JDBC driver class #ref is non-portable use.processbuilder.class.display.name=Use of 'java.lang.ProcessBuilder' class -use.processbuilder.class.problem.descriptor=Use of #ref is non-portable #loc +use.processbuilder.class.problem.descriptor=Use of #ref is non-portable use.sun.classes.display.name=Use of 'sun.*' classes -use.sun.classes.problem.descriptor=Use of Sun-supplied class #ref is non-portable #loc +use.sun.classes.problem.descriptor=Use of Sun-supplied class #ref is non-portable abstract.class.with.only.one.direct.inheritor.display.name=Abstract class with a single direct inheritor anonymous.inner.may.be.named.static.inner.class.display.name=Anonymous class may be a named 'static' inner class -anonymous.inner.may.be.named.static.inner.class.problem.descriptor=Anonymous class #ref may be a named 'static' inner class #loc +anonymous.inner.may.be.named.static.inner.class.problem.descriptor=Anonymous class #ref may be a named 'static' inner class array.length.in.loop.condition.display.name=Array.length in loop condition -array.length.in.loop.condition.problem.descriptor=Check of array #ref in loop condition #loc +array.length.in.loop.condition.problem.descriptor=Check of array #ref in loop condition large.array.allocation.no.outofmemoryerror.display.name=Large array allocation with no OutOfMemoryError check -large.array.allocation.no.outofmemoryerror.problem.descriptor=Large array allocation which is not checked for out-of-memory condition #loc +large.array.allocation.no.outofmemoryerror.problem.descriptor=Large array allocation which is not checked for out-of-memory condition large.array.allocation.no.outofmemoryerror.maximum.number.of.elements.option=Maximum number of elements: connection.opened.not.safely.closed.display.name=Connection opened but not safely closed interface.one.inheritor.display.name=Interface with a single direct inheritor -interface.one.inheritor.problem.descriptor=Interface #ref has only one direct inheritor #loc +interface.one.inheritor.problem.descriptor=Interface #ref has only one direct inheritor method.call.in.loop.condition.display.name=Method call in loop condition -method.call.in.loop.condition.problem.descriptor=Call to method #ref() in loop condition #loc +method.call.in.loop.condition.problem.descriptor=Call to method #ref() in loop condition large.initializer.primitive.type.array.display.name=Overly large initializer for array of primitive type -large.initializer.primitive.type.array.problem.descriptor=Primitive array initializer with too many elements ({0}) #loc +large.initializer.primitive.type.array.problem.descriptor=Primitive array initializer with too many elements ({0}) large.initializer.primitive.type.array.maximum.number.of.elements.option=Maximum number of elements: private.member.access.between.outer.and.inner.classes.display.name=Synthetic accessor call -private.member.access.between.outer.and.inner.classes.problem.descriptor=Access to ''private'' member of class ''{0}'' requires synthetic accessor #loc +private.member.access.between.outer.and.inner.classes.problem.descriptor=Access to ''private'' member of class ''{0}'' requires synthetic accessor private.member.access.between.outer.and.inner.classes.make.local.quickfix=Make ''{0}'' package-private private.member.access.between.outer.and.inner.classes.make.constructor.package.local.quickfix=Make ''{0}'' constructor package-private recordstore.opened.not.safely.closed.display.name='RecordStore' opened but not safely closed overly.complex.anonymous.inner.class.display.name=Overly complex anonymous class cyclomatic.complexity.limit.option=Cyclomatic complexity limit: -overly.complex.anonymous.inner.class.problem.descriptor=Overly complex anonymous class (cyclomatic complexity = {0}) #loc +overly.complex.anonymous.inner.class.problem.descriptor=Overly complex anonymous class (cyclomatic complexity = {0}) anonymous.inner.class.with.too.many.methods.display.name=Anonymous class with too many methods method.count.limit.option=Method count limit: -anonymous.inner.class.with.too.many.methods.problem.descriptor=Anonymous class with too many methods (method count = {0}) #loc +anonymous.inner.class.with.too.many.methods.problem.descriptor=Anonymous class with too many methods (method count = {0}) overly.complex.class.display.name=Overly complex class -overly.complex.class.problem.descriptor=Overly complex class #ref (cyclomatic complexity = {0}) #loc +overly.complex.class.problem.descriptor=Overly complex class #ref (cyclomatic complexity = {0}) overly.coupled.class.display.name=Overly coupled class overly.coupled.class.class.coupling.limit.option=Class coupling limit: include.java.system.classes.option=Include couplings to java system classes include.library.classes.option=Include couplings to library classes -overly.coupled.class.problem.descriptor=#ref is overly coupled (dependencies = {0}) #loc +overly.coupled.class.problem.descriptor=#ref is overly coupled (dependencies = {0}) class.too.deep.display.name=Class too deep in inheritance tree class.too.deep.inheritance.depth.limit.option=Inheritance depth limit: -class.too.deep.problem.descriptor=#ref is too deep in inheritance tree (inheritance depth = {0}) #loc +class.too.deep.problem.descriptor=#ref is too deep in inheritance tree (inheritance depth = {0}) inner.class.too.deeply.nested.display.name=Inner class too deeply nested inner.class.too.deeply.nested.nesting.limit.option=Nesting limit: -inner.class.too.deeply.nested.problem.descriptor=#ref is too deeply nested (nesting level = {0}) #loc +inner.class.too.deeply.nested.problem.descriptor=#ref is too deeply nested (nesting level = {0}) too.many.constructors.display.name=Class with too many constructors too.many.constructors.count.limit.option=Constructor count limit: too.many.constructors.ignore.deprecated.option=Ignore deprecated constructors -too.many.constructors.problem.descriptor=#ref has too many constructors (constructor count = {0}) #loc +too.many.constructors.problem.descriptor=#ref has too many constructors (constructor count = {0}) too.many.fields.display.name=Class with too many fields too.many.fields.count.limit.option=Field count limit: -too.many.fields.problem.descriptor=#ref has too many fields (field count = {0}) #loc +too.many.fields.problem.descriptor=#ref has too many fields (field count = {0}) too.many.methods.display.name=Class with too many methods -too.many.methods.problem.descriptor=#ref has too many methods (method count = {0}) #loc +too.many.methods.problem.descriptor=#ref has too many methods (method count = {0}) externalizable.with.serialization.methods.display.name=Externalizable class with 'readObject()' or 'writeObject()' -externalizable.with.serialization.methods.problem.descriptor.both=Externalizable {0, choice, 1#class|2#interface|3#anonymous class derived from|4#annotation type|5#enum|6#record} #ref defines ''readObject()'' and ''writeObject()'' #loc -externalizable.with.serialization.methods.problem.descriptor.write=Externalizable {0, choice, 1#class|2#interface|3#anonymous class derived from|4#annotation type|5#enum|6#record} #ref defines ''writeObject()'' #loc -externalizable.with.serialization.methods.problem.descriptor.read=Externalizable {0, choice, 1#class|2#interface|3#anonymous class derived from|4#annotation type|5#enum|6#record} #ref defines ''readObject()'' #loc +externalizable.with.serialization.methods.problem.descriptor.both=Externalizable {0, choice, 1#class|2#interface|3#anonymous class derived from|4#annotation type|5#enum|6#record} #ref defines ''readObject()'' and ''writeObject()'' +externalizable.with.serialization.methods.problem.descriptor.write=Externalizable {0, choice, 1#class|2#interface|3#anonymous class derived from|4#annotation type|5#enum|6#record} #ref defines ''writeObject()'' +externalizable.with.serialization.methods.problem.descriptor.read=Externalizable {0, choice, 1#class|2#interface|3#anonymous class derived from|4#annotation type|5#enum|6#record} #ref defines ''readObject()'' non.serializable.with.serialversionuid.display.name=Non-serializable class with 'serialVersionUID' -non.serializable.class.with.serialversionuid.problem.descriptor=Non-serializable class #ref defines a 'serialVersionUID' field #loc -non.serializable.interface.with.serialversionuid.problem.descriptor=Non-serializable interface #ref defines a 'serialVersionUID' field #loc -non.serializable.@interface.with.serialversionuid.problem.descriptor=Non-serializable @interface #ref defines a 'serialVersionUID' field #loc -non.serializable.anonymous.with.serialversionuid.problem.descriptor=Non-serializable anonymous class derived from #ref defines a 'serialVersionUID' field #loc +non.serializable.class.with.serialversionuid.problem.descriptor=Non-serializable class #ref defines a 'serialVersionUID' field +non.serializable.interface.with.serialversionuid.problem.descriptor=Non-serializable interface #ref defines a 'serialVersionUID' field +non.serializable.@interface.with.serialversionuid.problem.descriptor=Non-serializable @interface #ref defines a 'serialVersionUID' field +non.serializable.anonymous.with.serialversionuid.problem.descriptor=Non-serializable anonymous class derived from #ref defines a 'serialVersionUID' field non.serializable.class.with.readwriteobject.display.name=Non-serializable class with 'readObject()' or 'writeObject()' -non.serializable.class.with.readwriteobject.problem.descriptor.both=Non-serializable {0, choice, 1#class|2#interface|3#anonymous class derived from|4#annotation type|5#enum|6#record} #ref defines ''readObject()'' and ''writeObject()'' #loc -non.serializable.class.with.readwriteobject.problem.descriptor.write=Non-serializable {0, choice, 1#class|2#interface|3#anonymous class derived from|4#annotation type|5#enum|6#record} #ref defines ''writeObject()'' #loc -non.serializable.class.with.readwriteobject.problem.descriptor.read=Non-serializable {0, choice, 1#class|2#interface|3#anonymous class derived from|4#annotation type|5#enum|6#record} #ref defines ''readObject()'' #loc +non.serializable.class.with.readwriteobject.problem.descriptor.both=Non-serializable {0, choice, 1#class|2#interface|3#anonymous class derived from|4#annotation type|5#enum|6#record} #ref defines ''readObject()'' and ''writeObject()'' +non.serializable.class.with.readwriteobject.problem.descriptor.write=Non-serializable {0, choice, 1#class|2#interface|3#anonymous class derived from|4#annotation type|5#enum|6#record} #ref defines ''writeObject()'' +non.serializable.class.with.readwriteobject.problem.descriptor.read=Non-serializable {0, choice, 1#class|2#interface|3#anonymous class derived from|4#annotation type|5#enum|6#record} #ref defines ''readObject()'' readwriteobject.private.display.name='readObject()' or 'writeObject()' not declared 'private' -readwriteobject.private.problem.descriptor=#ref not declared 'private' #loc +readwriteobject.private.problem.descriptor=#ref not declared 'private' readobject.initialization.display.name=Instance field may not be initialized by 'readObject()' -readobject.initialization.problem.descriptor=Instance field #ref may not be initialized during 'readObject()' call #loc +readobject.initialization.problem.descriptor=Instance field #ref may not be initialized during 'readObject()' call readresolve.writereplace.protected.display.name='readResolve()' or 'writeReplace()' not declared 'protected' -readresolve.writereplace.protected.problem.descriptor=#ref() not declared 'protected' #loc +readresolve.writereplace.protected.problem.descriptor=#ref() not declared 'protected' missing.serial.annotation.display.name='@Serial' annotation can be used missing.serial.annotation.on.field.problem.descriptor=#ref can be annotated with '@Serial' annotation missing.serial.annotation.on.method.problem.descriptor=#ref() can be annotated with '@Serial' annotation @@ -507,9 +507,9 @@ serializable.record.contains.ignored.members.display.name='record' contains igno serializable.record.contains.ignored.field.problem.descriptor=#ref will be ignored during record serialization serializable.record.contains.ignored.method.problem.descriptor=#ref() will be ignored during record serialization serialpersistentfields.with.wrong.signature.display.name='serialPersistentFields' field not declared 'private static final ObjectStreamField[]' -serialpersistentfields.with.wrong.signature.problem.descriptor=#ref field of a Serializable class is not declared 'private static final ObjectStreamField[]' #loc +serialpersistentfields.with.wrong.signature.problem.descriptor=#ref field of a Serializable class is not declared 'private static final ObjectStreamField[]' serialversionuid.private.static.final.long.display.name='serialVersionUID' field not declared 'private static final long' -serialversionuid.private.static.final.long.problem.descriptor=#ref field of a Serializable class is not declared 'private static final long' #loc +serialversionuid.private.static.final.long.problem.descriptor=#ref field of a Serializable class is not declared 'private static final long' serialversionuid.private.static.final.long.quickfix=Make serialVersionUID 'private static final' #dynamic @@ -665,7 +665,7 @@ nested.try.statement.display.name=Nested 'try' statement condition.signal.display.name=Call to 'signal()' instead of 'signalAll()' jdbc.execute.with.non.constant.string.display.name=Call to 'Statement.execute()' with non-constant string system.set.security.manager.display.name=Call to 'System.setSecurityManager()' -system.set.security.manager.problem.descriptor=Call to System.#ref() may pose security concerns #loc +system.set.security.manager.problem.descriptor=Call to System.#ref() may pose security concerns control.flow.statement.without.braces.display.name=Control flow statement without braces trivial.if.display.name=Redundant 'if' statement trivial.if.fix.family.name=Simplify 'if else' @@ -746,7 +746,7 @@ unchecked.exception.class.display.name=Unchecked 'Exception' class for.loop.with.missing.component.display.name='for' loop with missing components for.loop.with.missing.component.collection.loop.option=Ignore collection iterations double.checked.locking.display.name=Double-checked locking -double.checked.locking.problem.descriptor=Double-checked locking #loc +double.checked.locking.problem.descriptor=Double-checked locking string.buffer.replaceable.by.string.display.name='StringBuilder' can be replaced with 'String' boolean.method.name.must.start.with.question.display.name=Boolean method name must start with question word class.name.same.as.ancestor.name.display.name=Class name same as ancestor name @@ -828,345 +828,345 @@ constant.declared.in.interface.display.name=Constant declared in interface #problem descriptors -exception.name.doesnt.end.with.exception.problem.descriptor=Exception class name #ref does not end with 'Exception' #loc -non.exception.name.ends.with.exception.problem.descriptor=Non-exception class name #ref ends with 'Exception' #loc -class.name.prefixed.with.package.name.problem.descriptor=Class name #ref begins with its package name #loc -class.name.same.as.ancestor.name.problem.descriptor=Class name #ref is the same as one of its superclass' names #loc -method.name.same.as.class.name.problem.descriptor=Method name #ref is the same as its class name #loc -method.name.same.as.parent.name.problem.descriptor=Method name #ref is the same as its parent class name #loc -boolean.method.name.must.start.with.question.problem.descriptor=Boolean method name #ref does not start with question word #loc -questionable.name.problem.descriptor=Questionable name #ref #loc -confusing.main.method.problem.descriptor=Method #ref() does not have signature 'public static void main(String[])' #loc +exception.name.doesnt.end.with.exception.problem.descriptor=Exception class name #ref does not end with 'Exception' +non.exception.name.ends.with.exception.problem.descriptor=Non-exception class name #ref ends with 'Exception' +class.name.prefixed.with.package.name.problem.descriptor=Class name #ref begins with its package name +class.name.same.as.ancestor.name.problem.descriptor=Class name #ref is the same as one of its superclass' names +method.name.same.as.class.name.problem.descriptor=Method name #ref is the same as its class name +method.name.same.as.parent.name.problem.descriptor=Method name #ref is the same as its parent class name +boolean.method.name.must.start.with.question.problem.descriptor=Boolean method name #ref does not start with question word +questionable.name.problem.descriptor=Questionable name #ref +confusing.main.method.problem.descriptor=Method #ref() does not have signature 'public static void main(String[])' unrunnable.main.method.problem.descriptor=Method #ref() can't be run because the containing class does not have a fully qualified name -upper.case.field.name.not.constant.problem.descriptor=Non-constant field #ref with constant-style name #loc -dollar.sign.in.name.problem.descriptor=Identifier #ref contains '$' #loc -integer.division.in.floating.point.context.problem.descriptor=#ref: integer division in floating-point context #loc +upper.case.field.name.not.constant.problem.descriptor=Non-constant field #ref with constant-style name +dollar.sign.in.name.problem.descriptor=Identifier #ref contains '$' +integer.division.in.floating.point.context.problem.descriptor=#ref: integer division in floating-point context integer.division.in.floating.point.context.fix.family.name=Cast the numerator to a floating-point type integer.division.in.floating.point.context.fix.name=Cast the numerator to ''{0}'' inspection.lossy.conversion.compound.assignment.name=Possibly lossy implicit cast in compound assignment inspection.lossy.conversion.compound.assignment.display.name=Implicit cast from ''{0}'' to ''{1}'' in compound assignment can be lossy -comparison.of.short.and.char.problem.descriptor=Equality comparison #ref of short and char values #loc -big.decimal.equals.problem.descriptor=#ref() between BigDecimal values should probably be 'compareTo()' #loc -divide.by.zero.problem.descriptor=Division by zero #loc -divide.by.zero.problem.may.descriptor=Possible division by zero #loc +comparison.of.short.and.char.problem.descriptor=Equality comparison #ref of short and char values +big.decimal.equals.problem.descriptor=#ref() between BigDecimal values should probably be 'compareTo()' +divide.by.zero.problem.descriptor=Division by zero +divide.by.zero.problem.may.descriptor=Possible division by zero divide.by.zero.problem.may.option=Report conditional divide-by-zero divide.by.zero.problem.may.option.description=Highlights divisions that can become zero in some execution branches divide.by.zero.problem.may.option.disabled=Don't suggest conditional divide-by-zero problems -non.reproducible.math.call.problem.descriptor=Math.#ref() may produce non-reproducible results #loc -constant.math.call.problem.descriptor=Constant call to #ref() can be simplified #loc -floating.point.equality.problem.descriptor=#ref: floating-point values compared for exact equality #loc -fallthru.in.switch.statement.problem.descriptor=Fallthrough in 'switch' statement #loc -switch.statements.without.default.problem.descriptor=#ref statement without 'default' branch #loc -default.not.last.case.in.switch.problem.descriptor=''default'' branch not last case in ''switch'' {0} #loc -loop.statements.that.dont.loop.problem.descriptor=#ref statement does not loop #loc -conditional.expression.with.identical.branches.problem.descriptor=Conditional expression #ref with identical branches #loc -conditional.can.be.pushed.inside.expression.problem.descriptor=Conditional expression can be pushed inside branch #loc -duplicate.condition.problem.descriptor=Duplicate condition #ref #loc +non.reproducible.math.call.problem.descriptor=Math.#ref() may produce non-reproducible results +constant.math.call.problem.descriptor=Constant call to #ref() can be simplified +floating.point.equality.problem.descriptor=#ref: floating-point values compared for exact equality +fallthru.in.switch.statement.problem.descriptor=Fallthrough in 'switch' statement +switch.statements.without.default.problem.descriptor=#ref statement without 'default' branch +default.not.last.case.in.switch.problem.descriptor=''default'' branch not last case in ''switch'' {0} +loop.statements.that.dont.loop.problem.descriptor=#ref statement does not loop +conditional.expression.with.identical.branches.problem.descriptor=Conditional expression #ref with identical branches +conditional.can.be.pushed.inside.expression.problem.descriptor=Conditional expression can be pushed inside branch +duplicate.condition.problem.descriptor=Duplicate condition #ref duplicate.condition.ignore.method.calls.option=Ignore conditions with possible side effects duplicate.condition.ignore.method.calls.option.description=If checked, conditions with potential side effects (for example, unknown method calls) will not be reported. Methods that are known to produce side effects will not be reported in any case. -iterator.next.does.not.throw.nosuchelementexception.problem.descriptor=Iterator.#ref() which can't throw 'NoSuchElementException' #loc -infinite.loop.statement.problem.descriptor=#ref statement cannot complete without throwing an exception #loc -confusing.floating.point.literal.problem.descriptor=Confusing floating-point literal #ref #loc -overly.complex.arithmetic.expression.problem.descriptor=Overly complex arithmetic expression #loc -overly.complex.boolean.expression.problem.descriptor=Overly complex boolean expression ({0} terms) #loc -labeled.statement.problem.descriptor=Labeled statement #ref: #loc -break.statement.with.label.problem.descriptor=#ref statement with label #loc -continue.statement.with.label.problem.descriptor=#ref statement with label #loc -conditional.expression.problem.descriptor=Conditional expression #ref #loc +iterator.next.does.not.throw.nosuchelementexception.problem.descriptor=Iterator.#ref() which can't throw 'NoSuchElementException' +infinite.loop.statement.problem.descriptor=#ref statement cannot complete without throwing an exception +confusing.floating.point.literal.problem.descriptor=Confusing floating-point literal #ref +overly.complex.arithmetic.expression.problem.descriptor=Overly complex arithmetic expression +overly.complex.boolean.expression.problem.descriptor=Overly complex boolean expression ({0} terms) +labeled.statement.problem.descriptor=Labeled statement #ref: +break.statement.with.label.problem.descriptor=#ref statement with label +continue.statement.with.label.problem.descriptor=#ref statement with label +conditional.expression.problem.descriptor=Conditional expression #ref conditional.expression.option=Ignore for simple assignments and returns conditional.expression.expression.context.option=Ignore places where an if statement is not possible conditional.expression.quickfix=Replace with 'if' statement -nested.conditional.expression.problem.descriptor=Nested conditional expression #ref #loc -long.literals.ending.with.lowercase.l.problem.descriptor='long' literal #ref ends with lowercase 'l' #loc -nested.switch.statement.problem.descriptor=Nested #ref {0} #loc -chained.method.call.problem.descriptor=Chained method call #ref() #loc -nested.method.call.problem.descriptor=Nested method call #ref() #loc -octal.literal.problem.descriptor=Octal integer #ref #loc -implicit.call.to.super.problem.descriptor=Implicit call to 'super()' #loc -negated.if.else.problem.descriptor=#ref statement with negated condition #loc -negated.conditional.problem.descriptor=Conditional expression with negated condition #loc -redundant.else.problem.descriptor=#ref branch may be unwrapped, as the 'if' branch never completes normally #loc -switch.statement.with.confusing.declaration.problem.descriptor=Local variable #ref declared in one 'switch' branch and used in another #loc -final.class.problem.descriptor=Class ''{0}'' declared #ref #loc -empty.class.problem.descriptor=Class #ref is empty #loc -empty.enum.problem.descriptor=Enum #ref is empty #loc -empty.class.file.without.class.problem.descriptor=Java file does not declare any class #loc -empty.anonymous.class.problem.descriptor=Anonymous class is empty #loc -anonymous.inner.class.problem.descriptor=Anonymous class #ref #loc -limited.scope.inner.class.problem.descriptor=Local class #ref #loc -final.method.problem.descriptor=Method declared #ref #loc -class.initializer.problem.descriptor=Non-'static' initializer #loc -class.may.be.interface.problem.descriptor=Abstract class #ref may be interface #loc -non.protected.constructor.in.abstract.class.problem.descriptor=Constructor #ref() of an abstract class should not be declared 'public' #loc -class.without.constructor.problem.descriptor=Class #ref has no constructor #loc -abstract.class.without.abstract.methods.problem.descriptor=Class #ref is declared 'abstract', and has no 'abstract' methods #loc +nested.conditional.expression.problem.descriptor=Nested conditional expression #ref +long.literals.ending.with.lowercase.l.problem.descriptor='long' literal #ref ends with lowercase 'l' +nested.switch.statement.problem.descriptor=Nested #ref {0} +chained.method.call.problem.descriptor=Chained method call #ref() +nested.method.call.problem.descriptor=Nested method call #ref() +octal.literal.problem.descriptor=Octal integer #ref +implicit.call.to.super.problem.descriptor=Implicit call to 'super()' +negated.if.else.problem.descriptor=#ref statement with negated condition +negated.conditional.problem.descriptor=Conditional expression with negated condition +redundant.else.problem.descriptor=#ref branch may be unwrapped, as the 'if' branch never completes normally +switch.statement.with.confusing.declaration.problem.descriptor=Local variable #ref declared in one 'switch' branch and used in another +final.class.problem.descriptor=Class ''{0}'' declared #ref +empty.class.problem.descriptor=Class #ref is empty +empty.enum.problem.descriptor=Enum #ref is empty +empty.class.file.without.class.problem.descriptor=Java file does not declare any class +empty.anonymous.class.problem.descriptor=Anonymous class is empty +anonymous.inner.class.problem.descriptor=Anonymous class #ref +limited.scope.inner.class.problem.descriptor=Local class #ref +final.method.problem.descriptor=Method declared #ref +class.initializer.problem.descriptor=Non-'static' initializer +class.may.be.interface.problem.descriptor=Abstract class #ref may be interface +non.protected.constructor.in.abstract.class.problem.descriptor=Constructor #ref() of an abstract class should not be declared 'public' +class.without.constructor.problem.descriptor=Class #ref has no constructor +abstract.class.without.abstract.methods.problem.descriptor=Class #ref is declared 'abstract', and has no 'abstract' methods abstract.class.without.abstract.methods.ignore.utility.class.option=Ignore utility classes -final.method.in.final.class.problem.descriptor=Method declared #ref in 'final' class #loc -protected.member.in.final.class.problem.descriptor=Class member declared #ref in 'final' class #loc -utility.class.with.public.constructor.problem.descriptor=Class #ref has only 'static' members, and a 'public' constructor #loc -utility.class.without.private.constructor.problem.descriptor=Class #ref has only 'static' members, and lacks a 'private' constructor #loc -abstract.method.overrides.concrete.method.problem.descriptor=Abstract method #ref() overrides concrete method #loc -abstract.method.with.missing.implementations.problem.descriptor=Abstract method #ref() is not implemented in every subclass #loc -abstract.method.overrides.abstract.method.problem.descriptor=Abstract method #ref() overrides abstract method #loc +final.method.in.final.class.problem.descriptor=Method declared #ref in 'final' class +protected.member.in.final.class.problem.descriptor=Class member declared #ref in 'final' class +utility.class.with.public.constructor.problem.descriptor=Class #ref has only 'static' members, and a 'public' constructor +utility.class.without.private.constructor.problem.descriptor=Class #ref has only 'static' members, and lacks a 'private' constructor +abstract.method.overrides.concrete.method.problem.descriptor=Abstract method #ref() overrides concrete method +abstract.method.with.missing.implementations.problem.descriptor=Abstract method #ref() is not implemented in every subclass +abstract.method.overrides.abstract.method.problem.descriptor=Abstract method #ref() overrides abstract method abstract.method.overrides.abstract.method.ignore.different.javadoc.option=Ignore methods with different Javadoc than their super methods -abstract.class.extends.concrete.class.problem.descriptor=Class #ref is declared 'abstract', and extends a concrete class #loc -static.non.final.field.problem.descriptor='static' non-'final' field #ref #loc -constant.declared.in.abstract.class.problem.descriptor=Constant #ref declared in abstract class #loc -constant.declared.in.interface.problem.descriptor=Constant #ref declared in interface #loc -static.inheritance.problem.descriptor=Interface #ref is implemented only for its static constants #loc -utility.class.problem.descriptor=Class #ref has only 'static' members, indicating procedural construction #loc -singleton.problem.descriptor=Class #ref is a singleton #loc -enum.singleton.problem.descriptor=Enum #ref is a singleton #loc -final.private.method.problem.descriptor='private' method declared #ref #loc -noop.method.in.abstract.class.problem.descriptor=No-op Method #ref() should be made abstract #loc -final.static.method.problem.descriptor='static' method declared #ref #loc -class.without.no.arg.constructor.problem.descriptor=Class #ref is missing a no-arg constructor #loc +abstract.class.extends.concrete.class.problem.descriptor=Class #ref is declared 'abstract', and extends a concrete class +static.non.final.field.problem.descriptor='static' non-'final' field #ref +constant.declared.in.abstract.class.problem.descriptor=Constant #ref declared in abstract class +constant.declared.in.interface.problem.descriptor=Constant #ref declared in interface +static.inheritance.problem.descriptor=Interface #ref is implemented only for its static constants +utility.class.problem.descriptor=Class #ref has only 'static' members, indicating procedural construction +singleton.problem.descriptor=Class #ref is a singleton +enum.singleton.problem.descriptor=Enum #ref is a singleton +final.private.method.problem.descriptor='private' method declared #ref +noop.method.in.abstract.class.problem.descriptor=No-op Method #ref() should be made abstract +final.static.method.problem.descriptor='static' method declared #ref +class.without.no.arg.constructor.problem.descriptor=Class #ref is missing a no-arg constructor multiple.top.level.classes.in.file.problem.descriptor=Multiple top level classes in file -class.name.differs.from.file.name.problem.descriptor=Class name #ref differs from file name #loc -marker.interface.problem.descriptor=Marker interface #ref #loc -field.has.setter.but.no.getter.problem.descriptor=Field #ref has setter but no getter #loc -abstract.class.never.implemented.problem.descriptor=Abstract class #ref has no concrete subclass #loc -interface.never.implemented.problem.descriptor=Interface #ref has no concrete subclass #loc -missing.deprecated.annotation.problem.descriptor=Missing '@Deprecated' annotation #loc -missing.deprecated.tag.problem.descriptor=Missing '@deprecated' Javadoc tag explanation #loc +class.name.differs.from.file.name.problem.descriptor=Class name #ref differs from file name +marker.interface.problem.descriptor=Marker interface #ref +field.has.setter.but.no.getter.problem.descriptor=Field #ref has setter but no getter +abstract.class.never.implemented.problem.descriptor=Abstract class #ref has no concrete subclass +interface.never.implemented.problem.descriptor=Interface #ref has no concrete subclass +missing.deprecated.annotation.problem.descriptor=Missing '@Deprecated' annotation +missing.deprecated.tag.problem.descriptor=Missing '@deprecated' Javadoc tag explanation missing.deprecated.tag.option=Warn on missing @deprecated Javadoc tag explanation -missing.override.annotation.problem.descriptor=Missing '@Override' annotation on #ref() #loc +missing.override.annotation.problem.descriptor=Missing '@Override' annotation on #ref() missing.override.annotation.in.overriding.problem.descriptor=Overriding methods are not annotated with '@Override' -non.thread.safe.lazy.initialization.problem.descriptor=Lazy initialization of 'static' field #ref is not thread-safe #loc +non.thread.safe.lazy.initialization.problem.descriptor=Lazy initialization of 'static' field #ref is not thread-safe missing.override.warn.on.super.option=Highlight method when its overriding methods do not all have the '@Override' annotation -empty.finally.block.problem.descriptor=Empty #ref block #loc -finally.block.cannot.complete.normally.problem.descriptor=#ref block can not complete normally #loc -empty.try.block.problem.descriptor=Empty #ref block #loc -throw.from.finally.block.problem.descriptor=#ref inside 'finally' block #loc -possible.throw.from.finally.block.problem.descriptor={0} might be thrown inside ''finally'' block #loc +empty.finally.block.problem.descriptor=Empty #ref block +finally.block.cannot.complete.normally.problem.descriptor=#ref block can not complete normally +empty.try.block.problem.descriptor=Empty #ref block +throw.from.finally.block.problem.descriptor=#ref inside 'finally' block +possible.throw.from.finally.block.problem.descriptor={0} might be thrown inside ''finally'' block throw,from.finally.block.everywhere.option=Warn everywhere declared exceptions may be thrown -throw.caught.locally.problem.descriptor=#ref caught by containing 'try' statement #loc +throw.caught.locally.problem.descriptor=#ref caught by containing 'try' statement throw.caught.locally.ignore.option=Ignore rethrown exceptions -return.from.finally.block.problem.descriptor='return' inside 'finally' block #loc -continue.or.break.from.finally.block.problem.descriptor=#ref inside 'finally' block #loc -bad.exception.declared.problem.descriptor=Prohibited exception #ref declared #loc -bad.exception.caught.problem.descriptor=Prohibited exception #ref caught #loc -checked.exception.class.problem.descriptor=Checked exception class #ref #loc -unchecked.exception.class.problem.descriptor=Unchecked exception class #ref #loc -thread.death.rethrown.problem.descriptor=ThreadDeath #ref not rethrown #loc -error.rethrown.problem.descriptor=Error #ref not rethrown #loc -nested.try.statement.problem.descriptor=Nested #ref statement #loc -exception.from.catch.which.doesnt.wrap.problem.descriptor=#ref inside 'catch' block ignores the caught exception #loc -instanceof.catch.parameter.problem.descriptor='instanceof' on 'catch' parameter #ref #loc -non.final.field.of.exception.problem.descriptor=Non-final field #ref of exception class #loc -unnecessary.label.on.break.statement.problem.descriptor=Unnecessary label #ref on break statement #loc -unnecessary.label.on.continue.statement.problem.descriptor=Unnecessary label #ref on continue statement #loc -trivial.if.problem.descriptor=#ref statement can be simplified #loc -unnecessary.parentheses.problem.descriptor=Parentheses around #ref are unnecessary #loc -unnecessary.local.variable.problem.descriptor=Local variable #ref is redundant #loc -unnecessary.this.problem.descriptor=#ref is unnecessary in this context #loc -unnecessary.block.statement.problem.descriptor=Braces around this statement are unnecessary #loc -unnecessary.continue.problem.descriptor=#ref is unnecessary as the last statement in a loop #loc -unnecessary.semicolon.problem.descriptor=Unnecessary semicolon #ref #loc +return.from.finally.block.problem.descriptor='return' inside 'finally' block +continue.or.break.from.finally.block.problem.descriptor=#ref inside 'finally' block +bad.exception.declared.problem.descriptor=Prohibited exception #ref declared +bad.exception.caught.problem.descriptor=Prohibited exception #ref caught +checked.exception.class.problem.descriptor=Checked exception class #ref +unchecked.exception.class.problem.descriptor=Unchecked exception class #ref +thread.death.rethrown.problem.descriptor=ThreadDeath #ref not rethrown +error.rethrown.problem.descriptor=Error #ref not rethrown +nested.try.statement.problem.descriptor=Nested #ref statement +exception.from.catch.which.doesnt.wrap.problem.descriptor=#ref inside 'catch' block ignores the caught exception +instanceof.catch.parameter.problem.descriptor='instanceof' on 'catch' parameter #ref +non.final.field.of.exception.problem.descriptor=Non-final field #ref of exception class +unnecessary.label.on.break.statement.problem.descriptor=Unnecessary label #ref on break statement +unnecessary.label.on.continue.statement.problem.descriptor=Unnecessary label #ref on continue statement +trivial.if.problem.descriptor=#ref statement can be simplified +unnecessary.parentheses.problem.descriptor=Parentheses around #ref are unnecessary +unnecessary.local.variable.problem.descriptor=Local variable #ref is redundant +unnecessary.this.problem.descriptor=#ref is unnecessary in this context +unnecessary.block.statement.problem.descriptor=Braces around this statement are unnecessary +unnecessary.continue.problem.descriptor=#ref is unnecessary as the last statement in a loop +unnecessary.semicolon.problem.descriptor=Unnecessary semicolon #ref unnecessary.semicolon.ignore.after.enum.constants.option=Ignore unnecessary semicolons after enum constants -unnecessary.fully.qualified.name.problem.descriptor1=Qualifier #ref is unnecessary, and can be replaced with an import #loc -unnecessary.fully.qualified.name.problem.descriptor2=Qualifier #ref is unnecessary and can be removed #loc -unnecessary.qualifier.for.this.problem.descriptor=Qualifier #ref on 'this' is unnecessary in this context #loc -unnecessary.qualifier.for.super.problem.descriptor=Qualifier #ref on 'super' is unnecessary in this context #loc -unused.label.problem.descriptor=Unused label #ref #loc -redundant.field.initialization.problem.descriptor=Field initialization to #ref is redundant #loc -redundant.implements.problem.descriptor=Redundant interface declaration #ref #loc -extends.object.problem.descriptor=Class #ref explicitly extends 'java.lang.Object' #loc -type.parameter.extends.object.problem.descriptor1=Type parameter #ref explicitly extends 'java.lang.Object' #loc -type.parameter.extends.object.problem.descriptor2=Wildcard type argument #ref explicitly extends 'java.lang.Object' #loc -unnecessary.super.constructor.problem.descriptor=#ref is unnecessary #loc -unnecessary.constructor.problem.descriptor=No-arg constructor #ref() is redundant #loc +unnecessary.fully.qualified.name.problem.descriptor1=Qualifier #ref is unnecessary, and can be replaced with an import +unnecessary.fully.qualified.name.problem.descriptor2=Qualifier #ref is unnecessary and can be removed +unnecessary.qualifier.for.this.problem.descriptor=Qualifier #ref on 'this' is unnecessary in this context +unnecessary.qualifier.for.super.problem.descriptor=Qualifier #ref on 'super' is unnecessary in this context +unused.label.problem.descriptor=Unused label #ref +redundant.field.initialization.problem.descriptor=Field initialization to #ref is redundant +redundant.implements.problem.descriptor=Redundant interface declaration #ref +extends.object.problem.descriptor=Class #ref explicitly extends 'java.lang.Object' +type.parameter.extends.object.problem.descriptor1=Type parameter #ref explicitly extends 'java.lang.Object' +type.parameter.extends.object.problem.descriptor2=Wildcard type argument #ref explicitly extends 'java.lang.Object' +unnecessary.super.constructor.problem.descriptor=#ref is unnecessary +unnecessary.constructor.problem.descriptor=No-arg constructor #ref() is redundant unnecessary.constructor.annotation.option=Ignore constructors with an annotation -for.loop.replaceable.by.while.problem.descriptor=#ref loop statement may be replace by 'while' loop #loc -unnecessary.default.problem.descriptor=#ref branch is unnecessary #loc +for.loop.replaceable.by.while.problem.descriptor=#ref loop statement may be replace by 'while' loop +unnecessary.default.problem.descriptor=#ref branch is unnecessary unnecessary.default.expressions.option=Only report switch expressions unnecessary.default.quickfix=Remove 'default' branch -unnecessary.boxing.problem.descriptor=Unnecessary boxing #loc -unnecessary.boxing.inside.value.of.problem.descriptor=Redundant boxing, {0}.{1}() call can be used instead #loc -unnecessary.unboxing.problem.descriptor=Unnecessary unboxing #loc +unnecessary.boxing.problem.descriptor=Unnecessary boxing +unnecessary.boxing.inside.value.of.problem.descriptor=Redundant boxing, {0}.{1}() call can be used instead +unnecessary.unboxing.problem.descriptor=Unnecessary unboxing unnecessary.boxing.superfluous.option=Only report truly superfluously boxed expressions unnecessary.unboxing.superfluous.option=Only report truly superfluously unboxed expressions -for.can.be.foreach.problem.descriptor=#ref loop can be replaced with enhanced 'for' #loc -while.can.be.foreach.problem.descriptor=#ref loop can be replaced with enhanced 'for' #loc -too.broad.scope.problem.descriptor=Scope of variable #ref is too broad #loc -return.this.problem.descriptor=Return of #ref #loc +for.can.be.foreach.problem.descriptor=#ref loop can be replaced with enhanced 'for' +while.can.be.foreach.problem.descriptor=#ref loop can be replaced with enhanced 'for' +too.broad.scope.problem.descriptor=Scope of variable #ref is too broad +return.this.problem.descriptor=Return of #ref constant.on.side.of.comparison.display.name=Constant on wrong side of comparison -constant.on.lhs.of.comparison.problem.descriptor=Constant #ref on the left side of the comparison #loc -constant.on.rhs.of.comparison.problem.descriptor=Constant #ref on the right side of the comparison #loc -control.flow.statement.without.braces.problem.descriptor={0} without braces #loc -missorted.modifiers.problem.descriptor=Missorted modifiers {0} #loc -cstyle.array.variable.declaration.problem.descriptor={0, choice, 1#Field|2#Parameter|3#Record component|4#Local variable} {1} has C-style array type declaration #loc -cstyle.array.method.declaration.problem.descriptor=Method {0}() has C-style array return type declaration #loc -multiple.declaration.problem.descriptor=Multiple variables in one declaration #loc -multiple.typed.declaration.problem.descriptor=Variables with different array dimension in one declaration #loc -serializable.inner.class.has.serial.version.uid.field.problem.descriptor=Inner class #ref does not define a 'serialVersionUID' field #loc -serializable.inner.class.with.non.serializable.outer.class.problem.descriptor=Inner class #ref is serializable while its outer class is not #loc -busy.wait.problem.descriptor=Call to Thread.#ref() in a loop, probably busy-waiting #loc -sleep.while.holding.lock.problem.descriptor=Call to Thread.#ref() while synchronized #loc -non.atomic.operation.on.volatile.field.problem.descriptor=Non-atomic operation on volatile field #ref #loc -call.to.native.method.while.locked.problem.descriptor=Call to native method #ref() in a synchronized context #loc -object.notify.problem.descriptor=#ref should probably be replaced with 'notifyAll()' #loc -condition.signal.problem.descriptor=#ref should probably be replaced with 'signalAll()' #loc -thread.with.default.run.method.problem.descriptor=Instantiating a #ref with default 'run()' method #loc -extends.thread.problem.descriptor=Class #ref directly extends 'java.lang.Thread' #loc -anonymous.extends.thread.problem.descriptor=Anonymous class directly extends 'java.lang.Thread' #loc -naked.notify.problem.descriptor=Call to #ref() without corresponding state change #loc -unconditional.wait.problem.descriptor=Unconditional call to #ref() #loc -system.run.finalizers.on.exit.problem.descriptor=Call to System.#ref() #loc -thread.priority.problem.descriptor=Call to Thread.#ref() #loc -thread.yield.problem.descriptor=Call to Thread.#ref() #loc -thread.stop.suspend.resume.problem.descriptor=Call to Thread.#ref() #loc -while.loop.spins.on.field.problem.descriptor=#ref loop spins on field #loc -wait.not.in.loop.problem.descriptor=Call to #ref() is not in loop #loc -await.not.in.loop.problem.descriptor=Call to #ref() is not in loop #loc -wait.called.on.condition.problem.descriptor=Call to #ref() on Condition object #loc -notify.called.on.condition.problem.descriptor=Call to #ref() on Condition object #loc -wait.while.holding.two.locks.problem.descriptor=Call to #ref() is made while holding two locks #loc -thread.run.problem.descriptor=Calls to #ref() should probably be replaced with 'start()' #loc -thread.start.in.construction.problem.descriptor=Call to #ref() during object construction #loc -synchronize.on.lock.problem.descriptor=Synchronization on a ''{0}'' object is unlikely to be intentional #loc -synchronized.on.literal.object.problem.descriptor=Synchronization on {0} #ref which is initialized by a literal #loc -synchronized.on.direct.literal.object.problem.descriptor=Synchronization on {0} literal #ref #loc -synchronized.on.possibly.literal.object.problem.descriptor=Synchronization on {0} #ref #loc -synchronize.on.non.final.field.problem.descriptor=Synchronization on a non-final field #ref #loc +constant.on.lhs.of.comparison.problem.descriptor=Constant #ref on the left side of the comparison +constant.on.rhs.of.comparison.problem.descriptor=Constant #ref on the right side of the comparison +control.flow.statement.without.braces.problem.descriptor={0} without braces +missorted.modifiers.problem.descriptor=Missorted modifiers {0} +cstyle.array.variable.declaration.problem.descriptor={0, choice, 1#Field|2#Parameter|3#Record component|4#Local variable} {1} has C-style array type declaration +cstyle.array.method.declaration.problem.descriptor=Method {0}() has C-style array return type declaration +multiple.declaration.problem.descriptor=Multiple variables in one declaration +multiple.typed.declaration.problem.descriptor=Variables with different array dimension in one declaration +serializable.inner.class.has.serial.version.uid.field.problem.descriptor=Inner class #ref does not define a 'serialVersionUID' field +serializable.inner.class.with.non.serializable.outer.class.problem.descriptor=Inner class #ref is serializable while its outer class is not +busy.wait.problem.descriptor=Call to Thread.#ref() in a loop, probably busy-waiting +sleep.while.holding.lock.problem.descriptor=Call to Thread.#ref() while synchronized +non.atomic.operation.on.volatile.field.problem.descriptor=Non-atomic operation on volatile field #ref +call.to.native.method.while.locked.problem.descriptor=Call to native method #ref() in a synchronized context +object.notify.problem.descriptor=#ref should probably be replaced with 'notifyAll()' +condition.signal.problem.descriptor=#ref should probably be replaced with 'signalAll()' +thread.with.default.run.method.problem.descriptor=Instantiating a #ref with default 'run()' method +extends.thread.problem.descriptor=Class #ref directly extends 'java.lang.Thread' +anonymous.extends.thread.problem.descriptor=Anonymous class directly extends 'java.lang.Thread' +naked.notify.problem.descriptor=Call to #ref() without corresponding state change +unconditional.wait.problem.descriptor=Unconditional call to #ref() +system.run.finalizers.on.exit.problem.descriptor=Call to System.#ref() +thread.priority.problem.descriptor=Call to Thread.#ref() +thread.yield.problem.descriptor=Call to Thread.#ref() +thread.stop.suspend.resume.problem.descriptor=Call to Thread.#ref() +while.loop.spins.on.field.problem.descriptor=#ref loop spins on field +wait.not.in.loop.problem.descriptor=Call to #ref() is not in loop +await.not.in.loop.problem.descriptor=Call to #ref() is not in loop +wait.called.on.condition.problem.descriptor=Call to #ref() on Condition object +notify.called.on.condition.problem.descriptor=Call to #ref() on Condition object +wait.while.holding.two.locks.problem.descriptor=Call to #ref() is made while holding two locks +thread.run.problem.descriptor=Calls to #ref() should probably be replaced with 'start()' +thread.start.in.construction.problem.descriptor=Call to #ref() during object construction +synchronize.on.lock.problem.descriptor=Synchronization on a ''{0}'' object is unlikely to be intentional +synchronized.on.literal.object.problem.descriptor=Synchronization on {0} #ref which is initialized by a literal +synchronized.on.direct.literal.object.problem.descriptor=Synchronization on {0} literal #ref +synchronized.on.possibly.literal.object.problem.descriptor=Synchronization on {0} #ref +synchronize.on.non.final.field.problem.descriptor=Synchronization on a non-final field #ref synchronized.on.literal.object.warn.on.all.option=Warn on all possible literals -synchronize.on.this.problem.descriptor=Lock operations on 'this' may have unforeseen side-effects #loc -synchronize.on.class.problem.descriptor=Lock operations on a class may have unforeseen side-effects #loc -nested.synchronized.statement.problem.descriptor=Nested #ref statement #loc -empty.synchronized.statement.problem.descriptor=Empty #ref statement #loc -non.synchronized.method.overrides.synchronized.method.problem.descriptor=Unsynchronized method #ref() overrides synchronized method #loc -public.field.accessed.in.synchronized.context.problem.descriptor=Non-private field #ref accessed in synchronized context #loc -field.accessed.synchronized.and.unsynchronized.problem.descriptor=Field #ref is accessed in both synchronized and unsynchronized contexts #loc -extended.for.statement.problem.descriptor=Extended #ref statement #loc -object.allocation.in.loop.new.descriptor=Object allocation new #ref() in loop #loc -object.allocation.in.loop.problem.array.initializer.descriptor=Array allocation in loop #loc -object.allocation.in.loop.problem.call.descriptor=Object allocation via #ref() call in loop #loc -object.allocation.in.loop.problem.methodref.descriptor=Object allocation via instance-bound method reference #ref() in loop #loc -object.allocation.in.loop.problem.lambda.descriptor=Object allocation via capturing lambda in loop #loc -object.allocation.in.loop.problem.string.concat=Object allocation via string concatenation in loop #loc -instantiating.object.to.get.class.object.problem.descriptor=Instantiating object to get Class object #loc -field.may.be.static.problem.descriptor=Field #ref may be 'static' #loc -method.may.be.static.problem.descriptor=Method #ref() may be 'static' #loc -class.initializer.may.be.static.problem.descriptor=Class initializer may be 'static' #loc -map.replaceable.by.enum.map.problem.descriptor=#ref can be replaced with 'EnumMap' #loc -set.replaceable.by.enum.set.problem.descriptor=#ref can be replaced with 'EnumSet' #loc -inner.class.may.be.static.problem.descriptor=Inner class #ref may be 'static' #loc -string.buffer.must.have.initial.capacity.problem.descriptor=new #ref() without initial capacity #loc -string.buffer.replaceable.by.string.builder.problem.descriptor=StringBuffer #ref may be declared as 'StringBuilder' #loc -string.buffer.replaceable.by.string.problem.descriptor={0} #ref can be replaced with ''String'' #loc -new.string.buffer.replaceable.by.string.problem.descriptor=#ref can be replaced with 'String' #loc -string.replaceable.by.string.buffer.problem.descriptor=Non-constant String #ref should probably be declared as 'StringBuilder' #loc -collections.must.have.initial.capacity.problem.descriptor=new #ref() without initial capacity #loc -string.concatenation.in.loops.problem.descriptor=String concatenation #ref in loop #loc -string.concatenation.inside.string.buffer.append.problem.descriptor=String concatenation as argument to {0}.#ref() call #loc -boolean.constructor.problem.descriptor=Boolean constructor call #loc -tail.recursion.problem.descriptor=Tail recursive call #ref() #loc -string.equals.empty.string.problem.descriptor=#ref("") can be replaced with 'length()==0' #loc -string.equals.empty.string.is.empty.problem.descriptor=#ref("") can be replaced with 'isEmpty()' #loc -random.double.for.random.integer.problem.descriptor=Using Random.#ref to create random integer #loc -manual.array.copy.problem.descriptor=Manual array copy #loc -manual.array.to.collection.copy.problem.descriptor=Manual array to collection copy #loc -call.to.simple.getter.in.class.problem.descriptor=Call to simple getter #ref() from within class #loc -call.to.simple.setter.in.class.problem.descriptor=Call to simple setter #ref() from within class #loc -assert.without.message.problem.descriptor=#ref() without message #loc +synchronize.on.this.problem.descriptor=Lock operations on 'this' may have unforeseen side-effects +synchronize.on.class.problem.descriptor=Lock operations on a class may have unforeseen side-effects +nested.synchronized.statement.problem.descriptor=Nested #ref statement +empty.synchronized.statement.problem.descriptor=Empty #ref statement +non.synchronized.method.overrides.synchronized.method.problem.descriptor=Unsynchronized method #ref() overrides synchronized method +public.field.accessed.in.synchronized.context.problem.descriptor=Non-private field #ref accessed in synchronized context +field.accessed.synchronized.and.unsynchronized.problem.descriptor=Field #ref is accessed in both synchronized and unsynchronized contexts +extended.for.statement.problem.descriptor=Extended #ref statement +object.allocation.in.loop.new.descriptor=Object allocation new #ref() in loop +object.allocation.in.loop.problem.array.initializer.descriptor=Array allocation in loop +object.allocation.in.loop.problem.call.descriptor=Object allocation via #ref() call in loop +object.allocation.in.loop.problem.methodref.descriptor=Object allocation via instance-bound method reference #ref() in loop +object.allocation.in.loop.problem.lambda.descriptor=Object allocation via capturing lambda in loop +object.allocation.in.loop.problem.string.concat=Object allocation via string concatenation in loop +instantiating.object.to.get.class.object.problem.descriptor=Instantiating object to get Class object +field.may.be.static.problem.descriptor=Field #ref may be 'static' +method.may.be.static.problem.descriptor=Method #ref() may be 'static' +class.initializer.may.be.static.problem.descriptor=Class initializer may be 'static' +map.replaceable.by.enum.map.problem.descriptor=#ref can be replaced with 'EnumMap' +set.replaceable.by.enum.set.problem.descriptor=#ref can be replaced with 'EnumSet' +inner.class.may.be.static.problem.descriptor=Inner class #ref may be 'static' +string.buffer.must.have.initial.capacity.problem.descriptor=new #ref() without initial capacity +string.buffer.replaceable.by.string.builder.problem.descriptor=StringBuffer #ref may be declared as 'StringBuilder' +string.buffer.replaceable.by.string.problem.descriptor={0} #ref can be replaced with ''String'' +new.string.buffer.replaceable.by.string.problem.descriptor=#ref can be replaced with 'String' +string.replaceable.by.string.buffer.problem.descriptor=Non-constant String #ref should probably be declared as 'StringBuilder' +collections.must.have.initial.capacity.problem.descriptor=new #ref() without initial capacity +string.concatenation.in.loops.problem.descriptor=String concatenation #ref in loop +string.concatenation.inside.string.buffer.append.problem.descriptor=String concatenation as argument to {0}.#ref() call +boolean.constructor.problem.descriptor=Boolean constructor call +tail.recursion.problem.descriptor=Tail recursive call #ref() +string.equals.empty.string.problem.descriptor=#ref("") can be replaced with 'length()==0' +string.equals.empty.string.is.empty.problem.descriptor=#ref("") can be replaced with 'isEmpty()' +random.double.for.random.integer.problem.descriptor=Using Random.#ref to create random integer +manual.array.copy.problem.descriptor=Manual array copy +manual.array.to.collection.copy.problem.descriptor=Manual array to collection copy +call.to.simple.getter.in.class.problem.descriptor=Call to simple getter #ref() from within class +call.to.simple.setter.in.class.problem.descriptor=Call to simple setter #ref() from within class +assert.without.message.problem.descriptor=#ref() without message assert.without.message.quick.fix.family.name=Add error message -misordered.assert.equals.arguments.problem.descriptor=Arguments to #ref() in wrong order #loc -simplifiable.junit.assertion.problem.descriptor=#ref() can be simplified to ''{0}'' #loc -deserializable.class.in.secure.context.problem.descriptor=Class #ref may be deserialized, compromising security #loc -serializable.class.in.secure.context.problem.descriptor=Class #ref may be serialized, compromising security #loc -serializable.deserializable.class.in.secure.context.problem.descriptor=Class #ref may be serialized and deserialized, compromising security #loc -cloneable.class.in.secure.context.problem.descriptor=Class #ref may be cloned, compromising security #loc +misordered.assert.equals.arguments.problem.descriptor=Arguments to #ref() in wrong order +simplifiable.junit.assertion.problem.descriptor=#ref() can be simplified to ''{0}'' +deserializable.class.in.secure.context.problem.descriptor=Class #ref may be deserialized, compromising security +serializable.class.in.secure.context.problem.descriptor=Class #ref may be serialized, compromising security +serializable.deserializable.class.in.secure.context.problem.descriptor=Class #ref may be serialized and deserialized, compromising security +cloneable.class.in.secure.context.problem.descriptor=Class #ref may be cloned, compromising security cloneable.class.in.secure.context.quickfix=Generate 'clone()' method which always throws exception remove.cloneable.quickfix=Remove 'Cloneable' from 'implements' clause -non.final.clone.problem.descriptor=Non-final #ref() method, compromising security #loc -runtime.exec.with.non.constant.string.problem.descriptor=Call to Runtime.#ref() with non-constant argument #loc -load.library.with.non.constant.string.problem.descriptor=Call to {0}.#ref() with non-constant argument #loc -jdbc.execute.with.non.constant.string.problem.descriptor=Call to Statement.#ref() with non-constant argument #loc -jdbc.prepare.statement.with.non.constant.string.problem.descriptor=Call to Connection.#ref() with non-constant argument #loc -custom.classloader.problem.descriptor=Custom ClassLoader class #ref #loc -custom.security.manager.problem.descriptor=Custom SecurityManager class #ref #loc -system.set.problem.descriptor=Call to System.#ref() may pose security concerns #loc -class.loader.instantiation.problem.descriptor=Instantiation of #ref may pose security concerns #loc -public.static.array.field.problem.descriptor='public static' array field #ref, compromising security #loc -public.static.collection.field.problem.descriptor='public static' collection field #ref, compromising security #loc -abstract.class.with.only.one.direct.inheritor.problem.descriptor=Abstract class #ref has only one direct inheritor #loc +non.final.clone.problem.descriptor=Non-final #ref() method, compromising security +runtime.exec.with.non.constant.string.problem.descriptor=Call to Runtime.#ref() with non-constant argument +load.library.with.non.constant.string.problem.descriptor=Call to {0}.#ref() with non-constant argument +jdbc.execute.with.non.constant.string.problem.descriptor=Call to Statement.#ref() with non-constant argument +jdbc.prepare.statement.with.non.constant.string.problem.descriptor=Call to Connection.#ref() with non-constant argument +custom.classloader.problem.descriptor=Custom ClassLoader class #ref +custom.security.manager.problem.descriptor=Custom SecurityManager class #ref +system.set.problem.descriptor=Call to System.#ref() may pose security concerns +class.loader.instantiation.problem.descriptor=Instantiation of #ref may pose security concerns +public.static.array.field.problem.descriptor='public static' array field #ref, compromising security +public.static.collection.field.problem.descriptor='public static' collection field #ref, compromising security +abstract.class.with.only.one.direct.inheritor.problem.descriptor=Abstract class #ref has only one direct inheritor #other abstract.method.overrides.abstract.method.remove.quickfix=Remove redundant abstract method declaration class.may.be.interface.convert.quickfix=Convert class to interface class.without.constructor.create.quickfix=Generate empty constructor class.without.no.arg.constructor.ignore.option=Ignore if class has default constructor -extends.annotation.problem.descriptor=Class ''{0}'' implements annotation interface #ref #loc -extends.annotation.interface.problem.descriptor=Interface ''{0}'' extends annotation interface #ref #loc -extends.concrete.collection.problem.descriptor=Class #ref explicitly extends ''{0}'' #loc -anonymous.extends.concrete.collection.problem.descriptor=Anonymous class explicitly extends ''{0}'' #loc +extends.annotation.problem.descriptor=Class ''{0}'' implements annotation interface #ref +extends.annotation.interface.problem.descriptor=Interface ''{0}'' extends annotation interface #ref +extends.concrete.collection.problem.descriptor=Class #ref explicitly extends ''{0}'' +anonymous.extends.concrete.collection.problem.descriptor=Anonymous class explicitly extends ''{0}'' inner.class.on.interface.ignore.option=Ignore inner interfaces of interfaces -inner.class.on.interface.problem.descriptor=Interface ''{0}'' has inner class #ref #loc +inner.class.on.interface.problem.descriptor=Interface ''{0}'' has inner class #ref missing.deprecated.annotation.add.quickfix=Add '@Deprecated' annotation missing.add.deprecated.javadoc.tag.quickfix=Add '@deprecated' Javadoc tag explanation non.protected.constructor.in.abstract.class.ignore.option=Ignore for non-public classes -public.constructor.in.non.public.class.problem.descriptor=Constructor is declared #ref in non-public class ''{0}'' #loc +public.constructor.in.non.public.class.problem.descriptor=Constructor is declared #ref in non-public class ''{0}'' static.inheritance.replace.quickfix=Replace inheritance with qualified references in {0} utility.class.with.public.constructor.make.private.quickfix=Make {0, choice, 1#constructor|2#constructors} ''private'' utility.class.with.public.constructor.make.protected.quickfix=Make {0, choice, 1#constructor|2#constructors} ''protected'' utility.class.without.private.constructor.create.quickfix=Generate empty 'private' constructor utility.class.without.private.constructor.make.quickfix=Make constructor 'private' -naming.convention.problem.descriptor.short={0} name #ref is too short ({1} < {2}) #loc -naming.convention.problem.descriptor.long={0} name #ref is too long ({1} > {2}) #loc -naming.convention.problem.descriptor.regex.mismatch={0} name #ref doesn''t match regex ''{1}'' #loc +naming.convention.problem.descriptor.short={0} name #ref is too short ({1} < {2}) +naming.convention.problem.descriptor.long={0} name #ref is too long ({1} > {2}) +naming.convention.problem.descriptor.regex.mismatch={0} name #ref doesn''t match regex ''{1}'' local.variable.naming.convention.ignore.option=Ignore for-loop parameters local.variable.naming.convention.ignore.catch.option=Ignore 'catch' block parameters -method.names.differ.only.by.case.problem.descriptor=Method name #ref and method name ''{0}'' differ only by case #loc +method.names.differ.only.by.case.problem.descriptor=Method name #ref and method name ''{0}'' differ only by case parameter.name.differs.from.overridden.parameter.ignore.character.option=Ignore if overridden parameter contains only one character parameter.name.differs.from.overridden.parameter.ignore.library.option=Ignore if overridden parameter is from a library -parameter.name.differs.from.overridden.parameter.problem.descriptor=Parameter name #ref is different from parameter ''{0}'' in the {1, choice, 1#super method|2#overloaded method|3#super constructor|4#overloaded constructor} #loc +parameter.name.differs.from.overridden.parameter.problem.descriptor=Parameter name #ref is different from parameter ''{0}'' in the {1, choice, 1#super method|2#overloaded method|3#super constructor|4#overloaded constructor} questionable.name.list.label=Reported names: -standard.variable.names.problem.descriptor=Variable named #ref doesn''t have type ''{0}'' #loc -standard.variable.names.problem.descriptor2=Variable named #ref doesn''t have type ''{0}'' or ''{1}'' #loc +standard.variable.names.problem.descriptor=Variable named #ref doesn''t have type ''{0}'' +standard.variable.names.problem.descriptor2=Variable named #ref doesn''t have type ''{0}'' or ''{1}'' standard.variable.names.ignore.override.option=Ignore for parameter names identical to super method parameters boolean.method.name.must.start.with.question.table.label=Boolean method name prefixes: conditional.expression.with.identical.branches.collapse.quickfix=Collapse conditional expression redundant.else.unwrap.quickfix=Remove redundant 'else' -constant.conditional.expression.problem.descriptor=#ref can be simplified to ''{0}'' #loc +constant.conditional.expression.problem.descriptor=#ref can be simplified to ''{0}'' constant.conditional.expression.simplify.quickfix=Simplify constant.conditional.expression.simplify.quickfix.sideEffect=Extract side effects and simplify -enum.switch.statement.which.misses.cases.problem.descriptor.single=#ref statement on enum type ''{0}'' misses case ''{1}'' #loc -enum.switch.statement.which.misses.cases.problem.descriptor=#ref statement on enum type ''{0}'' misses cases {1} #loc +enum.switch.statement.which.misses.cases.problem.descriptor.single=#ref statement on enum type ''{0}'' misses case ''{1}'' +enum.switch.statement.which.misses.cases.problem.descriptor=#ref statement on enum type ''{0}'' misses cases {1} for.loop.replaceable.by.while.ignore.option=Ignore 'infinite' for loops without conditions -for.loop.with.missing.component.problem.descriptor1=#ref statement lacks initializer #loc -for.loop.with.missing.component.problem.descriptor2=#ref statement lacks condition #loc -for.loop.with.missing.component.problem.descriptor3=#ref statement lacks update #loc -for.loop.with.missing.component.problem.descriptor4=#ref statement lacks initializer and condition #loc -for.loop.with.missing.component.problem.descriptor5=#ref statement lacks initializer and update #loc -for.loop.with.missing.component.problem.descriptor6=#ref statement lacks condition and update #loc -for.loop.with.missing.component.problem.descriptor7=#ref statement lacks initializer, condition and update #loc +for.loop.with.missing.component.problem.descriptor1=#ref statement lacks initializer +for.loop.with.missing.component.problem.descriptor2=#ref statement lacks condition +for.loop.with.missing.component.problem.descriptor3=#ref statement lacks update +for.loop.with.missing.component.problem.descriptor4=#ref statement lacks initializer and condition +for.loop.with.missing.component.problem.descriptor5=#ref statement lacks initializer and update +for.loop.with.missing.component.problem.descriptor6=#ref statement lacks condition and update +for.loop.with.missing.component.problem.descriptor7=#ref statement lacks initializer, condition and update foreach.replace.quickfix=Replace with enhanced 'for' unnecessary.boxing.remove.quickfix=Remove boxing unnecessary.unboxing.remove.quickfix=Remove unboxing misordered.assert.equals.arguments.flip.quickfix=Flip compared arguments simplify.junit.assertion.simplify.quickfix=Simplify assertion -system.properties.problem.descriptor=Call to Integer.#ref() may pose security concerns #loc -system.properties.problem.descriptor1=Call to Boolean.#ref() may pose security concerns #loc -unsecure.random.number.generation.problem.descriptor1=For security purposes, use 'java.security.SecureRandom' instead of java.lang.Math.#ref() #loc -unsecure.random.number.generation.problem.descriptor2=For security purposes, use 'java.security.SecureRandom' instead of java.util.#ref #loc -unsecure.random.number.generation.problem.descriptor3=For security purposes, use 'java.security.SecureRandom' instead of #ref #loc -serializable.has.serialization.methods.problem.descriptor=Serializable class #ref does not define 'readObject()' or 'writeObject()' #loc -serializable.has.serialization.methods.problem.descriptor1=Serializable class #ref does not define 'writeObject()' #loc -serializable.has.serialization.methods.problem.descriptor2=Serializable class #ref does not define 'readObject()' #loc -serializable.with.unconstructable.ancestor.problem.descriptor=#ref has a non-serializable ancestor ''{0}'' without no-arg constructor #loc -transient.field.in.non.serializable.class.problem.descriptor=Field ''{0}'' is marked #ref, in non-Serializable class #loc -safe.lock.problem.descriptor=''{0}'' should be locked in front of a ''try'' block and unlocked in the corresponding ''finally'' block #loc -synchronized.method.problem.descriptor=Method ''{0}()'' declared #ref #loc +system.properties.problem.descriptor=Call to Integer.#ref() may pose security concerns +system.properties.problem.descriptor1=Call to Boolean.#ref() may pose security concerns +unsecure.random.number.generation.problem.descriptor1=For security purposes, use 'java.security.SecureRandom' instead of java.lang.Math.#ref() +unsecure.random.number.generation.problem.descriptor2=For security purposes, use 'java.security.SecureRandom' instead of java.util.#ref +unsecure.random.number.generation.problem.descriptor3=For security purposes, use 'java.security.SecureRandom' instead of #ref +serializable.has.serialization.methods.problem.descriptor=Serializable class #ref does not define 'readObject()' or 'writeObject()' +serializable.has.serialization.methods.problem.descriptor1=Serializable class #ref does not define 'writeObject()' +serializable.has.serialization.methods.problem.descriptor2=Serializable class #ref does not define 'readObject()' +serializable.with.unconstructable.ancestor.problem.descriptor=#ref has a non-serializable ancestor ''{0}'' without no-arg constructor +transient.field.in.non.serializable.class.problem.descriptor=Field ''{0}'' is marked #ref, in non-Serializable class +safe.lock.problem.descriptor=''{0}'' should be locked in front of a ''try'' block and unlocked in the corresponding ''finally'' block +synchronized.method.problem.descriptor=Method ''{0}()'' declared #ref synchronized.method.include.option=Include native methods synchronized.method.ignore.synchronized.super.option=Ignore methods overriding a synchronized method synchronized.method.move.quickfix=Move synchronization into method -volatile.field.problem.descriptor=Volatile field #ref of type ''{0}'' #loc +volatile.field.problem.descriptor=Volatile field #ref of type ''{0}'' string.format.choose.class=Choose Formatter Class string.format.class.label=Additional formatter classes: string.format.class.method.label=Additional formatter methods: -bad.exception.thrown.problem.descriptor=Prohibited exception ''{0}'' thrown #loc -too.broad.catch.problem.descriptor=''catch'' of #ref is too broad, masking exception ''{0}'' #loc -too.broad.catch.problem.descriptor1=''catch'' of #ref is too broad, masking exceptions ''{0}'' and ''{1}'' #loc +bad.exception.thrown.problem.descriptor=Prohibited exception ''{0}'' thrown +too.broad.catch.problem.descriptor=''catch'' of #ref is too broad, masking exception ''{0}'' +too.broad.catch.problem.descriptor1=''catch'' of #ref is too broad, masking exceptions ''{0}'' and ''{1}'' add.serialversionuidfield.quickfix=Add 'serialVersionUID' field delete.import.quickfix=Delete unnecessary import encapsulate.variable.quickfix=Encapsulate field ''{0}'' @@ -1185,40 +1185,40 @@ move.class.quickfix=Move class normalize.declaration.quickfix=Split into separate declarations remove.modifier.quickfix=Remove ''{0}'' modifier replace.inheritance.with.delegation.quickfix=Replace inheritance with delegation -cast.that.loses.precision.problem.descriptor=Cast from ''{0}'' to #ref may result in loss of precision #loc -cast.that.loses.precision.negative.problem.descriptor=Cast from ''{0}'' to #ref may result in loss of precision for negative argument #loc -comparison.to.nan.problem.descriptor1=Comparison to #ref is always false #loc -comparison.to.nan.problem.descriptor2=Comparison to #ref is always true #loc +cast.that.loses.precision.problem.descriptor=Cast from ''{0}'' to #ref may result in loss of precision +cast.that.loses.precision.negative.problem.descriptor=Cast from ''{0}'' to #ref may result in loss of precision for negative argument +comparison.to.nan.problem.descriptor1=Comparison to #ref is always false +comparison.to.nan.problem.descriptor2=Comparison to #ref is always true confusing.floating.point.literal.change.quickfix=Change to canonical form implicit.numeric.conversion.ignore.widening.conversion.option=Ignore widening conversions implicit.numeric.conversion.ignore.char.conversion.option=Ignore conversions from and to 'char' implicit.numeric.conversion.ignore.constant.conversion.option=Ignore conversions from constants and literals -implicit.numeric.conversion.problem.descriptor=Implicit numeric conversion of #ref from ''{0}'' to ''{1}'' #loc -implicit.numeric.conversion.assignment.problem.descriptor=Implicit numeric conversion of result value from ''{0}'' to ''{1}'' #loc +implicit.numeric.conversion.problem.descriptor=Implicit numeric conversion of #ref from ''{0}'' to ''{1}'' +implicit.numeric.conversion.assignment.problem.descriptor=Implicit numeric conversion of result value from ''{0}'' to ''{1}'' implicit.numeric.conversion.make.explicit.quickfix=Make conversion explicit non.reproducible.math.call.replace.quickfix=Replace with 'StrictMath' call overly.complex.arithmetic.expression.max.number.option=Maximum number of terms: -expression.can.be.replaced.problem.descriptor=#ref can be replaced with ''{0}'' #loc +expression.can.be.replaced.problem.descriptor=#ref can be replaced with ''{0}'' method.complexity.limit.option=Method complexity limit: expression.can.be.replaced.no.quotes.problem.descriptor={0} can be replaced with {1} -cyclomatic.complexity.problem.descriptor=Overly complex method #ref() (cyclomatic complexity = {0}) #loc +cyclomatic.complexity.problem.descriptor=Overly complex method #ref() (cyclomatic complexity = {0}) method.coupling.limit.option=Method coupling limit: -method.coupling.problem.descriptor=#ref is overly coupled (# referenced classes = {0}) #loc -method.with.multiple.loops.problem.descriptor=#ref contains {0} loops #loc +method.coupling.problem.descriptor=#ref is overly coupled (# referenced classes = {0}) +method.with.multiple.loops.problem.descriptor=#ref contains {0} loops return.point.limit.option=&Return point limit: -multiple.return.points.per.method.problem.descriptor=#ref has {0} return points #loc +multiple.return.points.per.method.problem.descriptor=#ref has {0} return points nesting.depth.limit.option=Nesting depth limit: -nesting.depth.problem.descriptor=#ref is overly nested (maximum nesting depth = {0}) #loc +nesting.depth.problem.descriptor=#ref is overly nested (maximum nesting depth = {0}) non.comment.source.statements.limit.option=Non-comment source statements limit: -non.comment.source.statements.problem.descriptor=#ref is too long (# Non-comment source statements = {0}) #loc -parameters.per.method.problem.descriptor=#ref() has too many parameters (num parameters = {0}) #loc -parameters.per.constructor.problem.descriptor=#ref() has too many parameters (num parameters = {0}) #loc +non.comment.source.statements.problem.descriptor=#ref is too long (# Non-comment source statements = {0}) +parameters.per.method.problem.descriptor=#ref() has too many parameters (num parameters = {0}) +parameters.per.constructor.problem.descriptor=#ref() has too many parameters (num parameters = {0}) parameter.limit.option=Parameter limit: constructor.visibility.option=Ignore constructors with visibility: three.negations.per.method.ignore.option=Ignore negations in 'equals()' methods three.negations.per.method.ignore.assert.option=Ignore negations in 'assert' statements -three.negations.per.method.problem.descriptor=#ref contains {0} negations #loc -thrown.exceptions.per.method.problem.descriptor=#ref has too many exceptions declared (num exceptions = {0}) #loc +three.negations.per.method.problem.descriptor=#ref contains {0} negations +thrown.exceptions.per.method.problem.descriptor=#ref has too many exceptions declared (num exceptions = {0}) thrown.exceptions.per.method.limit.option=Exceptions thrown limit: call.to.simple.getter.in.class.ignore.option=Ignore getter calls on other objects call.to.private.simple.getter.in.class.option=Only report when getter is 'private' @@ -1229,8 +1229,8 @@ call.to.simple.setter.in.class.inline.quickfix=Inline call to setter make.static.quickfix=Make 'static' length.one.strings.in.concatenation.replace.quickfix=Replace with character multiply.or.divide.by.power.of.two.replace.quickfix=Replace with shift -boolean.expression.can.be.simplified.problem.descriptor=#ref can be simplified to ''{0}'' #loc -boolean.expression.does.not.modify.problem.descriptor=#ref does not modify value of ''{0}'' #loc +boolean.expression.can.be.simplified.problem.descriptor=#ref can be simplified to ''{0}'' +boolean.expression.does.not.modify.problem.descriptor=#ref does not modify value of ''{0}'' boolean.expression.remove.compound.assignment.quickfix=Remove pointless compound assignment trivial.string.concatenation.problem.descriptor=Empty string in concatenation string.replace.quickfix=Remove empty string operand @@ -1241,7 +1241,7 @@ string.concatenation.inside.string.buffer.append.replace.quickfix=Replace with c string.equals.empty.string.option.do.not.add.null.check=Do not report when null-check could be necessary tail.recursion.replace.quickfix=Replace tail recursion with iteration if.statement.with.too.many.branches.max.option=Maximum number of branches: -if.statement.with.too.many.branches.problem.descriptor=#ref has too many branches ({0}) #loc +if.statement.with.too.many.branches.problem.descriptor=#ref has too many branches ({0}) negated.conditional.invert.quickfix=Invert condition negated.if.else.ignore.negated.null.option=Ignore '!= null' comparisons negated.if.else.ignore.negated.zero.option=Ignore '!= 0' comparisons @@ -1249,36 +1249,36 @@ negated.if.else.invert.quickfix=Invert 'if' condition overly.complex.boolean.expression.max.terms.option=Maximum number of terms: pointless.boolean.expression.ignore.option=Ignore named constants in determining pointless expressions sequenced.collection.method.can.be.used.ignore.option=Ignore named constants used as arguments -simplifiable.conditional.expression.problem.descriptor={1} can be simplified to ''{0}'' #loc +simplifiable.conditional.expression.problem.descriptor={1} can be simplified to ''{0}'' switch.statement.density.min.option=Minimum density of branches: % -switch.statement.density.problem.descriptor=#ref branch density is too low ({0}%) #loc +switch.statement.density.problem.descriptor=#ref branch density is too low ({0}%) switch.statement.with.too.few.branches.min.option=Minimum number of branches: switch.statement.with.too.few.branches.ignore.pattern.option=Do not report pattern switch statements -switch.statement.with.too.few.branches.problem.descriptor=''switch'' statement has too few case labels ({0}), and should probably be replaced with an ''if'' statement #loc +switch.statement.with.too.few.branches.problem.descriptor=''switch'' statement has too few case labels ({0}), and should probably be replaced with an ''if'' statement switch.statement.with.single.default.message='switch' statement has only 'default' case -switch.expression.with.too.few.branches.problem.descriptor=''switch'' expression has too few case labels ({0}), and should probably be replaced with an ''if'' statement or conditional operator #loc +switch.expression.with.too.few.branches.problem.descriptor=''switch'' expression has too few case labels ({0}), and should probably be replaced with an ''if'' statement or conditional operator switch.expression.with.single.default.message='switch' expression has only 'default' case switch.statement.without.default.ignore.option=Ignore exhaustive switch statements unnecessary.label.remove.quickfix=Remove label -unnecessary.return.problem.descriptor=#ref is unnecessary as the last statement in a 'void' method #loc -unnecessary.return.constructor.problem.descriptor=#ref is unnecessary as the last statement in a constructor #loc +unnecessary.return.problem.descriptor=#ref is unnecessary as the last statement in a 'void' method +unnecessary.return.constructor.problem.descriptor=#ref is unnecessary as the last statement in a constructor unused.label.remove.quickfix=Remove unused label -unnecessarily.qualified.static.usage.problem.descriptor=Unnecessarily qualified call to static method {0}() #loc -unnecessarily.qualified.static.usage.problem.descriptor1=Unnecessarily qualified access to static field {0} #loc +unnecessarily.qualified.static.usage.problem.descriptor=Unnecessarily qualified call to static method {0}() +unnecessarily.qualified.static.usage.problem.descriptor1=Unnecessarily qualified access to static field {0} unnecessarily.qualified.static.usage.ignore.field.option=Ignore unnecessarily qualified field accesses unnecessarily.qualified.static.usage.ignore.method.option=Ignore unnecessarily qualified method calls -unnecessary.interface.modifier.problem.descriptor=Modifier #ref is redundant for interfaces #loc -unnecessary.inner.interface.modifier.problem.descriptor=Modifier #ref is redundant for inner interfaces #loc -unnecessary.interface.method.modifier.problem.descriptor=Modifier #ref is redundant for interface methods #loc -unnecessary.interface.member.modifier.problem.descriptor=Modifier #ref is redundant for interface members #loc -unnecessary.interface.inner.class.modifier.problem.descriptor=Modifier #ref is redundant for inner classes of interfaces #loc -unnecessary.interface.field.modifier.problem.descriptor=Modifier #ref is redundant for interface fields #loc +unnecessary.interface.modifier.problem.descriptor=Modifier #ref is redundant for interfaces +unnecessary.inner.interface.modifier.problem.descriptor=Modifier #ref is redundant for inner interfaces +unnecessary.interface.method.modifier.problem.descriptor=Modifier #ref is redundant for interface methods +unnecessary.interface.member.modifier.problem.descriptor=Modifier #ref is redundant for interface members +unnecessary.interface.inner.class.modifier.problem.descriptor=Modifier #ref is redundant for inner classes of interfaces +unnecessary.interface.field.modifier.problem.descriptor=Modifier #ref is redundant for interface fields unnecessary.transient.modifier.problem.descriptor=Modifier #ref is redundant for a 'static' field unnecessary.strictfp.modifier.problem.descriptor=Modifier #ref is redundant on Java 17 and later -unnecessary.main.modifier.problem.descriptor=Modifier #ref is redundant for ''main'' method on Java {0} #loc +unnecessary.main.modifier.problem.descriptor=Modifier #ref is redundant for ''main'' method on Java {0} smth.unnecessary.remove.quickfix=Remove unnecessary ''{0}'' -unqualified.static.usage.problem.descriptor=Unqualified static method call #ref() #loc -unqualified.static.usage.problem.descriptor1=Unqualified static field access #ref #loc +unqualified.static.usage.problem.descriptor=Unqualified static method call #ref() +unqualified.static.usage.problem.descriptor1=Unqualified static field access #ref unqualified.static.usage.ignore.field.option=Ignore unqualified field accesses unqualified.static.usage.ignore.method.option=Ignore unqualified method calls unqualified.static.usage.qualify.field.quickfix=Qualify static field access @@ -1288,11 +1288,11 @@ too.broad.scope.only.blocks.option=Only report variables that can be moved into too.broad.scope.narrow.quickfix=Move declaration of ''{0}'' closer to usages press.escape.to.remove.highlighting.message=Press Escape to remove the highlighting unnecessary.modifier.display.name=Unnecessary modifier -unnecessary.enum.constructor.modifier.problem.descriptor=Modifier #ref is redundant for enum constructors #loc -unnecessary.inner.enum.modifier.problem.descriptor=Modifier #ref is redundant for inner enums #loc +unnecessary.enum.constructor.modifier.problem.descriptor=Modifier #ref is redundant for enum constructors +unnecessary.inner.enum.modifier.problem.descriptor=Modifier #ref is redundant for inner enums unnecessary.record.modifier.problem.descriptor=Modifier #ref is redundant for records unnecessary.inner.record.modifier.problem.descriptor=Modifier #ref is redundant for inner records -literal.as.arg.to.string.equals.problem.descriptor=Literal #ref is argument of ''{0}()'', instead of its qualifier #loc +literal.as.arg.to.string.equals.problem.descriptor=Literal #ref is argument of ''{0}()'', instead of its qualifier literal.as.arg.to.string.equals.flip.quickfix=Flip ''{0}()'' c.style.array.declaration.replace.quickfix=Replace with Java-style array declaration chained.method.call.ignore.option=Ignore chained method calls in field initializers @@ -1330,70 +1330,70 @@ unnecessary.qualifier.for.this.remove.quickfix=Remove unnecessary qualifier unnecessary.semicolon.remove.quickfix=Remove unnecessary semicolon unnecessary.super.constructor.remove.quickfix=Remove unnecessary 'super()' unnecessary.this.remove.quickfix=Remove unnecessary 'this' qualifier -overly.strong.type.cast.problem.descriptor=Cast to #ref can be weakened to ''{0}'' #loc +overly.strong.type.cast.problem.descriptor=Cast to #ref can be weakened to ''{0}'' field.count.inspection.include.constant.fields.in.count.checkbox=Include constant fields in count field.count.inspection.static.final.fields.count.as.constant.checkbox='static final' fields count as constant field.count.inspection.include.enum.constants.in.count=Include enum constants in count make.method.final.fix.name=Make method ''{0}()'' ''final'' make.class.final.fix.name=Make class ''{0}'' ''final'' non.boolean.method.name.must.not.start.with.question.display.name=Non-boolean method name must not start with question word -non.boolean.method.name.must.not.start.with.question.problem.descriptor=Non-boolean method name #ref starts with a question word #loc +non.boolean.method.name.must.not.start.with.question.problem.descriptor=Non-boolean method name #ref starts with a question word boolean.constructor.simplify.quickfix=Simplify only.report.qualified.static.usages.option=Only report qualified static access from a static context unqualified,static.usage.only.report.static.usages.option=Only report static access from a non-static context -assignment.to.catch.block.parameter.problem.descriptor=Assignment to 'catch' block parameter #ref #loc -assignment.to.method.parameter.problem.descriptor=Assignment to method parameter #ref #loc -value.of.post.increment.problem.descriptor=Value of post-increment expression #ref is used #loc -value.of.post.decrement.problem.descriptor=Value of post-decrement expression #ref is used #loc -value.of.pre.increment.problem.descriptor=Value of pre-increment expression #ref is used #loc -value.of.pre.decrement.problem.descriptor=Value of pre-decrement expression #ref is used #loc -assignment.replaceable.with.operator.assignment.problem.descriptor=#ref can be simplified to ''{0}'' #loc +assignment.to.catch.block.parameter.problem.descriptor=Assignment to 'catch' block parameter #ref +assignment.to.method.parameter.problem.descriptor=Assignment to method parameter #ref +value.of.post.increment.problem.descriptor=Value of post-increment expression #ref is used +value.of.post.decrement.problem.descriptor=Value of post-decrement expression #ref is used +value.of.pre.increment.problem.descriptor=Value of pre-increment expression #ref is used +value.of.pre.decrement.problem.descriptor=Value of pre-decrement expression #ref is used +assignment.replaceable.with.operator.assignment.problem.descriptor=#ref can be simplified to ''{0}'' assignment.replaceable.with.operator.assignment.ignore.conditional.operators.option=Ignore conditional operators assignment.replaceable.with.operator.assignment.ignore.obscure.operators.option=Ignore the obscure ^ and % operators object.equality.ignore.between.objects.of.a.type.with.only.private.constructors.option=Ignore '==' between objects of a type with only 'private' constructors redundant.method.override.display.name=Method is identical to its super method -redundant.method.override.delegates.to.super.problem.descriptor=Method #ref() only delegates to its super method #loc -redundant.method.override.problem.descriptor=Method #ref() is identical to its super method #loc +redundant.method.override.delegates.to.super.problem.descriptor=Method #ref() only delegates to its super method +redundant.method.override.problem.descriptor=Method #ref() is identical to its super method redundant.method.override.quickfix=Remove redundant method redundant.method.override.delegate.quickfix=Replace method with delegate to super redundant.method.override.option.check.library.methods=Check methods overriding library methods redundant.method.override.option.ignore.delegates=Ignore delegates to super methods -refused.bequest.problem.descriptor=Method #ref() does not call 'super.#ref()' #loc +refused.bequest.problem.descriptor=Method #ref() does not call 'super.#ref()' refused.bequest.ignore.empty.super.methods.option=Ignore empty super methods refused.bequest.ignore.default.super.methods.option=Ignore 'default' super methods overly.complex.boolean.expression.ignore.option=Ignore pure conjunctions and disjunctions pointless.indexof.comparison.display.name=Pointless 'indexOf()' comparison -pointless.indexof.comparison.always.true.problem.descriptor=#ref is always true #loc -pointless.indexof.comparison.always.false.problem.descriptor=#ref is always false #loc -reuse.of.local.variable.problem.descriptor=Reuse of local variable #ref #loc +pointless.indexof.comparison.always.true.problem.descriptor=#ref is always true +pointless.indexof.comparison.always.false.problem.descriptor=#ref is always false +reuse.of.local.variable.problem.descriptor=Reuse of local variable #ref single.character.startswith.display.name=Single character 'startsWith()' or 'endsWith()' -single.character.startswith.problem.descriptor=Single character #ref() can be replaced with 'charAt()' expression #loc +single.character.startswith.problem.descriptor=Single character #ref() can be replaced with 'charAt()' expression list.indexof.replaceable.by.contains.display.name='List.indexOf()' expression can be replaced with 'contains()' string.indexof.replaceable.by.contains.display.name='String.indexOf()' expression can be replaced with 'contains()' -overloaded.methods.with.same.number.parameters.problem.descriptor=Multiple methods named #ref with the same number of parameters #loc -overloaded.vararg.method.problem.descriptor=Overloaded varargs method #ref() #loc -overloaded.vararg.constructor.problem.descriptor=Overloaded varargs constructor #ref() #loc +overloaded.methods.with.same.number.parameters.problem.descriptor=Multiple methods named #ref with the same number of parameters +overloaded.vararg.method.problem.descriptor=Overloaded varargs method #ref() +overloaded.vararg.constructor.problem.descriptor=Overloaded varargs constructor #ref() overloaded.vararg.method.problem.option=Ignore overloaded methods whose parameter types are definitely incompatible cached.number.constructor.call.display.name=Number constructor call with primitive argument -cached.number.constructor.call.problem.descriptor=Number constructor call with primitive argument #loc +cached.number.constructor.call.problem.descriptor=Number constructor call with primitive argument cached.number.constructor.call.ignore.string.arguments.option=Ignore new number expressions with a String argument cached.number.constructor.call.report.only.deprecated=Report only when constructor is @Deprecated -chained.equality.comparisons.problem.descriptor=Chained equality comparison #ref #loc -confusing.octal.escape.sequence.problem.descriptor=Octal escape sequence #ref immediately followed by a digit #loc +chained.equality.comparisons.problem.descriptor=Chained equality comparison #ref +confusing.octal.escape.sequence.problem.descriptor=Octal escape sequence #ref immediately followed by a digit field.accessed.synchronized.and.unsynchronized.option=Simple getters and setters are considered field accesses too method.overrides.inaccessible.method.display.name=Method overrides inaccessible method of superclass -method.overrides.package.local.method.problem.descriptor=Method #ref() overrides a package-private method of a superclass located in another package #loc +method.overrides.package.local.method.problem.descriptor=Method #ref() overrides a package-private method of a superclass located in another package suspicious.to.array.call.display.name=Suspicious 'Collection.toArray()' call -suspicious.to.array.call.problem.descriptor=Array of type ''{0}[]'' expected, ''{1}[]'' found #loc +suspicious.to.array.call.problem.descriptor=Array of type ''{0}[]'' expected, ''{1}[]'' found suspicious.system.arraycopy.display.name=Suspicious 'System.arraycopy()' call -suspicious.system.arraycopy.problem.descriptor4=#ref is not of an array type #loc -suspicious.system.arraycopy.problem.descriptor5=#ref is not of an array type #loc -suspicious.system.arraycopy.problem.descriptor6=Source parameter type ''{0}'' is not assignable to destination parameter #ref of type ''{1}'' #loc +suspicious.system.arraycopy.problem.descriptor4=#ref is not of an array type +suspicious.system.arraycopy.problem.descriptor5=#ref is not of an array type +suspicious.system.arraycopy.problem.descriptor6=Source parameter type ''{0}'' is not assignable to destination parameter #ref of type ''{1}'' suspicious.system.arraycopy.problem.descriptor.length.bigger.src=Length is always bigger than ''src.length - srcPos'' {0} suspicious.system.arraycopy.problem.descriptor.length.bigger.dest=Length is always bigger than ''dest.length - destPos'' {0} suspicious.system.arraycopy.problem.descriptor.ranges.intersect=Copying to the same array with intersecting ranges method.only.used.from.inner.class.display.name=Private method only used from inner class -method.only.used.from.inner.class.problem.descriptor=Method #ref()#loc is only used from {0, choice, 1#inner |2#local |3#}{1, choice, 1#class|2#interface|3#an anonymous class derived from|4#annotation type|5#enum|6#record} ''{2}'' #loc +method.only.used.from.inner.class.problem.descriptor=Method #ref() is only used from {0, choice, 1#inner |2#local |3#}{1, choice, 1#class|2#interface|3#an anonymous class derived from|4#annotation type|5#enum|6#record} ''{2}'' method.only.used.from.inner.class.ignore.option=Ignore methods called from an &anonymous or local class only.report.static.methods=&Only report 'static' methods single.character.startswith.quickfix=Replace with 'charAt()' expression @@ -1403,14 +1403,14 @@ size.replaceable.by.isempty.negation.ignore.option=Ignore expressions which woul size.replaceable.by.isempty.fix.ignore.calls=Ignore ''.{0}()'' calls on type ''{1}'' choose.class.type.to.ignore=Choose Class to Ignore loop.condition.not.updated.inside.loop.display.name=Loop variable not updated inside loop -loop.variable.not.updated.inside.loop.problem.descriptor=Variable '#ref' is not updated inside loop #loc -loop.condition.not.updated.inside.loop.problem.descriptor=Condition '#ref' is not updated inside loop #loc +loop.variable.not.updated.inside.loop.problem.descriptor=Variable '#ref' is not updated inside loop +loop.condition.not.updated.inside.loop.problem.descriptor=Condition '#ref' is not updated inside loop loop.variable.not.updated.inside.loop.option.nonlocal=Ignore possible non-local changes utility.class.without.private.constructor.option=Ignore classes with only a main method super.class.logger.option=Ignore when superclass has an accessible logger static.method.only.used.in.one.class.display.name=Static member only used from one other class -static.method.only.used.in.one.class.problem.descriptor=Static {0, choice, 1#method|2#field} #ref{0, choice, 1#()|2#} is only used from class ''{1}'' #loc -static.method.only.used.in.one.anonymous.class.problem.descriptor=Static {0, choice, 1#method|2#field} #ref{0, choice, 1#()|2#} is only used from an anonymous class derived from ''{1}'' #loc +static.method.only.used.in.one.class.problem.descriptor=Static {0, choice, 1#method|2#field} #ref{0, choice, 1#()|2#} is only used from class ''{1}'' +static.method.only.used.in.one.anonymous.class.problem.descriptor=Static {0, choice, 1#method|2#field} #ref{0, choice, 1#()|2#} is only used from an anonymous class derived from ''{1}'' static.method.only.used.in.one.class.quickfix=Move {0} to usage class static.method.only.used.in.one.class.quickfix.preview=Moves the static member to the class where it is used. static.method.only.used.in.one.class.ignore.test.option=Ignore when only used from a test class @@ -1418,25 +1418,25 @@ static.method.only.used.in.one.class.ignore.anonymous.option=Ignore when only us static.method.only.used.in.one.class.ignore.on.conflicts=Ignore when the method cannot be moved without conflicts static.method.only.used.in.one.class.ignore.utility.classes=Ignore members located in utility classes unary.plus.display.name=Unary plus -unary.plus.problem.descriptor=Unary #ref operator #loc +unary.plus.problem.descriptor=Unary #ref operator await.without.corresponding.signal.display.name='await()' without corresponding 'signal()' -await.without.corresponding.signal.problem.descriptor=Call to #ref() without corresponding signal() or signalAll() #loc +await.without.corresponding.signal.problem.descriptor=Call to #ref() without corresponding signal() or signalAll() signal.without.corresponding.await.display.name='signal()' without corresponding 'await()' -signal.without.corresponding.await.problem.descriptor=Call to #ref() without corresponding await() #loc +signal.without.corresponding.await.problem.descriptor=Call to #ref() without corresponding await() wait.without.corresponding.notify.display.name='wait()' without corresponding 'notify()' -wait.without.corresponding.notify.problem.descriptor=Call to #ref() without corresponding notify() or notifyAll() #loc +wait.without.corresponding.notify.problem.descriptor=Call to #ref() without corresponding notify() or notifyAll() thread.local.set.with.null.display.name = 'ThreadLocal.set()' with null as an argument thread.local.set.with.null.problem.descriptor = 'ThreadLocal.set()' with null as an argument may cause memory leak thread.local.set.with.null.quickfix = Replace with 'ThreadLocal.remove()' call notify.without.corresponding.wait.display.name='notify()' without corresponding 'wait()' -notify.without.corresponding.wait.problem.descriptor=Call to #ref() without corresponding wait() #loc +notify.without.corresponding.wait.problem.descriptor=Call to #ref() without corresponding wait() integer.multiplication.implicit.cast.to.long.display.name=Integer multiplication or shift implicitly cast to 'long' -integer.multiplication.implicit.cast.to.long.problem.descriptor=#ref: integer multiplication implicitly cast to long #loc +integer.multiplication.implicit.cast.to.long.problem.descriptor=#ref: integer multiplication implicitly cast to long integer.multiplication.implicit.cast.to.long.quickfix=Cast to long -integer.shift.implicit.cast.to.long.problem.descriptor=#ref: integer shift implicitly cast to long #loc +integer.shift.implicit.cast.to.long.problem.descriptor=#ref: integer shift implicitly cast to long integer.multiplication.implicit.cast.to.long.option=Ignore expressions where it's proven statically that overflow is impossible wait.or.await.without.timeout.display.name='wait()' or 'await()' without timeout -wait.or.await.without.timeout.problem.descriptor=#ref without timeout #loc +wait.or.await.without.timeout.problem.descriptor=#ref without timeout method.return.always.constant.display.name=Method returns per-class constant method.return.always.constant.problem.descriptor=Method #ref() and all its derivables always return constants class.with.too.many.dependencies.display.name=Class with too many dependencies @@ -1488,80 +1488,80 @@ package.naming.convention.problem.descriptor.short=Package name {0} package.naming.convention.problem.descriptor.long=Package name {0} is too long package.naming.convention.problem.descriptor.regex.mismatch=Package name {0} doesn''t match regex ''{1}'' design.for.extension.display.name=Design for extension -design.for.extension.problem.descriptor=Method #ref() may be overridden and its functionality ignored #loc +design.for.extension.problem.descriptor=Method #ref() may be overridden and its functionality ignored bad.oddness.display.name=Suspicious oddness check -bad.oddness.problem.descriptor=Oddness check will fail on negative values #loc +bad.oddness.problem.descriptor=Oddness check will fail on negative values comparator.not.serializable.display.name='Comparator' class not declared 'Serializable' -comparator.not.serializable.problem.descriptor=Comparator class #ref is not declared as Serializable #loc +comparator.not.serializable.problem.descriptor=Comparator class #ref is not declared as Serializable non.serializable.field.in.serializable.class.display.name=Non-serializable field in a 'Serializable' class -non.serializable.field.in.serializable.class.problem.descriptor=Non-serializable field '#ref' in Serializable class #loc -non.serializable.component.in.serializable.record.problem.descriptor=Non-serializable component '#ref' in Serializable record #loc +non.serializable.field.in.serializable.class.problem.descriptor=Non-serializable field '#ref' in Serializable class +non.serializable.component.in.serializable.record.problem.descriptor=Non-serializable component '#ref' in Serializable record non.serializable.object.passed.to.object.stream.display.name=Non-serializable object passed to 'ObjectOutputStream' -non.serializable.object.passed.to.object.stream.problem.descriptor=Non-serializable object passed to ObjectOutputStream #loc +non.serializable.object.passed.to.object.stream.problem.descriptor=Non-serializable object passed to ObjectOutputStream non.serializable.object.bound.to.http.session.display.name=Non-serializable object bound to 'HttpSession' -non.serializable.object.bound.to.http.session.problem.descriptor=Non-serializable object bound to HttpSession #loc +non.serializable.object.bound.to.http.session.problem.descriptor=Non-serializable object bound to HttpSession reflection.for.unavailable.annotation.display.name=Reflective access to a source-only annotation -reflection.for.unavailable.annotation.problem.descriptor=Annotation '#ref' is not retained for reflective access #loc +reflection.for.unavailable.annotation.problem.descriptor=Annotation '#ref' is not retained for reflective access access.to.static.field.locked.on.instance.display.name=Access to 'static' field locked on instance data -access.to.static.field.locked.on.instance.problem.descriptor=Access to static field #ref locked on instance data #loc +access.to.static.field.locked.on.instance.problem.descriptor=Access to static field #ref locked on instance data access.to.static.field.locked.on.instance.fix.name=Ignore static fields with type ''{0}'' make.method.ctr.quickfix=Make method constructor replace.all.dot.display.name=Suspicious regex expression argument -replace.all.dot.problem.descriptor=Suspicious regex expression #ref in call to ''{0}()'' #loc +replace.all.dot.problem.descriptor=Suspicious regex expression #ref in call to ''{0}()'' replace.all.file.separator.problem.descriptor=File.separator is used as a regex; will not work on Windows replace.all.dot.quickfix=Escape regex meta character class.extends.utility.class.display.name=Class extends utility class -class.extends.utility.class.problem.descriptor=Class #ref extends utility class ''{0}'' #loc +class.extends.utility.class.problem.descriptor=Class #ref extends utility class ''{0}'' class.extends.utility.class.ignore.utility.class.option=Ignore if overriding class is a utility class public.constructor.in.non.public.class.quickfix=Make constructor private assignment.to.method.parameter.ignore.transformation.option=Ignore if assignment is a transformation of the original parameter type.parameter.extends.final.class.display.name=Type parameter extends 'final' class -type.parameter.extends.final.class.type.parameter.problem.descriptor=Type parameter #ref extends ''final'' class ''{0}'' #loc -type.parameter.extends.enum.type.parameter.problem.descriptor=Type parameter #ref extends implicitly final enum ''{0}'' #loc -type.parameter.extends.final.class.wildcard.problem.descriptor=Wildcard type argument #ref extends ''final'' class ''{0}'' #loc -type.parameter.extends.enum.wildcard.problem.descriptor=Wildcard type argument #ref extends implicitly final enum ''{0}'' #loc +type.parameter.extends.final.class.type.parameter.problem.descriptor=Type parameter #ref extends ''final'' class ''{0}'' +type.parameter.extends.enum.type.parameter.problem.descriptor=Type parameter #ref extends implicitly final enum ''{0}'' +type.parameter.extends.final.class.wildcard.problem.descriptor=Wildcard type argument #ref extends ''final'' class ''{0}'' +type.parameter.extends.enum.wildcard.problem.descriptor=Wildcard type argument #ref extends implicitly final enum ''{0}'' type.parameter.extends.final.class.quickfix=Replace type parameter with actual class double.negation.display.name=Double negation -double.negation.problem.descriptor=Double negation in #ref #loc +double.negation.problem.descriptor=Double negation in #ref double.negation.quickfix=Remove double negation exception.from.catch.which.doesntwrap.ignore.option=Ignore if result of exception method call is used exception.from.catch.which.doesntwrap.ignore.cant.wrap.option=Ignore if thrown exception cannot wrap an exception comparable.implemented.but.equals.not.overridden.display.name='Comparable' implemented but 'equals()' not overridden -comparable.implemented.but.equals.not.overridden.problem.descriptor=Class #ref implements 'java.lang.Comparable' but does not override 'equals()' #loc +comparable.implemented.but.equals.not.overridden.problem.descriptor=Class #ref implements 'java.lang.Comparable' but does not override 'equals()' comparable.implemented.but.equals.not.overridden.fix.add.note.name=Add 'ordering inconsistent with equals' JavaDoc note comparable.implemented.but.equals.not.overridden.fix.generate.equals.name=Generate 'equals()' method unqualified.field.access.display.name=Instance field access not qualified with 'this' -unqualified.field.access.problem.descriptor=Instance field access #ref is not qualified with 'this' #loc +unqualified.field.access.problem.descriptor=Instance field access #ref is not qualified with 'this' unqualified.method.access.display.name=Instance method call not qualified with 'this' -unqualified.method.access.problem.descriptor=Instance method call #ref() is not qualified with 'this' #loc +unqualified.method.access.problem.descriptor=Instance method call #ref() is not qualified with 'this' add.this.qualifier.quickfix=Add 'this' qualifier while.loop.spins.on.field.ignore.non.empty.loops.option=Only warn if the loop is empty -method.may.be.synchronized.problem.descriptor=Method #ref() with synchronized block can be synchronized method #loc +method.may.be.synchronized.problem.descriptor=Method #ref() with synchronized block can be synchronized method method.may.be.synchronized.display.name=Method with single 'synchronized' block can be replaced with 'synchronized' method method.may.be.synchronized.quickfix=Make method synchronized and remove synchronized block fallthru.in.switch.statement.quickfix=Add ''{0}'' law.of.demeter.display.name=Law of Demeter -law.of.demeter.problem.descriptor=Call to #ref() violates Law of Demeter #loc -law.of.demeter.field.problem.descriptor=Access of #ref violates Law of Demeter #loc +law.of.demeter.problem.descriptor=Call to #ref() violates Law of Demeter +law.of.demeter.field.problem.descriptor=Access of #ref violates Law of Demeter law.of.demeter.ignore.library.calls.option=Ignore calls to library methods and access to library fields masked.assertion.display.name=Assertion is suppressed by 'catch' masked.assertion.problem.description=''{0}'' cannot fail as it''s suppressed by a surrounding ''catch'' enumeration.can.be.iteration.display.name=Enumeration can be iteration -enumeration.can.be.iteration.problem.descriptor=#ref() can be replaced with ''{0}'' construct #loc +enumeration.can.be.iteration.problem.descriptor=#ref() can be replaced with ''{0}'' construct enumeration.can.be.iteration.quickfix=Replace with 'Iterator' construct -implicit.array.to.string.problem.descriptor=Implicit call to 'toString()' on array #ref #loc -explicit.array.to.string.problem.descriptor=Call to '#ref()' on array #loc -implicit.array.to.string.method.call.problem.descriptor=Implicit call to 'toString()' on array returned by call to #ref #loc +implicit.array.to.string.problem.descriptor=Implicit call to 'toString()' on array #ref +explicit.array.to.string.problem.descriptor=Call to '#ref()' on array +implicit.array.to.string.method.call.problem.descriptor=Implicit call to 'toString()' on array returned by call to #ref implicit.array.to.string.display.name=Call to 'toString()' on array implicit.array.to.string.quickfix=Wrap with ''{0}'' expression -suspicious.indent.after.control.statement.problem.descriptor=Suspicious indentation after ''{0}'' statement #loc +suspicious.indent.after.control.statement.problem.descriptor=Suspicious indentation after ''{0}'' statement suspicious.indent.after.control.statement.display.name=Suspicious indentation after control statement without braces unpredictable.big.decimal.constructor.call.display.name=Unpredictable 'BigDecimal' constructor call -unpredictable.big.decimal.constructor.call.problem.descriptor=Unpredictable new #ref() call #loc +unpredictable.big.decimal.constructor.call.problem.descriptor=Unpredictable new #ref() call unpredictable.big.decimal.constructor.call.ignore.references.option=Ignore constructor calls with variable or method call arguments unpredictable.big.decimal.constructor.call.ignore.complex.literals.option=Ignore constructor calls with multiple literals (e.g. 0.1 + 0.2) unnecessary.unary.minus.display.name=Unnecessary unary minus -unnecessary.unary.minus.problem.descriptor=Unnecessary unary #ref operator #loc +unnecessary.unary.minus.problem.descriptor=Unnecessary unary #ref operator unnecessary.unary.minus.quickfix=Remove unary minus and invert parent operation sign unnecessary.unary.minus.remove.quickfix=Remove double unary minus make.field.final.quickfix=Make ''{0}'' ''final'' @@ -1569,80 +1569,80 @@ increment.decrement.used.as.expression.quickfix=Extract ''{0}'' to separate stat ignore.classes.in.hierarchy.column.name=Ignore subclasses of: overly.strong.type.cast.ignore.in.matching.instanceof.option=Ignore casts with a matching instanceof expression access.to.non.thread.safe.static.field.from.instance.display.name=Non-thread-safe 'static' field access -access.to.non.thread.safe.static.field.from.instance.field.problem.descriptor=Access to non-thread-safe static field #ref of type ''{0}'' #loc +access.to.non.thread.safe.static.field.from.instance.field.problem.descriptor=Access to non-thread-safe static field #ref of type ''{0}'' access.to.non.thread.safe.static.field.from.instance.option.title=Non-thread-safe classes: access.to.non.thread.safe.static.field.from.instance.class.chooser.title=Choose Non-Thread-Safe Class transient.field.not.initialized.display.name=Transient field is not initialized on deserialization -transient.field.not.initialized.problem.descriptor=Transient field #ref not initialized on deserialization #loc +transient.field.not.initialized.problem.descriptor=Transient field #ref not initialized on deserialization call.to.string.concat.can.be.replaced.by.operator.display.name=Call to 'String.concat()' can be replaced with '+' -call.to.string.concat.can.be.replaced.by.operator.problem.descriptor=Call to #ref() can be replaced with '+' expression #loc +call.to.string.concat.can.be.replaced.by.operator.problem.descriptor=Call to #ref() can be replaced with '+' expression call.to.string.concat.can.be.replaced.by.operator.quickfix=Replace 'concat()' call with '+' new.string.buffer.with.char.argument.display.name=StringBuilder constructor call with 'char' argument -new.string.buffer.with.char.argument.problem.descriptor=new #ref() with argument of type 'char' #loc +new.string.buffer.with.char.argument.problem.descriptor=new #ref() with argument of type 'char' new.string.buffer.with.char.argument.quickfix=Replace char argument with String literal math.rounding.with.int.argument.display.name=Call math rounding with 'int' argument -math.rounding.with.int.argument.problem.descriptor=#ref() with argument of type 'int' #loc +math.rounding.with.int.argument.problem.descriptor=#ref() with argument of type 'int' math.rounding.with.int.argument.quickfix=Simplify ''{0}()'' call math.rounding.with.int.argument.family.name=Simplify rounding calls suspicious.comparator.compare.display.name=Suspicious 'Comparator.compare()' implementation -suspicious.comparator.compare.descriptor.parameter.not.used=''{0}()'' parameter #ref is not used #loc +suspicious.comparator.compare.descriptor.parameter.not.used=''{0}()'' parameter #ref is not used suspicious.comparator.compare.descriptor.non.reflexive=Comparator does not return 0 for equal elements suspicious.comparator.compare.descriptor.non.positive=Comparator never returns positive values suspicious.comparator.compare.descriptor.non.negative=Comparator never returns negative values suspicious.comparator.compare.descriptor.min.value=Returning Integer.MIN_VALUE from a comparison function is discouraged to.array.call.style.display.name='Collection.toArray()' call style -to.array.call.style.problem.descriptor.zero=Call to #ref() with empty array argument ''{0}'' #loc -to.array.call.style.problem.descriptor.presized=Call to #ref() with pre-sized array argument ''{0}'' #loc +to.array.call.style.problem.descriptor.zero=Call to #ref() with empty array argument ''{0}'' +to.array.call.style.problem.descriptor.presized=Call to #ref() with pre-sized array argument ''{0}'' to.array.call.style.quickfix.family.name=Fix size of array passed to 'toArray()' call to.array.call.style.quickfix.make.presized=Replace argument with pre-sized array to.array.call.style.quickfix.make.zero=Replace argument with empty array -throwable.instance.never.thrown.runtime.exception.problem.descriptor=Runtime exception instance new #ref() is not thrown #loc -throwable.instance.never.thrown.checked.exception.problem.descriptor=Checked exception instance #ref is not thrown #loc -throwable.instance.never.thrown.error.problem.descriptor=Error instance #ref is not thrown #loc -throwable.instance.never.thrown.problem.descriptor=Throwable instance #ref is not thrown #loc +throwable.instance.never.thrown.runtime.exception.problem.descriptor=Runtime exception instance new #ref() is not thrown +throwable.instance.never.thrown.checked.exception.problem.descriptor=Checked exception instance #ref is not thrown +throwable.instance.never.thrown.error.problem.descriptor=Error instance #ref is not thrown +throwable.instance.never.thrown.problem.descriptor=Throwable instance #ref is not thrown ignore.guard.clauses.option=Ignore &guard clauses ignore.for.equals.methods.option=Ignore for '&equals()' methods caught.exception.immediately.rethrown.display.name=Caught exception is immediately rethrown -caught.exception.immediately.rethrown.problem.descriptor=Caught exception #ref is immediately rethrown #loc +caught.exception.immediately.rethrown.problem.descriptor=Caught exception #ref is immediately rethrown delete.catch.section.quickfix=Delete 'catch' section loop.with.implicit.termination.condition.display.name=Loop with implicit termination condition -loop.with.implicit.termination.condition.dowhile.problem.descriptor=#ref-while loop with implicit termination condition #loc -loop.with.implicit.termination.condition.problem.descriptor=#ref loop with implicit termination condition #loc +loop.with.implicit.termination.condition.dowhile.problem.descriptor=#ref-while loop with implicit termination condition +loop.with.implicit.termination.condition.problem.descriptor=#ref loop with implicit termination condition loop.with.implicit.termination.condition.quickfix=Make condition explicit inspection.empty.catch.block.generate.body=Generate 'catch' body from template unnecessary.super.qualifier.display.name=Unnecessary 'super' qualifier -unnecessary.super.qualifier.problem.descriptor=Qualifier #ref is unnecessary in this context #loc +unnecessary.super.qualifier.problem.descriptor=Qualifier #ref is unnecessary in this context unnecessary.super.qualifier.quickfix=Remove unnecessary 'super' qualifier collections.field.access.replaceable.by.method.call.display.name=Reference to empty collection field can be replaced with method call -collections.field.access.replaceable.by.method.call.problem.descriptor=#ref can be replaced with ''Collections.{0}'' #loc +collections.field.access.replaceable.by.method.call.problem.descriptor=#ref can be replaced with ''Collections.{0}'' synchronization.on.local.variable.or.method.parameter.display.name=Synchronization on local variable or method parameter -synchronization.on.local.variable.problem.descriptor=Synchronization on local variable #ref #loc -synchronization.on.method.parameter.problem.descriptor=Synchronization on method parameter #ref #loc +synchronization.on.local.variable.problem.descriptor=Synchronization on local variable #ref +synchronization.on.method.parameter.problem.descriptor=Synchronization on method parameter #ref too.broad.catch.quickfix=Add ''catch'' clause for ''{0}'' replace.with.catch.clause.for.runtime.exception.quickfix=Replace with 'catch' clause for 'RuntimeException' too.broad.catch.option=&Only warn on RuntimeException, Exception, Error or Throwable unnecessary.conversion.to.string.display.name=Unnecessary conversion to 'String' unnecessary.tostring.call.display.name=Unnecessary call to 'toString()' -unnecessary.tostring.call.problem.descriptor=Unnecessary #ref() call #loc +unnecessary.tostring.call.problem.descriptor=Unnecessary #ref() call unnecessary.tostring.call.problem.empty.string.descriptor=Can be replaced with concatenation with empty string unnecessary.tostring.call.option.report.with.empty.string=Report calls that can be replaced with a concatenation with the empty string throwable.not.thrown.display.name='Throwable' not thrown -throwable.result.of.method.call.ignored.problem.descriptor=Result of #ref() not thrown #loc +throwable.result.of.method.call.ignored.problem.descriptor=Result of #ref() not thrown char.used.in.arithmetic.context.display.name='char' expression used in arithmetic context -char.used.in.arithmetic.context.problem.descriptor='char' used in arithmetic context #loc +char.used.in.arithmetic.context.problem.descriptor='char' used in arithmetic context char.used.in.arithmetic.context.quickfix=Convert to String literal char.used.in.arithmetic.context.cast.quickfix=Insert cast to {0} unnecessary.constant.array.creation.expression.display.name=Redundant 'new' expression in constant array creation -unnecessary.constant.array.creation.expression.problem.descriptor=#ref can be removed from new array expression #loc +unnecessary.constant.array.creation.expression.problem.descriptor=#ref can be removed from new array expression unnecessary.constant.array.creation.expression.family.quickfix=Remove type specification from new array expression ambiguous.method.call.display.name=Call to inherited method looks like call to local method -ambiguous.method.call.problem.descriptor=Call to method #ref() from superclass ''{0}'' looks like call to method from class ''{1}'' #loc +ambiguous.method.call.problem.descriptor=Call to method #ref() from superclass ''{0}'' looks like call to method from class ''{1}'' ambiguous.method.call.quickfix=Add 'super' qualifier to method call change.modifier.quickfix=Make ''{0}'' change.modifier.package.private.quickfix=Make package-private the.whole.project=the whole project this.class=this class -logger.initialized.with.foreign.class.problem.descriptor=Logger initialized with foreign class #ref #loc +logger.initialized.with.foreign.class.problem.descriptor=Logger initialized with foreign class #ref logger.initialized.with.foreign.class.display.name=Logger initialized with foreign class logger.factory.method.name=Logger Factory Method Name logger.factory.class.name=Logger Factory Class Name @@ -1651,34 +1651,34 @@ logger.initialized.with.foreign.class.ignore.non.public.classes.option=Ignore lo logger.initialized.with.foreign.class.ignore.not.final.field=Ignore loggers not initialized in a final field make.static.final.quickfix=Make ''{0}'' static final log.statement.guarded.by.log.condition.display.name=Logging call not guarded by log condition -log.statement.guarded.by.log.condition.problem.descriptor=#ref() logging calls not guarded by log condition #loc +log.statement.guarded.by.log.condition.problem.descriptor=#ref() logging calls not guarded by log condition log.statement.guarded.by.log.condition.quickfix=Surround with log condition log.statement.guarded.by.log.condition.flag.all.unguarded.option=Flag all unguarded logging calls key.set.iteration.may.use.entry.set.display.name=Iteration over 'keySet()' can be optimized -key.set.iteration.may.use.entry.set.problem.descriptor=Iteration over #ref may be replaced with ''{0}'' iteration #loc +key.set.iteration.may.use.entry.set.problem.descriptor=Iteration over #ref may be replaced with ''{0}'' iteration key.set.iteration.may.use.entry.set.quickfix=Optimize Map iteration string.replaceable.by.string.buffer.in.loop.option=Only warn when appending in a loop declare.collection.as.interface.quickfix=Weaken to ''{0}'' non.exception.name.ends.with.exception.quickfix=Make ''{0}'' extend ''java.lang.Exception'' constant.value.variable.use.display.name=Use of variable whose value is known to be constant -constant.value.variable.use.problem.descriptor=Value of #ref is known to be constant #loc +constant.value.variable.use.problem.descriptor=Value of #ref is known to be constant unnecessary.parentheses.option=Ignore clarifying parentheses unnecessary.parentheses.conditional.option=Ignore parentheses around the condition of conditional expressions field.may.be.final.display.name=Field may be 'final' -field.may.be.final.problem.descriptor=Field #ref may be 'final' #loc +field.may.be.final.problem.descriptor=Field #ref may be 'final' cast.that.loses.precision.option=Ignore casts from int to char ignore.overflowing.byte.casts.option=Ignore casts from int 128-255 to byte variable.not.used.inside.if.display.name=Reference checked for 'null' is not used inside 'if' -variable.not.used.inside.if.problem.descriptor=#ref checked for 'null' is not used inside 'if' #loc -variable.not.used.inside.conditional.problem.descriptor=#ref checked for 'null' is not used inside conditional #loc +variable.not.used.inside.if.problem.descriptor=#ref checked for 'null' is not used inside 'if' +variable.not.used.inside.conditional.problem.descriptor=#ref checked for 'null' is not used inside conditional boolean.expression.may.be.conditional.display.name=Boolean expression can be replaced with conditional expression -if.may.be.conditional.problem.descriptor=#ref can be replaced with conditional expression #loc +if.may.be.conditional.problem.descriptor=#ref can be replaced with conditional expression if.may.be.conditional.quickfix=Replace with conditional expression expression.may.be.factorized.display.name=Expression can be factorized -if.may.be.factorized.problem.descriptor=#ref can be factorized #loc +if.may.be.factorized.problem.descriptor=#ref can be factorized if.may.be.factorized.quickfix=Replace with factorized expression redundant.string.format.call.display.name=Redundant call to 'String.format()' -redundant.call.problem.descriptor=Redundant call to #ref() #loc +redundant.call.problem.descriptor=Redundant call to #ref() inspection.redundant.java.time.operation.display.name=Redundant operation on 'java.time' object inspection.redundant.java.time.operation.explicit.chrono.field.family.name=Simplify calls with explicit 'ChronoField' or 'ChronoUnit' arguments inspection.redundant.java.time.operation.explicit.chrono.field.problem.descriptor=Calls with explicit 'ChronoField' or 'ChronoUnit' arguments can be simplified @@ -1693,39 +1693,39 @@ inspection.redundant.java.time.operation.compare.java.time.problem.descriptor=Ex redundant.string.format.call.quickfix=Remove redundant call to 'String.format()' redundant.string.formatted.call.quickfix=Remove redundant call to 'String.formatted()' equals.called.on.enum.constant.display.name='equals()' called on enum value -equals.called.on.enum.constant.problem.descriptor=#ref() called on enum value #loc +equals.called.on.enum.constant.problem.descriptor=#ref() called on enum value int.literal.may.be.long.literal.display.name=Cast to 'long' can be 'long' literal -int.literal.may.be.long.literal.problem.descriptor=#ref can be replaced with ''{0}'' #loc +int.literal.may.be.long.literal.problem.descriptor=#ref can be replaced with ''{0}'' constant.assert.condition.display.name=Constant condition in 'assert' statement -constant.assert.condition.problem.descriptor=Assert condition #ref is constant #loc +constant.assert.condition.problem.descriptor=Assert condition #ref is constant assert.with.side.effects.display.name='assert' statement with side effects -assert.with.side.effects.problem.descriptor=#ref has side effects: {0} #loc +assert.with.side.effects.problem.descriptor=#ref has side effects: {0} method.count.ignore.getters.setters.option=&Ignore simple getter and setter methods class.new.instance.display.name=Unsafe call to 'Class.newInstance()' -class.new.instance.problem.descriptor=Call to #ref() may throw undeclared checked exceptions #loc +class.new.instance.problem.descriptor=Call to #ref() may throw undeclared checked exceptions dynamic.regex.replaceable.by.compiled.pattern.display.name=Dynamic regular expression can be replaced by compiled 'Pattern' -dynamic.regex.replaceable.by.compiled.pattern.problem.descriptor=#ref() can be replaced with compiled 'java.util.regex.Pattern' construct #loc +dynamic.regex.replaceable.by.compiled.pattern.problem.descriptor=#ref() can be replaced with compiled 'java.util.regex.Pattern' construct dynamic.regex.replaceable.by.compiled.pattern.quickfix=Replace with call to method of compiled 'Pattern' constant ignore.serializable.option=Ignore 'java.io.Serializable' ignore.cloneable.option=Ignore 'java.lang.Cloneable' listener.may.use.adapter.display.name=Class may extend adapter instead of implementing listener -listener.may.use.adapter.problem.descriptor=Class ''{0}'' may extend ''{1}'' instead of implementing #ref #loc +listener.may.use.adapter.problem.descriptor=Class ''{0}'' may extend ''{1}'' instead of implementing #ref listener.may.use.adapter.emtpy.methods.option=&Only warn when empty implementing methods are found unnecessary.inherit.doc.display.name=Unnecessary '{@inheritDoc}' Javadoc comment -unnecessary.inherit.doc.problem.descriptor=Javadoc comment containing only #ref is unnecessary #loc -unnecessary.inherit.doc.field.invalid.problem.descriptor=#ref is not valid on fields #loc -unnecessary.inherit.doc.constructor.invalid.problem.descriptor=#ref is not valid on constructors #loc -unnecessary.inherit.doc.class.invalid.problem.descriptor=#ref is not valid on classes #loc -unnecessary.inherit.doc.module.invalid.problem.descriptor=#ref is not valid on module declarations #loc -unnecessary.inherit.doc.constructor.no.super.problem.descriptor=No super method found to inherit Javadoc from #loc +unnecessary.inherit.doc.problem.descriptor=Javadoc comment containing only #ref is unnecessary +unnecessary.inherit.doc.field.invalid.problem.descriptor=#ref is not valid on fields +unnecessary.inherit.doc.constructor.invalid.problem.descriptor=#ref is not valid on constructors +unnecessary.inherit.doc.class.invalid.problem.descriptor=#ref is not valid on classes +unnecessary.inherit.doc.module.invalid.problem.descriptor=#ref is not valid on module declarations +unnecessary.inherit.doc.constructor.no.super.problem.descriptor=No super method found to inherit Javadoc from unnecessary.inherit.doc.quickfix=Remove unnecessary {@inheritDoc} unnecessary.javadoc.link.display.name=Unnecessary Javadoc link -unnecessary.javadoc.link.super.method.problem.descriptor=#ref pointing to super method is unnecessary #loc -unnecessary.javadoc.link.this.method.problem.descriptor=#ref pointing to this method is unnecessary #loc -unnecessary.javadoc.link.this.class.problem.descriptor=#ref pointing to containing class is unnecessary #loc +unnecessary.javadoc.link.super.method.problem.descriptor=#ref pointing to super method is unnecessary +unnecessary.javadoc.link.this.method.problem.descriptor=#ref pointing to this method is unnecessary +unnecessary.javadoc.link.this.class.problem.descriptor=#ref pointing to containing class is unnecessary unnecessary.javadoc.link.quickfix=Remove unnecessary ''{0}'' thread.local.not.static.final.display.name='ThreadLocal' field not declared 'static final' -thread.local.not.static.final.problem.descriptor=ThreadLocal #ref is not declared 'static final' #loc +thread.local.not.static.final.problem.descriptor=ThreadLocal #ref is not declared 'static final' remove.try.finally.block.quickfix=Remove 'try-finally' block remove.finally.block.quickfix=Remove 'finally' block remove.leading.zero.to.make.decimal.quickfix=Remove leading zero to make decimal @@ -1765,22 +1765,22 @@ ignore.classes.annotated.by=Ignore classes annotated by: ignored.class.hierarchies.border.title=Ignore subclasses of: choose.class.hierarchy.to.ignore.title=Choose Class Hierarchy to Ignore unqualified.inner.class.access.display.name=Unqualified inner class access -unqualified.inner.class.access.problem.descriptor=#ref is not qualified with outer class #loc +unqualified.inner.class.access.problem.descriptor=#ref is not qualified with outer class unqualified.inner.class.access.quickfix=Qualify with outer class -unnecessarily.qualified.inner.class.access.problem.descriptor=''{0}'' is unnecessarily qualified with #ref #loc +unnecessarily.qualified.inner.class.access.problem.descriptor=''{0}'' is unnecessarily qualified with #ref unnecessarily.qualified.inner.class.access.display.name=Unnecessarily qualified inner class access unnecessarily.qualified.inner.class.access.quickfix=Remove qualifier synchronization.on.static.field.display.name=Synchronization on 'static' field -synchronization.on.static.field.problem.descriptor=Synchronization on 'static' field #ref #loc +synchronization.on.static.field.problem.descriptor=Synchronization on 'static' field #ref overly.broad.throws.clause.display.name=Overly broad 'throws' clause -overly.broad.throws.clause.problem.descriptor1=throws #ref is too broad, masking exception ''{0}'' #loc -overly.broad.throws.clause.problem.descriptor2=throws #ref is too broad, masking exceptions ''{0}'' and ''{1}'' #loc +overly.broad.throws.clause.problem.descriptor1=throws #ref is too broad, masking exception ''{0}'' +overly.broad.throws.clause.problem.descriptor2=throws #ref is too broad, masking exceptions ''{0}'' and ''{1}'' overly.broad.throws.clause.quickfix1=Add specific exceptions overly.broad.throws.clause.quickfix2=Replace with specific exceptions overly.broad.throws.clause.ignore.thrown.option=Ignore exceptions which &hide others but are themselves thrown overly.broad.throws.clause.threshold.option=Maximum number of hidden exceptions to report: unnecessarily.qualified.statically.imported.element.display.name=Unnecessarily qualified statically imported element -unnecessarily.qualified.statically.imported.element.problem.descriptor=Statically imported element ''{0}'' is unnecessarily qualified with #ref #loc +unnecessarily.qualified.statically.imported.element.problem.descriptor=Statically imported element ''{0}'' is unnecessarily qualified with #ref unnecessarily.qualified.statically.imported.element.quickfix=Remove unnecessary qualifier ignore.instanceof.on.library.classes=Ignore instanceof on library classes for.can.be.foreach.option=Report indexed 'java.util.List' loops @@ -1793,22 +1793,22 @@ double.literal.may.be.float.literal.display.name=Cast to 'float' can be 'float' multiple.declaration.ignore.for.option=Ignore 'for' loop declarations multiple.declaration.array.only.option=Only warn on different array dimensions in a single declaration simplifiable.annotation.display.name=Simplifiable annotation -simplifiable.annotation.problem.descriptor=Unnecessary #ref in annotation #loc -simplifiable.annotation.braces.problem.descriptor=Unnecessary braces around {0} in annotation #loc -simplifiable.annotation.whitespace.problem.descriptor=Unnecessary whitespace in annotation #loc +simplifiable.annotation.problem.descriptor=Unnecessary #ref in annotation +simplifiable.annotation.braces.problem.descriptor=Unnecessary braces around {0} in annotation +simplifiable.annotation.whitespace.problem.descriptor=Unnecessary whitespace in annotation simplifiable.annotation.quickfix=Simplify annotation overloaded.methods.with.same.number.parameters.option=Ignore overloaded methods whose parameter types are definitely incompatible string.concatenation.in.format.call.display.name=String concatenation as argument to 'format()' call string.concatenation.in.format.call.problem.descriptor=''{0}()'' call has a String concatenation argument string.concatenation.in.format.call.quickfix=Replace concatenation with separate argument string.concatenation.in.message.format.call.display.name=String concatenation as argument to 'MessageFormat.format()' call -string.concatenation.in.message.format.call.problem.descriptor=String concatenation as argument to 'MessageFormat.format()' call #loc +string.concatenation.in.message.format.call.problem.descriptor=String concatenation as argument to 'MessageFormat.format()' call boxing.boxed.value.display.name=Boxing of already boxed value -boxing.boxed.value.problem.descriptor=Boxing of already boxed #ref #loc +boxing.boxed.value.problem.descriptor=Boxing of already boxed #ref boxing.boxed.value.quickfix=Remove unnecessary boxing unnecessary.javadoc.link.option=Ignore inline links to super methods constant.junit.assert.argument.display.name=Constant assert argument -constant.junit.assert.argument.problem.descriptor=Argument #ref is constant #loc +constant.junit.assert.argument.problem.descriptor=Argument #ref is constant package.dot.html.may.be.package.info.display.name='package.html' may be converted to 'package-info.java' package.dot.html.may.be.package.info.exists.problem.descriptor=package.html is ignored because package-info.java exists package.dot.html.may.be.package.info.problem.descriptor=package.html may be converted to package-info.java @@ -1816,9 +1816,9 @@ package.dot.html.may.be.package.info.delete.quickfix=Delete 'package.html' package.dot.html.may.be.package.info.convert.quickfix=Convert to 'package-info.java' ignore.anonymous.inner.classes=Ignore anonymous classes try.with.identical.catches.display.name=Identical 'catch' branches in 'try' statement -try.with.identical.catches.problem.descriptor=''catch'' branch identical to ''{0}'' branch #loc +try.with.identical.catches.problem.descriptor=''catch'' branch identical to ''{0}'' branch if.can.be.switch.display.name='if' can be replaced with 'switch' -if.can.be.switch.problem.descriptor=#ref statement can be replaced with 'switch' statement #loc +if.can.be.switch.problem.descriptor=#ref statement can be replaced with 'switch' statement if.can.be.switch.minimum.branch.option=Minimum number of 'if' condition branches: if.can.be.switch.int.option=Suggest switch on numbers if.can.be.switch.enum.option=Suggest switch on enums @@ -1828,40 +1828,40 @@ unqualified.inner.class.access.option=Ignore references to local inner classes try.with.identical.catches.quickfix=Collapse 'catch' blocks confusing.else.option=Report when there are no more statements after the 'if' statement html.tag.can.be.javadoc.tag.display.name='\u2026' can be replaced with '{@code \u2026}' -html.tag.can.be.javadoc.tag.problem.descriptor=#ref...\\</code\\> can be replaced with '{@code \u2026}' #loc +html.tag.can.be.javadoc.tag.problem.descriptor=#ref...\\</code\\> can be replaced with '{@code \u2026}' try.finally.can.be.try.with.resources.display.name='try finally' can be replaced with 'try' with resources -try.finally.can.be.try.with.resources.problem.descriptor=#ref can use automatic resource management #loc +try.finally.can.be.try.with.resources.problem.descriptor=#ref can use automatic resource management try.finally.can.be.try.with.resources.quickfix=Replace with 'try' with resources array.comparison.display.name=Array comparison using '==', instead of 'Arrays.equals()' -array.comparison.problem.descriptor=Array objects are compared using #ref, not 'Arrays.equals()' #loc +array.comparison.problem.descriptor=Array objects are compared using #ref, not 'Arrays.equals()' array.hash.code.display.name='hashCode()' called on array -array.hash.code.problem.descriptor=#ref() called on array should probably be 'Arrays.hashCode()' #loc +array.hash.code.problem.descriptor=#ref() called on array should probably be 'Arrays.hashCode()' objects.hash.problem.descriptor=Array passed to 'Objects.hash()' should be wrapped in 'Arrays.hashcode()' wrap.with.arrays.hash.code.quickfix=Wrap with ''{0}'' method.can.be.variable.arity.method.display.name=Method can have varargs parameter -method.can.be.variable.arity.method.problem.descriptor=#ref() can be converted to varargs method #loc +method.can.be.variable.arity.method.problem.descriptor=#ref() can be converted to varargs method method.can.be.variable.arity.method.ignore.byte.short.option=Ignore parameters with type byte[] or short[] method.can.be.variable.arity.method.ignore.all.primitive.arrays.option=Ignore all primitive array types method.can.be.variable.arity.method.ignore.multiple.arrays.option=Ignore methods with multiple array parameters method.can.be.variable.arity.method.ignore.multidimensional.arrays.option=Ignore multidimensional array parameters convert.to.variable.arity.method.quickfix=Convert to varargs method mismatched.string.builder.query.update.display.name=Mismatched query and update of 'StringBuilder' -mismatched.string.builder.updated.problem.descriptor=Contents of {0} #ref are updated, but never queried #loc -mismatched.string.builder.queried.problem.descriptor=Contents of {0} #ref are queried, but never updated #loc +mismatched.string.builder.updated.problem.descriptor=Contents of {0} #ref are updated, but never queried +mismatched.string.builder.queried.problem.descriptor=Contents of {0} #ref are queried, but never updated math.random.cast.to.int.display.name='Math.random()' cast to 'int' -math.random.cast.to.int.problem.descriptor=#ref cast to ''{0}'' is always rounded down to ''0'' #loc +math.random.cast.to.int.problem.descriptor=#ref cast to ''{0}'' is always rounded down to ''0'' math.random.cast.to.int.quickfix=Add parentheses to perform multiplication before cast boolean.variable.always.inverted.display.name=Boolean variable is always inverted -boolean.field.always.inverted.problem.descriptor=Boolean field #ref is always inverted #loc -boolean.variable.always.inverted.problem.descriptor=Boolean variable #ref is always inverted #loc +boolean.field.always.inverted.problem.descriptor=Boolean field #ref is always inverted +boolean.variable.always.inverted.problem.descriptor=Boolean variable #ref is always inverted unnecessary.explicit.numeric.cast.display.name=Unnecessary explicit numeric cast -unnecessary.explicit.numeric.cast.problem.descriptor=''{0}'' unnecessarily cast to #ref #loc +unnecessary.explicit.numeric.cast.problem.descriptor=''{0}'' unnecessarily cast to #ref unnecessary.explicit.numeric.cast.quickfix=Remove cast null.thrown.display.name='null' thrown -null.thrown.problem.descriptor=#ref thrown #loc +null.thrown.problem.descriptor=#ref thrown unnecessary.final.on.local.variable.or.parameter.display.name=Unnecessary 'final' on local variable or parameter -unnecessary.final.on.local.variable.problem.descriptor=Unnecessary #ref on variable ''{0}'' #loc -unnecessary.final.on.parameter.problem.descriptor=Unnecessary #ref on parameter ''{0}'' #loc +unnecessary.final.on.local.variable.problem.descriptor=Unnecessary #ref on variable ''{0}'' +unnecessary.final.on.parameter.problem.descriptor=Unnecessary #ref on parameter ''{0}'' unnecessary.final.report.local.variables.option=Report local variables unnecessary.final.report.pattern.variables.option=Report pattern variables unnecessary.final.report.method.parameters.option=Report method parameters @@ -1872,12 +1872,12 @@ unnecessary.final.on.parameter.only.interface.option.description=final#ref has no dependencies or dependents in its module #loc +class.independent.of.module.problem.descriptor=Class #ref has no dependencies or dependents in its module class.only.used.in.one.module.display.name=Class only used from one other module -class.only.used.in.one.module.problem.descriptor=Class #ref has only dependencies on and/or dependents in module ''{0}'' #loc +class.only.used.in.one.module.problem.descriptor=Class #ref has only dependencies on and/or dependents in module ''{0}'' simplifiable.equals.expression.option.non.constant=Report equals with non-constant non-null argument simplifiable.equals.expression.display.name=Unnecessary 'null' check before 'equals()' call -simplifiable.equals.expression.problem.descriptor=Unnecessary ''null'' check before ''{0}()'' call #loc +simplifiable.equals.expression.problem.descriptor=Unnecessary ''null'' check before ''{0}()'' call simplifiable.equals.expression.quickfix=Flip ''.{0}()'' and remove unnecessary ''null'' check use.of.concrete.class.option.ignore.abstract=Ignore abstract class type use.of.concrete.class.option.ignore.records=Ignore Java records @@ -1889,81 +1889,81 @@ use.of.concrete.class.option.report.instance.fields=Report instance field type use.of.concrete.class.option.report.instanceof=Report type used in instanceof, patterns, or getClass() comparison use.of.concrete.class.option.report.cast=Report type used in cast expression class.only.used.in.one.package.display.name=Class only used from one other package -class.only.used.in.one.package.problem.descriptor=Class #ref has only dependencies on and/or dependents in package ''{0}'' #loc +class.only.used.in.one.package.problem.descriptor=Class #ref has only dependencies on and/or dependents in package ''{0}'' unnecessary.return.option=Ignore in then branch of 'if' statement with 'else' branch unclear.binary.expression.display.name=Multiple operators with different precedence -unclear.binary.expression.problem.descriptor=Expression could use clarifying parentheses #loc +unclear.binary.expression.problem.descriptor=Expression could use clarifying parentheses unclear.binary.expression.quickfix=Add clarifying parentheses new.exception.without.arguments.display.name=Exception constructor called without arguments -new.exception.without.arguments.problem.descriptor=new #ref() without arguments #loc +new.exception.without.arguments.problem.descriptor=new #ref() without arguments absolute.alignment.in.user.interface.display.name=Absolute alignment in AWT/Swing code -absolute.alignment.in.user.interface.problem.descriptor=Absolute alignment constant {0}.#ref used #loc +absolute.alignment.in.user.interface.problem.descriptor=Absolute alignment constant {0}.#ref used throwable.supplier.only.throw.exception.name=Throwable supplier never returns a value throwable.supplier.only.throw.exception.problem.descriptor=Throwable supplier doesn't return any exception throwable.supplier.only.throw.exception.quickfix=Replace 'throw' with 'return' in lambda throws.runtime.exception.display.name=Unchecked exception declared in 'throws' clause -throws.runtime.exception.problem.descriptor=Unchecked exception #ref declared in 'throws' clause #loc +throws.runtime.exception.problem.descriptor=Unchecked exception #ref declared in 'throws' clause throws.runtime.exception.quickfix=Remove ''{0}'' from ''throws'' clause throws.runtime.exception.move.quickfix=Move ''{0}'' to Javadoc ''@throws'' tag empty.class.ignore.parameterization.option=Ignore class if it is a parameterization of a super type ambiguous.field.access.display.name=Access to inherited field looks like access to element from surrounding code -ambiguous.field.access.hides.local.variable.problem.descriptor=Access of field #ref from superclass ''{0}'' looks like access of local variable #loc -ambiguous.field.access.hides.parameter.problem.descriptor=Access of field #ref from superclass ''{0}'' looks like access of parameter #loc -ambiguous.field.access.hides.field.problem.descriptor=Access of field #ref from superclass ''{0}'' looks like access of field from surrounding class #loc +ambiguous.field.access.hides.local.variable.problem.descriptor=Access of field #ref from superclass ''{0}'' looks like access of local variable +ambiguous.field.access.hides.parameter.problem.descriptor=Access of field #ref from superclass ''{0}'' looks like access of parameter +ambiguous.field.access.hides.field.problem.descriptor=Access of field #ref from superclass ''{0}'' looks like access of field from surrounding class ambiguous.field.access.quickfix=Add 'super' qualifier to field access ambiguous.field.access.navigate.quickfix=Navigate to apparently accessed {0, choice, 1#local variable|2#parameter|3#field} add.0.to.ignore.if.annotated.by.list.quickfix=Add ''{0}'' to ''Ignore if annotated by'' list non.final.field.in.enum.display.name=Non-final field in 'enum' -non.final.field.in.enum.problem.descriptor=Non-final field #ref in enum ''{0}'' #loc +non.final.field.in.enum.problem.descriptor=Non-final field #ref in enum ''{0}'' non.final.field.in.enum.quickfix.option=Ignore fields that cannot be made 'final' externalizable.without.public.no.arg.constructor.display.name='Externalizable' class without 'public' no-arg constructor -externalizable.without.public.no.arg.constructor.problem.descriptor=Externalizable class #ref has no 'public' no-arg constructor #loc +externalizable.without.public.no.arg.constructor.problem.descriptor=Externalizable class #ref has no 'public' no-arg constructor make.constructor.public=Make constructor 'public' string.concatenation.missing.whitespace.display.name=Whitespace may be missing in string concatenation -string.concatenation.missing.whitespace.problem.descriptor=Whitespace may be missing in string concatenation #loc +string.concatenation.missing.whitespace.problem.descriptor=Whitespace may be missing in string concatenation string.concatenation.missing.whitespace.option=Ignore concatenations with variable strings negated.equality.expression.display.name=Negated equality expression -negated.equality.expression.problem.descriptor=Negating ''{0}'' #loc +negated.equality.expression.problem.descriptor=Negating ''{0}'' negated.equality.expression.quickfix=Remove negation negated.conditional.expression.display.name=Negated conditional expression -negated.conditional.expression.problem.descriptor=Negating conditional expression #loc +negated.conditional.expression.problem.descriptor=Negating conditional expression negated.conditional.expression.quickfix=Remove negation suspicious.array.cast.display.name=Suspicious array cast -suspicious.array.cast.problem.descriptor=Suspicious cast to #ref #loc +suspicious.array.cast.problem.descriptor=Suspicious cast to #ref public.constructor.display.name='public' constructor can be replaced with factory method public.default.constructor.problem.descriptor=Class #ref has default 'public' constructor -public.constructor.problem.descriptor=Public constructor #ref() #loc +public.constructor.problem.descriptor=Public constructor #ref() public.constructor.quickfix=Replace constructor with factory method none=none private=private package.local.private=package-private \\& private protected.package.local.private=protected, package-private \\& private non.final.utility.class.display.name=Utility class is not 'final' -non.final.utility.class.problem.descriptor=Utility class #ref is not 'final' #loc +non.final.utility.class.problem.descriptor=Utility class #ref is not 'final' 0.will.no.longer.be.overridable.by.1={0} will no longer be overridable by {1} weaken.visibility.quickfix=Weaken visibility arrays.as.list.with.zero.or.one.argument.display.name=Call to 'Arrays.asList()' with too few arguments -arrays.as.list.with.one.argument.problem.descriptor=Call to #ref() with only one argument #loc -arrays.as.list.with.zero.arguments.problem.descriptor=Call to #ref() to create an empty List #loc +arrays.as.list.with.one.argument.problem.descriptor=Call to #ref() with only one argument +arrays.as.list.with.zero.arguments.problem.descriptor=Call to #ref() to create an empty List string.concatenation.argument.to.log.call.display.name=Non-constant string concatenation as argument to logging call -string.concatenation.argument.to.log.call.problem.descriptor=Non-constant string as argument to #ref() logging call #loc +string.concatenation.argument.to.log.call.problem.descriptor=Non-constant string as argument to #ref() logging call string.concatenation.argument.to.log.call.quickfix=Replace concatenation with parameterized log message string.concatenation.argument.to.log.string.format.call.quickfix=Replace 'String.format()' with parameterized log message string.concatenation.argument.to.log.message.format.call.quickfix=Replace 'Message.format()' with parameterized log message assignment.to.superclass.field.display.name=Constructor assigns value to field defined in superclass -assignment.to.superclass.field.problem.descriptor=Assignment to field ''{0}'' defined in superclass ''{1}'' #loc +assignment.to.superclass.field.problem.descriptor=Assignment to field ''{0}'' defined in superclass ''{1}'' inner.class.referenced.via.subclass.display.name=Inner class referenced via subclass -inner.class.referenced.via.subclass.problem.descriptor=Inner class #ref declared in class ''{0}'' but referenced via subclass ''{1}'' #loc +inner.class.referenced.via.subclass.problem.descriptor=Inner class #ref declared in class ''{0}'' but referenced via subclass ''{1}'' inner.class.referenced.via.subclass.quickfix=Rationalize inner class access boolean.parameter.display.name='public' method with 'boolean' parameter -boolean.parameter.problem.descriptor='public' method #ref() with 'boolean' parameter #loc -boolean.parameters.problem.descriptor='public' method #ref() with 'boolean' parameters #loc -boolean.parameter.constructor.problem.descriptor='public' constructor #ref() with 'boolean' parameter #loc -boolean.parameters.constructor.problem.descriptor='public' constructor #ref() with 'boolean' parameters #loc +boolean.parameter.problem.descriptor='public' method #ref() with 'boolean' parameter +boolean.parameters.problem.descriptor='public' method #ref() with 'boolean' parameters +boolean.parameter.constructor.problem.descriptor='public' constructor #ref() with 'boolean' parameter +boolean.parameters.constructor.problem.descriptor='public' constructor #ref() with 'boolean' parameters boolean.parameter.only.report.multiple.option=Only report methods with multiple boolean parameters unnecessary.unicode.escape.display.name=Unnecessary Unicode escape sequence -unnecessary.unicode.escape.problem.descriptor=Unicode escape sequence #ref can be replaced with ''{0}'' #loc -unnecessary.unicode.escape.problem.newline.descriptor=Unicode escape sequence #ref can be replaced with a line feed character #loc +unnecessary.unicode.escape.problem.descriptor=Unicode escape sequence #ref can be replaced with ''{0}'' +unnecessary.unicode.escape.problem.newline.descriptor=Unicode escape sequence #ref can be replaced with a line feed character missing.package.info.display.name=Missing 'package-info.java' missing.package.info.problem.descriptor=Package ''{0}'' is missing a package-info.java file missing.package.html.problem.descriptor=Package ''{0}'' is missing a package.html file @@ -1972,12 +1972,12 @@ package.info.without.package.problem.descriptor='package-info.java' does not hav package.info.without.package.quickfix=Add ''package {0};'' package.info.without.package.family.quickfix=Add package statement auto.closeable.resource.display.name=AutoCloseable used without 'try'-with-resources -auto.closeable.resource.problem.descriptor=''{0}'' used without ''try''-with-resources statement #loc +auto.closeable.resource.problem.descriptor=''{0}'' used without ''try''-with-resources statement auto.closeable.resource.quickfix=Ignore 'AutoCloseable' returned by this method auto.closeable.resource.returned.option=Ignore AutoCloseable instances returned from all method calls problematic.varargs.method.display.name=Non-varargs method overrides varargs method -problematic.varargs.method.override.problem.descriptor=Non-varargs method #ref() overrides varargs method #loc -negatively.named.boolean.variable.problem.descriptor=Boolean variable #ref is negatively named #loc +problematic.varargs.method.override.problem.descriptor=Non-varargs method #ref() overrides varargs method +negatively.named.boolean.variable.problem.descriptor=Boolean variable #ref is negatively named negatively.named.boolean.variable.display.name=Negatively named boolean variable invert.quickfix.family.name=Invert boolean invert.method.quickfix=Invert method @@ -1996,13 +1996,13 @@ interface.may.be.annotated.functional.problem.descriptor=Interface #ref#ref hides field in class ''{0}'' #loc +lambda.parameter.hides.member.variable.problem.descriptor=Lambda parameter #ref hides field in class ''{0}'' lambda.parameter.hides.member.variable.ignore.invisible.option=Ignore fields not actually visible from the lambda shared.thread.local.random.display.name='ThreadLocalRandom' instance might be shared shared.thread.local.random.problem.descriptor='ThreadLocalRandom' instance might be shared between threads native.method.naming.convention.element.description='native' method use.of.obsolete.date.time.api.display.name=Use of obsolete date-time API -use.of.obsolete.date.time.api.problem.descriptor=Obsolete date-time type #ref used #loc +use.of.obsolete.date.time.api.problem.descriptor=Obsolete date-time type #ref used log4j.use.parameterized.logger=For Log4j 2 use fixes as for parameterized logger log4j.use.parameterized.logger.description=For Log4j 2 use fixes as for parameterized logger if the type cannot be inferred, otherwise fixes will not be proposed warn.on.label=Warn on: @@ -2023,7 +2023,7 @@ serializable.lambda.stores.non.serializable.problem.descriptor=Serializable lamb serializable.local.class.stores.non.serializable.problem.descriptor=Serializable local class ''{1}'' implicitly stores non-Serializable object of type ''{0}'' serializable.anonymous.class.stores.non.serializable.problem.descriptor=Serializable anonymous class implicitly stores non-Serializable object of type ''{0}'' assignment.to.lambda.parameter.display.name=Assignment to lambda parameter -assignment.to.lambda.parameter.problem.descriptor=Assignment to lambda parameter #ref #loc +assignment.to.lambda.parameter.problem.descriptor=Assignment to lambda parameter #ref class.with.only.private.constructors.display.name=Class with only 'private' constructors should be declared 'final' class.with.only.private.constructors.problem.descriptor=Class #ref with only 'private' constructors should be declared 'final' property.value.set.to.itself.display.name=Property value set to itself @@ -2037,28 +2037,28 @@ introduce.holder.class.quickfix=Introduce holder class double.brace.initialization.display.name=Double brace initialization double.brace.initialization.quickfix=Replace with regular initialization return.of.inner.class.display.name=Return of instance of anonymous, local or inner class -return.of.anonymous.class.problem.descriptor=Return of instance of anonymous class #loc -return.of.local.class.problem.descriptor=Return of instance of local class {0} #loc -return.of.inner.class.problem.descriptor=Return of instance of non-static inner class {0} #loc +return.of.anonymous.class.problem.descriptor=Return of instance of anonymous class +return.of.local.class.problem.descriptor=Return of instance of local class {0} +return.of.inner.class.problem.descriptor=Return of instance of non-static inner class {0} return.of.inner.class.ignore.non.public.option=Ignore returns from non-public methods parameter.type.prevents.overriding.display.name=Parameter type prevents overriding -parameter.type.prevents.overriding.problem.descriptor=Parameter type #ref is located in ''{0}'' while super method parameter type is located in ''{1}'' preventing overriding #loc +parameter.type.prevents.overriding.problem.descriptor=Parameter type #ref is located in ''{0}'' while super method parameter type is located in ''{1}'' preventing overriding parameter.type.prevents.overriding.quickfix=Change type of parameter to ''{0}'' parameter.type.prevents.overriding.family.quickfix=Change type of parameter suspicious.getter.setter.display.name=Suspicious getter/setter -suspicious.setter.problem.descriptor=Setter #ref() assigns field ''{0}'' #loc -suspicious.getter.problem.descriptor=Getter #ref() returns field ''{0}'' #loc +suspicious.setter.problem.descriptor=Setter #ref() assigns field ''{0}'' +suspicious.getter.problem.descriptor=Getter #ref() returns field ''{0}'' unnecessary.break.display.name=Unnecessary 'break' statement -unnecessary.break.problem.descriptor=#ref statement is unnecessary #loc +unnecessary.break.problem.descriptor=#ref statement is unnecessary utility.class.can.be.enum.display.name=Utility class can be 'enum' -utility.class.code.can.be.enum.problem.descriptor=Utility class \#ref can be 'enum' #loc +utility.class.code.can.be.enum.problem.descriptor=Utility class \#ref can be 'enum' utility.class.code.can.be.enum.quickfix=Convert to 'enum' non.public.clone.display.name='clone()' method not 'public' -non.public.clone.problem.descriptor=#ref() method not 'public' #loc +non.public.clone.problem.descriptor=#ref() method not 'public' only.warn.on.public.clone.methods=Only warn on 'public' clone methods only.warn.on.protected.clone.methods=Only warn on 'protected' clone methods clone.returns.class.type.display.name='clone()' should have return type equal to the class it contains -clone.returns.class.type.problem.descriptor=''clone()'' should have return type ''{0}'' #loc +clone.returns.class.type.problem.descriptor=''clone()'' should have return type ''{0}'' clone.returns.class.type.quickfix=Change return type to ''{0}'' clone.returns.class.type.family.quickfix=Change return type to class type use.of.clone.display.name=Use of 'clone()' or 'Cloneable' @@ -2066,27 +2066,27 @@ use.of.clone.call.problem.descriptor=Call to #ref() use.of.clone.call.method.problem.descriptor=Implementation of #ref() use.of.clone.reference.problem.descriptor=Use of #ref dangling.javadoc.display.name=Dangling Javadoc comment -dangling.javadoc.problem.descriptor=Dangling Javadoc comment #loc +dangling.javadoc.problem.descriptor=Dangling Javadoc comment dangling.javadoc.convert.quickfix=Replace with block comment dangling.javadoc.convert.line.comment.quickfix=Replace with line comments dangling.javadoc.delete.quickfix=Remove dangling comment dangling.javadoc.ignore.copyright.option=Ignore file header comment in JavaDoc format equals.replaceable.by.objects.call.display.name='equals()' expression replaceable by 'Objects.equals()' expression -equals.replaceable.by.objects.call.problem.descriptor=#ref replaceable by 'Objects.equals()' expression #loc +equals.replaceable.by.objects.call.problem.descriptor=#ref replaceable by 'Objects.equals()' expression equals.replaceable.by.objects.check.not.null.option=Highlight expressions like 'a != null \\&\\& a.equals(b)' array.objects.equals.display.name=Use of shallow or 'Objects' methods with arrays array.equals.problem.descriptor=Arrays comparison should probably be done using ''{0}'' array.hashcode.problem.descriptor=Array hash code calculation should probably be done using ''{0}'' extends.throwable.display.name=Class directly extends 'Throwable' -anonymous.extends.throwable.problem.descriptor=Anonymous class directly extends 'java.lang.Throwable' #loc -extends.throwable.problem.descriptor=Class #ref directly extends 'java.lang.Throwable' #loc +anonymous.extends.throwable.problem.descriptor=Anonymous class directly extends 'java.lang.Throwable' +extends.throwable.problem.descriptor=Class #ref directly extends 'java.lang.Throwable' lambda.parameter.naming.convention.display.name=Lambda parameter naming convention lambda.parameter.naming.convention.element.description=Lambda parameter assert.message.not.string.display.name='assert' message is not a string -assert.message.of.type.boolean.problem.descriptor=''assert'' message of type ''{0}'' #loc +assert.message.of.type.boolean.problem.descriptor=''assert'' message of type ''{0}'' assert.message.not.string.only.warn.boolean.option=Only warn when 'assert' message is 'boolean' or 'java.lang.Boolean' suspicious.literal.underscore.display.name=Suspicious underscore in number literal -suspicious.literal.underscore.problem.descriptor=Group in number literal with underscores does not have length 3 #loc +suspicious.literal.underscore.problem.descriptor=Group in number literal with underscores does not have length 3 unary.plus.quickfix=Remove unary '+' convert.double.unary.quickfix=Replace with ''{0}{1}'' prefix.operation.quickfix.family.name=Replace with prefix operator @@ -2098,7 +2098,7 @@ unnecessary.initcause.problem.descriptor=Unnecessary Throwable.#ref()#ref is not declared ''static final'' #loc +atomic.field.updater.not.static.final.problem.descriptor={0} field #ref is not declared ''static final'' atomic.field.updater.issues.display.name=Inconsistent 'AtomicFieldUpdater' declaration field.not.found.in.class.problem.descriptor=No field named ''{0}'' found in class ''{1}'' field.incorrect.type.problem.descriptor=Field ''{0}'' does not have type ''{1}'' @@ -2119,10 +2119,10 @@ optional.contains.collection.display.name='Optional' contains array or collectio optional.contains.collection.problem.descriptor='Optional' contains collection #ref optional.contains.array.problem.descriptor='Optional' contains array #ref synchronization.on.get.class.display.name=Synchronization on 'getClass()' -synchronization.on.get.class.problem.descriptor=Synchronization on #ref() #loc +synchronization.on.get.class.problem.descriptor=Synchronization on #ref() object.instantiation.inside.equals.or.hashcode.display.name=Object instantiation inside 'equals()' or 'hashCode()' -object.instantiation.inside.equals.or.hashcode.problem.descriptor=Object instantiation inside ''{0}()'' #loc -object.instantiation.inside.equals.or.hashcode.problem.descriptor2=Object instantiation inside ''{0}()'' ({1})#loc +object.instantiation.inside.equals.or.hashcode.problem.descriptor=Object instantiation inside ''{0}()'' +object.instantiation.inside.equals.or.hashcode.problem.descriptor2=Object instantiation inside ''{0}()'' ({1}) lambda.body.can.be.code.block.name=Lambda body can be code block lambda.body.can.be.code.block.quickfix=Expand lambda body to {...} lambda.parameter.type.can.be.specified.name=Lambda parameter type can be specified @@ -2157,11 +2157,11 @@ array.creation.without.new.keyword.name=Array creation without 'new' expression array.creation.without.new.keyword.quickfix=Add ''new {0}'' array.creation.without.new.keyword.family.quickfix=Add 'new' expression overly.long.lambda.display.name=Overly long lambda expression -overly.long.lambda.problem.descriptor=Lambda expression is too long (# Non-comment source statements = {0}) #loc +overly.long.lambda.problem.descriptor=Lambda expression is too long (# Non-comment source statements = {0}) wait.notify.not.in.synchronized.context.display.name='wait()' or 'notify()' is not in synchronized context -wait.notify.while.not.synchronized.on.problem.descriptor=Call to #ref while not synchronized on ''{0}'' #loc +wait.notify.while.not.synchronized.on.problem.descriptor=Call to #ref while not synchronized on ''{0}'' call.to.suspicious.string.method.display.name=Call to suspicious 'String' method -call.to.suspicious.string.method.problem.descriptor=String.#ref() called in internationalized context #loc +call.to.suspicious.string.method.problem.descriptor=String.#ref() called in internationalized context unnecessary.string.escape.display.name=Unnecessarily escaped character unnecessary.string.escape.problem.descriptor={0} is unnecessarily escaped unnecessary.string.escape.quickfix=Remove unnecessary escaping @@ -2185,16 +2185,16 @@ ignored.class.names=Ignore Classes (Including Subclasses) ignored.class.label=Ignored classes (including subclasses): meta.annotation.without.runtime.retention=Test annotation without '@Retention(RUNTIME)' annotation string.equals.char.sequence.display.name='String.equals()' called with 'CharSequence' argument -string.equals.char.sequence.problem.descriptor=String.equals() called with ''{0}'' argument #loc +string.equals.char.sequence.problem.descriptor=String.equals() called with ''{0}'' argument object.equals.can.be.equality.display.name='equals()' call can be replaced with '==' object.equals.can.be.equality.problem.descriptor=#ref() can be replaced with '==' not.object.equals.can.be.equality.problem.descriptor=!#ref() can be replaced with '!=' redundant.explicit.var.type.display.name=Local variable type can be omitted variable.type.can.be.explicit.display.name=Variable type can be explicit assignment.or.return.of.field.with.mutable.type.display.name=Assignment or return of field with mutable type -assignment.of.field.with.mutable.type.problem.descriptor=Assignment to {0} field ''{1}'' from parameter #ref #loc -return.of.field.with.mutable.type.problem.descriptor=Return of {0} field #ref #loc -assignment.and.return.of.mutable.record.component=Implicit {0, choice, 1#assignment|2#return|3#assignment and return} of {1} record component #ref #loc +assignment.of.field.with.mutable.type.problem.descriptor=Assignment to {0} field ''{1}'' from parameter #ref +return.of.field.with.mutable.type.problem.descriptor=Return of {0} field #ref +assignment.and.return.of.mutable.record.component=Implicit {0, choice, 1#assignment|2#return|3#assignment and return} of {1} record component #ref ignore.private.methods.option=Ignore assignments in and returns from private methods inspection.replace.on.literal.display.name=Replacement operation has no effect @@ -2203,15 +2203,15 @@ inspection.redundant.embedded.expression.display.name=Redundant embedded express inspection.redundant.string.fix.remove.str.processor.description=String template can be converted to a plain string literal inspection.remove.redundant.call.fix.name=Remove redundant ''{0}()'' call inspection.redundant.string.fix.family.name=Remove redundant call -inspection.redundant.string.call.message=Call to #ref() is redundant #loc +inspection.redundant.string.call.message=Call to #ref() is redundant inspection.redundant.empty.string.argument.message=Unnecessary empty string argument inspection.redundant.string.length.argument.message=Unnecessary string length argument inspection.redundant.zero.argument.message=Unnecessary zero argument inspection.redundant.string.remove.argument.fix.name=Remove argument inspection.redundant.arguments.message=Unnecessary arguments -inspection.redundant.string.intern.on.constant.message=Call to #ref() on compile-time constant is unnecessary #loc -inspection.redundant.string.constructor.message=new #ref() is redundant #loc -inspection.redundant.string.new.array.message=#ref is redundant #loc +inspection.redundant.string.intern.on.constant.message=Call to #ref() on compile-time constant is unnecessary +inspection.redundant.string.constructor.message=new #ref() is redundant +inspection.redundant.string.new.array.message=#ref is redundant inspection.redundant.string.replace.with.arg.fix.name=Replace with argument inspection.redundant.string.replace.with.empty.fix.name=Replace with empty string inspection.redundant.string.option.do.not.report.string.constructors=Do not report String constructor calls @@ -2220,10 +2220,10 @@ inspection.x.call.can.be.replaced.with.y=#ref() call can be replace remove.unnecessary.0.call.quickfix=Remove unnecessary ''{0}()'' call inspection.type.may.be.weakened.display.name=Type may be weakened -inspection.type.may.be.weakened.problem.descriptor=Type of variable #ref may be weakened to {0} #loc -inspection.type.may.be.weakened.method.problem.descriptor=Return type of method #ref() may be weakened to {0} #loc -inspection.type.may.be.weakened.parameter.problem.descriptor=Type of parameter #ref may be weakened to {0} #loc -inspection.type.may.be.weakened.field.problem.descriptor=Type of field #ref may be weakened to {0} #loc +inspection.type.may.be.weakened.problem.descriptor=Type of variable #ref may be weakened to {0} +inspection.type.may.be.weakened.method.problem.descriptor=Return type of method #ref() may be weakened to {0} +inspection.type.may.be.weakened.parameter.problem.descriptor=Type of parameter #ref may be weakened to {0} +inspection.type.may.be.weakened.field.problem.descriptor=Type of field #ref may be weakened to {0} inspection.type.may.be.weakened.quickfix=Weaken type to ''{0}'' inspection.type.may.be.weakened.add.stopper=Add as Stop Class for Weakening inspection.type.may.be.weakened.add.stopper.single=Add {0} as stop class for weakening @@ -2247,10 +2247,10 @@ inspection.catch.ignores.exception.display.name=Catch block may ignore exception inspection.catch.ignores.exception.option.comments=Do not warn when 'catch' block contains a comment inspection.catch.ignores.exception.option.nonempty=Do not warn when 'catch' block is not empty inspection.catch.ignores.exception.option.ignored.used=Do not warn when exception named 'ignore(d)' is not actually ignored -inspection.catch.ignores.exception.used.message='catch' parameter named #ref is used #loc -inspection.catch.ignores.exception.empty.message=Empty #ref block #loc -inspection.catch.ignores.exception.unused.message=Unused 'catch' parameter #ref #loc -inspection.catch.ignores.exception.vm.ignored.message=Unexpected VM exception like ''{0}'' might be ignored in a #ref block #loc +inspection.catch.ignores.exception.used.message='catch' parameter named #ref is used +inspection.catch.ignores.exception.empty.message=Empty #ref block +inspection.catch.ignores.exception.unused.message=Unused 'catch' parameter #ref +inspection.catch.ignores.exception.vm.ignored.message=Unexpected VM exception like ''{0}'' might be ignored in a #ref block inspection.redundant.collection.operation.display.name=Redundant 'Collection' operation inspection.redundant.collection.operation.fix.family.name=Simplify collection operation diff --git a/java/openapi/resources/messages/JavaBundle.properties b/java/openapi/resources/messages/JavaBundle.properties index 0aa37b2ae297..08e9c1650307 100644 --- a/java/openapi/resources/messages/JavaBundle.properties +++ b/java/openapi/resources/messages/JavaBundle.properties @@ -393,7 +393,7 @@ inspection.duplicate.expressions.complexity.threshold=Expression complexity thre inspection.duplicate.expressions.display.name=Multiple occurrences of the same expression inspection.duplicate.expressions.introduce.variable.fix.family.name=Introduce variable inspection.duplicate.expressions.introduce.variable.fix.name=Introduce variable for ''{0}'' -inspection.duplicate.expressions.message=Multiple occurrences of #ref #loc +inspection.duplicate.expressions.message=Multiple occurrences of #ref inspection.duplicate.expressions.replace.other.occurrences.fix.family.name=Replace with variable other occurrences of expression inspection.duplicate.expressions.replace.other.occurrences.fix.name=Replace with ''{0}'' other occurrences of ''{1}'' inspection.duplicate.expressions.reuse.variable.fix.family.name=Reuse variable @@ -527,7 +527,7 @@ inspection.manual.min.max.calculation.description=Can be replaced with ''Math.{0 inspection.manual.min.max.calculation.disable.for.non.integral=Disable for float and double inspection.map.foreach.display.name=Map.forEach() can be used inspection.map.foreach.option.no.loops=Do not report loops -inspection.message.anonymous.ref.loc.can.be.replaced.with.method.reference=Anonymous #ref #loc can be replaced with method reference +inspection.message.anonymous.ref.loc.can.be.replaced.with.method.reference=Anonymous #ref can be replaced with method reference inspection.message.can.be.replaced.with.0.constructor=Can be replaced with ''{0}'' constructor inspection.message.can.be.replaced.with.files.readstring=Can be replaced with 'Files.readString()' inspection.message.can.be.replaced.with.optional.of.nullable=Can be replaced with Optional.ofNullable() @@ -576,7 +576,7 @@ inspection.overwritten.key.array.message=Overwritten array element inspection.parameter.can.be.local.display.name=Value passed as parameter never read inspection.parameter.can.be.local.problem.descriptor=Parameter can be converted to a local variable inspection.quickfix.assert.family=Assert -inspection.raw.use.of.parameterized.type.problem.descriptor=Raw use of parameterized class #ref #loc +inspection.raw.use.of.parameterized.type.problem.descriptor=Raw use of parameterized class #ref raw.variable.type.can.be.generic.family.quickfix=Add generic parameters to the type raw.variable.type.can.be.generic.quickfix=Change type of {0} to {1} raw.variable.type.can.be.generic.cast.quickfix=Change cast type to {0} @@ -591,7 +591,7 @@ inspection.redundant.array.creation.for.varargs.call.descriptor=Redundant array inspection.redundant.array.creation.quickfix=Remove explicit array creation inspection.redundant.explicit.close=Redundant 'close()' inspection.redundant.file.creation.display.name=Redundant 'File' instance creation -inspection.redundant.file.creation.description=#ref is redundant #loc +inspection.redundant.file.creation.description=#ref is redundant inspection.redundant.file.creation.quickfix=Replace with file name inspection.redundant.null.check.always.fail.message=Null-check will always fail: {0} is never null inspection.redundant.null.check.fix.family.name=Remove redundant null-check @@ -771,12 +771,12 @@ inspection.unused.assignment.option1=Report postfix expressions where the change inspection.unused.assignment.option2=Report redundant initializers inspection.unused.assignment.option3=Report pattern variables whose values are never used inspection.unused.assignment.option4=Report iteration parameters whose values are never used -inspection.unused.assignment.problem.descriptor1=Variable #ref #loc is never used -inspection.unused.assignment.problem.descriptor2=Variable {0} initializer #ref #loc is redundant -inspection.unused.assignment.problem.descriptor3=The value {0} assigned to #ref #loc is never used -inspection.unused.assignment.problem.descriptor4=The value changed at #ref #loc is never used -inspection.unused.assignment.problem.descriptor5=The value of pattern variable #ref #loc is never used -inspection.unused.assignment.problem.descriptor6=The value of foreach iteration parameter #ref #loc is never used +inspection.unused.assignment.problem.descriptor1=Variable #ref is never used +inspection.unused.assignment.problem.descriptor2=Variable {0} initializer #ref is redundant +inspection.unused.assignment.problem.descriptor3=The value {0} assigned to #ref is never used +inspection.unused.assignment.problem.descriptor4=The value changed at #ref is never used +inspection.unused.assignment.problem.descriptor5=The value of pattern variable #ref is never used +inspection.unused.assignment.problem.descriptor6=The value of foreach iteration parameter #ref is never used inspection.unused.assignment.remove.assignment.quickfix=Remove redundant assignment inspection.unused.assignment.remove.assignment.quickfix.title=Remove Redundant Assignment inspection.unused.assignment.remove.initializer.quickfix=Remove redundant initializer diff --git a/jvm/jvm-analysis-impl/resources/messages/JvmAnalysisBundle.properties b/jvm/jvm-analysis-impl/resources/messages/JvmAnalysisBundle.properties index 330a3365adbc..106c7ba563fc 100644 --- a/jvm/jvm-analysis-impl/resources/messages/JvmAnalysisBundle.properties +++ b/jvm/jvm-analysis-impl/resources/messages/JvmAnalysisBundle.properties @@ -61,7 +61,7 @@ jvm.inspections.api.override.only.on.invalid.class.description={0} ''{1}'' is ma jvm.inspections.equals.hashcode.called.on.url.display.name=Call to 'equals()' or 'hashCode()' on 'URL' object jvm.inspections.equals.hashcode.called.on.url.problem.descriptor=Call to ''{0}'' on URL object -jvm.inspections.collection.contains.url.problem.descriptor=''{0}'' may contain URL objects #loc +jvm.inspections.collection.contains.url.problem.descriptor=''{0}'' may contain URL objects jvm.inspections.dependency.display.name=Illegal package dependencies jvm.inspections.dependency.edit.rules.text=Edit dependency rule \"{0} \" @@ -141,23 +141,23 @@ jvm.inspections.testonly.method.call=Test-only method is called in production co jvm.inspections.testonly.visiblefortesting=@VisibleForTesting makes little sense on @TestOnly code jvm.inspections.test.method.without.assertion.display.name=Test method without assertions -jvm.inspections.test.method.without.assertion.problem.descriptor=Test method #ref() contains no assertions #loc +jvm.inspections.test.method.without.assertion.problem.descriptor=Test method #ref() contains no assertions jvm.inspections.test.case.without.test.methods.display.name=Test class without tests jvm.inspections.test.case.without.test.methods.option=Ignore test cases which have superclasses with test methods -jvm.inspections.test.case.without.test.methods.problem.descriptor=Test class #ref has no tests #loc +jvm.inspections.test.case.without.test.methods.problem.descriptor=Test class #ref has no tests jvm.inspections.test.case.with.constructor.display.name=TestCase with non-trivial constructors -jvm.inspections.test.case.with.constructor.problem.descriptor=Initialization logic in constructor #ref() instead of 'setup()' life cycle method #loc +jvm.inspections.test.case.with.constructor.problem.descriptor=Initialization logic in constructor #ref() instead of 'setup()' life cycle method jvm.inspections.test.case.with.constructor.problem.descriptor.initializer=Initialization logic in initializer instead of 'setup()' life cycle method jvm.inspections.test.case.in.product.source.display.name=Test in product source -jvm.inspections.test.case.in.product.source.problem.descriptor=Test case #ref should probably be placed in a test source tree #loc -jvm.inspections.test.method.in.product.source.problem.descriptor=Test method #ref() should probably be placed in a test source tree #loc +jvm.inspections.test.case.in.product.source.problem.descriptor=Test case #ref should probably be placed in a test source tree +jvm.inspections.test.method.in.product.source.problem.descriptor=Test method #ref() should probably be placed in a test source tree jvm.inspection.logging.string.template.as.argument.display.name=String template as argument to logging call -jvm.inspection.logging.string.template.as.argument.problem.descriptor=String template as argument to #ref() logging call #loc +jvm.inspection.logging.string.template.as.argument.problem.descriptor=String template as argument to #ref() logging call jvm.inspection.logging.string.template.as.argument.quickfix.name=Replace with placeholders jvm.inspection.logging.string.template.as.argument.skip.on.primitives=Do not warn when only expressions with primitive types, their wrappers or String are included jvm.inspection.logging.string.template.as.argument.skip.on.only.exception=Do not warn when call only with an exception as argument after message argument. @@ -179,18 +179,18 @@ jvm.inspection.log.statement.not.guarded.trace.level.option=trace level jvm.inspection.log.statement.not.guarded.unguarded.constant.option=Process unguarded logging calls with constant messages jvm.inspection.log.statement.not.guarded.unguarded.constant.option.comment=Process all unguarded log calls, not only those with non-constant arguments jvm.inspection.log.statement.not.guarded.log.fix.family.name=Surround with a logging condition -jvm.inspection.log.statement.not.guarded.log.problem.descriptor=Logging call not guarded by a logging condition #loc +jvm.inspection.log.statement.not.guarded.log.problem.descriptor=Logging call not guarded by a logging condition jvm.inspection.log.guarded.display.name=Logging calls guarded by log condition jvm.inspection.log.guarded.warn.if.fix.possible=Warn only if a fix is available -jvm.inspection.log.guarded.problem.descriptor=Logging call guarded by log condition #loc +jvm.inspection.log.guarded.problem.descriptor=Logging call guarded by log condition jvm.inspection.log.guarded.fix.family.name=Unwrap log guard condition jvm.inspection.logging.placeholder.count.matches.argument.count.display.name=Number of placeholders does not match number of arguments in logging call -jvm.inspection.logging.placeholder.count.matches.argument.count.more.problem.descriptor=More arguments provided ({0}) than placeholders specified ({1}) #loc -jvm.inspection.logging.placeholder.count.matches.argument.count.fewer.problem.partial.descriptor=Fewer arguments provided ({0}) than placeholders specified (at least {1}) #loc -jvm.inspection.logging.placeholder.count.matches.argument.count.fewer.problem.descriptor=Fewer arguments provided ({0}) than placeholders specified ({1}) #loc -jvm.inspection.logging.placeholder.count.matches.argument.count.incorrect.problem.descriptor=Illegal format string specifier #loc +jvm.inspection.logging.placeholder.count.matches.argument.count.more.problem.descriptor=More arguments provided ({0}) than placeholders specified ({1}) +jvm.inspection.logging.placeholder.count.matches.argument.count.fewer.problem.partial.descriptor=Fewer arguments provided ({0}) than placeholders specified (at least {1}) +jvm.inspection.logging.placeholder.count.matches.argument.count.fewer.problem.descriptor=Fewer arguments provided ({0}) than placeholders specified ({1}) +jvm.inspection.logging.placeholder.count.matches.argument.count.incorrect.problem.descriptor=Illegal format string specifier jvm.inspection.logging.placeholder.count.matches.argument.count.slf4j.throwable.option=SLF4J uses Log4j 2 as implementation jvm.inspection.logging.placeholder.count.matches.argument.count.slf4j.throwable.option.auto=Check automatically jvm.inspection.logging.placeholder.count.matches.argument.count.slf4j.throwable.option.yes=Yes @@ -213,9 +213,9 @@ jvm.inspection.test.failed.line.display.name=Failed line in test jvm.inspections.thread.run.display.name=Call to 'Thread.run()' jvm.inspections.serializable.class.without.serialversionuid.display.name=Serializable class without 'serialVersionUID' -jvm.inspections.serializable.class.without.serialversionuid.problem.descriptor=#ref does not define a 'serialVersionUID' field #loc +jvm.inspections.serializable.class.without.serialversionuid.problem.descriptor=#ref does not define a 'serialVersionUID' field -jvm.inspections.string.touppercase.tolowercase.without.locale.description=String.{0}() called without specifying a Locale using internationalized strings #loc +jvm.inspections.string.touppercase.tolowercase.without.locale.description=String.{0}() called without specifying a Locale using internationalized strings jvm.inspections.api.display.name=Usages of API which isn't available at the configured language level assertequals.between.inconvertible.types.display.name='assertEquals()' between objects of inconvertible types @@ -225,7 +225,7 @@ jvm.inspections.1.7.problem.descriptor=Usage of generified after 1.6 API which w jvm.inspections.1.8.problem.descriptor=Default {0, choice, 0#|1#method is|2# methods are} not overridden. It would cause compilation problems with JDK {1} jvm.inspections.1.8.problem.single.descriptor=Default method ''{0}'' is not overridden. It would cause compilation problems with JDK {1} -jvm.inspections.assertequals.between.inconvertible.types.problem.descriptor=#ref() between objects of inconvertible types ''{0}'' and ''{1}'' #loc +jvm.inspections.assertequals.between.inconvertible.types.problem.descriptor=#ref() between objects of inconvertible types ''{0}'' and ''{1}'' jvm.inspections.assertnotsame.between.inconvertible.types.problem.descriptor=Redundant assertion: incompatible types are compared ''{0}'' and ''{1}'' jvm.inspections.assertnotequals.between.inconvertible.types.problem.descriptor=Possibly redundant assertion: incompatible types are compared ''{0}'' and ''{1}'' @@ -243,8 +243,8 @@ jvm.inspections.dependency.intention.description=Opens a dialog to configure dep jvm.class.filter.choose.calls=Similar Log Calls: inspection.suppression.annotation.display.name=Inspection suppression annotation -inspection.suppression.annotation.problem.descriptor=Annotation suppresses {0} #loc -inspection.suppression.comment.problem.descriptor=Comment suppresses {0} #loc +inspection.suppression.annotation.problem.descriptor=Annotation suppresses {0} +inspection.suppression.comment.problem.descriptor=Comment suppresses {0} ignored.suppressions=Ignored suppressions: remove.suppress.comment.fix.family.name=Remove //{0} allow.suppressions.fix.family.name=Allow suppressions diff --git a/plugins/java-i18n/resources/messages/JavaI18nBundle.properties b/plugins/java-i18n/resources/messages/JavaI18nBundle.properties index 5af9dd7fdbb0..650230c49971 100644 --- a/plugins/java-i18n/resources/messages/JavaI18nBundle.properties +++ b/plugins/java-i18n/resources/messages/JavaI18nBundle.properties @@ -87,7 +87,7 @@ quickfix.text.title.capitalization=Properly capitalize ''{0}'' rename.prefix.based.property.key.error.message=Could not rename property key ''{1}'' based on prefix ''{0}'' by name ''{2}'', change prefix first resource.bundle.contains.locales.with.suspicious.locale.languages.desciptor=Resource bundle contains locales with suspicious locale languages unused.message.format.parameter.display.name=Missing message format parameter -unused.message.format.parameter.problem.descriptor=Using parameter {0} without using parameter {1} in #ref #loc +unused.message.format.parameter.problem.descriptor=Using parameter {0} without using parameter {1} in #ref unsupported.character.display.name=Unsupported character unsupported.character.problem.descriptor=Unsupported characters for the charset ''{0}'' unsupported.character.inspection.fix.description=Convert to escape sequences