diff --git a/java-analysis-impl/src/main/resources/LOCALIZE-LIB/en_US/com.siyeh.InspectionGadgetsLocalize.yaml b/java-analysis-impl/src/main/resources/LOCALIZE-LIB/en_US/com.siyeh.InspectionGadgetsLocalize.yaml index a21fb9ad05..f16f783f95 100644 --- a/java-analysis-impl/src/main/resources/LOCALIZE-LIB/en_US/com.siyeh.InspectionGadgetsLocalize.yaml +++ b/java-analysis-impl/src/main/resources/LOCALIZE-LIB/en_US/com.siyeh.InspectionGadgetsLocalize.yaml @@ -1,4432 +1,4460 @@ -cast.to.concrete.class.display.name: - text: Cast to a concrete class -cast.to.concrete.class.problem.descriptor: - text: 'Cast to concrete class {0} #loc' -class.references.subclass.display.name: - text: Class references one of its subclasses -class.references.subclass.problem.descriptor: - text: 'Class ''''{0}'''' references subclass #ref #loc' -class.references.subclass.problem.descriptor.anonymous: - text: 'Anonymous class references subclass #ref #loc' -collection.declared.by.class.display.name: - text: Collection declared by class, not interface -collection.declared.by.class.problem.descriptor: - text: 'Declaration of #ref should probably be weakened to ''''{0}'''' #loc' -collection.declared.by.class.ignore.locals.option: - text: Ignore local variables -collection.declared.by.class.ignore.private.members.option: - text: Ignore 'private' fields and methods -feature.envy.display.name: - text: Feature envy -feature.envy.problem.descriptor: - text: 'Class ''''{0}'''' accessed repeatedly in method #ref() #loc' -instance.variable.of.concrete.class.display.name: - text: Type of instance field is concrete class -instance.variable.of.concrete.class.problem.descriptor: - text: 'Type of field ''''{0}'''' is concrete class #ref #loc' -chain.of.instanceof.checks.display.name: - text: Chain of 'instanceof' checks -chain.of.instanceof.checks.problem.descriptor: - text: 'Chain of ''instanceof'' checks indicates abstraction failure #loc' -chain.of.class.equality.checks.problem.descriptor: - text: 'Chain of class equality checks indicates abstraction failure #loc' -instanceof.concrete.class.display.name: - text: '''instanceof'' a concrete class' -instanceof.concrete.class.problem.descriptor: - text: '''instanceof'' concrete class #ref #loc' -instanceof.check.for.this.display.name: - text: '''instanceof'' check for ''this''' -instanceof.check.for.this.problem.descriptor: - text: '''instanceof'' check for #ref #loc' -local.variable.of.concrete.class.display.name: - text: Local variable of concrete class -local.variable.of.concrete.class.problem.descriptor: - text: 'Local variable ''''{0}'''' of concrete class #ref #loc' -magic.number.display.name: - text: Magic number -magic.number.problem.descriptor: - text: 'Magic number #ref #loc' -method.return.concrete.class.display.name: - text: Method return of concrete class -method.return.concrete.class.problem.descriptor: - text: 'Method returns a concrete class #ref #loc' -overly.strong.type.cast.display.name: - text: Overly strong type cast -overly.strong.type.cast.weaken.quickfix: - text: Weaken overly strong cast -concrete.class.method.parameter.display.name: - text: Method parameter of concrete class -concrete.class.method.parameter.problem.descriptor: - text: 'Parameter ''''{0}'''' of concrete class #ref #loc' -public.method.not.in.interface.display.name: - text: '''public'' method not exposed in interface' -public.method.not.in.interface.problem.descriptor: - text: '''public'' method #ref() is not exposed via an interface #loc' -public.method.not.in.interface.option: - text: Ignore if the containing class does not implement a non-library interface -static.variable.of.concrete.class.display.name: - text: Static field of concrete class -static.variable.of.concrete.class.problem.descriptor: - text: 'Static field ''''{0}'''' of concrete class #ref #loc' -incompatible.mask.operation.display.name: - text: Incompatible bitwise mask operation -incompatible.mask.operation.problem.descriptor.always.false: - text: '#ref is always false #loc' -incompatible.mask.operation.problem.descriptor.always.true: - text: '#ref is always true #loc' -pointless.bitwise.expression.display.name: - text: Pointless bitwise expression -pointless.bitwise.expression.simplify.quickfix: - text: Simplify -shift.operation.by.inappropriate.constant.display.name: - text: Shift operation by inappropriate constant -shift.operation.by.inappropriate.constant.problem.descriptor.too.large: - text: 'Shift operation #ref by overly large constant value #loc' -shift.operation.by.inappropriate.constant.problem.descriptor.negative: - text: 'Shift operation #ref by negative constant value #loc' -equals.called.on.array.display.name: - text: '''equals()'' called on array' -equals.called.on.array.problem.descriptor: - text: '#ref() between arrays should probably be ''Arrays.equals()'' #loc' -replace.with.arrays.equals: - text: Replace with 'Arrays.equals()' -replace.with.arrays.deep.equals: - text: Replace with 'Arrays.deepEquals()' +0.will.have.incompatible.access.privileges.with.super.1: + text: '{0} will have incompatible access privileges with super {1}' +0.will.no.longer.be.overridable.by.1: + text: '{0} will no longer be overridable by {1}' +0.will.no.longer.be.visible.from.overriding.1: + text: '{0} will no longer be visible from overriding {1}' +absolute.alignment.in.user.interface.display.name: + text: Absolute alignment in AWT/Swing code +absolute.alignment.in.user.interface.problem.descriptor: + text: 'Absolute alignment constant {0}.#ref used #loc' +absolute.alignment.in.user.interface.quickfix: + text: Replace with ''{0}.{1}'' +abstract.class.extends.concrete.class.display.name: + text: Abstract class extends concrete class +abstract.class.extends.concrete.class.problem.descriptor: + text: 'Class #ref is declared ''abstract'', and extends a concrete class #loc' +abstract.class.naming.convention.display.name: + text: Abstract class naming convention +abstract.class.naming.convention.element.description: + text: Abstract class +abstract.class.never.implemented.display.name: + text: Abstract class which has no concrete subclass +abstract.class.never.implemented.problem.descriptor: + text: 'Abstract class #ref has no concrete subclass #loc' +abstract.class.with.only.one.direct.inheritor.display.name: + text: Abstract class with a single direct inheritor +abstract.class.with.only.one.direct.inheritor.problem.descriptor: + text: 'Abstract class #ref has only one direct inheritor #loc' +abstract.class.without.abstract.methods.display.name: + text: Abstract class without 'abstract' methods +abstract.class.without.abstract.methods.problem.descriptor: + text: 'Class #ref is declared ''abstract'', and has no ''abstract'' methods #loc' +abstract.method.call.in.constructor.display.name: + text: Abstract method called during object construction +abstract.method.call.in.constructor.problem.descriptor: + text: 'Call to ''abstract'' method #ref() during object construction #loc' +abstract.method.overrides.abstract.method.display.name: + text: Abstract method overrides abstract method +abstract.method.overrides.abstract.method.ignore.different.annotations.option: + text: Ignore methods with different annotations than their super methods +abstract.method.overrides.abstract.method.ignore.different.javadoc.option: + text: Ignore methods with different Javadoc than their super methods +abstract.method.overrides.abstract.method.problem.descriptor: + text: 'Abstract method #ref() overrides abstract method #loc' +abstract.method.overrides.abstract.method.remove.quickfix: + text: Remove redundant abstract method declaration +abstract.method.overrides.concrete.method.display.name: + text: Abstract method overrides concrete method +abstract.method.overrides.concrete.method.problem.descriptor: + text: 'Abstract method #ref() overrides concrete method #loc' +abstract.method.with.missing.implementations.display.name: + text: Abstract method with missing implementations +abstract.method.with.missing.implementations.problem.descriptor: + text: 'Abstract method #ref() is not implemented in every subclass #loc' +access.to.non.thread.safe.static.field.from.instance.class.chooser.title: + text: Choose Non-Thread-Safe Class +access.to.non.thread.safe.static.field.from.instance.display.name: + text: Non-thread-safe 'static' field access +access.to.non.thread.safe.static.field.from.instance.field.problem.descriptor: + text: 'Access to non-thread-safe static field #ref of type ''''{0}'''' #loc' +access.to.non.thread.safe.static.field.from.instance.option.title: + text: Non-thread-safe classes +access.to.static.field.locked.on.instance.display.name: + text: Access to 'static' field locked on instance data +access.to.static.field.locked.on.instance.problem.descriptor: + text: 'Access to static field #ref locked on instance data #loc' +accessing.non.public.field.of.another.object.display.name: + text: Accessing a non-public field of another object +accessing.non.public.field.of.another.object.problem.descriptor: + text: 'Direct access to non-public field #ref of another object #loc' +add.0.to.ignore.if.annotated.by.list.quickfix: + text: Add ''{0}'' to ''Ignore if annotated by'' list +add.serialversionuidfield.quickfix: + text: Add 'serialVersionUID' field +add.this.qualifier.quickfix: + text: Add 'this' qualifier +all.levels.option: + text: all log levels +allow.resource.to.be.opened.inside.a.try.block: + text: Allow resource to be opened inside a 'try' block +ambiguous.field.access.display.name: + text: Access to inherited field looks like access to element from surrounding code +ambiguous.field.access.hides.field.problem.descriptor: + text: 'Access of field #ref from superclass ''''{0}'''' looks like access of field from surrounding class #loc' +ambiguous.field.access.hides.local.variable.problem.descriptor: + text: 'Access of field #ref from superclass ''''{0}'''' looks like access of local variable #loc' +ambiguous.field.access.hides.parameter.problem.descriptor: + text: 'Access of field #ref from superclass ''''{0}'''' looks like access of parameter #loc' +ambiguous.field.access.quickfix: + text: Add 'super' qualifier to field access +ambiguous.method.call.display.name: + text: Call to inherited method looks like call to local method +ambiguous.method.call.problem.descriptor: + text: 'Call to method #ref() from superclass ''''{0}'''' looks like call to method from class ''''{1}'''' #loc' +ambiguous.method.call.quickfix: + text: Add 'super' qualifier to method call +annotation.class.display.name: + text: Annotation interface +annotation.class.problem.descriptor: + text: 'Annotation interface #ref #loc' +annotation.display.name: + text: Annotation +annotation.naming.convention.display.name: + text: Annotation naming convention +annotation.naming.convention.element.description: + text: Annotation interface +annotation.problem.descriptor: + text: 'Annotation #ref #loc' +anonymous.class.field.hides.containing.method.variable.problem.descriptor: + text: 'Anonymous class field #ref hides variable in containing method #loc' +anonymous.class.parameter.hides.containing.method.variable.problem.descriptor: + text: 'Anonymous class parameter #ref hides variable in containing method #loc' +anonymous.class.variable.hides.containing.method.variable.display.name: + text: Anonymous class variable hides variable in containing method +anonymous.class.variable.hides.containing.method.variable.problem.descriptor: + text: 'Anonymous class local variable #ref hides variable in containing method #loc' +anonymous.extends.concrete.collection.problem.descriptor: + text: 'Anonymous class explicitly extends ''''{0}'''' #loc' +anonymous.extends.thread.problem.descriptor: + text: 'Anonymous class directly extends ''java.lang.Thread'' #loc' +anonymous.extends.throwable.problem.descriptor: + text: 'Anonymous class directly extends ''java.lang.Throwable'' #loc' +anonymous.inner.class.display.name: + text: Anonymous class can be replaced with inner class +anonymous.inner.class.problem.descriptor: + text: 'Anonymous class #ref #loc' +anonymous.inner.class.with.too.many.methods.display.name: + text: Anonymous class with too many methods +anonymous.inner.class.with.too.many.methods.problem.descriptor: + text: 'Anonymous class with too many methods (method count = {0}) #loc' +anonymous.inner.may.be.named.static.inner.class.display.name: + text: Anonymous class may be a named 'static' inner class +anonymous.inner.may.be.named.static.inner.class.problem.descriptor: + text: 'Anonymous class #ref may be a named ''static'' inner class #loc' +anonymous.inner.may.be.named.static.inner.class.quickfix: + text: Convert to named 'static' inner class +any.method.may.close.resource.argument: + text: Any method may close resource argument +array.allocation.zero.length.display.name: + text: Zero-length array allocation +array.allocation.zero.length.problem.descriptor: + text: 'Allocation of zero length array #loc' +array.comparison.display.name: + text: Array comparison using '==', instead of 'Arrays.equals()' +array.comparison.problem.descriptor: + text: 'Array objects are compared using #ref, not ''Arrays.equals()'' #loc' +array.creation.without.new.keyword.family.quickfix: + text: Add 'new' expression +array.creation.without.new.keyword.name: + text: Array creation without 'new' expression +array.creation.without.new.keyword.quickfix: + text: Add ''new {0}'' +array.hash.code.display.name: + text: '''hashCode()'' called on array' +array.hash.code.problem.descriptor: + text: '#ref() called on array should probably be ''Arrays.hashCode()'' #loc' +array.length.in.loop.condition.display.name: + text: Array.length in loop condition +array.length.in.loop.condition.problem.descriptor: + text: 'Check of array #ref in loop condition #loc' +array.objects.deep.equals.problem.descriptor: + text: 'Objects.#ref() on arrays should probably be ''Arrays.deepEquals()'' #loc' +array.objects.equals.display.name: + text: '''Objects.equals()'' called on arrays' +array.objects.equals.problem.descriptor: + text: 'Objects.#ref() on arrays should probably be ''Arrays.equals()'' #loc' +arrays.as.list.with.one.argument.problem.descriptor: + text: 'Call to #ref() with only one argument #loc' +arrays.as.list.with.one.argument.quickfix: + text: Replace with call to 'Collections.singletonList()' +arrays.as.list.with.zero.arguments.problem.descriptor: + text: 'Call to #ref() to create an empty List #loc' +arrays.as.list.with.zero.arguments.quickfix: + text: Replace with call to 'Collections.emptyList()' +arrays.as.list.with.zero.or.one.argument.display.name: + text: Call to 'Arrays.asList()' with too few arguments +arrays.deep.hash.code.quickfix: + text: Replace with 'Arrays.deepHashCode()' +arrays.hash.code.quickfix: + text: Replace with 'Arrays.hashCode()' +assert.can.be.if.quickfix: + text: Replace 'assert' with 'if' statement +assert.keyword.is.considered.an.assertion: + text: '''assert'' keyword is considered an assertion' +assert.message.not.string.display.name: + text: '''assert'' message is not a string' +assert.message.not.string.only.warn.boolean.option: + text: Only warn when 'assert' message is 'boolean' or 'java.lang.Boolean' +assert.message.of.type.boolean.problem.descriptor: + text: '''''assert'''' message of type ''''{0}'''' #loc' +assert.statement.display.name: + text: '''assert'' statement' +assert.with.side.effects.display.name: + text: '''assert'' statement with side effects' +assert.with.side.effects.problem.descriptor: + text: '#ref has side effects #loc' +assertequals.between.inconvertible.types.display.name: + text: '''assertEquals()'' between objects of inconvertible types' +assertequals.between.inconvertible.types.problem.descriptor: + text: '#ref() between objects of inconvertible types ''''{0}'''' and ''''{1}'''' #loc' +assertequals.called.on.arrays.display.name: + text: '''assertEquals()'' called on array' +assertequals.called.on.arrays.problem.descriptor: + text: '#ref() called on array #loc' +assertequals.may.be.assertsame.display.name: + text: '''assertEquals()'' may be ''assertSame()''' +assertequals.may.be.assertsame.problem.descriptor: + text: '#ref() may be ''assertSame()'' #loc' +assertion.can.be.if.name: + text: Assertion can be replaced with 'if' statement +asserts.without.messages.display.name: + text: Message missing on assertion +asserts.without.messages.problem.descriptor: + text: 'JUnit #ref() without message #loc' +assignment.collection.array.field.from.parameter.display.name: + text: Assignment to Collection or array field from parameter +assignment.collection.array.field.from.parameter.problem.descriptor.array: + text: 'Assignment to array field #ref from parameter ''''{0}'''' #loc' +assignment.collection.array.field.from.parameter.problem.descriptor.collection: + text: 'Assignment to Collection field #ref from parameter ''''{0}'''' #loc' +assignment.collection.array.field.option: + text: Ignore assignments in 'private' methods +assignment.replaceable.with.operator.assignment.display.name: + text: Assignment can be replaced with operator assignment +assignment.replaceable.with.operator.assignment.ignore.conditional.operators.option: + text: Ignore conditional operators +assignment.replaceable.with.operator.assignment.ignore.obscure.operators.option: + text: Ignore the obscure ^ and % operators +assignment.replaceable.with.operator.assignment.problem.descriptor: + text: '#ref can be simplified to ''''{0}'''' #loc' +assignment.replaceable.with.operator.replace.quickfix: + text: Replace ''='' with ''{0}='' +assignment.to.catch.block.parameter.display.name: + text: Assignment to 'catch' block parameter +assignment.to.catch.block.parameter.problem.descriptor: + text: 'Assignment to ''catch'' block parameter #ref #loc' +assignment.to.date.calendar.field.from.parameter.display.name: + text: Assignment to Date or Calendar field from parameter +assignment.to.date.calendar.field.from.parameter.problem.descriptor: + text: 'Assignment to ''''{0}'''' field #ref from parameter {1} #loc' +assignment.to.for.loop.parameter.check.foreach.option: + text: Check enhanced 'for' loop parameters +assignment.to.for.loop.parameter.display.name: + text: Assignment to 'for' loop parameter +assignment.to.for.loop.parameter.problem.descriptor: + text: 'Assignment to for-loop parameter #ref #loc' +assignment.to.lambda.parameter.display.name: + text: Assignment to lambda parameter +assignment.to.lambda.parameter.problem.descriptor: + text: 'Assignment to lambda parameter #ref #loc' +assignment.to.method.parameter.display.name: + text: Assignment to method parameter +assignment.to.method.parameter.ignore.transformation.option: + text: Ignore if assignment is a transformation of the original parameter +assignment.to.method.parameter.problem.descriptor: + text: 'Assignment to method parameter #ref #loc' assignment.to.null.display.name: - text: '''null'' assignment' -assignment.to.null.problem.descriptor: - text: '''null'' assigned to variable #ref #loc' + text: '''null'' assignment' assignment.to.null.option: - text: Ignore assignments to fields + text: Ignore assignments to fields +assignment.to.null.problem.descriptor: + text: '''null'' assigned to variable #ref #loc' assignment.to.static.field.from.instance.method.display.name: - text: Assignment to static field from instance context + text: Assignment to static field from instance context assignment.to.static.field.from.instance.method.problem.descriptor: - text: 'Assignment to static field #ref from instance context #loc' + text: 'Assignment to static field #ref from instance context #loc' +assignment.to.superclass.field.display.name: + text: Constructor assigns value to field defined in superclass +assignment.to.superclass.field.problem.descriptor: + text: 'Assignment to field ''''{0}'''' defined in superclass ''''{1}'''' #loc' assignment.used.as.condition.display.name: - text: Assignment used as condition + text: Assignment used as condition assignment.used.as.condition.problem.descriptor: - text: '#ref used as condition #loc' + text: 'Assignment #ref used as condition #loc' assignment.used.as.condition.replace.quickfix: - text: Replace '=' with '==' -cast.conflicts.with.instanceof.display.name: - text: Cast conflicts with 'instanceof' -cast.conflicts.with.instanceof.problem.descriptor: - text: 'Cast #ref conflicts with surrounding ''instanceof'' check #loc' -casting.to.incompatible.interface.display.name: - text: Casting to incompatible interface -casting.to.incompatible.interface.problem.descriptor: - text: 'Cast to incompatible interface #ref #loc' -collection.added.to.self.display.name: - text: Collection added to self -collection.added.to.self.problem.descriptor: - text: '''''{0}()'''' called on collection #ref with itself as argument #loc' -non.final.field.compareto.display.name: - text: Non-final field referenced in 'compareTo()' -non.final.field.compareto.problem.descriptor: - text: 'Non-final field #ref accessed in ''compareTo()'' #loc' -covariant.equals.display.name: - text: Covariant 'equals()' -covariant.equals.problem.descriptor: - text: '#ref() should take ''Object'' as its argument #loc' -empty.class.initializer.display.name: - text: Empty class initializer -empty.class.initializer.problem.descriptor: - text: 'Empty class initializer #loc' -empty.class.initializer.delete.quickfix: - text: Delete empty class initializer -statement.with.empty.body.display.name: - text: Statement with empty body -statement.with.empty.body.problem.descriptor: - text: '#ref statement has empty body #loc' -statement.with.empty.body.include.option: - text: Include statement bodies that are empty code blocks -equals.between.inconvertible.types.display.name: - text: '''equals()'' between objects of inconvertible types' -equals.between.inconvertible.types.problem.descriptor: - text: '#ref() between objects of inconvertible types ''''{0}'''' and ''''{1}'''' #loc' -equals.called.on.suspicious.object.display.name: - text: '''equals()'' called on suspicious object' -equals.called.on.suspicious.object.problem.descriptor: - text: Suspicious call ''equals'' on ''{0}'' object -non.final.field.in.equals.display.name: - text: Non-final field referenced in 'equals()' -non.final.field.in.equals.problem.descriptor: - text: 'Non-final field #ref accessed in ''equals()'' #loc' -equals.doesnt.check.class.parameter.display.name: - text: '''equals()'' method which does not check class of parameter' -equals.doesnt.check.class.parameter.problem.descriptor: - text: '#ref() should check the class of its parameter #loc' -for.loop.not.use.loop.variable.display.name: - text: '''for'' loop where update or condition does not use loop variable' -for.loop.not.use.loop.variable.problem.descriptor.condition: - text: '#ref statement has condition which does not use the for loop variable #loc' -for.loop.not.use.loop.variable.problem.descriptor.update: - text: '#ref statement has update which does not use the for loop variable #loc' -for.loop.not.use.loop.variable.problem.descriptor.both.condition.and.update: - text: '#ref statement has condition and update which do not use the for loop variable #loc' -non.final.field.in.hashcode.display.name: - text: Non-final field referenced in 'hashCode()' -non.final.field.in.hashcode.problem.descriptor: - text: 'Non-final field #ref accessed in ''hashCode()'' #loc' -result.of.method.call.ignored.display.name: - text: Result of method call ignored -result.of.method.call.ignored.problem.descriptor: - text: 'Result of {0}.#ref() is ignored #loc' -result.of.method.call.ignored.class.column.title: - text: Class name -result.of.method.call.ignored.method.column.title: - text: Method name regex -result.of.method.call.ignored.non.library.option: - text: Report all ignored non-library calls -infinite.recursion.display.name: - text: Infinite recursion -infinite.recursion.problem.descriptor: - text: 'Method #ref() recurses infinitely, and can only end by throwing an exception #loc' -instanceof.with.incompatible.interface.display.name: - text: '''instanceof'' with incompatible interface' -instanceof.with.incompatible.interface.problem.descriptor: - text: '''instanceof'' incompatible interface #ref #loc' -instantiation.utility.class.display.name: - text: Instantiation of utility class -instantiation.utility.class.problem.descriptor: - text: 'Instantiation of utility class #ref #loc' -iterator.hasnext.which.calls.next.display.name: - text: '''Iterator.hasNext()'' which calls ''next()''' -iterator.hasnext.which.calls.next.problem.descriptor: - text: 'Iterator.#ref() contains call to ''next()'' #loc' -iterator.next.does.not.throw.nosuchelementexception.display.name: - text: '''Iterator.next()'' which can''t throw ''NoSuchElementException''' -malformed.format.string.display.name: - text: Malformed format string -malformed.format.string.problem.descriptor.malformed: - text: 'Format string #ref is malformed #loc' -malformed.format.string.problem.descriptor.illegal: - text: 'Illegal format string specifier: {0} #loc' -malformed.format.string.problem.descriptor.too.many.arguments: - text: 'Too many arguments for format string (found: {0}, expected: {1}) #loc' -malformed.format.string.problem.descriptor.too.few.arguments: - text: 'Too few arguments for format string (found: {0}, expected: {1}) #loc' -malformed.format.string.problem.descriptor.arguments.do.not.match.type: - text: 'Argument type ''''{0}'''' does not match the type of the format specifier ''''{1}'''' #loc' -malformed.regular.expression.display.name: - text: Malformed regular expression -malformed.regular.expression.problem.descriptor1: - text: 'Regular expression #ref is malformed #loc' -malformed.regular.expression.problem.descriptor2: - text: 'Regular expression #ref is malformed: {0} #loc' -malformed.xpath.expression.display.name: - text: Malformed XPath expression -malformed.xpath.expression.problem.description: - text: 'XPath expression #ref is malformed #loc' -mismatched.read.write.array.display.name: - text: Mismatched read and write of array -mismatched.read.write.array.problem.descriptor.write.not.read: - text: 'Contents of array #ref are written to, but never read #loc' -mismatched.read.write.array.problem.descriptor.read.not.write: - text: 'Contents of array #ref are read, but never written to #loc' -mismatched.update.collection.display.name: - text: Mismatched query and update of collection -mismatched.update.collection.problem.descriptor.updated.not.queried: - text: 'Contents of collection #ref are updated, but never queried #loc' -mismatched.update.collection.problem.description.queried.not.updated: - text: 'Contents of collection #ref are queried, but never updated #loc' -rename.quickfix: - text: Rename -renameto.quickfix: - text: Rename to ''{0}'' -misspelled.equals.display.name: - text: '''equal()'' instead of ''equals()''' -misspelled.equals.problem.descriptor: - text: '#ref() method should probably be ''equals()'' #loc' -non.short.circuit.boolean.expression.display.name: - text: Non-short-circuit boolean expression -non.short.circuit.boolean.expression.problem.descriptor: - text: 'Non-short-circuit boolean expression #ref #loc' -non.short.circuit.boolean.expression.replace.quickfix: - text: Replace with short circuit expression -null.argument.to.var.arg.method.display.name: - text: Confusing argument to varargs method -null.argument.to.var.arg.method.problem.descriptor: - text: 'Confusing argument #ref, unclear if a varargs or non-varargs call is desired #loc' -primitive.array.argument.to.var.arg.method.display.name: - text: Confusing primitive array argument to varargs method -primitive.array.argument.to.var.arg.method.problem.descriptor: - text: 'Confusing primitive array argument to varargs method #loc' -object.comparison.display.name: - text: Object comparison using '==', instead of 'equals()' -object.comparison.enumerated.ignore.option: - text: Ignore '==' between enumerated types -object.comparison.klass.ignore.option: - text: Ignore '==' on 'java.lang.Class' objects -object.comparison.problem.description: - text: 'Object values are compared using #ref, not ''equals()'' #loc' -object.comparison.replace.quickfix: - text: Replace with 'equals()' -object.equals.null.problem.descriptor: - text: '.equals(#ref) is probably not what was intended #loc' -default.tostring.call.display.name: - text: Call to default 'toString()' -default.tostring.call.problem.descriptor: - text: 'Call to default ''toString()'' on #ref #loc' -octal.and.decimal.integers.in.same.array.display.name: - text: Octal and decimal integers in same array -octal.and.decimal.integers.in.same.array.problem.descriptor: - text: 'Octal and decimal integers in the same array initializer #loc' -result.of.object.allocation.ignored.display.name: - text: Result of object allocation ignored -result.of.object.allocation.ignored.problem.descriptor: - text: 'Result of new #ref() is ignored #loc' -use.0index.in.jdbc.resultset.display.name: - text: Use of index 0 in JDBC ResultSet -use.0index.in.jdbc.resultset.problem.descriptor: - text: 'Use of index ''0'' in JDBC ResultSet #loc' -use.0index.in.jdbc.prepared.statement.problem.descriptor: - text: 'Use of index ''0'' in JDBC PreparedStatement #loc' -return.of.null.display.name: - text: Return of 'null' -return.of.null.problem.descriptor: - text: 'Return of #ref #loc' -return.of.null.arrays.option: - text: Report methods that return arrays -return.of.null.quickfix: - text: Annotate method as @Nullable -return.of.null.objects.option: - text: Report methods that return objects -return.of.null.collections.option: - text: Report methods that return collection objects -return.of.null.ignore.private.option: - text: Ignore 'private' methods -return.of.null.optional.quickfix: - text: Replace with ''{0}.{1}()'' -return.of.null.optional.quickfix.family: - text: Replace with 'Optional.empty()' -static.method.via.subclass.display.name: - text: Static method referenced via subclass -static.method.via.subclass.problem.descriptor: - text: 'Static method #ref() declared in class ''''{0}'''' but referenced via subclass ''''{1}'''' #loc' -static.method.via.subclass.rationalize.quickfix: - text: Rationalize static method call -static.field.via.subclass.display.name: - text: Static field referenced via subclass -static.field.via.subclass.problem.descriptor: - text: 'Static field #ref declared in class ''''{0}'''' but referenced via subclass ''''{1}'''' #loc' -static.field.via.subclass.rationalize.quickfix: - text: Rationalize static field access -string.comparison.display.name: - text: String comparison using '==', instead of 'equals()' -number.comparison.display.name: - text: Number comparison using '==', instead of 'equals()' -string.comparison.problem.descriptor: - text: 'String values are compared using #ref, not ''equals()'' #loc' -number.comparison.problem.descriptor: - text: 'Number objects are compared using #ref, not ''equals()'' #loc' -subtraction.in.compareto.display.name: - text: Subtraction in 'compareTo()' -subtraction.in.compareto.problem.descriptor: - text: 'Subtraction #ref in ''compareTo()'' may result in overflow errors #loc' -text.label.in.switch.statement.display.name: - text: Text label in 'switch' statement -text.label.in.switch.statement.problem.descriptor: - text: 'Text label #ref: in ''switch'' statement #loc' -properties.object.as.hashtable.display.name: - text: Use of Properties object as a Hashtable -properties.object.as.hashtable.problem.descriptor: - text: 'Call to Hashtable.#ref() on properties object #loc' -assignment.replaceable.with.operator.assignment.display.name: - text: Assignment replaceable with operator assignment -unnecessary.code.block.display.name: - text: Unnecessary code block -unnecessary.code.block.unwrap.quickfix: - text: Unwrap block -redundant.local.variable.display.name: - text: Redundant local variable -redundant.local.variable.ignore.option: - text: Ignore immediately returned or thrown variables -redundant.local.variable.annotation.option: - text: Ignore variables which have an annotation -static.collection.display.name: - text: Static collection -static.collection.problem.descriptor: - text: 'Static collection #ref #loc' -static.collection.ignore.option: - text: Ignore weak static collections or maps -stringbuffer.field.display.name: - text: StringBuffer field -stringbuffer.field.problem.descriptor: - text: '''''{0}'''' field #ref #loc' -gc.call.display.name: - text: Calls to 'System.gc()' or 'Runtime.gc()' -gc.call.problem.descriptor: - text: '#ref should not be called in production code #loc' -array.allocation.zero.length.display.name: - text: Zero-length array allocation -array.allocation.zero.length.problem.descriptor: - text: 'Allocation of zero length array #loc' -constant.for.zero.length.array.display.name: - text: Unnecessary zero length array usage -constant.for.zero.length.array.problem.descriptor: - text: 'Zero length array can be changed to constant #loc' -constant.for.zero.length.array.quickfix.family: - text: Replace with constant -replace.with: - text: Replace with ''{0}'' -multiple.loggers.display.name: - text: Class with multiple loggers -logger.name.option: - text: 'Logger &class name:' -multiple.loggers.problem.descriptor: - text: 'Class #ref declares multiple loggers #loc' -no.logger.display.name: - text: Class without logger -no.logger.problem.descriptor: - text: 'Class #ref does not declare a logger #loc' -non.constant.logger.display.name: - text: Non-constant logger -non.constant.logger.problem.descriptor: - text: 'Non-constant logger field #ref #loc' -public.method.without.logging.display.name: - text: '''public'' method without logging' -public.method.without.logging.problem.descriptor: - text: '''public'' method #ref() has no logging call #loc' -ignore.trivial.finalizers.option: - text: Ignore for trivial 'finalize()' implementations -finalize.declaration.display.name: - text: '''finalize()'' declaration' -finalize.declaration.problem.descriptor: - text: '#ref() declared #loc' -finalize.not.declared.protected.display.name: - text: '''finalize()'' not declared ''protected''' -finalize.not.declared.protected.problem.descriptor: - text: '#ref() not declared ''protected'' #loc' -make.protected.quickfix: - text: Make 'protected' -finalize.called.explicitly.display.name: - text: '''finalize()'' called explicitly' -finalize.called.explicitly.problem.descriptor: - text: '#ref() called explicitly #loc' -java.lang.import.display.name: - text: '''java.lang'' import' -java.lang.import.problem.descriptor: - text: 'Unnecessary import from package ''java.lang'' #loc' -import.display.name: - text: '''*'' import' -import.problem.descriptor: - text: 'Package import #ref #loc' -redundant.import.display.name: - text: Redundant import -redundant.import.problem.descriptor: - text: 'Redundant import #ref #loc' -import.from.same.package.display.name: - text: Import from same package -import.from.same.package.problem.descriptor: - text: 'Unnecessary import from same package #ref #loc' -single.class.import.display.name: - text: Single class import -single.class.import.problem.descriptor: - text: 'Single class import #ref #loc' -static.import.display.name: - text: Static import -static.import.problem.descriptor: - text: 'Static import #ref #loc' -static.import.replace.quickfix: - text: Replace with non-static import -unused.import.display.name: - text: Unused import -unused.import.problem.descriptor: - text: 'Unused import #ref #loc' -clone.instantiates.objects.with.constructor.display.name: - text: '''clone()'' instantiates objects with constructor' -clone.instantiates.objects.with.constructor.problem.descriptor: - text: '''clone()'' creates new #ref instances #loc' -clone.doesnt.declare.clonenotsupportedexception.display.name: - text: '''clone()'' does not declare ''CloneNotSupportedException''' -clone.doesnt.declare.clonenotsupportedexception.problem.descriptor: - text: '#ref() #loc does not declare ''CloneNotSupportedException''' -clone.doesnt.declare.clonenotsupportedexception.declare.quickfix: - text: Declare 'CloneNotSupportedException' -clone.method.in.non.cloneable.class.display.name: - text: '''clone()'' method in non-Cloneable class' -clone.method.in.non.cloneable.class.problem.descriptor: - text: '#ref() defined in non-Cloneable class ''''{0}'''' #loc' -clone.method.in.non.cloneable.interface.problem.descriptor: - text: '#ref() defined in non-Cloneable interface ''''{0}'''' #loc' -cloneable.class.without.clone.display.name: - text: Cloneable class without 'clone()' -cloneable.class.without.clone.problem.descriptor: - text: '#ref does not define ''clone()'' #loc' -cloneable.class.without.clone.ignore.option: - text: Ignore classes cloneable due to inheritance -cloneable.class.without.clone.quickfix: - text: Generate 'clone()' method -class.without.tostring.display.name: - text: Class without 'toString()' -class.without.tostring.problem.descriptor: - text: 'Class #ref should probably implement ''toString()'', for debugging purposes #loc' -use.obsolete.collection.type.display.name: - text: Use of obsolete collection type -use.obsolete.collection.type.problem.descriptor: - text: 'Obsolete collection type #ref used #loc' -use.obsolete.collection.type.ignore.library.arguments.option: - text: Ignore obsolete collection types where they are required -inspection.suppression.annotation.display.name: - text: Inspection suppression annotation -inspection.suppression.annotation.problem.descriptor: - text: 'Inspection suppression annotation #ref #loc' -use.system.out.err.display.name: - text: Use of System.out or System.err -use.system.out.err.problem.descriptor: - text: 'Uses of #ref should probably be replaced with more robust logging #loc' -dumpstack.call.display.name: - text: Call to 'Thread.dumpStack()' -dumpstack.call.problem.descriptor: - text: 'Call to Thread.#ref() should probably be replaced with more robust logging #loc' -printstacktrace.call.display.name: - text: Call to 'printStackTrace()' -printstacktrace.call.problem.descriptor: - text: 'Call to #ref() should probably be replaced with more robust logging #loc' -abstract.method.call.in.constructor.display.name: - text: Abstract method called during object construction -abstract.method.call.in.constructor.problem.descriptor: - text: 'Call to ''abstract'' method #ref() during object construction #loc' -instance.variable.may.not.be.initialized.display.name: - text: Instance field may not be initialized -instance.variable.may.not.be.initialized.problem.descriptor: - text: 'Instance field #ref may not be initialized during object construction #loc' -instance.Variable.may.not.be.initialized.problem.descriptor.junit: - text: 'Instance field #ref may not be initialized during object construction or ''setUp()'' call #loc' -primitive.fields.ignore.option: - text: Ignore primitive fields -instance.variable.used.before.initialized.display.name: - text: Instance field used before initialization -instance.variable.used.before.initialized.problem.descriptor: - text: 'Instance field #ref used before initialized #loc' -non.final.static.variable.initialization.display.name: - text: Non-final static field is used during class initialization -non.final.static.variable.initialization.problem.descriptor: - text: 'Non-final static field #ref used during class initialization #loc' -overridable.method.call.in.constructor.display.name: - text: Overridable method called during object construction -overridable.method.call.in.constructor.problem.descriptor: - text: 'Call to overridable method #ref() during object construction #loc' -overridden.method.call.in.constructor.display.name: - text: Overridden method called during object construction -overridden.method.call.in.constructor.problem.descriptor: - text: 'Call to overridden method #ref() during object construction #loc' -static.variable.may.not.be.initialized.display.name: - text: Static field may not be initialized -static.variable.may.not.be.initialized.problem.descriptor: - text: 'Static field #ref may not be initialized during class initialization #loc' -static.variable.used.before.initialization.display.name: - text: Static field used before initialization -static.variable.used.before.initialization.problem.descriptor: - text: 'Static field #ref used before initialization #loc' -this.reference.escaped.in.construction.display.name: - text: '''this'' reference escaped in object construction' -this.reference.escaped.in.construction.problem.descriptor: - text: 'Escape of #ref during object construction #loc' -assignment.to.catch.block.parameter.display.name: - text: Assignment to catch block parameter -extract.parameter.as.local.variable.quickfix: - text: Extract parameter as local variable -assignment.to.for.loop.parameter.display.name: - text: Assignment to 'for' loop parameter -assignment.to.for.loop.parameter.check.foreach.option: - text: Check foreach parameters -assignment.to.for.loop.parameter.problem.descriptor: - text: 'Assignment to for-loop parameter #ref #loc' -assignment.to.method.parameter.display.name: - text: Assignment to method parameter -chained.equality.comparisons.display.name: - text: Chained equality comparisons -confusing.octal.escape.sequence.display.name: - text: Confusing octal escape sequence -increment.decrement.display.name: - text: Value of ++ or -- used -nested.assignment.display.name: - text: Result of assignment used -nested.assignment.problem.descriptor: - text: 'Result of assignment expression used #loc' -overloaded.methods.with.same.number.parameters.display.name: - text: Overloaded methods with same number of parameters -overloaded.vararg.method.display.name: - text: Overloaded varargs method -refused.bequest.display.name: - text: Method does not call super method -reuse.of.local.variable.display.name: - text: Reuse of local variable -reuse.of.local.variable.split.quickfix: - text: Split local variable -character.comparison.display.name: - text: Character comparison -character.comparison.problem.descriptor: - text: 'Character comparison #ref in an internationalized context #loc' -assignment.collection.array.field.from.parameter.display.name: - text: Assignment to Collection or array field from parameter -assignment.collection.array.field.from.parameter.problem.descriptor.array: - text: 'Assignment to array field #ref from parameter ''''{0}'''' #loc' -assignment.collection.array.field.from.parameter.problem.descriptor.collection: - text: 'Assignment to Collection field #ref from parameter ''''{0}'''' #loc' -assignment.collection.array.field.option: - text: Ignore assignments in 'private' methods -assignment.to.date.calendar.field.from.parameter.display.name: - text: Assignment to Date or Calendar field from parameter -assignment.to.date.calendar.field.from.parameter.problem.descriptor: - text: 'Assignment to ''''{0}'''' field #ref from parameter {1} #loc' -package.visible.field.display.name: - text: Package-visible field -package.visible.field.problem.descriptor: - text: 'Package-visible field #ref #loc' -package.visible.inner.class.display.name: - text: Package-visible inner class -package.visible.inner.class.problem.descriptor: - text: 'Package-visible inner class #ref #loc' -package.visible.inner.class.ignore.enum.option: - text: Ignore package-visible inner enums -package.visible.inner.class.ignore.interface.option: - text: Ignore package-visible inner interfaces -protected.field.display.name: - text: Protected field -protected.field.problem.descriptor: - text: 'Protected field #ref #loc' -protected.inner.class.display.name: - text: Protected inner class -protected.inner.class.problem.descriptor: - text: 'Protected inner class #ref #loc' -protected.inner.class.ignore.enum.option: - text: Ignore 'protected' inner enums -protected.inner.class.ignore.interface.option: - text: Ignore 'protected' inner interfaces -public.field.display.name: - text: '''public'' field' -public.field.problem.descriptor: - text: '''public'' field #ref #loc' -public.field.ignore.enum.type.fields.option: - text: Ignore 'public final' fields of an enum type -public.inner.class.display.name: - text: '''public'' inner class' -public.inner.class.problem.descriptor: - text: '''public'' inner class #ref #loc' -public.inner.class.ignore.enum.option: - text: Ignore 'public' inner enums -public.inner.class.ignore.interface.option: - text: Ignore 'public' inner interfaces -return.of.collection.array.field.display.name: - text: Return of Collection or array field -return.of.collection.array.field.problem.descriptor.array: - text: '''return'' of array field #ref #loc' -return.of.collection.array.field.problem.descriptor.collection: - text: '''return'' of Collection field #ref #loc' -return.of.collection.array.field.option: - text: Ignore 'private' methods returning an array or collection field -return.date.calendar.field.display.name: - text: Return of Date or Calendar field -return.date.calendar.field.problem.descriptor: - text: 'Return of ''''{0}'''' field #ref #loc' -return.date.calendar.field.quickfix: - text: Return clone of ''{0}'' -accessing.non.public.field.of.another.object.display.name: - text: Accessing a non-public field of another object -accessing.non.public.field.of.another.object.problem.descriptor: - text: 'Direct access of non-public field #ref on another object #loc' + text: Replace '=' with '==' +atomic.field.updater.issues.display.name: + text: Inconsistent 'AtomicFieldUpdater' declaration +atomic.field.updater.not.static.final.display.name: + text: "'AtomicFieldUpdater' field not declared 'static final'" +atomic.field.updater.not.static.final.problem.descriptor: + text: '{0} field #ref is not declared ''''static final'''' #loc' +auto.boxing.display.name: + text: Auto-boxing +auto.boxing.ignore.added.to.collection.option: + text: Ignore expressions added to a collection +auto.boxing.make.boxing.explicit.quickfix: + text: Make boxing explicit +auto.boxing.problem.descriptor: + text: 'Auto-boxing #ref #loc' +auto.closeable.resource.display.name: + text: AutoCloseable used without 'try'-with-resources +auto.closeable.resource.problem.descriptor: + text: '''''{0}'''' used without ''''try''''-with-resources statement #loc' +auto.closeable.resource.quickfix: + text: Ignore 'AutoCloseable' returned by this method +auto.closeable.resource.returned.option: + text: Ignore AutoCloseable instances returned from all method calls +auto.unboxing.display.name: + text: Auto-unboxing +auto.unboxing.make.unboxing.explicit.quickfix: + text: Make unboxing explicit +auto.unboxing.problem.descriptor: + text: 'Auto-unboxing #ref #loc' +await.not.in.loop.display.name: + text: "'await()' not called in loop" +await.not.in.loop.problem.descriptor: + text: 'Call to #ref() is not in loop #loc' +await.without.corresponding.signal.display.name: + text: '''await()'' without corresponding ''signal()''' +await.without.corresponding.signal.problem.descriptor: + text: 'Call to #ref() without corresponding signal() or signalAll() #loc' +bad.exception.caught.display.name: + text: Prohibited 'Exception' caught +bad.exception.caught.problem.descriptor: + text: 'Prohibited exception #ref caught #loc' +bad.exception.declared.display.name: + text: Prohibited exception declared +bad.exception.declared.problem.descriptor: + text: 'Prohibited exception #ref declared #loc' +bad.exception.thrown.display.name: + text: Prohibited exception thrown +bad.exception.thrown.problem.descriptor: + text: 'Prohibited exception ''''{0}'''' thrown #loc' +bad.oddness.display.name: + text: Suspicious oddness check +bad.oddness.problem.descriptor: + text: 'Test for oddness #ref will fail on negative values #loc' +before.class.or.after.class.is.public.static.void.no.arg.display.name: + text: Malformed @BeforeClass/@BeforeAll or @AfterClass/@AfterAll method +before.class.or.after.class.is.public.static.void.no.arg.problem.descriptor: + text: '#ref() has incorrect signature for a @{0} method #loc' +before.or.after.is.public.void.no.arg.display.name: + text: Malformed @Before or @After method +before.or.after.is.public.void.no.arg.problem.descriptor: + text: '#ref() has incorrect signature for a @Before or @After method #loc' +big.decimal.equals.display.name: + text: '''equals()'' called on ''BigDecimal''' +big.decimal.equals.problem.descriptor: + text: '#ref() between BigDecimal values should probably be ''compareTo()'' #loc' +big.decimal.equals.replace.quickfix: + text: Replace with 'compareTo()==0' +big.decimal.method.without.rounding.called.display.name: + text: Call to 'BigDecimal' method without a rounding mode argument +big.decimal.method.without.rounding.called.problem.descriptor: + text: '''BigDecimal.#ref()'' called without a rounding mode argument' +bigdecimal.legacy.method.display.name: + text: '''BigDecimal'' legacy method called' +bigdecimal.legacy.method.problem.descriptor: + text: Call to 'BigDecimal.#ref()' can use 'RoundingMode' enum constant +bigdecimal.legacy.method.quickfix: + text: Use 'RoundingMode' enum constant +boolean.constructor.display.name: + text: Boolean constructor call +boolean.constructor.problem.descriptor: + text: 'Boolean constructor call #loc' +boolean.constructor.simplify.quickfix: + text: Simplify +boolean.expression.can.be.simplified.problem.descriptor: + text: '#ref can be simplified to ''''{0}'''' #loc' +boolean.expression.may.be.conditional.display.name: + text: Boolean expression can be replaced with conditional expression +boolean.field.always.inverted.problem.descriptor: + text: 'Boolean field #ref is always inverted #loc' +boolean.method.name.must.start.with.question.display.name: + text: Boolean method name must start with question word +boolean.method.name.must.start.with.question.problem.descriptor: + text: 'Boolean method name #ref does not start with question word #loc' +boolean.method.name.must.start.with.question.table.column.name: + text: Boolean method name prefix +boolean.parameter.constructor.problem.descriptor: + text: '''public'' constructor #ref() with ''boolean'' parameter #loc' +boolean.parameter.display.name: + text: '''public'' method with ''boolean'' parameter' +boolean.parameter.only.report.multiple.option: + text: Only report methods with multiple boolean parameters +boolean.parameter.problem.descriptor: + text: '''public'' method #ref() with ''boolean'' parameter #loc' +boolean.parameters.constructor.problem.descriptor: + text: '''public'' constructor #ref() with ''boolean'' parameters #loc' +boolean.parameters.problem.descriptor: + text: '''public'' method #ref() with ''boolean'' parameters #loc' +boolean.variable.always.inverted.display.name: + text: Boolean variable is always inverted +boolean.variable.always.inverted.problem.descriptor: + text: 'Boolean variable #ref is always inverted #loc' +boxing.boxed.value.display.name: + text: Boxing of already boxed value +boxing.boxed.value.problem.descriptor: + text: 'Boxing of already boxed #ref #loc' +boxing.boxed.value.quickfix: + text: Remove unnecessary boxing +break.statement.display.name: + text: '''break'' statement' +break.statement.with.label.display.name: + text: '''break'' statement with label' +break.statement.with.label.problem.descriptor: + text: '#ref statement with label #loc' +busy.wait.display.name: + text: Busy wait +busy.wait.problem.descriptor: + text: 'Call to Thread.#ref() in a loop, probably busy-waiting #loc' +c.style.array.declaration.display.name: + text: C-style array declaration +c.style.array.declaration.replace.quickfix: + text: Replace with Java-style array declaration +cached.number.constructor.call.display.name: + text: Number constructor call with primitive argument +cached.number.constructor.call.ignore.string.arguments.option: + text: Ignore new number expressions with a String argument +cached.number.constructor.call.problem.descriptor: + text: 'Number constructor call with primitive argument #loc' +cached.number.constructor.call.quickfix: + text: Replace with ''{0}.valueOf()'' call call.to.date.tostring.display.name: - text: Call to 'Date.toString()' + text: Call to 'Date.toString()' call.to.date.tostring.problem.descriptor: - text: 'Date.#ref() used in an internationalized context #loc' -magic.character.display.name: - text: Magic character -magic.character.problem.descriptor: - text: 'Magic character #ref in an internationalized context #loc' + text: 'Date.#ref() used in an internationalized context #loc' +call.to.native.method.while.locked.display.name: + text: Call to a 'native' method while locked +call.to.native.method.while.locked.problem.descriptor: + text: 'Call to native method #ref() in a synchronized context #loc' call.to.numeric.tostring.display.name: - text: Call to Numeric 'toString()' + text: Call to 'Number.toString()' call.to.numeric.tostring.problem.descriptor: - text: 'Numeric #ref() called in an internationalized context #loc' -instantiating.simpledateformat.without.locale.display.name: - text: Instantiating a SimpleDateFormat without a Locale -instantiating.simpledateformat.without.locale.problem.descriptor: - text: 'Instantiating a #ref without specifying a Locale in an internationalized context #loc' -string.concatenation.display.name: - text: String concatenation -string.concatenation.problem.descriptor: - text: 'String concatenation #ref in an internationalized context #loc' -inspection.option.ignore.system.out: - text: Ignore for 'System.out.print' arguments -inspection.option.ignore.system.err: - text: Ignore for 'System.err.print' arguments -inspection.option.ignore.assert: - text: Ignore for assert statement description arguments -inspection.option.ignore.exceptions: - text: Ignore for constructor arguments of Throwable subclasses -inspection.option.ignore.nonnls: - text: Ignore when annotated via @NonNls -inspection.option.ignore.constant.initializers: - text: Ignore for initializers of constant fields -inspection.option.ignore.in.annotations: - text: Ignore in annotations -inspection.option.ignore.in.tostring: - text: Ignore inside toString() methods -inspection.option.ignore.as.initial.capacity: - text: Ignore initial capacity for StringBuilders and Collections -inspection.option.ignore.in.hashcode: - text: Ignore constants in 'hashCode()' methods -string.touppercase.tolowercase.without.locale.display.name: - text: Call to 'String.toUpperCase()' or 'toLowerCase()' without a Locale -string.touppercase.tolowercase.without.locale.problem.descriptor: - text: 'String.#ref() called without specifying a Locale using internationalized strings #loc' -use.stringtokenizer.display.name: - text: Use of StringTokenizer -use.stringtokenizer.problem.descriptor: - text: '#ref in an internationalized context #loc' -time.tostring.call.display.name: - text: Call to 'Time.toString()' -time.tostring.call.problem.descriptor: - text: 'Time.#ref() in an internationalized context #loc' -class.escapes.defined.scope.display.name: - text: Non-accessible class is exposed + text: 'Number.#ref() called in an internationalized context #loc' +call.to.private.setter.in.class.option: + text: Only report when setter is 'private' +call.to.private.simple.getter.in.class.option: + text: Only report when getter is 'private' +call.to.simple.getter.in.class.display.name: + text: Call to simple getter from within class +call.to.simple.getter.in.class.ignore.option: + text: Ignore getter calls on other objects +call.to.simple.getter.in.class.inline.quickfix: + text: Inline call to getter +call.to.simple.getter.in.class.problem.descriptor: + text: 'Call to simple getter #ref() from within class #loc' +call.to.simple.setter.in.class.display.name: + text: Call to simple setter from within class +call.to.simple.setter.in.class.ignore.option: + text: Ignore setter calls on other objects +call.to.simple.setter.in.class.inline.quickfix: + text: Inline call to setter +call.to.simple.setter.in.class.problem.descriptor: + text: 'Call to simple setter #ref() from within class #loc' +call.to.string.concat.can.be.replaced.by.operator.display.name: + text: Call to 'String.concat()' can be replaced with '+' +call.to.string.concat.can.be.replaced.by.operator.problem.descriptor: + text: 'Call to #ref() can be replaced with ''+'' expression #loc' +call.to.string.concat.can.be.replaced.by.operator.quickfix: + text: Replace 'concat()' call with '+' +call.to.suspicious.string.method.display.name: + text: Call to suspicious 'String' method +call.to.suspicious.string.method.problem.descriptor: + text: 'String.#ref() called in internationalized context #loc' +cast.conflicts.with.instanceof.display.name: + text: Cast conflicts with 'instanceof' +cast.conflicts.with.instanceof.problem.descriptor: + text: 'Cast #ref conflicts with surrounding ''instanceof'' check #loc' +cast.conflicts.with.instanceof.quickfix1: + text: Replace ''{0}'' with ''{1}'' in cast +cast.conflicts.with.instanceof.quickfix2: + text: Replace ''{0}'' with ''{1}'' in instanceof +cast.that.loses.precision.display.name: + text: Numeric cast that loses precision +cast.that.loses.precision.negative.problem.descriptor: + text: 'Cast from ''''{0}'''' to #ref may result in loss of precision for negative argument #loc' +cast.that.loses.precision.option: + text: Ignore casts from int to char +cast.that.loses.precision.problem.descriptor: + text: 'Cast from ''''{0}'''' to #ref may result in loss of precision #loc' +cast.to.concrete.class.display.name: + text: Cast to a concrete class +cast.to.concrete.class.ignore.equals.option: + text: Ignore in equals() +cast.to.concrete.class.option: + text: Ignore casts to an abstract class type +cast.to.concrete.class.problem.descriptor: + text: 'Cast to concrete class {0} #loc' +casting.to.incompatible.interface.display.name: + text: Cast to incompatible type +casting.to.incompatible.interface.problem.descriptor: + text: 'Cast to incompatible interface #ref #loc' +caught.exception.immediately.rethrown.display.name: + text: Caught exception is immediately rethrown +caught.exception.immediately.rethrown.problem.descriptor: + text: 'Caught exception #ref is immediately rethrown #loc' +chain.of.class.equality.checks.problem.descriptor: + text: 'Chain of class equality checks indicates abstraction failure #loc' +chain.of.instanceof.checks.display.name: + text: Chain of 'instanceof' checks +chain.of.instanceof.checks.problem.descriptor: + text: 'Chain of ''instanceof'' checks indicates abstraction failure #loc' +chained.equality.comparisons.display.name: + text: Chained equality comparisons +chained.equality.comparisons.problem.descriptor: + text: 'Chained equality comparison #ref #loc' +chained.method.call.display.name: + text: Chained method calls +chained.method.call.ignore.option: + text: Ignore chained method calls in field initializers +chained.method.call.ignore.this.super.option: + text: Ignore chained method calls in 'this()' and 'super()' calls +chained.method.call.problem.descriptor: + text: 'Chained method call #ref() #loc' +change.modifier.quickfix: + text: Make ''{0}'' +channel.opened.not.closed.display.name: + text: "'Channel' opened but not safely closed" +char.used.in.arithmetic.context.cast.quickfix: + text: Insert cast to {0} +char.used.in.arithmetic.context.display.name: + text: "'char' expression used in arithmetic context" +char.used.in.arithmetic.context.problem.descriptor: + text: '''char'' #ref used in arithmetic context #loc' +char.used.in.arithmetic.context.quickfix: + text: Convert to String literal +character.comparison.display.name: + text: Character comparison +character.comparison.problem.descriptor: + text: 'Character comparison #ref in an internationalized context #loc' +checked.exception.class.display.name: + text: Checked exception class +checked.exception.class.problem.descriptor: + text: 'Checked exception class #ref #loc' +choose.autocloseable.type.to.ignore.title: + text: Choose AutoCloseable Resource Type to Ignore +choose.class: + text: Choose Class +choose.class.type.to.ignore: + text: Choose Class to Ignore +choose.exception.class: + text: Choose Exception Class +choose.io.resource.type.to.ignore: + text: Choose I/O Resource Type to Ignore +choose.logger.class: + text: Choose Logger Class +choose.super.class.to.ignore: + text: Choose class class.escapes.defined.scope.display.module.option: - text: Module's API exposes not exported classes (Java 9+) -class.escapes.defined.scope.display.public.option: - text: Public API exposes non-accessible classes + text: Report non-exported classes exposed in module API (Java 9+) +class.escapes.defined.scope.display.name: + text: Class is exposed outside of its visibility scope class.escapes.defined.scope.display.package.option: - text: Package-local API exposes private classes -class.escapes.defined.scope.problem.descriptor: - text: 'Class #ref is exposed outside its defined scope #loc' + text: Report private classes exposed in package-local API +class.escapes.defined.scope.display.public.option: + text: Report non-accessible classes exposed in public API class.escapes.defined.scope.java9.modules.descriptor: - text: Class #ref is not exported from module ''{0}'' -field.name.hides.in.superclass.display.name: - text: Field name hides field in superclass -field.name.hides.in.superclass.problem.descriptor: - text: 'Field #ref hides field in superclass #loc' -field.name.hides.in.superclass.ignore.option: - text: Ignore superclass fields not visible from subclass -inner.class.field.hides.outer.display.name: - text: Inner class field hides outer class field -inner.class.field.hides.outer.ignore.option: - text: Ignore outer fields not visible from inner class -inner.class.field.hides.outer.problem.descriptor: - text: 'Inner class field #ref hides outer class field #loc' -local.variable.hides.member.variable.display.name: - text: Local variable hides field -local.variable.hides.member.variable.problem.descriptor: - text: 'Local variable #ref hides field in class ''''{0}'''' #loc' -local.variable.hides.member.variable.ignore.option: - text: Ignore local variables in a static context -method.overloads.display.name: - text: Method overloads method of superclass -method.overloads.problem.descriptor: - text: 'Method #ref() overloads a compatible method of a superclass, when overriding might have been intended #loc' -method.overloads.report.incompatible.option: - text: Report even if parameter types are not compatible -method.overrides.private.display.name.problem.descriptor: - text: 'Method #ref() overrides a ''private'' method of a superclass #loc' -method.overrides.static.display.name: - text: Method overrides static method of superclass -method.overrides.static.problem.descriptor: - text: 'Method #ref() overrides a static method of a superclass #loc' -parameter.hides.member.variable.display.name: - text: Parameter hides field -parameter.hides.member.variable.problem.descriptor: - text: 'Parameter #ref hides field in class ''''{0}'''' #loc' -parameter.hides.member.variable.ignore.setters.option: - text: Ignore for property setters -parameter.hides.member.variable.ignore.superclass.option: - text: Ignore superclass fields not visible from subclass -parameter.hides.member.variable.ignore.constructors.option: - text: Ignore for constructors -parameter.hides.member.variable.ignore.abstract.methods.option: - text: Ignore for abstract methods -parameter.hides.member.variable.ignore.static.parameters.option: - text: Ignore for static method parameters hiding instance fields -type.parameter.hides.visible.type.display.name: - text: Type parameter hides visible type -type.parameter.hides.visible.type.problem.descriptor: - text: 'Type parameter #ref hides visible type ''''{0}'''' #loc' -type.parameter.hides.type.parameter.problem.descriptor: - text: 'Type parameter #ref hides type parameter ''''{0}'''' #loc' -anonymous.class.variable.hides.containing.method.variable.display.name: - text: Anonymous class variable hides variable in containing method -anonymous.class.parameter.hides.containing.method.variable.problem.descriptor: - text: 'Anonymous class parameter #ref hides variable in containing method #loc' -anonymous.class.field.hides.containing.method.variable.problem.descriptor: - text: 'Anonymous class field #ref hides variable in containing method #loc' -anonymous.class.variable.hides.containing.method.variable.problem.descriptor: - text: 'Anonymous class local variable #ref hides variable in containing method #loc' -channel.opened.not.closed.display.name: - text: Channel opened but not safely closed -drivermanager.call.display.name: - text: Use of DriverManager to get JDBC connection -drivermanager.call.problem.descriptor: - text: 'Call to DriverManager.#ref() #loc' -hibernate.resource.opened.not.closed.display.name: - text: Hibernate resource opened but not safely closed -i.o.resource.opened.not.closed.display.name: - text: I/O resource opened but not safely closed -resource.opened.not.closed.problem.descriptor: - text: '''''{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: - text: JDBC resource opened but not safely closed -jndi.resource.opened.not.closed.display.name: - text: JNDI resource opened but not safely closed -socket.opened.not.closed.display.name: - text: Socket opened but not safely closed -annotation.class.display.name: - text: Annotation class -annotation.class.problem.descriptor: - text: 'Annotation class #ref #loc' -annotation.display.name: - text: Annotation -annotation.problem.descriptor: - text: 'Annotation #ref #loc' -use.assert.as.identifier.display.name: - text: Use of 'assert' as identifier -use.assert.as.identifier.problem.descriptor: - text: 'Use of #ref as identifier #loc' -assert.statement.display.name: - text: '''assert'' statement' -statement.problem.descriptor: - text: '#ref statement #loc' -auto.boxing.display.name: - text: Auto-boxing -auto.boxing.problem.descriptor: - text: 'Auto-boxing #ref #loc' -auto.boxing.make.boxing.explicit.quickfix: - text: Make boxing explicit -auto.boxing.ignore.added.to.collection.option: - text: Ignore expressions added to a collection -auto.unboxing.display.name: - text: Auto-unboxing -auto.unboxing.problem.descriptor: - text: 'Auto-unboxing #ref #loc' -auto.unboxing.make.unboxing.explicit.quickfix: - text: Make unboxing explicit -use.enum.as.identifier.display.name: - text: Use of 'enum' as identifier -use.enum.as.identifier.problem.descriptor: - text: 'Use of #ref as identifier #loc' -enumerated.class.display.name: - text: Enumerated class -enumerated.class.problem.descriptor: - text: 'Enumerated class #ref #loc' -extended.for.statement.display.name: - text: Extended 'for' statement -extended.for.statement.replace.quickfix: - text: Replace with old-style 'for' statement -variable.argument.method.display.name: - text: Varargs method -variable.argument.method.problem.descriptor: - text: 'Varargs method #ref() #loc' -variable.argument.method.quickfix: - text: Convert varargs parameter to array -hardcoded.file.separator.display.name: - text: Hardcoded file separator -hardcoded.file.separator.problem.descriptor: - text: 'Hardcoded file separator #ref #loc' -hardcoded.file.separator.include.option: - text: Include "example/*" in recognized MIME media types -hardcoded.line.separator.display.name: - text: Hardcoded line separator -hardcoded.line.separator.problem.descriptor: - text: 'Hardcoded line separator #ref #loc' -native.method.display.name: - text: Native method -native.method.problem.descriptor: - text: 'Methods declared #ref are non-portable #loc' -runtime.exec.call.display.name: - text: Call to 'Runtime.exec()' -runtime.exec.call.problem.descriptor: - text: 'Call to Runtime.#ref() is non-portable #loc' -system.exit.call.display.name: - text: Call to 'System.exit()' or related methods -system.exit.call.problem.descriptor: - text: 'Call to {0}.#ref() is non-portable #loc' -system.exit.call.ignore.option: - text: Ignore in main method -system.getenv.call.display.name: - text: Call to 'System.getenv()' -system.getenv.call.problem.descriptor: - text: 'Call to System.#ref() is non-portable #loc' -use.of.awt.peer.class.display.name: - text: Use of AWT peer class -use.of.awt.peer.class.problem.descriptor: - text: 'Use of AWT peer class #ref is non-portable #loc' -use.of.concrete.jdbc.driver.class.display.name: - text: Use of concrete JDBC driver class -use.of.concrete.jdbc.driver.class.problem.descriptor: - text: 'Use of concrete JDBC driver class #ref is non-portable #loc' -use.processbuilder.class.display.name: - text: Use of 'java.lang.ProcessBuilder' class -use.processbuilder.class.problem.descriptor: - text: 'Use of #ref is non-portable #loc' -use.sun.classes.display.name: - text: Use of sun.* classes -use.sun.classes.problem.descriptor: - text: 'Use of Sun-supplied class #ref is non-portable #loc' -abstract.class.with.only.one.direct.inheritor.display.name: - text: Abstract class which has only one direct inheritor -anonymous.inner.may.be.named.static.inner.class.display.name: - text: Anonymous class may be a named 'static' inner class -anonymous.inner.may.be.named.static.inner.class.problem.descriptor: - text: 'Anonymous class #ref may be a named ''static'' inner class #loc' -array.length.in.loop.condition.display.name: - text: Array.length in loop condition -array.length.in.loop.condition.problem.descriptor: - text: 'Check of array #ref in loop condition #loc' -large.array.allocation.no.outofmemoryerror.display.name: - text: Large array allocation with no OutOfMemoryError check -large.array.allocation.no.outofmemoryerror.problem.descriptor: - text: 'Large array allocation which is not checked for out-of-memory condition #loc' -large.array.allocation.no.outofmemoryerror.maximum.number.of.elements.option: - text: 'Maximum number of elements:' -connection.opened.not.safely.closed.display.name: - text: Connection opened but not safely closed -interface.one.inheritor.display.name: - text: Interface which has only one direct inheritor -interface.one.inheritor.problem.descriptor: - text: 'Interface #ref has only one direct inheritor #loc' -method.call.in.loop.condition.display.name: - text: Method call in loop condition -method.call.in.loop.condition.problem.descriptor: - text: 'Call to method #ref() in loop condition #loc' -large.initializer.primitive.type.array.display.name: - text: Overly large initializer for array of primitive type -large.initializer.primitive.type.array.problem.descriptor: - text: 'Primitive array initializer with too many elements ({0}) #loc' -large.initializer.primitive.type.array.maximum.number.of.elements.option: - text: 'Maximum number of elements:' -private.member.access.between.outer.and.inner.classes.display.name: - text: Synthetic accessor call -private.member.access.between.outer.and.inner.classes.problem.descriptor: - text: 'Access to ''private'' member of class ''''{0}'''' requires synthetic accessor call #loc' -private.member.access.between.outer.and.inner.classes.make.local.quickfix: - text: Make ''{0}'' package-private -private.member.access.between.outer.and.inner.classes.make.constructor.package.local.quickfix: - text: Make ''{0}'' constructor package-private -recordstore.opened.not.safely.closed.display.name: - text: RecordStore opened but not safely closed -overly.complex.anonymous.inner.class.display.name: - text: Overly complex anonymous class -cyclomatic.complexity.limit.option: - text: 'Cyclomatic complexity limit:' -overly.complex.anonymous.inner.class.problem.descriptor: - text: 'Overly complex anonymous class (cyclomatic complexity = {0}) #loc' -anonymous.inner.class.with.too.many.methods.display.name: - text: Anonymous inner class with too many methods -method.count.limit.option: - text: 'Method count limit:' -anonymous.inner.class.with.too.many.methods.problem.descriptor: - text: 'Anonymous inner class with too many methods (method count = {0}) #loc' -overly.complex.class.display.name: - text: Overly complex class -overly.complex.class.problem.descriptor: - text: 'Overly complex class #ref (cyclomatic complexity = {0}) #loc' -overly.coupled.class.display.name: - text: Overly coupled class -overly.coupled.class.class.coupling.limit.option: - text: 'Class coupling limit:' -include.java.system.classes.option: - text: Include couplings to java system classes -include.library.classes.option: - text: Include couplings to library classes -overly.coupled.class.problem.descriptor: - text: '#ref is overly coupled (dependencies = {0}) #loc' + text: Class #ref is not exported from module ''{0}'' +class.escapes.defined.scope.problem.descriptor: + text: 'Class #ref is exposed outside its defined visibility scope #loc' +class.extends.utility.class.display.name: + text: Class extends utility class +class.extends.utility.class.ignore.utility.class.option: + text: Ignore if overriding class is a utility class +class.extends.utility.class.problem.descriptor: + text: 'Class #ref extends utility class ''''{0}'''' #loc' +class.independent.of.module.display.name: + text: Class independent of its module +class.independent.of.module.problem.descriptor: + text: 'Class #ref has no dependencies or dependents in its module #loc' +class.initializer.display.name: + text: Non-'static' initializer +class.initializer.may.be.static.display.name: + text: Class initializer may be 'static' +class.initializer.may.be.static.problem.descriptor: + text: 'Class initializer may be ''static'' #loc' +class.initializer.move.code.to.constructor.quickfix: + text: Move initializer code to constructor +class.initializer.option: + text: Only warn when the class has one or more constructors +class.initializer.problem.descriptor: + text: 'Non-''static'' initializer #loc' +class.loader.instantiation.display.name: + text: "'ClassLoader' instantiation" +class.loader.instantiation.problem.descriptor: + text: 'Instantiation of #ref may pose security concerns #loc' +class.may.be.interface.convert.quickfix: + text: Convert class to interface +class.may.be.interface.display.name: + text: Abstract 'class' may be 'interface' +class.may.be.interface.java8.option: + text: Report classes containing non-abstract methods when using Java 8 +class.may.be.interface.problem.descriptor: + text: 'Abstract class #ref may be interface #loc' +class.name: + text: Class Name +class.name.differs.from.file.name.display.name: + text: Class name differs from file name +class.name.differs.from.file.name.problem.descriptor: + text: 'Class name #ref differs from file name #loc' +class.name.prefixed.with.package.name.display.name: + text: Class name prefixed with package name +class.name.prefixed.with.package.name.problem.descriptor: + text: 'Class name #ref begins with its package name #loc' +class.name.same.as.ancestor.name.display.name: + text: Class name same as ancestor name +class.name.same.as.ancestor.name.problem.descriptor: + text: 'Class name #ref is the same as one of its superclass'' names #loc' +class.naming.convention.display.name: + text: Class naming convention +class.naming.convention.element.description: + text: Class +class.new.instance.display.name: + text: Unsafe call to 'Class.newInstance()' +class.new.instance.problem.descriptor: + text: 'Call to #ref() may throw undeclared checked exceptions #loc' +class.new.instance.quickfix: + text: Replace with 'Class.getConstructor().newInstance()' call +class.only.used.in.one.module.display.name: + text: Class only used from one other module +class.only.used.in.one.module.problem.descriptor: + text: 'Class #ref has only dependencies on and/or dependents in module ''''{0}'''' #loc' +class.only.used.in.one.package.display.name: + text: Class only used from one other package +class.only.used.in.one.package.problem.descriptor: + text: 'Class #ref has only dependencies on and/or dependents in package ''''{0}'''' #loc' +class.references.subclass.display.name: + text: Class references one of its subclasses +class.references.subclass.problem.descriptor: + text: 'Class ''''{0}'''' references subclass #ref #loc' +class.references.subclass.problem.descriptor.anonymous: + text: 'Anonymous class references subclass #ref #loc' class.too.deep.display.name: - text: Class too deep in inheritance tree + text: Class too deep in inheritance tree class.too.deep.inheritance.depth.limit.option: - text: 'Inheritance depth limit:' + text: 'Inheritance depth limit:' class.too.deep.problem.descriptor: - text: '#ref is too deep in inheritance tree (inheritance depth = {0}) #loc' -inner.class.too.deeply.nested.display.name: - text: Inner class too deeply nested -inner.class.too.deeply.nested.nesting.limit.option: - text: 'Nesting limit:' -inner.class.too.deeply.nested.problem.descriptor: - text: '#ref is too deeply nested (nesting level = {0}) #loc' -too.many.constructors.display.name: - text: Class with too many constructors -too.many.constructors.count.limit.option: - text: 'Constructor count limit:' -too.many.constructors.ignore.deprecated.option: - text: Ignore deprecated constructors -too.many.constructors.problem.descriptor: - text: '#ref has too many constructors (constructor count = {0}) #loc' -too.many.fields.display.name: - text: Class with too many fields -too.many.fields.count.limit.option: - text: 'Field count limit:' -too.many.fields.problem.descriptor: - text: '#ref has too many fields (field count = {0}) #loc' -too.many.methods.display.name: - text: Class with too many methods -too.many.methods.problem.descriptor: - text: '#ref has too many methods (method count = {0}) #loc' -externalizable.with.serialization.methods.display.name: - text: Externalizable class with 'readObject()' or 'writeObject()' -externalizable.with.serialization.methods.problem.descriptor.both: - text: 'Externalizable class #ref defines ''readObject()'' and ''writeObject()'' #loc' -externalizable.with.serialization.methods.problem.descriptor.write: - text: 'Externalizable class #ref defines ''writeObject()'' #loc' -externalizable.with.serialization.methods.problem.descriptor.read: - text: 'Externalizable class #ref defines ''readObject()'' #loc' -non.serializable.with.serialversionuid.display.name: - text: Non-serializable class with 'serialVersionUID' -non.serializable.class.with.serialversionuid.problem.descriptor: - text: 'Non-serializable class #ref defines a ''serialVersionUID'' field #loc' -non.serializable.interface.with.serialversionuid.problem.descriptor: - text: 'Non-serializable interface #ref defines a ''serialVersionUID'' field #loc' -non.serializable.ainterface.with.serialversionuid.problem.descriptor: - text: 'Non-serializable @interface #ref defines a ''serialVersionUID'' field #loc' -non.serializable.anonymous.with.serialversionuid.problem.descriptor: - text: 'Non-serializable anonymous class extending #ref defines a ''serialVersionUID'' field #loc' -non.serializable.with.serialversionuid.remove.quickfix: - text: Remove 'serialVersionUID' field -non.serializable.class.with.readwriteobject.display.name: - text: Non-serializable class with 'readObject()' or 'writeObject()' -non.serializable.class.with.readwriteobject.problem.descriptor.both: - text: 'Non-serializable class #ref defines ''readObject()'' and ''writeObject()'' #loc' -non.serializable.class.with.readwriteobject.problem.descriptor.write: - text: 'Non-serializable class #ref defines ''writeObject()'' #loc' -non.serializable.class.with.readwriteobject.problem.descriptor.read: - text: 'Non-serializable class #ref defines ''readObject()'' #loc' -non.serializable.anonymous.with.readwriteobject.problem.descriptor.both: - text: 'Non-serializable anonymous class extending #ref defines ''readObject()'' and ''writeObject()'' #loc' -non.serializable.anonymous.with.readwriteobject.problem.descriptor.write: - text: 'Non-serializable anonymous class extending #ref defines ''writeObject()'' #loc' -non.serializable.anonymous.with.readwriteobject.problem.descriptor.read: - text: 'Non-serializable anonymous class extending #ref defines ''readObject()'' #loc' -readwriteobject.private.display.name: - text: '''readObject()'' or ''writeObject()'' not declared ''private''' -readwriteobject.private.problem.descriptor: - text: '#ref not declared ''private'' #loc' -readobject.initialization.display.name: - text: Instance field may not be initialized by 'readObject()' -readobject.initialization.problem.descriptor: - text: 'Instance field #ref may not be initialized during ''readObject()'' call #loc' -readresolve.writereplace.protected.display.name: - text: '''readResolve()'' or ''writeReplace()'' not declared ''protected''' -readresolve.writereplace.protected.problem.descriptor: - text: '#ref() not declared ''protected'' #loc' -serialpersistentfields.with.wrong.signature.display.name: - text: '''serialPersistentFields'' field not declared ''private static final ObjectStreamField[]''' -serialpersistentfields.with.wrong.signature.problem.descriptor: - text: '#ref field of a Serializable class is not declared ''private static final ObjectStreamField[]'' #loc' -serialversionuid.private.static.final.long.display.name: - text: '''serialVersionUID'' field not declared ''private static final long''' -serialversionuid.private.static.final.long.problem.descriptor: - text: '#ref field of a Serializable class is not declared ''private static final long'' #loc' -serialversionuid.private.static.final.long.quickfix: - text: Make serialVersionUID 'private static final' -serializable.class.without.serialversionuid.display.name: - text: Serializable class without 'serialVersionUID' -serializable.class.without.serialversionuid.problem.descriptor: - text: '#ref does not define a ''serialVersionUID'' field #loc' -non.protected.constructor.in.abstract.class.display.name: - text: '''public'' constructor in ''abstract'' class' -unnecessary.qualifier.for.this.display.name: - text: Unnecessary qualifier for 'this' or 'super' -multiple.declaration.display.name: - text: Multiple variables in one declaration -thread.priority.display.name: - text: Call to 'Thread.setPriority()' -too.broad.scope.display.name: - text: Scope of variable is too broad -infinite.loop.statement.display.name: - text: Infinite loop statement -asserts.without.messages.display.name: - text: Message missing on JUnit assertion + text: '#ref is too deep in inheritance tree (inheritance depth = {0}) #loc' +class.unconnected.to.package.display.name: + text: Class independent of its package +class.unconnected.to.package.problem.descriptor: + text: Class #ref has no dependencies or dependents in its package +class.with.only.private.constructors.display.name: + text: Class with only 'private' constructors should be declared 'final' +class.with.only.private.constructors.problem.descriptor: + text: Class #ref with only 'private' constructors should be declared 'final' +class.with.too.many.dependencies.display.name: + text: Class with too many dependencies +class.with.too.many.dependencies.max.option: + text: Maximum number of dependencies +class.with.too.many.dependencies.problem.descriptor: + text: Class ''{0}'' has too many dependencies ({1} > {2}) +class.with.too.many.dependents.display.name: + text: Class with too many dependents +class.with.too.many.dependents.max.option: + text: Maximum number of dependents +class.with.too.many.dependents.problem.descriptor: + text: Class ''{0}'' has too many dependents ({1} > {2}) +class.with.too.many.transitive.dependencies.display.name: + text: Class with too many transitive dependencies +class.with.too.many.transitive.dependencies.max.option: + text: Maximum number of transitive dependencies +class.with.too.many.transitive.dependencies.problem.descriptor: + text: Class ''{0}'' has too many transitive dependencies ({1} > {2}) +class.with.too.many.transitive.dependents.display.name: + text: Class with too many transitive dependents +class.with.too.many.transitive.dependents.max.option: + text: Maximum number of transitive dependents +class.with.too.many.transitive.dependents.problem.descriptor: + text: Class ''{0}'' has too many transitive dependencies ({1} > {2}) +class.without.constructor.create.quickfix: + text: Generate empty constructor +class.without.constructor.display.name: + text: Class without constructor +class.without.constructor.problem.descriptor: + text: 'Class #ref has no constructor #loc' +class.without.no.arg.constructor.display.name: + text: Class without no-arg constructor +class.without.no.arg.constructor.ignore.option: + text: Ignore if class has default constructor +class.without.no.arg.constructor.problem.descriptor: + text: 'Class #ref is missing a no-arg constructor #loc' +class.without.tostring.display.name: + text: Class without 'toString()' +class.without.tostring.problem.descriptor: + text: 'Class #ref should probably implement ''toString()'', for debugging purposes #loc' +clone.doesnt.call.super.clone.display.name: + text: '''clone()'' does not call ''super.clone()''' +clone.doesnt.call.super.clone.problem.descriptor: + text: '#ref() does not call ''super.clone()'' #loc' +clone.doesnt.declare.clonenotsupportedexception.declare.quickfix: + text: Add 'CloneNotSupportedException' to throws clause +clone.doesnt.declare.clonenotsupportedexception.display.name: + text: '''clone()'' does not declare ''CloneNotSupportedException''' +clone.doesnt.declare.clonenotsupportedexception.problem.descriptor: + text: '#ref() #loc does not declare ''CloneNotSupportedException''' +clone.instantiates.objects.with.constructor.display.name: + text: '''clone()'' instantiates objects with constructor' +clone.instantiates.objects.with.constructor.problem.descriptor: + text: '''clone()'' creates new #ref instances #loc' +clone.method.in.non.cloneable.class.display.name: + text: '''clone()'' method in non-Cloneable class' +clone.method.in.non.cloneable.class.problem.descriptor: + text: '#ref() defined in non-Cloneable class ''''{0}'''' #loc' +clone.method.in.non.cloneable.interface.problem.descriptor: + text: '#ref() defined in non-Cloneable interface ''''{0}'''' #loc' +clone.returns.class.type.display.name: + text: '''clone()'' should have return type equal to the class it contains' +clone.returns.class.type.family.quickfix: + text: Change return type to class type +clone.returns.class.type.problem.descriptor: + text: '''''clone()'''' should have return type ''''{0}'''' #loc' +clone.returns.class.type.quickfix: + text: Change return type to ''{0}'' +cloneable.class.in.secure.context.display.name: + text: Cloneable class in secure context +cloneable.class.in.secure.context.problem.descriptor: + text: 'Class #ref may be cloned, compromising security #loc' +cloneable.class.without.clone.display.name: + text: Cloneable class without 'clone()' method +cloneable.class.without.clone.ignore.option: + text: Ignore classes cloneable due to inheritance +cloneable.class.without.clone.problem.descriptor: + text: '#ref is ''Cloneable'' but does not define ''clone()'' method #loc' +cloneable.class.without.clone.quickfix: + text: Generate 'clone()' method +collection.added.to.self.display.name: + text: Collection added to itself +collection.added.to.self.problem.descriptor: + text: '''''{0}()'''' called on collection #ref with itself as argument #loc' +collection.contains.url.display.name: + text: Map or Set may contain 'java.net.URL' objects +collection.contains.url.problem.decriptor: + text: '{0} #ref may contain URL objects #loc' +collection.declared.by.class.display.name: + text: Collection declared by class, not interface +collection.declared.by.class.ignore.locals.option: + text: Ignore local variables +collection.declared.by.class.ignore.private.members.option: + text: Ignore 'private' fields and methods +collection.declared.by.class.problem.descriptor: + text: 'Declaration of #ref should probably be weakened to ''''{0}'''' #loc' +collections.field.access.replaceable.by.method.call.display.name: + text: Reference to empty collection field can be replaced with method call +collections.field.access.replaceable.by.method.call.problem.descriptor: + text: "#ref can be replaced with ''Collections.{0}'' #loc" +collections.field.access.replaceable.by.method.call.quickfix: + text: Replace with ''{0}'' +collections.must.have.initial.capacity.display.name: + text: Collection without initial capacity +collections.must.have.initial.capacity.problem.descriptor: + text: 'new #ref() without initial capacity #loc' +comparable.implemented.but.equals.not.overridden.display.name: + text: '''Comparable'' implemented but ''equals()'' not overridden' +comparable.implemented.but.equals.not.overridden.problem.descriptor: + text: 'Class #ref implements ''java.lang.Comparable'' but does not override ''equals()'' #loc' +comparator.not.serializable.display.name: + text: "'Comparator' class not declared 'Serializable'" +comparator.not.serializable.problem.descriptor: + text: 'Comparator class #ref is not declared as Serializable #loc' +comparison.of.short.and.char.display.name: + text: Comparison of 'short' and 'char' values +comparison.of.short.and.char.problem.descriptor: + text: 'Equality comparison #ref of short and char values #loc' +comparison.to.nan.display.name: + text: Comparison to 'Double.NaN' or 'Float.NaN' +comparison.to.nan.problem.descriptor1: + text: 'Comparison to #ref is always false #loc' +comparison.to.nan.problem.descriptor2: + text: 'Comparison to #ref is always true #loc' +comparison.to.nan.replace.quickfix: + text: Replace with 'isNaN()' +concrete.class.method.parameter.display.name: + text: Method parameter of concrete class +concrete.class.method.parameter.problem.descriptor: + text: 'Parameter ''''{0}'''' of concrete class #ref #loc' +condition.signal.display.name: + text: Call to 'signal()' instead of 'signalAll()' +condition.signal.problem.descriptor: + text: '#ref should probably be replaced with ''signalAll()'' #loc' +condition.signal.replace.quickfix: + text: Replace with 'signalAll()' +conditional.can.be.pushed.inside.expression.display.name: + text: Conditional can be pushed inside branch expression +conditional.can.be.pushed.inside.expression.option: + text: Ignore when conditional will be only argument of a method call +conditional.can.be.pushed.inside.expression.problem.descriptor: + text: 'Conditional expression can be pushed inside branch #loc' +conditional.can.be.pushed.inside.expression.quickfix: + text: Push conditional expression inside branch +conditional.expression.display.name: + text: Conditional expression (?:) +conditional.expression.option: + text: Ignore for simple assignments and returns +conditional.expression.problem.descriptor: + text: 'Conditional expression #ref #loc' +conditional.expression.with.identical.branches.collapse.quickfix: + text: Collapse conditional expression +conditional.expression.with.identical.branches.display.name: + text: Conditional expression with identical branches +conditional.expression.with.identical.branches.problem.descriptor: + text: 'Conditional expression #ref with identical branches #loc' +confusing.else.option: + text: Report when there are no more statements after the 'if' statement +confusing.floating.point.literal.change.quickfix: + text: Change to canonical form +confusing.floating.point.literal.display.name: + text: Confusing floating-point literal +confusing.floating.point.literal.option: + text: Ignore floating-point literals in scientific notation +confusing.floating.point.literal.problem.descriptor: + text: 'Confusing floating-point literal #ref #loc' +confusing.main.method.display.name: + text: Confusing 'main()' method +confusing.main.method.problem.descriptor: + text: 'Method #ref() does not have signature ''public static void main(String[])'' #loc' +confusing.octal.escape.sequence.display.name: + text: Confusing octal escape sequence +confusing.octal.escape.sequence.problem.descriptor: + text: 'Octal escape sequence #ref immediately followed by a digit #loc' +connection.opened.not.safely.closed.display.name: + text: Connection opened but not safely closed +consider.static.final.fields.constant.option: + text: Consider 'static final' fields constant +constant.assert.condition.display.name: + text: Constant condition in 'assert' statement +constant.assert.condition.problem.descriptor: + text: 'Assert condition #ref is constant #loc' +constant.conditional.expression.display.name: + text: Constant conditional expression +constant.conditional.expression.problem.descriptor: + text: '#ref can be simplified to ''''{0}'''' #loc' +constant.conditional.expression.simplify.quickfix: + text: Simplify +constant.declared.in.abstract.class.display.name: + text: Constant declared in 'abstract' class +constant.declared.in.abstract.class.problem.descriptor: + text: 'Constant #ref declared in abstract class #loc' +constant.declared.in.interface.display.name: + text: Constant declared in interface +constant.declared.in.interface.problem.descriptor: + text: 'Constant #ref declared in interface #loc' +constant.for.zero.length.array.display.name: + text: Unnecessary zero length array usage +constant.for.zero.length.array.problem.descriptor: + text: 'Zero length array can be changed to constant #loc' +constant.for.zero.length.array.quickfix.family: + text: Replace with constant +constant.if.statement.display.name: + text: Constant 'if' statement +constant.if.statement.problem.descriptor: + text: '#ref statement can be simplified #loc' +constant.junit.assert.argument.display.name: + text: Constant assert argument +constant.junit.assert.argument.problem.descriptor: + text: 'Argument #ref is constant #loc' +constant.math.call.display.name: + text: Constant call to 'Math' +constant.math.call.problem.descriptor: + text: 'Constant call to #ref() can be simplified #loc' constant.naming.convention.display.name: - text: Constant naming convention + text: Constant naming convention constant.naming.convention.element.description: - text: Constant -random.double.for.random.integer.display.name: - text: Using 'Random.nextDouble()' to get random integer -test.method.without.assertion.display.name: - text: JUnit test method without any assertions -string.buffer.replaceable.by.string.builder.display.name: - text: '''StringBuffer'' may be ''StringBuilder''' -comparison.of.short.and.char.display.name: - text: Comparison of 'short' and 'char' values -unnecessary.fully.qualified.name.display.name: - text: Unnecessary fully qualified name -ignore.in.module.statements.option: - text: Ignore in Java 9 module statements -unnecessary.label.on.break.statement.display.name: - text: Unnecessary label on 'break' statement -exception.name.doesnt.end.with.exception.display.name: - text: Exception class name does not end with 'Exception' -bad.exception.declared.display.name: - text: Prohibited exception declared -deserializable.class.in.secure.context.display.name: - text: Deserializable class in secure context -pointless.boolean.expression.display.name: - text: Pointless boolean expression -class.without.constructor.display.name: - text: Class without constructor -break.statement.display.name: - text: '''break'' statement' -unconditional.wait.display.name: - text: Unconditional 'wait()' call -cyclomatic.complexity.display.name: - text: Overly complex method -string.to.string.display.name: - text: Redundant 'String.toString()' + text: Constant +constant.naming.convention.immutables.option: + text: Only check 'static final' fields with immutable types constant.on.lhs.of.comparison.display.name: - text: Constant on left side of comparison -final.class.display.name: - text: '''final'' class' -labeled.statement.display.name: - text: Labeled statement -notify.called.on.condition.display.name: - text: '''notify()'' or ''notifyAll()'' called on ''java.util.concurrent.locks.Condition'' object' -loop.statements.that.dont.loop.display.name: - text: Loop statement that does not loop -thread.run.display.name: - text: Call to 'Thread.run()' -non.synchronized.method.overrides.synchronized.method.display.name: - text: Unsynchronized method overrides synchronized method + text: Constant on left side of comparison +constant.on.lhs.of.comparison.problem.descriptor: + text: 'Constant #ref on the left side of the comparison #loc' constant.on.rhs.of.comparison.display.name: - text: Constant on right side of comparison -synchronize.on.this.display.name: - text: Synchronization on 'this' -switch.statement.with.too.many.branches.display.name: - text: '''switch'' statement with too many branches' -utility.class.without.private.constructor.display.name: - text: Utility class without 'private' constructor -throw.caught.locally.display.name: - text: '''throw'' caught by containing ''try'' statement' -exception.from.catch.which.doesnt.wrap.display.name: - text: '''throw'' inside ''catch'' block which ignores the caught exception' -type.parameter.naming.convention.display.name: - text: Type parameter naming convention -type.parameter.naming.convention.element.description: - text: Type parameter -multiply.or.divide.by.power.of.two.display.name: - text: Multiply or divide by power of two -multiply.or.divide.by.power.of.two.divide.option: - text: Check divisions by a power of two also -serializable.with.unconstructable.ancestor.display.name: - text: Serializable class with unconstructable ancestor -missorted.modifiers.display.name: - text: Missorted modifiers -sleep.while.holding.lock.display.name: - text: Call to 'Thread.sleep()' while synchronized -singleton.display.name: - text: Singleton -thread.death.rethrown.display.name: - text: '''java.lang.ThreadDeath'' not rethrown' -if.statement.with.too.many.branches.display.name: - text: '''if'' statement with too many branches' -redundant.implements.display.name: - text: Redundant interface declaration -nesting.depth.display.name: - text: Overly nested method -return.this.display.name: - text: Return of 'this' -busy.wait.display.name: - text: Busy wait -utility.class.display.name: - text: Utility class -instantiating.object.to.get.class.object.display.name: - text: Instantiating object to get Class object -abstract.class.extends.concrete.class.display.name: - text: Abstract class extends concrete class -parameter.naming.convention.display.name: - text: Method parameter naming convention -parameter.naming.convention.element.description: - text: Parameter -integer.division.in.floating.point.context.display.name: - text: Integer division in floating point context -interface.naming.convention.display.name: - text: Interface naming convention -interface.naming.convention.element.description: - text: Interface -length.one.strings.in.concatenation.display.name: - text: Single character string concatenation -length.one.string.in.indexof.display.name: - text: Single character string argument in 'String.indexOf()' call -unnecessary.conditional.expression.display.name: - text: Redundant conditional expression -thread.yield.display.name: - text: Call to 'Thread.yield()' -confusing.floating.point.literal.display.name: - text: Confusing floating-point literal -wait.not.in.loop.display.name: - text: '''wait()'' not in loop' -string.concatenation.inside.string.buffer.append.display.name: - text: String concatenation as argument to 'StringBuffer.append()' call -class.initializer.display.name: - text: Non-'static' initializer -enumerated.class.naming.convention.display.name: - text: Enumerated class naming convention -enumerated.class.naming.convention.element.description: - text: Enumerated class -non.thread.safe.lazy.initialization.display.name: - text: Unsafe lazy initialization of 'static' field -call.to.simple.setter.in.class.display.name: - text: Call to simple setter from within class -comparison.to.nan.display.name: - text: Comparison to Double.NaN or Float.NaN -instance.method.naming.convention.display.name: - text: Instance method naming convention -instance.method.naming.convention.element.description: - text: Instance method -unnecessary.semicolon.display.name: - text: Unnecessary semicolon -fallthru.in.switch.statement.display.name: - text: Fallthrough in 'switch' statement -call.to.native.method.while.locked.display.name: - text: Call to a native method while locked -switch.statement.display.name: - text: '''switch'' statement' -custom.classloader.display.name: - text: Custom ClassLoader -nested.conditional.expression.display.name: - text: Nested conditional expression -duplicate.condition.display.name: - text: Duplicate condition in 'if' statement -duplicate.boolean.branch.display.name: - text: Duplicate condition on '\&\&' or '||' -method.with.multiple.loops.display.name: - text: Method with multiple loops -non.comment.source.statements.display.name: - text: Overly long method -local.variable.naming.convention.display.name: - text: Local variable naming convention -local.variable.naming.convention.element.description: - text: Local variable -negated.if.else.display.name: - text: '''if'' statement with negated condition' -class.naming.convention.display.name: - text: Class naming convention -class.naming.convention.element.description: - text: Class -abstract.class.naming.convention.display.name: - text: Abstract class naming convention -abstract.class.naming.convention.element.description: - text: Abstract class -serializable.inner.class.with.non.serializable.outer.class.display.name: - text: Serializable non-'static' inner class with non-Serializable outer class -pointless.arithmetic.expression.display.name: - text: Pointless arithmetic expression -method.name.same.as.class.name.display.name: - text: Method name same as class name -unnecessary.temporary.on.conversion.to.string.display.name: - text: Unnecessary temporary object in conversion to String -unnecessary.continue.display.name: - text: Unnecessary 'continue' statement -inner.class.on.interface.display.name: - text: Inner class of interface -unused.label.display.name: - text: Unused label -multiple.typed.declaration.display.name: - text: Variables of different types in one declaration -overly.complex.boolean.expression.display.name: - text: Overly complex boolean expression + text: Constant on right side of comparison +constant.on.rhs.of.comparison.problem.descriptor: + text: 'Constant #ref on the right side of the comparison #loc' +constant.string.intern.display.name: + text: Call to 'intern()' on String constant +constant.string.intern.problem.descriptor: + text: '.#ref() on compile-time constant is unnecessary #loc' +constant.string.intern.quickfix: + text: Remove 'intern()' call +constant.value.variable.use.display.name: + text: Use of variable whose value is known to be constant +constant.value.variable.use.problem.descriptor: + text: 'Value of #ref is known to be constant #loc' +constructor.visibility.option: + text: 'Ignore constructors with visibility:' +continue.or.break.from.finally.block.display.name: + text: '''continue'' or ''break'' inside ''finally'' block' +continue.or.break.from.finally.block.problem.descriptor: + text: '#ref inside ''finally'' block #loc' +continue.statement.display.name: + text: '''continue'' statement' continue.statement.with.label.display.name: - text: '''continue'' statement with label' -class.loader.instantiation.display.name: - text: ClassLoader instantiation -return.from.finally.block.display.name: - text: '''return'' inside ''finally'' block' -unnecessary.boxing.display.name: - text: Unnecessary boxing -annotation.naming.convention.display.name: - text: Annotation naming convention -annotation.naming.convention.element.description: - text: Annotation -checked.exception.class.display.name: - text: Checked exception class -switch.statement.with.confusing.declaration.display.name: - text: Local variable used and declared in different 'switch' branches -cast.that.loses.precision.display.name: - text: Numeric cast that loses precision -manual.array.copy.display.name: - text: Manual array copy -manual.array.to.collection.copy.display.name: - text: Manual array to collection copy -long.literals.ending.with.lowercase.l.display.name: - text: '''long'' literal ending with ''l'' instead of ''L''' -overly.complex.arithmetic.expression.display.name: - text: Overly complex arithmetic expression -junit.abstract.test.class.naming.convention.display.name: - text: JUnit abstract test class naming convention -junit.abstract.test.class.naming.convention.element.description: - text: Abstract JUnit test class -unnecessary.parentheses.display.name: - text: Unnecessary parentheses -test.case.in.product.code.display.name: - text: JUnit TestCase in product source -test.method.in.product.code.display.name: - text: JUnit test method in product source -serializable.class.in.secure.context.display.name: - text: Serializable class in secure context -static.variable.naming.convention.display.name: - text: '''static'' field naming convention' -static.variable.naming.convention.element.description: - text: '''static'' field' -nested.method.call.display.name: - text: Nested method call -throw.from.finally.block.display.name: - text: '''throw'' inside ''finally'' block' -field.accessed.synchronized.and.unsynchronized.display.name: - text: Field accessed in both synchronized and unsynchronized contexts -abstract.method.overrides.abstract.method.display.name: - text: Abstract method overrides abstract method -static.non.final.field.display.name: - text: '''static'', non-''final'' field' -static.non.final.field.option: - text: Only report 'public' fields -substring.zero.display.name: - text: Redundant 'substring(0)' call -class.without.no.arg.constructor.display.name: - text: Class without no-arg constructor -unnecessary.return.display.name: - text: Unnecessary 'return' statement -final.static.method.display.name: - text: '''static'' method declared ''final''' -constant.declared.in.abstract.class.display.name: - text: Constant declared in abstract class -too.broad.catch.display.name: - text: Overly broad 'catch' block -floating.point.equality.display.name: - text: Floating point equality comparison -thrown.exceptions.per.method.display.name: - text: Method with too many exceptions declared -public.static.array.field.display.name: - text: '''public static'' array field' -await.not.in.loop.display.name: - text: '''await()'' not in loop' -method.names.differ.only.by.case.display.name: - text: Method names differing only by case -unsecure.random.number.generation.display.name: - text: Insecure random number generation -parameters.per.method.display.name: - text: Method with too many parameters -parameters.per.constructor.display.name: - text: Constructor with too many parameters -unnecessary.unboxing.display.name: - text: Unnecessary unboxing -extends.thread.display.name: - text: Class directly extends 'java.lang.Thread' -test.case.with.constructor.display.name: - text: JUnit TestCase with non-trivial constructors -parameter.name.differs.from.overridden.parameter.display.name: - text: Parameter name differs from parameter in overridden method -final.private.method.display.name: - text: '''private'' method declared ''final''' -enum.switch.statement.which.misses.cases.display.name: - text: Enum 'switch' statement that misses case -enum.switch.statement.which.misses.cases.option: - text: Ignore switch statements with a default branch -unconstructable.test.case.display.name: - text: Unconstructable JUnit TestCase -volatile.long.or.double.field.display.name: - text: Volatile long or double field -string.buffer.must.have.initial.capacity.display.name: - text: StringBuffer or StringBuilder without initial capacity -method.may.be.static.display.name: - text: Method may be 'static' -class.initializer.may.be.static.display.name: - text: Class initializer may be 'static' -class.initializer.option: - text: Only warn when the class has one or more constructors -class.initializer.move.code.to.constructor.quickfix: - text: Move initializer code to constructor -nested.switch.statement.display.name: - text: Nested 'switch' statement -c.style.array.declaration.display.name: - text: C-style array declaration -final.method.in.final.class.display.name: - text: '''final'' method in ''final'' class' -extends.annotation.display.name: - text: Class extends annotation interface -naked.notify.display.name: - text: '''notify()'' or ''notifyAll()'' without corresponding state change' -constant.if.statement.display.name: - text: Constant 'if' statement -switch.statement.density.display.name: - text: '''switch'' statement with too low of a branch density' -switch.statement.with.too.few.branches.display.name: - text: '''switch'' statement with too few branches' -upper.case.field.name.not.constant.display.name: - text: Non-constant field with upper-case name -unnecessary.label.on.continue.statement.display.name: - text: Unnecessary label on 'continue' statement -jdbc.prepare.statement.with.non.constant.string.display.name: - text: Call to 'Connection.prepare*()' with non-constant string -synchronize.on.non.final.field.display.name: - text: Synchronization on a non-final field -noop.method.in.abstract.class.display.name: - text: No-op method in abstract class -non.final.field.of.exception.display.name: - text: Non-final field of exception class -nested.try.statement.display.name: - text: Nested 'try' statement -condition.signal.display.name: - text: Call to 'signal()' instead of 'signalAll()' -jdbc.execute.with.non.constant.string.display.name: - text: Call to 'Statement.execute()' with non-constant string -system.set.security.manager.display.name: - text: Call to 'System.setSecurityManager()' -system.set.security.manager.problem.descriptor: - text: 'Call to System.#ref() may pose security concerns #loc' + text: '''continue'' statement with label' +continue.statement.with.label.problem.descriptor: + text: '#ref statement with label #loc' +control.flow.statement.without.braces.add.quickfix: + text: Add braces to statement control.flow.statement.without.braces.display.name: - text: Control flow statement without braces -trivial.if.display.name: - text: Redundant 'if' statement -thread.with.default.run.method.display.name: - text: Instantiating a Thread with default 'run()' method -while.loop.spins.on.field.display.name: - text: '''while'' loop spins on field' -while.loop.spins.on.field.fix.family.name: - text: Fix spin loop -while.loop.spins.on.field.fix.volatile: - text: Make ''{0}'' volatile -while.loop.spins.on.field.fix.spinwait: - text: Add Thread.onSpinWait() -while.loop.spins.on.field.fix.volatile.spinwait: - text: Make ''{0}'' volatile and add Thread.onSpinWait() -object.equals.null.display.name: - text: Object.equals(null) -test.method.is.public.void.no.arg.display.name: - text: Malformed test method -if.statement.with.identical.branches.display.name: - text: '''if'' statement with identical branches' -multiple.return.points.per.method.display.name: - text: Method with multiple return points -break.statement.with.label.display.name: - text: '''break'' statement with label' -public.constructor.in.non.public.class.display.name: - text: '''public'' constructor in non-public class' -questionable.name.display.name: - text: Questionable name -empty.finally.block.display.name: - text: Empty 'finally' block -abstract.method.overrides.concrete.method.display.name: - text: Abstract method overrides concrete method -thread.stop.suspend.resume.display.name: - text: Call to 'Thread.stop()', 'suspend()' or 'resume()' -constant.math.call.display.name: - text: Constant call to 'java.lang.Math' -volatile.array.field.display.name: - text: Volatile array field -literal.as.arg.to.string.equals.display.name: - text: '''expression.equals("literal")'' rather than ''"literal".equals(expression)''' -inner.class.may.be.static.display.name: - text: Inner class may be 'static' -static.suite.display.name: - text: '''suite()'' method not declared ''static''' -redundant.field.initialization.display.name: - text: Redundant field initialization -string.buffer.to.string.in.concatenation.display.name: - text: '''StringBuffer.toString()'' in concatenation' -utility.class.with.public.constructor.display.name: - text: Utility class with 'public' constructor -for.loop.replaceable.by.while.display.name: - text: '''for'' loop may be replaced with ''while'' loop' -missing.deprecated.annotation.display.name: - text: Missing @Deprecated annotation -cloneable.class.in.secure.context.display.name: - text: Cloneable class in secure context -static.inheritance.display.name: - text: Static inheritance -class.name.prefixed.with.package.name.display.name: - text: Class name prefixed with package name -call.to.simple.getter.in.class.display.name: - text: Call to simple getter from within class -class.name.differs.from.file.name.display.name: - text: Class name differs from file name -protected.member.in.final.class.display.name: - text: '''protected'' member in ''final'' class' -load.library.with.non.constant.string.display.name: - text: Call to 'System.loadLibrary()' with non-constant string -instanceof.catch.parameter.display.name: - text: '''instanceof'' on ''catch'' parameter' -implicit.numeric.conversion.display.name: - text: Implicit numeric conversion -unnecessary.interface.modifier.display.name: - text: Unnecessary interface modifier -confusing.main.method.display.name: - text: Confusing 'main()' method -octal.literal.display.name: - text: Octal integer -misordered.assert.equals.arguments.display.name: - text: Misordered 'assertEquals()' arguments -unnecessary.constructor.display.name: - text: Redundant no-arg constructor -method.name.same.as.parent.name.display.name: - text: Method name same as parent class name -while.can.be.foreach.display.name: - text: '''while'' loop replaceable with ''foreach''' -big.decimal.equals.display.name: - text: '''equals()'' called on ''java.math.BigDecimal''' -implicit.call.to.super.display.name: - text: Implicit call to 'super()' -empty.catch.block.display.name: - text: Empty 'catch' block -unqualified.static.usage.display.name: - text: Unqualified static access -simplifiable.junit.assertion.display.name: - text: Simplifiable JUnit assertion -simplifiable.testng.assertion.display.name: - text: Simplifiable TestNG assertion -object.notify.display.name: - text: Call to 'notify()' instead of 'notifyAll()' -thread.start.in.construction.display.name: - text: Call to 'Thread.start()' during object construction -non.final.clone.display.name: - text: Non-final 'clone()' in secure context -unnecessary.temporary.on.conversion.from.string.display.name: - text: Unnecessary temporary object in conversion from String -unnecessary.this.display.name: - text: Unnecessary 'this' qualifier -unnecessary.this.ignore.assignments.option: - text: Ignore field assignments -runtime.exec.with.non.constant.string.display.name: - text: Call to 'Runtime.exec()' with non-constant string -system.properties.display.name: - text: Access of system properties -chained.method.call.display.name: - text: Chained method calls -safe.lock.display.name: - text: Lock acquired but not safely unlocked -system.run.finalizers.on.exit.display.name: - text: Call to 'System.runFinalizersOnExit()' -for.can.be.foreach.display.name: - text: '''for'' loop replaceable with ''foreach''' -type.parameter.extends.object.display.name: - text: Type parameter explicitly extends 'java.lang.Object' -marker.interface.display.name: - text: Marker interface -limited.scope.inner.class.display.name: - text: Limited-scope inner class -switch.statements.without.default.display.name: - text: '''switch'' statement without ''default'' branch' -unchecked.exception.class.display.name: - text: Unchecked exception class -for.loop.with.missing.component.display.name: - text: '''for'' loop with missing components' -for.loop.with.missing.component.collection.loop.option: - text: Ignore collection iterations + text: Control flow statement without braces +control.flow.statement.without.braces.message: + text: Add braces to ''{0}'' statement +control.flow.statement.without.braces.problem.descriptor: + text: '{0} without braces #loc' +convert.junit3.test.class.quickfix: + text: Convert JUnit 3 class ''{0}'' to JUnit 4 +convert.octal.literal.to.decimal.literal.quickfix: + text: Convert octal literal to decimal literal +convert.to.variable.arity.method.quickfix: + text: Convert to varargs method +covariant.equals.display.name: + text: Covariant 'equals()' +covariant.equals.problem.descriptor: + text: '#ref() should take ''Object'' as its argument #loc' +cstyle.array.method.declaration.problem.descriptor: + text: C-style array declaration of the return type of method #ref()#loc +cstyle.array.variable.declaration.problem.descriptor: + text: 'C-style array declaration of {0, choice, 1#field|2#parameter|3#local variable} #ref #loc' +custom.classloader.display.name: + text: Custom 'ClassLoader' is declared +custom.classloader.problem.descriptor: + text: 'Custom ClassLoader class #ref #loc' +custom.security.manager.display.name: + text: Custom 'SecurityManager' +custom.security.manager.problem.descriptor: + text: 'Custom SecurityManager class #ref #loc' +cyclic.class.dependency.1.problem.descriptor: + text: Class ''{0}'' is cyclically dependent on class ''{1}'' +cyclic.class.dependency.2.problem.descriptor: + text: Class ''{0}'' is cyclically dependent on classes ''{1}'' and ''{2}'' +cyclic.class.dependency.display.name: + text: Cyclic class dependency +cyclic.class.dependency.problem.descriptor: + text: Class ''{0}'' is cyclically dependent on {1} other classes +cyclic.class.initialization.display.name: + text: Cyclic class initialization dependency +cyclic.class.initialization.problem.descriptor: + text: Initialization of class ''{0}'' is cyclically dependent on {1} other classes +cyclic.package.dependency.1.problem.descriptor: + text: Package ''{0}'' is cyclically dependent on package ''{1}'' +cyclic.package.dependency.2.problem.descriptor: + text: Package ''{0}'' is cyclically dependent on packages ''{1}'' and ''{2}'' +cyclic.package.dependency.display.name: + text: Cyclic package dependency +cyclic.package.dependency.problem.descriptor: + text: Package ''{0}'' is cyclically dependent on {1} other packages +cyclomatic.complexity.display.name: + text: Overly complex method +cyclomatic.complexity.limit.option: + text: 'Cyclomatic complexity limit:' +cyclomatic.complexity.problem.descriptor: + text: 'Overly complex method #ref() (cyclomatic complexity = {0}) #loc' +dangling.javadoc.convert.quickfix: + text: Replace with block comment +dangling.javadoc.delete.quickfix: + text: Remove dangling comment +dangling.javadoc.display.name: + text: Dangling Javadoc comment +dangling.javadoc.problem.descriptor: + text: 'Dangling Javadoc comment #loc' +debug.level.and.lower.option: + text: debug level and lower +declare.collection.as.interface.quickfix: + text: Weaken to ''{0}'' +default.not.last.case.in.switch.display.name: + text: '''default'' not last case in ''switch''' +default.not.last.case.in.switch.problem.descriptor: + text: '#ref branch not last case in ''switch'' statement #loc' +default.tostring.call.display.name: + text: Call to default 'toString()' +default.tostring.call.problem.descriptor: + text: 'Call to default ''toString()'' on #ref #loc' +delete.catch.section.quickfix: + text: Delete 'catch' section +delete.import.quickfix: + text: Delete unnecessary import +deserializable.class.in.secure.context.display.name: + text: Deserializable class in secure context +deserializable.class.in.secure.context.problem.descriptor: + text: 'Class #ref may be deserialized, compromising security #loc' +design.for.extension.display.name: + text: Design for extension +design.for.extension.problem.descriptor: + text: 'Method #ref() may be overridden and its functionality ignored #loc' +diamond.can.be.replaced.with.explicit.type.arguments.name: + text: Diamond can be replaced with explicit type arguments +diamond.can.be.replaced.with.explicit.type.arguments.quickfix: + text: Replace '<>' with explicit type arguments +disjoint.package.display.name: + text: Package with disjoint dependency graph +disjoint.package.problem.descriptor: + text: Package {0} can be decomposed into {1} independent packages +divide.by.zero.display.name: + text: Division by zero +divide.by.zero.problem.descriptor: + text: 'Division by zero #loc' +dollar.sign.in.name.display.name: + text: Use of '$' in identifier +dollar.sign.in.name.problem.descriptor: + text: 'Identifier #ref contains ''$'' #loc' +double.brace.initialization.display.name: + text: Double brace initialization +double.brace.initialization.quickfix: + text: Replace with regular initialization double.checked.locking.display.name: - text: Double-checked locking -double.checked.locking.problem.descriptor: - text: 'Double-checked locking #loc' + text: Double-checked locking double.checked.locking.ignore.on.volatiles.option: - text: Ignore double-checked locking on volatile fields -string.buffer.replaceable.by.string.display.name: - text: '''StringBuffer'' can be replaced with ''String''' -boolean.method.name.must.start.with.question.display.name: - text: Boolean method name must start with question word -class.name.same.as.ancestor.name.display.name: - text: Class name same as ancestor name -error.rethrown.display.name: - text: '''java.lang.Error'' not rethrown' -serializable.has.serialization.methods.display.name: - text: Serializable class without 'readObject()' and 'writeObject()' -serializable.has.serialization.methods.ignore.option: - text: Ignore classes that do not define instance fields -missing.override.annotation.display.name: - text: Missing @Override annotation -wait.while.holding.two.locks.display.name: - text: '''wait()'' while holding two locks' + text: Ignore double-checked locking on volatile fields +double.checked.locking.problem.descriptor: + text: 'Double-checked locking #loc' +double.checked.locking.quickfix: + text: Make ''{0}'' volatile +double.literal.may.be.float.literal.display.name: + text: Cast to 'float' can be 'float' literal +double.literal.may.be.float.literal.problem.descriptor: + text: '#ref could be replaced with ''''{0}'''' #loc' +double.literal.may.be.float.literal.quickfix: + text: Replace with ''{0}'' +double.negation.display.name: + text: Double negation +double.negation.problem.descriptor: + text: 'Double negation in #ref #loc' +double.negation.quickfix: + text: Remove double negation +drivermanager.call.display.name: + text: Use of 'DriverManager' to get JDBC connection +drivermanager.call.problem.descriptor: + text: 'Call to DriverManager.#ref() #loc' +dumpstack.call.display.name: + text: Call to 'Thread.dumpStack()' +dumpstack.call.problem.descriptor: + text: 'Call to Thread.#ref() should probably be replaced with more robust logging #loc' +duplicate.boolean.branch.display.name: + text: Duplicate condition on '\&\&' or '||' +duplicate.boolean.branch.problem.descriptor: + text: 'Duplicate branch #ref #loc' +duplicate.condition.display.name: + text: Duplicate condition in 'if' statement +duplicate.condition.ignore.method.calls.option: + text: Ignore conditions with possible side effects +duplicate.condition.problem.descriptor: + text: 'Duplicate condition #ref #loc' +dynamic.regex.replaceable.by.compiled.pattern.display.name: + text: Dynamic regular expression can be replaced by compiled 'Pattern' +dynamic.regex.replaceable.by.compiled.pattern.problem.descriptor: + text: '#ref() can be replaced with compiled ''java.util.regex.Pattern'' construct #loc' +dynamic.regex.replaceable.by.compiled.pattern.quickfix: + text: Replace with call to method of compiled 'Pattern' constant +empty.anonymous.class.problem.descriptor: + text: 'Anonymous class is empty #loc' +empty.catch.block.comments.option: + text: Comments count as content +empty.catch.block.display.name: + text: Empty 'catch' block +empty.catch.block.ignore.ignore.option: + text: Ignore when 'catch' parameter is named 'ignore' or 'ignored' +empty.catch.block.problem.descriptor: + text: 'Empty #ref block #loc' empty.class.display.name: - text: Empty class -trivial.string.concatenation.display.name: - text: Concatenation with empty string + text: Empty class +empty.class.file.without.class.problem.descriptor: + text: 'Java file does not declare any class #loc' +empty.class.ignore.parameterization.option: + text: Ignore class if it is a parameterization of a super type +empty.class.initializer.delete.quickfix: + text: Delete empty class initializer +empty.class.initializer.display.name: + text: Empty class initializer +empty.class.initializer.problem.descriptor: + text: 'Empty class initializer #loc' +empty.class.problem.descriptor: + text: 'Class #ref is empty #loc' +empty.directories.delete.quickfix: + text: Delete empty directory ''{0}'' +empty.directories.only.under.source.roots.option: + text: Only report empty directories located under a source folder +empty.directories.problem.descriptor: + text: Empty directory {0} +empty.directory.display.name: + text: Empty directory +empty.finally.block.display.name: + text: Empty 'finally' block +empty.finally.block.problem.descriptor: + text: 'Empty #ref block #loc' empty.synchronized.statement.display.name: - text: Empty 'synchronized' statement -unnecessary.default.display.name: - text: Unnecessary 'default' for enum 'switch' statement -simplifiable.conditional.expression.display.name: - text: Simplifiable conditional expression -simplifiable.if.statement.display.name: - text: '''if'' statement may be replaced with \&\& or || expression' -unnecessary.super.constructor.display.name: - text: Unnecessary call to 'super()' -unnecessarily.qualified.static.usage.display.name: - text: Unnecessarily qualified static access -bad.exception.caught.display.name: - text: Prohibited exception caught -custom.security.manager.display.name: - text: Custom SecurityManager -string.concatenation.in.loops.display.name: - text: String concatenation in loop -boolean.constructor.display.name: - text: Boolean constructor call -continue.statement.display.name: - text: '''continue'' statement' -extends.object.display.name: - text: Class explicitly extends 'java.lang.Object' -serializable.inner.class.has.serial.version.uid.field.display.name: - text: Serializable non-'static' inner class without 'serialVersionUID' -static.method.naming.convention.display.name: - text: '''static'' method naming convention' -static.method.naming.convention.element.description: - text: '''static'' method' + text: Empty 'synchronized' statement +empty.synchronized.statement.problem.descriptor: + text: 'Empty #ref statement #loc' empty.try.block.display.name: - text: Empty 'try' block -field.has.setter.but.no.getter.display.name: - text: Field has setter but no getter -three.negations.per.method.display.name: - text: Method with more than three negations -conditional.expression.display.name: - text: Conditional expression (?:) -unnecessary.enum.modifier.display.name: - text: Unnecessary enum modifier -string.equals.empty.string.display.name: - text: '''String.equals("")''' -synchronize.on.lock.display.name: - text: Synchronization on a Lock object -synchronized.on.literal.object.name: - text: Synchronization on an object initialized with a literal -field.may.be.static.display.name: - text: Field may be 'static' -class.may.be.interface.display.name: - text: Abstract class may be interface -abstract.class.without.abstract.methods.display.name: - text: Abstract class without abstract methods -divide.by.zero.display.name: - text: Divide by zero -default.not.last.case.in.switch.display.name: - text: '''default'' not last case in ''switch'' statement' -nested.synchronized.statement.display.name: - text: Nested 'synchronized' statement -constant.conditional.expression.display.name: - text: Constant conditional expression -unused.catch.parameter.display.name: - text: Unused 'catch' parameter -redundant.else.display.name: - text: Redundant 'else' -public.field.accessed.in.synchronized.context.display.name: - text: Non-private field accessed in synchronized context -string.replaceable.by.string.buffer.display.name: - text: Non-constant String should be StringBuilder -junit.test.class.naming.convention.display.name: - text: JUnit test class naming convention -junit.test.class.naming.convention.element.description: - text: JUnit test class -method.coupling.display.name: - text: Overly coupled method -collections.must.have.initial.capacity.display.name: - text: Collection without initial capacity -anonymous.inner.class.display.name: - text: Anonymous inner class -negated.conditional.display.name: - text: Conditional expression with negated condition -non.reproducible.math.call.display.name: - text: Non-reproducible call to 'java.lang.Math' -multiple.top.level.classes.in.file.display.name: - text: Multiple top level classes in single file -set.replaceable.by.enum.set.display.name: - text: Set replaceable with EnumSet -non.static.inner.class.in.secure.context.display.name: - text: Non-'static' inner class in secure context -tail.recursion.display.name: - text: Tail recursion -finally.block.cannot.complete.normally.display.name: - text: '''finally'' block which can not complete normally' -non.atomic.operation.on.volatile.field.display.name: - text: Non-atomic operation on volatile field -public.static.collection.field.display.name: - text: '''public static'' collection field' -non.exception.name.ends.with.exception.display.name: - text: Non-exception class name ends with 'Exception' -synchronized.method.display.name: - text: '''synchronized'' method' + text: Empty 'try' block +empty.try.block.problem.descriptor: + text: 'Empty #ref block #loc' +encapsulate.variable.quickfix: + text: Encapsulate field ''{0}'' +enum.switch.statement.which.misses.cases.display.name: + text: Enum 'switch' statement that misses case +enum.switch.statement.which.misses.cases.option: + text: Ignore switch statements with a default branch +enum.switch.statement.which.misses.cases.problem.descriptor: + text: '#ref statement on enum type ''''{0}'''' misses cases #loc' +enumerated.class.display.name: + text: Enumerated class +enumerated.class.naming.convention.display.name: + text: Enumerated class naming convention +enumerated.class.naming.convention.element.description: + text: Enum class +enumerated.class.problem.descriptor: + text: 'Enumerated class #ref #loc' enumerated.constant.naming.convention.display.name: - text: Enumerated constant naming convention + text: Enumerated constant naming convention enumerated.constant.naming.convention.element.description: - text: Enumerated constant -final.method.display.name: - text: '''final'' method' -transient.field.in.non.serializable.class.display.name: - text: Transient field in non-serializable class -bad.exception.thrown.display.name: - text: Prohibited exception thrown -conditional.expression.with.identical.branches.display.name: - text: Conditional expression with identical branches -conditional.can.be.pushed.inside.expression.display.name: - text: Conditional can be pushed inside branch expression -conditional.can.be.pushed.inside.expression.option: - text: Ignore when conditional will be only argument of a method call -conditional.can.be.pushed.inside.expression.quickfix: - text: Push conditional expression inside branch -raw.use.of.parameterized.type.display.name: - text: Raw use of parameterized class -standard.variable.names.display.name: - text: Standard variable names -instance.variable.naming.convention.display.name: - text: Instance field naming convention -instance.variable.naming.convention.element.description: - text: Instance field -dollar.sign.in.name.display.name: - text: Use of '$' in identifier -map.replaceable.by.enum.map.display.name: - text: Map replaceable with EnumMap -extends.concrete.collection.display.name: - text: Class explicitly extends a Collection class -continue.or.break.from.finally.block.display.name: - text: '''continue'' or ''break'' inside ''finally'' block' -abstract.method.with.missing.implementations.display.name: - text: Abstract method with missing implementations -object.allocation.in.loop.display.name: - text: Object allocation in loop -wait.called.on.condition.display.name: - text: '''wait()'' called on ''java.util.concurrent.locks.Condition'' object' -test.case.with.no.test.methods.display.name: - text: JUnit test case with no tests -abstract.class.never.implemented.display.name: - text: Abstract class which has no concrete subclass -interface.never.implemented.display.name: - text: Interface which has no concrete subclass -constant.declared.in.interface.display.name: - text: Constant declared in interface + text: Enum constant +enumeration.can.be.iteration.display.name: + text: Enumeration can be iteration +enumeration.can.be.iteration.problem.descriptor: + text: '#ref() can be replaced with ''''{0}'''' construct #loc' +enumeration.can.be.iteration.quickfix: + text: Replace with 'Iterator' construct +equality.operator.compares.objects.descriptor: + text: Objects compared with ''{0}'' +equality.operator.compares.objects.family.quickfix: + text: Replace equality operator with equals() +equality.operator.compares.objects.name: + text: Objects compared with '==' +equality.operator.compares.objects.quickfix: + text: Replace ''{0}'' with ''{1}equals()'' +equality.operator.compares.objects.safe.family.quickfix: + text: Replace equality operator with safe equals() +equality.operator.compares.objects.safe.quickfix: + text: Replace ''{0}'' with safe ''{1}equals()'' +equals.between.inconvertible.types.display.name: + text: '''equals()'' between objects of inconvertible types' +equals.between.inconvertible.types.problem.descriptor: + text: '#ref() between objects of inconvertible types ''''{0}'''' and ''''{1}'''' #loc' +equals.called.on.array.display.name: + text: '''equals()'' called on array' +equals.called.on.array.problem.descriptor: + text: '#ref() between arrays should probably be ''Arrays.equals()'' #loc' +equals.called.on.enum.constant.display.name: + text: '''equals()'' called on enum value' +equals.called.on.enum.constant.problem.descriptor: + text: '#ref() called on enum value #loc' +equals.called.on.enum.constant.quickfix: + text: Replace 'equals()' with '==' +equals.called.on.suspicious.object.display.name: + text: '''equals()'' called on classes which don''t override it' +equals.called.on.suspicious.object.problem.descriptor: + text: Suspicious call to ''equals()'' on ''{0}'' object +equals.doesnt.check.class.parameter.display.name: + text: '''equals()'' method that does not check the class of its parameter' +equals.doesnt.check.class.parameter.problem.descriptor: + text: '#ref() should check the class of its parameter #loc' +equals.hashcode.called.on.url.display.name: + text: '''equals()'' or ''hashCode()'' called on ''java.net.URL'' object' +equals.hashcode.called.on.url.problem.descriptor: + text: 'Call to #ref() on URL object #loc' +equals.replaceable.by.objects.call.display.name: + text: '''equals()'' expression replaceable by ''Objects.equals()'' expression' +equals.replaceable.by.objects.call.problem.descriptor: + text: '#ref replaceable by ''Objects.equals()'' expression #loc' +equals.replaceable.by.objects.call.quickfix: + text: Replace with 'Objects.equals()' expression +equals.replaceable.by.objects.check.not.null.option: + text: Report only null safe 'equals' calls +equals.with.itself.display.name: + text: '''equals()'' called on itself' +equals.with.itself.problem.descriptor: + text: #ref() called on itself +error.rethrown.display.name: + text: '''Error'' not rethrown' +error.rethrown.problem.descriptor: + text: 'Error #ref not rethrown #loc' +exception.class.column.name: + text: Exception class +exception.from.catch.which.doesnt.wrap.display.name: + text: '''throw'' inside ''catch'' block which ignores the caught exception' +exception.from.catch.which.doesnt.wrap.problem.descriptor: + text: '#ref inside ''catch'' block ignores the caught exception #loc' +exception.from.catch.which.doesntwrap.ignore.cant.wrap.option: + text: Ignore if thrown exception cannot wrap an exception +exception.from.catch.which.doesntwrap.ignore.option: + text: Ignore if result of exception method call is used +exception.name.doesnt.end.with.exception.display.name: + text: Exception class name does not end with 'Exception' exception.name.doesnt.end.with.exception.problem.descriptor: - text: 'Exception class name #ref does not end with ''Exception'' #loc' -non.exception.name.ends.with.exception.problem.descriptor: - text: 'Non-exception class name #ref ends with ''Exception'' #loc' -class.name.prefixed.with.package.name.problem.descriptor: - text: 'Class name #ref begins with its package name #loc' -class.name.same.as.ancestor.name.problem.descriptor: - text: 'Class name #ref is the same as one of its superclass'' names #loc' -method.name.same.as.class.name.problem.descriptor: - text: 'Method name #ref is the same as its class name #loc' -method.name.same.as.parent.name.problem.descriptor: - text: 'Method name #ref is the same as its parent class name #loc' -boolean.method.name.must.start.with.question.problem.descriptor: - text: 'Boolean method name #ref does not start with question word #loc' -questionable.name.problem.descriptor: - text: 'Questionable name #ref #loc' -confusing.main.method.problem.descriptor: - text: 'Method named #ref without signature ''public static void main(String[])'' #loc' -upper.case.field.name.not.constant.problem.descriptor: - text: 'Non-constant field #ref with constant-style name #loc' -dollar.sign.in.name.problem.descriptor: - text: 'Identifier #ref contains ''$'' #loc' -integer.division.in.floating.point.context.problem.descriptor: - text: '#ref: integer division in floating-point context #loc' -comparison.of.short.and.char.problem.descriptor: - text: 'Equality comparison #ref of short and char values #loc' -big.decimal.equals.problem.descriptor: - text: '#ref() between BigDecimal values should probably be ''compareTo()'' #loc' -divide.by.zero.problem.descriptor: - text: 'Division by zero #loc' -non.reproducible.math.call.problem.descriptor: - text: 'Math.#ref() may produce non-reproducible results #loc' -constant.math.call.problem.descriptor: - text: 'Constant call to #ref() can be simplified #loc' -floating.point.equality.problem.descriptor: - text: '#ref: floating point values compared for exact equality #loc' + text: 'Exception class name #ref does not end with ''Exception'' #loc' +expected.exception.never.thrown.display.name: + text: Expected exception never thrown in test method body +expected.exception.never.thrown.problem.descriptor: + text: 'Expected #ref never thrown in body of ''''{0}()'''' #loc' +explicit.array.to.string.problem.descriptor: + text: 'Call to ''#ref()'' on array #loc' +expression.can.be.replaced.problem.descriptor: + text: '#ref can be replaced with ''''{0}'''' #loc' +extended.for.statement.display.name: + text: Enhanced 'for' statement +extended.for.statement.problem.descriptor: + text: 'Extended #ref statement #loc' +extended.for.statement.replace.quickfix: + text: Replace with old-style 'for' statement +extends.annotation.display.name: + text: Class extends annotation interface +extends.annotation.interface.problem.descriptor: + text: 'Interface ''''{0}'''' extends annotation interface #ref #loc' +extends.annotation.problem.descriptor: + text: 'Class ''''{0}'''' implements annotation interface #ref #loc' +extends.concrete.collection.display.name: + text: Class explicitly extends a 'Collection' class +extends.concrete.collection.problem.descriptor: + text: 'Class #ref explicitly extends ''''{0}'''' #loc' +extends.object.display.name: + text: Class explicitly extends 'Object' +extends.object.problem.descriptor: + text: 'Class #ref explicitly extends ''java.lang.Object'' #loc' +extends.object.remove.quickfix: + text: Remove redundant 'extends Object' +extends.thread.display.name: + text: Class directly extends 'Thread' +extends.thread.problem.descriptor: + text: 'Class #ref directly extends ''java.lang.Thread'' #loc' +extends.throwable.display.name: + text: Class directly extends 'Throwable' +extends.throwable.problem.descriptor: + text: 'Class #ref directly extends ''java.lang.Throwable'' #loc' +externalizable.with.serialization.methods.display.name: + text: Externalizable class with 'readObject()' or 'writeObject()' +externalizable.with.serialization.methods.problem.descriptor.both: + text: 'Externalizable class #ref defines ''readObject()'' and ''writeObject()'' #loc' +externalizable.with.serialization.methods.problem.descriptor.read: + text: 'Externalizable class #ref defines ''readObject()'' #loc' +externalizable.with.serialization.methods.problem.descriptor.write: + text: 'Externalizable class #ref defines ''writeObject()'' #loc' +externalizable.without.public.no.arg.constructor.display.name: + text: '''Externalizable'' class without ''public'' no-arg constructor' +externalizable.without.public.no.arg.constructor.problem.descriptor: + text: 'Externalizable class #ref has no ''public'' no-arg constructor #loc' +extract.method.quickfix: + text: Extract method +extract.parameter.as.local.variable.quickfix: + text: Extract parameter as local variable +fallthru.in.switch.statement.display.name: + text: Fallthrough in 'switch' statement fallthru.in.switch.statement.problem.descriptor: - text: 'Fallthrough in ''switch'' statement #loc' -switch.statements.without.default.problem.descriptor: - text: '#ref statement without ''default'' branch #loc' -default.not.last.case.in.switch.problem.descriptor: - text: '#ref branch not last case in ''switch'' statement #loc' -loop.statements.that.dont.loop.problem.descriptor: - text: '#ref statement does not loop #loc' -conditional.expression.with.identical.branches.problem.descriptor: - text: 'Conditional expression #ref with identical branches #loc' -conditional.can.be.pushed.inside.expression.problem.descriptor: - text: 'Conditional expression can be pushed inside branch #loc' -if.statement.with.identical.branches.problem.descriptor: - text: '#ref statement with identical branches #loc' -duplicate.condition.problem.descriptor: - text: 'Duplicate condition #ref #loc' -duplicate.condition.ignore.method.calls.option: - text: Ignore conditions with side effects -duplicate.boolean.branch.problem.descriptor: - text: 'Duplicate branch #ref #loc' -iterator.next.does.not.throw.nosuchelementexception.problem.descriptor: - text: 'Iterator.#ref() which can''t throw ''NoSuchElementException'' #loc' -infinite.loop.statement.problem.descriptor: - text: '#ref statement cannot complete without throwing an exception #loc' -confusing.floating.point.literal.problem.descriptor: - text: 'Confusing floating point literal #ref #loc' -overly.complex.arithmetic.expression.problem.descriptor: - text: 'Overly complex arithmetic expression #loc' -overly.complex.boolean.expression.problem.descriptor: - text: 'Overly complex boolean expression ({0} terms) #loc' -labeled.statement.problem.descriptor: - text: 'Labeled statement #ref: #loc' -break.statement.with.label.problem.descriptor: - text: '#ref statement with label #loc' -continue.statement.with.label.problem.descriptor: - text: '#ref statement with label #loc' -conditional.expression.problem.descriptor: - text: 'Conditional expression #ref #loc' -conditional.expression.option: - text: Ignore for simple assignments and returns -nested.conditional.expression.problem.descriptor: - text: 'Nested conditional expression #ref #loc' -long.literals.ending.with.lowercase.l.problem.descriptor: - text: '''long'' literal #ref ends with lowercase ''l'' #loc' -nested.switch.statement.problem.descriptor: - text: 'Nested #ref statement #loc' -chained.method.call.problem.descriptor: - text: 'Chained method call #ref() #loc' -nested.method.call.problem.descriptor: - text: 'Nested method call #ref() #loc' -octal.literal.problem.descriptor: - text: 'Octal integer #ref #loc' -implicit.call.to.super.problem.descriptor: - text: 'Implicit call to ''super()'' #loc' -negated.if.else.problem.descriptor: - text: '#ref statement with negated condition #loc' -negated.conditional.problem.descriptor: - text: 'Conditional expression with negated condition #loc' -redundant.else.problem.descriptor: - text: '#ref branch may be unwrapped, as the ''if'' branch never completes normally #loc' -switch.statement.with.confusing.declaration.problem.descriptor: - text: 'Local variable #ref declared in one ''switch'' branch and used in another #loc' -raw.use.of.parameterized.type.problem.descriptor: - text: 'Raw use of parameterized class #ref #loc' + text: 'Fallthrough in ''switch'' statement #loc' +fallthru.in.switch.statement.quickfix: + text: Add 'break' +feature.envy.display.name: + text: Feature envy +feature.envy.problem.descriptor: + text: 'Class ''''{0}'''' accessed repeatedly in method #ref() #loc' +field.accessed.synchronized.and.unsynchronized.display.name: + text: Field accessed in both 'synchronized' and unsynchronized contexts +field.accessed.synchronized.and.unsynchronized.option: + text: Simple getters and setters are considered field accesses too +field.accessed.synchronized.and.unsynchronized.problem.descriptor: + text: 'Field #ref is accessed in both synchronized and unsynchronized contexts #loc' +field.count.inspection.include.constant.fields.in.count.checkbox: + text: Include constant fields in count +field.count.inspection.include.enum.constants.in.count: + text: Include enum constants in count +field.count.inspection.static.final.fields.count.as.constant.checkbox: + text: '''static final'' fields count as constant' +field.has.setter.but.no.getter.display.name: + text: Field has setter but no getter +field.has.setter.but.no.getter.problem.descriptor: + text: 'Field #ref has setter but no getter #loc' +field.has.static.modifier.problem.descriptor: + text: Field ''{0}'' has ''static'' modifier +field.incorrect.type.problem.descriptor: + text: Field ''{0}'' does not have type ''{1}'' +field.may.be.final.display.name: + text: Field may be 'final' +field.may.be.final.problem.descriptor: + text: 'Field #ref may be ''final'' #loc' +field.may.be.static.display.name: + text: Field can be made 'static' +field.may.be.static.problem.descriptor: + text: 'Field #ref may be ''static'' #loc' +field.missing.volatile.modifier.problem.descriptor: + text: Field ''{0}'' does not have ''volatile'' modifier +field.name.hides.in.superclass.display.name: + text: Subclass field hides superclass field +field.name.hides.in.superclass.ignore.option: + text: Ignore non-accessible fields +field.name.hides.in.superclass.problem.descriptor: + text: 'Field #ref hides field in superclass #loc' +field.not.found.in.class.problem.descriptor: + text: No field named ''{0}'' found in class ''{1}'' +final.class.display.name: + text: Class is closed to inheritance final.class.problem.descriptor: - text: 'Class declared #ref #loc' -empty.class.problem.descriptor: - text: 'Class #ref is empty #loc' -empty.class.file.without.class.problem.descriptor: - text: 'Java file does not declare any class #loc' -empty.anonymous.class.problem.descriptor: - text: 'Anonymous class is empty #loc' -anonymous.inner.class.problem.descriptor: - text: 'Anonymous inner class #ref #loc' -limited.scope.inner.class.problem.descriptor: - text: 'Limited-scope inner class #ref #loc' -final.method.problem.descriptor: - text: 'Method declared #ref #loc' -class.initializer.problem.descriptor: - text: 'Non-''static'' initializer #loc' -class.may.be.interface.problem.descriptor: - text: 'Abstract class #ref may be interface #loc' -non.protected.constructor.in.abstract.class.problem.descriptor: - text: 'Constructor #ref() is not declared ''protected'' in ''abstract'' class #loc' -class.without.constructor.problem.descriptor: - text: 'Class #ref has no constructor #loc' -abstract.class.without.abstract.methods.problem.descriptor: - text: 'Class #ref is declared ''abstract'', and has no ''abstract'' methods #loc' + text: 'Class declared #ref #loc' +final.method.display.name: + text: Method can't be overridden +final.method.in.final.class.display.name: + text: '''final'' method in ''final'' class' final.method.in.final.class.problem.descriptor: - text: 'Method declared #ref in ''final'' class #loc' -protected.member.in.final.class.problem.descriptor: - text: 'Class member declared #ref in ''final'' class #loc' -utility.class.with.public.constructor.problem.descriptor: - text: 'Class #ref has only ''static'' members, and a ''public'' constructor #loc' -utility.class.without.private.constructor.problem.descriptor: - text: 'Class #ref has only ''static'' members, and lacks a ''private'' constructor #loc' -abstract.method.overrides.concrete.method.problem.descriptor: - text: 'Abstract method #ref() overrides concrete method #loc' -abstract.method.with.missing.implementations.problem.descriptor: - text: 'Abstract method #ref() is not implemented in every subclass #loc' -abstract.method.overrides.abstract.method.problem.descriptor: - text: 'Abstract method #ref() overrides abstract method #loc' -abstract.method.overrides.abstract.method.ignore.different.javadoc.option: - text: Ignore methods with different Javadoc than their super methods -abstract.method.overrides.abstract.method.ignore.different.annotations.option: - text: Ignore methods with different annotations than their super methods -abstract.class.extends.concrete.class.problem.descriptor: - text: 'Class #ref is declared ''abstract'', and extends a concrete class #loc' -static.non.final.field.problem.descriptor: - text: '''static'' non-''final'' field #ref #loc' -constant.declared.in.abstract.class.problem.descriptor: - text: 'Constant #ref declared in abstract class #loc' -constant.declared.in.interface.problem.descriptor: - text: 'Constant #ref declared in interface #loc' -static.inheritance.problem.descriptor: - text: 'Interface #ref is implemented only for its ''static'' constants #loc' -utility.class.problem.descriptor: - text: 'Class #ref has only ''static'' members, indicating procedural construction #loc' -singleton.problem.descriptor: - text: 'Class #ref is a singleton #loc' + text: 'Method declared #ref in ''final'' class #loc' +final.method.problem.descriptor: + text: 'Method declared #ref #loc' +final.private.method.display.name: + text: '''private'' method declared ''final''' final.private.method.problem.descriptor: - text: '''private'' method declared #ref #loc' -noop.method.in.abstract.class.problem.descriptor: - text: 'No-op Method #ref() should be made abstract #loc' + text: '''private'' method declared #ref #loc' +final.static.method.display.name: + text: '''static'' method declared ''final''' final.static.method.problem.descriptor: - text: '''static'' method declared #ref #loc' -class.without.no.arg.constructor.problem.descriptor: - text: '#ref has no no-arg constructor #loc' -multiple.top.level.classes.in.file.problem.descriptor: - text: Multiple top level classes in file -class.name.differs.from.file.name.problem.descriptor: - text: 'Class name #ref differs from file name #loc' -marker.interface.problem.descriptor: - text: 'Marker interface #ref #loc' -field.has.setter.but.no.getter.problem.descriptor: - text: 'Field #ref has setter but no getter #loc' -abstract.class.never.implemented.problem.descriptor: - text: 'Abstract class #ref has no concrete subclass #loc' -interface.never.implemented.problem.descriptor: - text: 'Interface #ref has no concrete subclass #loc' -missing.deprecated.annotation.problem.descriptor: - text: 'Missing ''@Deprecated'' annotation #loc' -missing.deprecated.tag.problem.descriptor: - text: 'Missing ''@deprecated'' Javadoc tag explanation #loc' -missing.deprecated.tag.option: - text: Warn on missing @deprecated Javadoc tag explanation -missing.override.annotation.problem.descriptor: - text: 'Missing ''@Override'' annotation on #ref() #loc' -non.thread.safe.lazy.initialization.problem.descriptor: - text: 'Lazy initialization of ''static'' field #ref is not thread-safe #loc' -empty.catch.block.problem.descriptor: - text: 'Empty #ref block #loc' -unused.catch.parameter.problem.descriptor: - text: 'Unused ''catch'' parameter #ref #loc' -used.catch.parameter.named.ignore.problem.descriptor: - text: '''catch'' parameter named #ref is used #loc' -empty.finally.block.problem.descriptor: - text: 'Empty #ref block #loc' + text: '''static'' method declared #ref #loc' +finalize.called.explicitly.display.name: + text: '''finalize()'' called explicitly' +finalize.called.explicitly.problem.descriptor: + text: '#ref() called explicitly #loc' +finalize.declaration.display.name: + text: '''finalize()'' should not be overridden' +finalize.declaration.problem.descriptor: + text: '''finalize()'' should not be overridden #loc' +finalize.not.declared.protected.display.name: + text: '''finalize()'' should be protected, not public' +finalize.not.declared.protected.problem.descriptor: + text: '''finalize()'' should have protected access, not public #loc' +finally.block.cannot.complete.normally.display.name: + text: '''finally'' block which can not complete normally' finally.block.cannot.complete.normally.problem.descriptor: - text: '#ref block can not complete normally #loc' -empty.try.block.problem.descriptor: - text: 'Empty #ref block #loc' -throw.from.finally.block.problem.descriptor: - text: '#ref inside ''finally'' block #loc' -possible.throw.from.finally.block.problem.descriptor: - text: '{0} might be thrown inside ''''finally'''' block #loc' -throw.from.finally.block.everywhere.option: - text: Warn everywhere declared exceptions may be thrown -throw.caught.locally.problem.descriptor: - text: '#ref caught by containing ''try'' statement #loc' -throw.caught.locally.ignore.option: - text: Ignore rethrown exceptions -return.from.finally.block.problem.descriptor: - text: '#ref inside ''finally'' block #loc' -continue.or.break.from.finally.block.problem.descriptor: - text: '#ref inside ''finally'' block #loc' -bad.exception.declared.problem.descriptor: - text: 'Prohibited exception #ref declared #loc' -bad.exception.caught.problem.descriptor: - text: 'Prohibited exception #ref caught #loc' -checked.exception.class.problem.descriptor: - text: 'Checked exception class #ref #loc' -unchecked.exception.class.problem.descriptor: - text: 'Unchecked exception class #ref #loc' -thread.death.rethrown.problem.descriptor: - text: 'ThreadDeath #ref not rethrown #loc' -error.rethrown.problem.descriptor: - text: 'Error #ref not rethrown #loc' -nested.try.statement.problem.descriptor: - text: 'Nested #ref statement #loc' -exception.from.catch.which.doesnt.wrap.problem.descriptor: - text: '#ref inside ''catch'' block ignores the caught exception #loc' -instanceof.catch.parameter.problem.descriptor: - text: '''instanceof'' on ''catch'' parameter #ref #loc' -non.final.field.of.exception.problem.descriptor: - text: 'Non-final field #ref of exception class #loc' -unnecessary.label.on.break.statement.problem.descriptor: - text: 'Unnecessary label on #ref statement #loc' -unnecessary.label.on.continue.statement.problem.descriptor: - text: 'Unnecessary label on #ref statement #loc' -trivial.if.problem.descriptor: - text: '#ref statement can be simplified #loc' -constant.if.statement.problem.descriptor: - text: '#ref statement can be simplified #loc' -unnecessary.parentheses.problem.descriptor: - text: 'Parentheses around #ref are unnecessary #loc' -unnecessary.local.variable.problem.descriptor: - text: 'Local variable #ref is redundant #loc' -unnecessary.this.problem.descriptor: - text: '#ref is unnecessary in this context #loc' -unnecessary.block.statement.problem.descriptor: - text: 'Braces around this statement are unnecessary #loc' -unnecessary.continue.problem.descriptor: - text: '#ref is unnecessary as the last statement in a loop #loc' -unnecessary.semicolon.problem.descriptor: - text: 'Unnecessary semicolon #ref #loc' -unnecessary.fully.qualified.name.problem.descriptor1: - text: 'Qualifier #ref is unnecessary, and can be replaced with an import #loc' -unnecessary.fully.qualified.name.problem.descriptor2: - text: 'Qualifier #ref is unnecessary and can be removed #loc' -unnecessary.qualifier.for.this.problem.descriptor: - text: 'Qualifier #ref on ''this'' is unnecessary in this context #loc' -unnecessary.qualifier.for.super.problem.descriptor: - text: 'Qualifier #ref on ''super'' is unnecessary in this context #loc' -unused.label.problem.descriptor: - text: 'Unused label #ref #loc' -redundant.field.initialization.problem.descriptor: - text: 'Field initialization to #ref is redundant #loc' -redundant.implements.problem.descriptor: - text: 'Redundant interface declaration #ref #loc' -extends.object.problem.descriptor: - text: 'Class #ref explicitly extends ''java.lang.Object'' #loc' -type.parameter.extends.object.problem.descriptor1: - text: 'Type parameter #ref explicitly extends ''java.lang.Object'' #loc' -type.parameter.extends.object.problem.descriptor2: - text: 'Wildcard type argument #ref explicitly extends ''java.lang.Object'' #loc' -unnecessary.super.constructor.problem.descriptor: - text: '#ref is unnecessary #loc' -unnecessary.constructor.problem.descriptor: - text: 'No-arg constructor #ref() is redundant #loc' -unnecessary.constructor.annotation.option: - text: Ignore constructors with an annotation -for.loop.replaceable.by.while.problem.descriptor: - text: '#ref loop statement may be replace by ''while'' loop #loc' -unnecessary.default.problem.descriptor: - text: '#ref branch is unnecessary #loc' -unnecessary.boxing.problem.descriptor: - text: 'Unnecessary boxing #ref #loc' -unnecessary.unboxing.problem.descriptor: - text: 'Unnecessary unboxing #ref #loc' -unnecessary.boxing.superfluous.option: - text: Only report truly superfluously boxed expressions -unnecessary.unboxing.superfluous.option: - text: Only report truly superfluously unboxed expressions + text: '#ref block can not complete normally #loc' +flip.comparison.quickfix: + text: Flip comparison +floating.point.equality.display.name: + text: Floating-point equality comparison +floating.point.equality.problem.descriptor: + text: '#ref: floating-point values compared for exact equality #loc' +for.can.be.foreach.display.name: + text: '''for'' loop can be replaced with enhanced for loop' +for.can.be.foreach.option: + text: Report indexed 'java.util.List' loops +for.can.be.foreach.option2: + text: Do not report iterations over untyped collections for.can.be.foreach.problem.descriptor: - text: '#ref loop replaceable with ''foreach'' #loc' -while.can.be.foreach.problem.descriptor: - text: '#ref loop replaceable with ''foreach'' #loc' -too.broad.scope.problem.descriptor: - text: 'Scope of variable #ref is too broad #loc' -return.this.problem.descriptor: - text: 'Return of #ref #loc' -constant.on.lhs.of.comparison.problem.descriptor: - text: '#ref: constant on left side of comparison #loc' -constant.on.rhs.of.comparison.problem.descriptor: - text: '#ref: constant on right side of comparison #loc' -control.flow.statement.without.braces.problem.descriptor: - text: '{0} without braces #loc' -missorted.modifiers.problem.descriptor: - text: 'Missorted modifiers #ref #loc' -cstyle.array.variable.declaration.problem.descriptor: - text: 'C-style array declaration of {0, choice, 1#field|2#parameter|3#local variable} #ref #loc' -cstyle.array.method.declaration.problem.descriptor: - text: C-style array declaration of the return type of method #ref()#loc -multiple.declaration.problem.descriptor: - text: 'Multiple variables in one declaration #loc' -multiple.typed.declaration.problem.descriptor: - text: 'Variables of different types in one declaration #loc' -serializable.inner.class.has.serial.version.uid.field.problem.descriptor: - text: 'Inner class #ref does not define a ''serialVersionUID'' field #loc' -serializable.inner.class.with.non.serializable.outer.class.problem.descriptor: - text: 'Inner class #ref is serializable while its outer class is not #loc' -busy.wait.problem.descriptor: - text: 'Call to Thread.#ref() in a loop, probably busy-waiting #loc' -sleep.while.holding.lock.problem.descriptor: - text: 'Call to Thread.#ref() while synchronized #loc' -non.atomic.operation.on.volatile.field.problem.descriptor: - text: 'Non-atomic operation on volatile field #ref #loc' -call.to.native.method.while.locked.problem.descriptor: - text: 'Call to native method #ref() in a synchronized context #loc' -object.notify.problem.descriptor: - text: '#ref should probably be replaced with ''notifyAll()'' #loc' -condition.signal.problem.descriptor: - text: '#ref should probably be replaced with ''signalAll()'' #loc' -thread.with.default.run.method.problem.descriptor: - text: 'Instantiating a #ref with default ''run()'' method #loc' -extends.thread.problem.descriptor: - text: 'Class #ref directly extends ''java.lang.Thread'' #loc' -anonymous.extends.thread.problem.descriptor: - text: 'Anonymous class directly extends ''java.lang.Thread'' #loc' -naked.notify.problem.descriptor: - text: 'Call to #ref() without corresponding state change #loc' -unconditional.wait.problem.descriptor: - text: 'Unconditional call to #ref() #loc' -system.run.finalizers.on.exit.problem.descriptor: - text: 'Call to System.#ref() #loc' -thread.priority.problem.descriptor: - text: 'Call to Thread.#ref() #loc' -thread.yield.problem.descriptor: - text: 'Call to Thread.#ref() #loc' -thread.stop.suspend.resume.problem.descriptor: - text: 'Call to Thread.#ref() #loc' -while.loop.spins.on.field.problem.descriptor: - text: '#ref loop spins on field #loc' -wait.not.in.loop.problem.descriptor: - text: 'Call to #ref() is not made in a loop #loc' -await.not.in.loop.problem.descriptor: - text: 'Call to #ref() is not made in a loop #loc' -wait.called.on.condition.problem.descriptor: - text: 'Call to #ref() on Condition object #loc' -notify.called.on.condition.problem.descriptor: - text: 'Call to #ref() on Condition object #loc' -wait.while.holding.two.locks.problem.descriptor: - text: 'Call to #ref() is made while holding two locks #loc' -thread.run.problem.descriptor: - text: 'Calls to #ref() should probably be replaced with ''start()'' #loc' -thread.start.in.construction.problem.descriptor: - text: 'Call to #ref during object construction #loc' -synchronize.on.lock.problem.descriptor: - text: 'Synchronization on a ''''{0}'''' object is unlikely to be intentional #loc' -synchronized.on.literal.object.problem.descriptor: - text: 'Synchronization on {0} #ref which is initialized by a literal #loc' -synchronized.on.direct.literal.object.problem.descriptor: - text: 'Synchronization on {0} literal #ref #loc' -synchronized.on.possibly.literal.object.problem.descriptor: - text: 'Synchronization on {0} #ref #loc' -synchronize.on.non.final.field.problem.descriptor: - text: 'Synchronization on a non-final field #ref #loc' -synchronized.on.literal.object.warn.on.all.option: - text: Warn on all possible literals -synchronize.on.this.problem.descriptor: - text: 'Lock operations on ''this'' may have unforeseen side-effects #loc' -synchronize.on.class.problem.descriptor: - text: 'Lock operations on a class may have unforeseen side-effects #loc' -nested.synchronized.statement.problem.descriptor: - text: 'Nested #ref statement #loc' -empty.synchronized.statement.problem.descriptor: - text: 'Empty #ref statement #loc' -non.synchronized.method.overrides.synchronized.method.problem.descriptor: - text: 'Unsynchronized method #ref() overrides synchronized method #loc' -public.field.accessed.in.synchronized.context.problem.descriptor: - text: 'Non-private field #ref accessed in synchronized context #loc' -field.accessed.synchronized.and.unsynchronized.problem.descriptor: - text: 'Field #ref is accessed in both synchronized and unsynchronized contexts #loc' -extended.for.statement.problem.descriptor: - text: 'Extended #ref statement #loc' -object.allocation.in.loop.problem.descriptor: - text: 'Object allocation new #ref() in loop #loc' -instantiating.object.to.get.class.object.problem.descriptor: - text: 'Instantiating object to get Class object #loc' -field.may.be.static.problem.descriptor: - text: 'Field #ref may be ''static'' #loc' -method.may.be.static.problem.descriptor: - text: 'Method #ref() may be ''static'' #loc' -class.initializer.may.be.static.problem.descriptor: - text: 'Class initializer may be ''static'' #loc' -map.replaceable.by.enum.map.problem.descriptor: - text: '#ref replaceable with ''EnumMap'' #loc' -set.replaceable.by.enum.set.problem.descriptor: - text: '#ref replaceable with ''EnumSet'' #loc' -inner.class.may.be.static.problem.descriptor: - text: 'Inner class #ref may be ''static'' #loc' -string.buffer.must.have.initial.capacity.problem.descriptor: - text: 'new #ref() without initial capacity #loc' -string.buffer.replaceable.by.string.builder.problem.descriptor: - text: 'StringBuffer #ref may be declared as ''StringBuilder'' #loc' -string.buffer.replaceable.by.string.problem.descriptor: - text: '{0} #ref can be replaced with ''''String'''' #loc' -new.string.buffer.replaceable.by.string.problem.descriptor: - text: '#ref can be replaced with ''String'' #loc' -string.replaceable.by.string.buffer.problem.descriptor: - text: 'Non-constant String #ref should probably be declared as ''''StringBuilder'''' #loc' -collections.must.have.initial.capacity.problem.descriptor: - text: 'new #ref() without initial capacity #loc' -string.concatenation.in.loops.problem.descriptor: - text: 'String concatenation #ref in loop #loc' -string.concatenation.inside.string.buffer.append.problem.descriptor: - text: 'String concatenation as argument to {0}.#ref() call #loc' -boolean.constructor.problem.descriptor: - text: 'Boolean constructor call #loc' -string.to.string.problem.descriptor: - text: '#ref is redundant #loc' -substring.zero.problem.descriptor: - text: '#ref is redundant #loc' -string.buffer.to.string.in.concatenation.problem.descriptor: - text: 'Calls to StringBuffer.#ref() in concatenation #loc' -tail.recursion.problem.descriptor: - text: 'Tail recursive call #ref() #loc' -string.equals.empty.string.problem.descriptor: - text: '#ref("") can be replaced with ''length()==0'' #loc' -string.equals.empty.string.is.empty.problem.descriptor: - text: '#ref("") can be replaced with ''isEmpty()'' #loc' -random.double.for.random.integer.problem.descriptor: - text: 'Using Random.#ref to create random integer #loc' -manual.array.copy.problem.descriptor: - text: 'Manual array copy #loc' -manual.array.to.collection.copy.problem.descriptor: - text: 'Manual array to collection copy #loc' -call.to.simple.getter.in.class.problem.descriptor: - text: 'Call to simple getter #ref() from within class #loc' -call.to.simple.setter.in.class.problem.descriptor: - text: 'Call to simple setter #ref() from within class #loc' -asserts.without.messages.problem.descriptor: - text: 'JUnit #ref() without message #loc' -test.case.with.constructor.problem.descriptor: - text: 'Initialization logic in constructor #ref() instead of ''setUp()'' #loc' -test.case.with.constructor.problem.descriptor.initializer: - text: Initialization logic in initializer instead of 'setUp()' -misordered.assert.equals.arguments.problem.descriptor: - text: 'Arguments to #ref() in wrong order #loc' -static.suite.problem.descriptor: - text: 'JUnit #ref() methods not declared ''static'' #loc' -simplifiable.junit.assertion.problem.descriptor: - text: '#ref() can be simplified to ''''{0}'''' #loc' -test.method.without.assertion.problem.descriptor: - text: 'JUnit test method #ref() contains no assertions #loc' -test.case.with.no.test.methods.problem.descriptor: - text: 'JUnit test case #ref has no tests #loc' -test.case.in.product.code.problem.descriptor: - text: 'Test case #ref should probably be placed in a test source tree #loc' -test.method.in.product.code.problem.descriptor: - text: 'Test method #ref() should probably be placed in a test source tree #loc' -unconstructable.test.case.problem.descriptor: - text: 'Test case #ref is not constructable by most test runners #loc' -deserializable.class.in.secure.context.problem.descriptor: - text: 'Class #ref may be deserialized, compromising security #loc' -serializable.class.in.secure.context.problem.descriptor: - text: 'Class #ref may be serialized, compromising security #loc' -cloneable.class.in.secure.context.problem.descriptor: - text: 'Class #ref may be cloned, compromising security #loc' -non.final.clone.problem.descriptor: - text: 'Non-final #ref() method, compromising security #loc' -non.static.inner.class.in.secure.context.problem.descriptor: - text: 'Non-''static'' inner class #ref, compromising security #loc' -runtime.exec.with.non.constant.string.problem.descriptor: - text: 'Call to Runtime.#ref() with non-constant argument #loc' -load.library.with.non.constant.string.problem.descriptor: - text: 'Call to {0}.#ref() with non-constant argument #loc' -jdbc.execute.with.non.constant.string.problem.descriptor: - text: 'Call to Statement.#ref() with non-constant argument #loc' -jdbc.prepare.statement.with.non.constant.string.problem.descriptor: - text: 'Call to Connection.#ref() with non-constant argument #loc' -custom.classloader.problem.descriptor: - text: 'Custom ClassLoader class #ref #loc' -custom.security.manager.problem.descriptor: - text: 'Custom SecurityManager class #ref #loc' -system.set.problem.descriptor: - text: 'Call to System.#ref() may pose security concerns #loc' -class.loader.instantiation.problem.descriptor: - text: 'Instantiation of #ref may pose security concerns #loc' -public.static.array.field.problem.descriptor: - text: '''public static'' array field #ref, compromising security #loc' -public.static.collection.field.problem.descriptor: - text: '''public static'' collection field #ref, compromising security #loc' -abstract.class.with.only.one.direct.inheritor.problem.descriptor: - text: 'Abstract class #ref has only one direct inheritor #loc' -abstract.method.overrides.abstract.method.remove.quickfix: - text: Remove redundant abstract method declaration -class.may.be.interface.convert.quickfix: - text: Convert class to interface -class.without.constructor.create.quickfix: - text: Generate empty constructor -class.without.no.arg.constructor.ignore.option: - text: Ignore if class has default constructor -extends.annotation.problem.descriptor: - text: 'Class ''''{0}'''' implements annotation interface #ref #loc' -extends.annotation.interface.problem.descriptor: - text: 'Interface ''''{0}'''' extends annotation interface #ref #loc' -extends.concrete.collection.problem.descriptor: - text: 'Class #ref explicitly extends ''''{0}'''' #loc' -anonymous.extends.concrete.collection.problem.descriptor: - text: 'Anonymous class explicitly extends ''''{0}'''' #loc' -inner.class.on.interface.ignore.option: - text: Ignore inner interfaces of interfaces -inner.class.on.interface.problem.descriptor: - text: 'Interface ''''{0}'''' has inner class #ref #loc' -missing.deprecated.annotation.add.quickfix: - text: Add @Deprecated annotation -missing.override.annotation.add.quickfix: - text: Add @Override annotation -non.protected.constructor.in.abstract.class.ignore.option: - text: Ignore for non-public classes -public.constructor.in.non.public.class.problem.descriptor: - text: 'Constructor is declared #ref in non-public class ''''{0}'''' #loc' -static.inheritance.replace.quickfix: - text: Replace inheritance with qualified references in {0} -utility.class.with.public.constructor.make.quickfix: - text: Make {0, choice, 1#constructor|2#constructors} 'private' -utility.class.without.private.constructor.create.quickfix: - text: Generate empty 'private' constructor -utility.class.without.private.constructor.make.quickfix: - text: Make constructor 'private' -naming.convention.problem.descriptor.short: - text: '{0} name #ref is too short ({1} < {2}) #loc' -naming.convention.problem.descriptor.long: - text: '{0} name #ref is too long ({1} > {2}) #loc' -naming.convention.problem.descriptor.regex.mismatch: - text: '{0} name #ref doesn''''t match regex ''''{1}'''' #loc' -constant.naming.convention.immutables.option: - text: Only check 'static final' fields with immutable types -local.variable.naming.convention.ignore.option: - text: Ignore for-loop parameters -local.variable.naming.convention.ignore.catch.option: - text: Ignore 'catch' block parameters -method.names.differ.only.by.case.problem.descriptor: - text: 'Method name #ref and method name ''''{0}'''' differ only by case #loc' -parameter.name.differs.from.overridden.parameter.ignore.character.option: - text: Ignore if overridden parameter contains only one character -parameter.name.differs.from.overridden.parameter.ignore.library.option: - text: Ignore if overridden parameter is from a library -parameter.name.differs.from.overridden.parameter.problem.descriptor: - text: 'Parameter name #ref is different from parameter ''''{0}'''' overridden #loc' -questionable.name.column.title: - text: Name -standard.variable.names.problem.descriptor: - text: 'Variable named #ref doesn''''t have type ''''{0}'''' #loc' -standard.variable.names.problem.descriptor2: - text: 'Variable named #ref doesn''''t have type ''''{0}'''' or ''''{1}'''' #loc' -standard.variable.names.ignore.override.option: - text: Ignore for parameter names identical to super method parameters -static.variable.naming.convention.mutable.option: - text: Check 'static final' fields with a mutable type -boolean.method.name.must.start.with.question.table.column.name: - text: Boolean method name prefix -conditional.expression.with.identical.branches.collapse.quickfix: - text: Collapse conditional expression -redundant.else.unwrap.quickfix: - text: Remove redundant 'else' -constant.conditional.expression.problem.descriptor: - text: '#ref can be simplified to ''''{0}'''' #loc' -constant.conditional.expression.simplify.quickfix: - text: Simplify -enum.switch.statement.which.misses.cases.problem.descriptor: - text: '#ref statement on enumerated type ''''{0}'''' misses cases #loc' + text: '#ref loop can be replaced with enhanced ''for'' #loc' +for.loop.not.use.loop.variable.display.name: + text: '''for'' loop where update or condition does not use loop variable' +for.loop.not.use.loop.variable.problem.descriptor.both.condition.and.update: + text: '#ref statement has condition and update which do not use the for loop variable #loc' +for.loop.not.use.loop.variable.problem.descriptor.condition: + text: '#ref statement has condition which does not use the for loop variable #loc' +for.loop.not.use.loop.variable.problem.descriptor.update: + text: '#ref statement has update which does not use the for loop variable #loc' +for.loop.replaceable.by.while.display.name: + text: '''for'' loop may be replaced with ''while'' loop' for.loop.replaceable.by.while.ignore.option: - text: Ignore 'infinite' for loops without conditions + text: Ignore 'infinite' for loops without conditions +for.loop.replaceable.by.while.problem.descriptor: + text: '#ref loop statement may be replace by ''while'' loop #loc' for.loop.replaceable.by.while.replace.quickfix: - text: Replace with 'while' + text: Replace with 'while' +for.loop.with.missing.component.collection.loop.option: + text: Ignore collection iterations +for.loop.with.missing.component.display.name: + text: '''for'' loop with missing components' for.loop.with.missing.component.problem.descriptor1: - text: '#ref statement lacks initializer #loc' + text: '#ref statement lacks initializer #loc' for.loop.with.missing.component.problem.descriptor2: - text: '#ref statement lacks condition #loc' + text: '#ref statement lacks condition #loc' for.loop.with.missing.component.problem.descriptor3: - text: '#ref statement lacks update #loc' + text: '#ref statement lacks update #loc' for.loop.with.missing.component.problem.descriptor4: - text: '#ref statement lacks initializer and condition #loc' + text: '#ref statement lacks initializer and condition #loc' for.loop.with.missing.component.problem.descriptor5: - text: '#ref statement lacks initializer and update #loc' + text: '#ref statement lacks initializer and update #loc' for.loop.with.missing.component.problem.descriptor6: - text: '#ref statement lacks condition and update #loc' + text: '#ref statement lacks condition and update #loc' for.loop.with.missing.component.problem.descriptor7: - text: '#ref statement lacks initializer, condition and update #loc' -if.statement.with.identical.branches.collapse.quickfix: - text: Collapse 'if' statement + text: '#ref statement lacks initializer, condition and update #loc' foreach.replace.quickfix: - text: Replace with 'foreach' -unnecessary.boxing.remove.quickfix: - text: Remove boxing -unnecessary.unboxing.remove.quickfix: - text: Remove unboxing -misordered.assert.equals.arguments.flip.quickfix: - text: Flip compared arguments -simplify.junit.assertion.simplify.quickfix: - text: Simplify assertion -test.method.is.public.void.no.arg.problem.descriptor1: - text: 'Test method #ref() should probably not have parameters #loc' -test.method.is.public.void.no.arg.problem.descriptor2: - text: 'Test method #ref() is not declared ''public void'' #loc' -test.method.is.public.void.no.arg.problem.descriptor3: - text: 'Test method #ref() should not be ''static'' #loc' -system.properties.problem.descriptor: - text: 'Call to Integer.#ref() may pose security concerns #loc' -system.properties.problem.descriptor1: - text: 'Call to Boolean.#ref() may pose security concerns #loc' -unsecure.random.number.generation.problem.descriptor1: - text: 'For security purposes, use ''java.security.SecureRandom'' instead of java.lang.Math.#ref() #loc' -unsecure.random.number.generation.problem.descriptor2: - text: 'For security purposes, use ''java.security.SecureRandom'' instead of java.util.#ref #loc' -unsecure.random.number.generation.problem.descriptor3: - text: 'For security purposes, use ''java.security.SecureRandom'' instead of #ref #loc' -serializable.has.serialization.methods.problem.descriptor: - text: 'Serializable class #ref does not define ''readObject()'' or ''writeObject()'' #loc' -serializable.has.serialization.methods.problem.descriptor1: - text: 'Serializable class #ref does not define ''writeObject()'' #loc' -serializable.has.serialization.methods.problem.descriptor2: - text: 'Serializable class #ref does not define ''readObject()'' #loc' -serializable.with.unconstructable.ancestor.problem.descriptor: - text: '#ref has a non-serializable ancestor ''''{0}'''' without no-arg constructor #loc' -transient.field.in.non.serializable.class.problem.descriptor: - text: 'Field ''''{0}'''' is marked #ref, in non-Serializable class #loc' -transient.field.in.non.serializable.class.remove.quickfix: - text: Remove 'transient' -condition.signal.replace.quickfix: - text: Replace with 'signalAll()' -object.notify.replace.quickfix: - text: Replace with 'notifyAll()' -safe.lock.problem.descriptor: - text: '''''{0}'''' should be locked in front of a ''''try'''' block and unlocked in the corresponding ''''finally'''' block #loc' -synchronized.method.problem.descriptor: - text: 'Method ''''{0}()'''' declared #ref #loc' -synchronized.method.include.option: - text: Include native methods -synchronized.method.ignore.synchronized.super.option: - text: Ignore methods overriding a synchronized method -synchronized.method.move.quickfix: - text: Move synchronization into method -thread.run.replace.quickfix: - text: Replace with 'start()' -volatile.field.problem.descriptor: - text: 'Volatile field #ref of type ''''{0}'''' #loc' -string.format.choose.class: - text: Choose Formatter class -string.format.class.column.name: - text: Additional formatter classes -string.format.class.method.name: - text: Additional formatter methods -exception.class.column.name: - text: Exception class -bad.exception.thrown.problem.descriptor: - text: 'Prohibited exception ''''{0}'''' thrown #loc' -empty.catch.block.comments.option: - text: Comments count as content -empty.catch.block.ignore.ignore.option: - text: Ignore when 'catch' parameter is named 'ignore' or 'ignored' -too.broad.catch.problem.descriptor: - text: '''''catch'''' of #ref is too broad, masking exception ''''{0}'''' #loc' -too.broad.catch.problem.descriptor1: - text: '''''catch'''' of #ref is too broad, masking exceptions ''''{0}'''' and ''''{1}'''' #loc' -unused.catch.parameter.ignore.catch.option: - text: Ignore when 'catch' block contains a comment -add.serialversionuidfield.quickfix: - text: Add 'serialVersionUID' field -delete.import.quickfix: - text: Delete unnecessary import -encapsulate.variable.quickfix: - text: Encapsulate field ''{0}'' -extract.method.quickfix: - text: Extract method -inline.call.quickfix: - text: Inline call -inline.variable.quickfix: - text: Inline variable -pointless.nullcheck.display.name: - text: Unnecessary 'null' check before 'instanceof' expression -pointless.nullcheck.problem.descriptor: - text: Unnecessary 'null' check before 'instanceof' expression -pointless.nullcheck.after.problem.descriptor: - text: Unnecessary 'null' check after 'instanceof' expression -pointless.nullcheck.simplify.quickfix: - text: Remove unnecessary ''{0}'' condition -introduce.constant.quickfix: - text: Introduce constant -make.initialization.explicit.quickfix: - text: Make initialization explicit -move.anonymous.to.inner.quickfix: - text: Convert to named inner class -anonymous.inner.may.be.named.static.inner.class.quickfix: - text: Convert to named 'static' inner class -move.class.quickfix: - text: Move class -normalize.declaration.quickfix: - text: Split into multiple declarations -remove.modifier.quickfix: - text: Remove ''{0}'' modifier -replace.inheritance.with.delegation.quickfix: - text: Replace inheritance with delegation -big.decimal.equals.replace.quickfix: - text: Replace with 'compareTo()==0' -cast.that.loses.precision.problem.descriptor: - text: 'Cast from ''''{0}'''' to #ref may result in loss of precision #loc' -cast.that.loses.precision.negative.problem.descriptor: - text: 'Cast from ''''{0}'''' to #ref may result in loss of precision for negative argument #loc' -comparison.to.nan.problem.descriptor1: - text: 'Comparison to #ref is always false #loc' -comparison.to.nan.problem.descriptor2: - text: 'Comparison to #ref is always true #loc' -comparison.to.nan.replace.quickfix: - text: Replace with 'isNaN()' -confusing.floating.point.literal.change.quickfix: - text: Change to canonical form -implicit.numeric.conversion.ignore.widening.conversion.option: - text: Ignore widening conversions + text: Replace with enhanced 'for' +format.decode.any: + text: any +format.decode.char: + text: char +format.decode.date.time: + text: Date/Time +format.decode.error.requires.both.0.and.1: + text: requires both {0} and {1} +format.decode.floating.point: + text: floating point +format.decode.integer.type: + text: integer type +gc.call.display.name: + text: Call to 'System.gc()' or 'Runtime.gc()' +gc.call.problem.descriptor: + text: '#ref should not be called in production code #loc' +hardcoded.file.separator.display.name: + text: Hardcoded file separator +hardcoded.file.separator.include.option: + text: Include 'example/*' in recognized MIME media types +hardcoded.file.separator.problem.descriptor: + text: 'Hardcoded file separator #ref #loc' +hardcoded.line.separator.display.name: + text: Hardcoded line separator +hardcoded.line.separator.problem.descriptor: + text: 'Hardcoded line separator #ref #loc' +hibernate.resource.opened.not.closed.display.name: + text: Hibernate resource opened but not safely closed +html.tag.can.be.javadoc.tag.display.name: + text: '''…'' can be replaced with ''{@code …}''' +html.tag.can.be.javadoc.tag.problem.descriptor: + text: '#ref…\</code\> can be replaced with ''{@code …}'' #loc' +html.tag.can.be.javadoc.tag.quickfix: + text: Replace with '{@code ...}' +i.o.resource.opened.not.closed.display.name: + text: I/O resource opened but not safely closed +if.can.be.assertion.name: + text: If statement can be replaced with assertion +if.can.be.assertion.quickfix: + text: Replace 'if' with 'assert' statement +if.can.be.switch.display.name: + text: '''if'' can be replaced with ''switch''' +if.can.be.switch.enum.option: + text: Suggest switch on enums +if.can.be.switch.int.option: + text: Suggest switch on numbers +if.can.be.switch.minimum.branch.option: + text: 'Minimum number of ''if'' condition branches:' +if.can.be.switch.null.safe.option: + text: Only suggest on null-safe expressions +if.can.be.switch.problem.descriptor: + text: '#ref statement can be replaced with ''switch'' statement #loc' +if.can.be.switch.quickfix: + text: Replace with 'switch' +if.may.be.conditional.display.name: + text: '''if'' statement could be replaced with conditional expression' +if.may.be.conditional.problem.descriptor: + text: '#ref can be replaced with conditional expression #loc' +if.may.be.conditional.quickfix: + text: Replace with conditional expression +if.may.be.conditional.report.method.calls.option: + text: Report if statements containing method calls +if.statement.with.identical.branches.collapse.quickfix: + text: Collapse 'if' statement +if.statement.with.identical.branches.display.name: + text: '''if'' statement with identical branches' +if.statement.with.identical.branches.problem.descriptor: + text: '#ref statement with identical branches #loc' +if.statement.with.too.many.branches.display.name: + text: '''if'' statement with too many branches' +if.statement.with.too.many.branches.max.option: + text: 'Maximum number of branches:' +if.statement.with.too.many.branches.problem.descriptor: + text: '#ref has too many branches ({0}) #loc' +ignore.accesses.from.equals.method: + text: Ignore accesses from 'equals()' method +ignore.accesses.from.the.same.class: + text: Ignore accesses from the same class +ignore.anonymous.inner.classes: + text: Ignore anonymous inner classes +ignore.boolean.methods.in.an.interface.option: + text: Ignore boolean methods in an @&interface +ignore.branches.of.switch.statements: + text: Ignore branches of 'switch' statements +ignore.calls.to.property.getters: + text: Ignore calls to property getters +ignore.calls.to.static.methods: + text: Ignore calls to static methods +ignore.classes.extending.throwable.option: + text: Ignore classes extending 'Throwable' +ignore.classes.in.hierarchy.column.name: + text: 'Ignore subclasses of:' +ignore.cloneable.option: + text: Ignore 'java.lang.Cloneable' +ignore.equals.hashcode.and.tostring: + text: Ignore 'equals()', 'hashCode()' and 'toString()' methods +ignore.exceptions.declared.on.library.override.option: + text: Ignore exceptions declared on methods overriding a &library method +ignore.for.equals.methods.option: + text: Ignore for '&equals()' methods +ignore.guard.clauses.option: + text: Ignore &guard clauses +ignore.if.annotated.by: + text: 'Ignore if annotated by:' +ignore.in.module.statements.option: + text: Ignore in Java 9 module statements +ignore.instanceof.on.library.classes: + text: Ignore instanceof on library classes +ignore.iterator.loop.variables: + text: Ignore 'java.util.Iterator' loop variables +ignore.methods.in.anonymous.classes: + text: Ignore methods in anonymous classes +ignore.methods.overriding.super.method: + text: Ignore methods &overriding/implementing a super method +ignore.methods.with.boolean.return.type.option: + text: Ignore methods with 'java.lang.&Boolean' return type +ignore.nullable.parameters.option: + text: Ignore @Nullable parameters +ignore.overflowing.byte.casts.option: + text: Ignore casts from int 128-255 to byte +ignore.parameter.if.annotated.by: + text: Ignore parameter if it is annotated by +ignore.parentheses.around.single.no.formal.type.lambda.parameter: + text: Ignore parentheses around single no formal type lambda parameter +ignore.serializable.option: + text: Ignore 'java.io.Serializable' +ignore.single.field.static.imports.option: + text: Ignore single &field static imports +ignore.single.method.static.imports.option: + text: Ignore single &method static imports +ignore.static.methods.accessed.from.a.non.static.inner.class: + text: Ignore '&static' methods accessed from a non-'static' inner class +ignore.test.method.in.class.extending.junit3.testcase.problem.descriptor: + text: 'JUnit 3 test method #ref() annotated with ''@Ignore'' won''t be ignored #loc' +ignore.test.method.in.class.extending.junit3.testcase.quickfix: + text: Remove ''@Ignore'' and rename method to ''{0}'' +ignore.trivial.finalizers.option: + text: Ignore for trivial 'finalize()' implementations +ignored.autocloseable.types.column.label: + text: Ignored AutoCloseable resource types +ignored.class.names: + text: Ignore Classes (Including Subclasses) +ignored.classes.table: + text: Ignored classes +ignored.io.resource.types: + text: Ignored I/O resource types +ignored.junit.test.classproblem.descriptor: + text: 'Test class ''''{0}'''' annotated with #ref #loc' +ignored.junit.test.display.name: + text: JUnit test annotated with '@Ignore'/'@Disabled' +ignored.junit.test.method.problem.descriptor: + text: 'Test method ''''{0}()'''' annotated with #ref #loc' +implicit.array.to.string.display.name: + text: Call to 'toString()' on array +implicit.array.to.string.method.call.problem.descriptor: + text: 'Implicit call to ''toString()'' on array returned by call to #ref #loc' +implicit.array.to.string.problem.descriptor: + text: 'Implicit call to ''toString()'' on array #ref #loc' +implicit.array.to.string.quickfix: + text: Wrap with ''{0}'' expression +implicit.call.to.super.display.name: + text: Implicit call to 'super()' +implicit.call.to.super.ignore.option: + text: Ignore for direct subclasses of 'java.lang.Object' +implicit.call.to.super.make.explicit.quickfix: + text: Make call to 'super()' explicit +implicit.call.to.super.problem.descriptor: + text: 'Implicit call to ''super()'' #loc' +implicit.default.charset.usage.constructor.problem.descriptor: + text: 'new #ref() call uses the platform''s default charset' +implicit.default.charset.usage.display.name: + text: Implicit usage of platform's default charset +implicit.default.charset.usage.problem.descriptor: + text: Call to #ref() uses the platform's default charset +implicit.numeric.conversion.convert.quickfix: + text: Convert to ''{0}'' +implicit.numeric.conversion.display.name: + text: Implicit numeric conversion implicit.numeric.conversion.ignore.char.conversion.option: - text: Ignore conversions from and to char + text: Ignore conversions from and to 'char' implicit.numeric.conversion.ignore.constant.conversion.option: - text: Ignore conversions from constants and literals -implicit.numeric.conversion.problem.descriptor: - text: 'Implicit numeric conversion of #ref from ''''{0}'''' to ''''{1}'''' #loc' -implicit.numeric.conversion.convert.quickfix: - text: Convert to ''{0}'' + text: Ignore conversions from constants and literals +implicit.numeric.conversion.ignore.widening.conversion.option: + text: Ignore widening conversions implicit.numeric.conversion.make.explicit.quickfix: - text: Make conversion explicit -long.literals.ending.with.lowercase.l.replace.quickfix: - text: Replace 'l' with 'L' -non.reproducible.math.call.replace.quickfix: - text: Replace with 'StrictMath' call + text: Make conversion explicit +implicit.numeric.conversion.problem.descriptor: + text: 'Implicit numeric conversion of #ref from ''''{0}'''' to ''''{1}'''' #loc' +import.display.name: + text: '''*'' import' +import.from.same.package.display.name: + text: Unnecessary import from the same package +import.from.same.package.problem.descriptor: + text: 'Unnecessary import from the same package #ref #loc' +import.problem.descriptor: + text: 'Package import #ref #loc' +include.java.system.classes.option: + text: Include couplings to java system classes +include.library.classes.option: + text: Include couplings to library classes +incompatible.mask.operation.display.name: + text: Incompatible bitwise mask operation +incompatible.mask.operation.problem.descriptor.always.false: + text: '#ref is always false #loc' +incompatible.mask.operation.problem.descriptor.always.true: + text: '#ref is always true #loc' +increment.decrement.display.name: + text: Result of '++' or '--' used +increment.decrement.used.as.expression.quickfix: + text: Extract ''{0}'' to separate statement +indexof.replaceable.by.contains.display.name: + text: '''indexOf()'' expression is replaceable with ''contains()''' +infinite.loop.statement.display.name: + text: Infinite loop statement +infinite.loop.statement.problem.descriptor: + text: '#ref statement cannot complete without throwing an exception #loc' +infinite.recursion.display.name: + text: Infinite recursion +infinite.recursion.problem.descriptor: + text: 'Method #ref() recurses infinitely, and can only end by throwing an exception #loc' +info.level.and.lower.option: + text: info level and lower +inline.call.quickfix: + text: Inline call +inline.variable.quickfix: + text: Inline variable +inner.class.field.hides.outer.display.name: + text: Inner class field hides outer class field +inner.class.field.hides.outer.ignore.option: + text: Ignore outer fields not visible from inner class +inner.class.field.hides.outer.problem.descriptor: + text: 'Inner class field #ref hides outer class field #loc' +inner.class.may.be.static.display.name: + text: Inner class may be 'static' +inner.class.may.be.static.problem.descriptor: + text: 'Inner class #ref may be ''static'' #loc' +inner.class.on.interface.display.name: + text: Inner class of interface +inner.class.on.interface.ignore.option: + text: Ignore inner interfaces of interfaces +inner.class.on.interface.problem.descriptor: + text: 'Interface ''''{0}'''' has inner class #ref #loc' +inner.class.referenced.via.subclass.display.name: + text: Inner class referenced via subclass +inner.class.referenced.via.subclass.problem.descriptor: + text: 'Inner class #ref declared in class ''''{0}'''' but referenced via subclass ''''{1}'''' #loc' +inner.class.referenced.via.subclass.quickfix: + text: Rationalize inner class access +inner.class.too.deeply.nested.display.name: + text: Inner class too deeply nested +inner.class.too.deeply.nested.nesting.limit.option: + text: 'Nesting limit:' +inner.class.too.deeply.nested.problem.descriptor: + text: '#ref is too deeply nested (nesting level = {0}) #loc' +inspection.option.ignore.as.initial.capacity: + text: Ignore initial capacity for StringBuilders and Collections +inspection.option.ignore.assert: + text: Ignore for assert statement description arguments +inspection.option.ignore.constant.initializers: + text: Ignore for initializers of constant fields +inspection.option.ignore.exceptions: + text: Ignore for constructor arguments of Throwable subclasses +inspection.option.ignore.in.annotations: + text: Ignore in annotations +inspection.option.ignore.in.hashcode: + text: Ignore constants in 'hashCode()' methods +inspection.option.ignore.in.tostring: + text: Ignore inside toString() methods +inspection.option.ignore.nonnls: + text: Ignore when annotated via @NonNls +inspection.option.ignore.system.err: + text: Ignore for 'System.err.print' arguments +inspection.option.ignore.system.out: + text: Ignore for 'System.out.print' arguments +inspection.suppression.annotation.display.name: + text: Inspection suppression annotation +inspection.suppression.annotation.problem.descriptor: + text: 'Inspection suppression annotation #ref #loc' +instance.Variable.may.not.be.initialized.problem.descriptor.junit: + text: 'Instance field #ref may not be initialized during object construction or ''setUp()'' call #loc' +instance.method.naming.convention.display.name: + text: Instance method naming convention +instance.method.naming.convention.element.description: + text: Instance method +instance.variable.may.not.be.initialized.display.name: + text: Instance field may not be initialized +instance.variable.may.not.be.initialized.problem.descriptor: + text: 'Instance field #ref may not be initialized during object construction #loc' +instance.variable.naming.convention.display.name: + text: Instance field naming convention +instance.variable.naming.convention.element.description: + text: Instance field +instance.variable.of.concrete.class.display.name: + text: Type of instance field is concrete class +instance.variable.of.concrete.class.option: + text: Ignore instance fields whose type is an abstract class +instance.variable.of.concrete.class.problem.descriptor: + text: 'Type of field ''''{0}'''' is concrete class #ref #loc' +instance.variable.used.before.initialized.display.name: + text: Instance field used before initialization +instance.variable.used.before.initialized.problem.descriptor: + text: 'Instance field #ref used before initialized #loc' +instanceof.catch.parameter.display.name: + text: '''instanceof'' on ''catch'' parameter' +instanceof.catch.parameter.problem.descriptor: + text: '''instanceof'' on ''catch'' parameter #ref #loc' +instanceof.check.for.this.display.name: + text: '''instanceof'' check for ''this''' +instanceof.check.for.this.problem.descriptor: + text: '''instanceof'' check for #ref #loc' +instanceof.concrete.class.display.name: + text: '''instanceof'' a concrete class' +instanceof.concrete.class.problem.descriptor: + text: '''instanceof'' concrete class #ref #loc' +instanceof.interfaces.option: + text: Ignore instanceof abstract class +instanceof.with.incompatible.interface.display.name: + text: '''instanceof'' with incompatible type' +instanceof.with.incompatible.interface.problem.descriptor: + text: '''instanceof'' incompatible interface #ref #loc' +instantiating.object.to.get.class.object.display.name: + text: Instantiating object to get Class object +instantiating.object.to.get.class.object.problem.descriptor: + text: 'Instantiating object to get Class object #loc' +instantiating.object.to.get.class.object.replace.quickfix: + text: Replace with direct class object access +instantiating.simpledateformat.without.locale.display.name: + text: '''SimpleDateFormat'' without locale' +instantiating.simpledateformat.without.locale.problem.descriptor: + text: 'Instantiating a #ref without specifying a Locale in an internationalized context #loc' +instantiation.utility.class.display.name: + text: Instantiation of utility class +instantiation.utility.class.problem.descriptor: + text: 'Instantiation of utility class #ref #loc' +int.literal.may.be.long.literal.display.name: + text: Cast to 'long' can be 'long' literal +int.literal.may.be.long.literal.problem.descriptor: + text: '#ref can be replaced with ''''{0}'''' #loc' +int.literal.may.be.long.literal.quickfix: + text: Replace with ''{0}'' +integer.division.in.floating.point.context.display.name: + text: Integer division in floating-point context +integer.division.in.floating.point.context.problem.descriptor: + text: '#ref: integer division in floating-point context #loc' +integer.multiplication.implicit.cast.to.long.display.name: + text: Integer multiplication or shift implicitly cast to 'long' +integer.multiplication.implicit.cast.to.long.option: + text: Ignore compile time constant expressions which do not overflow +integer.multiplication.implicit.cast.to.long.problem.descriptor: + text: '#ref: integer multiplication implicitly cast to long #loc' +integer.shift.implicit.cast.to.long.problem.descriptor: + text: '#ref: integer shift implicitly cast to long #loc' +interface.clashes.with.object.class.display.name: + text: Interface method clashes with method in 'Object' +interface.clashes.with.object.class.problem.descriptor: + text: #ref() clashes with method in 'java.lang.Object' +interface.may.be.annotated.functional.display.name: + text: Interface may be annotated as '@FunctionalInterface' +interface.may.be.annotated.functional.problem.descriptor: + text: Interface #ref may be annotated with @FunctionalInterface +interface.naming.convention.display.name: + text: Interface naming convention +interface.naming.convention.element.description: + text: Interface +interface.never.implemented.display.name: + text: Interface which has no concrete subclass +interface.never.implemented.option: + text: Ignore interfaces which only declare constants +interface.never.implemented.problem.descriptor: + text: 'Interface #ref has no concrete subclass #loc' +interface.one.inheritor.display.name: + text: Interface with a single direct inheritor +interface.one.inheritor.problem.descriptor: + text: 'Interface #ref has only one direct inheritor #loc' +introduce.constant.quickfix: + text: Introduce constant +introduce.holder.class.quickfix: + text: Introduce holder class +introduce.variable.may.change.semantics.quickfix: + text: Introduce variable (may change semantics) +introduce.variable.quickfix: + text: Introduce variable +invert.method.quickfix: + text: Invert method +invert.quickfix: + text: Invert ''{0}'' +invert.quickfix.family.name: + text: Invert boolean +iterator.hasnext.which.calls.next.display.name: + text: '''Iterator.hasNext()'' which calls ''next()''' +iterator.hasnext.which.calls.next.problem.descriptor: + text: 'Iterator.#ref() contains call to ''next()'' #loc' +iterator.next.does.not.throw.nosuchelementexception.display.name: + text: '''Iterator.next()'' which can''t throw ''NoSuchElementException''' +iterator.next.does.not.throw.nosuchelementexception.problem.descriptor: + text: 'Iterator.#ref() which can''t throw ''NoSuchElementException'' #loc' +java.lang.import.display.name: + text: Unnecessary import from the 'java.lang' package +java.lang.import.problem.descriptor: + text: 'Unnecessary import from the ''java.lang'' package #loc' +jdbc.execute.with.non.constant.string.display.name: + text: Call to 'Statement.execute()' with non-constant string +jdbc.execute.with.non.constant.string.problem.descriptor: + text: 'Call to Statement.#ref() with non-constant argument #loc' +jdbc.prepare.statement.with.non.constant.string.display.name: + text: Call to 'Connection.prepare*()' with non-constant string +jdbc.prepare.statement.with.non.constant.string.problem.descriptor: + text: 'Call to Connection.#ref() with non-constant argument #loc' +jdbc.resource.opened.not.closed.display.name: + text: JDBC resource opened but not safely closed +jndi.resource.opened.not.closed.display.name: + text: JNDI resource opened but not safely closed +junit.abstract.test.class.naming.convention.display.name: + text: JUnit abstract test class naming convention +junit.abstract.test.class.naming.convention.element.description: + text: Abstract JUnit test class +junit.datapoint.display.name: + text: Malformed @DataPoint field +junit.datapoint.problem.descriptor: + text: '{1}s annotated with @DataPoint should be {0}' +junit.rule.display.name: + text: Malformed @Rule/@ClassRule field +junit.rule.problem.descriptor: + text: Fields annotated with ''@{0}'' should be {1} +junit.rule.type.problem.descriptor: + text: Field type should be subtype of 'org.junit.rules.TestRule' +junit.test.class.naming.convention.display.name: + text: JUnit test class naming convention +junit.test.class.naming.convention.element.description: + text: Test class +junit3.method.naming.convention.display.name: + text: JUnit 3 test method naming convention +junit3.method.naming.convention.element.description: + text: JUnit 3 test method +junit3.style.test.method.in.junit4.class.display.name: + text: Old style JUnit test method in JUnit 4 class +junit3.style.test.method.in.junit4.class.problem.descriptor: + text: 'Old style JUnit test method #ref() in JUnit 4 class #loc' +junit4.method.naming.convention.display.name: + text: JUnit 4+ test method naming convention +junit4.method.naming.convention.element.description: + text: JUnit 4+ test method +junit4.test.method.in.class.extending.junit3.testcase.display.name: + text: JUnit 4 test method in class extending JUnit 3 TestCase +junit4.test.method.in.class.extending.junit3.testcase.problem.descriptor: + text: 'Method #ref() annotated with ''@Test'' inside class extending JUnit 3 TestCase #loc' +junit5.assertions.converter.display.name: + text: Obsolete assertions in JUnit 5 tests +junit5.assertions.converter.familyName: + text: Replace with JUnit 5 compatible call +junit5.assertions.converter.problem.descriptor: + text: 'Call to #ref() from ''''{0}'''' should be replaced with call to method from ''''{1}'''' #loc' +junit5.assertions.converter.quickfix: + text: Replace with ''{0}'' method call +junit5.converter.display.name: + text: JUnit 4 test can be JUnit 5 +junit5.converter.fix.name: + text: Migrate to JUnit 5 +junit5.malformed.repeated.test.display.name: + text: JUnit 5 malformed repeated test +junit5.platform.runner.display.name: + text: '@RunWith(JUnitPlatform.class) without test methods' +junit5.valid.parameterized.configuration.display.name: + text: JUnit 5 malformed parameterized test +key.set.iteration.may.use.entry.set.display.name: + text: Iteration over 'keySet()' may be replaced with 'entrySet()' iteration +key.set.iteration.may.use.entry.set.problem.descriptor: + text: 'Iteration over #ref may be replaced with ''entrySet()'' iteration #loc' +key.set.iteration.may.use.entry.set.quickfix: + text: Replace with 'entrySet()' iteration +labeled.statement.display.name: + text: Labeled statement +labeled.statement.problem.descriptor: + text: 'Labeled statement #ref: #loc' +lambda.body.can.be.code.block.name: + text: Lambda body can be code block +lambda.body.can.be.code.block.quickfix: + text: Expand lambda body to '{'...'}' +lambda.can.be.replaced.with.anonymous.name: + text: Lambda can be replaced with anonymous class +lambda.can.be.replaced.with.anonymous.quickfix: + text: Replace lambda with anonymous class +lambda.parameter.hides.member.variable.display.name: + text: Lambda parameter hides field +lambda.parameter.hides.member.variable.ignore.invisible.option: + text: Ignore fields not actually visible from the lambda +lambda.parameter.hides.member.variable.problem.descriptor: + text: 'Lambda parameter #ref hides field in class ''''{0}'''' #loc' +lambda.parameter.naming.convention.display.name: + text: Lambda parameter naming convention +lambda.parameter.naming.convention.element.description: + text: Lambda parameter +lambda.parameter.type.can.be.specified.descriptor: + text: Lambda can be expanded to {0} -> '{'...'}' +lambda.parameter.type.can.be.specified.family.quickfix: + text: Specify lambda parameter type +lambda.parameter.type.can.be.specified.name: + text: Lambda parameter type can be specified +lambda.parameter.type.can.be.specified.quickfix: + text: Expand lambda to {0} -> '{'...'}' +lambda.unfriendly.constructor.overload.problem.descriptor: + text: Lambda-unfriendly overload of constructor #ref() +lambda.unfriendly.method.overload.display.name: + text: Lambda-unfriendly method overload +lambda.unfriendly.method.overload.problem.descriptor: + text: Lambda-unfriendly overload of method #ref() +large.array.allocation.no.outofmemoryerror.display.name: + text: Large array allocation with no OutOfMemoryError check +large.array.allocation.no.outofmemoryerror.maximum.number.of.elements.option: + text: 'Maximum number of elements:' +large.array.allocation.no.outofmemoryerror.problem.descriptor: + text: 'Large array allocation which is not checked for out-of-memory condition #loc' +large.initializer.primitive.type.array.display.name: + text: Overly large initializer for array of primitive type +large.initializer.primitive.type.array.maximum.number.of.elements.option: + text: 'Maximum number of elements:' +large.initializer.primitive.type.array.problem.descriptor: + text: 'Primitive array initializer with too many elements ({0}) #loc' +law.of.demeter.display.name: + text: Method call violates Law of Demeter +law.of.demeter.ignore.library.calls.option: + text: Ignore calls on library methods +law.of.demeter.problem.descriptor: + text: '#ref() call violates Law of Demeter #loc' +length.one.string.in.indexof.display.name: + text: Single character string argument in 'String.indexOf()' call +length.one.strings.in.concatenation.display.name: + text: Single character string concatenation +length.one.strings.in.concatenation.replace.quickfix: + text: Replace with character +limited.scope.inner.class.display.name: + text: Limited-scope inner class +limited.scope.inner.class.problem.descriptor: + text: 'Limited-scope inner class #ref #loc' +listener.may.use.adapter.display.name: + text: Class may extend adapter instead of implementing listener +listener.may.use.adapter.emtpy.methods.option: + text: '&Only warn when empty implementing methods are found' +listener.may.use.adapter.problem.descriptor: + text: 'Class ''''{0}'''' may extend ''''{1}'''' instead of implementing #ref #loc' +listener.may.use.adapter.quickfix: + text: Replace with ''extends {0}'' +literal.as.arg.to.string.equals.display.name: + text: '''expression.equals("literal")'' rather than ''"literal".equals(expression)''' +literal.as.arg.to.string.equals.flip.quickfix: + text: Flip 'equals()' +literal.as.arg.to.string.equals.problem.descriptor: + text: '#ref is argument of ''''{0}()'''', instead of its target #loc' +load.library.with.non.constant.string.display.name: + text: Call to 'System.loadLibrary()' with non-constant string +load.library.with.non.constant.string.problem.descriptor: + text: 'Call to {0}.#ref() with non-constant argument #loc' +local.variable.hides.member.variable.display.name: + text: Local variable hides field +local.variable.hides.member.variable.ignore.option: + text: Ignore local variables in a static context +local.variable.hides.member.variable.problem.descriptor: + text: 'Local variable #ref hides field in class ''''{0}'''' #loc' +local.variable.naming.convention.display.name: + text: Local variable naming convention +local.variable.naming.convention.element.description: + text: Local variable +local.variable.naming.convention.ignore.catch.option: + text: Ignore 'catch' block parameters +local.variable.naming.convention.ignore.option: + text: Ignore for-loop parameters +local.variable.of.concrete.class.display.name: + text: Local variable of concrete class +local.variable.of.concrete.class.option: + text: Ignore local variables whose type is an abstract class +local.variable.of.concrete.class.problem.descriptor: + text: 'Local variable ''''{0}'''' of concrete class #ref #loc' +log.condition.text: + text: Log Condition Text +log.method.name: + text: Logging Method Name +log.statement.guarded.by.log.condition.display.name: + text: Logging call not guarded by log condition +log.statement.guarded.by.log.condition.flag.all.unguarded.option: + text: Flag all unguarded logging calls +log.statement.guarded.by.log.condition.problem.descriptor: + text: '#ref() logging calls not guarded by log condition #loc' +log.statement.guarded.by.log.condition.quickfix: + text: Surround with log condition +logger.class.name: + text: Logger class name +logger.factory.class.name: + text: Logger Factory Class Name +logger.factory.method.name: + text: Logger Factory Method Name +logger.initialized.with.foreign.class.display.name: + text: Logger initialized with foreign class +logger.initialized.with.foreign.class.problem.descriptor: + text: 'Logger initialized with foreign class #ref #loc' +logger.initialized.with.foreign.class.quickfix: + text: Replace with ''{0}.class'' +logger.name.option: + text: 'Logger &class name:' +logging.condition.disagrees.with.log.statement.display.name: + text: Log condition does not match logging call +logging.condition.disagrees.with.log.statement.problem.descriptor: + text: 'Log condition #ref() does not match ''''{0}()'''' logging call #loc' +long.literals.ending.with.lowercase.l.display.name: + text: '''long'' literal ending with ''l'' instead of ''L''' +long.literals.ending.with.lowercase.l.problem.descriptor: + text: '''long'' literal #ref ends with lowercase ''l'' #loc' +long.literals.ending.with.lowercase.l.replace.quickfix: + text: Replace 'l' with 'L' +loop.condition.not.updated.inside.loop.display.name: + text: Loop variable not updated inside loop +loop.condition.not.updated.inside.loop.problem.descriptor: + text: 'Condition ''#ref'' is not updated inside loop #loc' +loop.statements.that.dont.loop.display.name: + text: Loop statement that does not loop +loop.statements.that.dont.loop.problem.descriptor: + text: '#ref statement does not loop #loc' +loop.variable.not.updated.inside.loop.problem.descriptor: + text: 'Variable ''#ref'' is not updated inside loop #loc' +loop.with.implicit.termination.condition.display.name: + text: Loop with implicit termination condition +loop.with.implicit.termination.condition.dowhile.problem.descriptor: + text: '#ref-while loop with implicit termination condition #loc' +loop.with.implicit.termination.condition.problem.descriptor: + text: '#ref loop with implicit termination condition #loc' +loop.with.implicit.termination.condition.quickfix: + text: Make condition explicit +magic.character.display.name: + text: Magic character +magic.character.problem.descriptor: + text: 'Magic character #ref in an internationalized context #loc' +magic.number.display.name: + text: Magic number +magic.number.problem.descriptor: + text: 'Magic number #ref #loc' +make.class.final.fix.name: + text: Make class ''{0}'' ''final'' +make.constructor.public: + text: Make constructor 'public' +make.field.final.quickfix: + text: Make ''{0}'' ''final'' +make.initialization.explicit.quickfix: + text: Make initialization explicit +make.method.ctr.quickfix: + text: Make method constructor +make.method.final.fix.name: + text: Make method ''{0}()'' ''final'' +make.private.quickfix: + text: Make 'private' +make.protected.quickfix: + text: Make 'protected' +make.static.final.quickfix: + text: Make ''{0}'' static final +make.static.quickfix: + text: Make 'static' +malformed.format.string.display.name: + text: Malformed format string +malformed.format.string.problem.descriptor.arguments.do.not.match.type: + text: 'Argument type ''''{0}'''' does not match the type of the format specifier ''''{1}'''' #loc' +malformed.format.string.problem.descriptor.illegal: + text: 'Illegal format string specifier: {0} #loc' +malformed.format.string.problem.descriptor.malformed: + text: 'Format string #ref is malformed #loc' +malformed.format.string.problem.descriptor.too.few.arguments: + text: 'Too few arguments for format string (found: {0}, expected: {1}) #loc' +malformed.format.string.problem.descriptor.too.many.arguments: + text: 'Too many arguments for format string (found: {0}, expected: {1}) #loc' +malformed.regular.expression.display.name: + text: Malformed regular expression +malformed.regular.expression.problem.descriptor1: + text: 'Regular expression #ref is malformed #loc' +malformed.regular.expression.problem.descriptor2: + text: 'Regular expression #ref is malformed: {0} #loc' +malformed.set.up.tear.down.display.name: + text: Malformed 'setUp()' or 'tearDown()' method +malformed.set.up.tear.down.problem.descriptor: + text: '''#ref()'' has incorrect signature #loc' +malformed.xpath.expression.display.name: + text: Malformed XPath expression +malformed.xpath.expression.problem.description: + text: 'XPath expression #ref is malformed #loc' +manual.array.copy.display.name: + text: Manual array copy +manual.array.copy.problem.descriptor: + text: 'Manual array copy #loc' +manual.array.copy.replace.quickfix: + text: Replace with 'System.arraycopy()' +manual.array.to.collection.copy.display.name: + text: Manual array to collection copy +manual.array.to.collection.copy.problem.descriptor: + text: 'Manual array to collection copy #loc' +manual.array.to.collection.copy.replace.quickfix: + text: Replace with 'Collections.addAll(...,...)' +map.replaceable.by.enum.map.display.name: + text: '''Map'' can be replaced with ''EnumMap''' +map.replaceable.by.enum.map.problem.descriptor: + text: '#ref can be replaced with ''EnumMap'' #loc' +marker.interface.display.name: + text: Marker interface +marker.interface.problem.descriptor: + text: 'Marker interface #ref #loc' +math.random.cast.to.int.display.name: + text: '''Math.random()'' cast to ''int''' +math.random.cast.to.int.problem.descriptor: + text: '#ref cast to ''''{0}'''' is always rounded down to ''''0'''' #loc' +math.random.cast.to.int.quickfix: + text: Add parentheses to perform multiplication before cast +meta.annotation.without.runtime.retention: + text: Non-runtime annotation to be used by reflection +method.call.in.loop.condition.display.name: + text: Method call in loop condition +method.call.in.loop.condition.problem.descriptor: + text: 'Call to method #ref() in loop condition #loc' +method.can.be.variable.arity.method.display.name: + text: Method can have varargs parameter +method.can.be.variable.arity.method.ignore.all.primitive.arrays.option: + text: Ignore all primitive array types +method.can.be.variable.arity.method.ignore.byte.short.option: + text: Ignore parameters with type byte[] or short[] +method.can.be.variable.arity.method.ignore.multidimensional.arrays.option: + text: Ignore multidimensional array parameters +method.can.be.variable.arity.method.ignore.multiple.arrays.option: + text: Ignore methods with multiple array parameters +method.can.be.variable.arity.method.problem.descriptor: + text: '#ref() can be converted to varargs method #loc' +method.complexity.limit.option: + text: 'Method complexity limit:' +method.count.ignore.getters.setters.option: + text: '&Ignore simple getter and setter methods' +method.count.limit.option: + text: 'Method count limit:' +method.coupling.display.name: + text: Overly coupled method +method.coupling.limit.option: + text: 'Method coupling limit:' +method.coupling.problem.descriptor: + text: '#ref is overly coupled (# referenced classes = {0}) #loc' +method.may.be.static.display.name: + text: Method can be made 'static' +method.may.be.static.empty.option: + text: Ignore empty methods +method.may.be.static.only.option: + text: Only check 'private' or 'final' methods +method.may.be.static.problem.descriptor: + text: 'Method #ref() may be ''static'' #loc' +method.may.be.synchronized.display.name: + text: Method with single 'synchronized' block can be replaced with 'synchronized' method +method.may.be.synchronized.problem.descriptor: + text: 'Method #ref() with synchronized block can be synchronized method #loc' +method.may.be.synchronized.quickfix: + text: Make method synchronized and remove synchronized block +method.missing.return.statement.display.name: + text: Method contains logic but is missing a 'return' statement +method.missing.return.statement.problem.descriptor: + text: Method #ref contains logic but is missing a 'return' statement +method.name.regex: + text: Method Name Regex +method.name.same.as.class.name.display.name: + text: Method name same as class name +method.name.same.as.class.name.problem.descriptor: + text: 'Method name #ref is the same as its class name #loc' +method.name.same.as.parent.name.display.name: + text: Method name same as parent class name +method.name.same.as.parent.name.problem.descriptor: + text: 'Method name #ref is the same as its parent class name #loc' +method.names.differ.only.by.case.display.name: + text: Method names differing only by case +method.names.differ.only.by.case.problem.descriptor: + text: 'Method name #ref and method name ''''{0}'''' differ only by case #loc' +method.only.used.from.inner.class.display.name: + text: Private method only used from inner class +method.only.used.from.inner.class.ignore.option: + text: Ignore methods accessed from an &anonymous class +method.only.used.from.inner.class.problem.descriptor: + text: 'Method #ref()#loc is only used from inner class ''''{0}'''' #loc' +method.only.used.from.inner.class.problem.descriptor.anonymous.extending: + text: 'Method #ref()#loc is only used from an anonymous class extending ''''{0}'''' #loc' +method.only.used.from.inner.class.problem.descriptor.anonymous.implementing: + text: 'Method #ref()#loc is only used from an anonymous class implementing ''''{0}'''' #loc' +method.overloads.display.name: + text: Possibly unintended overload of method from superclass +method.overloads.problem.descriptor: + text: 'Method #ref() overloads a compatible method of a superclass, when overriding might have been intended #loc' +method.overloads.report.incompatible.option: + text: Report even if parameter types are not compatible +method.overrides.inaccessible.method.display.name: + text: Method overrides inaccessible method of superclass +method.overrides.package.local.method.problem.descriptor: + text: 'Method #ref() overrides a package-private method of a superclass located in another package #loc' +method.overrides.private.display.name.problem.descriptor: + text: 'Method #ref() overrides a ''private'' method of a superclass #loc' +method.overrides.static.display.name: + text: Method tries to override 'static' method of superclass +method.overrides.static.problem.descriptor: + text: 'Method #ref() tries to override a static method of a superclass #loc' +method.ref.can.be.replaced.with.lambda.name: + text: Method reference can be replaced with lambda +method.ref.can.be.replaced.with.lambda.quickfix: + text: Replace method reference with lambda +method.return.always.constant.display.name: + text: Method returns per-class constant +method.return.always.constant.problem.descriptor: + text: Method #ref() and all its derivables always return constants +method.return.concrete.class.display.name: + text: Method return of concrete class +method.return.concrete.class.problem.descriptor: + text: 'Method returns a concrete class #ref #loc' +method.return.of.concrete.class.option: + text: Ignore methods whose return type is an abstract class +method.with.multiple.loops.display.name: + text: Method with multiple loops +method.with.multiple.loops.problem.descriptor: + text: '#ref contains {0} loops #loc' +mismatched.read.write.array.display.name: + text: Mismatched read and write of array +mismatched.read.write.array.problem.descriptor.read.not.write: + text: 'Contents of array #ref are read, but never written to #loc' +mismatched.read.write.array.problem.descriptor.write.not.read: + text: 'Contents of array #ref are written to, but never read #loc' +mismatched.string.builder.queried.problem.descriptor: + text: 'Contents of {0} #ref are queried, but never updated #loc' +mismatched.string.builder.query.update.display.name: + text: Mismatched query and update of 'StringBuilder' +mismatched.string.builder.updated.problem.descriptor: + text: 'Contents of {0} #ref are updated, but never queried #loc' +mismatched.update.collection.display.name: + text: Mismatched query and update of collection +mismatched.update.collection.problem.description.queried.not.updated: + text: 'Contents of collection #ref are queried, but never updated #loc' +mismatched.update.collection.problem.descriptor.updated.not.queried: + text: 'Contents of collection #ref are updated, but never queried #loc' +misordered.assert.equals.arguments.display.name: + text: Misordered 'assertEquals()' arguments +misordered.assert.equals.arguments.flip.quickfix: + text: Flip compared arguments +misordered.assert.equals.arguments.problem.descriptor: + text: 'Arguments to #ref() in wrong order #loc' +missing.deprecated.annotation.add.quickfix: + text: Add '@Deprecated' annotation +missing.deprecated.annotation.display.name: + text: Missing '@Deprecated' annotation +missing.deprecated.annotation.problem.descriptor: + text: 'Missing ''@Deprecated'' annotation #loc' +missing.deprecated.tag.option: + text: Warn on missing @deprecated Javadoc tag explanation +missing.deprecated.tag.problem.descriptor: + text: 'Missing ''@deprecated'' Javadoc tag explanation #loc' +missing.override.annotation.add.quickfix: + text: Add @Override annotation +missing.override.annotation.display.name: + text: Missing '@Override' annotation +missing.override.annotation.problem.descriptor: + text: 'Missing ''@Override'' annotation on #ref() #loc' +missing.package.html.problem.descriptor: + text: Package ''{0}'' is missing a package.html file +missing.package.info.display.name: + text: Missing 'package-info.java' +missing.package.info.problem.descriptor: + text: Package ''{0}'' is missing a package-info.java file +missorted.modifiers.display.name: + text: Missorted modifiers +missorted.modifiers.problem.descriptor: + text: 'Missorted modifiers #ref #loc' +missorted.modifiers.require.option: + text: Require annotations to be sorted before keywords +missorted.modifiers.sort.quickfix: + text: Sort modifiers +misspelled.equals.display.name: + text: '''equal()'' instead of ''equals()''' +misspelled.equals.problem.descriptor: + text: '#ref() method should probably be ''equals()'' #loc' +module.with.too.few.classes.display.name: + text: Module with too few classes +module.with.too.few.classes.min.option: + text: 'Minimum number of classes:' +module.with.too.few.classes.problem.descriptor: + text: Module ''{0}'' contains too few classes ({1} < {2}) +module.with.too.many.classes.display.name: + text: Module with too many classes +module.with.too.many.classes.max.option: + text: 'Maximum number of classes:' +module.with.too.many.classes.problem.descriptor: + text: Module ''{0}'' contains too many classes ({1} > {2}) +move.anonymous.to.inner.quickfix: + text: Convert to named inner class +move.class.quickfix: + text: Move class +multi.catch.can.be.split.name: + text: Multi-catch can be split into separate catch blocks +multi.catch.can.be.split.quickfix: + text: Split multi-catch into separate 'catch' blocks +multiple.declaration.display.name: + text: Multiple variables in one declaration +multiple.declaration.option: + text: Ignore 'for' loop declarations +multiple.declaration.problem.descriptor: + text: 'Multiple variables in one declaration #loc' +multiple.exceptions.declared.on.test.method.display.name: + text: Multiple exceptions declared on test method +multiple.exceptions.declared.on.test.method.problem.descriptor: + text: '#ref could be replaced with ''throws Exception'' #loc' +multiple.exceptions.declared.on.test.method.quickfix: + text: Replace with 'throws Exception' +multiple.loggers.display.name: + text: Class with multiple loggers +multiple.loggers.problem.descriptor: + text: 'Class #ref declares multiple loggers #loc' +multiple.return.points.per.method.display.name: + text: Method with multiple return points +multiple.return.points.per.method.problem.descriptor: + text: '#ref has {0} return points #loc' +multiple.top.level.classes.in.file.display.name: + text: Multiple top level classes in single file +multiple.top.level.classes.in.file.problem.descriptor: + text: Multiple top level classes in file +multiple.typed.declaration.display.name: + text: Variables of different types in one declaration +multiple.typed.declaration.problem.descriptor: + text: 'Variables of different types in one declaration #loc' +multiply.or.divide.by.power.of.two.display.name: + text: Multiplication or division by power of two +multiply.or.divide.by.power.of.two.divide.option: + text: Check divisions by a power of two also +multiply.or.divide.by.power.of.two.replace.quickfix: + text: Replace with shift +naked.notify.display.name: + text: '''notify()'' or ''notifyAll()'' without corresponding state change' +naked.notify.problem.descriptor: + text: 'Call to #ref() without corresponding state change #loc' +naming.convention.problem.descriptor.long: + text: '{0} name #ref is too long ({1} > {2}) #loc' +naming.convention.problem.descriptor.regex.mismatch: + text: '{0} name #ref doesn''''t match regex ''''{1}'''' #loc' +naming.convention.problem.descriptor.short: + text: '{0} name #ref is too short ({1} < {2}) #loc' +native.method.display.name: + text: Native method +native.method.naming.convention.display.name: + text: '''native'' method naming convention' +native.method.naming.convention.element.description: + text: '''native'' method' +native.method.problem.descriptor: + text: 'Methods declared #ref are non-portable #loc' +negated.conditional.display.name: + text: Conditional expression with negated condition +negated.conditional.expression.display.name: + text: Negated conditional expression +negated.conditional.expression.problem.descriptor: + text: 'Negating conditional expression #loc' +negated.conditional.expression.quickfix: + text: Remove negation +negated.conditional.ignore.option: + text: Ignore '!= null' comparisons +negated.conditional.invert.quickfix: + text: Invert condition +negated.conditional.problem.descriptor: + text: 'Conditional expression with negated condition #loc' +negated.equality.expression.display.name: + text: Negated equality expression +negated.equality.expression.problem.descriptor: + text: 'Negating ''''{0}'''' #loc' +negated.equality.expression.quickfix: + text: Remove negation +negated.if.else.display.name: + text: '''if'' statement with negated condition' +negated.if.else.ignore.negated.null.option: + text: Ignore '!= null' comparisons +negated.if.else.ignore.negated.zero.option: + text: Ignore '!= 0' comparisons +negated.if.else.invert.quickfix: + text: Invert 'if' condition +negated.if.else.problem.descriptor: + text: '#ref statement with negated condition #loc' +negatively.named.boolean.variable.display.name: + text: Negatively named boolean variable +negatively.named.boolean.variable.problem.descriptor: + text: 'Boolean variable #ref is negatively named #loc' +nested.assignment.display.name: + text: Result of assignment used +nested.assignment.problem.descriptor: + text: 'Result of assignment expression used #loc' +nested.conditional.expression.display.name: + text: Nested conditional expression +nested.conditional.expression.problem.descriptor: + text: 'Nested conditional expression #ref #loc' +nested.method.call.display.name: + text: Nested method call +nested.method.call.ignore.option: + text: Ignore nested method calls in field initializers +nested.method.call.problem.descriptor: + text: 'Nested method call #ref() #loc' +nested.switch.statement.display.name: + text: Nested 'switch' statement +nested.switch.statement.problem.descriptor: + text: 'Nested #ref statement #loc' +nested.synchronized.statement.display.name: + text: Nested 'synchronized' statement +nested.synchronized.statement.problem.descriptor: + text: 'Nested #ref statement #loc' +nested.try.statement.display.name: + text: Nested 'try' statement +nested.try.statement.problem.descriptor: + text: 'Nested #ref statement #loc' +nesting.depth.display.name: + text: Overly nested method +nesting.depth.limit.option: + text: 'Nesting depth limit:' +nesting.depth.problem.descriptor: + text: '#ref is overly nested (maximum nesting depth = {0}) #loc' +new.exception.without.arguments.display.name: + text: Exception constructor called without arguments +new.exception.without.arguments.ignore.option: + text: Ignore for exceptions that have no constructors with parameters +new.exception.without.arguments.problem.descriptor: + text: 'new #ref() without arguments #loc' +new.string.buffer.replaceable.by.string.problem.descriptor: + text: '#ref can be replaced with ''String'' #loc' +new.string.buffer.with.char.argument.display.name: + text: StringBuffer constructor call with 'char' argument +new.string.buffer.with.char.argument.problem.descriptor: + text: 'new #ref() with argument of type ''char'' #loc' +new.string.buffer.with.char.argument.quickfix: + text: Replace char argument with String literal +no.logger.display.name: + text: Class without logger +no.logger.problem.descriptor: + text: 'Class #ref does not declare a logger #loc' +non.atomic.operation.on.volatile.field.display.name: + text: Non-atomic operation on 'volatile' field +non.atomic.operation.on.volatile.field.problem.descriptor: + text: 'Non-atomic operation on volatile field #ref #loc' +non.boolean.method.name.must.not.start.with.question.display.name: + text: Non-boolean method name must not start with question word +non.boolean.method.name.must.not.start.with.question.problem.descriptor: + text: 'Non-boolean method name #ref starts with a question word #loc' +non.comment.source.statements.display.name: + text: Overly long method +non.comment.source.statements.limit.option: + text: 'Non-comment source statements limit:' +non.comment.source.statements.problem.descriptor: + text: '#ref is too long (# Non-comment source statements = {0}) #loc' +non.constant.logger.display.name: + text: Non-constant logger +non.constant.logger.problem.descriptor: + text: 'Non-constant logger field #ref #loc' +non.exception.name.ends.with.exception.display.name: + text: Non-exception class name ends with 'Exception' +non.exception.name.ends.with.exception.problem.descriptor: + text: 'Non-exception class name #ref ends with ''Exception'' #loc' +non.exception.name.ends.with.exception.quickfix: + text: Make ''{0}'' extend ''java.lang.Exception'' +non.final.clone.display.name: + text: Non-final 'clone()' in secure context +non.final.clone.problem.descriptor: + text: 'Non-final #ref() method, compromising security #loc' +non.final.field.compareto.display.name: + text: Non-final field referenced in 'compareTo()' +non.final.field.compareto.problem.descriptor: + text: 'Non-final field #ref accessed in ''compareTo()'' #loc' +non.final.field.in.enum.display.name: + text: Non-final field in 'enum' +non.final.field.in.enum.problem.descriptor: + text: 'Non-final field #ref in enum ''''{0}'''' #loc' +non.final.field.in.equals.display.name: + text: Non-final field referenced in 'equals()' +non.final.field.in.equals.problem.descriptor: + text: 'Non-final field #ref accessed in ''equals()'' #loc' +non.final.field.in.hashcode.display.name: + text: Non-final field referenced in 'hashCode()' +non.final.field.in.hashcode.problem.descriptor: + text: 'Non-final field #ref accessed in ''hashCode()'' #loc' +non.final.field.of.exception.display.name: + text: Non-final field of 'Exception' class +non.final.field.of.exception.problem.descriptor: + text: 'Non-final field #ref of exception class #loc' +non.final.static.variable.initialization.display.name: + text: Non-final static field is used during class initialization +non.final.static.variable.initialization.problem.descriptor: + text: 'Non-final static field #ref used during class initialization #loc' +non.final.utility.class.display.name: + text: Utility class is not 'final' +non.final.utility.class.problem.descriptor: + text: 'Utility class #ref is not ''final'' #loc' +non.protected.constructor.in.abstract.class.display.name: + text: '''public'' constructor in ''abstract'' class' +non.protected.constructor.in.abstract.class.ignore.option: + text: Ignore for non-public classes +non.protected.constructor.in.abstract.class.problem.descriptor: + text: 'Constructor #ref() is not declared ''protected'' in ''abstract'' class #loc' +non.public.clone.display.name: + text: '''clone()'' method not ''public''' +non.public.clone.problem.descriptor: + text: '#ref() method not ''public'' #loc' +non.reproducible.math.call.display.name: + text: Non-reproducible call to 'Math' +non.reproducible.math.call.problem.descriptor: + text: 'Math.#ref() may produce non-reproducible results #loc' +non.reproducible.math.call.replace.quickfix: + text: Replace with 'StrictMath' call +non.serializable.ainterface.with.serialversionuid.problem.descriptor: + text: 'Non-serializable @interface #ref defines a ''serialVersionUID'' field #loc' +non.serializable.anonymous.with.readwriteobject.problem.descriptor.both: + text: 'Non-serializable anonymous class extending #ref defines ''readObject()'' and ''writeObject()'' #loc' +non.serializable.anonymous.with.readwriteobject.problem.descriptor.read: + text: 'Non-serializable anonymous class extending #ref defines ''readObject()'' #loc' +non.serializable.anonymous.with.readwriteobject.problem.descriptor.write: + text: 'Non-serializable anonymous class extending #ref defines ''writeObject()'' #loc' +non.serializable.anonymous.with.serialversionuid.problem.descriptor: + text: 'Non-serializable anonymous class derived from #ref defines a ''serialVersionUID'' field #loc' +non.serializable.class.with.readwriteobject.display.name: + text: Non-serializable class with 'readObject()' or 'writeObject()' +non.serializable.class.with.readwriteobject.problem.descriptor.both: + text: 'Non-serializable class #ref defines ''readObject()'' and ''writeObject()'' #loc' +non.serializable.class.with.readwriteobject.problem.descriptor.read: + text: 'Non-serializable class #ref defines ''readObject()'' #loc' +non.serializable.class.with.readwriteobject.problem.descriptor.write: + text: 'Non-serializable class #ref defines ''writeObject()'' #loc' +non.serializable.class.with.serialversionuid.problem.descriptor: + text: 'Non-serializable class #ref defines a ''serialVersionUID'' field #loc' +non.serializable.field.in.serializable.class.display.name: + text: Non-serializable field in a 'Serializable' class +non.serializable.field.in.serializable.class.problem.descriptor: + text: 'Non-serializable field ''#ref'' in Serializable class #loc' +non.serializable.interface.with.serialversionuid.problem.descriptor: + text: 'Non-serializable interface #ref defines a ''serialVersionUID'' field #loc' +non.serializable.object.bound.to.http.session.display.name: + text: Non-serializable object bound to 'HttpSession' +non.serializable.object.bound.to.http.session.problem.descriptor: + text: 'Non-serializable object bound to HttpSession #loc' +non.serializable.object.passed.to.object.stream.display.name: + text: Non-serializable object passed to 'ObjectOutputStream' +non.serializable.object.passed.to.object.stream.problem.descriptor: + text: 'Non-serializable object passed to ObjectOutputStream #loc' +non.serializable.with.serialversionuid.display.name: + text: Non-serializable class with 'serialVersionUID' +non.serializable.with.serialversionuid.remove.quickfix: + text: Remove 'serialVersionUID' field +non.short.circuit.boolean.expression.display.name: + text: Non-short-circuit boolean expression +non.short.circuit.boolean.expression.problem.descriptor: + text: 'Non-short-circuit boolean expression #ref #loc' +non.short.circuit.boolean.expression.replace.quickfix: + text: Replace with short circuit expression +non.static.inner.class.in.secure.context.display.name: + text: Non-'static' inner class in secure context +non.static.inner.class.in.secure.context.problem.descriptor: + text: 'Non-''static'' inner class #ref, compromising security #loc' +non.synchronized.method.overrides.synchronized.method.display.name: + text: Unsynchronized method overrides 'synchronized' method +non.synchronized.method.overrides.synchronized.method.problem.descriptor: + text: 'Unsynchronized method #ref() overrides synchronized method #loc' +non.thread.safe.lazy.initialization.display.name: + text: Unsafe lazy initialization of 'static' field +non.thread.safe.lazy.initialization.problem.descriptor: + text: 'Lazy initialization of ''static'' field #ref is not thread-safe #loc' +none: + text: none +noop.method.in.abstract.class.display.name: + text: No-op method in 'abstract' class +noop.method.in.abstract.class.problem.descriptor: + text: 'No-op Method #ref() should be made abstract #loc' +normalize.declaration.quickfix: + text: Split into separate declarations +notify.called.on.condition.display.name: + text: '''notify()'' or ''notifyAll()'' called on ''java.util.concurrent.locks.Condition'' object' +notify.called.on.condition.problem.descriptor: + text: 'Call to #ref() on Condition object #loc' +notify.without.corresponding.wait.display.name: + text: '''notify()'' without corresponding ''wait()''' +notify.without.corresponding.wait.problem.descriptor: + text: 'Call to #ref() without corresponding wait() #loc' +null.argument.to.var.arg.method.display.name: + text: Confusing argument to varargs method +null.argument.to.var.arg.method.problem.descriptor: + text: 'Confusing argument #ref, unclear if a varargs or non-varargs call is desired #loc' +null.thrown.display.name: + text: '''null'' thrown' +null.thrown.problem.descriptor: + text: '#ref thrown #loc' +null.thrown.quickfix: + text: Replace with 'new NullPointerException()' +number.comparison.display.name: + text: Number comparison using '==', instead of 'equals()' +number.comparison.problem.descriptor: + text: 'Number objects are compared using #ref, not ''equals()'' #loc' +object.allocation.in.loop.display.name: + text: Object allocation in loop +object.allocation.in.loop.problem.descriptor: + text: 'Object allocation new #ref() in loop #loc' +object.comparison.display.name: + text: Object comparison using '==', instead of 'equals()' +object.comparison.enumerated.ignore.option: + text: Ignore '==' between enum variables +object.comparison.klass.ignore.option: + text: Ignore '==' on 'java.lang.Class' objects +object.comparison.problem.description: + text: 'Object values are compared using #ref, not ''equals()'' #loc' +object.comparison.replace.quickfix: + text: Replace with 'equals()' +object.equality.ignore.between.objects.of.a.type.with.only.private.constructors.option: + text: Ignore '==' between objects of a type with only 'private' constructors +object.equals.null.display.name: + text: Object.equals(null) +object.equals.null.problem.descriptor: + text: '.equals(#ref) is probably not what was intended #loc' +object.instantiation.inside.equals.or.hashcode.display.name: + text: Object instantiation inside 'equals()' or 'hashCode()' +object.instantiation.inside.equals.or.hashcode.problem.descriptor: + text: 'Object instantiation inside ''''{0}()'''' #loc' +object.instantiation.inside.equals.or.hashcode.problem.descriptor2: + text: Object instantiation inside ''{0}()'' ({1})#loc +object.notify.display.name: + text: Call to 'notify()' instead of 'notifyAll()' +object.notify.problem.descriptor: + text: '#ref should probably be replaced with ''notifyAll()'' #loc' +object.notify.replace.quickfix: + text: Replace with 'notifyAll()' +octal.and.decimal.integers.in.same.array.display.name: + text: Octal and decimal integers in same array +octal.and.decimal.integers.in.same.array.problem.descriptor: + text: 'Octal and decimal integers in the same array initializer #loc' +octal.literal.display.name: + text: Octal integer +octal.literal.problem.descriptor: + text: 'Octal integer #ref #loc' +only.report.public.methods.option: + text: Only report 'public' methods +only.report.qualified.static.usages.option: + text: Only report qualified static access from a static context +only.report.static.methods: + text: '&Only report ''static'' methods' +only.warn.on.protected.clone.methods: + text: Only warn on 'protected' clone methods +only.warn.on.public.clone.methods: + text: Only warn on 'public' clone methods +only.weaken.to.an.interface: + text: Only weaken to an interface +optional.contains.array.problem.descriptor: + text: '''Optional'' contains array #ref' +optional.contains.collection.display.name: + text: '''Optional'' contains array or collection' +optional.contains.collection.problem.descriptor: + text: '''Optional'' contains collection #ref' +optional.used.as.field.or.parameter.type.display.name: + text: '''Optional'' used as field or parameter type' +optional.used.as.field.type.problem.descriptor: + text: #ref used as type for field ''{0}'' +optional.used.as.parameter.type.problem.descriptor: + text: #ref used as type for parameter ''{0}'' +orred.not.equal.expression.display.name: + text: Identical reference in '!=' expression on both sides of '||' expression +orred.not.equal.expression.problem.descriptor: + text: '#ref is always true #loc' +overloaded.methods.with.same.number.parameters.display.name: + text: Overloaded methods with same number of parameters +overloaded.methods.with.same.number.parameters.option: + text: Ignore overloaded methods whose parameter types are definitely incompatible +overloaded.methods.with.same.number.parameters.problem.descriptor: + text: 'Multiple methods named #ref with the same number of parameters #loc' +overloaded.vararg.constructor.problem.descriptor: + text: 'Overloaded varargs constructor #ref() #loc' +overloaded.vararg.method.display.name: + text: Overloaded varargs method +overloaded.vararg.method.problem.descriptor: + text: 'Overloaded varargs method #ref() #loc' +overly.broad.throws.clause.display.name: + text: Overly broad 'throws' clause +overly.broad.throws.clause.ignore.thrown.option: + text: Ignore exceptions which &hide others but are themselves thrown +overly.broad.throws.clause.problem.descriptor1: + text: 'throws #ref is too broad, masking exception ''''{0}'''' #loc' +overly.broad.throws.clause.problem.descriptor2: + text: 'throws #ref is too broad, masking exceptions ''''{0}'''' and ''''{1}'''' #loc' +overly.broad.throws.clause.quickfix1: + text: Add specific exceptions +overly.broad.throws.clause.quickfix2: + text: Replace with specific exceptions +overly.complex.anonymous.inner.class.display.name: + text: Overly complex anonymous class +overly.complex.anonymous.inner.class.problem.descriptor: + text: 'Overly complex anonymous class (cyclomatic complexity = {0}) #loc' +overly.complex.arithmetic.expression.display.name: + text: Overly complex arithmetic expression overly.complex.arithmetic.expression.max.number.option: - text: 'Maximum number of terms:' -expression.can.be.replaced.problem.descriptor: - text: '#ref can be replaced with ''''{0}'''' #loc' -method.complexity.limit.option: - text: 'Method complexity limit:' -cyclomatic.complexity.problem.descriptor: - text: 'Overly complex method #ref() (cyclomatic complexity = {0}) #loc' -method.coupling.limit.option: - text: 'Method coupling limit:' -method.coupling.problem.descriptor: - text: '#ref is overly coupled (# referenced classes = {0}) #loc' -method.with.multiple.loops.problem.descriptor: - text: '#ref contains {0} loops #loc' -return.point.limit.option: - text: '&Return point limit:' -multiple.return.points.per.method.problem.descriptor: - text: '#ref has {0} return points #loc' -nesting.depth.limit.option: - text: 'Nesting depth limit:' -nesting.depth.problem.descriptor: - text: '#ref is overly nested (maximum nesting depth = {0}) #loc' -non.comment.source.statements.limit.option: - text: 'Non-comment source statements limit:' -non.comment.source.statements.problem.descriptor: - text: '#ref is too long (# Non-comment source statements = {0}) #loc' -parameters.per.method.problem.descriptor: - text: '#ref() has too many parameters (num parameters = {0}) #loc' -parameters.per.constructor.problem.descriptor: - text: '#ref() has too many parameters (num parameters = {0}) #loc' -parameter.limit.option: - text: 'Parameter limit:' -constructor.visibility.option: - text: 'Ignore constructors with visibility:' -three.negations.per.method.ignore.option: - text: Ignore negations in 'equals()' methods -three.negations.per.method.ignore.assert.option: - text: Ignore negations in 'assert' statements -three.negations.per.method.problem.descriptor: - text: '#ref contains {0} negations #loc' -thrown.exceptions.per.method.problem.descriptor: - text: '#ref has too many exceptions declared (num exceptions = {0}) #loc' -thrown.exceptions.per.method.limit.option: - text: 'Exceptions thrown limit:' -call.to.simple.getter.in.class.ignore.option: - text: Ignore getter calls on other objects -call.to.private.simple.getter.in.class.option: - text: Only report getter is 'private' -call.to.simple.getter.in.class.inline.quickfix: - text: Inline call to getter -call.to.simple.setter.in.class.ignore.option: - text: Ignore setter calls on other objects -call.to.private.setter.in.class.option: - text: Only report when setter is 'private' -call.to.simple.setter.in.class.inline.quickfix: - text: Inline call to setter -make.static.quickfix: - text: Make 'static' -length.one.strings.in.concatenation.replace.quickfix: - text: Replace with character -multiply.or.divide.by.power.of.two.replace.quickfix: - text: Replace with shift -boolean.expression.can.be.simplified.problem.descriptor: - text: '#ref can be simplified to ''''{0}'''' #loc' -trivial.string.concatenation.problem.descriptor: - text: Empty string used in concatenation -string.replace.quickfix: - text: Replace concatenation with ''{0}'' -instantiating.object.to.get.class.object.replace.quickfix: - text: Replace with direct class object access -manual.array.copy.replace.quickfix: - text: Replace with 'System.arraycopy()' -manual.array.to.collection.copy.replace.quickfix: - text: Replace with 'Collections.addAll(...,...)' -method.may.be.static.only.option: - text: Only check 'private' or 'final' methods -method.may.be.static.empty.option: - text: Ignore empty methods -random.double.for.random.integer.replace.quickfix: - text: Replace with 'nextInt()' -string.buffer.replaceable.by.string.builder.replace.quickfix: - text: Replace with 'StringBuilder' -string.buffer.to.string.in.concatenation.remove.quickfix: - text: Remove 'toString()' -string.concatenation.in.loops.only.option: - text: Only warn if string is repeatedly appended -string.concatenation.inside.string.buffer.append.replace.quickfix: - text: Replace with chained 'append()' calls -string.equals.empty.string.quickfix: - text: Replace with 'length()==0' -string.equals.empty.string.isempty.quickfix: - text: Replace with 'isEmpty()' -tail.recursion.replace.quickfix: - text: Replace tail recursion with iteration -if.statement.with.too.many.branches.max.option: - text: 'Maximum number of branches:' -if.statement.with.too.many.branches.problem.descriptor: - text: '#ref has too many branches ({0}) #loc' -negated.conditional.ignore.option: - text: Ignore '!= null' comparisons -negated.conditional.invert.quickfix: - text: Invert condition -negated.if.else.ignore.negated.null.option: - text: Ignore '!= null' comparisons -negated.if.else.ignore.negated.zero.option: - text: Ignore '!= 0' comparisons -negated.if.else.invert.quickfix: - text: Invert 'if' condition + text: 'Maximum number of terms:' +overly.complex.arithmetic.expression.problem.descriptor: + text: 'Overly complex arithmetic expression #loc' +overly.complex.boolean.expression.display.name: + text: Overly complex boolean expression +overly.complex.boolean.expression.ignore.option: + text: Ignore pure conjunctions and disjunctions overly.complex.boolean.expression.max.terms.option: - text: 'Maximum number of terms:' + text: 'Maximum number of terms:' +overly.complex.boolean.expression.problem.descriptor: + text: 'Overly complex boolean expression ({0} terms) #loc' +overly.complex.class.display.name: + text: Overly complex class +overly.complex.class.problem.descriptor: + text: 'Overly complex class #ref (cyclomatic complexity = {0}) #loc' +overly.coupled.class.class.coupling.limit.option: + text: 'Class coupling limit:' +overly.coupled.class.display.name: + text: Overly coupled class +overly.coupled.class.problem.descriptor: + text: '#ref is overly coupled (dependencies = {0}) #loc' +overly.long.lambda.display.name: + text: Overly long lambda expression +overly.long.lambda.problem.descriptor: + text: 'Lambda expression is too long (# Non-comment source statements = {0}) #loc' +overly.strong.type.cast.display.name: + text: Overly strong type cast +overly.strong.type.cast.ignore.in.matching.instanceof.option: + text: Ignore casts with a matching instanceof expression +overly.strong.type.cast.problem.descriptor: + text: 'Cast to #ref can be weakened to ''''{0}'''' #loc' +overly.strong.type.cast.weaken.quickfix: + text: Weaken overly strong cast +overridable.method.call.in.constructor.display.name: + text: Overridable method called during object construction +overridable.method.call.in.constructor.problem.descriptor: + text: 'Call to overridable method #ref() during object construction #loc' +overridden.method.call.in.constructor.display.name: + text: Overridden method called during object construction +overridden.method.call.in.constructor.problem.descriptor: + text: 'Call to overridden method #ref() during object construction #loc' +package.dot.html.may.be.package.info.convert.quickfix: + text: Convert to 'package-info.java' +package.dot.html.may.be.package.info.delete.quickfix: + text: Delete 'package.html' +package.dot.html.may.be.package.info.display.name: + text: '''package.html'' may be converted to ''package-info.java''' +package.dot.html.may.be.package.info.exists.problem.descriptor: + text: package.html is ignored because package-info.java exists +package.dot.html.may.be.package.info.problem.descriptor: + text: package.html may be converted to package-info.java +package.in.multiple.modules.display.name: + text: Package with classes in multiple modules +package.in.multiple.modules.problem.descriptor: + text: Package ''{0}'' has classes in multiple modules +package.info.java.without.package.display.name: + text: '''package-info.java'' without ''package'' statement' +package.info.without.package.family.quickfix: + text: Add package statement +package.info.without.package.problem.descriptor: + text: '''package-info.java'' does not have a ''package'' statement' +package.info.without.package.quickfix: + text: Add ''package {0};'' +package.local.field.not.accessible: + text: Package-private field ''{0}'' is not accessible from here +package.local.private: + text: package-private \& private +package.naming.convention.display.name: + text: Package naming convention +package.naming.convention.problem.descriptor.long: + text: Package name {0} is too long +package.naming.convention.problem.descriptor.regex.mismatch: + text: Package name {0} doesn''t match regex ''{1}'' +package.naming.convention.problem.descriptor.short: + text: Package name {0} is too short +package.visible.field.display.name: + text: Package-visible field +package.visible.field.problem.descriptor: + text: 'Package-visible field #ref #loc' +package.visible.inner.class.display.name: + text: Package-visible nested class +package.visible.inner.class.ignore.enum.option: + text: Ignore package-visible inner enums +package.visible.inner.class.ignore.interface.option: + text: Ignore package-visible inner interfaces +package.visible.inner.class.problem.descriptor: + text: 'Package-visible nested class #ref #loc' +package.with.too.few.classes.display.name: + text: Package with too few classes +package.with.too.few.classes.min.option: + text: 'Minimum number of classes:' +package.with.too.few.classes.problem.descriptor: + text: Package ''{0}'' contains too few classes ({1} < {2}) +package.with.too.many.classes.display.name: + text: Package with too many classes +package.with.too.many.classes.max.option: + text: 'Maximum number of classes:' +package.with.too.many.classes.problem.descriptor: + text: Package ''{0}'' contains too many classes ({1} > {2}) +parameter.hides.member.variable.display.name: + text: Parameter hides field +parameter.hides.member.variable.ignore.abstract.methods.option: + text: Ignore for abstract methods +parameter.hides.member.variable.ignore.constructors.option: + text: Ignore for constructors +parameter.hides.member.variable.ignore.setters.option: + text: Ignore for property setters +parameter.hides.member.variable.ignore.static.parameters.option: + text: Ignore for static method parameters hiding instance fields +parameter.hides.member.variable.ignore.superclass.option: + text: Ignore superclass fields not visible from subclass +parameter.hides.member.variable.problem.descriptor: + text: 'Parameter #ref hides field in class ''''{0}'''' #loc' +parameter.limit.option: + text: 'Parameter limit:' +parameter.name.differs.from.overridden.parameter.display.name: + text: Parameter name differs from parameter in overridden method +parameter.name.differs.from.overridden.parameter.ignore.character.option: + text: Ignore if overridden parameter contains only one character +parameter.name.differs.from.overridden.parameter.ignore.library.option: + text: Ignore if overridden parameter is from a library +parameter.name.differs.from.overridden.parameter.problem.descriptor: + text: 'Parameter name #ref is different from parameter ''''{0}'''' overridden #loc' +parameter.naming.convention.display.name: + text: Method parameter naming convention +parameter.naming.convention.element.description: + text: Parameter +parameter.of.concrete.class.option: + text: Ignore parameters whose type is abstract class +parameter.type.prevents.overriding.display.name: + text: Parameter type prevents overriding +parameter.type.prevents.overriding.family.quickfix: + text: Change type of parameter +parameter.type.prevents.overriding.problem.descriptor: + text: 'Parameter type #ref is located in ''''{0}'''' while super method parameter type is located in ''''{1}'''' preventing overriding #loc' +parameter.type.prevents.overriding.quickfix: + text: Change type of parameter to ''{0}'' +parameters.per.constructor.display.name: + text: Constructor with too many parameters +parameters.per.constructor.problem.descriptor: + text: '#ref() has too many parameters (num parameters = {0}) #loc' +parameters.per.method.display.name: + text: Method with too many parameters +parameters.per.method.problem.descriptor: + text: '#ref() has too many parameters (num parameters = {0}) #loc' +placeholder.count.matches.argument.count.display.name: + text: Number of placeholders does not match number of arguments in logging call +placeholder.count.matches.argument.count.fewer.problem.descriptor: + text: 'Fewer arguments provided ({0}) than placeholders specified ({1}) #loc' +placeholder.count.matches.argument.count.more.problem.descriptor: + text: 'More arguments provided ({0}) than placeholders specified ({1}) #loc' +pointless.arithmetic.expression.display.name: + text: Pointless arithmetic expression +pointless.bitwise.expression.display.name: + text: Pointless bitwise expression +pointless.bitwise.expression.simplify.quickfix: + text: Simplify +pointless.boolean.expression.display.name: + text: Pointless boolean expression pointless.boolean.expression.ignore.option: - text: Ignore named constants in determining pointless expressions -simplifiable.conditional.expression.problem.descriptor: - text: '#ref can be simplified to ''''{0}'''' #loc' -simplifiable.if.statement.problem.descriptor: - text: '#ref statement can be replaced with ''''{0}'''' #loc' -switch.statement.density.min.option: - text: 'Minimum density of branches: %' -switch.statement.density.problem.descriptor: - text: '#ref has too low of a branch density ({0}%) #loc' -switch.statement.with.too.few.branches.min.option: - text: 'Minimum number of branches:' -switch.statement.with.too.few.branches.problem.descriptor: - text: '#ref has too few branches ({0}), and should probably be replaced with an ''''if'''' statement #loc' -switch.statement.without.default.ignore.option: - text: Ignore if all cases of an enumerated type are covered -unnecessary.label.remove.quickfix: - text: Remove label -unnecessary.return.problem.descriptor: - text: '#ref is unnecessary as the last statement in a ''void'' method #loc' -unnecessary.return.constructor.problem.descriptor: - text: '#ref is unnecessary as the last statement in a constructor #loc' -unused.label.remove.quickfix: - text: Remove unused label -unnecessarily.qualified.static.usage.problem.descriptor: - text: 'Unnecessarily qualified static method call {0}() #loc' -unnecessarily.qualified.static.usage.problem.descriptor1: - text: 'Unnecessarily qualified static access {0} #loc' -unnecessarily.qualified.static.usage.ignore.field.option: - text: Ignore unnecessarily qualified field accesses -unnecessarily.qualified.static.usage.ignore.method.option: - text: Ignore unnecessarily qualified method calls -unnecessary.interface.modifier.problem.descriptor: - text: 'Modifier #ref is redundant for interfaces #loc' -unnecessary.interface.modifier.inner.interface.of.interface.problem.descriptor: - text: 'Modifier #ref is redundant for inner interfaces #loc' -unnecessary.interface.modifier.problem.descriptor2: - text: 'Modifier #ref is redundant for interface methods #loc' -unnecessary.interface.modifier.problem.descriptor3: - text: 'Modifier #ref is redundant for inner classes of interfaces #loc' -unnecessary.interface.modifier.problem.descriptor4: - text: 'Modifier #ref is redundant for interface fields #loc' -smth.unnecessary.remove.quickfix: - text: Remove unnecessary ''{0}'' -unqualified.static.usage.problem.descriptor: - text: 'Unqualified static method call #ref() #loc' -unqualified.static.usage.problem.descriptor1: - text: 'Unqualified static field access #ref #loc' -unqualified.static.usage.ignore.field.option: - text: Ignore unqualified field accesses -unqualified.static.usage.ignore.method.option: - text: Ignore unqualified method calls -unqualified.static.usage.qualify.field.quickfix: - text: Qualify static field access -unqualified.static.usage.qualify.method.quickfix: - text: Qualify static method call -too.broad.scope.allow.option: - text: 'Report variables with a new expression as initializer
(Potentially unsafe: quick fix may modify semantics if the constructor has non-local side-effects)' -too.broad.scope.only.blocks.option: - text: Only report variables that can be moved into inner blocks -too.broad.scope.narrow.quickfix: - text: Move declaration of ''{0}'' closer to usages + text: Ignore named constants in determining pointless expressions +pointless.indexof.comparison.always.false.problem.descriptor: + text: '#ref is always false #loc' +pointless.indexof.comparison.always.true.problem.descriptor: + text: '#ref is always true #loc' +pointless.indexof.comparison.display.name: + text: Pointless 'indexOf()' comparison +pointless.nullcheck.after.problem.descriptor: + text: Unnecessary 'null' check after 'instanceof' expression +pointless.nullcheck.display.name: + text: Unnecessary 'null' check before 'instanceof' expression +pointless.nullcheck.problem.descriptor: + text: Unnecessary 'null' check before 'instanceof' expression +pointless.nullcheck.simplify.quickfix: + text: Remove unnecessary ''{0}'' condition +possible.throw.from.finally.block.problem.descriptor: + text: '{0} might be thrown inside ''''finally'''' block #loc' press.escape.to.remove.highlighting.message: - text: Press Escape to remove the highlighting -unnecessary.enum.modifier.problem.descriptor: - text: 'Modifier #ref is redundant for enum constructors #loc' -unnecessary.enum.modifier.problem.descriptor1: - text: 'Modifier #ref is redundant for inner enums #loc' -literal.as.arg.to.string.equals.problem.descriptor: - text: '#ref is argument of ''''{0}()'''', instead of its target #loc' -literal.as.arg.to.string.equals.flip.quickfix: - text: Flip 'equals()' -c.style.array.declaration.replace.quickfix: - text: Replace with Java-style array declaration -chained.method.call.ignore.option: - text: Ignore chained method calls in field initializers -chained.method.call.ignore.this.super.option: - text: Ignore chained method calls in 'this()' and 'super()' calls -introduce.variable.quickfix: - text: Introduce variable -introduce.variable.may.change.semantics.quickfix: - text: Introduce variable (may change semantics) -flip.comparison.quickfix: - text: Flip comparison -control.flow.statement.without.braces.add.quickfix: - text: Add braces to statement -control.flow.statement.without.braces.message: - text: Add braces to ''{0}'' statement -extends.object.remove.quickfix: - text: Remove redundant 'extends Object' -implicit.call.to.super.ignore.option: - text: Ignore for direct subclasses of 'java.lang.Object' -implicit.call.to.super.make.explicit.quickfix: - text: Make call to 'super()' explicit -missorted.modifiers.require.option: - text: Require annotations to be sorted before keywords -missorted.modifiers.sort.quickfix: - text: Sort modifiers -nested.method.call.ignore.option: - text: Ignore nested method calls in field initializers -ignore.calls.to.static.methods: - text: Ignore calls to static methods -ignore.calls.to.property.getters: - text: Ignore calls to property getters + text: Press Escape to remove the highlighting +primitive.array.argument.to.var.arg.method.display.name: + text: Confusing primitive array argument to varargs method +primitive.array.argument.to.var.arg.method.problem.descriptor: + text: 'Confusing primitive array argument to varargs method #loc' +primitive.fields.ignore.option: + text: Ignore primitive fields +printstacktrace.call.display.name: + text: Call to 'printStackTrace()' +printstacktrace.call.problem.descriptor: + text: 'Call to #ref() should probably be replaced with more robust logging #loc' +private.field.not.accessible.problem.descriptor: + text: '''''private'''' field ''''{0}'''' is not accessible from here' +private.member.access.between.outer.and.inner.classes.display.name: + text: Synthetic accessor call +private.member.access.between.outer.and.inner.classes.make.constructor.package.local.quickfix: + text: Make ''{0}'' constructor package-private +private.member.access.between.outer.and.inner.classes.make.local.quickfix: + text: Make ''{0}'' package-private +private.member.access.between.outer.and.inner.classes.problem.descriptor: + text: 'Access to ''private'' member of class ''''{0}'''' requires synthetic accessor call #loc' +private.modifier: + text: private +problematic.varargs.method.display.name: + text: Non-varargs method overrides varargs method +problematic.varargs.method.override.problem.descriptor: + text: 'Non-varargs method #ref() overrides varargs method #loc' +properties.object.as.hashtable.display.name: + text: Use of 'Properties' object as a 'Hashtable' +properties.object.as.hashtable.get.quickfix: + text: Replace with call to 'getProperty()' +properties.object.as.hashtable.problem.descriptor: + text: 'Call to Hashtable.#ref() on properties object #loc' +properties.object.as.hashtable.set.quickfix: + text: Replace with call to 'setProperty()' +property.value.set.to.itself.display.name: + text: Property value set to itself +protected.field.display.name: + text: Protected field +protected.field.not.accessible.problem.descriptor: + text: '''''protected'''' field ''''{0}'''' is not accessible from here' +protected.field.problem.descriptor: + text: 'Protected field #ref #loc' +protected.inner.class.display.name: + text: Protected nested class +protected.inner.class.ignore.enum.option: + text: Ignore 'protected' inner enums +protected.inner.class.ignore.interface.option: + text: Ignore 'protected' inner interfaces +protected.inner.class.problem.descriptor: + text: 'Protected nested class #ref #loc' +protected.member.in.final.class.display.name: + text: '''protected'' member in ''final'' class' +protected.member.in.final.class.problem.descriptor: + text: 'Class member declared #ref in ''final'' class #loc' +protected.package.local.private: + text: protected, package-private \& private +public.constructor.display.name: + text: '''public'' constructor' +public.constructor.in.non.public.class.display.name: + text: '''public'' constructor in non-public class' +public.constructor.in.non.public.class.problem.descriptor: + text: 'Constructor is declared #ref in non-public class ''''{0}'''' #loc' +public.constructor.in.non.public.class.quickfix: + text: Make constructor ''{0}'' +public.constructor.problem.descriptor: + text: 'Public constructor #ref() #loc' +public.constructor.quickfix: + text: Replace constructor with factory method +public.default.constructor.problem.descriptor: + text: Class #ref has 'public' default constructor +public.field.accessed.in.synchronized.context.display.name: + text: Non-private field accessed in 'synchronized' context +public.field.accessed.in.synchronized.context.problem.descriptor: + text: 'Non-private field #ref accessed in synchronized context #loc' +public.field.display.name: + text: '''public'' field' +public.field.ignore.enum.type.fields.option: + text: Ignore 'public final' fields of an enum type +public.field.problem.descriptor: + text: '''public'' field #ref #loc' +public.inner.class.display.name: + text: '''public'' nested class' +public.inner.class.ignore.enum.option: + text: Ignore 'public' inner enums +public.inner.class.ignore.interface.option: + text: Ignore 'public' inner interfaces +public.inner.class.problem.descriptor: + text: '''public'' nested class #ref #loc' +public.method.not.in.interface.display.name: + text: '''public'' method not exposed in interface' +public.method.not.in.interface.option: + text: Ignore if the containing class does not implement a non-library interface +public.method.not.in.interface.problem.descriptor: + text: '''public'' method #ref() is not exposed via an interface #loc' +public.method.without.logging.display.name: + text: '''public'' method without logging' +public.method.without.logging.problem.descriptor: + text: '''public'' method #ref() has no logging call #loc' +public.static.array.field.display.name: + text: '''public static'' array field' +public.static.array.field.problem.descriptor: + text: '''public static'' array field #ref, compromising security #loc' +public.static.collection.field.display.name: + text: '''public static'' collection field' +public.static.collection.field.problem.descriptor: + text: '''public static'' collection field #ref, compromising security #loc' +query.column.name: + text: Query names start with +questionable.name.column.title: + text: Name +questionable.name.display.name: + text: Questionable name +questionable.name.problem.descriptor: + text: 'Questionable name #ref #loc' +random.double.for.random.integer.display.name: + text: Using 'Random.nextDouble()' to get random integer +random.double.for.random.integer.problem.descriptor: + text: 'Using Random.#ref to create random integer #loc' +random.double.for.random.integer.replace.quickfix: + text: Replace with 'nextInt()' +raw.use.of.parameterized.type.display.name: + text: Raw use of parameterized class +raw.use.of.parameterized.type.ignore.new.objects.option: + text: Ignore construction of new objects +raw.use.of.parameterized.type.ignore.overridden.parameter.option: + text: Ignore parameter types of overriding methods +raw.use.of.parameterized.type.ignore.type.casts.option: + text: Ignore type casts +raw.use.of.parameterized.type.ignore.uncompilable.option: + text: Ignore where a type parameter would not compile +raw.use.of.parameterized.type.problem.descriptor: + text: 'Raw use of parameterized class #ref #loc' +readobject.initialization.display.name: + text: Instance field may not be initialized by 'readObject()' +readobject.initialization.problem.descriptor: + text: 'Instance field #ref may not be initialized during ''readObject()'' call #loc' +readresolve.writereplace.protected.display.name: + text: '''readResolve()'' or ''writeReplace()'' not declared ''protected''' +readresolve.writereplace.protected.problem.descriptor: + text: '#ref() not declared ''protected'' #loc' +readwriteobject.private.display.name: + text: '''readObject()'' or ''writeObject()'' not declared ''private''' +readwriteobject.private.problem.descriptor: + text: '#ref not declared ''private'' #loc' +recordstore.opened.not.safely.closed.display.name: + text: "'RecordStore' opened but not safely closed" +redundant.else.display.name: + text: Redundant 'else' +redundant.else.problem.descriptor: + text: '#ref branch may be unwrapped, as the ''if'' branch never completes normally #loc' +redundant.else.unwrap.quickfix: + text: Remove redundant 'else' +redundant.field.initialization.display.name: + text: Redundant field initialization +redundant.field.initialization.problem.descriptor: + text: 'Field initialization to #ref is redundant #loc' redundant.field.initialization.remove.quickfix: - text: Remove initializer + text: Remove initializer +redundant.implements.display.name: + text: Redundant interface declaration +redundant.implements.problem.descriptor: + text: 'Redundant interface declaration #ref #loc' redundant.implements.remove.quickfix: - text: Remove redundant interface declaration -unnecessary.constructor.remove.quickfix: - text: Remove redundant constructor -unnecessary.fully.qualified.name.replace.quickfix: - text: Replace with import -unnecessary.fully.qualified.name.remove.quickfix: - text: Remove qualification -unnecessary.fully.qualified.name.status.bar.escape.highlighting.message: - text: '{0} fully qualified {0, choice, 1#name|2#names} replaced with import (press Escape to remove highlighting)' -unnecessary.parentheses.remove.quickfix: - text: Remove unnecessary parentheses -unnecessary.qualifier.for.this.remove.quickfix: - text: Remove unnecessary qualifier -unnecessary.semicolon.remove.quickfix: - text: Remove unnecessary semicolon -unnecessary.super.constructor.remove.quickfix: - text: Remove unnecessary 'super()' -unnecessary.this.remove.quickfix: - text: Remove unnecessary 'this' qualifier -overly.strong.type.cast.problem.descriptor: - text: 'Cast to #ref can be weakened to ''''{0}'''' #loc' -field.count.inspection.include.constant.fields.in.count.checkbox: - text: Include constant fields in count -field.count.inspection.static.final.fields.count.as.constant.checkbox: - text: '''static final'' fields count as constant' -field.count.inspection.include.enum.constants.in.count: - text: Include enum constants in count -make.method.final.fix.name: - text: Make method ''{0}()'' ''final'' -make.class.final.fix.name: - text: Make class ''{0}'' ''final'' -non.boolean.method.name.must.not.start.with.question.display.name: - text: Non-boolean method name must not start with question word -non.boolean.method.name.must.not.start.with.question.problem.descriptor: - text: 'Non-boolean method name #ref starts with a question word #loc' -boolean.constructor.simplify.quickfix: - text: Simplify -unnecessary.temporary.on.conversion.from.string.problem.descriptor: - text: '#ref #loc can be simplified to ''''{0}''''' -unnecessary.temporary.on.conversion.from.string.fix.name: - text: Replace with ''{0}'' -only.report.qualified.static.usages.option: - text: Only report qualified static access from a static context -unqualified.static.usage.only.report.static.usages.option: - text: Only report static access from a non-static context -assignment.to.catch.block.parameter.problem.descriptor: - text: 'Assignment to ''catch'' block parameter #ref #loc' -assignment.to.method.parameter.problem.descriptor: - text: 'Assignment to method parameter #ref #loc' -value.of.post.increment.problem.descriptor: - text: 'Value of post-increment expression #ref is used #loc' -value.of.post.decrement.problem.descriptor: - text: 'Value of post-decrement expression #ref is used #loc' -value.of.pre.increment.problem.descriptor: - text: 'Value of pre-increment expression #ref is used #loc' -value.of.pre.decrement.problem.descriptor: - text: 'Value of pre-decrement expression #ref is used #loc' -assignment.replaceable.with.operator.assignment.problem.descriptor: - text: '#ref could be simplified to ''''{0}'''' #loc' -assignment.replaceable.with.operator.assignment.ignore.conditional.operators.option: - text: Ignore conditional operators -assignment.replaceable.with.operator.assignment.ignore.obscure.operators.option: - text: Ignore the obscure ^ and % operators -assignment.replaceable.with.operator.replace.quickfix: - text: Replace ''='' with ''{0}='' -object.equality.ignore.between.objects.of.a.type.with.only.private.constructors.option: - text: Ignore '==' between objects of a type with only 'private' constructors + text: Remove redundant interface declaration +redundant.import.display.name: + text: Redundant import +redundant.import.problem.descriptor: + text: 'Redundant import #ref #loc' +redundant.local.variable.annotation.option: + text: Ignore variables which have an annotation +redundant.local.variable.display.name: + text: Redundant local variable +redundant.local.variable.ignore.option: + text: Ignore immediately returned or thrown variables redundant.method.override.display.name: - text: Method is identical to its super method + text: Method is identical to its super method redundant.method.override.problem.descriptor: - text: 'Method #ref() is identical to its super method #loc' + text: 'Method #ref() is identical to its super method #loc' redundant.method.override.quickfix: - text: Remove redundant method -refused.bequest.problem.descriptor: - text: 'Method #ref() does not call ''super.#ref()'' #loc' + text: Remove redundant method +redundant.string.format.call.display.name: + text: Redundant call to 'String.format()' +redundant.string.format.call.problem.descriptor: + text: 'Redundant call to #ref #loc' +redundant.string.format.call.quickfix: + text: Remove redundant call to 'String.format()' +reflection.for.unavailable.annotation.display.name: + text: Reflective access to a source-only annotation +reflection.for.unavailable.annotation.problem.descriptor: + text: 'Annotation ''#ref'' is not retained for reflective access #loc' +refused.bequest.display.name: + text: Method does not call super method refused.bequest.ignore.empty.super.methods.option: - text: Ignore empty super methods -overly.complex.boolean.expression.ignore.option: - text: Ignore pure conjunctions and disjunctions -pointless.indexof.comparison.display.name: - text: Pointless 'indexOf()' comparison -pointless.indexof.comparison.always.true.problem.descriptor: - text: '#ref is always true #loc' -pointless.indexof.comparison.always.false.problem.descriptor: - text: '#ref is always false #loc' + text: Ignore empty super methods +refused.bequest.problem.descriptor: + text: 'Method #ref() does not call ''super.#ref()'' #loc' +remove.annotation.parameter.0.fix.name: + text: Remove annotation parameter ''{0}'' +remove.finally.block.quickfix: + text: Remove 'finally' block +remove.junit4.test.annotation.and.rename.quickfix: + text: Remove ''@Test'' annotation and rename to ''{0}'' +remove.junit4.test.annotation.quickfix: + text: Remove '@Test' annotation +remove.leading.zero.to.make.decimal.quickfix: + text: Remove leading zero to make decimal +remove.modifier.quickfix: + text: Remove ''{0}'' modifier +remove.try.catch.quickfix: + text: Remove 'try catch' statement +remove.try.finally.block.quickfix: + text: Remove 'try-finally' block +rename.catch.parameter.to.ignored: + text: Rename 'catch' parameter to 'ignored' +rename.quickfix: + text: Rename +renameto.quickfix: + text: Rename to ''{0}'' +replace.all.dot.display.name: + text: Call to String.replaceAll(".", ...) +replace.all.dot.problem.descriptor: + text: 'Call to String.#ref(".", ...) #loc' +replace.assertequals.quickfix: + text: Replace with ''{0}'' +replace.indexof.with.contains.quickfix: + text: Replace 'indexOf()' with 'contains()' +replace.inheritance.with.delegation.quickfix: + text: Replace inheritance with delegation +replace.reference.with.expression.quickfix: + text: Replace with ''{0}'' +replace.with: + text: Replace with ''{0}'' +replace.with.arrays.deep.equals: + text: Replace with 'Arrays.deepEquals()' +replace.with.arrays.equals: + text: Replace with 'Arrays.equals()' +replace.with.catch.clause.for.runtime.exception.quickfix: + text: Replace with 'catch' clause for 'RuntimeException' +resource.opened.not.closed.problem.descriptor: + text: '''''{0}'''' should be opened in front of a ''''try'''' block and closed in the corresponding ''''finally'''' block #loc' +result.of.method.call.ignored.class.column.title: + text: Class Name +result.of.method.call.ignored.display.name: + text: Result of method call ignored +result.of.method.call.ignored.method.column.title: + text: Method name regex +result.of.method.call.ignored.non.library.option: + text: Report all ignored non-library calls +result.of.method.call.ignored.problem.descriptor: + text: 'Result of {0}.#ref() is ignored #loc' +result.of.object.allocation.ignored.display.name: + text: Result of object allocation ignored +result.of.object.allocation.ignored.problem.descriptor: + text: 'Result of new #ref() is ignored #loc' +return.date.calendar.field.display.name: + text: Return of Date or Calendar field +return.date.calendar.field.problem.descriptor: + text: 'Return of ''''{0}'''' field #ref #loc' +return.date.calendar.field.quickfix: + text: Return clone of ''{0}'' +return.from.finally.block.display.name: + text: '''return'' inside ''finally'' block' +return.from.finally.block.problem.descriptor: + text: '#ref inside ''finally'' block #loc' +return.of.anonymous.class.problem.descriptor: + text: 'Return of instance of anonymous class #loc' +return.of.collection.array.field.display.name: + text: Return of Collection or array field +return.of.collection.array.field.option: + text: Ignore 'private' methods returning an array or collection field +return.of.collection.array.field.problem.descriptor.array: + text: '''return'' of array field #ref #loc' +return.of.collection.array.field.problem.descriptor.collection: + text: '''return'' of Collection field #ref #loc' +return.of.collection.field.quickfix: + text: Replace with ''{0}'' +return.of.inner.class.display.name: + text: Return of instance of anonymous, local or inner class +return.of.inner.class.ignore.non.public.option: + text: Ignore returns from non-public methods +return.of.inner.class.problem.descriptor: + text: 'Return of instance of non-static inner class {0} #loc' +return.of.local.class.problem.descriptor: + text: 'Return of instance of local class {0} #loc' +return.of.null.arrays.option: + text: Report methods that return arrays +return.of.null.collections.option: + text: Report methods that return collection objects +return.of.null.display.name: + text: Return of 'null' +return.of.null.ignore.private.option: + text: Ignore 'private' methods +return.of.null.objects.option: + text: Report methods that return objects +return.of.null.optional.quickfix: + text: Replace with ''{0}.{1}()'' +return.of.null.optional.quickfix.family: + text: Replace with 'Optional.empty()' +return.of.null.problem.descriptor: + text: 'Return of #ref #loc' +return.of.null.quickfix: + text: Annotate method as @Nullable +return.point.limit.option: + text: '&Return point limit:' +return.this.display.name: + text: Return of 'this' +return.this.problem.descriptor: + text: 'Return of #ref #loc' +reuse.of.local.variable.display.name: + text: Reuse of local variable reuse.of.local.variable.problem.descriptor: - text: 'Reuse of local variable #ref #loc' + text: 'Reuse of local variable #ref #loc' +reuse.of.local.variable.split.quickfix: + text: Split local variable +runtime.exec.call.display.name: + text: Call to 'Runtime.exec()' +runtime.exec.call.problem.descriptor: + text: 'Call to Runtime.#ref() is non-portable #loc' +runtime.exec.with.non.constant.string.display.name: + text: Call to 'Runtime.exec()' with non-constant string +runtime.exec.with.non.constant.string.problem.descriptor: + text: 'Call to Runtime.#ref() with non-constant argument #loc' +safe.lock.display.name: + text: Lock acquired but not safely unlocked +safe.lock.problem.descriptor: + text: '''''{0}'''' should be locked in front of a ''''try'''' block and unlocked in the corresponding ''''finally'''' block #loc' +serializable.anonymous.class.stores.non.serializable.problem.descriptor: + text: Serializable anonymous class implicitly stores non-Serializable object of type ''{0}'' +serializable.class.in.secure.context.display.name: + text: Serializable class in secure context +serializable.class.in.secure.context.problem.descriptor: + text: 'Class #ref may be serialized, compromising security #loc' +serializable.class.without.serialversionuid.display.name: + text: Serializable class without 'serialVersionUID' +serializable.class.without.serialversionuid.problem.descriptor: + text: '#ref does not define a ''serialVersionUID'' field #loc' +serializable.has.serialization.methods.display.name: + text: Serializable class without 'readObject()' and 'writeObject()' +serializable.has.serialization.methods.ignore.option: + text: Ignore classes that do not define instance fields +serializable.has.serialization.methods.problem.descriptor: + text: 'Serializable class #ref does not define ''readObject()'' or ''writeObject()'' #loc' +serializable.has.serialization.methods.problem.descriptor1: + text: 'Serializable class #ref does not define ''writeObject()'' #loc' +serializable.has.serialization.methods.problem.descriptor2: + text: 'Serializable class #ref does not define ''readObject()'' #loc' +serializable.inner.class.has.serial.version.uid.field.display.name: + text: Serializable non-static inner class without 'serialVersionUID' +serializable.inner.class.has.serial.version.uid.field.problem.descriptor: + text: 'Inner class #ref does not define a ''serialVersionUID'' field #loc' +serializable.inner.class.with.non.serializable.outer.class.display.name: + text: Serializable non-'static' inner class with non-Serializable outer class +serializable.inner.class.with.non.serializable.outer.class.problem.descriptor: + text: 'Inner class #ref is serializable while its outer class is not #loc' +serializable.lambda.stores.non.serializable.problem.descriptor: + text: Serializable lambda implicitly stores non-Serializable object of type ''{0}'' +serializable.local.class.stores.non.serializable.problem.descriptor: + text: Serializable local class ''{1}'' implicitly stores non-Serializable object of type ''{0}'' +serializable.stores.non.serializable.display.name: + text: '''Serializable'' object implicitly stores non-''Serializable'' object' +serializable.with.unconstructable.ancestor.display.name: + text: Serializable class with unconstructable ancestor +serializable.with.unconstructable.ancestor.problem.descriptor: + text: '#ref has a non-serializable ancestor ''''{0}'''' without no-arg constructor #loc' +serialpersistentfields.with.wrong.signature.display.name: + text: '''serialPersistentFields'' field not declared ''private static final ObjectStreamField[]''' +serialpersistentfields.with.wrong.signature.problem.descriptor: + text: '#ref field of a Serializable class is not declared ''private static final ObjectStreamField[]'' #loc' +serialversionuid.private.static.final.long.display.name: + text: '''serialVersionUID'' field not declared ''private static final long''' +serialversionuid.private.static.final.long.problem.descriptor: + text: '#ref field of a Serializable class is not declared ''private static final long'' #loc' +serialversionuid.private.static.final.long.quickfix: + text: Make serialVersionUID 'private static final' +set.annotation.parameter.0.1.fix.name: + text: Set annotation parameter {0} = "{1}" +set.replaceable.by.enum.set.display.name: + text: '''Set'' can be replaced with ''EnumSet''' +set.replaceable.by.enum.set.problem.descriptor: + text: '#ref can be replaced with ''EnumSet'' #loc' +shared.thread.local.random.display.name: + text: '''ThreadLocalRandom'' instance might be shared' +shared.thread.local.random.problem.descriptor: + text: '''ThreadLocalRandom'' instance might be shared between threads' +shift.operation.by.inappropriate.constant.display.name: + text: Shift operation by inappropriate constant +shift.operation.by.inappropriate.constant.problem.descriptor.negative: + text: 'Shift operation #ref by negative constant value #loc' +shift.operation.by.inappropriate.constant.problem.descriptor.too.large: + text: 'Shift operation #ref by overly large constant value #loc' +shift.out.of.range.quickfix: + text: Replace ''{0}'' with ''{1}'' +signal.without.corresponding.await.display.name: + text: '''signal()'' without corresponding ''await()''' +signal.without.corresponding.await.problem.descriptor: + text: 'Call to #ref() without corresponding await() #loc' +simplifiable.annotation.display.name: + text: Simplifiable annotation +simplifiable.annotation.problem.descriptor: + text: 'Unnecessary #ref in annotation #loc' +simplifiable.annotation.quickfix: + text: Simplify annotation +simplifiable.annotation.whitespace.problem.descriptor: + text: 'Unnecessary whitespace in annotation #loc' +simplifiable.boolean.expression.display.name: + text: Simplifiable boolean expression +simplifiable.conditional.expression.display.name: + text: Simplifiable conditional expression +simplifiable.conditional.expression.problem.descriptor: + text: '#ref can be simplified to ''''{0}'''' #loc' +simplifiable.equals.expression.display.name: + text: Unnecessary 'null' check before 'equals()' call +simplifiable.equals.expression.problem.descriptor: + text: 'Unnecessary ''''null'''' check before ''''{0}()'''' call #loc' +simplifiable.equals.expression.quickfix: + text: Flip ''.{0}()'' and remove unnecessary ''null'' check +simplifiable.if.statement.display.name: + text: '''if'' statement may be replaced with \&\& or || expression' +simplifiable.if.statement.problem.descriptor: + text: '#ref statement can be replaced with ''''{0}'''' #loc' +simplifiable.junit.assertion.display.name: + text: Simplifiable assertion +simplifiable.junit.assertion.problem.descriptor: + text: '#ref() can be simplified to ''''{0}'''' #loc' +simplifiable.testng.assertion.display.name: + text: Simplifiable TestNG assertion +simplify.junit.assertion.simplify.quickfix: + text: Simplify assertion single.character.startswith.display.name: - text: Single character 'startsWith()' or 'endsWith()' + text: Single character 'startsWith()' or 'endsWith()' single.character.startswith.problem.descriptor: - text: 'Single character #ref() could be replaced with ''charAt()'' expression #loc' -indexof.replaceable.by.contains.display.name: - text: '''indexOf()'' expression is replaceable with ''contains()''' -replace.indexof.with.contains.quickfix: - text: Replace 'indexOf()' with 'contains()' -overloaded.methods.with.same.number.parameters.problem.descriptor: - text: 'Multiple methods named #ref with the same number of parameters #loc' -overloaded.vararg.method.problem.descriptor: - text: 'Overloaded varargs method #ref() #loc' -overloaded.vararg.constructor.problem.descriptor: - text: 'Overloaded varargs constructor #ref() #loc' -cached.number.constructor.call.display.name: - text: Number constructor call with primitive argument -cached.number.constructor.call.problem.descriptor: - text: 'Number constructor call with primitive argument #loc' -cached.number.constructor.call.quickfix: - text: Replace with ''{0}.valueOf()'' call -cached.number.constructor.call.ignore.string.arguments.option: - text: Ignore new number expressions with a String argument -chained.equality.comparisons.problem.descriptor: - text: 'Chained equality comparison #ref #loc' -confusing.octal.escape.sequence.problem.descriptor: - text: 'Octal escape sequence #ref immediately followed by digit #loc' -field.accessed.synchronized.and.unsynchronized.option: - text: Simple getters and setters are considered field accesses too -method.overrides.inaccessible.method.display.name: - text: Method overrides inaccessible method of superclass -method.overrides.package.local.method.problem.descriptor: - text: 'Method #ref() overrides a package-private method of a superclass located in another package #loc' -suspicious.to.array.call.display.name: - text: Suspicious 'Collection.toArray()' call -suspicious.to.array.call.problem.descriptor: - text: 'Array of type ''''{0}[]'''' expected #loc' -suspicious.system.arraycopy.display.name: - text: Suspicious 'System.arraycopy()' call -suspicious.system.arraycopy.problem.descriptor1: - text: 'Parameter ''srcPos'' may not be negative #loc' -suspicious.system.arraycopy.problem.descriptor2: - text: 'Parameter ''destPos'' may not be negative #loc' -suspicious.system.arraycopy.problem.descriptor3: - text: 'Parameter ''length'' may not be negative #loc' -suspicious.system.arraycopy.problem.descriptor4: - text: '#ref is not of an array type #loc' -suspicious.system.arraycopy.problem.descriptor5: - text: '#ref is not of an array type #loc' -suspicious.system.arraycopy.problem.descriptor6: - text: 'Source parameter type ''''{0}'''' is not assignable to destination parameter #ref of type ''''{1}'''' #loc' -raw.use.of.parameterized.type.ignore.new.objects.option: - text: Ignore construction of new objects -raw.use.of.parameterized.type.ignore.type.casts.option: - text: Ignore type casts -raw.use.of.parameterized.type.ignore.uncompilable.option: - text: Ignore where a type parameter would not compile -raw.use.of.parameterized.type.ignore.overridden.parameter.option: - text: Ignore parameter types of overriding methods -method.only.used.from.inner.class.display.name: - text: Private method only used from inner class -method.only.used.from.inner.class.problem.descriptor.anonymous.extending: - text: 'Method #ref()#loc is only used from an anonymous class extending ''''{0}'''' #loc' -method.only.used.from.inner.class.problem.descriptor.anonymous.implementing: - text: 'Method #ref()#loc is only used from an anonymous class implementing ''''{0}'''' #loc' -method.only.used.from.inner.class.problem.descriptor: - text: 'Method #ref()#loc is only used from inner class ''''{0}'''' #loc' -method.only.used.from.inner.class.ignore.option: - text: Ignore methods accessed from an &anonymous class -ignore.static.methods.accessed.from.a.non.static.inner.class: - text: Ignore '&static' methods accessed from a non-'static' inner class -only.report.static.methods: - text: '&Only report ''static'' methods' -format.decode.error.requires.both.0.and.1: - text: requires both {0} and {1} -format.decode.any: - text: any -format.decode.date.time: - text: Date/Time -format.decode.char: - text: char -format.decode.integer.type: - text: integer type -format.decode.floating.point: - text: floating point + text: 'Single character #ref() can be replaced with ''charAt()'' expression #loc' single.character.startswith.quickfix: - text: Replace with 'charAt()' -interface.never.implemented.option: - text: Ignore interfaces which only declare constants + text: Replace with 'charAt()' +single.class.import.display.name: + text: Single class import +single.class.import.problem.descriptor: + text: 'Single class import #ref #loc' +single.element.annotation.family.quickfix: + text: Expand annotation to normal form +single.element.annotation.name: + text: Single-element annotation +single.element.annotation.quickfix: + text: Add 'value=' +single.statement.in.block.descriptor: + text: '''''{0}'''' contains single statement' +single.statement.in.block.family.quickfix: + text: Remove braces from statement +single.statement.in.block.name: + text: Code block contains single statement +single.statement.in.block.quickfix: + text: Remove braces from ''{0}'' statement +singleton.display.name: + text: Singleton +singleton.problem.descriptor: + text: 'Class #ref is a singleton #loc' size.replaceable.by.isempty.display.name: - text: '''size() == 0'' replaceable with ''isEmpty()''' -size.replaceable.by.isempty.quickfix: - text: Replace with 'isEmpty()' + text: '''size() == 0'' can be replaced with ''isEmpty()''' size.replaceable.by.isempty.negation.ignore.option: - text: Ignore expressions which would be replaced with '!isEmpty()' -ignored.classes.table: - text: Ignored classes -choose.class.type.to.ignore: - text: Choose class type to ignore -loop.condition.not.updated.inside.loop.display.name: - text: Loop variable not updated inside loop -loop.variable.not.updated.inside.loop.problem.descriptor: - text: 'Variable ''#ref'' is not updated inside loop #loc' -loop.condition.not.updated.inside.loop.problem.descriptor: - text: 'Condition ''#ref'' is not updated inside loop #loc' -utility.class.without.private.constructor.option: - text: Ignore classes with only a main method -super.class.logger.option: - text: Ignore classes with an accessible logger declared in a superclass + text: Ignore expressions which would be replaced with '!isEmpty()' +size.replaceable.by.isempty.quickfix: + text: Replace with 'isEmpty()' +sleep.while.holding.lock.display.name: + text: Call to 'Thread.sleep()' while synchronized +sleep.while.holding.lock.problem.descriptor: + text: 'Call to Thread.#ref() while synchronized #loc' +smth.unnecessary.remove.quickfix: + text: Remove unnecessary ''{0}'' +socket.opened.not.closed.display.name: + text: Socket opened but not safely closed +standard.variable.names.display.name: + text: Standard variable names +standard.variable.names.ignore.override.option: + text: Ignore for parameter names identical to super method parameters +standard.variable.names.problem.descriptor: + text: 'Variable named #ref doesn''''t have type ''''{0}'''' #loc' +standard.variable.names.problem.descriptor2: + text: 'Variable named #ref doesn''''t have type ''''{0}'''' or ''''{1}'''' #loc' +statement.problem.descriptor: + text: '#ref statement #loc' +statement.with.empty.body.display.name: + text: Statement with empty body +statement.with.empty.body.include.option: + text: Include statement bodies that are empty code blocks +statement.with.empty.body.problem.descriptor: + text: '#ref statement has empty body #loc' +static.collection.display.name: + text: Static collection +static.collection.ignore.option: + text: Ignore weak static collections or maps +static.collection.problem.descriptor: + text: 'Static collection #ref #loc' +static.field.via.subclass.display.name: + text: Static field referenced via subclass +static.field.via.subclass.problem.descriptor: + text: 'Static field #ref declared in class ''''{0}'''' but referenced via subclass ''''{1}'''' #loc' +static.field.via.subclass.rationalize.quickfix: + text: Rationalize static field access +static.import.display.name: + text: Static import +static.import.problem.descriptor: + text: 'Static import #ref #loc' +static.import.replace.quickfix: + text: Replace with non-static import +static.inheritance.display.name: + text: Static inheritance +static.inheritance.problem.descriptor: + text: 'Interface #ref is implemented only for its static constants #loc' +static.inheritance.replace.quickfix: + text: Replace inheritance with qualified references in {0} +static.initializer.references.subclass.display.name: + text: Static initializer references subclass +static.method.naming.convention.display.name: + text: '''static'' method naming convention' +static.method.naming.convention.element.description: + text: '''static'' method' +static.method.only.used.in.one.anonymous.class.problem.descriptor: + text: '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.display.name: - text: '''static'' method only used from one other class' + text: '''static'' method only used from one other class' +static.method.only.used.in.one.class.ignore.anonymous.option: + text: Ignore when only used from an anonymous class +static.method.only.used.in.one.class.ignore.on.conflicts: + text: Ignore when the method cannot be moved without conflicts +static.method.only.used.in.one.class.ignore.test.option: + text: Ignore when only used from a test class static.method.only.used.in.one.class.problem.descriptor: - text: '''static'' method #ref() is only used from class ''''{0}'''' #loc' -static.method.only.used.in.one.class.problem.descriptor.anonymous.implementing: - text: '''static'' method #ref() is only used from an anonymous class implementing ''''{0}'''' #loc' + text: '''static'' method #ref() is only used from class ''''{0}'''' #loc' static.method.only.used.in.one.class.problem.descriptor.anonymous.extending: - text: '''static'' method #ref() is only used from an anonymous class extending ''''{0}'''' #loc' + text: '''static'' method #ref() is only used from an anonymous class extending ''''{0}'''' #loc' +static.method.only.used.in.one.class.problem.descriptor.anonymous.implementing: + text: '''static'' method #ref() is only used from an anonymous class implementing ''''{0}'''' #loc' static.method.only.used.in.one.class.quickfix: - text: Move method -static.method.only.used.in.one.class.ignore.test.option: - text: Ignore when only used from a test class -static.method.only.used.in.one.class.ignore.anonymous.option: - text: Ignore when only used from an anonymous class -static.method.only.used.in.one.class.ignore.on.conflicts: - text: Ignore when the method cannot be moved without conflicts -unary.plus.display.name: - text: Unary plus -unary.plus.problem.descriptor: - text: 'Unary #ref operator #loc' -await.without.corresponding.signal.display.name: - text: '''await()'' without corresponding ''signal()''' -await.without.corresponding.signal.problem.descriptor: - text: 'Call to #ref without corresponding signal() or signalAll() #loc' -signal.without.corresponding.await.display.name: - text: '''signal()'' without corresponding ''await()''' -signal.without.corresponding.await.problem.descriptor: - text: 'Call to #ref without corresponding await() #loc' -wait.without.corresponding.notify.display.name: - text: '''wait()'' without corresponding ''notify()''' -wait.without.corresponding.notify.problem.descriptor: - text: 'Call to #ref without corresponding notify() or notifyAll() #loc' -notify.without.corresponding.wait.display.name: - text: '''notify()'' without corresponding ''wait()''' -notify.without.corresponding.wait.problem.descriptor: - text: 'Call to #ref without corresponding wait() #loc' -integer.multiplication.implicit.cast.to.long.display.name: - text: Integer multiplication or shift implicitly cast to long -integer.multiplication.implicit.cast.to.long.problem.descriptor: - text: '#ref: integer multiplication implicitly cast to long #loc' -integer.shift.implicit.cast.to.long.problem.descriptor: - text: '#ref: integer shift implicitly cast to long #loc' -integer.multiplication.implicit.cast.to.long.option: - text: Ignore compile time constant expressions which do not overflow -wait.or.await.without.timeout.display.name: - text: '''wait()'' or ''await()'' without timeout' -wait.or.await.without.timeout.problem.descriptor: - text: '#ref without timeout #loc' -method.return.always.constant.display.name: - text: Method returns per-class constant -method.return.always.constant.problem.descriptor: - text: Method #ref() and all it's derivables always return constants -class.with.too.many.dependencies.display.name: - text: Class with too many dependencies -class.with.too.many.dependencies.problem.descriptor: - text: Class ''{0}'' has too many dependencies ({1} > {2}) -class.with.too.many.transitive.dependencies.display.name: - text: Class with too many transitive dependencies -class.with.too.many.transitive.dependencies.problem.descriptor: - text: Class ''{0}'' has too many transitive dependencies ({1} > {2}) -class.with.too.many.dependents.display.name: - text: Class with too many dependents -class.with.too.many.dependents.problem.descriptor: - text: Class ''{0}'' has too many dependents ({1} > {2}) -class.with.too.many.transitive.dependents.display.name: - text: Class with too many transitive dependents -class.with.too.many.transitive.dependents.problem.descriptor: - text: Class ''{0}'' has too many transitive dependencies ({1} > {2}) -class.with.too.many.dependencies.max.option: - text: Maximum number of dependencies -class.with.too.many.dependents.max.option: - text: Maximum number of dependents -class.with.too.many.transitive.dependencies.max.option: - text: Maximum number of transitive dependencies -class.with.too.many.transitive.dependents.max.option: - text: Maximum number of transitive dependents -cyclic.class.dependency.display.name: - text: Cyclic class dependency -cyclic.class.dependency.problem.descriptor: - text: Class ''{0}'' is cyclically dependent on {1} other classes -cyclic.class.dependency.1.problem.descriptor: - text: Class ''{0}'' is cyclically dependent on class ''{1}'' -cyclic.class.dependency.2.problem.descriptor: - text: Class ''{0}'' is cyclically dependent on classes ''{1}'' and ''{2}'' -cyclic.package.dependency.display.name: - text: Cyclic package dependency -cyclic.package.dependency.problem.descriptor: - text: Package ''{0}'' is cyclically dependent on {1} other packages -cyclic.package.dependency.1.problem.descriptor: - text: Package ''{0}'' is cyclically dependent on package ''{1}'' -cyclic.package.dependency.2.problem.descriptor: - text: Package ''{0}'' is cyclically dependent on packages ''{1}'' and ''{2}'' -class.unconnected.to.package.display.name: - text: Class independent of its package -class.unconnected.to.package.problem.descriptor: - text: Class #ref has no dependencies or dependents in its package -package.with.too.many.classes.display.name: - text: Package with too many classes -package.with.too.many.classes.problem.descriptor: - text: Package ''{0}'' contains too many classes ({1} > {2}) -package.with.too.many.classes.max.option: - text: 'Maximum number of classes:' -package.with.too.few.classes.display.name: - text: Package with too few classes -package.with.too.few.classes.problem.descriptor: - text: Package ''{0}'' contains too few classes ({1} < {2}) -package.with.too.few.classes.min.option: - text: 'Minimum number of classes:' -module.with.too.many.classes.display.name: - text: Module with too many classes -module.with.too.many.classes.problem.descriptor: - text: Module ''{0}'' contains too many classes ({1} > {2}) -module.with.too.many.classes.max.option: - text: 'Maximum number of classes:' -module.with.too.few.classes.display.name: - text: Module with too few classes -module.with.too.few.classes.problem.descriptor: - text: Module ''{0}'' contains too few classes ({1} < {2}) -module.with.too.few.classes.min.option: - text: 'Minimum number of classes:' -package.in.multiple.modules.display.name: - text: Package with classes in multiple modules -package.in.multiple.modules.problem.descriptor: - text: Package ''{0}'' has classes in multiple modules -disjoint.package.display.name: - text: Package with disjoint dependency graph -disjoint.package.problem.descriptor: - text: Package {0} can be decomposed into {1} independent packages -package.naming.convention.display.name: - text: Package naming convention -package.naming.convention.problem.descriptor.short: - text: Package name {0} is too short -package.naming.convention.problem.descriptor.long: - text: Package name {0} is too long -package.naming.convention.problem.descriptor.regex.mismatch: - text: Package name {0} doesn''t match regex ''{1}'' -cyclic.class.initialization.display.name: - text: Cyclic class initialization dependency -cyclic.class.initialization.problem.descriptor: - text: Initialization of class ''{0}'' is cyclically dependent on {1} other classes -before.or.after.is.public.void.no.arg.display.name: - text: Malformed @Before or @After method -before.or.after.is.public.void.no.arg.problem.descriptor: - text: '#ref() has incorrect signature for a @Before or @After method #loc' -before.class.or.after.class.is.public.static.void.no.arg.display.name: - text: Malformed @BeforeClass/@BeforeAll or @AfterClass/@AfterAll method -before.class.or.after.class.is.public.static.void.no.arg.problem.descriptor: - text: '#ref() has incorrect signature for a @{0} method #loc' + text: Move method +static.method.via.subclass.display.name: + text: Static method referenced via subclass +static.method.via.subclass.problem.descriptor: + text: 'Static method #ref() declared in class ''''{0}'''' but referenced via subclass ''''{1}'''' #loc' +static.method.via.subclass.rationalize.quickfix: + text: Rationalize static method call +static.non.final.field.display.name: + text: '''static'', non-''final'' field' +static.non.final.field.option: + text: Only report 'public' fields +static.non.final.field.problem.descriptor: + text: '''static'' non-''final'' field #ref #loc' +static.suite.display.name: + text: '''suite()'' method not declared ''static''' +static.suite.problem.descriptor: + text: 'JUnit #ref() methods not declared ''static'' #loc' +static.variable.may.not.be.initialized.display.name: + text: Static field may not be initialized +static.variable.may.not.be.initialized.problem.descriptor: + text: 'Static field #ref may not be initialized during class initialization #loc' +static.variable.naming.convention.display.name: + text: '''static'' field naming convention' +static.variable.naming.convention.element.description: + text: '''static'' field' +static.variable.naming.convention.mutable.option: + text: Check 'static final' fields with a mutable type +static.variable.of.concrete.class.display.name: + text: Static field of concrete class +static.variable.of.concrete.class.option: + text: Ignore static fields whose type is an abstract class +static.variable.of.concrete.class.problem.descriptor: + text: 'Static field ''''{0}'''' of concrete class #ref #loc' +static.variable.used.before.initialization.display.name: + text: Static field used before initialization +static.variable.used.before.initialization.problem.descriptor: + text: 'Static field #ref used before initialization #loc' +string.buffer.must.have.initial.capacity.display.name: + text: StringBuffer or StringBuilder without initial capacity +string.buffer.must.have.initial.capacity.problem.descriptor: + text: 'new #ref() without initial capacity #loc' +string.buffer.replaceable.by.string.builder.display.name: + text: '''StringBuffer'' may be ''StringBuilder''' +string.buffer.replaceable.by.string.builder.problem.descriptor: + text: 'StringBuffer #ref may be declared as ''StringBuilder'' #loc' +string.buffer.replaceable.by.string.builder.replace.quickfix: + text: Replace with 'StringBuilder' +string.buffer.replaceable.by.string.display.name: + text: '''StringBuffer'' can be replaced with ''String''' +string.buffer.replaceable.by.string.problem.descriptor: + text: '{0} #ref can be replaced with ''''String'''' #loc' +string.buffer.replaceable.by.string.quickfix: + text: Replace 'StringBuffer' with 'String' +string.buffer.to.string.in.concatenation.display.name: + text: '''StringBuffer.toString()'' in concatenation' +string.buffer.to.string.in.concatenation.problem.descriptor: + text: 'Calls to StringBuffer.#ref() in concatenation #loc' +string.buffer.to.string.in.concatenation.remove.quickfix: + text: Remove 'toString()' +string.builder.replaceable.by.string.quickfix: + text: Replace 'StringBuilder' with 'String' +string.comparison.display.name: + text: String comparison using '==', instead of 'equals()' +string.comparison.problem.descriptor: + text: 'String values are compared using #ref, not ''equals()'' #loc' +string.concatenation.argument.to.log.call.display.name: + text: Non-constant string concatenation as argument to logging call +string.concatenation.argument.to.log.call.problem.descriptor: + text: 'Non-constant string concatenation as argument to #ref() logging call #loc' +string.concatenation.argument.to.log.call.quickfix: + text: Replace concatenation with parameterized log message +string.concatenation.display.name: + text: String concatenation +string.concatenation.in.format.call.display.name: + text: String concatenation as argument to 'format()' call +string.concatenation.in.format.call.problem.descriptor: + text: '#ref() call has a String concatenation argument #loc' +string.concatenation.in.format.call.quickfix: + text: Replace concatenation with separate argument +string.concatenation.in.loops.display.name: + text: String concatenation in loop +string.concatenation.in.loops.only.option: + text: Only warn if string is repeatedly appended +string.concatenation.in.loops.problem.descriptor: + text: 'String concatenation #ref in loop #loc' +string.concatenation.in.message.format.call.display.name: + text: String concatenation as argument to 'MessageFormat.format()' call +string.concatenation.in.message.format.call.problem.descriptor: + text: 'String concatenation as argument to ''MessageFormat.format()'' call #loc' +string.concatenation.inside.string.buffer.append.display.name: + text: String concatenation as argument to 'StringBuilder.append()' call +string.concatenation.inside.string.buffer.append.problem.descriptor: + text: 'String concatenation as argument to {0}.#ref() call #loc' +string.concatenation.inside.string.buffer.append.replace.quickfix: + text: Replace with chained 'append()' calls +string.concatenation.introduce.fix: + text: Introduce StringBuilder +string.concatenation.introduce.fix.name: + text: Introduce new {1} to update variable ''{0}'' +string.concatenation.missing.whitespace.display.name: + text: String literal concatenation missing whitespace +string.concatenation.missing.whitespace.option: + text: Ignore when one or both sides are not literals +string.concatenation.missing.whitespace.problem.descriptor: + text: 'String literal concatenation missing whitespace #loc' +string.concatenation.problem.descriptor: + text: 'String concatenation #ref in an internationalized context #loc' +string.concatenation.replace.fix: + text: Replace with StringBuilder +string.concatenation.replace.fix.name: + text: Convert variable ''{0}'' from String to {1} string.constructor.display.name: - text: Redundant String constructor call + text: Redundant String constructor call string.constructor.problem.descriptor: - text: '#ref is redundant #loc' + text: '#ref is redundant #loc' string.constructor.replace.arg.quickfix: - text: Replace with arg + text: Replace with arg string.constructor.replace.empty.quickfix: - text: Replace with empty string + text: Replace with empty string string.constructor.substring.parameter.option: - text: Ignore string constructor calls with a 'substring()' call argument -design.for.extension.display.name: - text: Design for extension -design.for.extension.problem.descriptor: - text: 'Method #ref() may be overridden and its functionality ignored #loc' -bad.oddness.display.name: - text: Suspicious test for oddness -bad.oddness.problem.descriptor: - text: 'Test for oddness #ref will fail on negative values #loc' -comparator.not.serializable.display.name: - text: Comparator class not declared Serializable -comparator.not.serializable.problem.descriptor: - text: 'Comparator class #ref is not declared as Serializable #loc' -non.serializable.field.in.serializable.class.display.name: - text: Non-serializable field in a Serializable class -non.serializable.field.in.serializable.class.problem.descriptor: - text: 'Non-serializable field ''#ref'' in a Serializable class #loc' -non.serializable.object.passed.to.object.stream.display.name: - text: Non-serializable object passed to ObjectOutputStream -non.serializable.object.passed.to.object.stream.problem.descriptor: - text: 'Non-serializable object passed to ObjectOutputStream #loc' -non.serializable.object.bound.to.http.session.display.name: - text: Non-serializable object bound to HttpSession -non.serializable.object.bound.to.http.session.problem.descriptor: - text: 'Non-serializable object bound to HttpSession #loc' -reflection.for.unavailable.annotation.display.name: - text: Reflective access to a source-only annotation -reflection.for.unavailable.annotation.problem.descriptor: - text: 'Annotation ''#ref'' is not retained for reflective access #loc' -access.to.static.field.locked.on.instance.display.name: - text: Access to static field locked on instance data -access.to.static.field.locked.on.instance.problem.descriptor: - text: 'Access to static field #ref locked on instance data #loc' -make.method.ctr.quickfix: - text: Make method constructor -replace.all.dot.display.name: - text: Call to String.replaceAll(".", ...) -replace.all.dot.problem.descriptor: - text: 'Call to String.#ref(".", ...) #loc' -constant.string.intern.display.name: - text: Call to 'intern()' on String constant -constant.string.intern.problem.descriptor: - text: '.#ref() on compile-time constant is unnecessary #loc' -constant.string.intern.quickfix: - text: Remove 'intern()' call -class.extends.utility.class.display.name: - text: Class extends utility class -class.extends.utility.class.problem.descriptor: - text: 'Class #ref extends utility class ''''{0}'''' #loc' -class.extends.utility.class.ignore.utility.class.option: - text: Ignore if overriding class is a utility class -public.constructor.in.non.public.class.quickfix: - text: Make constructor ''{0}'' -assignment.to.method.parameter.ignore.transformation.option: - text: Ignore if assignment is a transformation of the original parameter -type.parameter.extends.final.class.display.name: - text: Type parameter extends final class -type.parameter.extends.final.class.problem.descriptor1: - text: 'Type parameter #ref extends ''''final'''' class ''''{0}'''' #loc' -type.parameter.extends.final.class.problem.descriptor2: - text: 'Wildcard type argument #ref extends ''''final'''' class ''''{0}'''' #loc' -type.parameter.extends.final.class.quickfix: - text: Replace type parameter with actual class -double.negation.display.name: - text: Double negation -double.negation.problem.descriptor: - text: 'Double negation in #ref #loc' -double.negation.quickfix: - text: Remove double negation -exception.from.catch.which.doesntwrap.ignore.option: - text: Ignore if result of exception method call is used -exception.from.catch.which.doesntwrap.ignore.cant.wrap.option: - text: Ignore if thrown exception cannot wrap an exception -comparable.implemented.but.equals.not.overridden.display.name: - text: Comparable implemented but 'equals()' not overridden -comparable.implemented.but.equals.not.overridden.problem.descriptor: - text: 'Class #ref implements ''java.lang.Comparable'' but does not override ''equals()'' #loc' -unqualified.field.access.display.name: - text: Instance field access not qualified with 'this' -unqualified.field.access.problem.descriptor: - text: 'Instance field access #ref is not qualified with ''this'' #loc' -unqualified.method.access.display.name: - text: Instance method call not qualified with 'this' -unqualified.method.access.problem.descriptor: - text: 'Instance method call #ref is not qualified with ''this'' #loc' -add.this.qualifier.quickfix: - text: Add 'this' qualifier -while.loop.spins.on.field.ignore.non.empty.loops.option: - text: Only warn if the loop is empty -method.may.be.synchronized.problem.descriptor: - text: 'Method #ref() with synchronized block could be synchronized method #loc' -method.may.be.synchronized.display.name: - text: Method with synchronized block could be synchronized method -method.may.be.synchronized.quickfix: - text: Make method synchronized and remove synchronized block -fallthru.in.switch.statement.quickfix: - text: Add 'break' -law.of.demeter.display.name: - text: Method call violates Law of Demeter -law.of.demeter.problem.descriptor: - text: '#ref() call violates Law of Demeter #loc' -law.of.demeter.ignore.library.calls.option: - text: Ignore calls on library methods -assertequals.between.inconvertible.types.display.name: - text: '''assertEquals()'' between objects of inconvertible types' -assertequals.between.inconvertible.types.problem.descriptor: - text: '#ref() between objects of inconvertible types ''''{0}'''' and ''''{1}'''' #loc' -enumeration.can.be.iteration.display.name: - text: Enumeration can be iteration -enumeration.can.be.iteration.problem.descriptor: - text: '#ref() can be replaced with ''''{0}'''' construct #loc' -enumeration.can.be.iteration.quickfix: - text: Replace with 'Iterator' construct -equals.hashcode.called.on.url.display.name: - text: '''equals()'' or ''hashCode()'' called on ''java.net.URL'' object' -equals.hashcode.called.on.url.problem.descriptor: - text: 'Call to #ref() on URL object #loc' -collection.contains.url.problem.decriptor: - text: '{0} #ref may contain URL objects #loc' -collection.contains.url.display.name: - text: Map or Set may contain 'java.net.URL' objects -implicit.array.to.string.problem.descriptor: - text: 'Implicit call to ''toString()'' on array #ref #loc' -explicit.array.to.string.problem.descriptor: - text: 'Call to ''#ref()'' on array #loc' -implicit.array.to.string.method.call.problem.descriptor: - text: 'Implicit call to ''toString()'' on array returned by call to #ref #loc' -implicit.array.to.string.display.name: - text: Call to 'toString()' on array -implicit.array.to.string.quickfix: - text: Wrap with ''{0}'' expression -suspicious.indent.after.control.statement.problem.descriptor: - text: '#ref statement has suspicious indentation #loc' -suspicious.indent.after.control.statement.display.name: - text: Suspicious indentation after control statement without braces -unpredictable.big.decimal.constructor.call.display.name: - text: Unpredictable BigDecimal constructor call -unpredictable.big.decimal.constructor.call.problem.descriptor: - text: 'Unpredictable new #ref() call #loc' -unpredictable.big.decimal.constructor.call.ignore.references.option: - text: Ignore constructor calls with variable or method call arguments -unpredictable.big.decimal.constructor.call.ignore.complex.literals.option: - text: Ignore constructor calls with multiple literals (e.g. 0.1 + 0.2) -unpredictable.big.decimal.constructor.call.quickfix: - text: Replace with ''{0}'' -unnecessary.unary.minus.display.name: - text: Unnecessary unary minus -unnecessary.unary.minus.problem.descriptor: - text: 'Unnecessary unary minus #loc' -unnecessary.unary.minus.quickfix: - text: Remove unary minus and invert parent operation sign -make.field.final.quickfix: - text: Make ''{0}'' ''final'' -increment.decrement.used.as.expression.quickfix: - text: Extract ''{0}'' to separate statement -ignore.classes.in.hierarchy.column.name: - text: Ignore subclasses of -overly.strong.type.cast.ignore.in.matching.instanceof.option: - text: Ignore casts with a matching instanceof expression -return.of.collection.field.quickfix: - text: Replace with ''{0}'' -access.to.non.thread.safe.static.field.from.instance.display.name: - text: Non thread-safe static field access -access.to.non.thread.safe.static.field.from.instance.field.problem.descriptor: - text: 'Access to non thread-safe static field #ref of type ''''{0}'''' #loc' -access.to.non.thread.safe.static.field.from.instance.option.title: - text: Non thread-safe classes -access.to.non.thread.safe.static.field.from.instance.class.chooser.title: - text: Choose non thread-safe class -transient.field.not.initialized.display.name: - text: Transient field is not initialized on deserialization -transient.field.not.initialized.problem.descriptor: - text: 'Transient field #ref not initialized on deserialization #loc' -call.to.string.concat.can.be.replaced.by.operator.display.name: - text: Call to 'String.concat()' can be replaced with '+' -call.to.string.concat.can.be.replaced.by.operator.problem.descriptor: - text: 'Call to #ref() can be replaced with ''+'' expression #loc' -call.to.string.concat.can.be.replaced.by.operator.quickfix: - text: Replace 'concat()' call with '+' -new.string.buffer.with.char.argument.display.name: - text: StringBuffer constructor call with 'char' argument -new.string.buffer.with.char.argument.problem.descriptor: - text: 'new #ref() with argument of type ''char'' #loc' -new.string.buffer.with.char.argument.quickfix: - text: Replace char argument with String literal -suspicious.comparator.compare.display.name: - text: Suspicious 'Comparator.compare()' implementation -suspicious.comparator.compare.descriptor.parameter.not.used: - text: '''compare()'' parameter #ref is not used #loc' + text: Ignore string constructor calls with a 'substring()' call argument +string.equals.call.display.name: + text: Call to 'String.equals()' +string.equals.call.problem.descriptor: + text: 'String.#ref() using internationalized strings #loc' +string.equals.empty.string.display.name: + text: '''String.equals("")''' +string.equals.empty.string.is.empty.problem.descriptor: + text: '#ref("") can be replaced with ''isEmpty()'' #loc' +string.equals.empty.string.isempty.quickfix: + text: Replace with 'isEmpty()' +string.equals.empty.string.problem.descriptor: + text: '#ref("") can be replaced with ''length()==0'' #loc' +string.equals.empty.string.quickfix: + text: Replace with 'length()==0' +string.equalsignorecase.call.display.name: + text: Call to 'String.equalsIgnoreCase()' +string.equalsignorecase.call.problem.descriptor: + text: 'String.#ref() using internationalized strings #loc' +string.format.choose.class: + text: Choose Formatter Class +string.format.class.column.name: + text: Additional formatter classes +string.format.class.method.name: + text: Additional formatter methods +string.replace.quickfix: + text: Replace concatenation with ''{0}'' +string.replaceable.by.string.buffer.display.name: + text: Non-constant 'String' can be replaced with 'StringBuilder' +string.replaceable.by.string.buffer.in.loop.option: + text: Only warn when appending in a loop +string.replaceable.by.string.buffer.problem.descriptor: + text: 'Non-constant String #ref should probably be declared as ''StringBuilder'' #loc' +string.to.string.display.name: + text: Redundant 'String.toString()' +string.to.string.problem.descriptor: + text: '#ref is redundant #loc' +string.touppercase.tolowercase.without.locale.display.name: + text: Call to 'String.toUpperCase()' or 'toLowerCase()' without locale +string.touppercase.tolowercase.without.locale.problem.descriptor: + text: 'String.#ref() called without specifying a Locale using internationalized strings #loc' +stringbuffer.field.display.name: + text: '''StringBuilder'' field' +stringbuffer.field.problem.descriptor: + text: '''''{0}'''' field #ref #loc' +substring.zero.display.name: + text: Redundant 'substring(0)' call +substring.zero.problem.descriptor: + text: '#ref is redundant #loc' +subtraction.in.compareto.display.name: + text: Subtraction in 'compareTo()' +subtraction.in.compareto.problem.descriptor: + text: 'Subtraction #ref in ''compareTo()'' may result in overflow errors #loc' +super.class.logger.option: + text: Ignore classes with an accessible logger declared in a superclass +super.tear.down.in.finally.display.name: + text: '''super.tearDown()'' not called from ''finally'' block' +super.tear.down.in.finally.problem.descriptor: + text: '#ref() not called from ''finally'' block #loc' +suppress.for.tests.scope.quickfix: + text: Suppress for 'Tests' scope +suspicious.array.cast.display.name: + text: Suspicious array cast +suspicious.array.cast.problem.descriptor: + text: 'Suspicious cast to #ref #loc' suspicious.comparator.compare.descriptor.non.reflexive: - text: Comparator does not return 0 for equal elements -to.array.call.with.zero.length.array.argument.display.name: - text: Call to 'Collection.toArray()' with zero-length array argument -to.array.call.with.zero.length.array.argument.problem.descriptor: - text: 'Call to #ref() with zero-length array argument ''''{0}'''' #loc' -to.array.call.with.zero.length.array.argument.quickfix: - text: Replace argument with correctly sized array -throwable.instance.never.thrown.runtime.exception.problem.descriptor: - text: 'Runtime exception instance #ref is not thrown #loc' + text: Comparator does not return 0 for equal elements +suspicious.comparator.compare.descriptor.parameter.not.used: + text: '''compare()'' parameter #ref is not used #loc' +suspicious.comparator.compare.display.name: + text: Suspicious 'Comparator.compare()' implementation +suspicious.getter.problem.descriptor: + text: 'Getter #ref() returns field ''''{0}'''' #loc' +suspicious.getter.setter.display.name: + text: Suspicious getter/setter +suspicious.indent.after.control.statement.display.name: + text: Suspicious indentation after control statement without braces +suspicious.indent.after.control.statement.problem.descriptor: + text: '#ref statement has suspicious indentation #loc' +suspicious.literal.underscore.display.name: + text: Suspicious underscore in number literal +suspicious.literal.underscore.problem.descriptor: + text: 'Group in number literal with underscores does not have length 3 #loc' +suspicious.setter.problem.descriptor: + text: 'Setter #ref() assigns field ''''{0}'''' #loc' +suspicious.system.arraycopy.display.name: + text: Suspicious 'System.arraycopy()' call +suspicious.system.arraycopy.problem.descriptor1: + text: 'Parameter ''srcPos'' may not be negative #loc' +suspicious.system.arraycopy.problem.descriptor2: + text: 'Parameter ''destPos'' may not be negative #loc' +suspicious.system.arraycopy.problem.descriptor3: + text: 'Parameter ''length'' may not be negative #loc' +suspicious.system.arraycopy.problem.descriptor4: + text: '#ref is not of an array type #loc' +suspicious.system.arraycopy.problem.descriptor5: + text: '#ref is not of an array type #loc' +suspicious.system.arraycopy.problem.descriptor6: + text: 'Source parameter type ''''{0}'''' is not assignable to destination parameter #ref of type ''''{1}'''' #loc' +suspicious.to.array.call.display.name: + text: Suspicious 'Collection.toArray()' call +suspicious.to.array.call.problem.descriptor: + text: 'Array of type ''''{0}[]'''' expected #loc' +switch.expression.with.single.default.message: + text: '''switch'' expression has only ''default'' case' +switch.expression.with.too.few.branches.problem.descriptor: + text: '''''switch'''' expression has too few case labels ({0}), and should probably be replaced with an ''''if'''' statement or conditional operator #loc' +switch.statement.density.display.name: + text: '''switch'' statement with too low of a branch density' +switch.statement.density.min.option: + text: 'Minimum density of branches: %' +switch.statement.density.problem.descriptor: + text: '#ref branch density is too low ({0}%) #loc' +switch.statement.display.name: + text: '''switch'' statement' +switch.statement.with.confusing.declaration.display.name: + text: Local variable used and declared in different 'switch' branches +switch.statement.with.confusing.declaration.problem.descriptor: + text: 'Local variable #ref declared in one ''switch'' branch and used in another #loc' +switch.statement.with.single.default.message: + text: '''switch'' statement has only ''default'' case' +switch.statement.with.too.few.branches.display.name: + text: '''switch'' statement with too few branches' +switch.statement.with.too.few.branches.min.option: + text: 'Minimum number of branches:' +switch.statement.with.too.few.branches.problem.descriptor: + text: '#ref has too few branches ({0}), and should probably be replaced with an ''''if'''' statement #loc' +switch.statement.with.too.many.branches.display.name: + text: '''switch'' statement with too many branches' +switch.statement.without.default.ignore.option: + text: Ignore if all cases of an enumerated type are covered +switch.statements.without.default.display.name: + text: '''switch'' statement without ''default'' branch' +switch.statements.without.default.problem.descriptor: + text: '#ref statement without ''default'' branch #loc' +synchronization.on.get.class.display.name: + text: Synchronization on 'getClass()' +synchronization.on.get.class.problem.descriptor: + text: 'Synchronization on #ref() #loc' +synchronization.on.local.variable.or.method.parameter.display.name: + text: Synchronization on local variable or method parameter +synchronization.on.local.variable.problem.descriptor: + text: 'Synchronization on local variable #ref #loc' +synchronization.on.method.parameter.problem.descriptor: + text: 'Synchronization on method parameter #ref #loc' +synchronization.on.static.field.display.name: + text: Synchronization on 'static' field +synchronization.on.static.field.problem.descriptor: + text: 'Synchronization on ''static'' field #ref #loc' +synchronize.on.class.problem.descriptor: + text: 'Lock operations on a class may have unforeseen side-effects #loc' +synchronize.on.lock.display.name: + text: Synchronization on a 'Lock' object +synchronize.on.lock.problem.descriptor: + text: 'Synchronization on a ''''{0}'''' object is unlikely to be intentional #loc' +synchronize.on.non.final.field.display.name: + text: Synchronization on a non-final field +synchronize.on.non.final.field.problem.descriptor: + text: 'Synchronization on a non-final field #ref #loc' +synchronize.on.this.display.name: + text: Synchronization on 'this' +synchronize.on.this.problem.descriptor: + text: 'Lock operations on ''this'' may have unforeseen side-effects #loc' +synchronized.method.display.name: + text: '''synchronized'' method' +synchronized.method.ignore.synchronized.super.option: + text: Ignore methods overriding a synchronized method +synchronized.method.include.option: + text: Include native methods +synchronized.method.move.quickfix: + text: Move synchronization into method +synchronized.method.problem.descriptor: + text: 'Method ''''{0}()'''' declared #ref #loc' +synchronized.on.direct.literal.object.problem.descriptor: + text: 'Synchronization on {0} literal #ref #loc' +synchronized.on.literal.object.name: + text: Synchronization on an object initialized with a literal +synchronized.on.literal.object.problem.descriptor: + text: 'Synchronization on {0} #ref which is initialized by a literal #loc' +synchronized.on.literal.object.warn.on.all.option: + text: Warn on all possible literals +synchronized.on.possibly.literal.object.problem.descriptor: + text: 'Synchronization on {0} #ref #loc' +system.exit.call.display.name: + text: Call to 'System.exit()' or related methods +system.exit.call.ignore.option: + text: Ignore in main method +system.exit.call.problem.descriptor: + text: 'Call to {0}.#ref() is non-portable #loc' +system.getenv.call.display.name: + text: Call to 'System.getenv()' +system.getenv.call.problem.descriptor: + text: 'Call to System.#ref() is non-portable #loc' +system.properties.display.name: + text: Access of system properties +system.properties.problem.descriptor: + text: 'Call to Integer.#ref() may pose security concerns #loc' +system.properties.problem.descriptor1: + text: 'Call to Boolean.#ref() may pose security concerns #loc' +system.run.finalizers.on.exit.display.name: + text: Call to 'System.runFinalizersOnExit()' +system.run.finalizers.on.exit.problem.descriptor: + text: 'Call to System.#ref() #loc' +system.set.problem.descriptor: + text: 'Call to System.#ref() may pose security concerns #loc' +system.set.security.manager.display.name: + text: Call to 'System.setSecurityManager()' +system.set.security.manager.problem.descriptor: + text: 'Call to System.#ref() may pose security concerns #loc' +tail.recursion.display.name: + text: Tail recursion +tail.recursion.problem.descriptor: + text: 'Tail recursive call #ref() #loc' +tail.recursion.replace.quickfix: + text: Replace tail recursion with iteration +test.case.in.product.code.display.name: + text: JUnit TestCase in product source +test.case.in.product.code.problem.descriptor: + text: 'Test case #ref should probably be placed in a test source tree #loc' +test.case.with.constructor.display.name: + text: JUnit TestCase with non-trivial constructors +test.case.with.constructor.problem.descriptor: + text: 'Initialization logic in constructor #ref() instead of ''setUp()'' #loc' +test.case.with.constructor.problem.descriptor.initializer: + text: Initialization logic in initializer instead of 'setUp()' +test.case.with.no.test.methods.display.name: + text: JUnit test case with no tests +test.case.with.no.test.methods.option: + text: Ignore test cases which have superclasses with test methods +test.case.with.no.test.methods.problem.descriptor: + text: 'JUnit test case #ref has no tests #loc' +test.method.in.product.code.display.name: + text: JUnit test method in product source +test.method.in.product.code.problem.descriptor: + text: 'Test method #ref() should probably be placed in a test source tree #loc' +test.method.is.public.void.no.arg.display.name: + text: Malformed test method +test.method.is.public.void.no.arg.problem.descriptor1: + text: 'Test method #ref() should probably not have parameters #loc' +test.method.is.public.void.no.arg.problem.descriptor2: + text: 'Test method #ref() is not declared ''public void'' #loc' +test.method.is.public.void.no.arg.problem.descriptor3: + text: 'Test method #ref() should not be ''static'' #loc' +test.method.without.assertion.display.name: + text: JUnit test method without any assertions +test.method.without.assertion.problem.descriptor: + text: 'JUnit test method #ref() contains no assertions #loc' +text.label.in.switch.statement.display.name: + text: Text label in 'switch' statement +text.label.in.switch.statement.problem.descriptor: + text: 'Text label #ref: in ''switch'' statement #loc' +the.whole.project: + text: the whole project +this.class: + text: this class +this.reference.escaped.in.construction.display.name: + text: '''this'' reference escaped in object construction' +this.reference.escaped.in.construction.problem.descriptor: + text: 'Escape of #ref during object construction #loc' +thread.death.rethrown.display.name: + text: '''ThreadDeath'' not rethrown' +thread.death.rethrown.problem.descriptor: + text: 'ThreadDeath #ref not rethrown #loc' +thread.local.not.static.final.display.name: + text: '''ThreadLocal'' field not declared ''static final''' +thread.local.not.static.final.problem.descriptor: + text: 'ThreadLocal #ref is not declared ''static final'' #loc' +thread.priority.display.name: + text: Call to 'Thread.setPriority()' +thread.priority.problem.descriptor: + text: 'Call to Thread.#ref() #loc' +thread.run.display.name: + text: Call to 'Thread.run()' +thread.run.problem.descriptor: + text: 'Calls to #ref() should probably be replaced with ''start()'' #loc' +thread.run.replace.quickfix: + text: Replace with 'start()' +thread.start.in.construction.display.name: + text: Call to 'Thread.start()' during object construction +thread.start.in.construction.problem.descriptor: + text: 'Call to #ref() during object construction #loc' +thread.stop.suspend.resume.display.name: + text: Call to 'Thread.stop()', 'suspend()' or 'resume()' +thread.stop.suspend.resume.problem.descriptor: + text: 'Call to Thread.#ref() #loc' +thread.with.default.run.method.display.name: + text: Instantiating a 'Thread' with default 'run()' method +thread.with.default.run.method.problem.descriptor: + text: 'Instantiating a #ref with default ''run()'' method #loc' +thread.yield.display.name: + text: Call to 'Thread.yield()' +thread.yield.problem.descriptor: + text: 'Call to Thread.#ref() #loc' +three.negations.per.method.display.name: + text: Method with more than three negations +three.negations.per.method.ignore.assert.option: + text: Ignore negations in 'assert' statements +three.negations.per.method.ignore.option: + text: Ignore negations in 'equals()' methods +three.negations.per.method.problem.descriptor: + text: '#ref contains {0} negations #loc' +throw.caught.locally.display.name: + text: '''throw'' caught by containing ''try'' statement' +throw.caught.locally.ignore.option: + text: Ignore rethrown exceptions +throw.caught.locally.problem.descriptor: + text: '#ref caught by containing ''try'' statement #loc' +throw.from.finally.block.display.name: + text: '''throw'' inside ''finally'' block' +throw.from.finally.block.everywhere.option: + text: Warn everywhere declared exceptions may be thrown +throw.from.finally.block.problem.descriptor: + text: '#ref inside ''finally'' block #loc' throwable.instance.never.thrown.checked.exception.problem.descriptor: - text: 'Checked exception instance #ref is not thrown #loc' + text: 'Checked exception instance #ref is not thrown #loc' +throwable.instance.never.thrown.display.name: + text: Throwable instance not thrown throwable.instance.never.thrown.error.problem.descriptor: - text: 'Error instance #ref is not thrown #loc' + text: 'Error instance #ref is not thrown #loc' throwable.instance.never.thrown.problem.descriptor: - text: 'Throwable instance #ref is not thrown #loc' + text: 'Throwable instance #ref is not thrown #loc' +throwable.instance.never.thrown.runtime.exception.problem.descriptor: + text: 'Runtime exception instance new #ref() is not thrown #loc' +throwable.not.thrown.display.name: + text: '''Throwable'' not thrown' +throwable.printed.to.system.out.display.name: + text: '''Throwable'' printed to ''System.out''' +throwable.printed.to.system.out.problem.descriptor: + text: '''Throwable'' argument #ref to ''''System.{0}.{1}()'''' call' +throwable.result.of.method.call.ignored.problem.descriptor: + text: 'Result of #ref() not thrown #loc' +thrown.exceptions.per.method.display.name: + text: Method with too many exceptions declared +thrown.exceptions.per.method.limit.option: + text: 'Exceptions thrown limit:' +thrown.exceptions.per.method.problem.descriptor: + text: '#ref has too many exceptions declared (num exceptions = {0}) #loc' +throws.runtime.exception.display.name: + text: Unchecked exception declared in 'throws' clause +throws.runtime.exception.move.quickfix: + text: Move ''{0}'' to Javadoc ''@throws'' tag +throws.runtime.exception.problem.descriptor: + text: 'Unchecked exception #ref declared in ''throws'' clause #loc' +throws.runtime.exception.quickfix: + text: Remove ''{0}'' from ''throws'' clause +time.tostring.call.display.name: + text: Call to 'Time.toString()' +time.tostring.call.problem.descriptor: + text: 'Time.#ref() in an internationalized context #loc' +to.array.call.with.zero.length.array.argument.display.name: + text: Call to 'Collection.toArray()' with zero-length array argument +to.array.call.with.zero.length.array.argument.problem.descriptor: + text: 'Call to #ref() with zero-length array argument ''''{0}'''' #loc' +to.array.call.with.zero.length.array.argument.quickfix: + text: Replace argument with correctly sized array +too.broad.catch.display.name: + text: Overly broad 'catch' block +too.broad.catch.option: + text: '&Only warn on RuntimeException, Exception, Error or Throwable' +too.broad.catch.problem.descriptor: + text: '''''catch'''' of #ref is too broad, masking exception ''''{0}'''' #loc' +too.broad.catch.problem.descriptor1: + text: '''''catch'''' of #ref is too broad, masking exceptions ''''{0}'''' and ''''{1}'''' #loc' +too.broad.catch.quickfix: + text: Add ''catch'' clause for ''{0}'' +too.broad.scope.allow.option: + text: 'Report variables with a new expression as initializer
(potentially unsafe: quick fix may modify semantics if the constructor has non-local side-effects)' +too.broad.scope.display.name: + text: Scope of variable is too broad +too.broad.scope.narrow.quickfix: + text: Move declaration of ''{0}'' closer to usages +too.broad.scope.only.blocks.option: + text: Only report variables that can be moved into inner blocks +too.broad.scope.problem.descriptor: + text: 'Scope of variable #ref is too broad #loc' +too.many.constructors.count.limit.option: + text: 'Constructor count limit:' +too.many.constructors.display.name: + text: Class with too many constructors +too.many.constructors.ignore.deprecated.option: + text: Ignore deprecated constructors +too.many.constructors.problem.descriptor: + text: '#ref has too many constructors (constructor count = {0}) #loc' +too.many.fields.count.limit.option: + text: 'Field count limit:' +too.many.fields.display.name: + text: Class with too many fields +too.many.fields.problem.descriptor: + text: '#ref has too many fields (field count = {0}) #loc' +too.many.methods.display.name: + text: Class with too many methods +too.many.methods.problem.descriptor: + text: '#ref has too many methods (method count = {0}) #loc' +trace.level.option: + text: trace level +transient.field.in.non.serializable.class.display.name: + text: Transient field in non-serializable class +transient.field.in.non.serializable.class.problem.descriptor: + text: 'Field ''''{0}'''' is marked #ref, in non-Serializable class #loc' +transient.field.in.non.serializable.class.remove.quickfix: + text: Remove 'transient' +transient.field.not.initialized.display.name: + text: Transient field is not initialized on deserialization +transient.field.not.initialized.problem.descriptor: + text: 'Transient field #ref not initialized on deserialization #loc' +trivial.if.display.name: + text: Redundant 'if' statement +trivial.if.problem.descriptor: + text: '#ref statement can be simplified #loc' +trivial.string.concatenation.display.name: + text: Concatenation with empty string +trivial.string.concatenation.problem.descriptor: + text: Empty string in concatenation +try.finally.can.be.try.with.resources.display.name: + text: '''try finally'' can be replaced with ''try'' with resources' +try.finally.can.be.try.with.resources.problem.descriptor: + text: '#ref can use automatic resource management #loc' +try.finally.can.be.try.with.resources.quickfix: + text: Replace with 'try' with resources +try.statement.with.multiple.resources.name: + text: '''try'' statement with multiple resources can be split' +try.statement.with.multiple.resources.quickfix: + text: Split 'try' statement with multiple resources +try.with.identical.catches.display.name: + text: Identical 'catch' branches in 'try' statement +try.with.identical.catches.problem.descriptor: + text: '''''catch'''' branch identical to ''''{0}'''' branch #loc' +try.with.identical.catches.quickfix: + text: Collapse 'catch' blocks +type.may.be.weakened.collection.method.option: + text: Use ¶meterized type of collection for method call arguments type.may.be.weakened.display.name: - text: Type may be weakened -type.may.be.weakened.problem.descriptor: - text: 'Type of variable #ref may be weakened to {0} #loc' + text: Type may be weakened +type.may.be.weakened.do.not.weaken.to.object.option: + text: Do not &weaken to 'java.lang.Object' +type.may.be.weakened.field.problem.descriptor: + text: 'Type of field #ref may be weakened to {0} #loc' +type.may.be.weakened.ignore.option: + text: Use &righthand type as weakest type in assignments type.may.be.weakened.method.problem.descriptor: - text: 'Return type of method #ref() may be weakened to {0} #loc' + text: 'Return type of method #ref() may be weakened to {0} #loc' type.may.be.weakened.parameter.problem.descriptor: - text: 'Type of parameter #ref may be weakened to {0} #loc' -type.may.be.weakened.field.problem.descriptor: - text: 'Type of field #ref may be weakened to {0} #loc' + text: 'Type of parameter #ref may be weakened to {0} #loc' +type.may.be.weakened.problem.descriptor: + text: 'Type of variable #ref may be weakened to {0} #loc' type.may.be.weakened.quickfix: - text: Weaken type to ''{0}'' -type.may.be.weakened.ignore.option: - text: Use &righthand type as weakest type in assignments -type.may.be.weakened.collection.method.option: - text: Use ¶meterized type of collection for method call arguments -type.may.be.weakened.do.not.weaken.to.object.option: - text: Do not &weaken to 'java.lang.Object' -ignore.guard.clauses.option: - text: Ignore &guard clauses -ignore.for.equals.methods.option: - text: Ignore for '&equals()' methods -caught.exception.immediately.rethrown.display.name: - text: Caught exception is immediately rethrown -caught.exception.immediately.rethrown.problem.descriptor: - text: 'Caught exception #ref is immediately rethrown #loc' -delete.catch.section.quickfix: - text: Delete 'catch' section -remove.try.catch.quickfix: - text: Remove 'try catch' statement -loop.with.implicit.termination.condition.display.name: - text: Loop with implicit termination condition -loop.with.implicit.termination.condition.dowhile.problem.descriptor: - text: '#ref-while loop with implicit termination condition #loc' -loop.with.implicit.termination.condition.problem.descriptor: - text: '#ref loop with implicit termination condition #loc' -loop.with.implicit.termination.condition.quickfix: - text: Make condition explicit -ignore.iterator.loop.variables: - text: Ignore 'java.util.Iterator' loop variables -rename.catch.parameter.to.ignored: - text: Rename 'catch' parameter to 'ignored' -unnecessary.super.qualifier.display.name: - text: Unnecessary 'super' qualifier -unnecessary.super.qualifier.problem.descriptor: - text: 'Qualifier #ref is unnecessary in this context #loc' -unnecessary.super.qualifier.quickfix: - text: Remove unnecessary 'super' qualifier -collections.field.access.replaceable.by.method.call.display.name: - text: Collections.EMPTY_* field access replaceable with 'Collections.empty*()' method call -collections.field.access.replaceable.by.method.call.problem.descriptor: - text: '#ref replaceable with ''''Collections.{0}'''' #loc' -collections.field.access.replaceable.by.method.call.quickfix: - text: Replace with ''{0}'' -synchronization.on.local.variable.or.method.parameter.display.name: - text: Synchronization on local variable or method parameter -synchronization.on.local.variable.problem.descriptor: - text: 'Synchronization on local variable #ref #loc' -synchronization.on.method.parameter.problem.descriptor: - text: 'Synchronization on method parameter #ref #loc' -too.broad.catch.quickfix: - text: Add ''catch'' clause for ''{0}'' -replace.with.catch.clause.for.runtime.exception.quickfix: - text: Replace with 'catch' clause for 'RuntimeException' -too.broad.catch.option: - text: '&Only warn on RuntimeException, Exception, Error or Throwable' + text: Weaken type to ''{0}'' +type.parameter.extends.final.class.display.name: + text: Type parameter extends 'final' class +type.parameter.extends.final.class.problem.descriptor1: + text: 'Type parameter #ref extends ''''final'''' class ''''{0}'''' #loc' +type.parameter.extends.final.class.problem.descriptor2: + text: 'Wildcard type argument #ref extends ''''final'''' class ''''{0}'''' #loc' +type.parameter.extends.final.class.quickfix: + text: Replace type parameter with actual class +type.parameter.extends.object.display.name: + text: Type parameter explicitly extends 'Object' +type.parameter.extends.object.problem.descriptor1: + text: 'Type parameter #ref explicitly extends ''java.lang.Object'' #loc' +type.parameter.extends.object.problem.descriptor2: + text: 'Wildcard type argument #ref explicitly extends ''java.lang.Object'' #loc' +type.parameter.hides.type.parameter.problem.descriptor: + text: 'Type parameter #ref hides type parameter ''''{0}'''' #loc' +type.parameter.hides.visible.type.display.name: + text: Type parameter hides visible type +type.parameter.hides.visible.type.problem.descriptor: + text: 'Type parameter #ref hides visible type ''''{0}'''' #loc' +type.parameter.naming.convention.display.name: + text: Type parameter naming convention +type.parameter.naming.convention.element.description: + text: Type parameter +unary.plus.display.name: + text: Unary plus +unary.plus.problem.descriptor: + text: 'Unary #ref operator #loc' +unary.plus.quickfix: + text: Remove unary '+' +unchecked.exception.class.display.name: + text: Unchecked 'Exception' class +unchecked.exception.class.problem.descriptor: + text: 'Unchecked exception class #ref #loc' +unclear.binary.expression.display.name: + text: Unclear expression +unclear.binary.expression.problem.descriptor: + text: 'Expression could use clarifying parentheses #loc' +unclear.binary.expression.quickfix: + text: Add clarifying parentheses +unconditional.wait.display.name: + text: Unconditional 'wait()' call +unconditional.wait.problem.descriptor: + text: 'Unconditional call to #ref() #loc' +unconstructable.test.case.display.name: + text: Unconstructable JUnit TestCase +unconstructable.test.case.problem.descriptor: + text: 'Test case #ref is not constructable by most test runners #loc' +unnecessarily.qualified.inner.class.access.display.name: + text: Unnecessarily qualified inner class access +unnecessarily.qualified.inner.class.access.option: + text: Ignore references for which an import is needed +unnecessarily.qualified.inner.class.access.problem.descriptor: + text: '''''{0}'''' is unnecessarily qualified with #ref #loc' +unnecessarily.qualified.inner.class.access.quickfix: + text: Remove qualifier +unnecessarily.qualified.static.usage.display.name: + text: Unnecessarily qualified static access +unnecessarily.qualified.static.usage.ignore.field.option: + text: Ignore unnecessarily qualified field accesses +unnecessarily.qualified.static.usage.ignore.method.option: + text: Ignore unnecessarily qualified method calls +unnecessarily.qualified.static.usage.problem.descriptor: + text: 'Unnecessarily qualified call to static method {0}() #loc' +unnecessarily.qualified.static.usage.problem.descriptor1: + text: 'Unnecessarily qualified access to static field {0} #loc' +unnecessarily.qualified.statically.imported.element.display.name: + text: Unnecessarily qualified statically imported element +unnecessarily.qualified.statically.imported.element.problem.descriptor: + text: 'Statically imported element ''''{0}'''' is unnecessarily qualified with #ref #loc' +unnecessarily.qualified.statically.imported.element.quickfix: + text: Remove unnecessary qualifier +unnecessary.block.statement.problem.descriptor: + text: 'Braces around this statement are unnecessary #loc' +unnecessary.boxing.display.name: + text: Unnecessary boxing +unnecessary.boxing.problem.descriptor: + text: 'Unnecessary boxing #ref #loc' +unnecessary.boxing.remove.quickfix: + text: Remove boxing +unnecessary.boxing.superfluous.option: + text: Only report truly superfluously boxed expressions +unnecessary.break.display.name: + text: Unnecessary 'break' statement +unnecessary.break.problem.descriptor: + text: '#ref statement is unnecessary #loc' unnecessary.call.to.string.valueof.display.name: - text: Unnecessary call to 'String.valueOf()' -unnecessary.tostring.call.display.name: - text: Unnecessary call to 'toString()' + text: Unnecessary call to 'String.valueOf()' unnecessary.call.to.string.valueof.problem.descriptor: - text: '#ref can be simplified to ''''{0}'''' #loc' -unnecessary.tostring.call.problem.descriptor: - text: 'Unnecessary #ref() call #loc' + text: '#ref can be simplified to ''''{0}'''' #loc' unnecessary.call.to.string.valueof.quickfix: - text: Replace with ''{0}'' -throwable.not.thrown.display.name: - text: Throwable not thrown -throwable.result.of.method.call.ignored.problem.descriptor: - text: 'Result of #ref() not thrown #loc' -char.used.in.arithmetic.context.display.name: - text: Char expression used in arithmetic context -char.used.in.arithmetic.context.problem.descriptor: - text: '''char'' #ref used in arithmetic context #loc' -char.used.in.arithmetic.context.quickfix: - text: Convert to String literal -char.used.in.arithmetic.context.cast.quickfix: - text: Insert cast to {0} + text: Replace with ''{0}'' +unnecessary.code.block.display.name: + text: Unnecessary code block +unnecessary.code.block.unwrap.quickfix: + text: Unwrap block +unnecessary.conditional.expression.display.name: + text: Redundant conditional expression unnecessary.constant.array.creation.expression.display.name: - text: Redundant 'new' expression in constant array creation + text: Redundant 'new' expression in constant array creation +unnecessary.constant.array.creation.expression.family.quickfix: + text: Replace with array initializer expression unnecessary.constant.array.creation.expression.problem.descriptor: - text: '#ref can be replaced with array initializer expression #loc' + text: '#ref can be replaced with array initializer expression #loc' unnecessary.constant.array.creation.expression.quickfix: - text: Remove ''new {0}'' -unnecessary.constant.array.creation.expression.family.quickfix: - text: Replace with array initializer expression -ambiguous.method.call.display.name: - text: Call to inherited method looks like call to local method -ambiguous.method.call.problem.descriptor: - text: 'Call to method #ref() from superclass ''''{0}'''' looks like call to method from class ''''{1}'''' #loc' -ambiguous.method.call.quickfix: - text: Add 'super' qualifier to method call -change.modifier.quickfix: - text: Make ''{0}'' -the.whole.project: - text: the whole project -this.class: - text: this class -assertequals.may.be.assertsame.display.name: - text: '''assertEquals()'' may be ''assertSame()''' -assertequals.may.be.assertsame.problem.descriptor: - text: '#ref() may be ''assertSame()'' #loc' -logger.initialized.with.foreign.class.quickfix: - text: Replace with ''{0}.class'' -logger.initialized.with.foreign.class.problem.descriptor: - text: 'Logger initialized with foreign class #ref #loc' -logger.initialized.with.foreign.class.display.name: - text: Logger initialized with foreign class -logger.factory.method.name: - text: Logger factory method name -logger.factory.class.name: - text: Logger factory class name -make.static.final.quickfix: - text: Make ''{0}'' static final -logging.condition.disagrees.with.log.statement.display.name: - text: Log condition does not match logging call -logging.condition.disagrees.with.log.statement.problem.descriptor: - text: 'Log condition #ref() does not match ''''{0}()'''' logging call #loc' -log.statement.guarded.by.log.condition.display.name: - text: Logging call not guarded by log condition -log.statement.guarded.by.log.condition.problem.descriptor: - text: '#ref() logging calls not guarded by log condition #loc' -log.statement.guarded.by.log.condition.quickfix: - text: Surround with log condition -log.statement.guarded.by.log.condition.flag.all.unguarded.option: - text: Flag all unguarded logging calls -key.set.iteration.may.use.entry.set.display.name: - text: Iteration over 'keySet()' may be replaced with 'entrySet()' iteration -key.set.iteration.may.use.entry.set.problem.descriptor: - text: 'Iteration over #ref may be replaced with ''entrySet()'' iteration #loc' -key.set.iteration.may.use.entry.set.quickfix: - text: Replace with 'entrySet()' iteration -string.replaceable.by.string.buffer.in.loop.option: - text: Only warn when appending in a loop -declare.collection.as.interface.quickfix: - text: Weaken to ''{0}'' -non.exception.name.ends.with.exception.quickfix: - text: Make ''{0}'' extend ''java.lang.Exception'' -constant.value.variable.use.display.name: - text: Use of variable whose value is known to be constant -constant.value.variable.use.problem.descriptor: - text: 'Value of #ref is known to be constant #loc' -replace.reference.with.expression.quickfix: - text: Replace with ''{0}'' -unnecessary.parentheses.option: - text: Ignore clarifying parentheses -unnecessary.parentheses.conditional.option: - text: Ignore parentheses around the condition of conditional expressions -field.may.be.final.display.name: - text: Field may be 'final' -field.may.be.final.problem.descriptor: - text: 'Field #ref may be ''final'' #loc' -cast.that.loses.precision.option: - text: Ignore casts from int to char -ignore.overflowing.byte.casts.option: - text: Ignore casts from int 128-255 to byte -variable.not.used.inside.if.display.name: - text: Reference checked for 'null' is not used inside 'if' -variable.not.used.inside.if.problem.descriptor: - text: '#ref checked for ''null'' is not used inside ''if'' #loc' -variable.not.used.inside.conditional.problem.descriptor: - text: '#ref checked for ''null'' is not used inside conditional #loc' -boolean.expression.may.be.conditional.display.name: - text: Boolean expression could be replaced with conditional expression -if.may.be.conditional.display.name: - text: '''if'' statement could be replaced with conditional expression' -if.may.be.conditional.problem.descriptor: - text: '#ref could be replaced with conditional expression #loc' -if.may.be.conditional.quickfix: - text: Replace with conditional expression -if.may.be.conditional.report.method.calls.option: - text: Report if statements containing method calls -redundant.string.format.call.display.name: - text: Redundant call to 'String.format()' -redundant.string.format.call.problem.descriptor: - text: 'Redundant call to #ref #loc' -redundant.string.format.call.quickfix: - text: Remove redundant call to 'String.format()' -junit4.test.method.in.class.extending.junit3.testcase.display.name: - text: JUnit 4 test method in class extending JUnit 3 TestCase -junit4.test.method.in.class.extending.junit3.testcase.problem.descriptor: - text: 'Method #ref() annotated with ''@Test'' inside class extending JUnit 3 TestCase #loc' -ignore.test.method.in.class.extending.junit3.testcase.problem.descriptor: - text: 'JUnit 3 test method #ref() annotated with ''@Ignore'' won''t be ignored #loc' -ignore.test.method.in.class.extending.junit3.testcase.quickfix: - text: Remove ''@Ignore'' and rename method to ''{0}'' -convert.junit3.test.class.quickfix: - text: Convert JUnit 3 class ''{0}'' to JUnit 4 -remove.junit4.test.annotation.quickfix: - text: Remove '@Test' annotation -remove.junit4.test.annotation.and.rename.quickfix: - text: Remove ''@Test'' annotation and rename to ''{0}'' -equals.called.on.enum.constant.display.name: - text: '''equals()'' called on Enum value' -equals.called.on.enum.constant.problem.descriptor: - text: '#ref() called on Enum value #loc' -equals.called.on.enum.constant.quickfix: - text: Replace 'equals()' with '==' -int.literal.may.be.long.literal.display.name: - text: '''int'' literal cast to ''long'' could be ''long'' literal' -int.literal.may.be.long.literal.problem.descriptor: - text: '#ref could be replaced with ''''{0}'''' #loc' -int.literal.may.be.long.literal.quickfix: - text: Replace with ''{0}'' -constant.assert.condition.display.name: - text: '''assert'' statement condition is constant' -constant.assert.condition.problem.descriptor: - text: 'Assert condition #ref is constant #loc' -assert.with.side.effects.display.name: - text: '''assert'' statement with side effects' -assert.with.side.effects.problem.descriptor: - text: '#ref has side effects #loc' -method.count.ignore.getters.setters.option: - text: '&Ignore simple getter and setter methods' -class.new.instance.display.name: - text: Unsafe call to 'Class.newInstance()' -class.new.instance.problem.descriptor: - text: 'Call to #ref() may throw undeclared checked exceptions #loc' -class.new.instance.quickfix: - text: Replace with 'Class.getConstructor().newInstance()' call -dynamic.regex.replaceable.by.compiled.pattern.display.name: - text: Dynamic regular expression could be replaced by compiled Pattern -dynamic.regex.replaceable.by.compiled.pattern.problem.descriptor: - text: '#ref() could be replaced with compiled ''java.util.regex.Pattern'' construct #loc' -dynamic.regex.replaceable.by.compiled.pattern.quickfix: - text: Replace with call to method of compiled 'Pattern' constant -ignore.serializable.option: - text: Ignore 'java.io.Serializable' -ignore.cloneable.option: - text: Ignore 'java.lang.Cloneable' -listener.may.use.adapter.display.name: - text: Class may extend adapter instead of implementing listener -listener.may.use.adapter.problem.descriptor: - text: 'Class ''''{0}'''' may extend ''''{1}'''' instead of implementing #ref #loc' -listener.may.use.adapter.quickfix: - text: Replace with ''extends {0}'' -listener.may.use.adapter.emtpy.methods.option: - text: '&Only warn when empty implementing methods are found' -unnecessary.inherit.doc.display.name: - text: Unnecessary '{'@inheritDoc'}' Javadoc comment -unnecessary.inherit.doc.problem.descriptor: - text: 'Javadoc comment containing only #ref is unnecessary #loc' -unnecessary.inherit.doc.field.invalid.problem.descriptor: - text: '#ref is not valid on fields #loc' -unnecessary.inherit.doc.constructor.invalid.problem.descriptor: - text: '#ref is not valid on constructors #loc' -unnecessary.inherit.doc.class.invalid.problem.descriptor: - text: '#ref is not valid on classes #loc' -unnecessary.inherit.doc.module.invalid.problem.descriptor: - text: '#ref is not valid on module declarations #loc' -unnecessary.inherit.doc.constructor.no.super.problem.descriptor: - text: 'No super method found to inherit Javadoc from #loc' -unnecessary.inherit.doc.quickfix: - text: Remove unnecessary '{'@inheritDoc'}' -multiple.exceptions.declared.on.test.method.display.name: - text: Multiple exceptions declared on test method -multiple.exceptions.declared.on.test.method.problem.descriptor: - text: '#ref could be replaced with ''throws Exception'' #loc' -multiple.exceptions.declared.on.test.method.quickfix: - text: Replace with 'throws Exception' -unnecessary.javadoc.link.display.name: - text: Unnecessary Javadoc link -unnecessary.javadoc.link.super.method.problem.descriptor: - text: '#ref pointing to super method is unnecessary #loc' -unnecessary.javadoc.link.this.method.problem.descriptor: - text: '#ref pointing to this method is unnecessary #loc' -unnecessary.javadoc.link.this.class.problem.descriptor: - text: '#ref pointing to containing class is unnecessary #loc' -unnecessary.javadoc.link.quickfix: - text: Remove unnecessary ''{0}'' -thread.local.not.static.final.display.name: - text: ThreadLocal field not declared static final -thread.local.not.static.final.problem.descriptor: - text: 'ThreadLocal #ref is not declared ''static final'' #loc' -remove.try.finally.block.quickfix: - text: Remove 'try-finally' block -remove.finally.block.quickfix: - text: Remove 'finally' block -remove.leading.zero.to.make.decimal.quickfix: - text: Remove leading zero to make decimal -convert.octal.literal.to.decimal.literal.quickfix: - text: Convert octal literal to decimal literal -ignore.single.field.static.imports.option: - text: Ignore single &field static imports -ignore.single.method.static.imports.option: - text: Ignore single &method static imports -ignore.methods.with.boolean.return.type.option: - text: Ignore methods with 'java.lang.&Boolean' return type -ignore.boolean.methods.in.an.interface.option: - text: Ignore boolean methods in an @&interface -ignore.methods.overriding.super.method: - text: Ignore methods &overriding/implementing a super method -ignore.nullable.parameters.option: - text: Ignore @Nullable parameters -ignored.io.resource.types: - text: Ignored I/O resource types -choose.io.resource.type.to.ignore: - text: Choose I/O resource type to ignore -ignore.accesses.from.the.same.class: - text: Ignore accesses from the same class -ignore.accesses.from.equals.method: - text: Ignore accesses from 'equals()' method -ignore.branches.of.switch.statements: - text: Ignore branches of 'switch' statements -ignore.equals.hashcode.and.tostring: - text: Ignore 'equals()', 'hashCode()' and 'toString()' methods -ignore.methods.in.anonymous.classes: - text: Ignore methods in anonymous classes -class.name: - text: Class name -method.name.regex: - text: Method name regex -choose.class: - text: Choose class -query.column.name: - text: Query names start with -update.column.name: - text: Update names start with -assert.keyword.is.considered.an.assertion: - text: '''assert'' keyword is considered an assertion' -expected.exception.never.thrown.display.name: - text: Expected exception never thrown in test method body -expected.exception.never.thrown.problem.descriptor: - text: 'Expected #ref never thrown in body of ''''{0}()'''' #loc' -choose.logger.class: - text: Choose logger class -logger.class.name: - text: Logger class name -ignore.exceptions.declared.on.library.override.option: - text: Ignore exceptions declared on methods overriding a &library method -allow.resource.to.be.opened.inside.a.try.block: - text: Allow resource to be opened inside a 'try' block -any.method.may.close.resource.argument: - text: Any method may close resource argument -log.method.name: - text: Logging method name -log.condition.text: - text: Log condition text -ignore.if.annotated.by: - text: Ignore if annotated by -ignore.parameter.if.annotated.by: - text: Ignore parameter if it is annotated by -only.weaken.to.an.interface: - text: Only weaken to an interface -unqualified.inner.class.access.display.name: - text: Unqualified inner class access -unqualified.inner.class.access.problem.descriptor: - text: '#ref is not qualified with outer class #loc' -unqualified.inner.class.access.quickfix: - text: Qualify with outer class -unnecessarily.qualified.inner.class.access.problem.descriptor: - text: '''''{0}'''' is unnecessarily qualified with #ref #loc' -unnecessarily.qualified.inner.class.access.display.name: - text: Unnecessarily qualified inner class access -unnecessarily.qualified.inner.class.access.quickfix: - text: Remove qualifier -synchronization.on.static.field.display.name: - text: Synchronization on 'static' field -synchronization.on.static.field.problem.descriptor: - text: 'Synchronization on ''static'' field #ref #loc' -assertequals.called.on.arrays.display.name: - text: '''assertEquals()'' called on array' -assertequals.called.on.arrays.problem.descriptor: - text: '#ref() called on array #loc' -overly.broad.throws.clause.display.name: - text: Overly broad 'throws' clause -overly.broad.throws.clause.problem.descriptor1: - text: 'throws #ref is too broad, masking exception ''''{0}'''' #loc' -overly.broad.throws.clause.problem.descriptor2: - text: 'throws #ref is too broad, masking exceptions ''''{0}'''' and ''''{1}'''' #loc' -overly.broad.throws.clause.quickfix1: - text: Add specific exceptions -overly.broad.throws.clause.quickfix2: - text: Replace with specific exceptions -overly.broad.throws.clause.ignore.thrown.option: - text: Ignore exceptions which &hide others but are themselves thrown -unnecessarily.qualified.statically.imported.element.display.name: - text: Unnecessarily qualified statically imported element -unnecessarily.qualified.statically.imported.element.problem.descriptor: - text: 'Statically imported element ''''{0}'''' is unnecessarily qualified with #ref #loc' -unnecessarily.qualified.statically.imported.element.quickfix: - text: Remove unnecessary qualifier -ignore.instanceof.on.library.classes: - text: Ignore instanceof on library classes -replace.assertequals.quickfix: - text: Replace with ''{0}'' -for.can.be.foreach.option: - text: Report indexed 'java.util.List' loops -for.can.be.foreach.option2: - text: Do not report iterations over untyped collections -cast.conflicts.with.instanceof.quickfix1: - text: Replace ''{0}'' with ''{1}'' in cast -cast.conflicts.with.instanceof.quickfix2: - text: Replace ''{0}'' with ''{1}'' in instanceof -double.checked.locking.quickfix: - text: Make ''{0}'' volatile -double.literal.may.be.float.literal.display.name: - text: '''double'' literal cast to ''float'' could be ''float'' literal' -double.literal.may.be.float.literal.problem.descriptor: - text: '#ref could be replaced with ''''{0}'''' #loc' -double.literal.may.be.float.literal.quickfix: - text: Replace with ''{0}'' -multiple.declaration.option: - text: Ignore 'for' loop declarations -simplifiable.annotation.display.name: - text: Simplifiable annotation -simplifiable.annotation.problem.descriptor: - text: 'Unnecessary #ref in annotation #loc' -simplifiable.annotation.whitespace.problem.descriptor: - text: 'Unnecessary whitespace in annotation #loc' -simplifiable.annotation.quickfix: - text: Simplify annotation -overloaded.methods.with.same.number.parameters.option: - text: Ignore overloaded methods whose parameter types are definitely incompatible -string.concatenation.in.format.call.display.name: - text: String concatenation as argument to 'format()' call -string.concatenation.in.format.call.problem.descriptor: - text: '#ref() call has a String concatenation argument #loc' -string.concatenation.in.format.call.quickfix: - text: Replace concatenation with separate argument -string.concatenation.in.message.format.call.display.name: - text: String concatenation as argument to 'MessageFormat.format()' call -string.concatenation.in.message.format.call.problem.descriptor: - text: 'String concatenation as argument to ''MessageFormat.format()'' call #loc' -shift.out.of.range.quickfix: - text: Replace ''{0}'' with ''{1}'' -boxing.boxed.value.display.name: - text: Boxing of already boxed value -boxing.boxed.value.problem.descriptor: - text: 'Boxing of already boxed #ref #loc' -boxing.boxed.value.quickfix: - text: Remove unnecessary boxing -unnecessary.javadoc.link.option: - text: Ignore inline links to super methods -constant.junit.assert.argument.display.name: - text: Constant JUnit assert argument -constant.junit.assert.argument.problem.descriptor: - text: 'Argument #ref is constant #loc' -test.case.with.no.test.methods.option: - text: Ignore test cases which have superclasses with test methods -package.dot.html.may.be.package.info.display.name: - text: '''package.html'' may be converted to ''package-info.java''' -package.dot.html.may.be.package.info.exists.problem.descriptor: - text: package.html is ignored because package-info.java exists -package.dot.html.may.be.package.info.problem.descriptor: - text: package.html may be converted to package-info.java -package.dot.html.may.be.package.info.delete.quickfix: - text: Delete 'package.html' -package.dot.html.may.be.package.info.convert.quickfix: - text: Convert to 'package-info.java' -choose.super.class.to.ignore: - text: Choose class -ignore.anonymous.inner.classes: - text: Ignore anonymous inner classes -try.with.identical.catches.display.name: - text: Identical 'catch' branches in 'try' statement -try.with.identical.catches.problem.descriptor: - text: '''''catch'''' branch identical to ''''{0}'''' branch #loc' -if.can.be.switch.display.name: - text: '''if'' replaceable with ''switch''' -if.can.be.switch.problem.descriptor: - text: '#ref statement replaceable with ''switch'' statement #loc' -if.can.be.switch.quickfix: - text: Replace with 'switch' -if.can.be.switch.minimum.branch.option: - text: 'Minimum number of branches:' -if.can.be.switch.int.option: - text: Suggest switch on numbers -if.can.be.switch.enum.option: - text: Suggest switch on enums -if.can.be.switch.null.safe.option: - text: Only suggest on null-safe expressions -unnecessarily.qualified.inner.class.access.option: - text: Ignore references for which an import is needed -unqualified.inner.class.access.option: - text: Ignore references to local inner classes -try.with.identical.catches.quickfix: - text: Collapse 'catch' blocks -confusing.else.option: - text: Report when there are no more statements after the 'if' statement -html.tag.can.be.javadoc.tag.display.name: - text: ... can be replaced with '{'@code ...'}' -html.tag.can.be.javadoc.tag.problem.descriptor: - text: '#ref...\</code\> can be replaced with ''{@code ...}'' #loc' -html.tag.can.be.javadoc.tag.quickfix: - text: Replace with '{@code ...}' -try.finally.can.be.try.with.resources.display.name: - text: '''try finally'' replaceable with ''try'' with resources' -try.finally.can.be.try.with.resources.problem.descriptor: - text: '#ref can use automatic resource management #loc' -try.finally.can.be.try.with.resources.quickfix: - text: Replace with 'try' with resources -array.comparison.display.name: - text: Array comparison using '==', instead of 'Arrays.equals()' -array.comparison.problem.descriptor: - text: 'Array objects are compared using #ref, not ''Arrays.equals()'' #loc' -array.hash.code.display.name: - text: '''hashCode()'' called on array' -array.hash.code.problem.descriptor: - text: '#ref() called on array should probably be ''Arrays.hashCode()'' #loc' -arrays.deep.hash.code.quickfix: - text: Replace with 'Arrays.deepHashCode()' -arrays.hash.code.quickfix: - text: Replace with 'Arrays.hashCode()' -method.can.be.variable.arity.method.display.name: - text: Method can be varargs method -method.can.be.variable.arity.method.problem.descriptor: - text: '#ref() can be converted to varargs method #loc' -method.can.be.variable.arity.method.ignore.byte.short.option: - text: Ignore parameters with type byte[] or short[] -method.can.be.variable.arity.method.ignore.all.primitive.arrays.option: - text: Ignore all primitive array types -method.can.be.variable.arity.method.ignore.multiple.arrays.option: - text: Ignore methods with multiple array parameters -method.can.be.variable.arity.method.ignore.multidimensional.arrays.option: - text: Ignore multidimensional array parameters -convert.to.variable.arity.method.quickfix: - text: Convert to varargs method -mismatched.string.builder.query.update.display.name: - text: Mismatched query and update of StringBuilder -mismatched.string.builder.updated.problem.descriptor: - text: 'Contents of {0} #ref are updated, but never queried #loc' -mismatched.string.builder.queried.problem.descriptor: - text: 'Contents of {0} #ref are queried, but never updated #loc' -math.random.cast.to.int.display.name: - text: '''Math.random()'' cast to ''int''' -math.random.cast.to.int.problem.descriptor: - text: '#ref cast to ''''{0}'''' is always rounded down to ''''0'''' #loc' -math.random.cast.to.int.quickfix: - text: Add parentheses to perform multiplication before cast -boolean.variable.always.inverted.display.name: - text: Boolean variable is always inverted -boolean.field.always.inverted.problem.descriptor: - text: 'Boolean field #ref is always inverted #loc' -boolean.variable.always.inverted.problem.descriptor: - text: 'Boolean variable #ref is always inverted #loc' + text: Remove ''new {0}'' +unnecessary.constructor.annotation.option: + text: Ignore constructors with an annotation +unnecessary.constructor.display.name: + text: Redundant no-arg constructor +unnecessary.constructor.problem.descriptor: + text: 'No-arg constructor #ref() is redundant #loc' +unnecessary.constructor.remove.quickfix: + text: Remove redundant constructor +unnecessary.continue.display.name: + text: Unnecessary 'continue' statement +unnecessary.continue.problem.descriptor: + text: '#ref is unnecessary as the last statement in a loop #loc' +unnecessary.default.display.name: + text: Unnecessary 'default' for enum 'switch' statement +unnecessary.default.problem.descriptor: + text: '#ref branch is unnecessary #loc' +unnecessary.enum.modifier.display.name: + text: Unnecessary enum modifier +unnecessary.enum.modifier.problem.descriptor: + text: 'Modifier #ref is redundant for enum constructors #loc' +unnecessary.enum.modifier.problem.descriptor1: + text: 'Modifier #ref is redundant for inner enums #loc' unnecessary.explicit.numeric.cast.display.name: - text: Unnecessary explicit numeric cast + text: Unnecessary explicit numeric cast unnecessary.explicit.numeric.cast.problem.descriptor: - text: '''''{0}'''' unnecessarily cast to #ref #loc' + text: '''''{0}'''' unnecessarily cast to #ref #loc' unnecessary.explicit.numeric.cast.quickfix: - text: Remove cast -null.thrown.display.name: - text: '''null'' thrown' -null.thrown.problem.descriptor: - text: '#ref thrown #loc' -null.thrown.quickfix: - text: Replace with 'new NullPointerException()' + text: Remove cast unnecessary.final.on.local.variable.or.parameter.display.name: - text: Unnecessary 'final' on local variable or parameter + text: Unnecessary 'final' on local variable or parameter unnecessary.final.on.local.variable.problem.descriptor: - text: 'Unnecessary #ref on variable ''''{0}'''' #loc' + text: 'Unnecessary #ref on variable ''''{0}'''' #loc' +unnecessary.final.on.parameter.only.interface.option: + text: Only warn on abstract or interface methods unnecessary.final.on.parameter.problem.descriptor: - text: 'Unnecessary #ref on parameter ''''{0}'''' #loc' + text: 'Unnecessary #ref on parameter ''''{0}'''' #loc' unnecessary.final.report.local.variables.option: - text: Report local variables + text: Report local variables unnecessary.final.report.parameters.option: - text: Report parameters -unnecessary.final.on.parameter.only.interface.option: - text: Only warn on abstract or interface methods -choose.exception.class: - text: Choose Exception class -class.independent.of.module.display.name: - text: Class independent of its module -class.independent.of.module.problem.descriptor: - text: 'Class #ref has no dependencies or dependents in its module #loc' -class.only.used.in.one.module.display.name: - text: Class only used from one other module -class.only.used.in.one.module.problem.descriptor: - text: 'Class #ref has only dependencies on and/or dependents in module ''''{0}'''' #loc' -empty.directory.display.name: - text: Empty directory -empty.directories.problem.descriptor: - text: Empty directory {0} -empty.directories.only.under.source.roots.option: - text: Only report empty directories located under a source folder -empty.directories.delete.quickfix: - text: Delete empty directory ''{0}'' -simplifiable.equals.expression.display.name: - text: Unnecessary 'null' check before 'equals()' call -simplifiable.equals.expression.problem.descriptor: - text: 'Unnecessary ''''null'''' check before ''''{0}()'''' call #loc' -simplifiable.equals.expression.quickfix: - text: Flip ''.{0}()'' and remove unnecessary ''null'' check -cast.to.concrete.class.option: - text: Ignore casts to an abstract class type -cast.to.concrete.class.ignore.equals.option: - text: Ignore in equals() -instanceof.interfaces.option: - text: Ignore instanceof abstract class -instance.variable.of.concrete.class.option: - text: Ignore instance fields whose type is an abstract class -local.variable.of.concrete.class.option: - text: Ignore local variables whose type is an abstract class -method.return.of.concrete.class.option: - text: Ignore methods whose return type is an abstract class -parameter.of.concrete.class.option: - text: Ignore parameters whose type is abstract class -static.variable.of.concrete.class.option: - text: Ignore static fields whose type is an abstract class -class.only.used.in.one.package.display.name: - text: Class only used from one other package -class.only.used.in.one.package.problem.descriptor: - text: 'Class #ref has only dependencies on and/or dependents in package ''''{0}'''' #loc' + text: Report parameters +unnecessary.fully.qualified.name.display.name: + text: Unnecessary fully qualified name +unnecessary.fully.qualified.name.problem.descriptor1: + text: 'Qualifier #ref is unnecessary, and can be replaced with an import #loc' +unnecessary.fully.qualified.name.problem.descriptor2: + text: 'Qualifier #ref is unnecessary and can be removed #loc' +unnecessary.fully.qualified.name.remove.quickfix: + text: Remove unnecessary qualification +unnecessary.fully.qualified.name.replace.quickfix: + text: Replace qualified name with import +unnecessary.fully.qualified.name.status.bar.escape.highlighting.message: + text: '{0} fully qualified {0, choice, 1#name|2#names} replaced with import (press Escape to remove highlighting)' +unnecessary.inherit.doc.class.invalid.problem.descriptor: + text: '#ref is not valid on classes #loc' +unnecessary.inherit.doc.constructor.invalid.problem.descriptor: + text: '#ref is not valid on constructors #loc' +unnecessary.inherit.doc.constructor.no.super.problem.descriptor: + text: 'No super method found to inherit Javadoc from #loc' +unnecessary.inherit.doc.display.name: + text: Unnecessary '{@inheritDoc}' Javadoc comment +unnecessary.inherit.doc.field.invalid.problem.descriptor: + text: '#ref is not valid on fields #loc' +unnecessary.inherit.doc.module.invalid.problem.descriptor: + text: '#ref is not valid on module declarations #loc' +unnecessary.inherit.doc.problem.descriptor: + text: 'Javadoc comment containing only #ref is unnecessary #loc' +unnecessary.inherit.doc.quickfix: + text: Remove unnecessary '{@inheritDoc}' +unnecessary.initcause.display.name: + text: Unnecessary call to 'Throwable.initCause()' +unnecessary.initcause.problem.descriptor: + text: Unnecessary Throwable.#ref() call +unnecessary.initcause.quickfix: + text: Remove 'Throwable.initCause()' call +unnecessary.interface.modifier.display.name: + text: Unnecessary interface modifier +unnecessary.interface.modifier.inner.interface.of.interface.problem.descriptor: + text: 'Modifier #ref is redundant for inner interfaces #loc' +unnecessary.interface.modifier.problem.descriptor: + text: 'Modifier #ref is redundant for interfaces #loc' +unnecessary.interface.modifier.problem.descriptor2: + text: 'Modifier #ref is redundant for interface methods #loc' +unnecessary.interface.modifier.problem.descriptor3: + text: 'Modifier #ref is redundant for inner classes of interfaces #loc' +unnecessary.interface.modifier.problem.descriptor4: + text: 'Modifier #ref is redundant for interface fields #loc' +unnecessary.javadoc.link.display.name: + text: Unnecessary Javadoc link +unnecessary.javadoc.link.option: + text: Ignore inline links to super methods +unnecessary.javadoc.link.quickfix: + text: Remove unnecessary ''{0}'' +unnecessary.javadoc.link.super.method.problem.descriptor: + text: '#ref pointing to super method is unnecessary #loc' +unnecessary.javadoc.link.this.class.problem.descriptor: + text: '#ref pointing to containing class is unnecessary #loc' +unnecessary.javadoc.link.this.method.problem.descriptor: + text: '#ref pointing to this method is unnecessary #loc' +unnecessary.label.on.break.statement.display.name: + text: Unnecessary label on 'break' statement +unnecessary.label.on.break.statement.problem.descriptor: + text: 'Unnecessary label on #ref statement #loc' +unnecessary.label.on.continue.statement.display.name: + text: Unnecessary label on 'continue' statement +unnecessary.label.on.continue.statement.problem.descriptor: + text: 'Unnecessary label on #ref statement #loc' +unnecessary.label.remove.quickfix: + text: Remove label +unnecessary.local.variable.problem.descriptor: + text: 'Local variable #ref is redundant #loc' +unnecessary.parentheses.conditional.option: + text: Ignore parentheses around the condition of conditional expressions +unnecessary.parentheses.display.name: + text: Unnecessary parentheses +unnecessary.parentheses.option: + text: Ignore clarifying parentheses +unnecessary.parentheses.problem.descriptor: + text: 'Parentheses around #ref are unnecessary #loc' +unnecessary.parentheses.remove.quickfix: + text: Remove unnecessary parentheses +unnecessary.qualifier.for.super.problem.descriptor: + text: 'Qualifier #ref on ''super'' is unnecessary in this context #loc' +unnecessary.qualifier.for.this.display.name: + text: Unnecessary qualifier for 'this' or 'super' +unnecessary.qualifier.for.this.problem.descriptor: + text: 'Qualifier #ref on ''this'' is unnecessary in this context #loc' +unnecessary.qualifier.for.this.remove.quickfix: + text: Remove unnecessary qualifier +unnecessary.return.constructor.problem.descriptor: + text: '#ref is unnecessary as the last statement in a constructor #loc' +unnecessary.return.display.name: + text: Unnecessary 'return' statement unnecessary.return.option: - text: Ignore in then branch of 'if' statement with 'else' branch -usage.of.obsolete.assert.display.name: - text: Usage of obsolete 'junit.framework.Assert' method -use.of.obsolete.assert.problem.descriptor: - text: 'Call to #ref() from ''''{0}'''' should be replaced with call to method from ''''org.junit.Assert'''' #loc' -use.of.obsolete.assert.quickfix: - text: Replace with 'org.junit.Assert' method call -junit5.assertions.converter.problem.descriptor: - text: 'Call to #ref() from ''''{0}'''' should be replaced with call to method from ''''{1}'''' #loc' -junit5.assertions.converter.quickfix: - text: Replace with ''{0}'' method call -junit5.assertions.converter.familyName: - text: Replace with JUnit 5 compatible call -properties.object.as.hashtable.set.quickfix: - text: Replace with call to 'setProperty()' -properties.object.as.hashtable.get.quickfix: - text: Replace with call to 'getProperty()' -ignored.junit.test.display.name: - text: JUnit test annotated with '@Ignore'/'@Disabled' -ignored.junit.test.classproblem.descriptor: - text: 'Test class ''''{0}'''' annotated with #ref #loc' -ignored.junit.test.method.problem.descriptor: - text: 'Test method ''''{0}()'''' annotated with #ref #loc' -unclear.binary.expression.display.name: - text: Unclear expression -unclear.binary.expression.problem.descriptor: - text: 'Expression could use clarifying parentheses #loc' -unclear.binary.expression.quickfix: - text: Add clarifying parentheses -new.exception.without.arguments.display.name: - text: Exception constructor called without arguments -new.exception.without.arguments.problem.descriptor: - text: 'new #ref() without arguments #loc' -new.exception.without.arguments.ignore.option: - text: Ignore for exceptions that have no constructors with parameters -absolute.alignment.in.user.interface.display.name: - text: Absolute alignment used in AWT/Swing code -absolute.alignment.in.user.interface.problem.descriptor: - text: 'Absolute alignment constant {0}.#ref used #loc' -absolute.alignment.in.user.interface.quickfix: - text: Replace with ''{0}.{1}'' -throws.runtime.exception.display.name: - text: Unchecked exception declared in 'throws' clause -throws.runtime.exception.problem.descriptor: - text: 'Unchecked exception #ref declared in ''throws'' clause #loc' -throws.runtime.exception.quickfix: - text: Remove ''{0}'' from ''throws'' clause -throws.runtime.exception.move.quickfix: - text: Move ''{0}'' to Javadoc ''@throws'' tag -empty.class.ignore.parameterization.option: - text: Ignore class if it is a parameterization of a super type -ambiguous.field.access.display.name: - text: Access of inherited field looks like access of element in surrounding code -ambiguous.field.access.hides.local.variable.problem.descriptor: - text: 'Access of field #ref from superclass ''''{0}'''' looks like access of local variable #loc' -ambiguous.field.access.hides.parameter.problem.descriptor: - text: 'Access of field #ref from superclass ''''{0}'''' looks like access of parameter #loc' -ambiguous.field.access.hides.field.problem.descriptor: - text: 'Access of field #ref from superclass ''''{0}'''' looks like access of field from surrounding class #loc' -ambiguous.field.access.quickfix: - text: Add 'super' qualifier to field access -string.builder.replaceable.by.string.quickfix: - text: Replace 'StringBuilder' with 'String' -string.buffer.replaceable.by.string.quickfix: - text: Replace 'StringBuffer' with 'String' -add.0.to.ignore.if.annotated.by.list.quickfix: - text: Add ''{0}'' to ''Ignore if annotated by'' list -non.final.field.in.enum.display.name: - text: Non-'final' field in enum -non.final.field.in.enum.problem.descriptor: - text: 'non-''''final'''' field #ref in enum ''''{0}'''' #loc' -externalizable.without.public.no.arg.constructor.display.name: - text: Externalizable class without 'public' no-arg constructor -externalizable.without.public.no.arg.constructor.problem.descriptor: - text: 'Externalizable class #ref has no ''public'' no-arg constructor #loc' -make.constructor.public: - text: Make constructor 'public' -string.concatenation.missing.whitespace.display.name: - text: String literal concatenation missing whitespace -string.concatenation.missing.whitespace.problem.descriptor: - text: 'String literal concatenation missing whitespace #loc' -string.concatenation.missing.whitespace.option: - text: Ignore when one or both sides are not literals -negated.equality.expression.display.name: - text: Negated equality expression -negated.equality.expression.problem.descriptor: - text: 'Negating ''''{0}'''' #loc' -negated.equality.expression.quickfix: - text: Remove negation -negated.conditional.expression.display.name: - text: Negated conditional expression -negated.conditional.expression.problem.descriptor: - text: 'Negating conditional expression #loc' -negated.conditional.expression.quickfix: - text: Remove negation -suspicious.array.cast.display.name: - text: Suspicious array cast -suspicious.array.cast.problem.descriptor: - text: 'Suspicious cast to #ref #loc' -public.constructor.display.name: - text: '''public'' constructor' -public.default.constructor.problem.descriptor: - text: Class #ref has 'public' default constructor -public.constructor.problem.descriptor: - text: 'Public constructor #ref() #loc' -public.constructor.quickfix: - text: Replace constructor with factory method -junit3.style.test.method.in.junit4.class.display.name: - text: Old style JUnit test method in JUnit 4 class -junit3.style.test.method.in.junit4.class.problem.descriptor: - text: 'Old style JUnit test method #ref() in JUnit 4 class #loc' -none: - text: none -private.modifier: - text: private -package.local.private: - text: package-private \& private -protected.package.local.private: - text: protected, package-private \& private -non.final.utility.class.display.name: - text: Utility class is not 'final' -non.final.utility.class.problem.descriptor: - text: 'Utility class #ref is not ''final'' #loc' -0.will.no.longer.be.overridable.by.1: - text: '{0} will no longer be overridable by {1}' -0.will.have.incompatible.access.privileges.with.super.1: - text: '{0} will have incompatible access privileges with super {1}' -0.will.no.longer.be.visible.from.overriding.1: - text: '{0} will no longer be visible from overriding {1}' -make.private.quickfix: - text: Make 'private' -arrays.as.list.with.zero.or.one.argument.display.name: - text: Call to 'Arrays.asList()' with too few arguments -arrays.as.list.with.one.argument.problem.descriptor: - text: 'Call to #ref with only one argument #loc' -arrays.as.list.with.zero.arguments.problem.descriptor: - text: 'Call to #ref with zero arguments #loc' -arrays.as.list.with.one.argument.quickfix: - text: Replace with call to 'Collections.singletonList()' -arrays.as.list.with.zero.arguments.quickfix: - text: Replace with call to 'Collections.emptyList()' -ignore.classes.extending.throwable.option: - text: Ignore classes extending 'Throwable' -string.concatenation.argument.to.log.call.display.name: - text: Non-constant string concatenation as argument to logging call -string.concatenation.argument.to.log.call.problem.descriptor: - text: 'Non-constant string concatenation as argument to #ref() logging call #loc' -string.concatenation.argument.to.log.call.quickfix: - text: Replace concatenation with parameterized log message -placeholder.count.matches.argument.count.display.name: - text: Number of placeholders does not match number of arguments in logging call -placeholder.count.matches.argument.count.more.problem.descriptor: - text: 'More arguments provided ({0}) than placeholders specified ({1}) #loc' -placeholder.count.matches.argument.count.fewer.problem.descriptor: - text: 'Fewer arguments provided ({0}) than placeholders specified ({1}) #loc' -assignment.to.superclass.field.display.name: - text: Constructor assigns value to field defined in superclass -assignment.to.superclass.field.problem.descriptor: - text: 'Assignment to field ''''{0}'''' defined in superclass ''''{1}'''' #loc' -junit.rule.display.name: - text: Malformed @Rule/@ClassRule field -junit.rule.problem.descriptor: - text: Fields annotated with ''@{0}'' should be {1} -junit.rule.type.problem.descriptor: - text: Field type should be subtype of 'org.junit.rules.TestRule' -junit.datapoint.display.name: - text: Malformed @DataPoint field -junit.datapoint.problem.descriptor: - text: '{1}s annotated with @DataPoint should be {0}' -inner.class.referenced.via.subclass.display.name: - text: Inner class referenced via subclass -inner.class.referenced.via.subclass.problem.descriptor: - text: 'Inner class #ref declared in class ''''{0}'''' but referenced via subclass ''''{1}'''' #loc' -inner.class.referenced.via.subclass.quickfix: - text: Rationalize inner class access -boolean.parameter.display.name: - text: '''public'' method with ''boolean'' parameter' -boolean.parameter.problem.descriptor: - text: '''public'' method #ref() with ''boolean'' parameter #loc' -boolean.parameters.problem.descriptor: - text: '''public'' method #ref() with ''boolean'' parameters #loc' -boolean.parameter.constructor.problem.descriptor: - text: '''public'' constructor #ref() with ''boolean'' parameter #loc' -boolean.parameters.constructor.problem.descriptor: - text: '''public'' constructor #ref() with ''boolean'' parameters #loc' -boolean.parameter.only.report.multiple.option: - text: Only report methods with multiple boolean parameters + text: Ignore in then branch of 'if' statement with 'else' branch +unnecessary.return.problem.descriptor: + text: '#ref is unnecessary as the last statement in a ''void'' method #loc' +unnecessary.semicolon.display.name: + text: Unnecessary semicolon +unnecessary.semicolon.problem.descriptor: + text: 'Unnecessary semicolon #ref #loc' +unnecessary.semicolon.remove.quickfix: + text: Remove unnecessary semicolon +unnecessary.super.constructor.display.name: + text: Unnecessary call to 'super()' +unnecessary.super.constructor.problem.descriptor: + text: '#ref is unnecessary #loc' +unnecessary.super.constructor.remove.quickfix: + text: Remove unnecessary 'super()' +unnecessary.super.qualifier.display.name: + text: Unnecessary 'super' qualifier +unnecessary.super.qualifier.problem.descriptor: + text: 'Qualifier #ref is unnecessary in this context #loc' +unnecessary.super.qualifier.quickfix: + text: Remove unnecessary 'super' qualifier +unnecessary.temporary.on.conversion.from.string.display.name: + text: Unnecessary temporary object in conversion from 'String' +unnecessary.temporary.on.conversion.from.string.fix.name: + text: Replace with ''{0}'' +unnecessary.temporary.on.conversion.from.string.problem.descriptor: + text: '#ref #loc can be simplified to ''''{0}''''' +unnecessary.temporary.on.conversion.to.string.display.name: + text: Unnecessary temporary object in conversion to 'String' +unnecessary.this.display.name: + text: Unnecessary 'this' qualifier +unnecessary.this.ignore.assignments.option: + text: Ignore field assignments +unnecessary.this.problem.descriptor: + text: '#ref is unnecessary in this context #loc' +unnecessary.this.remove.quickfix: + text: Remove unnecessary 'this' qualifier +unnecessary.tostring.call.display.name: + text: Unnecessary call to 'toString()' +unnecessary.tostring.call.problem.descriptor: + text: 'Unnecessary #ref() call #loc' +unnecessary.unary.minus.display.name: + text: Unnecessary unary minus +unnecessary.unary.minus.problem.descriptor: + text: 'Unnecessary unary minus #loc' +unnecessary.unary.minus.quickfix: + text: Remove unary minus and invert parent operation sign +unnecessary.unboxing.display.name: + text: Unnecessary unboxing +unnecessary.unboxing.problem.descriptor: + text: 'Unnecessary unboxing #ref #loc' +unnecessary.unboxing.remove.quickfix: + text: Remove unboxing +unnecessary.unboxing.superfluous.option: + text: Only report truly superfluously unboxed expressions unnecessary.unicode.escape.display.name: - text: Unnecessary unicode escape sequence + text: Unnecessary Unicode escape sequence unnecessary.unicode.escape.problem.descriptor: - text: 'Unicode escape sequence #ref can be replaced with ''''{0}'''' #loc' -missing.package.info.display.name: - text: Missing 'package-info.java' -missing.package.info.problem.descriptor: - text: Package ''{0}'' is missing a package-info.java file -missing.package.html.problem.descriptor: - text: Package ''{0}'' is missing a package.html file -package.info.java.without.package.display.name: - text: '''package-info.java'' without ''package'' statement' -package.info.without.package.problem.descriptor: - text: '''package-info.java'' does not have a ''package'' statement' -package.info.without.package.quickfix: - text: add ''package {0};'' -package.info.without.package.family.quickfix: - text: add package statement -auto.closeable.resource.display.name: - text: AutoCloseable used without 'try'-with-resources -auto.closeable.resource.problem.descriptor: - text: '''''{0}'''' used without ''''try''''-with-resources statement #loc' -auto.closeable.resource.quickfix: - text: Ignore 'AutoCloseable' returned by this method -auto.closeable.resource.returned.option: - text: Ignore AutoCloseable instances returned from all method calls -problematic.varargs.method.display.name: - text: Non-varargs method overrides varargs method -problematic.varargs.method.override.problem.descriptor: - text: 'Non-varargs method #ref() overrides varargs method #loc' -negatively.named.boolean.variable.problem.descriptor: - text: 'Boolean variable #ref is negatively named #loc' -negatively.named.boolean.variable.display.name: - text: Negatively named boolean variable -invert.quickfix.family.name: - text: Invert boolean -invert.method.quickfix: - text: Invert method -invert.quickfix: - text: Invert ''{0}'' -throwable.printed.to.system.out.display.name: - text: '''Throwable'' printed to ''System.out''' -throwable.printed.to.system.out.problem.descriptor: - text: '''Throwable'' argument #ref to ''''System.{0}.{1}()'''' call' -suppress.for.tests.scope.quickfix: - text: Suppress for 'Tests' scope -implicit.default.charset.usage.display.name: - text: Implicit usage of platform's default charset -implicit.default.charset.usage.problem.descriptor: - text: Call to #ref() uses the platform's default charset -implicit.default.charset.usage.constructor.problem.descriptor: - text: 'new #ref() call uses the platform''s default charset' -interface.may.be.annotated.functional.display.name: - text: Interface may be annotated @FunctionalInterface -interface.may.be.annotated.functional.problem.descriptor: - text: Interface #ref may be annotated with @FunctionalInterface -only.report.public.methods.option: - text: Only report 'public' methods -lambda.parameter.hides.member.variable.display.name: - text: Lambda parameter hides field -static.initializer.references.subclass.display.name: - text: Static initializer references subclass -lambda.parameter.hides.member.variable.problem.descriptor: - text: 'Lambda parameter #ref hides field in class ''''{0}'''' #loc' -lambda.parameter.hides.member.variable.ignore.invisible.option: - text: Ignore fields not actually visible from the lambda -shared.thread.local.random.display.name: - text: '''ThreadLocalRandom'' instance might be shared' -shared.thread.local.random.problem.descriptor: - text: '''ThreadLocalRandom'' instance might be shared between threads' -native.method.naming.convention.display.name: - text: '''native'' method naming convention' -native.method.naming.convention.element.description: - text: '''native'' method' + text: 'Unicode escape sequence #ref can be replaced with ''''{0}'''' #loc' +unpredictable.big.decimal.constructor.call.display.name: + text: Unpredictable 'BigDecimal' constructor call +unpredictable.big.decimal.constructor.call.ignore.complex.literals.option: + text: Ignore constructor calls with multiple literals (e.g. 0.1 + 0.2) +unpredictable.big.decimal.constructor.call.ignore.references.option: + text: Ignore constructor calls with variable or method call arguments +unpredictable.big.decimal.constructor.call.problem.descriptor: + text: 'Unpredictable new #ref() call #loc' +unpredictable.big.decimal.constructor.call.quickfix: + text: Replace with ''{0}'' +unqualified.field.access.display.name: + text: Instance field access not qualified with 'this' +unqualified.field.access.problem.descriptor: + text: 'Instance field access #ref is not qualified with ''this'' #loc' +unqualified.inner.class.access.display.name: + text: Unqualified inner class access +unqualified.inner.class.access.option: + text: Ignore references to local inner classes +unqualified.inner.class.access.problem.descriptor: + text: '#ref is not qualified with outer class #loc' +unqualified.inner.class.access.quickfix: + text: Qualify with outer class +unqualified.method.access.display.name: + text: Instance method call not qualified with 'this' +unqualified.method.access.problem.descriptor: + text: 'Instance method call #ref() is not qualified with ''this'' #loc' +unqualified.static.usage.display.name: + text: Unqualified static access +unqualified.static.usage.ignore.field.option: + text: Ignore unqualified field accesses +unqualified.static.usage.ignore.method.option: + text: Ignore unqualified method calls +unqualified.static.usage.only.report.static.usages.option: + text: Only report static access from a non-static context +unqualified.static.usage.problem.descriptor: + text: 'Unqualified static method call #ref() #loc' +unqualified.static.usage.problem.descriptor1: + text: 'Unqualified static field access #ref #loc' +unqualified.static.usage.qualify.field.quickfix: + text: Qualify static field access +unqualified.static.usage.qualify.method.quickfix: + text: Qualify static method call +unsecure.random.number.generation.display.name: + text: Insecure random number generation +unsecure.random.number.generation.problem.descriptor1: + text: 'For security purposes, use ''java.security.SecureRandom'' instead of java.lang.Math.#ref() #loc' +unsecure.random.number.generation.problem.descriptor2: + text: 'For security purposes, use ''java.security.SecureRandom'' instead of java.util.#ref #loc' +unsecure.random.number.generation.problem.descriptor3: + text: 'For security purposes, use ''java.security.SecureRandom'' instead of #ref #loc' +unused.catch.parameter.display.name: + text: Unused 'catch' parameter +unused.catch.parameter.ignore.catch.option: + text: Ignore when 'catch' block contains a comment +unused.catch.parameter.problem.descriptor: + text: 'Unused ''catch'' parameter #ref #loc' +unused.import.display.name: + text: Unused import +unused.import.problem.descriptor: + text: 'Unused import #ref #loc' +unused.label.display.name: + text: Unused label +unused.label.problem.descriptor: + text: 'Unused label #ref #loc' +unused.label.remove.quickfix: + text: Remove unused label +update.column.name: + text: Update names start with +upper.case.field.name.not.constant.display.name: + text: Non-constant field with upper-case name +upper.case.field.name.not.constant.problem.descriptor: + text: 'Non-constant field #ref with constant-style name #loc' +usage.of.obsolete.assert.display.name: + text: Usage of obsolete 'junit.framework.Assert' method +use.0index.in.jdbc.prepared.statement.problem.descriptor: + text: 'Use of index ''0'' in JDBC PreparedStatement #loc' +use.0index.in.jdbc.resultset.display.name: + text: Use of index 0 in JDBC ResultSet +use.0index.in.jdbc.resultset.problem.descriptor: + text: 'Use of index ''0'' in JDBC ResultSet #loc' +use.assert.as.identifier.display.name: + text: Use of 'assert' as identifier +use.assert.as.identifier.problem.descriptor: + text: 'Use of #ref as identifier #loc' +use.enum.as.identifier.display.name: + text: Use of 'enum' as identifier +use.enum.as.identifier.problem.descriptor: + text: 'Use of #ref as identifier #loc' +use.obsolete.collection.type.display.name: + text: Use of obsolete collection type +use.obsolete.collection.type.ignore.library.arguments.option: + text: Ignore obsolete collection types where they are required +use.obsolete.collection.type.problem.descriptor: + text: 'Obsolete collection type #ref used #loc' +use.of.awt.peer.class.display.name: + text: Use of AWT peer class +use.of.awt.peer.class.problem.descriptor: + text: 'Use of AWT peer class #ref is non-portable #loc' +use.of.clone.call.method.problem.descriptor: + text: Implementation of #ref() +use.of.clone.call.problem.descriptor: + text: Call to #ref() +use.of.clone.display.name: + text: Use of 'clone()' or 'Cloneable' +use.of.clone.reference.problem.descriptor: + text: Use of #ref +use.of.concrete.jdbc.driver.class.display.name: + text: Use of concrete JDBC driver class +use.of.concrete.jdbc.driver.class.problem.descriptor: + text: 'Use of concrete JDBC driver class #ref is non-portable #loc' +use.of.obsolete.assert.problem.descriptor: + text: 'Call to #ref() from ''''{0}'''' should be replaced with call to method from ''''org.junit.Assert'''' #loc' +use.of.obsolete.assert.quickfix: + text: Replace with 'org.junit.Assert' method call use.of.obsolete.date.time.api.display.name: - text: Use of obsolete date-time API + text: Use of obsolete date-time API use.of.obsolete.date.time.api.problem.descriptor: - text: 'Obsolete date-time type #ref used #loc' -warn.on.label: - text: 'Warn on:' -all.levels.option: - text: all log levels -warn.level.and.lower.option: - text: warn level and lower -info.level.and.lower.option: - text: info level and lower -debug.level.and.lower.option: - text: debug level and lower -trace.level.option: - text: trace level -ignored.autocloseable.types.column.label: - text: Ignored AutoCloseable resource types -choose.autocloseable.type.to.ignore.title: - text: Choose AutoCloseable resource type to ignore -big.decimal.method.without.rounding.called.display.name: - text: Call to 'BigDecimal' method without a rounding mode argument -big.decimal.method.without.rounding.called.problem.descriptor: - text: '''BigDecimal.#ref()'' called without a rounding mode argument' -bigdecimal.legacy.method.display.name: - text: '''BigDecimal'' legacy method called' -bigdecimal.legacy.method.problem.descriptor: - text: Call to 'BigDecimal.#ref()' can use 'RoundingMode' enum constant -bigdecimal.legacy.method.quickfix: - text: Use 'RoundingMode' enum constant -serializable.stores.non.serializable.display.name: - text: Serializable object implicitly stores non-Serializable object -serializable.lambda.stores.non.serializable.problem.descriptor: - text: Serializable lambda implicitly stores non-Serializable object of type ''{0}'' -serializable.local.class.stores.non.serializable.problem.descriptor: - text: Serializable local class ''{1}'' implicitly stores non-Serializable object of type ''{0}'' -serializable.anonymous.class.stores.non.serializable.problem.descriptor: - text: Serializable anonymous class implicitly stores non-Serializable object of type ''{0}'' -assignment.to.lambda.parameter.display.name: - text: Assignment to lambda parameter -assignment.to.lambda.parameter.problem.descriptor: - text: 'Assignment to lambda parameter #ref #loc' -class.with.only.private.constructors.display.name: - text: Class with only 'private' constructors should be declared 'final' -class.with.only.private.constructors.problem.descriptor: - text: Class #ref with only 'private' constructors should be declared 'final' -property.value.set.to.itself.display.name: - text: Property value set to itself -equals.with.itself.display.name: - text: '''equals()'' called on itself' -equals.with.itself.problem.descriptor: - text: #ref() called on itself -junit4.method.naming.convention.display.name: - text: JUnit 4+ test method naming convention -junit4.method.naming.convention.element.description: - text: JUnit 4+ test method -junit3.method.naming.convention.display.name: - text: JUnit 3 test method naming convention -junit3.method.naming.convention.element.description: - text: JUnit 3 test method -introduce.holder.class.quickfix: - text: Introduce holder class -double.brace.initialization.display.name: - text: Double brace initialization -double.brace.initialization.quickfix: - text: Replace with regular initialization -return.of.inner.class.display.name: - text: Return of instance of anonymous, local or inner class -return.of.anonymous.class.problem.descriptor: - text: 'Return of instance of anonymous class #loc' -return.of.local.class.problem.descriptor: - text: 'Return of instance of local class {0} #loc' -return.of.inner.class.problem.descriptor: - text: 'Return of instance of non-static inner class {0} #loc' -return.of.inner.class.ignore.non.public.option: - text: Ignore returns from non-public methods -parameter.type.prevents.overriding.display.name: - text: Parameter type prevents overriding -parameter.type.prevents.overriding.problem.descriptor: - text: 'Parameter type #ref is located in ''''{0}'''' while super method parameter type is located in ''''{1}'''' preventing overriding #loc' -parameter.type.prevents.overriding.quickfix: - text: Change type of parameter to ''{0}'' -parameter.type.prevents.overriding.family.quickfix: - text: Change type of parameter -suspicious.getter.setter.display.name: - text: Suspicious getter/setter -suspicious.setter.problem.descriptor: - text: 'Setter #ref() assigns field ''''{0}'''' #loc' -suspicious.getter.problem.descriptor: - text: 'Getter #ref() returns field ''''{0}'''' #loc' -unnecessary.break.display.name: - text: Unnecessary 'break' statement -unnecessary.break.problem.descriptor: - text: '#ref statement is unnecessary #loc' + text: 'Obsolete date-time type #ref used #loc' +use.processbuilder.class.display.name: + text: Use of 'java.lang.ProcessBuilder' class +use.processbuilder.class.problem.descriptor: + text: 'Use of #ref is non-portable #loc' +use.stringtokenizer.display.name: + text: Use of 'StringTokenizer' +use.stringtokenizer.problem.descriptor: + text: '#ref in an internationalized context #loc' +use.sun.classes.display.name: + text: Use of 'sun.*' classes +use.sun.classes.problem.descriptor: + text: 'Use of Sun-supplied class #ref is non-portable #loc' +use.system.out.err.display.name: + text: Use of 'System.out' or 'System.err' +use.system.out.err.problem.descriptor: + text: 'Uses of #ref should probably be replaced with more robust logging #loc' +used.catch.parameter.named.ignore.problem.descriptor: + text: '''catch'' parameter named #ref is used #loc' utility.class.can.be.enum.display.name: - text: Utility class can be 'enum' + text: Utility class can be 'enum' utility.class.code.can.be.enum.problem.descriptor: - text: 'Utility class #ref can be ''enum'' #loc' + text: 'Utility class #ref can be ''enum'' #loc' utility.class.code.can.be.enum.quickfix: - text: Convert to 'enum' -non.public.clone.display.name: - text: '''clone()'' method not ''public''' -non.public.clone.problem.descriptor: - text: '#ref() method not ''public'' #loc' -only.warn.on.public.clone.methods: - text: Only warn on 'public' clone methods -only.warn.on.protected.clone.methods: - text: Only warn on 'protected' clone methods -clone.returns.class.type.display.name: - text: '''clone()'' should have return type equal to the class it contains' -clone.returns.class.type.problem.descriptor: - text: '''''clone()'''' should have return type ''''{0}'''' #loc' -clone.returns.class.type.quickfix: - text: Change return type to ''{0}'' -clone.returns.class.type.family.quickfix: - text: Change return type to class type -use.of.clone.display.name: - text: Use of 'clone()' or 'Cloneable' -use.of.clone.call.problem.descriptor: - text: Call to #ref() -use.of.clone.call.method.problem.descriptor: - text: Implementation of #ref() -use.of.clone.reference.problem.descriptor: - text: Use of #ref -dangling.javadoc.display.name: - text: Dangling Javadoc comment -dangling.javadoc.problem.descriptor: - text: 'Dangling Javadoc comment #loc' -dangling.javadoc.convert.quickfix: - text: Replace with block comment -dangling.javadoc.delete.quickfix: - text: Remove dangling comment -equals.replaceable.by.objects.call.display.name: - text: '''equals()'' expression replaceable by ''Objects.equals()'' expression' -equals.replaceable.by.objects.call.problem.descriptor: - text: '#ref replaceable by ''Objects.equals()'' expression #loc' -equals.replaceable.by.objects.call.quickfix: - text: Replace with 'Objects.equals()' expression -equals.replaceable.by.objects.check.not.null.option: - text: Report only null safe 'equals' calls -array.objects.equals.display.name: - text: '''Objects.equals()'' called on arrays' -array.objects.equals.problem.descriptor: - text: 'Objects.#ref() on arrays should probably be ''Arrays.equals()'' #loc' -array.objects.deep.equals.problem.descriptor: - text: 'Objects.#ref() on arrays should probably be ''Arrays.deepEquals()'' #loc' -extends.throwable.display.name: - text: Class directly extends 'java.lang.Throwable' -anonymous.extends.throwable.problem.descriptor: - text: 'Anonymous class directly extends ''java.lang.Throwable'' #loc' -extends.throwable.problem.descriptor: - text: 'class #ref directly extends ''java.lang.Throwable'' #loc' -lambda.parameter.naming.convention.display.name: - text: Lambda parameter naming convention -lambda.parameter.naming.convention.element.description: - text: Lambda parameter -assert.message.not.string.display.name: - text: '''assert'' message is not a String' -assert.message.of.type.boolean.problem.descriptor: - text: '''''assert'''' message of type ''''{0}'''' #loc' -assert.message.not.string.only.warn.boolean.option: - text: Only warn when 'assert' message is 'boolean' or 'java.lang.Boolean' -suspicious.literal.underscore.display.name: - text: Suspicious underscore in number literal -suspicious.literal.underscore.problem.descriptor: - text: 'Group in number literal with underscores does not have length 3 #loc' -unary.plus.quickfix: - text: Remove unary '+' -super.tear.down.in.finally.display.name: - text: '''super.tearDown()'' not called from ''finally'' block' -super.tear.down.in.finally.problem.descriptor: - text: '#ref() not called from ''finally'' block #loc' -confusing.floating.point.literal.option: - text: Ignore floating point literals in scientific notation -class.may.be.interface.java8.option: - text: Report classes containing non-abstract methods when using Java 8 -simplifiable.boolean.expression.display.name: - text: Simplifiable boolean expression -unnecessary.initcause.display.name: - text: Unnecessary call to 'Throwable.initCause()' -unnecessary.initcause.problem.descriptor: - text: Unnecessary Throwable.#ref() call -unnecessary.initcause.quickfix: - text: Remove 'Throwable.initCause()' call -consider.static.final.fields.constant.option: - text: Consider 'static final' fields constant -atomic.field.updater.not.static.final.display.name: - text: AtomicFieldUpdater field not declared 'static final' -atomic.field.updater.not.static.final.problem.descriptor: - text: '{0} field #ref is not declared ''''static final'''' #loc' -atomic.field.updater.issues.display.name: - text: AtomicFieldUpdater issues -field.not.found.in.class.problem.descriptor: - text: No field named ''{0}'' found in class ''{1}'' -field.incorrect.type.problem.descriptor: - text: Field ''{0}'' does not have type ''{1}'' -field.missing.volatile.modifier.problem.descriptor: - text: Field ''{0}'' does not have ''volatile'' modifier -field.has.static.modifier.problem.descriptor: - text: Field ''{0}'' has ''static'' modifier -private.field.not.accessible.problem.descriptor: - text: '''''private'''' field ''''{0}'''' is not accessible from here' -package.local.field.not.accessible: - text: package-private field ''{0}'' is not accessible from here -protected.field.not.accessible.problem.descriptor: - text: '''''protected'''' field ''''{0}'''' is not accessible from here' -interface.clashes.with.object.class.display.name: - text: Interface method clashes with method in 'java.lang.Object' -interface.clashes.with.object.class.problem.descriptor: - text: #ref() clashes with method in 'java.lang.Object' -optional.used.as.field.or.parameter.type.display.name: - text: '''Optional'' used as field or parameter type' -optional.used.as.field.type.problem.descriptor: - text: #ref used as type for field ''{0}'' -optional.used.as.parameter.type.problem.descriptor: - text: #ref used as type for parameter ''{0}'' -lambda.unfriendly.method.overload.display.name: - text: Lambda unfriendly method overload -lambda.unfriendly.method.overload.problem.descriptor: - text: Lambda unfriendly overload of method #ref() -lambda.unfriendly.constructor.overload.problem.descriptor: - text: Lambda unfriendly overload of constructor #ref() -optional.contains.collection.display.name: - text: '''Optional'' contains array or collection' -optional.contains.collection.problem.descriptor: - text: '''Optional'' contains collection #ref' -optional.contains.array.problem.descriptor: - text: '''Optional'' contains array #ref' -synchronization.on.get.class.display.name: - text: Synchronization on 'getClass()' -synchronization.on.get.class.problem.descriptor: - text: 'Synchronization on #ref() #loc' -object.instantiation.inside.equals.or.hashcode.display.name: - text: Object instantiation inside 'equals()' or 'hashCode()' -object.instantiation.inside.equals.or.hashcode.problem.descriptor: - text: 'Object instantiation inside ''''{0}()'''' #loc' -object.instantiation.inside.equals.or.hashcode.problem.descriptor2: - text: Object instantiation inside ''{0}()'' ({1})#loc -lambda.body.can.be.code.block.name: - text: Lambda body can be code block -lambda.body.can.be.code.block.quickfix: - text: Expand lambda body to '{'...'}' -lambda.parameter.type.can.be.specified.name: - text: Lambda parameter type can be specified -lambda.parameter.type.can.be.specified.descriptor: - text: Lambda can be expanded to {0} -> '{'...'}' -lambda.parameter.type.can.be.specified.quickfix: - text: Expand lambda to {0} -> '{'...'}' -lambda.parameter.type.can.be.specified.family.quickfix: - text: Specify lambda parameter type -diamond.can.be.replaced.with.explicit.type.arguments.name: - text: Diamond can be replaced with explicit type arguments -diamond.can.be.replaced.with.explicit.type.arguments.quickfix: - text: Replace '<>' with explicit type arguments -lambda.can.be.replaced.with.anonymous.name: - text: Lambda can be replaced with anonymous class -lambda.can.be.replaced.with.anonymous.quickfix: - text: Replace lambda with anonymous class -method.ref.can.be.replaced.with.lambda.name: - text: Method reference can be replaced with lambda -method.ref.can.be.replaced.with.lambda.quickfix: - text: Replace method reference with lambda -try.statement.with.multiple.resources.name: - text: Try statement with multiple resources can be split -try.statement.with.multiple.resources.quickfix: - text: Split 'try' statement with multiple resources -multi.catch.can.be.split.name: - text: Multi-catch can be split into separate catch blocks -multi.catch.can.be.split.quickfix: - text: Split multi-catch into separate 'catch' blocks -assertion.can.be.if.name: - text: Assertion can be replaced with if statement -assert.can.be.if.quickfix: - text: Replace 'assert' with 'if' statement -if.can.be.assertion.name: - text: If statement can be replaced with assertion -if.can.be.assertion.quickfix: - text: Replace 'if' with 'assert' statement -equality.operator.compares.objects.name: - text: Objects compared with '==' -equality.operator.compares.objects.descriptor: - text: Objects compared with ''{0}'' -equality.operator.compares.objects.quickfix: - text: Replace ''{0}'' with ''{1}equals()'' -equality.operator.compares.objects.family.quickfix: - text: Replace equality operator with equals() -equality.operator.compares.objects.safe.quickfix: - text: Replace ''{0}'' with safe ''{1}equals()'' -equality.operator.compares.objects.safe.family.quickfix: - text: Replace equality operator with safe equals() -single.statement.in.block.name: - text: Code block contains single statement -single.statement.in.block.descriptor: - text: '''''{0}'''' contains single statement' -single.statement.in.block.quickfix: - text: Remove braces from ''{0}'' statement -single.statement.in.block.family.quickfix: - text: Remove braces from statement -single.element.annotation.name: - text: Single-element annotation -single.element.annotation.quickfix: - text: Add 'value=' -single.element.annotation.family.quickfix: - text: Expand annotation to normal form -array.creation.without.new.keyword.name: - text: Array creation without 'new' expression -array.creation.without.new.keyword.quickfix: - text: Add ''new {0}'' -array.creation.without.new.keyword.family.quickfix: - text: Add 'new' expression -malformed.set.up.tear.down.display.name: - text: Malformed 'setUp()' or 'tearDown()' method -malformed.set.up.tear.down.problem.descriptor: - text: '''#ref()'' has incorrect signature #loc' -method.missing.return.statement.display.name: - text: Method contains logic but is missing a 'return' statement -method.missing.return.statement.problem.descriptor: - text: Method #ref contains logic but is missing a 'return' statement -overly.long.lambda.display.name: - text: Overly long lambda expression -overly.long.lambda.problem.descriptor: - text: 'Lambda expression is too long (# Non-comment source statements = {0}) #loc' + text: Convert to 'enum' +utility.class.display.name: + text: Utility class +utility.class.problem.descriptor: + text: 'Class #ref has only ''static'' members, indicating procedural construction #loc' +utility.class.with.public.constructor.display.name: + text: Utility class with 'public' constructor +utility.class.with.public.constructor.make.quickfix: + text: Make {0, choice, 1#constructor|2#constructors} 'private' +utility.class.with.public.constructor.problem.descriptor: + text: 'Class #ref has only ''static'' members, and a ''public'' constructor #loc' +utility.class.without.private.constructor.create.quickfix: + text: Generate empty 'private' constructor +utility.class.without.private.constructor.display.name: + text: Utility class without 'private' constructor +utility.class.without.private.constructor.make.quickfix: + text: Make constructor 'private' +utility.class.without.private.constructor.option: + text: Ignore classes with only a main method +utility.class.without.private.constructor.problem.descriptor: + text: 'Class #ref has only ''static'' members, and lacks a ''private'' constructor #loc' +value.of.post.decrement.problem.descriptor: + text: 'Value of post-decrement expression #ref is used #loc' +value.of.post.increment.problem.descriptor: + text: 'Value of post-increment expression #ref is used #loc' +value.of.pre.decrement.problem.descriptor: + text: 'Value of pre-decrement expression #ref is used #loc' +value.of.pre.increment.problem.descriptor: + text: 'Value of pre-increment expression #ref is used #loc' +variable.argument.method.display.name: + text: Varargs method +variable.argument.method.problem.descriptor: + text: 'Varargs method #ref() #loc' +variable.argument.method.quickfix: + text: Convert varargs parameter to array +variable.not.used.inside.conditional.problem.descriptor: + text: '#ref checked for ''null'' is not used inside conditional #loc' +variable.not.used.inside.if.display.name: + text: Reference checked for 'null' is not used inside 'if' +variable.not.used.inside.if.problem.descriptor: + text: '#ref checked for ''null'' is not used inside ''if'' #loc' +volatile.array.field.display.name: + text: Volatile array field +volatile.field.problem.descriptor: + text: 'Volatile field #ref of type ''''{0}'''' #loc' +volatile.long.or.double.field.display.name: + text: Volatile long or double field +wait.called.on.condition.display.name: + text: '''wait()'' called on ''java.util.concurrent.locks.Condition'' object' +wait.called.on.condition.problem.descriptor: + text: 'Call to #ref() on Condition object #loc' +wait.not.in.loop.display.name: + text: '''wait()'' not called in loop' +wait.not.in.loop.problem.descriptor: + text: 'Call to #ref() is not in loop #loc' wait.notify.not.in.synchronized.context.display.name: - text: '''wait()'' or ''notify()'' while not synchronized' + text: '''wait()'' or ''notify()'' is not in synchronized context' wait.notify.while.not.synchronized.on.problem.descriptor: - text: 'Call to #ref while not synchronized on ''''{0}'''' #loc' -junit5.assertions.converter.display.name: - text: Obsolete assertions in JUnit 5 tests -junit5.converter.display.name: - text: JUnit 4 test can be JUnit 5 -junit5.converter.fix.name: - text: Migrate to JUnit 5 -call.to.suspicious.string.method.display.name: - text: Call to suspicious String method -call.to.suspicious.string.method.problem.descriptor: - text: 'String.#ref() called in internationalized context #loc' -string.concatenation.replace.fix: - text: Replace with StringBuilder -string.concatenation.replace.fix.name: - text: Convert variable ''{0}'' from String to {1} -string.concatenation.introduce.fix: - text: Introduce StringBuilder -string.concatenation.introduce.fix.name: - text: Introduce new {1} to update variable ''{0}'' -ignored.class.names: - text: Ignore classes (including subclasses) -junit5.platform.runner.display.name: - text: '@RunWith(JUnitPlatform.class) without test methods' -junit5.valid.parameterized.configuration.display.name: - text: JUnit 5 malformed parameterized test -junit5.malformed.repeated.test.display.name: - text: JUnit 5 malformed repeated test -meta.annotation.without.runtime.retention: - text: Non-runtime annotation to be used by reflection -clone.doesnt.call.super.clone.display.name: - text: "'clone()' does not call 'super.clone()'" -clone.doesnt.call.super.clone.problem.descriptor: - text: "#ref() does not call 'super.clone()' #loc" \ No newline at end of file + text: 'Call to #ref while not synchronized on ''''{0}'''' #loc' +wait.or.await.without.timeout.display.name: + text: '''wait()'' or ''await()'' without timeout' +wait.or.await.without.timeout.problem.descriptor: + text: '#ref without timeout #loc' +wait.while.holding.two.locks.display.name: + text: '''wait()'' while holding two locks' +wait.while.holding.two.locks.problem.descriptor: + text: 'Call to #ref() is made while holding two locks #loc' +wait.without.corresponding.notify.display.name: + text: '''wait()'' without corresponding ''notify()''' +wait.without.corresponding.notify.problem.descriptor: + text: 'Call to #ref() without corresponding notify() or notifyAll() #loc' +warn.level.and.lower.option: + text: warn level and lower +warn.on.label: + text: 'Warn on:' +while.can.be.foreach.display.name: + text: '''while'' loop can be replaced with enhanced ''for'' loop' +while.can.be.foreach.problem.descriptor: + text: '#ref loop can be replaced with enhanced ''for'' #loc' +while.loop.spins.on.field.display.name: + text: '''while'' loop spins on field' +while.loop.spins.on.field.fix.family.name: + text: Fix spin loop +while.loop.spins.on.field.fix.spinwait: + text: Add Thread.onSpinWait() +while.loop.spins.on.field.fix.volatile: + text: Make ''{0}'' volatile +while.loop.spins.on.field.fix.volatile.spinwait: + text: Make ''{0}'' volatile and add Thread.onSpinWait() +while.loop.spins.on.field.ignore.non.empty.loops.option: + text: Only warn if the loop is empty +while.loop.spins.on.field.problem.descriptor: + text: '#ref loop spins on field #loc'