cast.to.concrete.class.problem.descriptor=Cast to concrete class {0} #loc 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 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.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 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.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 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 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 magic.number.display.name=Magic number magic.number.problem.descriptor=Magic number #ref #loc concrete.class.use.display.name=Use of concrete class method.return.concrete.class.problem.descriptor=Method returns a concrete class #ref #loc 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 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.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 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 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 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 assignment.to.null.display.name='null' assignment assignment.to.null.problem.descriptor='null' assigned to variable #ref #loc 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.used.as.condition.display.name=Assignment used as condition assignment.used.as.condition.problem.descriptor=Assignment #ref used as condition #loc 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 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 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 covariant.equals.display.name=Covariant 'equals()' covariant.equals.problem.descriptor=#ref() should take 'Object' as its argument #loc empty.class.initializer.display.name=Empty class initializer empty.class.initializer.problem.descriptor=Empty class initializer #loc 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.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.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 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 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 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.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 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 instantiation.utility.class.display.name=Instantiation of utility class instantiation.utility.class.problem.descriptor=Instantiation of utility class #ref #loc 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.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 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.update.collection.display.name=Mismatched query and update of collection mismatched.update.collection.problem.descriptor.updated.not.queried=Contents of collection #ref are updated, but never queried #loc mismatched.update.collection.problem.description.queried.not.updated=Contents of collection #ref are queried, but never updated #loc 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 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.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 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 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 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 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 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.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 return.of.null.display.name=Return of 'null' return.of.null.problem.descriptor=Return of #ref #loc 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.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.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 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 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 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 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 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.ignore.option=Ignore weak static collections or maps stringbuffer.field.display.name='StringBuilder' field stringbuffer.field.problem.descriptor=''{0}'' field #ref #loc gc.call.display.name=Call to 'System.gc()' or 'Runtime.gc()' gc.call.problem.descriptor=#ref should not be called in production code #loc array.allocation.zero.length.display.name=Zero-length array allocation array.allocation.zero.length.problem.descriptor=Allocation of zero length array #loc 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.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 no.logger.display.name=Class without logger no.logger.problem.descriptor=Class #ref does not declare a logger #loc non.constant.logger.display.name=Non-constant logger non.constant.logger.problem.descriptor=Non-constant logger field #ref #loc public.method.without.logging.display.name='public' method without logging public.method.without.logging.problem.descriptor='public' method #ref() has no logging call #loc 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.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.called.explicitly.display.name='finalize()' called explicitly finalize.called.explicitly.problem.descriptor=#ref() called explicitly #loc 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 import.display.name='*' import import.problem.descriptor=Package import #ref #loc 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 single.class.import.display.name=Single class import single.class.import.problem.descriptor=Single class import #ref #loc static.import.display.name=Static import static.import.problem.descriptor=Static import #ref #loc 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 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.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.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 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.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.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.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 printstacktrace.call.display.name=Call to 'printStackTrace()' printstacktrace.call.problem.descriptor=Call to #ref() should probably be replaced with more robust logging #loc 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 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 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 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 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 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 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.used.before.initialization.display.name=Static field used before initialization static.variable.used.before.initialization.problem.descriptor=Static field #ref used before initialization #loc 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 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.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 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 package.visible.field.display.name=Package-visible field package.visible.field.problem.descriptor=Package-visible field #ref #loc 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.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.inner.class.display.name=Protected nested class protected.inner.class.problem.descriptor=Protected nested class #ref #loc 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.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.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 call.to.date.tostring.display.name=Call to 'Date.toString()' call.to.date.tostring.problem.descriptor=Date.#ref() used in an internationalized context #loc magic.character.display.name=Magic character magic.character.problem.descriptor=Magic character #ref in an internationalized context #loc call.to.numeric.tostring.display.name=Call to 'Number.toString()' call.to.numeric.tostring.problem.descriptor=Number.#ref() called in an internationalized context #loc 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 string.concatenation.display.name=String concatenation string.concatenation.problem.descriptor=String concatenation #ref in an internationalized context #loc 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 inspection.option.ignore.exceptions=Ignore for constructor arguments of Throwable subclasses inspection.option.ignore.nonnls=Ignore when annotated via @NonNls inspection.option.ignore.constant.initializers=Ignore for initializers of constant fields inspection.option.ignore.in.annotations=Ignore in annotations 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 use.stringtokenizer.display.name=Use of 'StringTokenizer' use.stringtokenizer.problem.descriptor=#ref in an internationalized context #loc time.tostring.call.display.name=Call to 'Time.toString()' time.tostring.call.problem.descriptor=Time.#ref() in an internationalized context #loc 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.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.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 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.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 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.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.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 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.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 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 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 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 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.display.name=Annotation annotation.problem.descriptor=Annotation #ref #loc assert.statement.display.name='assert' statement statement.problem.descriptor=#ref statement #loc auto.boxing.display.name=Auto-boxing auto.boxing.problem.descriptor=Auto-boxing #ref #loc 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.make.unboxing.explicit.quickfix=Make unboxing explicit enumerated.class.display.name=Enumerated class enumerated.class.problem.descriptor=Enumerated class #ref #loc 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.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.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 native.method.display.name=Native method native.method.problem.descriptor=Methods declared #ref are non-portable #loc runtime.exec.call.display.name=Call to 'Runtime.exec()' runtime.exec.call.problem.descriptor=Call to Runtime.#ref() is non-portable #loc 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.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 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.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.processbuilder.class.display.name=Use of 'java.lang.ProcessBuilder' class use.processbuilder.class.problem.descriptor=Use of #ref is non-portable #loc use.sun.classes.display.name=Use of 'sun.*' classes use.sun.classes.problem.descriptor=Use of Sun-supplied class #ref is non-portable #loc 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 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 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.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 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 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.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.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 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 overly.complex.class.display.name=Overly complex class overly.complex.class.problem.descriptor=Overly complex class #ref (cyclomatic complexity = {0}) #loc 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 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 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 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.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.methods.display.name=Class with too many methods too.many.methods.problem.descriptor=#ref has too many methods (method count = {0}) #loc 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 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.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 readwriteobject.private.display.name='readObject()' or 'writeObject()' not declared 'private' readwriteobject.private.problem.descriptor=#ref not declared 'private' #loc 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 readresolve.writereplace.protected.display.name='readResolve()' or 'writeReplace()' not declared 'protected' readresolve.writereplace.protected.problem.descriptor=#ref() not declared 'protected' #loc 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 serial.annotation.used.on.wrong.member.display.name='@Serial' annotation used on wrong member serial.annotation.used.on.wrong.member.problem.descriptor=Annotated member is not a part of the serialization mechanism serializable.record.contains.ignored.members.display.name='record' contains ignored members 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 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.quickfix=Make serialVersionUID 'private static final' #dynamic non.protected.constructor.in.abstract.class.display.name=Public constructor in abstract class unnecessary.qualifier.for.this.display.name=Unnecessary qualifier for 'this' or 'super' multiple.declaration.display.name=Multiple variables in one declaration thread.priority.display.name=Call to 'Thread.setPriority()' too.broad.scope.display.name=Scope of variable is too broad infinite.loop.statement.display.name=Infinite loop statement asserts.without.messages.display.name=Message missing on assertion constant.naming.convention.element.description=Constant constant.with.mutable.field.naming.convention.element.description=Constant with mutable type random.double.for.random.integer.display.name=Using 'Random.nextDouble()' to get random integer string.buffer.replaceable.by.string.builder.display.name='StringBuffer' may be 'StringBuilder' comparison.of.short.and.char.display.name=Comparison of 'short' and 'char' values unnecessary.fully.qualified.name.display.name=Unnecessary fully qualified name ignore.in.module.statements.option=Ignore in Java 9 module statements unnecessary.label.on.break.statement.display.name=Unnecessary label on 'break' statement exception.name.doesnt.end.with.exception.display.name=Exception class name does not end with 'Exception' bad.exception.declared.display.name=Prohibited exception declared pointless.boolean.expression.display.name=Pointless boolean expression class.without.constructor.display.name=Class without constructor break.statement.display.name='break' statement unconditional.wait.display.name=Unconditional 'wait()' call cyclomatic.complexity.display.name=Overly complex method final.class.display.name=Class is closed to inheritance labeled.statement.display.name=Labeled statement notify.called.on.condition.display.name='notify()' or 'notifyAll()' called on 'java.util.concurrent.locks.Condition' object loop.statements.that.dont.loop.display.name=Loop statement that does not loop ignore.enhanced.for.loop.statements=Ignore enhanced for loops non.synchronized.method.overrides.synchronized.method.display.name=Unsynchronized method overrides 'synchronized' method synchronize.on.this.display.name=Synchronization on 'this' switch.statement.with.too.many.branches.display.name=Maximum 'switch' branches utility.class.without.private.constructor.display.name=Utility class without 'private' constructor throw.caught.locally.display.name='throw' caught by containing 'try' statement exception.from.catch.which.doesnt.wrap.display.name='throw' inside 'catch' block which ignores the caught exception type.parameter.naming.convention.element.description=Type parameter multiply.or.divide.by.power.of.two.display.name=Multiplication or division by power of two multiply.or.divide.by.power.of.two.divide.option=Check divisions by a power of two also serializable.with.unconstructable.ancestor.display.name=Serializable class with unconstructable ancestor missorted.modifiers.display.name=Missorted modifiers sleep.while.holding.lock.display.name=Call to 'Thread.sleep()' while synchronized singleton.display.name=Singleton thread.death.rethrown.display.name='ThreadDeath' not rethrown if.statement.with.too.many.branches.display.name='if' statement with too many branches redundant.implements.display.name=Redundant interface declaration nesting.depth.display.name=Overly nested method return.this.display.name=Return of 'this' busy.wait.display.name=Busy wait utility.class.display.name=Utility class instantiating.object.to.get.class.object.display.name=Instantiating object to get 'Class' object abstract.class.extends.concrete.class.display.name=Abstract class extends concrete class parameter.naming.convention.display.name=Method parameter naming convention parameter.naming.convention.element.description=Parameter integer.division.in.floating.point.context.display.name=Integer division in floating-point context interface.naming.convention.element.description=Interface length.one.strings.in.concatenation.display.name=Single character string concatenation length.one.string.in.indexof.display.name= Single character string argument in 'String.indexOf()' call thread.yield.display.name=Call to 'Thread.yield()' confusing.floating.point.literal.display.name=Confusing floating-point literal wait.not.in.loop.display.name='wait()' not called in loop string.concatenation.inside.string.buffer.append.display.name=String concatenation as argument to 'StringBuilder.append()' call class.initializer.display.name=Non-'static' initializer enumerated.class.naming.convention.element.description=Enum class non.thread.safe.lazy.initialization.display.name=Unsafe lazy initialization of 'static' field call.to.simple.setter.in.class.display.name=Call to simple setter from within class comparison.to.nan.display.name=Comparison to 'Double.NaN' or 'Float.NaN' new.method.naming.convention.display.name=Method naming convention instance.method.naming.convention.element.description=Instance method unnecessary.semicolon.display.name=Unnecessary semicolon fallthru.in.switch.statement.display.name=Fallthrough in 'switch' statement call.to.native.method.while.locked.display.name=Call to a 'native' method while locked switch.statement.display.name='switch' statement custom.classloader.display.name=Custom 'ClassLoader' is declared nested.conditional.expression.display.name=Nested conditional expression duplicate.condition.display.name=Duplicate condition method.with.multiple.loops.display.name=Method with multiple loops non.comment.source.statements.display.name=Overly long method local.variable.naming.convention.display.name=Local variable naming convention local.variable.naming.convention.element.description=Local variable negated.if.else.display.name='if' statement with negated condition class.naming.convention.display.name=Class naming convention class.naming.convention.element.description=Class abstract.class.naming.convention.element.description=Abstract class serializable.inner.class.with.non.serializable.outer.class.display.name=Serializable non-'static' inner class with non-Serializable outer class pointless.arithmetic.expression.display.name=Pointless arithmetic expression method.name.same.as.class.name.display.name=Method name same as class name unnecessary.temporary.on.conversion.to.string.display.name=Unnecessary temporary object in conversion to 'String' unnecessary.continue.display.name=Unnecessary 'continue' statement inner.class.on.interface.display.name=Inner class of interface unused.label.display.name=Unused label overly.complex.boolean.expression.display.name=Overly complex boolean expression continue.statement.with.label.display.name='continue' statement with label class.loader.instantiation.display.name='ClassLoader' instantiation return.from.finally.block.display.name='return' inside 'finally' block unnecessary.boxing.display.name=Unnecessary boxing annotation.naming.convention.element.description=Annotation interface checked.exception.class.display.name=Checked exception class switch.statement.with.confusing.declaration.display.name=Local variable used and declared in different 'switch' branches cast.that.loses.precision.display.name=Numeric cast that loses precision manual.array.copy.display.name=Manual array copy manual.array.to.collection.copy.display.name=Manual array to collection copy long.literals.ending.with.lowercase.l.display.name='long' literal ending with 'l' instead of 'L' overly.complex.arithmetic.expression.display.name=Overly complex arithmetic expression junit.abstract.test.class.naming.convention.element.description=Abstract test class unnecessary.parentheses.display.name=Unnecessary parentheses serializable.class.in.secure.context.display.name=Serializable class in secure context static.variable.naming.convention.element.description='static' field nested.method.call.display.name=Nested method call throw.from.finally.block.display.name='throw' inside 'finally' block field.accessed.synchronized.and.unsynchronized.display.name=Field accessed in both 'synchronized' and unsynchronized contexts abstract.method.overrides.abstract.method.display.name=Abstract method overrides abstract method static.non.final.field.display.name='static', non-'final' field static.non.final.field.option=Only report 'public' fields class.without.no.arg.constructor.display.name=Class without no-arg constructor unnecessary.return.display.name=Unnecessary 'return' statement final.static.method.display.name='static' method declared 'final' constant.declared.in.abstract.class.display.name=Constant declared in 'abstract' class too.broad.catch.display.name=Overly broad 'catch' block floating.point.equality.display.name=Floating-point equality comparison thrown.exceptions.per.method.display.name=Method with too many exceptions declared public.static.array.field.display.name='public static' array field await.not.in.loop.display.name='await()' not called in loop method.names.differ.only.by.case.display.name=Method names differing only by case unsecure.random.number.generation.display.name=Insecure random number generation parameters.per.method.display.name=Method with too many parameters parameters.per.constructor.display.name=Constructor with too many parameters unnecessary.unboxing.display.name=Unnecessary unboxing extends.thread.display.name=Class directly extends 'Thread' parameter.name.differs.from.overridden.parameter.display.name=Parameter name differs from parameter in overridden or overloaded method final.private.method.display.name='private' method declared 'final' enum.switch.statement.which.misses.cases.display.name=Enum 'switch' statement that misses case enum.switch.statement.which.misses.cases.option=Ignore switch statements with a default branch string.buffer.must.have.initial.capacity.display.name='StringBuilder' without initial capacity method.may.be.static.display.name=Method can be made 'static' class.initializer.may.be.static.display.name=Class initializer may be 'static' class.initializer.option=Only warn when the class has one or more constructors class.initializer.move.code.to.constructor.quickfix=Move initializer code to constructor nested.switch.statement.display.name=Nested 'switch' statement c.style.array.declaration.display.name=C-style array declaration final.method.in.final.class.display.name='final' method in 'final' class extends.annotation.display.name=Class extends annotation interface naked.notify.display.name='notify()' or 'notifyAll()' without corresponding state change switch.statement.density.display.name='switch' statement with too low of a branch density switch.statement.with.too.few.branches.display.name=Minimum 'switch' branches upper.case.field.name.not.constant.display.name=Non-constant field with upper-case name unnecessary.label.on.continue.statement.display.name=Unnecessary label on 'continue' statement jdbc.prepare.statement.with.non.constant.string.display.name=Call to 'Connection.prepare*()' with non-constant string synchronize.on.non.final.field.display.name=Synchronization on a non-final field noop.method.in.abstract.class.display.name=No-op method in 'abstract' class non.final.field.of.exception.display.name=Non-final field of 'Exception' class 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 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' trivial.if.option.ignore.chained=Ignore chained 'if' statements trivial.if.option.ignore.assert.statements=Ignore 'if' statements with trivial 'assert' thread.with.default.run.method.display.name=Instantiating a 'Thread' with default 'run()' method while.loop.spins.on.field.display.name='while' loop spins on field while.loop.spins.on.field.fix.family.name=Fix spin loop while.loop.spins.on.field.fix.volatile=Make ''{0}'' volatile while.loop.spins.on.field.fix.spinwait=Add Thread.onSpinWait() while.loop.spins.on.field.fix.volatile.spinwait=Make ''{0}'' volatile and add Thread.onSpinWait() if.statement.with.identical.branches.display.name='if' statement with identical branches or common parts inspection.common.if.parts.message.variables.only=Extract variables from ''if''{0} inspection.common.if.parts.message.with.variables.extract=Extract common part with variables from ''if''{0} inspection.common.if.parts.message.without.variables.extract=Extract common part from ''if''{0} inspection.common.if.parts.message.whole.branch=Extract common part removing branch{0} inspection.common.if.parts.message.complete.duplicate=Collapse ''if'' statement{0} inspection.common.if.parts.message.complete.duplicate.side.effect=Collapse 'if' statement and extract side effect inspection.common.if.parts.description.variables.only=Variables can be extracted from ''if''{0} inspection.common.if.parts.description.with.variables.extract=Common parts with variables can be extracted from ''if''{0} inspection.common.if.parts.description.without.variables.extract=Common part can be extracted from ''if''{0} inspection.common.if.parts.description.whole.branch=Common part can be extracted removing branch{0} inspection.common.if.parts.description.complete.duplicate=''if'' statement can be collapsed{0} inspection.common.if.parts.description.complete.duplicate.side.effect='if' statement can be collapsed with side effect extraction inspection.note.may.change.semantics=may change semantics multiple.return.points.per.method.display.name=Method with multiple return points break.statement.with.label.display.name='break' statement with label public.constructor.in.non.public.class.display.name='public' constructor in non-public class questionable.name.display.name=Questionable name empty.finally.block.display.name=Empty 'finally' block abstract.method.overrides.concrete.method.display.name=Abstract method overrides concrete method thread.stop.suspend.resume.display.name=Call to 'Thread.stop()', 'suspend()' or 'resume()' constant.math.call.display.name=Constant call to 'Math' volatile.array.field.display.name=Volatile array field literal.as.arg.to.string.equals.display.name=String literal may be 'equals()' qualifier inner.class.may.be.static.display.name=Inner class may be 'static' redundant.field.initialization.display.name=Redundant field initialization utility.class.with.public.constructor.display.name=Utility class with 'public' constructor for.loop.replaceable.by.while.display.name='for' loop may be replaced by 'while' loop missing.deprecated.annotation.display.name=Missing '@Deprecated' annotation cloneable.class.in.secure.context.display.name=Cloneable class in secure context static.inheritance.display.name=Static inheritance class.name.prefixed.with.package.name.display.name=Class name prefixed with package name call.to.simple.getter.in.class.display.name=Call to simple getter from within class class.name.differs.from.file.name.display.name=Class name differs from file name protected.member.in.final.class.display.name='protected' member in 'final' class load.library.with.non.constant.string.display.name=Call to 'System.loadLibrary()' with non-constant string instanceof.catch.parameter.display.name='instanceof' on 'catch' parameter implicit.numeric.conversion.display.name=Implicit numeric conversion confusing.main.method.display.name=Confusing 'main()' method octal.literal.display.name=Octal integer misordered.assert.equals.arguments.display.name=Misordered 'assertEquals()' arguments unnecessary.constructor.display.name=Redundant no-arg constructor method.name.same.as.parent.name.display.name=Method name same as parent class name while.can.be.foreach.display.name='while' loop can be replaced with enhanced 'for' loop big.decimal.equals.display.name='equals()' called on 'BigDecimal' implicit.call.to.super.display.name=Implicit call to 'super()' unqualified.static.usage.display.name=Unqualified static access simplifiable.junit.assertion.display.name=Simplifiable assertion object.notify.display.name=Call to 'notify()' instead of 'notifyAll()' thread.start.in.construction.display.name=Call to 'Thread.start()' during object construction non.final.clone.display.name=Non-final 'clone()' in secure context unnecessary.temporary.on.conversion.from.string.display.name=Unnecessary temporary object in conversion from 'String' unnecessary.this.display.name=Unnecessary 'this' qualifier unnecessary.this.ignore.assignments.option=Ignore field assignments runtime.exec.with.non.constant.string.display.name=Call to 'Runtime.exec()' with non-constant string system.properties.display.name=Access of system properties chained.method.call.display.name=Chained method calls safe.lock.display.name=Lock acquired but not safely unlocked system.run.finalizers.on.exit.display.name=Call to 'System.runFinalizersOnExit()' for.can.be.foreach.display.name='for' loop can be replaced with enhanced for loop type.parameter.extends.object.display.name=Type parameter explicitly extends 'Object' type.parameter.extends.object.ignore.annotated=Ignore when java.lang.Object is annotated marker.interface.display.name=Marker interface limited.scope.inner.class.display.name=Local class switch.statements.without.default.display.name='switch' statement without 'default' branch 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 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 error.rethrown.display.name='Error' not rethrown serializable.has.serialization.methods.display.name=Serializable class without 'readObject()' and 'writeObject()' serializable.has.serialization.methods.ignore.option=Ignore classes that do not define instance fields missing.override.annotation.display.name=Missing '@Override' annotation wait.while.holding.two.locks.display.name='wait()' while holding two locks empty.class.display.name=Empty class trivial.string.concatenation.display.name=Concatenation with empty string trivial.string.concatenation.option.only.necessary=Report only where empty strings can be removed without other changes empty.synchronized.statement.display.name=Empty 'synchronized' statement unnecessary.default.display.name=Unnecessary 'default' for enum 'switch' statement simplifiable.conditional.expression.display.name=Simplifiable conditional expression unnecessary.super.constructor.display.name=Unnecessary call to 'super()' unnecessarily.qualified.static.usage.display.name=Unnecessarily qualified static access bad.exception.caught.display.name=Prohibited 'Exception' caught custom.security.manager.display.name=Custom 'SecurityManager' string.concatenation.in.loops.display.name=String concatenation in loop boolean.constructor.display.name=Boolean constructor call continue.statement.display.name='continue' statement extends.object.display.name=Class explicitly extends 'Object' serializable.inner.class.has.serial.version.uid.field.display.name=Serializable non-static inner class without 'serialVersionUID' static.method.naming.convention.element.description='static' method empty.try.block.display.name=Empty 'try' block field.has.setter.but.no.getter.display.name=Field has setter but no getter three.negations.per.method.display.name=Method with more than three negations conditional.expression.display.name=Conditional expression string.equals.empty.string.display.name='String.equals()' can be replaced with 'String.isEmpty()' synchronize.on.lock.display.name=Synchronization on a 'Lock' object synchronized.on.literal.object.name=Synchronization on an object initialized with a literal field.may.be.static.display.name=Field can be made 'static' class.may.be.interface.display.name=Abstract 'class' may be 'interface' abstract.class.without.abstract.methods.display.name=Abstract class without 'abstract' methods divide.by.zero.display.name=Division by zero default.not.last.case.in.switch.display.name='default' not last case in 'switch' nested.synchronized.statement.display.name=Nested 'synchronized' statement constant.conditional.expression.display.name=Constant conditional expression redundant.else.display.name=Redundant 'else' public.field.accessed.in.synchronized.context.display.name=Non-private field accessed in 'synchronized' context string.replaceable.by.string.buffer.display.name=Non-constant 'String' can be replaced with 'StringBuilder' junit.test.class.naming.convention.element.description=Test class junit.test.suite.naming.convention.element.description=Test suite method.coupling.display.name=Overly coupled method collections.must.have.initial.capacity.display.name=Collection without initial capacity anonymous.inner.class.display.name=Anonymous class can be replaced with inner class negated.conditional.display.name=Conditional expression with negated condition non.reproducible.math.call.display.name=Non-reproducible call to 'Math' multiple.top.level.classes.in.file.display.name=Multiple top level classes in single file set.replaceable.by.enum.set.display.name='Set' can be replaced with 'EnumSet' tail.recursion.display.name=Tail recursion finally.block.cannot.complete.normally.display.name='finally' block which can not complete normally non.atomic.operation.on.volatile.field.display.name=Non-atomic operation on 'volatile' field public.static.collection.field.display.name='public static' collection field non.exception.name.ends.with.exception.display.name=Non-exception class name ends with 'Exception' synchronized.method.display.name='synchronized' method enumerated.constant.naming.convention.element.description=Enum constant final.method.display.name=Method can't be overridden transient.field.in.non.serializable.class.display.name=Transient field in non-serializable class bad.exception.thrown.display.name=Prohibited exception thrown conditional.expression.with.identical.branches.display.name=Conditional expression with identical branches conditional.can.be.pushed.inside.expression.display.name=Conditional can be pushed inside branch expression conditional.can.be.pushed.inside.expression.option=Ignore when conditional will be only argument of a method call conditional.can.be.pushed.inside.expression.quickfix=Push conditional expression inside branch raw.use.of.parameterized.type.display.name=Raw use of parameterized class standard.variable.names.display.name=Standard variable names field.naming.convention.display.name=Field naming convention instance.variable.naming.convention.element.description=Instance field dollar.sign.in.name.display.name=Use of '$' in identifier map.replaceable.by.enum.map.display.name='Map' can be replaced with 'EnumMap' extends.concrete.collection.display.name=Class explicitly extends a 'Collection' class continue.or.break.from.finally.block.display.name='continue' or 'break' inside 'finally' block abstract.method.with.missing.implementations.display.name=Abstract method with missing implementations object.allocation.in.loop.display.name=Object allocation in loop wait.called.on.condition.display.name='wait()' called on 'java.util.concurrent.locks.Condition' object abstract.class.never.implemented.display.name=Abstract class which has no concrete subclass interface.never.implemented.display.name=Interface which has no concrete subclass 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 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 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 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 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 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 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 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 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 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.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 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 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.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 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.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 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.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 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 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 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 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 #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 inner.class.on.interface.ignore.option=Ignore inner interfaces of interfaces inner.class.on.interface.problem.descriptor=Interface ''{0}'' has inner class #ref #loc 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 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 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 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 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.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.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 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 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 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 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 add.serialversionuidfield.quickfix=Add 'serialVersionUID' field delete.import.quickfix=Delete unnecessary import encapsulate.variable.quickfix=Encapsulate field ''{0}'' extract.method.quickfix=Extract method inline.call.quickfix=Inline call inline.variable.quickfix=Inline variable pointless.nullcheck.display.name=Unnecessary 'null' check before method call pointless.nullcheck.problem.descriptor.call=Unnecessary ''null'' check before ''{0}()'' call remove.redundant.polyadic.operand.fix.name=Remove unnecessary ''{0}'' condition remove.redundant.polyadic.operand.fix.family.name=Remove unnecessary condition make.initialization.explicit.quickfix=Make initialization explicit move.anonymous.to.inner.quickfix=Convert to named inner class move.local.to.inner.quickfix=Convert to inner class anonymous.inner.may.be.named.static.inner.class.quickfix=Convert to named 'static' inner class 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 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.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 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 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 return.point.limit.option=&Return point limit: multiple.return.points.per.method.problem.descriptor=#ref has {0} return points #loc nesting.depth.limit.option=Nesting depth limit: nesting.depth.problem.descriptor=#ref is overly nested (maximum nesting depth = {0}) #loc 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 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 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' call.to.simple.getter.in.class.inline.quickfix=Inline call to getter call.to.simple.setter.in.class.ignore.option=Ignore setter calls on other objects call.to.private.setter.in.class.option=Only report when setter is 'private' 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.remove.compound.assignment.quickfix=Remove pointless compound assignment trivial.string.concatenation.problem.descriptor=Empty string in concatenation string.replace.quickfix=Remove empty string operand instantiating.object.to.get.class.object.replace.quickfix=Replace with direct class object access method.may.be.static.only.option=Only check 'private' or 'final' methods method.may.be.static.empty.option=Ignore empty methods string.concatenation.inside.string.buffer.append.replace.quickfix=Replace with chained 'append()' calls 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 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 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 simplifiable.conditional.expression.problem.descriptor={1} can be simplified to ''{0}'' #loc switch.statement.density.min.option=Minimum density of branches: % switch.statement.density.problem.descriptor=#ref branch density is too low ({0}%) #loc 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.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.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 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.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.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 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.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 unqualified.static.usage.qualify.method.quickfix=Qualify static method call too.broad.scope.allow.option=Report variables with a new expression as initializer
(potentially unsafe) too.broad.scope.only.blocks.option=Only report variables that can be moved into inner blocks 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.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.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 chained.method.call.ignore.self.types.option=Ignore calls to methods returning the same type as their enclosing class introduce.variable.quickfix=Introduce variable introduce.variable.may.change.semantics.quickfix=Introduce variable (may change semantics) flip.comparison.quickfix=Flip comparison control.flow.statement.without.braces.add.quickfix=Add braces to statement control.flow.statement.without.braces.message=Add braces to ''{0}'' statement extends.object.remove.quickfix=Remove redundant 'extends Object' implicit.call.to.super.ignore.option=Ignore for direct subclasses of 'java.lang.Object' implicit.call.to.super.make.explicit.quickfix=Make call to 'super()' explicit missorted.modifiers.require.option=Check annotation order missorted.modifiers.require.option.description=Use this option to report annotations in the wrong position: \ annotations with ElementType.TYPE_USE not directly \ before the type and after the modifier keywords, or \ other annotations not before the modifier keywords. \ When this option is disabled, annotations are allowed both before and after the modifier keywords. \ Annotations in between the modifier keywords will always be reported. missorted.modifiers.allowed.place=TYPE_USE annotations follow generation options missorted.modifiers.allowed.place.description=When this option is enabled, target TYPE_USE annotations are reported when they are not positioned according to the \ 
{0}
option in 
Settings | Editor | Code Style | Java | Code Generation.
\ When this option is disabled, target TYPE_USE annotations are allowed both directly before the type and before the modifier keywords. missorted.modifiers.sort.quickfix=Sort modifiers nested.method.call.ignore.option=Ignore nested method calls in field initializers ignore.calls.to.static.methods=Ignore calls to static methods ignore.calls.to.property.getters=Ignore calls to property getters redundant.field.initialization.remove.quickfix=Remove initializer redundant.implements.remove.quickfix=Remove redundant interface declaration unnecessary.constructor.remove.quickfix=Remove redundant constructor unnecessary.fully.qualified.name.replace.quickfix=Replace qualified name with import unnecessary.fully.qualified.name.remove.quickfix=Remove unnecessary qualification unnecessary.parentheses.remove.quickfix=Remove unnecessary parentheses 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 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 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.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.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.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 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 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.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.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 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 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.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.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.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 interface.never.implemented.option=Ignore interfaces which only declare constants size.replaceable.by.isempty.display.name='size() == 0' can be replaced with 'isEmpty()' size.replaceable.by.isempty.negation.ignore.option=Ignore expressions which would be replaced with '!isEmpty()' 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.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.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 static.method.only.used.in.one.class.ignore.anonymous.option=Ignore when only used from an anonymous class 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 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 signal.without.corresponding.await.display.name='signal()' without corresponding 'await()' signal.without.corresponding.await.problem.descriptor=Call to #ref() without corresponding await() #loc 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 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 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.quickfix=Cast to long integer.shift.implicit.cast.to.long.problem.descriptor=#ref: integer shift implicitly cast to long #loc 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 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 class.with.too.many.dependencies.problem.descriptor=Class ''{0}'' has too many dependencies ({1} > {2}) class.with.too.many.transitive.dependencies.display.name=Class with too many transitive dependencies class.with.too.many.transitive.dependencies.problem.descriptor=Class ''{0}'' has too many transitive dependencies ({1} > {2}) class.with.too.many.dependents.display.name=Class with too many dependents class.with.too.many.dependents.problem.descriptor=Class ''{0}'' has too many dependents ({1} > {2}) class.with.too.many.transitive.dependents.display.name=Class with too many transitive dependents class.with.too.many.transitive.dependents.problem.descriptor=Class ''{0}'' has too many transitive dependencies ({1} > {2}) class.with.too.many.dependencies.max.option=Maximum number of dependencies class.with.too.many.dependents.max.option=Maximum number of dependents class.with.too.many.transitive.dependencies.max.option=Maximum number of transitive dependencies class.with.too.many.transitive.dependents.max.option=Maximum number of transitive dependents cyclic.class.dependency.display.name=Cyclic class dependency cyclic.class.dependency.problem.descriptor=Class ''{0}'' is cyclically dependent on {1} other classes cyclic.class.dependency.1.problem.descriptor=Class ''{0}'' is cyclically dependent on class ''{1}'' cyclic.class.dependency.2.problem.descriptor=Class ''{0}'' is cyclically dependent on classes ''{1}'' and ''{2}'' cyclic.class.dependency.ignore.in.same.file=Ignore cycles between classes located in the same file cyclic.package.dependency.display.name=Cyclic package dependency cyclic.package.dependency.problem.descriptor=Package ''{0}'' is cyclically dependent on {1} other packages cyclic.package.dependency.1.problem.descriptor=Package ''{0}'' is cyclically dependent on package ''{1}'' cyclic.package.dependency.2.problem.descriptor=Package ''{0}'' is cyclically dependent on packages ''{1}'' and ''{2}'' class.unconnected.to.package.display.name=Class independent of its package class.unconnected.to.package.problem.descriptor=Class #ref has no dependencies or dependents in its package exception.package.display.name=Exception package exception.package.problem.descriptor=Package ''{0}'' contains only exception classes package.with.too.many.classes.display.name=Package with too many classes package.with.too.many.classes.problem.descriptor=Package ''{0}'' contains too many classes ({1} > {2}) package.with.too.many.classes.max.option=Maximum number of classes: package.with.too.few.classes.display.name=Package with too few classes package.with.too.few.classes.problem.descriptor=Package ''{0}'' contains too few classes ({1} < {2}) package.with.too.few.classes.min.option=Minimum number of classes: suspicious.package.private.access.display.name=Suspicious package-private access groups.of.modules.loaded.together.label=Groups of modules that are loaded together: groups.of.modules.loaded.together.description=Each line specifies a comma-separated list of module names which are known to be loaded by the same classloader.\nAccess to package-private members between such modules shouldn't be reported. module.with.too.many.classes.display.name=Module with too many classes module.with.too.many.classes.problem.descriptor=Module ''{0}'' contains too many classes ({1} > {2}) module.with.too.many.classes.max.option=Maximum number of classes: module.with.too.few.classes.display.name=Module with too few classes module.with.too.few.classes.problem.descriptor=Module ''{0}'' contains too few classes ({1} < {2}) module.with.too.few.classes.min.option=Minimum number of classes: package.in.multiple.modules.display.name=Package with classes in multiple modules package.in.multiple.modules.problem.descriptor2=Package ''{0}'' has classes in modules ''{1}'' and ''{2}'' package.in.multiple.modules.problem.descriptor3=Package ''{0}'' has classes in modules ''{1}'', ''{2}'' and ''{3}'' package.in.multiple.modules.problem.descriptor.many=Package ''{0}'' has classes in modules ''{1}'', ''{2}'' and ''{3}'' other modules disjoint.package.display.name=Package with disjoint dependency graph disjoint.package.problem.descriptor=Package {0} can be decomposed into {1} independent packages package.naming.convention.display.name=Package naming convention package.naming.convention.problem.descriptor.short=Package name {0} is too short 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 bad.oddness.display.name=Suspicious oddness check bad.oddness.problem.descriptor=Oddness check will fail on negative values #loc comparator.not.serializable.display.name='Comparator' class not declared 'Serializable' comparator.not.serializable.problem.descriptor=Comparator class #ref is not declared as Serializable #loc 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.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.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 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 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.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.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.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.quickfix=Replace type parameter with actual class double.negation.display.name=Double negation double.negation.problem.descriptor=Double negation in #ref #loc 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.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.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 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.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.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.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.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.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.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.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'' increment.decrement.used.as.expression.quickfix=Extract ''{0}'' to separate statement 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.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 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.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.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.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.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.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 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 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.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.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 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 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.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 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.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.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.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.display.name=Logger initialized with foreign class logger.factory.method.name=Logger Factory Method Name logger.factory.class.name=Logger Factory Class Name logger.initialized.with.foreign.class.ignore.super.class.option=Ignore loggers initialized with a superclass logger.initialized.with.foreign.class.ignore.non.public.classes.option=Ignore loggers in non-public classes 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.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.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 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 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 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.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.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 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 inspection.redundant.java.time.operation.creation.java.time.redundant.call.message=Redundant ''{0}'' call inspection.redundant.java.time.operation.creation.java.time.error.message=Redundant creation of ''{0}'' object inspection.redundant.java.time.operation.creation.java.time.error.remove.fix.message=Remove ''{0}'' call inspection.redundant.java.time.operation.creation.java.time.error.replace.fix.message=Replace with ''{0}'' call inspection.redundant.java.time.operation.creation.java.time.family.name=Simplify creation of 'java.time' object inspection.redundant.java.time.operation.creation.java.time.remove.family.name=Remove unnecessary call inspection.redundant.java.time.operation.compare.java.time.family.name=Simplify expression with 'java.time' 'compareTo()' call inspection.redundant.java.time.operation.compare.java.time.problem.descriptor=Expression with 'java.time' #ref() call can be simplified 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 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 constant.assert.condition.display.name=Constant condition in 'assert' statement constant.assert.condition.problem.descriptor=Assert condition #ref is constant #loc assert.with.side.effects.display.name='assert' statement with side effects assert.with.side.effects.problem.descriptor=#ref has side effects: {0} #loc 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 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.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.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.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.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 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 remove.leading.zeroes.to.make.decimals.quickfix=Remove leading zeroes to make decimals convert.octal.literal.to.decimal.literal.quickfix=Convert octal literal to decimal literal convert.octal.literals.to.decimal.literals.quickfix=Convert octal literals to decimal literals ignore.single.field.static.imports.option=Ignore single &field static imports ignore.single.method.static.imports.option=Ignore single &method static imports ignore.methods.with.boolean.return.type.option=Ignore methods with 'java.lang.&Boolean' return type ignore.boolean.methods.in.an.interface.option=Ignore boolean methods in an @&interface ignore.methods.overriding.super.method=Ignore methods &overriding/implementing a super method ignored.io.resource.types.label=Ignored I/O resource types: choose.io.resource.type.to.ignore=Choose I/O Resource Type to Ignore ignore.accesses.from.the.same.class=Ignore accesses from the same class ignore.accesses.from.equals.method=Ignore accesses from 'equals()' method ignore.branches.of.switch.statements=Ignore branches of 'switch' statements ignore.equals.hashcode.and.tostring=Ignore 'equals()', 'hashCode()' and 'toString()' methods ignore.methods.in.anonymous.classes=Ignore methods in anonymous classes class.name=Class Name method.name.regex=Method Name Regex inspection.test.method.without.assertion.list.name=Assertion methods: choose.class=Choose Class query.label=Query names start with: update.label=Update names start with: assert.keyword.is.considered.an.assertion='assert' keyword is considered an assertion choose.logger.class=Choose Logger Class logger.class.name=Logger class names: ignore.exceptions.declared.on.library.override.option=Ignore exceptions declared on methods overriding a &library method allow.resource.to.be.opened.inside.a.try.block=Allow resource to be opened inside a 'try' block any.method.may.close.resource.argument=Any method may close resource argument ignore.constructor.method.references=Ignore constructor method references which produce AutoCloseable ignore.getters.returning.resource=Ignore getters that returns resource log.method.name=Logging Method Name log.condition.text=Log Condition Text ignore.if.annotated.by=Ignore if annotated by: 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.quickfix=Qualify with outer class unnecessarily.qualified.inner.class.access.problem.descriptor=''{0}'' is unnecessarily qualified with #ref #loc 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 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.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.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 for.can.be.foreach.fix.no.indexed=Do not report indexed 'java.util.List' loops for.can.be.foreach.option2=Do not report iterations over untyped collections cast.conflicts.with.instanceof.quickfix1=Replace ''{0}'' with ''{1}'' in cast cast.conflicts.with.instanceof.quickfix2=Replace ''{0}'' with ''{1}'' in instanceof double.checked.locking.quickfix=Make ''{0}'' volatile double.literal.may.be.float.literal.display.name=Cast to 'float' can be 'float' literal 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.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 boxing.boxed.value.display.name=Boxing of already boxed value boxing.boxed.value.problem.descriptor=Boxing of already boxed #ref #loc 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 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 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 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.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 if.can.be.switch.null.safe.option=Only suggest on null-safe expressions unnecessarily.qualified.inner.class.access.option=Ignore references for which an import is needed 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 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.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.hash.code.display.name='hashCode()' called on array array.hash.code.problem.descriptor=#ref() called on array should probably be 'Arrays.hashCode()' #loc 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.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 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.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 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.quickfix=Remove cast null.thrown.display.name='null' thrown null.thrown.problem.descriptor=#ref thrown #loc 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.report.local.variables.option=Report local variables unnecessary.final.report.pattern.variables.option=Report pattern variables unnecessary.final.report.parameters.option=Report parameters unnecessary.final.on.parameter.only.interface.option=Only warn on abstract or interface methods choose.exception.class=Choose Exception Class choose.exception.label=Prohibited exceptions: class.independent.of.module.display.name=Class independent of its module class.independent.of.module.problem.descriptor=Class #ref has no dependencies or dependents in its module #loc 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 simplifiable.equals.expression.option.non.constant=Report equals with non-constant not-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.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 use.of.concrete.class.option.report.method.returns=Report method return type use.of.concrete.class.option.report.local.variable=Report local variable type use.of.concrete.class.option.report.parameter=Report method parameter type use.of.concrete.class.option.report.static.fields=Report static field type 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 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.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 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 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.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.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.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 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.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.quickfix=Remove negation negated.conditional.expression.display.name=Negated conditional expression negated.conditional.expression.problem.descriptor=Negating conditional expression #loc negated.conditional.expression.quickfix=Remove negation suspicious.array.cast.display.name=Suspicious array cast suspicious.array.cast.problem.descriptor=Suspicious cast to #ref #loc public.constructor.display.name='public' constructor can be replaced with factory method public.default.constructor.problem.descriptor=Class #ref has 'public' default constructor public.constructor.problem.descriptor=Public constructor #ref() #loc 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 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 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.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 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.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.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 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 package.info.java.without.package.display.name='package-info.java' without 'package' statement package.info.without.package.problem.descriptor='package-info.java' does not have a 'package' statement 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.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 negatively.named.boolean.variable.display.name=Negatively named boolean variable invert.quickfix.family.name=Invert boolean invert.method.quickfix=Invert method invert.quickfix=Invert ''{0}'' throwable.printed.to.system.out.display.name='Throwable' printed to 'System.out' throwable.printed.to.system.out.problem.descriptor=''Throwable'' argument #ref to ''System.{0}.{1}()'' call throwable.printed.to.system.out.problem.fix.level.option=Log method for fix: convert.system.out.to.log.call.family.name=Convert 'System.out' call to log call convert.system.out.to.log.call.name=Convert ''System.out'' call to call of ''{0}'' suppress.for.tests.scope.quickfix=Suppress for 'Tests' scope implicit.default.charset.usage.display.name=Implicit platform default charset implicit.default.charset.usage.problem.descriptor=Call to #ref() uses the platform's default charset implicit.default.charset.usage.constructor.problem.descriptor=new #ref() call uses the platform's default charset interface.may.be.annotated.functional.display.name=Interface may be annotated as '@FunctionalInterface' interface.may.be.annotated.functional.problem.descriptor=Interface #ref may be annotated with @FunctionalInterface only.report.public.methods.option=Only report 'public' methods lambda.parameter.hides.member.variable.display.name=Lambda parameter hides field static.initializer.references.subclass.display.name=Static initializer references subclass lambda.parameter.hides.member.variable.problem.descriptor=Lambda parameter #ref hides field in class ''{0}'' #loc 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 warn.on.label=Warn on: all.levels.option=all log levels warn.level.and.lower.option=warn level and lower info.level.and.lower.option=info level and lower debug.level.and.lower.option=debug level and lower trace.level.option=trace level ignored.autocloseable.types.label=Ignored AutoCloseable resource types: choose.autocloseable.type.to.ignore.title=Choose AutoCloseable Resource Type to Ignore big.decimal.method.without.rounding.called.display.name=Call to 'BigDecimal' method without a rounding mode argument big.decimal.method.without.rounding.called.problem.descriptor='BigDecimal.#ref()' called without a rounding mode argument bigdecimal.legacy.method.display.name='BigDecimal' legacy method called bigdecimal.legacy.method.problem.descriptor=Call to 'BigDecimal.#ref()' can use 'RoundingMode' enum constant bigdecimal.legacy.method.quickfix=Use 'RoundingMode' enum constant serializable.stores.non.serializable.display.name='Serializable' object implicitly stores non-'Serializable' object serializable.lambda.stores.non.serializable.problem.descriptor=Serializable lambda implicitly stores non-Serializable object of type ''{0}'' 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 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 equals.with.itself.display.name='equals()' called on itself equals.with.itself.problem.descriptor=#ref() called on itself equals.with.itself.option=Ignore possible contract testing equals.with.itself.option.description=When checked, some cases like assertEquals(myObj, myObj) will not be reported, to avoid warnings on tests checking the correctness of the equals() method. junit4.method.naming.convention.element.description=JUnit 4+ test method junit3.method.naming.convention.element.description=JUnit 3 test method 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.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.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 unnecessary.break.display.name=Unnecessary 'break' statement unnecessary.break.problem.descriptor=#ref statement is unnecessary #loc 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.quickfix=Convert to 'enum' non.public.clone.display.name='clone()' method not 'public' non.public.clone.problem.descriptor=#ref() method not 'public' #loc 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.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' 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.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.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 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.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 unary.plus.quickfix=Remove unary '+' convert.double.unary.quickfix=Replace with ''{0}{1}'' prefix.operation.quickfix.family.name=Replace with prefix operator confusing.floating.point.literal.option=Ignore floating-point literals in scientific notation class.may.be.interface.java8.option=Report classes containing non-abstract methods when using Java 8 simplifiable.boolean.expression.display.name=Simplifiable boolean expression unnecessary.initcause.display.name=Unnecessary call to 'Throwable.initCause()' unnecessary.initcause.problem.descriptor=Unnecessary Throwable.#ref() call unnecessary.initcause.quickfix=Remove 'Throwable.initCause()' call consider.static.final.fields.constant.option=Consider 'static final' fields constant atomic.field.updater.not.static.final.display.name='AtomicFieldUpdater' field not declared 'static final' atomic.field.updater.not.static.final.problem.descriptor={0} field #ref is not declared ''static final'' #loc 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}'' field.missing.volatile.modifier.problem.descriptor=Field ''{0}'' does not have ''volatile'' modifier field.has.static.modifier.problem.descriptor=Field ''{0}'' has ''static'' modifier private.field.not.accessible.problem.descriptor=''private'' field ''{0}'' is not accessible from here package.local.field.not.accessible=Package-private field ''{0}'' is not accessible from here protected.field.not.accessible.problem.descriptor=''protected'' field ''{0}'' is not accessible from here interface.clashes.with.object.class.display.name=Interface method clashes with method in 'Object' interface.clashes.with.object.class.problem.descriptor=#ref() clashes with method in 'java.lang.Object' optional.used.as.field.or.parameter.type.display.name='Optional' used as field or parameter type optional.used.as.field.type.problem.descriptor=#ref used as type for field ''{0}'' optional.used.as.parameter.type.problem.descriptor=#ref used as type for parameter ''{0}'' lambda.unfriendly.method.overload.display.name=Lambda-unfriendly method overload lambda.unfriendly.method.overload.problem.descriptor=Lambda-unfriendly overload of method #ref() lambda.unfriendly.constructor.overload.problem.descriptor=Lambda-unfriendly overload of constructor #ref() optional.contains.collection.display.name='Optional' contains array or collection 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 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 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 lambda.parameter.type.can.be.specified.descriptor=Lambda parameter types can be expanded to {0} lambda.parameter.type.can.be.specified.quickfix=Expand parameter types to {0} lambda.parameter.type.can.be.specified.family.quickfix=Specify lambda parameter type diamond.can.be.replaced.with.explicit.type.arguments.name=Diamond can be replaced with explicit type arguments diamond.can.be.replaced.with.explicit.type.arguments.quickfix=Replace '<>' with explicit type arguments lambda.can.be.replaced.with.anonymous.name=Lambda can be replaced with anonymous class lambda.can.be.replaced.with.anonymous.quickfix=Replace lambda with anonymous class method.ref.can.be.replaced.with.lambda.name=Method reference can be replaced with lambda method.ref.can.be.replaced.with.lambda.quickfix=Replace method reference with lambda try.statement.with.multiple.resources.name='try' statement with multiple resources can be split try.statement.with.multiple.resources.quickfix=Split 'try' statement with multiple resources multi.catch.can.be.split.name=Multi-catch can be split into separate catch blocks multi.catch.can.be.split.quickfix=Split multi-catch into separate 'catch' blocks assertion.can.be.if.name=Assertion can be replaced with 'if' statement assert.can.be.if.quickfix=Replace 'assert' with 'if' statement if.can.be.assertion.name=Statement can be replaced with 'assert' or 'Objects.requireNonNull' if.can.be.assertion.replace.with.assertion.quickfix=Replace statement with 'assert' statement if.can.be.assertion.replace.with.objects.requirenonnull.quickfix=Replace statement with 'Objects.requireNonNull()' single.statement.in.block.name=Code block contains single statement single.statement.in.block.descriptor=''{0}'' contains single statement single.statement.in.block.quickfix=Remove braces from ''{0}'' statement single.statement.in.block.family.quickfix=Remove braces from statement single.element.annotation.name=Non-normalized annotation single.element.annotation.quickfix=Add 'value=' single.element.annotation.family.quickfix=Expand annotation to normal form 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 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 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 unnecessary.string.escape.display.name=Unnecessarily escaped character unnecessary.string.escape.problem.descriptor={0} is unnecessarily escaped unnecessary.string.escape.quickfix=Remove unnecessary escaping redundant.escape.in.regex.replacement.display.name=Redundant escape in regex replacement string redundant.escape.in.regex.replacement.problem.descriptor=Redundant escape of ''{0}'' redundant.escape.in.regex.replacement.quickfix=Remove redundant escape array.can.be.replaced.with.enum.values = Array can be replaced with enum values array.can.be.replaced.with.enum.values.quickfix = Replace array with {0}.values() array.can.be.replaced.with.enum.values.family.quickfix = Replace array with EnumType.values() string.concatenation.replace.fix=Replace with StringBuilder string.concatenation.replace.fix.name=Convert variable ''{0}'' from String to {1} string.concatenation.replace.fix.name.null.safe=Convert variable ''{0}'' from String to {1} (null-safe) string.concatenation.introduce.fix=Introduce StringBuilder string.concatenation.introduce.fix.name=Introduce new {1} to update variable ''{0}'' string.concatenation.introduce.fix.name.null.safe=Introduce new {1} to update variable ''{0}'' (null-safe) 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 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 {1} #loc ignore.private.methods.option=Ignore assignments in and returns from private methods inspection.replace.on.literal.display.name=Replacement operation has no effect inspection.redundant.string.operation.display.name=Redundant 'String' operation inspection.redundant.embedded.expression.display.name=Redundant embedded expression in string template 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.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.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 inspection.redundant.string.option.do.not.report.single.argument.substring=Do not report redundant single argument substring() calls inspection.x.call.can.be.replaced.with.y=#ref() call can be replaced with ''{0}()'' 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.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 inspection.type.may.be.weakened.add.stopper.preview=The stop class will be added to the list of stop classes for this inspection. inspection.type.may.be.weakened.only.weaken.to.an.interface=Only weaken to an interface inspection.type.may.be.weakened.add.stop.class.family=Add stop class inspection.type.may.be.weakened.weaken.type.family=Weaken type inspection.type.may.be.weakened.add.stop.class.selection.table=Stop Classes inspection.type.may.be.weakened.add.stop.class.selection.table.label=Stop classes: inspection.type.may.be.weakened.add.stop.class.selection.popup=Select Stop Class inspection.type.may.be.weakened.do.not.weaken.inferred.variable.type=Do not suggest weakening variable declared as 'var' inspection.commented.out.code.display.name=Commented out code inspection.commented.out.code.problem.descriptor=Commented out code ({0} {0, choice, 1#line|1#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.redundant.collection.operation.display.name=Redundant 'Collection' operation inspection.redundant.collection.operation.fix.family.name=Simplify collection operation inspection.redundant.collection.operation.problem.arraycopy=Unnecessary collection created to copy an array inspection.redundant.collection.removal.by.index.problem=Removal by index can be replaced with removal by object inspection.redundant.collection.removal.by.index.fix=Use removal by object inspection.redundant.collection.unnecessary.contains.problem=Unnecessary ''{0}()'' check inspection.redundant.collection.unnecessary.contains.fix=Remove ''{0}()'' check comments.as.content.option=Comments count as content copy.constructor.misses.field.display.name=Copy constructor misses field copy.constructor.misses.field.problem.descriptor.1=Copy constructor does not copy field ''{0}'' copy.constructor.misses.field.problem.descriptor.2=Copy constructor does not copy fields ''{0}'' and ''{1}'' copy.constructor.misses.field.problem.descriptor.3=Copy constructor does not copy fields ''{0}'', ''{1}'' and ''{2}'' copy.constructor.misses.field.problem.descriptor.many=Copy constructor does not copy {0} fields fix.add.argument.family.name=Add argument fix.add.argument.name=Add ''{0}'' argument inspection.constant.expression.display.name=Constant expression can be evaluated inspection.constant.expression.message=Constant expression can be evaluated to ''{0}'' inspection.constant.expression.fix.name=Compute constant value of ''{0}'' inspection.constant.expression.fix.name.short=Replace with constant value inspection.constant.expression.fix.family.name=Compute constant value inspection.constant.expression.skip.non.literal=Don't report expressions containing references to defined constants inspection.constant.expression.skip.non.literal.description=Ignore expressions which contain references to non-literal operands, \ such as fields and variables. inspection.constant.expression.report.compile.time=Report only compile-time constants inspection.constant.expression.report.compile.time.description=By default, the inspection can evaluate some constants that involve \ library method calls, or even deduce the constant value based on the surrounding code. \ Check this option to report only compile-time constants, according to the Java language specification. inspection.redundant.compare.call.display.name=Redundant 'compare()' method call inspection.redundant.compare.call.fix.name=Inline 'compare()' call inspection.simplifiable.if.statement.display.name='if' statement can be replaced with conditional or boolean expression inspection.simplifiable.if.statement.message=If statement can be replaced with ''{0}'' inspection.simplifiable.if.statement.option.dont.warn.on.ternary=Don't suggest '?:' operator inspection.simplifiable.if.statement.fix.name=Replace ''if else'' with ''{0}'' inspection.simplifiable.if.statement.fix.family.name=Replace 'if else' with conditional expression inspection.list.remove.in.loop.display.name='List.remove()' called in loop inspection.list.remove.in.loop.message=Can be replaced with 'List.subList().clear()' implicit.default.charset.usage.fix.family.name=Specify UTF-8 charset inspection.redundant.class.call.display.name=Redundant 'isInstance()' or 'cast()' call inspection.new.object.equality.display.name=New object is compared using '==' inspection.new.object.equality.message=New object is compared using ''{0}'' inspection.excessive.range.check.message=Can be replaced with ''{0}'' inspection.excessive.range.check.fix.family.name=Simplify excessive range check suspicious.integer.div.assignment.problem.descriptor=Division result is truncated to integer suspicious.integer.div.assignment.display.name=Suspicious integer division assignment suspicious.integer.div.assignment.quickfix=Cast to double inspection.if.statement.missing.break.in.loop.name=Early loop exit in 'if' condition inspection.if.statement.missing.break.in.loop.description=Loop can be terminated after condition is met inspection.if.statement.missing.break.in.loop.quickfix=Add 'break' inspection.case.mismatch.display.name=Mismatched case in 'String' operation inspection.case.mismatch.message.arg.is.lower=Method ''{0}()'' always returns {1}: the argument contains a lowercase symbol while the qualifier doesn''t contain lowercase symbols inspection.case.mismatch.message.arg.is.upper=Method ''{0}()'' always returns {1}: the argument contains an uppercase symbol while the qualifier doesn''t contain uppercase symbols inspection.case.mismatch.message.label.is.lower=Switch branch is unreachable: the label contains a lowercase symbol while the selector is uppercase-only inspection.case.mismatch.message.label.is.upper=Switch branch is unreachable: the label contains an uppercase symbol while the selector is lowercase-only inspection.suspicious.date.format.display.name=Suspicious date format pattern inspection.suspicious.date.format.message.upper=Uppercase ''{0}'' ({1}) pattern is used: probably ''{2}'' ({3}) was intended inspection.suspicious.date.format.message.lower=Lowercase ''{0}'' ({1}) pattern is used: probably ''{2}'' ({3}) was intended inspection.unsupported.chrono.field.unit.call.display.name=Call methods with unsupported 'java.time.temporal.ChronoUnit' and 'java.time.temporal.ChronoField' inspection.unsupported.chrono.value.message=Unsupported argument value: {0} inspection.unsupported.chrono.values.message=Unsupported argument values: {0} inspection.incorrect.date.format.display.name=Incorrect 'DateTimeFormat' pattern inspection.incorrect.date.format.message.reserved.character=Use of reserved character ''{0}'' inspection.incorrect.date.format.message.unsupported=Illegal pattern letter ''{0}'' inspection.incorrect.date.format.too.many.letters=Too many consecutive pattern letters ''{0}''; maximum: {1}; specified: {2} inspection.incorrect.date.format.too.few.letters=Too few consecutive pattern letters ''{0}''; minimum: {1}; specified: {2} inspection.incorrect.date.format.wrong.number.of.letters=Wrong number of consecutive pattern letters ''{0}''; allowed: {1}; specified: {2} inspection.incorrect.date.format.message.unpaired=Closing #ref without previous opening ''{0}'' inspection.incorrect.date.format.message.literal=Opening single quote ({0}) without following closing single quote inspection.incorrect.date.format.message.padding=Padding modifier ''{0}'' without consecutive pattern letters inspection.incorrect.message.format.display.name=Incorrect 'MessageFormat' pattern inspection.incorrect.message.format.quotes.around.parameter=Placeholder ''{0}'' won''t be substituted because it is enclosed in quotes inspection.incorrect.message.format.choice.limit.incorrect=Lower bound ''{0}'' in choice pattern is incorrect inspection.incorrect.message.format.choice.limit.not.found=Empty lower bound in choice pattern inspection.incorrect.message.format.unknown.format.type=Unknown format type ''{0}'' inspection.incorrect.message.format.incorrect.index=Incorrect index ''{0}'' inspection.incorrect.message.format.unclosed.brace=Unclosed brace inspection.incorrect.message.format.unmatched.brace=Unmatched brace inspection.incorrect.message.format.incorrect.order.choice=Lower bounds not in ascending order in choice pattern inspection.incorrect.message.format.unpaired.quote=Unpaired quote in message pattern inspection.incorrect.message.format.incorrect.quotes.number=Probably incorrect number of quotes, more than 1 quote will be printed inspection.incorrect.message.format.not.found.argument=No argument for index ''{0}'' inspection.incorrect.message.format.not.found.arguments=No arguments for indexes: {0} inspection.incorrect.message.format.not.used.argument=Argument with index ''{0}'' is not used in the pattern inspection.incorrect.message.custom.classes.methods=Custom MessageFormat methods: # {0} is one of the inspection.incorrect.message.format messages above inspection.incorrect.message.format.pattern={0} in message format pattern ''{1}'' fix.replace.map.with.flat.map.description='map()' can be replaced with 'flatMap()' fix.eliminate.folded.if.present.name=Remove folded 'ifPresent()' call fix.eliminate.folded.if.present.description=Folded 'ifPresent()' call can be eliminated inspection.enhanced.for.with.record.pattern.can.be.used.display.name=Enhanced 'for' with a record pattern can be used inspection.enhanced.for.with.record.pattern.can.be.used.message=Can be replaced with enhanced 'for' with a record pattern inspection.enhanced.for.with.record.pattern.can.be.used.fix.family.name=Replace with a record pattern inspection.enhanced.for.with.record.pattern.can.be.used.level.option=Nesting depth limit: inspection.enhanced.for.with.record.pattern.can.be.used.components.option=Maximum number of record components to deconstruct: inspection.enhanced.for.with.record.pattern.can.be.used.not.used.option=Maximum number of not-used record components: inspection.enhanced.for.with.record.pattern.can.be.used.maximum.number.disabled=Don''t suggest for records with {0} or more components inspection.enhanced.for.with.record.pattern.can.be.used.maximum.depth.disabled=Don''t suggest for patterns with {0} and more nested patterns inspection.pattern.variable.can.be.used.display.name=Pattern variable can be used inspection.pattern.variable.can.be.used.message=Variable ''{0}'' can be replaced with pattern variable inspection.pattern.variable.can.be.used.instead.of.cast.message=Cast expression can be replaced with pattern variable inspection.pattern.variable.can.be.used.fix.family.name=Replace with pattern variable inspection.pattern.variable.instead.of.cast.can.be.used.fix.family.name=Replace cast expressions with pattern variable inspection.pattern.variable.can.be.used.fix.name=Replace ''{0}'' with pattern variable inspection.pattern.variable.can.be.used.existing.message=Existing pattern variable ''{0}'' can be used instead of ''{1}'' inspection.pattern.variable.can.be.used.existing.cast.message=Existing pattern variable ''{0}'' can be used instead of cast expression inspection.pattern.variable.can.be.used.existing.fix.family.name=Replace with existing pattern variable inspection.pattern.variable.can.be.used.existing.fix.name=Replace ''{0}'' with existing pattern variable ''{1}'' inspection.pattern.variable.instead.of.cast.can.be.used.existing.fix.name=Replace cast expression with existing pattern variable ''{0}'' inspection.pattern.variable.can.be.used.report.cast.only=Report cast expressions which can be replaced with new introduced pattern variables inspection.cast.can.be.replaced.with.variable.display.name=Cast can be replaced with variable inspection.cast.can.be.replaced.with.variable.message=Variable ''{0}'' can be used instead of ''{1}'' inspection.cast.can.be.replaced.with.variable.family.name=Replace cast with variable inspection.deconstruction.can.be.used.display.name=Record pattern can be used inspection.deconstruction.can.be.used.message=Can be replaced with record pattern inspection.deconstruction.can.be.used.fix.family.name=Replace with record pattern markdown.documentation.comments.migration.display.name=Javadoc comment can be Markdown documentation comment markdown.documentation.comments.migration.fix=Convert to Markdown documentation comment array.hash.code.fix.family.name=Replace with 'Arrays.hashCode()' call objects.hash.fix.family.name=Wrap with 'Arrays.hashCode()' unqualified.static.access.fix.family.name=Qualify static access replace.field.reference.fix.family.name=Replace field reference replace.field.reference.fix.text=Replace field reference with ''{0}'' replace.method.call.fix.family.name=Replace method call replace.method.call.fix.text=Replace method call with ''{0}'' delete.unnecessary.statement.fix.family.name=Remove redundant statement increment.decrement.used.as.expression.fix.family.name=Extract to separate statement use.of.properties.as.hashtable.fix.family.name=Fix property access unnecessary.java.doc.link.fix.family.name=Remove redundant tag swap.equals.fix.family.name=Flip method call remove.modifier.fix.family.name=Remove modifier shift.out.of.range.fix.family.name=Fix shift value unnecessary.unicode.escape.fix.family.name=Replace with character unnecessary.unicode.escape.fix.text=Replace with line feed character absolute.alignment.in.user.interface.fix.family.name=Replace with constant static.inheritance.fix.family.name=Replace inheritance with qualified reference suspicious.to.array.call.fix.family.name=Replace with proper array incorrect.date.format.fix.family.name=Fix incorrect date format referencing.subclass.0.from.superclass.1.initializer.might.lead.to.class.loading.deadlock=Referencing subclass {0} from superclass {1} initializer might lead to class loading deadlock collections.field.access.replaceable.by.method.call.fix.family.name=Replace Collections.EMPTY_* with call delete.catch.section.fix.family.name=Delete catch statement make.field.static.final.fix.family.name=Make static final string.concatenation.in.format.call.fix.family.name=Replace concatenation with argument implicit.array.to.string.fix.family.name=Make Array.toString() implicit listener.may.use.adapter.fix.family.name=Replace with adapter unnecessary.temporary.object.fix.family.name=Replace concatenation utility.class.with.public.constructor.fix.family.name=Make constructors not public change.modifier.fix.family.name=Change modifier make.field.final.fix.family.name=Make final generate.to.string.quick.fix.family.name=Generate generate.to.string.quick.fix.text=Generate toString() replace.instanceof.fix.family.name=Replace instanceOf type replace.cast.fix.family.name=Replace cast type make.package.private.fix.family.name=Make package-private make.method.final.fix.family.name=Make method 'final' replace.casted.literal.with.just.literal.fix.family.name=Replace with {0} literal char.used.in.arithmetic.content.cast.fix.family.name=Insert cast ignore.parentheses.around.single.no.formal.type.lambda.parameter=Ignore parentheses around single no formal type lambda parameter double.checked.locking.fix.family.name=Make field volatile declare.collection.as.interface.fix.family.name=Weaken type string.equals.empty.string.fix.family.name=Simplify empty string check class.without.logger.annotations.tab=Annotations class.without.logger.loggers.tab=Loggers options.title.ignored.classes=Ignored Classes options.label.ignored.classes=Ignored classes: add.catch.section.fix.family.name=Add 'catch' clause inspection.autocloseable.resource.ignored.methods.title=Ignore AutoCloseable instances returned from these methods: logger.initialized.with.foreign.class.fix.family.name=Replace foreign class extend.exception.fix.family.name=Make class extend 'Exception' inspection.use.of.private.field.inner.classes.option=Ignore accesses from inner classes refused.bequest.fix.family.name=Insert call to super method mark.modules.as.loaded.together.fix.family.name=Mark modules as loaded together mark.modules.as.loaded.together.fix.text=Mark ''{0}'' and ''{1}'' modules as loaded together inspection.suspicious.package.private.access.description={0} is {1}, but declared in a different module ''{2}'' replace.case.default.with.default=Replace 'case default' with 'default' replace.case.default.null.with.null.default=Replace 'case default, null' with 'case null, default' create.default.branch.fix.family.name=Create 'default' branch create.null.branch.fix.family.name=Create 'null' branch create.missing.enum.switch.branches.fix.family.name=Create missing enum switch branches create.missing.boolean.switch.branches.fix.family.name=Create missing boolean switch branches create.missing.sealed.class.switch.branches.fix.family.name=Create missing sealed class switch branches create.missing.branches.with.null.branch.fix.family.name=Create missing and 'null' branches create.missing.record.deconstructions.switch.branches.fix.family.name=Create missing record deconstruction switch branches unnecessary.fully.qualified.name.fix.family.name=Replace fully qualified name return.of.collection.field.fix.family.name=Make return collection 'unmodifiable' remove.redundant.substring.fix.family.name=Remove redundant 'substring()' call remove.redundant.string.fix.text=Use ''{0}()'' and remove redundant ''{1}()'' call use.equalsignorecase.for.case.insensitive.comparison=Use 'equalsIgnoreCase()' for case-insensitive comparison use.contentequals=Use 'contentEquals()' for comparison with 'AbstractStringBuilder' use.isblank.to.check.if.string.is.whitespace.or.empty=Use 'isBlank()' to check if a string is empty or only contains whitespace make.class.final.fix.family.name=Make class final side.effects.method.ref.to.lambda.fix.family.name={0} (side effects) encapsulate.variable.fix.family.name=Encapsulate field method.may.be.static.replaces.qualifiers.with.class.references.option=Quick-fix replaces instance qualifiers with class references method.may.be.static.ignore.default.methods.option=Ignore 'default' methods convert.empty.anonymous.to.new.fix.family.name=Remove '{}' replace.method.ref.with.qualifier.fix.family.name=Replace with qualifier replace.method.ref.with.qualifier.problem.method=Method reference can be replaced with qualifier replace.method.ref.with.qualifier.problem.lambda=Lambda can be replaced with call qualifier add.throws.clause.fix.family.name=Fix 'throws' clause prefer.empty.array.options.title=Prefer empty array: prefer.empty.array.options.mode.always=Always prefer.empty.array.options.mode.by.level=According to language level prefer.empty.array.options.mode.always.never=Never (prefer pre-sized array) too.broad.scope.inspection.fix.family.name=Narrow scope replace.with.cast.fix.family.name=Replace with cast replace.anonymous.with.lambda.body.fix.family.name=Replace call with method body replace.with.method.reference.fix.family.name=Replace method call on method reference with corresponding method call replace.with.lambda.body.fix.family.name=Replace method call on lambda with lambda body inspection.trivial.functional.expression.usage.description=Method call can be simplified replace.with.var.fix.family.name=Replace explicit type with 'var' inspection.redundant.explicit.variable.type.description=Explicit type of local variable can be omitted add.read.write.object.methods.fix.family.name=Add 'readObject()' and 'writeObject()' methods which always throw an exception add.read.write.object.methods.fix.text=Add 'writeObject()' method which always throws an exception add.read.write.object.methods.fix.text2=Add 'readObject()' method which always throws an exception replace.with.method.ref.fix.family.name=Replace lambda with method reference replace.with.method.ref.fix.name.may.change.semantics=Replace lambda with method reference (may change semantics) qualify.call.fix.family.name=Qualify call replace.with.comparator.fix.family.name=Simplify comparator using 'Comparator' static methods inspection.comparator.combinators.description=Can be replaced with 'Comparator' chain inspection.comparator.combinators.description2=Can be replaced with ''{0}'' inspection.unnecessary.string.escape.report.char.literals.option=Report char literals inspection.method.call.in.loop.ignore.known.methods.option=Ignore known methods with side-effects throws.runtime.exception.fix.family.name=Remove from 'throws' clause move.exception.to.javadoc.fix.family.name=Move to Javadoc '@throws' create.package.info.java.family.name=Create 'package-info.java' remove.loop.fix.family.name=Remove loop remove.call.fix.family.name=Remove call inspection.meta.annotation.without.runtime.description={0} should have @Retention(RetentionPolicy.RUNTIME) inspection.refused.bequest.super.annotated.option=Only report when super method is annotated by: inspection.empty.class.ignore.subclasses.option=Ignore subclasses of {0} inspection.test.method.without.assertions.exceptions.option=Ignore test methods which declare exceptions inspection.collection.must.have.initial.capacity.initializers.option=Don't report field initializers utility.class.without.private.constructor.cant.generate.constructor.message=Utility class has instantiations, private constructor will not be created inspection.suspicious.package.private.access.problem={0} overrides a package-private method from {1} which is declared in a different module ''{2}'' inspection.condition.covered.by.further.condition.descr=Condition ''{0}'' covered by subsequent {1, choice, 1#condition ''''{2}''''|2#conditions} create.missing.switch.branch=Create missing branch {0} create.missing.switch.branches=Create missing branches {0} redundant.as.list.for.iteration.problem=Unnecessary 'Arrays.asList()' call redundant.as.list.for.iteration.fix.name=Unwrap assert.with.side.effects.call.mutates.expression=call to ''{0}()'' mutates ''{1}'' assert.with.side.effects.call.performs.io=call to ''{0}()'' performs input/output operation assert.with.side.effects.call.mutates.field=call to ''{0}()'' mutates field ''{1}'' inspection.comparator.combinators.fix.chain=Replace with 'Comparator' chain constant.on.lhs.of.comparison.options.item.left=left constant.on.lhs.of.comparison.options.item.right=right inspection.byte.array.output.stream.to.string.message=Inefficient conversion from ByteArrayOutputStream checkbox.ignore.null.on.wrong.side=Ignore 'null' on the wrong side remove.annotation.parameter.0.fix.name=Remove annotation parameter ''{0}'' set.annotation.parameter.0.1.fix.name=Set annotation parameter {0} = "{1}" progress.text.analyzing.package.0=Analyzing package {0} try.with.identical.catches.checkbox.different.comments=Do not report catch blocks with different comments inspection.non.strict.comparison.equality.message=Can be replaced with equality inspection.non.strict.comparison.equality.display.name=Non-strict inequality '>=' or '<=' can be replaced with '==' inspection.use.of.slash.s.fix.family=Replace '\\s' sequences with spaces inspection.use.of.slash.s.message=Use of the escape sequence '\\s' as a non-trailing space inspection.use.of.slash.s.non.text.block.message=Use of the escape sequence '\\s' outside of text blocks inspection.use.of.slash.s.display.name=Non-terminal use of '\\s' escape sequence negative.int.constant.in.long.context.display.name=Negative int hexadecimal constant in long context negative.int.constant.in.long.context.fix.add.suffix=Add 'L' suffix (changes semantics) negative.int.constant.in.long.context.fix.convert=Convert to long constant (preserves semantics) inspection.only.one.element.used.display.name=Only one element is used inspection.only.one.element.used.array=Only one array element is used inspection.only.one.element.used.string=Only one string character is used inspection.only.one.element.used.list=Only one list element is used inspection.only.one.element.used.fix.family=Replace with an accessed element inspection.common.subexpression.in.switch.display.name=Common subexpression can be extracted from 'switch' inspection.common.subexpression.in.switch.fix.family.name=Push down 'switch' expression inspection.redundant.length.check.display.name=Redundant array length check inspection.redundant.embedded.expression.message.literal=Redundant embedded literal inspection.redundant.embedded.expression.message.empty=Redundant empty embedded expression inspection.redundant.embedded.expression.fix.family.name=Inline embedded expression auto.closeable.resource.quickfix.preview=Add method {0} to the list of ignored methods inspection.while.can.be.replaced.with.do.while.display.name='while' can be replaced with 'do while' inspection.while.can.be.replaced.with.do.while.message=Replace 'while' with 'do while' inspection.while.can.be.replaced.with.do.while.family.name=Replace 'while' with 'do while'