plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/InspectionGadgetsBundle.properties

   1 cast.to.concrete.class.display.name=Cast to a concrete class
   2 cast.to.concrete.class.problem.descriptor=Cast to concrete class <code>{0}</code> #loc
   3 class.references.subclass.display.name=Class references one of its subclasses
   4 class.references.subclass.problem.descriptor=Class ''{0}'' references subclass <code>#ref</code> #loc
   5 class.references.subclass.problem.descriptor.anonymous=Anonymous class references subclass <code>#ref</code> #loc
   6 collection.declared.by.class.display.name=Collection declared by class, not interface
   7 collection.declared.by.class.problem.descriptor=Declaration of <code>#ref</code> should probably be weakened to ''{0}'' #loc
   8 collection.declared.by.class.ignore.locals.option=Ignore local variables
   9 collection.declared.by.class.ignore.private.members.option=Ignore 'private' fields and methods
  10 feature.envy.display.name=Feature envy
  11 feature.envy.problem.descriptor=Class ''{0}'' accessed repeatedly in method <code>#ref()</code> #loc
  12 instance.variable.of.concrete.class.display.name=Type of instance field is concrete class
  13 instance.variable.of.concrete.class.problem.descriptor=Type of field ''{0}'' is concrete class <code>#ref</code> #loc
  14 chain.of.instanceof.checks.display.name=Chain of 'instanceof' checks
  15 chain.of.instanceof.checks.problem.descriptor=Chain of 'instanceof' checks indicates abstraction failure #loc
  16 chain.of.class.equality.checks.problem.descriptor=Chain of class equality checks indicates abstraction failure #loc
  17 instanceof.concrete.class.display.name='instanceof' a concrete class
  18 instanceof.concrete.class.problem.descriptor='instanceof' concrete class <code>#ref</code> #loc
  19 instanceof.check.for.this.display.name='instanceof' check for 'this'
  20 instanceof.check.for.this.problem.descriptor='instanceof' check for <code>#ref</code> #loc
  21 local.variable.of.concrete.class.display.name=Local variable of concrete class
  22 local.variable.of.concrete.class.problem.descriptor=Local variable ''{0}'' of concrete class <code>#ref</code> #loc
  23 magic.number.display.name=Magic number
  24 magic.number.problem.descriptor=Magic number <code>#ref</code> #loc
  25 magic.number.ignore.option=Ignore constants in 'hashCode()' methods
  26 method.return.concrete.class.display.name=Method return of concrete class
  27 method.return.concrete.class.problem.descriptor=Method returns a concrete class <code>#ref</code> #loc
  28 overly.strong.type.cast.display.name=Overly strong type cast
  29 overly.strong.type.cast.weaken.quickfix=Weaken overly strong cast
  30 concrete.class.method.parameter.display.name=Method parameter of concrete class
  31 concrete.class.method.parameter.problem.descriptor=Parameter ''{0}'' of concrete class <code>#ref</code> #loc
  32 public.method.not.in.interface.display.name='public' method not exposed in interface
  33 public.method.not.in.interface.problem.descriptor='public' method <code>#ref()</code> is not exposed via an interface #loc
  34 public.method.not.in.interface.option=<html>Ignore if the containing class does not implement a non-library interface</html>
  35 static.variable.of.concrete.class.display.name=Static field of concrete class
  36 static.variable.of.concrete.class.problem.descriptor=Static field ''{0}'' of concrete class <code>#ref</code> #loc
  37 incompatible.mask.operation.display.name=Incompatible bitwise mask operation
  38 incompatible.mask.operation.problem.descriptor.always.false=<code>#ref</code> is always false #loc
  39 incompatible.mask.operation.problem.descriptor.always.true=<code>#ref</code> is always true #loc
  40 pointless.bitwise.expression.display.name=Pointless bitwise expression
  41 pointless.bitwise.expression.simplify.quickfix=Simplify
  42 shift.operation.by.inappropriate.constant.display.name=Shift operation by inappropriate constant
  43 shift.operation.by.inappropriate.constant.problem.descriptor.too.large=Shift operation <code>#ref</code> by overly large constant value #loc
  44 shift.operation.by.inappropriate.constant.problem.descriptor.negative=Shift operation <code>#ref</code> by negative constant value #loc
  45 equals.called.on.array.display.name='equals()' called on array
  46 equals.called.on.array.problem.descriptor=<code>#ref()</code> between arrays should probably be 'Arrays.equals()' #loc
  47 replace.with.arrays.equals=Replace with 'Arrays.equals()'
  48 replace.with.arrays.deep.equals=Replace with 'Arrays.deepEquals()'
  49 assignment.to.null.display.name=Assignment to 'null'
  50 assignment.to.null.problem.descriptor=Assignment of variable <code>#ref</code> to 'null' #loc
  51 assignment.to.null.option=Ignore assignments to fields
  52 assignment.to.static.field.from.instance.method.display.name=Assignment to static field from instance context
  53 assignment.to.static.field.from.instance.method.problem.descriptor=Assignment to static field <code>#ref</code> from instance context #loc
  54 assignment.used.as.condition.display.name=Assignment used as condition
  55 assignment.used.as.condition.problem.descriptor=<code>#ref</code> used as condition #loc
  56 assignment.used.as.condition.replace.quickfix=Replace '=' with '=='
  57 cast.conflicts.with.instanceof.display.name=Cast conflicts with 'instanceof'
  58 cast.conflicts.with.instanceof.problem.descriptor=Cast <code>#ref</code> conflicts with surrounding 'instanceof' check #loc
  59 casting.to.incompatible.interface.display.name=Casting to incompatible interface
  60 casting.to.incompatible.interface.problem.descriptor=Cast to incompatible interface <code>#ref</code> #loc
  61 collection.added.to.self.display.name=Collection added to self
  62 collection.added.to.self.problem.descriptor=''{0}()'' called on collection <code>#ref</code> with itself as argument #loc
  63 non.final.field.compareto.display.name=Non-final field referenced in 'compareTo()'
  64 non.final.field.compareto.problem.descriptor=Non-final field <code>#ref</code> accessed in 'compareTo()' #loc
  65 covariant.equals.display.name=Covariant 'equals()'
  66 covariant.equals.problem.descriptor=<code>#ref()</code> should take 'Object' as its argument #loc
  67 empty.class.initializer.display.name=Empty class initializer
  68 empty.class.initializer.problem.descriptor=Empty class initializer #loc
  69 empty.class.initializer.delete.quickfix=Delete empty class initializer
  70 statement.with.empty.body.display.name=Statement with empty body
  71 statement.with.empty.body.problem.descriptor=<code>#ref</code> statement has empty body #loc
  72 statement.with.empty.body.include.option=Include statement bodies that are empty code blocks
  73 equals.between.inconvertible.types.display.name='equals()' between objects of inconvertible types
  74 equals.between.inconvertible.types.problem.descriptor=<code>#ref()</code> between objects of inconvertible types ''{0}'' and ''{1}'' #loc
  75 non.final.field.in.equals.display.name=Non-final field referenced in 'equals()'
  76 non.final.field.in.equals.problem.descriptor=Non-final field <code>#ref</code> accessed in 'equals()'  #loc
  77 equals.doesnt.check.class.parameter.display.name='equals()' method which does not check class of parameter
  78 equals.doesnt.check.class.parameter.problem.descriptor=<code>#ref()</code> should check the class of its parameter #loc
  79 for.loop.not.use.loop.variable.display.name='for' loop where update or condition does not use loop variable
  80 for.loop.not.use.loop.variable.problem.descriptor.condition=<code>#ref</code> statement has condition which does not use the for loop variable #loc
  81 for.loop.not.use.loop.variable.problem.descriptor.update=<code>#ref</code> statement has update which does not use the for loop variable #loc
  82 for.loop.not.use.loop.variable.problem.descriptor.both.condition.and.update=<code>#ref</code> statement has condition and update which do not use the for loop variable #loc
  83 non.final.field.in.hashcode.display.name=Non-final field referenced in 'hashCode()'
  84 non.final.field.in.hashcode.problem.descriptor=Non-final field <code>#ref</code> accessed in 'hashCode()' #loc
  85 result.of.method.call.ignored.display.name=Result of method call ignored
  86 result.of.method.call.ignored.problem.descriptor=Result of <code>{0}.#ref()</code> is ignored #loc
  87 result.of.method.call.ignored.class.column.title=Class name
  88 result.of.method.call.ignored.method.column.title=Method name regex
  89 result.of.method.call.ignored.non.library.option=Report all ignored non-library calls
  90 infinite.recursion.display.name=Infinite recursion
  91 infinite.recursion.problem.descriptor=Method <code>#ref()</code> recurses infinitely, and can only end by throwing an exception #loc
  92 instanceof.with.incompatible.interface.display.name='instanceof' with incompatible interface
  93 instanceof.with.incompatible.interface.problem.descriptor='instanceof' incompatible interface <code>#ref</code> #loc
  94 instantiation.utility.class.display.name=Instantiation of utility class
  95 instantiation.utility.class.problem.descriptor=Instantiation of utility class <code>#ref</code> #loc
  96 iterator.hasnext.which.calls.next.display.name='Iterator.hasNext()' which calls 'next()'
  97 iterator.hasnext.which.calls.next.problem.descriptor=<code>Iterator.#ref()</code> contains call to 'next()' #loc
  98 iterator.next.does.not.throw.nosuchelementexception.display.name='Iterator.next()' which can't throw 'NoSuchElementException'
  99 malformed.format.string.display.name=Malformed format string
 100 malformed.format.string.problem.descriptor.malformed=Format string <code>#ref</code> is malformed #loc
 101 malformed.format.string.problem.descriptor.illegal=Illegal format string specifier: {0} #loc
 102 malformed.format.string.problem.descriptor.too.many.arguments=Too many arguments for format string (found: {0}, expected: {1}) #loc
 103 malformed.format.string.problem.descriptor.too.few.arguments=Too few arguments for format string (found: {0}, expected: {1}) #loc
 104 malformed.format.string.problem.descriptor.arguments.do.not.match.type=Argument type ''{0}'' does not match the type of the format specifier ''{1}'' #loc
 105 malformed.regular.expression.display.name=Malformed regular expression
 106 malformed.regular.expression.problem.descriptor1=Regular expression <code>#ref</code> is malformed #loc
 107 malformed.regular.expression.problem.descriptor2=Regular expression <code>#ref</code> is malformed: {0} #loc
 108 malformed.xpath.expression.display.name=Malformed XPath expression
 109 malformed.xpath.expression.problem.description=XPath expression <code>#ref</code> is malformed #loc
 110 mismatched.read.write.array.display.name=Mismatched read and write of array
 111 mismatched.read.write.array.problem.descriptor.write.not.read=Contents of array <code>#ref</code> are written to, but never read #loc
 112 mismatched.read.write.array.problem.descriptor.read.not.write=Contents of array <code>#ref</code> are read, but never written to #loc
 113 mismatched.update.collection.display.name=Mismatched query and update of collection
 114 mismatched.update.collection.problem.descriptor.updated.not.queried=Contents of collection <code>#ref</code> are updated, but never queried #loc
 115 mismatched.update.collection.problem.description.queried.not.updated=Contents of collection <code>#ref</code> are queried, but never updated #loc
 116 rename.quickfix=Rename
 117 renameto.quickfix=Rename to ''{0}''
 118 misspelled.equals.display.name='equal()' instead of 'equals()'
 119 misspelled.equals.problem.descriptor=<code>#ref()</code> method should probably be 'equals()' #loc
 120 non.short.circuit.boolean.expression.display.name=Non-short-circuit boolean expression
 121 non.short.circuit.boolean.expression.problem.descriptor=Non-short-circuit boolean expression <code>#ref</code> #loc
 122 non.short.circuit.boolean.expression.replace.quickfix=Replace with short circuit expression
 123 null.argument.to.var.arg.method.display.name=Confusing argument to varargs method
 124 null.argument.to.var.arg.method.problem.descriptor=Confusing argument <code>#ref</code>, unclear if a varargs or non-varargs call is desired #loc
 125 primitive.array.argument.to.var.arg.method.display.name=Confusing primitive array argument to varargs method
 126 primitive.array.argument.to.var.arg.method.problem.descriptor=Confusing primitive array argument to varargs method #loc
 127 object.comparison.display.name=Object comparison using '==', instead of 'equals()'
 128 object.comparison.enumerated.ignore.option=Ignore '==' between enumerated types
 129 object.comparison.klass.ignore.option=Ignore '==' on 'java.lang.Class' objects
 130 object.comparison.problem.description=Object values are compared using <code>#ref</code>, not 'equals()' #loc
 131 object.comparison.replace.quickfix=Replace with 'equals()'
 132 object.equals.null.problem.descriptor=<code>.equals(#ref)</code> is probably not what was intended #loc
 133 default.tostring.call.display.name=Call to default 'toString()'
 134 default.tostring.call.problem.descriptor=Call to default 'toString()' on <code>#ref</code> #loc
 135 octal.and.decimal.integers.in.same.array.display.name=Octal and decimal integers in same array
 136 octal.and.decimal.integers.in.same.array.problem.descriptor=Octal and decimal integers in the same array initializer #loc
 137 result.of.object.allocation.ignored.display.name=Result of object allocation ignored
 138 result.of.object.allocation.ignored.problem.descriptor=Result of <code>new #ref()</code> is ignored #loc
 139 use.0index.in.jdbc.resultset.display.name=Use of index 0 in JDBC ResultSet
 140 use.0index.in.jdbc.resultset.problem.descriptor=Use of index '0' in JDBC ResultSet #loc
 141 use.0index.in.jdbc.prepared.statement.problem.descriptor=Use of index '0' in JDBC PreparedStatement #loc
 142 return.of.null.display.name=Return of 'null'
 143 return.of.null.problem.descriptor=Return of <code>#ref</code> #loc
 144 return.of.null.arrays.option=Report methods that return arrays
 145 return.of.null.quickfix=Annotate method as @Nullable
 146 return.of.null.objects.option=Report methods that return objects
 147 return.of.null.collections.option=Report methods that return collection objects
 148 return.of.null.ignore.private.option=Ignore 'private' methods
 149 return.of.null.optional.quickfix=Replace with ''{0}.{1}()''
 150 return.of.null.optional.quickfix.family=Replace with 'Optional.empty()'
 151 static.method.via.subclass.display.name=Static method referenced via subclass
 152 static.method.via.subclass.problem.descriptor=Static method <code>#ref()</code> declared in class ''{0}'' but referenced via subclass ''{1}'' #loc
 153 static.method.via.subclass.rationalize.quickfix=Rationalize static method call
 154 static.field.via.subclass.display.name=Static field referenced via subclass
 155 static.field.via.subclass.problem.descriptor=Static field <code>#ref</code> declared in class ''{0}'' but referenced via subclass ''{1}'' #loc
 156 static.field.via.subclass.rationalize.quickfix=Rationalize static field access
 157 string.comparison.display.name=String comparison using '==', instead of 'equals()'
 158 number.comparison.display.name=Number comparison using '==', instead of 'equals()'
 159 string.comparison.problem.descriptor=String values are compared using <code>#ref</code>, not 'equals()' #loc
 160 number.comparison.problem.descriptor=Number objects are compared using <code>#ref</code>, not 'equals()' #loc
 161 subtraction.in.compareto.display.name=Subtraction in 'compareTo()'
 162 subtraction.in.compareto.problem.descriptor=Subtraction <code>#ref</code> in 'compareTo()' may result in overflow errors #loc
 163 text.label.in.switch.statement.display.name=Text label in 'switch' statement
 164 text.label.in.switch.statement.problem.descriptor=Text label <code>#ref:</code> in 'switch' statement #loc
 165 properties.object.as.hashtable.display.name=Use of Properties object as a Hashtable
 166 properties.object.as.hashtable.problem.descriptor=Call to <code>Hashtable.#ref()</code> on properties object #loc
 167 assignment.replaceable.with.operator.assignment.display.name=Assignment replaceable with operator assignment
 168 unnecessary.code.block.display.name=Unnecessary code block
 169 unnecessary.code.block.unwrap.quickfix=Unwrap block
 170 redundant.local.variable.display.name=Redundant local variable
 171 redundant.local.variable.ignore.option=Ignore immediately returned or thrown variables
 172 redundant.local.variable.annotation.option=Ignore variables which have an annotation
 173 static.collection.display.name=Static collection
 174 static.collection.problem.descriptor=Static collection <code>#ref</code> #loc
 175 static.collection.ignore.option=Ignore weak static collections or maps
 176 stringbuffer.field.display.name=StringBuffer field
 177 stringbuffer.field.problem.descriptor=''{0}'' field <code>#ref</code> #loc
 178 gc.call.display.name=Calls to 'System.gc()' or 'Runtime.gc()'
 179 gc.call.problem.descriptor=<code>#ref</code> should not be called in production code #loc
 180 array.allocation.zero.length.display.name=Zero-length array allocation
 181 array.allocation.zero.length.problem.descriptor=Allocation of zero length array #loc
 182 constant.for.zero.length.array.display.name=Unnecessary zero length array usage
 183 constant.for.zero.length.array.problem.descriptor=Zero length array can be changed to constant #loc
 184 constant.for.zero.length.array.quickfix.family=Replace with constant
 185 replace.with=Replace with ''{0}''
 186 multiple.loggers.display.name=Class with multiple loggers
 187 logger.name.option=Logger &class name:
 188 multiple.loggers.problem.descriptor=Class <code>#ref</code> declares multiple loggers #loc
 189 no.logger.display.name=Class without logger
 190 no.logger.problem.descriptor=Class <code>#ref</code> does not declare a logger #loc
 191 non.constant.logger.display.name=Non-constant logger
 192 non.constant.logger.problem.descriptor=Non-constant logger field <code>#ref</code> #loc
 193 public.method.without.logging.display.name='public' method without logging
 194 public.method.without.logging.problem.descriptor='public' method <code>#ref()</code> has no logging call #loc
 195 ignore.trivial.finalizers.option=Ignore for trivial 'finalize()' implementations
 196 finalize.declaration.display.name='finalize()' declaration
 197 finalize.declaration.problem.descriptor=<code>#ref()</code> declared #loc
 198 finalize.not.declared.protected.display.name='finalize()' not declared 'protected'
 199 finalize.not.declared.protected.problem.descriptor=<code>#ref()</code> not declared 'protected' #loc
 200 make.protected.quickfix=Make 'protected'
 201 finalize.called.explicitly.display.name='finalize()' called explicitly
 202 finalize.called.explicitly.problem.descriptor=<code>#ref()</code> called explicitly #loc
 203 java.lang.import.display.name='java.lang' import
 204 java.lang.import.problem.descriptor=Unnecessary import from package 'java.lang' #loc
 205 import.display.name='*' import
 206 import.problem.descriptor=Package import <code>#ref</code> #loc
 207 redundant.import.display.name=Redundant import
 208 redundant.import.problem.descriptor=Redundant import <code>#ref</code> #loc
 209 import.from.same.package.display.name=Import from same package
 210 import.from.same.package.problem.descriptor=Unnecessary import from same package <code>#ref</code> #loc
 211 single.class.import.display.name=Single class import
 212 single.class.import.problem.descriptor=Single class import <code>#ref</code> #loc
 213 static.import.display.name=Static import
 214 static.import.problem.descriptor=Static import <code>#ref</code>  #loc
 215 static.import.replace.quickfix=Replace with non-static import
 216 unused.import.display.name=Unused import
 217 unused.import.problem.descriptor=Unused import <code>#ref</code> #loc
 218 clone.instantiates.objects.with.constructor.display.name='clone()' instantiates objects with constructor
 219 clone.instantiates.objects.with.constructor.problem.descriptor='clone()' creates new <code>#ref</code> instances #loc
 220 clone.doesnt.declare.clonenotsupportedexception.display.name='clone()' does not declare 'CloneNotSupportedException'
 221 clone.doesnt.declare.clonenotsupportedexception.problem.descriptor=<code>#ref()</code> #loc does not declare 'CloneNotSupportedException'
 222 clone.doesnt.declare.clonenotsupportedexception.declare.quickfix=Declare 'CloneNotSupportedException'
 223 clone.method.in.non.cloneable.class.display.name='clone()' method in non-Cloneable class
 224 clone.method.in.non.cloneable.class.problem.descriptor=<code>#ref()</code> defined in non-Cloneable class ''{0}'' #loc
 225 clone.method.in.non.cloneable.interface.problem.descriptor=<code>#ref()</code> defined in non-Cloneable interface ''{0}'' #loc
 226 cloneable.class.without.clone.display.name=Cloneable class without 'clone()'
 227 cloneable.class.without.clone.problem.descriptor=<code>#ref</code> does not define 'clone()' #loc
 228 cloneable.class.without.clone.ignore.option=Ignore classes cloneable due to inheritance
 229 cloneable.class.without.clone.quickfix=Generate 'clone()' method
 230 class.without.tostring.display.name=Class without 'toString()'
 231 class.without.tostring.problem.descriptor=Class <code>#ref</code> should probably implement 'toString()', for debugging purposes #loc
 232 use.obsolete.collection.type.display.name=Use of obsolete collection type
 233 use.obsolete.collection.type.problem.descriptor=Obsolete collection type <code>#ref</code> used #loc
 234 use.obsolete.collection.type.ignore.library.arguments.option=Ignore obsolete collection types where they are required
 235 inspection.suppression.annotation.display.name=Inspection suppression annotation
 236 inspection.suppression.annotation.problem.descriptor=Inspection suppression annotation <code>#ref</code> #loc
 237 use.system.out.err.display.name=Use of System.out or System.err
 238 use.system.out.err.problem.descriptor=Uses of <code>#ref</code> should probably be replaced with more robust logging #loc
 239 dumpstack.call.display.name=Call to 'Thread.dumpStack()'
 240 dumpstack.call.problem.descriptor=Call to <code>Thread.#ref()</code> should probably be replaced with more robust logging #loc
 241 printstacktrace.call.display.name=Call to 'printStackTrace()'
 242 printstacktrace.call.problem.descriptor=Call to <code>#ref()</code> should probably be replaced with more robust logging #loc
 243 abstract.method.call.in.constructor.display.name=Abstract method called during object construction
 244 abstract.method.call.in.constructor.problem.descriptor=Call to 'abstract' method <code>#ref()</code> during object construction #loc
 245 instance.variable.may.not.be.initialized.display.name=Instance field may not be initialized
 246 instance.variable.may.not.be.initialized.problem.descriptor=Instance field <code>#ref</code> may not be initialized during object construction #loc
 247 instance.Variable.may.not.be.initialized.problem.descriptor.junit=Instance field <code>#ref</code> may not be initialized during object construction or 'setUp()' call #loc
 248 primitive.fields.ignore.option=Ignore primitive fields
 249 instance.variable.used.before.initialized.display.name=Instance field used before initialization
 250 instance.variable.used.before.initialized.problem.descriptor=Instance field <code>#ref</code> used before initialized #loc
 251 non.final.static.variable.initialization.display.name=Non-final static field is used during class initialization
 252 non.final.static.variable.initialization.problem.descriptor=Non-final static field <code>#ref</code> used during class initialization #loc
 253 overridable.method.call.in.constructor.display.name=Overridable method called during object construction
 254 overridable.method.call.in.constructor.problem.descriptor=Call to overridable method <code>#ref()</code> during object construction #loc
 255 overridden.method.call.in.constructor.display.name=Overridden method called during object construction
 256 overridden.method.call.in.constructor.problem.descriptor=Call to overridden method <code>#ref()</code> during object construction #loc
 257 static.variable.may.not.be.initialized.display.name=Static field may not be initialized
 258 static.variable.may.not.be.initialized.problem.descriptor=Static field <code>#ref</code> may not be initialized during class initialization #loc
 259 static.variable.used.before.initialization.display.name=Static field used before initialization
 260 static.variable.used.before.initialization.problem.descriptor=Static field <code>#ref</code> used before initialization #loc
 261 this.reference.escaped.in.construction.display.name='this' reference escaped in object construction
 262 this.reference.escaped.in.construction.problem.descriptor=Escape of <code>#ref</code> during object construction #loc
 263 assignment.to.catch.block.parameter.display.name=Assignment to catch block parameter
 264 extract.parameter.as.local.variable.quickfix=Extract parameter as local variable
 265 assignment.to.for.loop.parameter.display.name=Assignment to 'for' loop parameter
 266 assignment.to.for.loop.parameter.check.foreach.option=Check foreach parameters
 267 assignment.to.for.loop.parameter.problem.descriptor=Assignment to for-loop parameter <code>#ref</code> #loc
 268 assignment.to.method.parameter.display.name=Assignment to method parameter
 269 chained.equality.comparisons.display.name=Chained equality comparisons
 270 confusing.octal.escape.sequence.display.name=Confusing octal escape sequence
 271 increment.decrement.display.name=Value of ++ or -- used
 272 nested.assignment.display.name=Result of assignment used
 273 nested.assignment.problem.descriptor=Result of assignment expression used #loc
 274 overloaded.methods.with.same.number.parameters.display.name=Overloaded methods with same number of parameters
 275 overloaded.vararg.method.display.name=Overloaded variable argument method
 276 refused.bequest.display.name=Method does not call super method
 277 reuse.of.local.variable.display.name=Reuse of local variable
 278 reuse.of.local.variable.split.quickfix=Split local variable
 279 character.comparison.display.name=Character comparison
 280 character.comparison.problem.descriptor=Character comparison <code>#ref</code> in an internationalized context #loc
 281 assignment.collection.array.field.from.parameter.display.name=Assignment to Collection or array field from parameter
 282 assignment.collection.array.field.from.parameter.problem.descriptor.array=Assignment to array field <code>#ref</code> from parameter ''{0}'' #loc
 283 assignment.collection.array.field.from.parameter.problem.descriptor.collection=Assignment to Collection field <code>#ref</code> from parameter ''{0}'' #loc
 284 assignment.collection.array.field.option=Ignore assignments in 'private' methods
 285 assignment.to.date.calendar.field.from.parameter.display.name=Assignment to Date or Calendar field from parameter
 286 assignment.to.date.calendar.field.from.parameter.problem.descriptor=Assignment to ''{0}'' field <code>#ref</code> from parameter {1} #loc
 287 package.visible.field.display.name=Package-visible field
 288 package.visible.field.problem.descriptor=Package-visible field <code>#ref</code> #loc
 289 package.visible.inner.class.display.name=Package-visible inner class
 290 package.visible.inner.class.problem.descriptor=Package-visible inner class <code>#ref</code> #loc
 291 package.visible.inner.class.ignore.enum.option=Ignore package-visible inner enums
 292 package.visible.inner.class.ignore.interface.option=Ignore package-visible inner interfaces
 293 protected.field.display.name=Protected field
 294 protected.field.problem.descriptor=Protected field <code>#ref</code> #loc
 295 protected.inner.class.display.name=Protected inner class
 296 protected.inner.class.problem.descriptor=Protected inner class <code>#ref</code> #loc
 297 protected.inner.class.ignore.enum.option=Ignore 'protected' inner enums
 298 protected.inner.class.ignore.interface.option=Ignore 'protected' inner interfaces
 299 public.field.display.name='public' field
 300 public.field.problem.descriptor='public' field <code>#ref</code> #loc
 301 public.field.ignore.enum.type.fields.option=Ignore 'public final' fields of an enum type
 302 public.inner.class.display.name='public' inner class
 303 public.inner.class.problem.descriptor='public' inner class <code>#ref</code> #loc
 304 public.inner.class.ignore.enum.option=Ignore 'public' inner enums
 305 public.inner.class.ignore.interface.option=Ignore 'public' inner interfaces
 306 return.of.collection.array.field.display.name=Return of Collection or array field
 307 return.of.collection.array.field.problem.descriptor.array='return' of array field <code>#ref</code> #loc
 308 return.of.collection.array.field.problem.descriptor.collection='return' of Collection field <code>#ref</code> #loc
 309 return.of.collection.array.field.option=Ignore 'private' methods returning an array or collection field
 310 return.date.calendar.field.display.name=Return of Date or Calendar field
 311 return.date.calendar.field.problem.descriptor=Return of ''{0}'' field <code>#ref</code> #loc
 312 return.date.calendar.field.quickfix=Return clone of ''{0}''
 313 accessing.non.public.field.of.another.object.display.name=Accessing a non-public field of another object
 314 accessing.non.public.field.of.another.object.problem.descriptor=Direct access of non-public field <code>#ref</code> on another object #loc
 315 call.to.date.tostring.display.name=Call to 'Date.toString()'
 316 call.to.date.tostring.problem.descriptor=<code>Date.#ref()</code> used in an internationalized context #loc
 317 magic.character.display.name=Magic character
 318 magic.character.problem.descriptor=Magic character <code>#ref</code> in an internationalized context #loc
 319 call.to.numeric.tostring.display.name=Call to Numeric 'toString()'
 320 call.to.numeric.tostring.problem.descriptor=Numeric <code>#ref()</code> called in an internationalized context #loc
 321 instantiating.simpledateformat.without.locale.display.name=Instantiating a SimpleDateFormat without a Locale
 322 instantiating.simpledateformat.without.locale.problem.descriptor=Instantiating a <code>#ref</code> without specifying a Locale in an internationalized context #loc
 323 string.compareto.call.display.name=Call to 'String.compareTo()'
 324 string.compareto.call.problem.descriptor=<code>String.#ref()</code> called using internationalized strings #loc
 325 string.concatenation.display.name=String concatenation
 326 string.concatenation.problem.descriptor=String concatenation <code>#ref</code> in an internationalized context #loc
 327 string.concatenation.ignore.system.out.option=Ignore for 'System.out.print' arguments
 328 string.concatenation.ignore.system.err.option=Ignore for 'System.err.print' arguments
 329 string.concatenation.ignore.assert.option=Ignore for assert statement arguments
 330 string.concatenation.ignore.exceptions.option=Ignore for throwable arguments
 331 string.concatenation.ignore.constant.initializers.option=Ignore for initializers of constants
 332 ignore.in.annotations=Ignore in annotations
 333 ignore.in.tostring=Ignore inside toString() methods
 334 ignore.as.initial.capacity=Ignore initial capacity for StringBuilders and Collections
 335 string.equalsignorecase.call.display.name=Call to 'String.equalsIgnoreCase()'
 336 string.equalsignorecase.call.problem.descriptor=<code>String.#ref()</code> using internationalized strings #loc
 337 string.equals.call.display.name=Call to 'String.equals()'
 338 string.equals.call.problem.descriptor=<code>String.#ref()</code> using internationalized strings #loc
 339 string.touppercase.tolowercase.without.locale.display.name=Call to 'String.toUpperCase()' or 'toLowerCase()' without a Locale
 340 string.touppercase.tolowercase.without.locale.problem.descriptor=<code>String.#ref()</code> called without specifying a Locale using internationalized strings #loc
 341 use.stringtokenizer.display.name=Use of StringTokenizer
 342 use.stringtokenizer.problem.descriptor=<code>#ref</code> in an internationalized context #loc
 343 time.tostring.call.display.name=Call to 'Time.toString()'
 344 time.tostring.call.problem.descriptor=<code>Time.#ref()</code> in an internationalized context #loc
 345 class.escapes.defined.scope.display.name=Class escapes defined scope
 346 class.escapes.defined.scope.problem.descriptor=Class <code>#ref</code> is made visible outside its defined scope #loc
 347 field.name.hides.in.superclass.display.name=Field name hides field in superclass
 348 field.name.hides.in.superclass.problem.descriptor=Field <code>#ref</code> hides field in superclass #loc
 349 field.name.hides.in.superclass.ignore.option=Ignore superclass fields not visible from subclass
 350 inner.class.field.hides.outer.display.name=Inner class field hides outer class field
 351 inner.class.field.hides.outer.ignore.option=Ignore outer fields not visible from inner class
 352 inner.class.field.hides.outer.problem.descriptor=Inner class field <code>#ref</code> hides outer class field #loc
 353 local.variable.hides.member.variable.display.name=Local variable hides field
 354 local.variable.hides.member.variable.problem.descriptor=Local variable <code>#ref</code> hides field in class ''{0}'' #loc
 355 local.variable.hides.member.variable.ignore.option=Ignore local variables in a static context
 356 method.overloads.display.name=Method overloads method of superclass
 357 method.overloads.problem.descriptor=Method <code>#ref()</code> overloads a compatible method of a superclass, when overriding might have been intended #loc
 358 method.overloads.report.incompatible.option=Report even if parameter types are not compatible
 359 method.overrides.private.display.name=Method overrides 'private' method of superclass
 360 method.overrides.private.display.name.problem.descriptor=Method <code>#ref()</code> overrides a 'private' method of a superclass #loc
 361 method.overrides.static.display.name=Method overrides static method of superclass
 362 method.overrides.static.problem.descriptor=Method <code>#ref()</code> overrides a static method of a superclass #loc
 363 parameter.hides.member.variable.display.name=Parameter hides field
 364 parameter.hides.member.variable.problem.descriptor=Parameter <code>#ref</code> hides field in class ''{0}'' #loc
 365 parameter.hides.member.variable.ignore.setters.option=Ignore for property setters
 366 parameter.hides.member.variable.ignore.superclass.option=Ignore superclass fields not visible from subclass
 367 parameter.hides.member.variable.ignore.constructors.option=Ignore for constructors
 368 parameter.hides.member.variable.ignore.abstract.methods.option=Ignore for abstract methods
 369 parameter.hides.member.variable.ignore.static.parameters.option=Ignore for static method parameters hiding instance fields
 370 type.parameter.hides.visible.type.display.name=Type parameter hides visible type
 371 type.parameter.hides.visible.type.problem.descriptor=Type parameter <code>#ref</code> hides visible type ''{0}'' #loc
 372 type.parameter.hides.type.parameter.problem.descriptor=Type parameter <code>#ref</code> hides type parameter ''{0}'' #loc
 373 anonymous.class.variable.hides.containing.method.variable.display.name=Anonymous class variable hides variable in containing method
 374 anonymous.class.parameter.hides.containing.method.variable.problem.descriptor=Anonymous class parameter <code>#ref</code> hides variable in containing method #loc
 375 anonymous.class.field.hides.containing.method.variable.problem.descriptor=Anonymous class field <code>#ref</code> hides variable in containing method #loc
 376 anonymous.class.variable.hides.containing.method.variable.problem.descriptor=Anonymous class local variable <code>#ref</code> hides variable in containing method #loc
 377 channel.opened.not.closed.display.name=Channel opened but not safely closed
 378 drivermanager.call.display.name=Use of DriverManager to get JDBC connection
 379 drivermanager.call.problem.descriptor=Call to <code>DriverManager.#ref()</code> #loc
 380 hibernate.resource.opened.not.closed.display.name=Hibernate resource opened but not safely closed
 381 i.o.resource.opened.not.closed.display.name=I/O resource opened but not safely closed
 382 resource.opened.not.closed.problem.descriptor=''{0}'' should be opened in front of a ''try'' block and closed in the corresponding ''finally'' block #loc
 383 jdbc.resource.opened.not.closed.display.name=JDBC resource opened but not safely closed
 384 jndi.resource.opened.not.closed.display.name=JNDI resource opened but not safely closed
 385 socket.opened.not.closed.display.name=Socket opened but not safely closed
 386 annotation.class.display.name=Annotation class
 387 annotation.class.problem.descriptor=Annotation class <code>#ref</code> #loc
 388 annotation.display.name=Annotation
 389 annotation.problem.descriptor=Annotation <code>#ref</code> #loc
 390 use.assert.as.identifier.display.name=Use of 'assert' as identifier
 391 use.assert.as.identifier.problem.descriptor=Use of <code>#ref</code> as identifier #loc
 392 assert.statement.display.name='assert' statement
 393 statement.problem.descriptor=<code>#ref</code> statement #loc
 394 auto.boxing.display.name=Auto-boxing
 395 auto.boxing.problem.descriptor=Auto-boxing <code>#ref</code> #loc
 396 auto.boxing.make.boxing.explicit.quickfix=Make boxing explicit
 397 auto.boxing.ignore.added.to.collection.option=Ignore expressions added to a collection
 398 auto.unboxing.display.name=Auto-unboxing
 399 auto.unboxing.problem.descriptor=Auto-unboxing <code>#ref</code> #loc
 400 auto.unboxing.make.unboxing.explicit.quickfix=Make unboxing explicit
 401 use.enum.as.identifier.display.name=Use of 'enum' as identifier
 402 use.enum.as.identifier.problem.descriptor=Use of <code>#ref</code> as identifier #loc
 403 enumerated.class.display.name=Enumerated class
 404 enumerated.class.problem.descriptor=Enumerated class <code>#ref</code> #loc
 405 extended.for.statement.display.name=Extended 'for' statement
 406 extended.for.statement.replace.quickfix=Replace with old-style 'for' statement
 407 variable.argument.method.display.name=Variable argument method
 408 variable.argument.method.problem.descriptor=Variable argument method <code>#ref()</code> #loc
 409 variable.argument.method.quickfix=Convert variable argument parameter to array
 410 hardcoded.file.separator.display.name=Hardcoded file separator
 411 hardcoded.file.separator.problem.descriptor=Hardcoded file separator <code>#ref</code> #loc
 412 hardcoded.file.separator.include.option=Include "example/*" in recognized MIME media types
 413 hardcoded.line.separator.display.name=Hardcoded line separator
 414 hardcoded.line.separator.problem.descriptor=Hardcoded line separator <code>#ref</code> #loc
 415 native.method.display.name=Native method
 416 native.method.problem.descriptor=Methods declared <code>#ref</code> are non-portable #loc
 417 runtime.exec.call.display.name=Call to 'Runtime.exec()'
 418 runtime.exec.call.problem.descriptor=Call to <code>Runtime.#ref()</code> is non-portable #loc
 419 system.exit.call.display.name=Call to 'System.exit()' or related methods
 420 system.exit.call.problem.descriptor=Call to <code>{0}.#ref()</code> is non-portable #loc
 421 system.exit.call.ignore.option=Ignore in main method
 422 system.getenv.call.display.name=Call to 'System.getenv()'
 423 system.getenv.call.problem.descriptor=Call to <code>System.#ref()</code> is non-portable #loc
 424 use.of.awt.peer.class.display.name=Use of AWT peer class
 425 use.of.awt.peer.class.problem.descriptor=Use of AWT peer class <code>#ref</code> is non-portable #loc
 426 use.of.concrete.jdbc.driver.class.display.name=Use of concrete JDBC driver class
 427 use.of.concrete.jdbc.driver.class.problem.descriptor=Use of concrete JDBC driver class <code>#ref</code> is non-portable #loc
 428 use.processbuilder.class.display.name=Use of 'java.lang.ProcessBuilder' class
 429 use.processbuilder.class.problem.descriptor=Use of <code>#ref</code> is non-portable #loc
 430 use.sun.classes.display.name=Use of sun.* classes
 431 use.sun.classes.problem.descriptor=Use of Sun-supplied class <code>#ref</code> is non-portable #loc
 432 abstract.class.with.only.one.direct.inheritor.display.name=Abstract class which has only one direct inheritor
 433 anonymous.inner.may.be.named.static.inner.class.display.name=Anonymous class may be a named 'static' inner class
 434 anonymous.inner.may.be.named.static.inner.class.problem.descriptor=Anonymous class <code>#ref</code> may be a named 'static' inner class #loc
 435 array.length.in.loop.condition.display.name=Array.length in loop condition
 436 array.length.in.loop.condition.problem.descriptor=Check of array <code>#ref</code> in loop condition #loc
 437 large.array.allocation.no.outofmemoryerror.display.name=Large array allocation with no OutOfMemoryError check
 438 large.array.allocation.no.outofmemoryerror.problem.descriptor=Large array allocation which is not checked for out-of-memory condition #loc
 439 large.array.allocation.no.outofmemoryerror.maximum.number.of.elements.option=Maximum number of elements:
 440 connection.opened.not.safely.closed.display.name=Connection opened but not safely closed
 441 interface.one.inheritor.display.name=Interface which has only one direct inheritor
 442 interface.one.inheritor.problem.descriptor=Interface <code>#ref</code> has only one direct inheritor #loc
 443 method.call.in.loop.condition.display.name=Method call in loop condition
 444 method.call.in.loop.condition.problem.descriptor=Call to method <code>#ref()</code> in loop condition #loc
 445 large.initializer.primitive.type.array.display.name=Overly large initializer for array of primitive type
 446 large.initializer.primitive.type.array.problem.descriptor=Primitive array initializer with too many elements ({0}) #loc
 447 large.initializer.primitive.type.array.maximum.number.of.elements.option=Maximum number of elements:
 448 private.member.access.between.outer.and.inner.classes.display.name=Private member access between outer and inner classes
 449 private.member.access.between.outer.and.inner.classes.problem.descriptor=Access to 'private' member of class ''{0}'' #loc
 450 private.member.access.between.outer.and.inner.classes.make.local.quickfix=Make ''{0}'' package-private
 451 private.member.access.between.outer.and.inner.classes.make.constructor.package.local.quickfix=Make ''{0}'' constructor package-private
 452 recordstore.opened.not.safely.closed.display.name=RecordStore opened but not safely closed
 453 overly.complex.anonymous.inner.class.display.name=Overly complex anonymous class
 454 cyclomatic.complexity.limit.option=Cyclomatic complexity limit:
 455 overly.complex.anonymous.inner.class.problem.descriptor=Overly complex anonymous class (cyclomatic complexity = {0}) #loc
 456 anonymous.inner.class.with.too.many.methods.display.name=Anonymous inner class with too many methods
 457 method.count.limit.option=Method count limit:
 458 anonymous.inner.class.with.too.many.methods.problem.descriptor=Anonymous inner class with too many methods (method count = {0}) #loc
 459 overly.complex.class.display.name=Overly complex class
 460 overly.complex.class.problem.descriptor=Overly complex class <code>#ref</code> (cyclomatic complexity = {0}) #loc
 461 overly.coupled.class.display.name=Overly coupled class
 462 overly.coupled.class.class.coupling.limit.option=Class coupling limit:
 463 include.java.system.classes.option=Include couplings to java system classes
 464 include.library.classes.option=Include couplings to library classes
 465 overly.coupled.class.problem.descriptor=<code>#ref</code> is overly coupled (dependencies = {0}) #loc
 466 class.too.deep.display.name=Class too deep in inheritance tree
 467 class.too.deep.inheritance.depth.limit.option=Inheritance depth limit:
 468 class.too.deep.problem.descriptor=<code>#ref</code> is too deep in inheritance tree (inheritance depth = {0}) #loc
 469 inner.class.too.deeply.nested.display.name=Inner class too deeply nested
 470 inner.class.too.deeply.nested.nesting.limit.option=Nesting limit:
 471 inner.class.too.deeply.nested.problem.descriptor=<code>#ref</code> is too deeply nested (nesting level = {0}) #loc
 472 too.many.constructors.display.name=Class with too many constructors
 473 too.many.constructors.count.limit.option=Constructor count limit:
 474 too.many.constructors.ignore.deprecated.option=Ignore deprecated constructors
 475 too.many.constructors.problem.descriptor=<code>#ref</code> has too many constructors (constructor count = {0}) #loc
 476 too.many.fields.display.name=Class with too many fields
 477 too.many.fields.count.limit.option=Field count limit:
 478 too.many.fields.problem.descriptor=<code>#ref</code> has too many fields (field count = {0}) #loc
 479 too.many.methods.display.name=Class with too many methods
 480 too.many.methods.problem.descriptor=<code>#ref</code> has too many methods (method count = {0}) #loc
 481 externalizable.with.serialization.methods.display.name=Externalizable class with 'readObject()' or 'writeObject()'
 482 externalizable.with.serialization.methods.problem.descriptor.both=Externalizable class <code>#ref</code> defines 'readObject()' and 'writeObject()' #loc
 483 externalizable.with.serialization.methods.problem.descriptor.write=Externalizable class <code>#ref</code> defines 'writeObject()' #loc
 484 externalizable.with.serialization.methods.problem.descriptor.read=Externalizable class <code>#ref</code> defines 'readObject()' #loc
 485 non.serializable.with.serialversionuid.display.name=Non-serializable class with 'serialVersionUID'
 486 non.serializable.class.with.serialversionuid.problem.descriptor=Non-serializable class <code>#ref</code> defines a 'serialVersionUID' field #loc
 487 non.serializable.interface.with.serialversionuid.problem.descriptor=Non-serializable interface <code>#ref</code> defines a 'serialVersionUID' field #loc
 488 non.serializable.@interface.with.serialversionuid.problem.descriptor=Non-serializable @interface <code>#ref</code> defines a 'serialVersionUID' field #loc
 489 non.serializable.anonymous.with.serialversionuid.problem.descriptor=Non-serializable anonymous class extending <code>#ref</code> defines a 'serialVersionUID' field #loc
 490 non.serializable.with.serialversionuid.remove.quickfix=Remove 'serialVersionUID' field
 491 non.serializable.class.with.readwriteobject.display.name=Non-serializable class with 'readObject()' or 'writeObject()'
 492 non.serializable.class.with.readwriteobject.problem.descriptor.both=Non-serializable class <code>#ref</code> defines 'readObject()' and 'writeObject()' #loc
 493 non.serializable.class.with.readwriteobject.problem.descriptor.write=Non-serializable class <code>#ref</code> defines 'writeObject()' #loc
 494 non.serializable.class.with.readwriteobject.problem.descriptor.read=Non-serializable class <code>#ref</code> defines 'readObject()' #loc
 495 non.serializable.anonymous.with.readwriteobject.problem.descriptor.both=Non-serializable anonymous class extending <code>#ref</code> defines 'readObject()' and 'writeObject()' #loc
 496 non.serializable.anonymous.with.readwriteobject.problem.descriptor.write=Non-serializable anonymous class extending <code>#ref</code> defines 'writeObject()' #loc
 497 non.serializable.anonymous.with.readwriteobject.problem.descriptor.read=Non-serializable anonymous class extending <code>#ref</code> defines 'readObject()' #loc
 498 readwriteobject.private.display.name='readObject()' or 'writeObject()' not declared 'private'
 499 readwriteobject.private.problem.descriptor=<code>#ref</code> not declared 'private' #loc
 500 readobject.initialization.display.name=Instance field may not be initialized by 'readObject()'
 501 readobject.initialization.problem.descriptor=Instance field <code>#ref</code> may not be initialized during 'readObject()' call #loc
 502 readresolve.writereplace.protected.display.name='readResolve()' or 'writeReplace()' not declared 'protected'
 503 readresolve.writereplace.protected.problem.descriptor=<code>#ref()</code> not declared 'protected' #loc
 504 serialpersistentfields.with.wrong.signature.display.name='serialPersistentFields' field not declared 'private static final ObjectStreamField[]'
 505 serialpersistentfields.with.wrong.signature.problem.descriptor=<code>#ref</code> field of a Serializable class is not declared 'private static final ObjectStreamField[]' #loc
 506 serialversionuid.private.static.final.long.display.name='serialVersionUID' field not declared 'private static final long'
 507 serialversionuid.private.static.final.long.problem.descriptor=<code>#ref</code> field of a Serializable class is not declared 'private static final long' #loc
 508 serialversionuid.private.static.final.long.quickfix=Make serialVersionUID 'private static final'
 509 serializable.class.without.serialversionuid.display.name=Serializable class without 'serialVersionUID'
 510 serializable.class.without.serialversionuid.problem.descriptor=<code>#ref</code> does not define a 'serialVersionUID' field #loc
 511
 512 #dynamic
 513 non.protected.constructor.in.abstract.class.display.name='public' constructor in 'abstract' class
 514 unnecessary.qualifier.for.this.display.name=Unnecessary qualifier for 'this' or 'super'
 515 multiple.declaration.display.name=Multiple variables in one declaration
 516 thread.priority.display.name=Call to 'Thread.setPriority()'
 517 too.broad.scope.display.name=Scope of variable is too broad
 518 infinite.loop.statement.display.name=Infinite loop statement
 519 asserts.without.messages.display.name=Message missing on JUnit assertion
 520 constant.naming.convention.display.name=Constant naming convention
 521 constant.naming.convention.element.description=Constant
 522 random.double.for.random.integer.display.name=Using 'Random.nextDouble()' to get random integer
 523 test.method.without.assertion.display.name=JUnit test method without any assertions
 524 string.buffer.replaceable.by.string.builder.display.name='StringBuffer' may be 'StringBuilder'
 525 comparison.of.short.and.char.display.name=Comparison of 'short' and 'char' values
 526 unnecessary.fully.qualified.name.display.name=Unnecessary fully qualified name
 527 unnecessary.label.on.break.statement.display.name=Unnecessary label on 'break' statement
 528 exception.name.doesnt.end.with.exception.display.name=Exception class name does not end with 'Exception'
 529 bad.exception.declared.display.name=Prohibited exception declared
 530 deserializable.class.in.secure.context.display.name=Deserializable class in secure context
 531 pointless.boolean.expression.display.name=Pointless boolean expression
 532 class.without.constructor.display.name=Class without constructor
 533 break.statement.display.name='break' statement
 534 unconditional.wait.display.name=Unconditional 'wait()' call
 535 cyclomatic.complexity.display.name=Overly complex method
 536 string.to.string.display.name=Redundant 'String.toString()'
 537 constant.on.lhs.of.comparison.display.name=Constant on left side of comparison
 538 final.class.display.name='final' class
 539 labeled.statement.display.name=Labeled statement
 540 notify.called.on.condition.display.name='notify()'  or 'notifyAll()' called on 'java.util.concurrent.locks.Condition' object
 541 loop.statements.that.dont.loop.display.name=Loop statement that does not loop
 542 thread.run.display.name=Call to 'Thread.run()'
 543 non.synchronized.method.overrides.synchronized.method.display.name=Unsynchronized method overrides synchronized method
 544 constant.on.rhs.of.comparison.display.name=Constant on right side of comparison
 545 synchronize.on.this.display.name=Synchronization on 'this'
 546 switch.statement.with.too.many.branches.display.name='switch' statement with too many branches
 547 utility.class.without.private.constructor.display.name=Utility class without 'private' constructor
 548 throw.caught.locally.display.name='throw' caught by containing 'try' statement
 549 exception.from.catch.which.doesnt.wrap.display.name='throw' inside 'catch' block which ignores the caught exception
 550 type.parameter.naming.convention.display.name=Type parameter naming convention
 551 type.parameter.naming.convention.element.description=Type parameter
 552 multiply.or.divide.by.power.of.two.display.name=Multiply or divide by power of two
 553 multiply.or.divide.by.power.of.two.divide.option=Check divisions by a power of two also
 554 serializable.with.unconstructable.ancestor.display.name=Serializable class with unconstructable ancestor
 555 missorted.modifiers.display.name=Missorted modifiers
 556 sleep.while.holding.lock.display.name=Call to 'Thread.sleep()' while synchronized
 557 singleton.display.name=Singleton
 558 thread.death.rethrown.display.name='java.lang.ThreadDeath' not rethrown
 559 if.statement.with.too.many.branches.display.name='if' statement with too many branches
 560 redundant.implements.display.name=Redundant interface declaration
 561 nesting.depth.display.name=Overly nested method
 562 return.this.display.name=Return of 'this'
 563 busy.wait.display.name=Busy wait
 564 utility.class.display.name=Utility class
 565 instantiating.object.to.get.class.object.display.name=Instantiating object to get Class object
 566 abstract.class.extends.concrete.class.display.name=Abstract class extends concrete class
 567 parameter.naming.convention.display.name=Method parameter naming convention
 568 parameter.naming.convention.element.description=Parameter
 569 integer.division.in.floating.point.context.display.name=Integer division in floating point context
 570 interface.naming.convention.display.name=Interface naming convention
 571 interface.naming.convention.element.description=Interface
 572 length.one.strings.in.concatenation.display.name=Single character string concatenation
 573 length.one.string.in.indexof.display.name= Single character string argument in 'String.indexOf()' call
 574 unnecessary.conditional.expression.display.name=Redundant conditional expression
 575 thread.yield.display.name=Call to 'Thread.yield()'
 576 confusing.floating.point.literal.display.name=Confusing floating-point literal
 577 wait.not.in.loop.display.name='wait()' not in loop
 578 string.concatenation.inside.string.buffer.append.display.name=String concatenation as argument to 'StringBuffer.append()' call
 579 class.initializer.display.name=Non-'static' initializer
 580 enumerated.class.naming.convention.display.name=Enumerated class naming convention
 581 enumerated.class.naming.convention.element.description=Enumerated class
 582 non.thread.safe.lazy.initialization.display.name=Unsafe lazy initialization of 'static' field
 583 call.to.simple.setter.in.class.display.name=Call to simple setter from within class
 584 comparison.to.nan.display.name=Comparison to Double.NaN or Float.NaN
 585 instance.method.naming.convention.display.name=Instance method naming convention
 586 instance.method.naming.convention.element.description=Instance method
 587 unnecessary.semicolon.display.name=Unnecessary semicolon
 588 fallthru.in.switch.statement.display.name=Fallthrough in 'switch' statement
 589 call.to.native.method.while.locked.display.name=Call to a native method while locked
 590 switch.statement.display.name='switch' statement
 591 custom.classloader.display.name=Custom ClassLoader
 592 nested.conditional.expression.display.name=Nested conditional expression
 593 duplicate.condition.display.name=Duplicate condition in 'if' statement
 594 duplicate.boolean.branch.display.name=Duplicate condition on '\\&\\&' or '||'
 595 method.with.multiple.loops.display.name=Method with multiple loops
 596 non.comment.source.statements.display.name=Overly long method
 597 local.variable.naming.convention.display.name=Local variable naming convention
 598 local.variable.naming.convention.element.description=Local variable
 599 negated.if.else.display.name='if' statement with negated condition
 600 class.naming.convention.display.name=Class naming convention
 601 class.naming.convention.element.description=Class
 602 abstract.class.naming.convention.display.name=Abstract class naming convention
 603 abstract.class.naming.convention.element.description=Abstract class
 604 serializable.inner.class.with.non.serializable.outer.class.display.name=Serializable non-'static' inner class with non-Serializable outer class
 605 pointless.arithmetic.expression.display.name=Pointless arithmetic expression
 606 method.name.same.as.class.name.display.name=Method name same as class name
 607 unnecessary.temporary.on.conversion.to.string.display.name=Unnecessary temporary object in conversion to String
 608 unnecessary.continue.display.name=Unnecessary 'continue' statement
 609 inner.class.on.interface.display.name=Inner class of interface
 610 unused.label.display.name=Unused label
 611 multiple.typed.declaration.display.name=Variables of different types in one declaration
 612 overly.complex.boolean.expression.display.name=Overly complex boolean expression
 613 continue.statement.with.label.display.name='continue' statement with label
 614 class.loader.instantiation.display.name=ClassLoader instantiation
 615 return.from.finally.block.display.name='return' inside 'finally' block
 616 unnecessary.boxing.display.name=Unnecessary boxing
 617 annotation.naming.convention.display.name=Annotation naming convention
 618 annotation.naming.convention.element.description=Annotation
 619 checked.exception.class.display.name=Checked exception class
 620 switch.statement.with.confusing.declaration.display.name=Local variable used and declared in different 'switch' branches
 621 cast.that.loses.precision.display.name=Numeric cast that loses precision
 622 manual.array.copy.display.name=Manual array copy
 623 manual.array.to.collection.copy.display.name=Manual array to collection copy
 624 long.literals.ending.with.lowercase.l.display.name='long' literal ending with 'l' instead of 'L'
 625 overly.complex.arithmetic.expression.display.name=Overly complex arithmetic expression
 626 junit.abstract.test.class.naming.convention.display.name=JUnit abstract test class naming convention
 627 junit.abstract.test.class.naming.convention.element.description=Abstract JUnit test class
 628 unnecessary.parentheses.display.name=Unnecessary parentheses
 629 test.case.in.product.code.display.name=JUnit TestCase in product source
 630 test.method.in.product.code.display.name=JUnit test method in product source
 631 serializable.class.in.secure.context.display.name=Serializable class in secure context
 632 static.variable.naming.convention.display.name='static' field naming convention
 633 static.variable.naming.convention.element.description='static' field
 634 nested.method.call.display.name=Nested method call
 635 throw.from.finally.block.display.name='throw' inside 'finally' block
 636 field.accessed.synchronized.and.unsynchronized.display.name=Field accessed in both synchronized and unsynchronized contexts
 637 abstract.method.overrides.abstract.method.display.name=Abstract method overrides abstract method
 638 static.non.final.field.display.name='static', non-'final' field
 639 static.non.final.field.option=Only report 'public' fields
 640 substring.zero.display.name=Redundant 'substring(0)' call
 641 class.without.no.arg.constructor.display.name=Class without no-arg constructor
 642 unnecessary.return.display.name=Unnecessary 'return' statement
 643 final.static.method.display.name='static' method declared 'final'
 644 constant.declared.in.abstract.class.display.name=Constant declared in abstract class
 645 too.broad.catch.display.name=Overly broad 'catch' block
 646 floating.point.equality.display.name=Floating point equality comparison
 647 thrown.exceptions.per.method.display.name=Method with too many exceptions declared
 648 public.static.array.field.display.name='public static' array field
 649 await.not.in.loop.display.name='await()' not in loop
 650 method.names.differ.only.by.case.display.name=Method names differing only by case
 651 unsecure.random.number.generation.display.name=Insecure random number generation
 652 parameters.per.method.display.name=Method with too many parameters
 653 parameters.per.constructor.display.name=Constructor with too many parameters
 654 unnecessary.unboxing.display.name=Unnecessary unboxing
 655 extends.thread.display.name=Class directly extends 'java.lang.Thread'
 656 test.case.with.constructor.display.name=JUnit TestCase with non-trivial constructors
 657 parameter.name.differs.from.overridden.parameter.display.name=Parameter name differs from parameter in overridden method
 658 final.private.method.display.name='private' method declared 'final'
 659 enum.switch.statement.which.misses.cases.display.name=Enum 'switch' statement that misses case
 660 enum.switch.statement.which.misses.cases.option=Ignore switch statements with a default branch
 661 unconstructable.test.case.display.name=Unconstructable JUnit TestCase
 662 volatile.long.or.double.field.display.name=Volatile long or double field
 663 string.buffer.must.have.initial.capacity.display.name=StringBuffer or StringBuilder without initial capacity
 664 method.may.be.static.display.name=Method may be 'static'
 665 class.initializer.may.be.static.display.name=Class initializer may be 'static'
 666 class.initializer.option=Only warn when the class has one or more constructors
 667 class.initializer.move.code.to.constructor.quickfix=Move initializer code to constructor
 668 nested.switch.statement.display.name=Nested 'switch' statement
 669 c.style.array.declaration.display.name=C-style array declaration
 670 final.method.in.final.class.display.name='final' method in 'final' class
 671 extends.annotation.display.name=Class extends annotation interface
 672 naked.notify.display.name='notify()' or 'notifyAll()' without corresponding state change
 673 constant.if.statement.display.name=Constant 'if' statement
 674 switch.statement.density.display.name='switch' statement with too low of a branch density
 675 switch.statement.with.too.few.branches.display.name='switch' statement with too few branches
 676 upper.case.field.name.not.constant.display.name=Non-constant field with upper-case name
 677 unnecessary.label.on.continue.statement.display.name=Unnecessary label on 'continue' statement
 678 jdbc.prepare.statement.with.non.constant.string.display.name=Call to 'Connection.prepare*()' with non-constant string
 679 synchronize.on.non.final.field.display.name=Synchronization on a non-final field
 680 noop.method.in.abstract.class.display.name=No-op method in abstract class
 681 non.final.field.of.exception.display.name=Non-final field of exception class
 682 nested.try.statement.display.name=Nested 'try' statement
 683 condition.signal.display.name=Call to 'signal()' instead of 'signalAll()'
 684 jdbc.execute.with.non.constant.string.display.name=Call to 'Statement.execute()' with non-constant string
 685 system.set.security.manager.display.name=Call to 'System.setSecurityManager()'
 686 system.set.security.manager.problem.descriptor=Call to <code>System.#ref()</code> may pose security concerns #loc
 687 control.flow.statement.without.braces.display.name=Control flow statement without braces
 688 trivial.if.display.name=Redundant 'if' statement
 689 thread.with.default.run.method.display.name=Instantiating a Thread with default 'run()' method
 690 while.loop.spins.on.field.display.name='while' loop spins on field
 691 object.equals.null.display.name=Object.equals(null)
 692 test.method.is.public.void.no.arg.display.name=Test method with incorrect signature
 693 if.statement.with.identical.branches.display.name='if' statement with identical branches
 694 multiple.return.points.per.method.display.name=Method with multiple return points
 695 break.statement.with.label.display.name='break' statement with label
 696 public.constructor.in.non.public.class.display.name='public' constructor in non-public class
 697 questionable.name.display.name=Questionable name
 698 empty.finally.block.display.name=Empty 'finally' block
 699 abstract.method.overrides.concrete.method.display.name=Abstract method overrides concrete method
 700 thread.stop.suspend.resume.display.name=Call to 'Thread.stop()', 'suspend()' or 'resume()'
 701 constant.math.call.display.name=Constant call to 'java.lang.Math'
 702 volatile.array.field.display.name=Volatile array field
 703 literal.as.arg.to.string.equals.display.name='expression.equals("literal")' rather than '"literal".equals(expression)'
 704 inner.class.may.be.static.display.name=Inner class may be 'static'
 705 static.suite.display.name='suite()' method not declared 'static'
 706 redundant.field.initialization.display.name=Redundant field initialization
 707 string.buffer.to.string.in.concatenation.display.name='StringBuffer.toString()' in concatenation
 708 utility.class.with.public.constructor.display.name=Utility class with 'public' constructor
 709 for.loop.replaceable.by.while.display.name='for' loop may be replaced with 'while' loop
 710 missing.deprecated.annotation.display.name=Missing @Deprecated annotation
 711 cloneable.class.in.secure.context.display.name=Cloneable class in secure context
 712 static.inheritance.display.name=Static inheritance
 713 class.name.prefixed.with.package.name.display.name=Class name prefixed with package name
 714 call.to.simple.getter.in.class.display.name=Call to simple getter from within class
 715 class.name.differs.from.file.name.display.name=Class name differs from file name
 716 protected.member.in.final.class.display.name='protected' member in 'final' class
 717 load.library.with.non.constant.string.display.name=Call to 'System.loadLibrary()' with non-constant string
 718 instanceof.catch.parameter.display.name='instanceof' on 'catch' parameter
 719 implicit.numeric.conversion.display.name=Implicit numeric conversion
 720 unnecessary.interface.modifier.display.name=Unnecessary interface modifier
 721 confusing.main.method.display.name=Confusing 'main()' method
 722 octal.literal.display.name=Octal integer
 723 misordered.assert.equals.arguments.display.name=Misordered 'assertEquals()' arguments
 724 unnecessary.constructor.display.name=Redundant no-arg constructor
 725 method.name.same.as.parent.name.display.name=Method name same as parent class name
 726 while.can.be.foreach.display.name='while' loop replaceable with 'foreach'
 727 big.decimal.equals.display.name='equals()' called on 'java.math.BigDecimal'
 728 implicit.call.to.super.display.name=Implicit call to 'super()'
 729 empty.catch.block.display.name=Empty 'catch' block
 730 unqualified.static.usage.display.name=Unqualified static access
 731 simplifiable.junit.assertion.display.name=Simplifiable JUnit assertion
 732 object.notify.display.name=Call to 'notify()' instead of 'notifyAll()'
 733 thread.start.in.construction.display.name=Call to 'Thread.start()' during object construction
 734 non.final.clone.display.name=Non-final 'clone()' in secure context
 735 unnecessary.temporary.on.conversion.from.string.display.name=Unnecessary temporary object in conversion from String
 736 unnecessary.this.display.name=Unnecessary 'this' qualifier
 737 unnecessary.this.ignore.assignments.option=Ignore field assignments
 738 runtime.exec.with.non.constant.string.display.name=Call to 'Runtime.exec()' with non-constant string
 739 system.properties.display.name=Access of system properties
 740 chained.method.call.display.name=Chained method calls
 741 safe.lock.display.name=Lock acquired but not safely unlocked
 742 system.run.finalizers.on.exit.display.name=Call to 'System.runFinalizersOnExit()'
 743 for.can.be.foreach.display.name='for' loop replaceable with 'foreach'
 744 type.parameter.extends.object.display.name=Type parameter explicitly extends 'java.lang.Object'
 745 marker.interface.display.name=Marker interface
 746 limited.scope.inner.class.display.name=Limited-scope inner class
 747 switch.statements.without.default.display.name='switch' statement without 'default' branch
 748 unchecked.exception.class.display.name=Unchecked exception class
 749 for.loop.with.missing.component.display.name='for' loop with missing components
 750 for.loop.with.missing.component.collection.loop.option=Ignore collection iterations
 751 double.checked.locking.display.name=Double-checked locking
 752 double.checked.locking.problem.descriptor=Double-checked locking #loc
 753 double.checked.locking.ignore.on.volatiles.option=Ignore double-checked locking on volatile fields
 754 string.buffer.replaceable.by.string.display.name='StringBuffer' can be replaced with 'String'
 755 boolean.method.name.must.start.with.question.display.name=Boolean method name must start with question word
 756 class.name.same.as.ancestor.name.display.name=Class name same as ancestor name
 757 error.rethrown.display.name='java.lang.Error' not rethrown
 758 serializable.has.serialization.methods.display.name=Serializable class without 'readObject()' and 'writeObject()'
 759 serializable.has.serialization.methods.ignore.option=Ignore classes that do not define instance fields
 760 missing.override.annotation.display.name=Missing @Override annotation
 761 wait.while.holding.two.locks.display.name='wait()' while holding two locks
 762 empty.class.display.name=Empty class
 763 trivial.string.concatenation.display.name=Concatenation with empty string
 764 empty.synchronized.statement.display.name=Empty 'synchronized' statement
 765 unnecessary.default.display.name=Unnecessary 'default' for enum 'switch' statement
 766 simplifiable.conditional.expression.display.name=Simplifiable conditional expression
 767 simplifiable.if.statement.display.name='if' statement may be replaced with \\&\\& or || expression
 768 unnecessary.super.constructor.display.name=Unnecessary call to 'super()'
 769 unnecessarily.qualified.static.usage.display.name=Unnecessarily qualified static access
 770 bad.exception.caught.display.name=Prohibited exception caught
 771 custom.security.manager.display.name=Custom SecurityManager
 772 string.concatenation.in.loops.display.name=String concatenation in loop
 773 boolean.constructor.display.name=Boolean constructor call
 774 continue.statement.display.name='continue' statement
 775 extends.object.display.name=Class explicitly extends 'java.lang.Object'
 776 serializable.inner.class.has.serial.version.uid.field.display.name=Serializable non-'static' inner class without 'serialVersionUID'
 777 static.method.naming.convention.display.name='static' method naming convention
 778 static.method.naming.convention.element.description='static' method
 779 empty.try.block.display.name=Empty 'try' block
 780 field.has.setter.but.no.getter.display.name=Field has setter but no getter
 781 three.negations.per.method.display.name=Method with more than three negations
 782 conditional.expression.display.name=Conditional expression (?:)
 783 unnecessary.enum.modifier.display.name=Unnecessary enum modifier
 784 string.equals.empty.string.display.name='String.equals("")'
 785 synchronize.on.lock.display.name=Synchronization on a Lock object
 786 synchronized.on.literal.object.name=Synchronization on an object initialized with a literal
 787 field.may.be.static.display.name=Field may be 'static'
 788 class.may.be.interface.display.name=Abstract class may be interface
 789 abstract.class.without.abstract.methods.display.name=Abstract class without abstract methods
 790 divide.by.zero.display.name=Divide by zero
 791 default.not.last.case.in.switch.display.name='default' not last case in 'switch' statement
 792 nested.synchronized.statement.display.name=Nested 'synchronized' statement
 793 constant.conditional.expression.display.name=Constant conditional expression
 794 unused.catch.parameter.display.name=Unused 'catch' parameter
 795 confusing.else.display.name=Confusing 'else' branch
 796 public.field.accessed.in.synchronized.context.display.name=Non-private field accessed in synchronized context
 797 string.replaceable.by.string.buffer.display.name=Non-constant String should be StringBuilder
 798 junit.test.class.naming.convention.display.name=JUnit test class naming convention
 799 junit.test.class.naming.convention.element.description=JUnit test class
 800 method.coupling.display.name=Overly coupled method
 801 collections.must.have.initial.capacity.display.name=Collection without initial capacity
 802 anonymous.inner.class.display.name=Anonymous inner class
 803 negated.conditional.display.name=Conditional expression with negated condition
 804 non.reproducible.math.call.display.name=Non-reproducible call to 'java.lang.Math'
 805 multiple.top.level.classes.in.file.display.name=Multiple top level classes in single file
 806 set.replaceable.by.enum.set.display.name=Set replaceable with EnumSet
 807 non.static.inner.class.in.secure.context.display.name=Non-'static' inner class in secure context
 808 tail.recursion.display.name=Tail recursion
 809 finally.block.cannot.complete.normally.display.name='finally' block which can not complete normally
 810 non.atomic.operation.on.volatile.field.display.name=Non-atomic operation on volatile field
 811 public.static.collection.field.display.name='public static' collection field
 812 non.exception.name.ends.with.exception.display.name=Non-exception class name ends with 'Exception'
 813 synchronized.method.display.name='synchronized' method
 814 enumerated.constant.naming.convention.display.name=Enumerated constant naming convention
 815 enumerated.constant.naming.convention.element.description=Enumerated constant
 816 final.method.display.name='final' method
 817 transient.field.in.non.serializable.class.display.name=Transient field in non-serializable class
 818 bad.exception.thrown.display.name=Prohibited exception thrown
 819 conditional.expression.with.identical.branches.display.name=Conditional expression with identical or similar branches
 820 raw.use.of.parameterized.type.display.name=Raw use of parameterized class
 821 standard.variable.names.display.name=Standard variable names
 822 instance.variable.naming.convention.display.name=Instance field naming convention
 823 instance.variable.naming.convention.element.description=Instance field
 824 dollar.sign.in.name.display.name=Use of '$' in identifier
 825 map.replaceable.by.enum.map.display.name=Map replaceable with EnumMap
 826 extends.concrete.collection.display.name=Class explicitly extends a Collection class
 827 continue.or.break.from.finally.block.display.name='continue' or 'break' inside 'finally' block
 828 abstract.method.with.missing.implementations.display.name=Abstract method with missing implementations
 829 object.allocation.in.loop.display.name=Object allocation in loop
 830 wait.called.on.condition.display.name='wait()' called on 'java.util.concurrent.locks.Condition' object
 831 test.case.with.no.test.methods.display.name=JUnit test case with no tests
 832 abstract.class.never.implemented.display.name=Abstract class which has no concrete subclass
 833 interface.never.implemented.display.name=Interface which has no concrete subclass
 834 constant.declared.in.interface.display.name=Constant declared in interface
 835
 836
 837 #problem descriptors
 838 exception.name.doesnt.end.with.exception.problem.descriptor=Exception class name <code>#ref</code> does not end with 'Exception' #loc
 839 non.exception.name.ends.with.exception.problem.descriptor=Non-exception class name <code>#ref</code> ends with 'Exception' #loc
 840 class.name.prefixed.with.package.name.problem.descriptor=Class name <code>#ref</code> begins with its package name #loc
 841 class.name.same.as.ancestor.name.problem.descriptor=Class name <code>#ref</code> is the same as one of its superclass' names #loc
 842 method.name.same.as.class.name.problem.descriptor=Method name <code>#ref</code> is the same as its class name #loc
 843 method.name.same.as.parent.name.problem.descriptor=Method name <code>#ref</code> is the same as its parent class name #loc
 844 boolean.method.name.must.start.with.question.problem.descriptor=Boolean method name <code>#ref</code> does not start with question word #loc
 845 questionable.name.problem.descriptor=Questionable name <code>#ref</code> #loc
 846 confusing.main.method.problem.descriptor=Method named <code>#ref</code> without signature 'public static void main(String[])' #loc
 847 upper.case.field.name.not.constant.problem.descriptor=Non-constant field <code>#ref</code> with constant-style name #loc
 848 dollar.sign.in.name.problem.descriptor=Identifier <code>#ref</code> contains '$' #loc
 849 integer.division.in.floating.point.context.problem.descriptor=<code>#ref</code>: integer division in floating-point context #loc
 850 comparison.of.short.and.char.problem.descriptor=Equality comparison <code>#ref</code> of short and char values #loc
 851 big.decimal.equals.problem.descriptor=<code>#ref()</code> between BigDecimal values should probably be 'compareTo()' #loc
 852 divide.by.zero.problem.descriptor=Division by zero #loc
 853 non.reproducible.math.call.problem.descriptor=<code>Math.#ref()</code> may produce non-reproducible results #loc
 854 constant.math.call.problem.descriptor=Constant call to <code>#ref()</code> can be simplified #loc
 855 floating.point.equality.problem.descriptor=<code>#ref</code>: floating point values compared for exact equality #loc
 856 fallthru.in.switch.statement.problem.descriptor=Fallthrough in 'switch' statement #loc
 857 switch.statements.without.default.problem.descriptor=<code>#ref</code> statement without 'default' branch #loc
 858 default.not.last.case.in.switch.problem.descriptor=<code>#ref</code> branch not last case in 'switch' statement #loc
 859 loop.statements.that.dont.loop.problem.descriptor=<code>#ref</code> statement does not loop #loc
 860 conditional.expression.with.identical.branches.problem.descriptor=Conditional expression <code>#ref</code> with identical branches #loc
 861 conditional.expression.with.similar.branches.problem.descriptor=Conditional expression <code>#ref</code> with similar branches #loc
 862 if.statement.with.identical.branches.problem.descriptor=<code>#ref</code> statement with identical branches #loc
 863 duplicate.condition.problem.descriptor=Duplicate condition <code>#ref</code> #loc
 864 duplicate.condition.ignore.method.calls.option=Ignore method calls in condition
 865 duplicate.boolean.branch.problem.descriptor=Duplicate branch <code>#ref</code> #loc
 866 iterator.next.does.not.throw.nosuchelementexception.problem.descriptor=<code>Iterator.#ref()</code> which can't throw 'NoSuchElementException' #loc
 867 infinite.loop.statement.problem.descriptor=<code>#ref</code> statement cannot complete without throwing an exception #loc
 868 confusing.floating.point.literal.problem.descriptor=Confusing floating point literal <code>#ref</code> #loc
 869 overly.complex.arithmetic.expression.problem.descriptor=Overly complex arithmetic expression #loc
 870 overly.complex.boolean.expression.problem.descriptor=Overly complex boolean expression ({0} terms) #loc
 871 labeled.statement.problem.descriptor=Labeled statement <code>#ref:</code> #loc
 872 break.statement.with.label.problem.descriptor=<code>#ref</code> statement with label #loc
 873 continue.statement.with.label.problem.descriptor=<code>#ref</code> statement with label #loc
 874 conditional.expression.problem.descriptor=Conditional expression <code>#ref</code> #loc
 875 conditional.expression.option=Ignore for simple assignments and returns
 876 nested.conditional.expression.problem.descriptor=Nested conditional expression <code>#ref</code> #loc
 877 long.literals.ending.with.lowercase.l.problem.descriptor='long' literal <code>#ref</code> ends with lowercase 'l' #loc
 878 nested.switch.statement.problem.descriptor=Nested <code>#ref</code> statement #loc
 879 chained.method.call.problem.descriptor=Chained method call <code>#ref()</code> #loc
 880 nested.method.call.problem.descriptor=Nested method call <code>#ref()</code> #loc
 881 octal.literal.problem.descriptor=Octal integer <code>#ref</code> #loc
 882 implicit.call.to.super.problem.descriptor=Implicit call to 'super()' #loc
 883 negated.if.else.problem.descriptor=<code>#ref</code> statement with negated condition #loc
 884 negated.conditional.problem.descriptor=Conditional expression with negated condition #loc
 885 confusing.else.problem.descriptor=<code>#ref</code> branch may be unwrapped, as the 'if' branch never completes #loc
 886 switch.statement.with.confusing.declaration.problem.descriptor=Local variable <code>#ref</code> declared in one 'switch' branch and used in another #loc
 887 raw.use.of.parameterized.type.problem.descriptor=Raw use of parameterized class <code>#ref</code> #loc
 888 final.class.problem.descriptor=Class declared <code>#ref</code> #loc
 889 empty.class.problem.descriptor=Class <code>#ref</code> is empty #loc
 890 empty.class.file.without.class.problem.descriptor=Java file does not declare any class #loc
 891 empty.anonymous.class.problem.descriptor=Anonymous class is empty #loc
 892 anonymous.inner.class.problem.descriptor=Anonymous inner class <code>#ref</code> #loc
 893 limited.scope.inner.class.problem.descriptor=Limited-scope inner class <code>#ref</code> #loc
 894 final.method.problem.descriptor=Method declared <code>#ref</code> #loc
 895 class.initializer.problem.descriptor=Non-'static' initializer #loc
 896 class.may.be.interface.problem.descriptor=Abstract class <code>#ref</code> may be interface #loc
 897 non.protected.constructor.in.abstract.class.problem.descriptor=Constructor <code>#ref()</code> is not declared 'protected' in 'abstract' class #loc
 898 class.without.constructor.problem.descriptor=Class <code>#ref</code> has no constructor #loc
 899 abstract.class.without.abstract.methods.problem.descriptor=Class <code>#ref</code> is declared 'abstract', and has no 'abstract' methods #loc
 900 final.method.in.final.class.problem.descriptor=Method declared <code>#ref</code> in 'final' class #loc
 901 protected.member.in.final.class.problem.descriptor=Class member declared <code>#ref</code> in 'final' class #loc
 902 utility.class.with.public.constructor.problem.descriptor=Class <code>#ref</code> has only 'static' members, and a 'public' constructor #loc
 903 utility.class.without.private.constructor.problem.descriptor=Class <code>#ref</code> has only 'static' members, and lacks a 'private' constructor #loc
 904 abstract.method.overrides.concrete.method.problem.descriptor=Abstract method <code>#ref()</code> overrides concrete method #loc
 905 abstract.method.with.missing.implementations.problem.descriptor=Abstract method <code>#ref()</code> is not implemented in every subclass #loc
 906 abstract.method.overrides.abstract.method.problem.descriptor=Abstract method <code>#ref()</code> overrides abstract method #loc
 907 abstract.method.overrides.abstract.method.ignore.different.javadoc.option=Ignore methods with different Javadoc than their super methods
 908 abstract.method.overrides.abstract.method.ignore.different.annotations.option=Ignore methods with different annotations than their super methods
 909 abstract.class.extends.concrete.class.problem.descriptor=Class <code>#ref</code> is declared 'abstract', and extends a concrete class #loc
 910 static.non.final.field.problem.descriptor='static' non-'final' field <code>#ref</code> #loc
 911 constant.declared.in.abstract.class.problem.descriptor=Constant <code>#ref</code> declared in abstract class #loc
 912 constant.declared.in.interface.problem.descriptor=Constant <code>#ref</code> declared in interface #loc
 913 static.inheritance.problem.descriptor=Interface <code>#ref</code> is implemented only for its 'static' constants #loc
 914 utility.class.problem.descriptor=Class <code>#ref</code> has only 'static' members, indicating procedural construction #loc
 915 singleton.problem.descriptor=Class <code>#ref</code> is a singleton #loc
 916 final.private.method.problem.descriptor='private' method declared <code>#ref</code> #loc
 917 noop.method.in.abstract.class.problem.descriptor=No-op Method <code>#ref()</code> should be made abstract #loc
 918 final.static.method.problem.descriptor='static' method declared <code>#ref</code> #loc
 919 class.without.no.arg.constructor.problem.descriptor=<code>#ref</code> has no no-arg constructor #loc
 920 multiple.top.level.classes.in.file.problem.descriptor=Multiple top level classes in file
 921 class.name.differs.from.file.name.problem.descriptor=Class name <code>#ref</code> differs from file name #loc
 922 marker.interface.problem.descriptor=Marker interface <code>#ref</code> #loc
 923 field.has.setter.but.no.getter.problem.descriptor=Field <code>#ref</code> has setter but no getter #loc
 924 abstract.class.never.implemented.problem.descriptor=Abstract class <code>#ref</code> has no concrete subclass #loc
 925 interface.never.implemented.problem.descriptor=Interface <code>#ref</code> has no concrete subclass #loc
 926 missing.deprecated.annotation.problem.descriptor=Missing '@Deprecated' annotation #loc
 927 missing.deprecated.tag.problem.descriptor=Missing '@deprecated' Javadoc tag explanation #loc
 928 missing.deprecated.tag.option=Warn on missing @deprecated Javadoc tag explanation
 929 missing.override.annotation.problem.descriptor=Missing '@Override' annotation on <code>#ref()</code> #loc
 930 non.thread.safe.lazy.initialization.problem.descriptor=Lazy initialization of 'static' field <code>#ref</code> is not thread-safe #loc
 931 empty.catch.block.problem.descriptor=Empty <code>#ref</code> block #loc
 932 unused.catch.parameter.problem.descriptor=Unused 'catch' parameter <code>#ref</code> #loc
 933 used.catch.parameter.named.ignore.problem.descriptor='catch' parameter named <code>#ref</code> is used #loc
 934 empty.finally.block.problem.descriptor=Empty <code>#ref</code> block #loc
 935 finally.block.cannot.complete.normally.problem.descriptor=<code>#ref</code> block can not complete normally #loc
 936 empty.try.block.problem.descriptor=Empty <code>#ref</code> block #loc
 937 throw.from.finally.block.problem.descriptor=<code>#ref</code> inside 'finally' block #loc
 938 possible.throw.from.finally.block.problem.descriptor=<code>{0}</code> might be thrown inside ''finally'' block #loc
 939 throw,from.finally.block.everywhere.option=Warn everywhere declared exceptions may be thrown
 940 throw.caught.locally.problem.descriptor=<code>#ref</code> caught by containing 'try' statement #loc
 941 throw.caught.locally.ignore.option=Ignore rethrown exceptions
 942 return.from.finally.block.problem.descriptor=<code>#ref</code> inside 'finally' block #loc
 943 continue.or.break.from.finally.block.problem.descriptor=<code>#ref</code> inside 'finally' block #loc
 944 bad.exception.declared.problem.descriptor=Prohibited exception <code>#ref</code> declared #loc
 945 bad.exception.caught.problem.descriptor=Prohibited exception <code>#ref</code> caught #loc
 946 checked.exception.class.problem.descriptor=Checked exception class <code>#ref</code> #loc
 947 unchecked.exception.class.problem.descriptor=Unchecked exception class <code>#ref</code> #loc
 948 thread.death.rethrown.problem.descriptor=ThreadDeath <code>#ref</code> not rethrown #loc
 949 error.rethrown.problem.descriptor=Error <code>#ref</code> not rethrown #loc
 950 nested.try.statement.problem.descriptor=Nested <code>#ref</code> statement #loc
 951 exception.from.catch.which.doesnt.wrap.problem.descriptor=<code>#ref</code> inside 'catch' block ignores the caught exception #loc
 952 instanceof.catch.parameter.problem.descriptor='instanceof' on 'catch' parameter <code>#ref</code> #loc
 953 non.final.field.of.exception.problem.descriptor=Non-final field <code>#ref</code> of exception class #loc
 954 unnecessary.label.on.break.statement.problem.descriptor=Unnecessary label on <code>#ref</code> statement #loc
 955 unnecessary.label.on.continue.statement.problem.descriptor=Unnecessary label on <code>#ref</code> statement #loc
 956 trivial.if.problem.descriptor=<code>#ref</code> statement can be simplified #loc
 957 constant.if.statement.problem.descriptor=<code>#ref</code> statement can be simplified #loc
 958 unnecessary.parentheses.problem.descriptor=Parentheses around <code>#ref</code> are unnecessary #loc
 959 unnecessary.local.variable.problem.descriptor=Local variable <code>#ref</code> is redundant #loc
 960 unnecessary.this.problem.descriptor=<code>#ref</code> is unnecessary in this context #loc
 961 unnecessary.block.statement.problem.descriptor=Braces around this statement are unnecessary #loc
 962 unnecessary.continue.problem.descriptor=<code>#ref</code> is unnecessary as the last statement in a loop #loc
 963 unnecessary.semicolon.problem.descriptor=Unnecessary semicolon <code>#ref</code> #loc
 964 unnecessary.fully.qualified.name.problem.descriptor1=Qualifier <code>#ref</code> is unnecessary, and can be replaced with an import #loc
 965 unnecessary.fully.qualified.name.problem.descriptor2=Qualifier <code>#ref</code> is unnecessary and can be removed #loc
 966 unnecessary.qualifier.for.this.problem.descriptor=Qualifier <code>#ref</code> on 'this' is unnecessary in this context #loc
 967 unnecessary.qualifier.for.super.problem.descriptor=Qualifier <code>#ref</code> on 'super' is unnecessary in this context #loc
 968 unused.label.problem.descriptor=Unused label <code>#ref</code> #loc
 969 redundant.field.initialization.problem.descriptor=Field initialization to <code>#ref</code> is redundant #loc
 970 redundant.implements.problem.descriptor=Redundant interface declaration <code>#ref</code> #loc
 971 extends.object.problem.descriptor=Class <code>#ref</code> explicitly extends 'java.lang.Object' #loc
 972 type.parameter.extends.object.problem.descriptor1=Type parameter <code>#ref</code> explicitly extends 'java.lang.Object' #loc
 973 type.parameter.extends.object.problem.descriptor2=Wildcard type argument <code>#ref</code> explicitly extends 'java.lang.Object' #loc
 974 unnecessary.super.constructor.problem.descriptor=<code>#ref</code> is unnecessary #loc
 975 unnecessary.constructor.problem.descriptor=No-arg constructor <code>#ref()</code> is redundant #loc
 976 unnecessary.constructor.annotation.option=Ignore constructors with an annotation
 977 for.loop.replaceable.by.while.problem.descriptor=<code>#ref</code> loop statement may be replace by 'while' loop #loc
 978 unnecessary.default.problem.descriptor=<code>#ref</code> branch is unnecessary #loc
 979 unnecessary.boxing.problem.descriptor=Unnecessary boxing <code>#ref</code> #loc
 980 unnecessary.unboxing.problem.descriptor=Unnecessary unboxing <code>#ref</code> #loc
 981 unnecessary.boxing.superfluous.option=Only report truly superfluously boxed expressions
 982 unnecessary.unboxing.superfluous.option=Only report truly superfluously unboxed expressions
 983 for.can.be.foreach.problem.descriptor=<code>#ref</code> loop replaceable with 'foreach' #loc
 984 while.can.be.foreach.problem.descriptor=<code>#ref</code> loop replaceable with 'foreach' #loc
 985 too.broad.scope.problem.descriptor=Scope of variable <code>#ref</code> is too broad #loc
 986 return.this.problem.descriptor=Return of <code>#ref</code> #loc
 987 constant.on.lhs.of.comparison.problem.descriptor=<code>#ref</code>: constant on left side of comparison #loc
 988 constant.on.rhs.of.comparison.problem.descriptor=<code>#ref</code>: constant on right side of comparison #loc
 989 control.flow.statement.without.braces.problem.descriptor=<code>{0}</code> without braces #loc
 990 missorted.modifiers.problem.descriptor=Missorted modifiers <code>#ref</code> #loc
 991 cstyle.array.variable.declaration.problem.descriptor=C-style array declaration of {0, choice, 1#field|2#parameter|3#local variable} <code>#ref</code> #loc
 992 cstyle.array.method.declaration.problem.descriptor=C-style array declaration of the return type of method <code>#ref()</code>#loc
 993 multiple.declaration.problem.descriptor=Multiple variables in one declaration #loc
 994 multiple.typed.declaration.problem.descriptor=Variables of different types in one declaration #loc
 995 serializable.inner.class.has.serial.version.uid.field.problem.descriptor=Inner class <code>#ref</code> does not define a 'serialVersionUID' field #loc
 996 serializable.inner.class.with.non.serializable.outer.class.problem.descriptor=Inner class <code>#ref</code> is serializable while its outer class is not #loc
 997 busy.wait.problem.descriptor=Call to <code>Thread.#ref()</code> in a loop, probably busy-waiting #loc
 998 sleep.while.holding.lock.problem.descriptor=Call to <code>Thread.#ref()</code> while synchronized #loc
 999 non.atomic.operation.on.volatile.field.problem.descriptor=Non-atomic operation on volatile field <code>#ref</code> #loc
1000 call.to.native.method.while.locked.problem.descriptor=Call to native method <code>#ref()</code> in a synchronized context #loc
1001 object.notify.problem.descriptor=<code>#ref</code> should probably be replaced with 'notifyAll()' #loc
1002 condition.signal.problem.descriptor=<code>#ref</code> should probably be replaced with 'signalAll()' #loc
1003 thread.with.default.run.method.problem.descriptor=Instantiating a <code>#ref</code> with default 'run()' method #loc
1004 extends.thread.problem.descriptor=Class <code>#ref</code> directly extends 'java.lang.Thread' #loc
1005 anonymous.extends.thread.problem.descriptor=Anonymous class directly extends 'java.lang.Thread' #loc
1006 naked.notify.problem.descriptor=Call to <code>#ref()</code> without corresponding state change #loc
1007 unconditional.wait.problem.descriptor=Unconditional call to <code>#ref()</code> #loc
1008 system.run.finalizers.on.exit.problem.descriptor=Call to <code>System.#ref()</code> #loc
1009 thread.priority.problem.descriptor=Call to <code>Thread.#ref()</code> #loc
1010 thread.yield.problem.descriptor=Call to <code>Thread.#ref()</code> #loc
1011 thread.stop.suspend.resume.problem.descriptor=Call to <code>Thread.#ref()</code> #loc
1012 while.loop.spins.on.field.problem.descriptor=<code>#ref</code> loop spins on field #loc
1013 wait.not.in.loop.problem.descriptor=Call to <code>#ref()</code> is not made in a loop #loc
1014 await.not.in.loop.problem.descriptor=Call to <code>#ref()</code> is not made in a loop #loc
1015 wait.called.on.condition.problem.descriptor=Call to <code>#ref()</code> on Condition object #loc
1016 notify.called.on.condition.problem.descriptor=Call to <code>#ref()</code> on Condition object #loc
1017 wait.while.holding.two.locks.problem.descriptor=Call to <code>#ref()</code> is made while holding two locks #loc
1018 thread.run.problem.descriptor=Calls to <code>#ref()</code> should probably be replaced with 'start()' #loc
1019 thread.start.in.construction.problem.descriptor=Call to <code>#ref</code> during object construction #loc
1020 synchronize.on.lock.problem.descriptor=Synchronization on a ''{0}'' object is unlikely to be intentional #loc
1021 synchronized.on.literal.object.problem.descriptor=Synchronization on {0} <code>#ref</code> which is initialized by a literal #loc
1022 synchronized.on.direct.literal.object.problem.descriptor=Synchronization on {0} literal <code>#ref</code> #loc
1023 synchronized.on.possibly.literal.object.problem.descriptor=Synchronization on {0} <code>#ref</code> #loc
1024 synchronize.on.non.final.field.problem.descriptor=Synchronization on a non-final field <code>#ref</code> #loc
1025 synchronized.on.literal.object.warn.on.all.option=Warn on all possible literals
1026 synchronize.on.this.problem.descriptor=Lock operations on 'this' may have unforeseen side-effects #loc
1027 synchronize.on.class.problem.descriptor=Lock operations on a class may have unforeseen side-effects #loc
1028 nested.synchronized.statement.problem.descriptor=Nested <code>#ref</code> statement #loc
1029 empty.synchronized.statement.problem.descriptor=Empty <code>#ref</code> statement #loc
1030 non.synchronized.method.overrides.synchronized.method.problem.descriptor=Unsynchronized method <code>#ref()</code> overrides synchronized method #loc
1031 public.field.accessed.in.synchronized.context.problem.descriptor=Non-private field <code>#ref</code> accessed in synchronized context  #loc
1032 field.accessed.synchronized.and.unsynchronized.problem.descriptor=Field <code>#ref</code> is accessed in both synchronized and unsynchronized contexts #loc
1033 extended.for.statement.problem.descriptor=Extended <code>#ref</code> statement #loc
1034 object.allocation.in.loop.problem.descriptor=Object allocation <code>new #ref()</code> in loop #loc
1035 instantiating.object.to.get.class.object.problem.descriptor=Instantiating object to get Class object #loc
1036 field.may.be.static.problem.descriptor=Field <code>#ref</code> may be 'static' #loc
1037 method.may.be.static.problem.descriptor=Method <code>#ref()</code> may be 'static' #loc
1038 class.initializer.may.be.static.problem.descriptor=Class initializer may be 'static' #loc
1039 map.replaceable.by.enum.map.problem.descriptor=<code>#ref</code> replaceable with 'EnumMap' #loc
1040 set.replaceable.by.enum.set.problem.descriptor=<code>#ref</code> replaceable with 'EnumSet' #loc
1041 inner.class.may.be.static.problem.descriptor=Inner class <code>#ref</code> may be 'static' #loc
1042 string.buffer.must.have.initial.capacity.problem.descriptor=<code>new #ref()</code> without initial capacity #loc
1043 string.buffer.replaceable.by.string.builder.problem.descriptor=<code>StringBuffer #ref</code> may be declared as 'StringBuilder' #loc
1044 string.buffer.replaceable.by.string.problem.descriptor=<code>{0} #ref</code> can be replaced with ''String'' #loc
1045 new.string.buffer.replaceable.by.string.problem.descriptor=<code>#ref</code> can be replaced with 'String' #loc
1046 string.replaceable.by.string.buffer.problem.descriptor=Non-constant <code>String #ref</code> should probably be declared as ''StringBuilder'' #loc
1047 collections.must.have.initial.capacity.problem.descriptor=<code>new #ref()</code> without initial capacity #loc
1048 string.concatenation.in.loops.problem.descriptor=String concatenation <code>#ref</code> in loop #loc
1049 string.concatenation.inside.string.buffer.append.problem.descriptor=String concatenation as argument to <code>{0}.#ref()</code> call #loc
1050 boolean.constructor.problem.descriptor=Boolean constructor call #loc
1051 string.to.string.problem.descriptor=<code>#ref</code> is redundant #loc
1052 substring.zero.problem.descriptor=<code>#ref</code> is redundant #loc
1053 string.buffer.to.string.in.concatenation.problem.descriptor=Calls to <code>StringBuffer.#ref()</code> in concatenation #loc
1054 tail.recursion.problem.descriptor=Tail recursive call <code>#ref()</code> #loc
1055 string.equals.empty.string.problem.descriptor=<code>#ref("")</code> can be replaced with 'length()==0' #loc
1056 string.equals.empty.string.is.empty.problem.descriptor=<code>#ref("")</code> can be replaced with 'isEmpty()' #loc
1057 random.double.for.random.integer.problem.descriptor=Using <code>Random.#ref</code> to create random integer #loc
1058 manual.array.copy.problem.descriptor=Manual array copy #loc
1059 manual.array.to.collection.copy.problem.descriptor=Manual array to collection copy #loc
1060 call.to.simple.getter.in.class.problem.descriptor=Call to simple getter <code>#ref()</code> from within class #loc
1061 call.to.simple.setter.in.class.problem.descriptor=Call to simple setter <code>#ref()</code> from within class #loc
1062 asserts.without.messages.problem.descriptor=JUnit <code>#ref()</code> without message #loc
1063 test.case.with.constructor.problem.descriptor=Initialization logic in constructor <code>#ref()</code> instead of 'setUp()' #loc
1064 test.case.with.constructor.problem.descriptor.initializer=Initialization logic in initializer instead of 'setUp()'
1065 misordered.assert.equals.arguments.problem.descriptor=Arguments to <code>#ref()</code> in wrong order #loc
1066 static.suite.problem.descriptor=JUnit <code>#ref()</code> methods not declared 'static' #loc
1067 simplifiable.junit.assertion.problem.descriptor=<code>#ref()</code> can be simplified to ''{0}'' #loc
1068 test.method.without.assertion.problem.descriptor=JUnit test method <code>#ref()</code> contains no assertions #loc
1069 test.case.with.no.test.methods.problem.descriptor=JUnit test case <code>#ref</code> has no tests #loc
1070 test.case.in.product.code.problem.descriptor=Test case <code>#ref</code> should probably be placed in a test source tree #loc
1071 test.method.in.product.code.problem.descriptor=Test method <code>.#ref()</code> should probably be placed in a test source tree #loc
1072 unconstructable.test.case.problem.descriptor=Test case <code>#ref</code> is not constructable by most test runners #loc
1073 deserializable.class.in.secure.context.problem.descriptor=Class <code>#ref</code> may be deserialized, compromising security #loc
1074 serializable.class.in.secure.context.problem.descriptor=Class <code>#ref</code> may be serialized, compromising security #loc
1075 cloneable.class.in.secure.context.problem.descriptor=Class <code>#ref</code> may be cloned, compromising security #loc
1076 non.final.clone.problem.descriptor=Non-final <code>#ref()</code> method, compromising security #loc
1077 non.static.inner.class.in.secure.context.problem.descriptor=Non-'static' inner class <code>#ref</code>, compromising security #loc
1078 runtime.exec.with.non.constant.string.problem.descriptor=Call to <code>Runtime.#ref()</code> with non-constant argument #loc
1079 load.library.with.non.constant.string.problem.descriptor=Call to <code>{0}.#ref()</code> with non-constant argument #loc
1080 jdbc.execute.with.non.constant.string.problem.descriptor=Call to <code>Statement.#ref()</code> with non-constant argument #loc
1081 jdbc.prepare.statement.with.non.constant.string.problem.descriptor=Call to <code>Connection.#ref()</code> with non-constant argument #loc
1082 custom.classloader.problem.descriptor=Custom ClassLoader class <code>#ref</code> #loc
1083 custom.security.manager.problem.descriptor=Custom SecurityManager class <code>#ref</code> #loc
1084 system.set.problem.descriptor=Call to <code>System.#ref()</code> may pose security concerns #loc
1085 class.loader.instantiation.problem.descriptor=Instantiation of <code>#ref</code> may pose security concerns #loc
1086 public.static.array.field.problem.descriptor='public static' array field <code>#ref</code>, compromising security #loc
1087 public.static.collection.field.problem.descriptor='public static' collection field <code>#ref</code>, compromising security #loc
1088 abstract.class.with.only.one.direct.inheritor.problem.descriptor=Abstract class <code>#ref</code> has only one direct inheritor #loc
1089
1090 #other
1091 abstract.method.overrides.abstract.method.remove.quickfix=Remove redundant abstract method declaration
1092 class.may.be.interface.convert.quickfix=Convert class to interface
1093 class.without.constructor.create.quickfix=Generate empty constructor
1094 class.without.no.arg.constructor.ignore.option=Ignore if class has default constructor
1095 extends.annotation.problem.descriptor=Class ''{0}'' implements annotation interface <code>#ref</code> #loc
1096 extends.annotation.interface.problem.descriptor=Interface ''{0}'' extends annotation interface <code>#ref</code> #loc
1097 extends.concrete.collection.problem.descriptor=Class <code>#ref</code> explicitly extends ''{0}'' #loc
1098 anonymous.extends.concrete.collection.problem.descriptor=Anonymous class explicitly extends ''{0}'' #loc
1099 inner.class.on.interface.ignore.option=Ignore inner interfaces of interfaces
1100 inner.class.on.interface.problem.descriptor=Interface ''{0}'' has inner class <code>#ref</code> #loc
1101 missing.deprecated.annotation.add.quickfix=Add @Deprecated annotation
1102 missing.override.annotation.add.quickfix=Add @Override annotation
1103 non.protected.constructor.in.abstract.class.ignore.option=Ignore for non-public classes
1104 public.constructor.in.non.public.class.problem.descriptor=Constructor is declared <code>#ref</code> in non-public class ''{0}'' #loc
1105 static.inheritance.replace.quickfix=Replace inheritance with qualified references in {0}
1106 utility.class.with.public.constructor.make.quickfix=Make {0, choice, 1#constructor|2#constructors} 'private'
1107 utility.class.without.private.constructor.create.quickfix=Generate empty 'private' constructor
1108 utility.class.without.private.constructor.make.quickfix=Make constructor 'private'
1109 naming.convention.problem.descriptor.short={0} name <code>#ref</code> is too short ({1} < {2}) #loc
1110 naming.convention.problem.descriptor.long={0} name <code>#ref</code> is too long ({1} > {2}) #loc
1111 naming.convention.problem.descriptor.regex.mismatch={0} name <code>#ref</code> doesn''t match regex ''{1}'' #loc
1112 constant.naming.convention.immutables.option=Only check 'static final' fields with immutable types
1113 local.variable.naming.convention.ignore.option=Ignore for-loop parameters
1114 local.variable.naming.convention.ignore.catch.option=Ignore 'catch' block parameters
1115 method.names.differ.only.by.case.problem.descriptor=Method name <code>#ref</code> and method name ''{0}'' differ only by case #loc
1116 parameter.name.differs.from.overridden.parameter.ignore.character.option=Ignore if overridden parameter contains only one character
1117 parameter.name.differs.from.overridden.parameter.ignore.library.option=Ignore if overridden parameter is from a library
1118 parameter.name.differs.from.overridden.parameter.problem.descriptor=Parameter name <code>#ref</code> is different from parameter ''{0}'' overridden #loc
1119 questionable.name.column.title=Name
1120 standard.variable.names.problem.descriptor=Variable named <code>#ref</code> doesn''t have type ''{0}'' #loc
1121 standard.variable.names.problem.descriptor2=Variable named <code>#ref</code> doesn''t have type ''{0}'' or ''{1}'' #loc
1122 standard.variable.names.ignore.override.option=Ignore for parameter names identical to super method parameters
1123 static.variable.naming.convention.mutable.option=Check 'static final' fields with a mutable type
1124 boolean.method.name.must.start.with.question.table.column.name=Boolean method name prefix
1125 conditional.expression.with.identical.branches.collapse.quickfix=Collapse conditional expression
1126 conditional.expression.with.identical.branches.push.inside.quickfix=Push conditional inside expression
1127 conditional.expression.with.identical.branches.collapse.quickfix.family=Conditional expression can be simplified
1128 confusing.else.unwrap.quickfix=Remove redundant 'else'
1129 constant.conditional.expression.problem.descriptor=<code>#ref</code> can be simplified to ''{0}'' #loc
1130 constant.conditional.expression.simplify.quickfix=Simplify
1131 enum.switch.statement.which.misses.cases.problem.descriptor=<code>#ref</code> statement on enumerated type ''{0}'' misses cases #loc
1132 for.loop.replaceable.by.while.ignore.option=Ignore 'infinite' for loops without conditions
1133 for.loop.replaceable.by.while.replace.quickfix=Replace with 'while'
1134 for.loop.with.missing.component.problem.descriptor1=<code>#ref</code> statement lacks initializer #loc
1135 for.loop.with.missing.component.problem.descriptor2=<code>#ref</code> statement lacks condition #loc
1136 for.loop.with.missing.component.problem.descriptor3=<code>#ref</code> statement lacks update #loc
1137 for.loop.with.missing.component.problem.descriptor4=<code>#ref</code> statement lacks initializer and condition #loc
1138 for.loop.with.missing.component.problem.descriptor5=<code>#ref</code> statement lacks initializer and update #loc
1139 for.loop.with.missing.component.problem.descriptor6=<code>#ref</code> statement lacks condition and update #loc
1140 for.loop.with.missing.component.problem.descriptor7=<code>#ref</code> statement lacks initializer, condition and update #loc
1141 if.statement.with.identical.branches.collapse.quickfix=Collapse 'if' statement
1142 foreach.replace.quickfix=Replace with 'foreach'
1143 unnecessary.boxing.remove.quickfix=Remove boxing
1144 unnecessary.unboxing.remove.quickfix=Remove unboxing
1145 misordered.assert.equals.arguments.flip.quickfix=Flip compared arguments
1146 simplify.junit.assertion.simplify.quickfix=Simplify assertion
1147 test.method.is.public.void.no.arg.problem.descriptor1=Test method <code>#ref()</code> should probably not have parameters #loc
1148 test.method.is.public.void.no.arg.problem.descriptor2=Test method <code>#ref()</code> is not declared 'public void' #loc
1149 test.method.is.public.void.no.arg.problem.descriptor3=Test method <code>#ref()</code> should not be 'static' #loc
1150 system.properties.problem.descriptor=Call to <code>Integer.#ref()</code> may pose security concerns #loc
1151 system.properties.problem.descriptor1=Call to <code>Boolean.#ref()</code> may pose security concerns #loc
1152 unsecure.random.number.generation.problem.descriptor1=For security purposes, use 'java.security.SecureRandom' instead of <code>java.lang.Math.#ref()</code> #loc
1153 unsecure.random.number.generation.problem.descriptor2=For security purposes, use 'java.security.SecureRandom' instead of <code>java.util.#ref</code> #loc
1154 unsecure.random.number.generation.problem.descriptor3=For security purposes, use 'java.security.SecureRandom' instead of <code>#ref</code> #loc
1155 serializable.has.serialization.methods.problem.descriptor=Serializable class <code>#ref</code> does not define 'readObject()' or 'writeObject()' #loc
1156 serializable.has.serialization.methods.problem.descriptor1=Serializable class <code>#ref</code> does not define 'writeObject()' #loc
1157 serializable.has.serialization.methods.problem.descriptor2=Serializable class <code>#ref</code> does not define 'readObject()' #loc
1158 serializable.with.unconstructable.ancestor.problem.descriptor=<code>#ref</code> has a non-serializable ancestor ''{0}'' without no-arg constructor #loc
1159 transient.field.in.non.serializable.class.problem.descriptor=Field ''{0}'' is marked <code>#ref</code>, in non-Serializable class #loc
1160 transient.field.in.non.serializable.class.remove.quickfix=Remove 'transient'
1161 condition.signal.replace.quickfix=Replace with 'signalAll()'
1162 object.notify.replace.quickfix=Replace with 'notifyAll()'
1163 safe.lock.problem.descriptor=''{0}'' should be locked in front of a ''try'' block and unlocked in the corresponding ''finally'' block #loc
1164 synchronized.method.problem.descriptor=Method ''{0}()'' declared <code>#ref</code> #loc
1165 synchronized.method.include.option=Include native methods
1166 synchronized.method.ignore.synchronized.super.option=Ignore methods overriding a synchronized method
1167 synchronized.method.move.quickfix=Move synchronization into method
1168 thread.run.replace.quickfix=Replace with 'start()'
1169 volatile.field.problem.descriptor=Volatile field <code>#ref</code> of type ''{0}'' #loc
1170 string.format.choose.class=Choose Formatter class
1171 string.format.class.column.name=Additional formatter classes
1172 string.format.class.method.name=Additional formatter methods
1173 exception.class.column.name=Exception class
1174 bad.exception.thrown.problem.descriptor=Prohibited exception ''{0}'' thrown #loc
1175 empty.catch.block.comments.option=Comments count as content
1176 empty.catch.block.ignore.ignore.option=Ignore when 'catch' parameter is named 'ignore' or 'ignored'
1177 too.broad.catch.problem.descriptor=''catch'' of <code>#ref</code> is too broad, masking exception ''{0}'' #loc
1178 too.broad.catch.problem.descriptor1=''catch'' of <code>#ref</code> is too broad, masking exceptions ''{0}'' and ''{1}'' #loc
1179 unused.catch.parameter.ignore.catch.option=Ignore when 'catch' block contains a comment
1180 add.serialversionuidfield.quickfix=Add 'serialVersionUID' field
1181 delete.import.quickfix=Delete unnecessary import
1182 encapsulate.variable.quickfix=Encapsulate field ''{0}''
1183 extract.method.quickfix=Extract method
1184 inline.call.quickfix=Inline call
1185 inline.variable.quickfix=Inline variable
1186 pointless.nullcheck.display.name=Unnecessary 'null' check before 'instanceof' expression
1187 pointless.nullcheck.problem.descriptor=Unnecessary 'null' check before 'instanceof' expression
1188 pointless.nullcheck.after.problem.descriptor=Unnecessary 'null' check after 'instanceof' expression
1189 pointless.nullcheck.simplify.quickfix=Remove unnecessary ''{0}'' condition
1190 introduce.constant.quickfix=Introduce constant
1191 make.initialization.explicit.quickfix=Make initialization explicit
1192 move.anonymous.to.inner.quickfix=Convert to named inner class
1193 anonymous.inner.may.be.named.static.inner.class.quickfix=Convert to named 'static' inner class
1194 move.class.quickfix=Move class
1195 normalize.declaration.quickfix=Split into multiple declarations
1196 remove.modifier.quickfix=Remove ''{0}'' modifier
1197 replace.inheritance.with.delegation.quickfix=Replace inheritance with delegation
1198 big.decimal.equals.replace.quickfix=Replace with 'compareTo()==0'
1199 cast.that.loses.precision.problem.descriptor=Cast to <code>#ref</code> from ''{0}'' may result in loss of precision #loc
1200 comparison.to.nan.problem.descriptor1=Comparison to <code>#ref</code> is always false #loc
1201 comparison.to.nan.problem.descriptor2=Comparison to <code>#ref</code> is always true #loc
1202 comparison.to.nan.replace.quickfix=Replace with 'isNaN()'
1203 confusing.floating.point.literal.change.quickfix=Change to canonical form
1204 implicit.numeric.conversion.ignore.widening.conversion.option=Ignore widening conversions
1205 implicit.numeric.conversion.ignore.char.conversion.option=Ignore conversions from and to char
1206 implicit.numeric.conversion.ignore.constant.conversion.option=Ignore conversions from constants and literals
1207 implicit.numeric.conversion.problem.descriptor=Implicit numeric conversion of <code>#ref</code> from ''{0}'' to ''{1}'' #loc
1208 implicit.numeric.conversion.convert.quickfix=Convert to ''{0}''
1209 implicit.numeric.conversion.make.explicit.quickfix=Make conversion explicit
1210 long.literals.ending.with.lowercase.l.replace.quickfix=Replace 'l' with 'L'
1211 non.reproducible.math.call.replace.quickfix=Replace with 'StrictMath' call
1212 overly.complex.arithmetic.expression.max.number.option=Maximum number of terms:
1213 expression.can.be.replaced.problem.descriptor=<code>#ref</code> can be replaced with ''{0}'' #loc
1214 method.complexity.limit.option=Method complexity limit:
1215 cyclomatic.complexity.problem.descriptor=Overly complex method <code>#ref()</code> (cyclomatic complexity = {0}) #loc
1216 method.coupling.limit.option=Method coupling limit:
1217 method.coupling.problem.descriptor=<code>#ref</code> is overly coupled (# referenced classes = {0}) #loc
1218 method.with.multiple.loops.problem.descriptor=<code>#ref</code> contains {0} loops #loc
1219 return.point.limit.option=&Return point limit:
1220 multiple.return.points.per.method.problem.descriptor=<code>#ref</code> has {0} return points #loc
1221 nesting.depth.limit.option=Nesting depth limit:
1222 nesting.depth.problem.descriptor=<code>#ref</code> is overly nested (maximum nesting depth = {0}) #loc
1223 non.comment.source.statements.limit.option=Non-comment source statements limit:
1224 non.comment.source.statements.problem.descriptor=<code>#ref</code> is too long (# Non-comment source statements = {0}) #loc
1225 parameters.per.method.problem.descriptor=<code>#ref()</code> has too many parameters (num parameters = {0}) #loc
1226 parameters.per.constructor.problem.descriptor=<code>#ref()</code> has too many parameters (num parameters = {0}) #loc
1227 parameter.limit.option=Parameter limit:
1228 constructor.visibility.option=Ignore constructors with visibility:
1229 three.negations.per.method.ignore.option=Ignore negations in 'equals()' methods
1230 three.negations.per.method.ignore.assert.option=Ignore negations in 'assert' statements
1231 three.negations.per.method.problem.descriptor=<code>#ref</code> contains {0} negations #loc
1232 thrown.exceptions.per.method.problem.descriptor=<code>#ref</code> has too many exceptions declared (num exceptions = {0}) #loc
1233 thrown.exceptions.per.method.limit.option=Exceptions thrown limit:
1234 call.to.simple.getter.in.class.ignore.option=Ignore getter calls on other objects
1235 call.to.private.simple.getter.in.class.option=Only report getter is 'private'
1236 call.to.simple.getter.in.class.inline.quickfix=Inline call to getter
1237 call.to.simple.setter.in.class.ignore.option=Ignore setter calls on other objects
1238 call.to.private.setter.in.class.option=Only report when setter is 'private'
1239 call.to.simple.setter.in.class.inline.quickfix=Inline call to setter
1240 make.static.quickfix=Make 'static'
1241 length.one.strings.in.concatenation.replace.quickfix=Replace with character
1242 multiply.or.divide.by.power.of.two.replace.quickfix=Replace with shift
1243 boolean.expression.can.be.simplified.problem.descriptor=<code>#ref</code> can be simplified to ''{0}'' #loc
1244 trivial.string.concatenation.problem.descriptor=Empty string used in concatenation
1245 string.replace.quickfix=Replace concatenation with ''{0}''
1246 instantiating.object.to.get.class.object.replace.quickfix=Replace with direct class object access
1247 manual.array.copy.replace.quickfix=Replace with 'System.arraycopy()'
1248 manual.array.to.collection.copy.replace.quickfix=Replace with 'Collections.addAll(...,...)'
1249 method.may.be.static.only.option=Only check 'private' or 'final' methods
1250 method.may.be.static.empty.option=Ignore empty methods
1251 random.double.for.random.integer.replace.quickfix=Replace with 'nextInt()'
1252 string.buffer.replaceable.by.string.builder.replace.quickfix=Replace with 'StringBuilder'
1253 string.buffer.to.string.in.concatenation.remove.quickfix=Remove 'toString()'
1254 string.concatenation.in.loops.only.option=Only warn if string is repeatedly appended
1255 string.concatenation.inside.string.buffer.append.replace.quickfix=Replace with chained 'append()' calls
1256 string.equals.empty.string.quickfix=Replace with 'length()==0'
1257 string.equals.empty.string.isempty.quickfix=Replace with 'isEmpty()'
1258 tail.recursion.replace.quickfix=Replace tail recursion with iteration
1259 if.statement.with.too.many.branches.max.option=Maximum number of branches:
1260 if.statement.with.too.many.branches.problem.descriptor=<code>#ref</code> has too many branches ({0}) #loc
1261 negated.conditional.ignore.option=Ignore '!= null' comparisons
1262 negated.conditional.invert.quickfix=Invert condition
1263 negated.if.else.ignore.negated.null.option=Ignore '!= null' comparisons
1264 negated.if.else.ignore.negated.zero.option=Ignore '!= 0' comparisons
1265 negated.if.else.invert.quickfix=Invert 'if' condition
1266 overly.complex.boolean.expression.max.terms.option=Maximum number of terms:
1267 pointless.boolean.expression.ignore.option=Ignore named constants in determining pointless expressions
1268 simplifiable.conditional.expression.problem.descriptor=<code>#ref</code> can be simplified to ''{0}'' #loc
1269 simplifiable.if.statement.problem.descriptor=<code>#ref</code> statement can be replaced with ''{0}'' #loc
1270 switch.statement.density.min.option=Minimum density of branches: %
1271 switch.statement.density.problem.descriptor=<code>#ref</code> has too low of a branch density ({0}%) #loc
1272 switch.statement.with.too.few.branches.min.option=Minimum number of branches:
1273 switch.statement.with.too.few.branches.problem.descriptor=<code>#ref</code> has too few branches ({0}), and should probably be replaced with an ''if'' statement #loc
1274 switch.statement.without.default.ignore.option=Ignore if all cases of an enumerated type are covered
1275 unnecessary.label.remove.quickfix=Remove label
1276 unnecessary.return.problem.descriptor=<code>#ref</code> is unnecessary as the last statement in a 'void' method #loc
1277 unnecessary.return.constructor.problem.descriptor=<code>#ref</code> is unnecessary as the last statement in a constructor #loc
1278 unused.label.remove.quickfix=Remove unused label
1279 unnecessarily.qualified.static.usage.problem.descriptor=Unnecessarily qualified static method call <code>{0}()</code> #loc
1280 unnecessarily.qualified.static.usage.problem.descriptor1=Unnecessarily qualified static access <code>{0}</code> #loc
1281 unnecessarily.qualified.static.usage.ignore.field.option=Ignore unnecessarily qualified field accesses
1282 unnecessarily.qualified.static.usage.ignore.method.option=Ignore unnecessarily qualified method calls
1283 unnecessary.interface.modifier.problem.descriptor=Modifier <code>#ref</code> is redundant for interfaces #loc
1284 unnecessary.interface.modifier.inner.interface.of.interface.problem.descriptor=Modifier <code>#ref</code> is redundant for inner interfaces #loc
1285 unnecessary.interface.modifier.problem.descriptor2=Modifier <code>#ref</code> is redundant for interface methods #loc
1286 unnecessary.interface.modifier.problem.descriptor3=Modifier <code>#ref</code> is redundant for inner classes of interfaces #loc
1287 unnecessary.interface.modifier.problem.descriptor4=Modifier <code>#ref</code> is redundant for interface fields #loc
1288 smth.unnecessary.remove.quickfix=Remove unnecessary ''{0}''
1289 unqualified.static.usage.problem.descriptor=Unqualified static method call <code>#ref()</code> #loc
1290 unqualified.static.usage.problem.descriptor1=Unqualified static field access <code>#ref</code> #loc
1291 unqualified.static.usage.ignore.field.option=Ignore unqualified field accesses
1292 unqualified.static.usage.ignore.method.option=Ignore unqualified method calls
1293 unqualified.static.usage.qualify.field.quickfix=Qualify static field access
1294 unqualified.static.usage.qualify.method.quickfix=Qualify static method call
1295 too.broad.scope.allow.option=<html>Report variables with a new expression as initializer<br>(Potentially unsafe: quick fix may modify semantics if the constructor has non-local side-effects)</html>
1296 too.broad.scope.only.blocks.option=Only report variables that can be moved into inner blocks
1297 too.broad.scope.narrow.quickfix=Move declaration of ''{0}'' closer to usages
1298 press.escape.to.remove.highlighting.message=Press Escape to remove the highlighting
1299 unnecessary.enum.modifier.problem.descriptor=Modifier <code>#ref</code> is redundant for enum constructors #loc
1300 unnecessary.enum.modifier.problem.descriptor1=Modifier <code>#ref</code> is redundant for inner enums #loc
1301 literal.as.arg.to.string.equals.problem.descriptor=<code>#ref</code> is argument of ''{0}()'', instead of its target #loc
1302 literal.as.arg.to.string.equals.flip.quickfix=Flip 'equals()'
1303 c.style.array.declaration.replace.quickfix=Replace with Java-style array declaration
1304 chained.method.call.ignore.option=Ignore chained method calls in field initializers
1305 chained.method.call.ignore.this.super.option=Ignore chained method calls in 'this()' and 'super()' calls
1306 introduce.variable.quickfix=Introduce variable
1307 introduce.variable.may.change.semantics.quickfix=Introduce variable (may change semantics)
1308 flip.comparison.quickfix=Flip comparison
1309 control.flow.statement.without.braces.add.quickfix=Add braces to statement
1310 control.flow.statement.without.braces.message=Add braces to ''{0}'' statement
1311 extends.object.remove.quickfix=Remove redundant 'extends Object'
1312 implicit.call.to.super.ignore.option=Ignore for direct subclasses of 'java.lang.Object'
1313 implicit.call.to.super.make.explicit.quickfix=Make call to 'super()' explicit
1314 missorted.modifiers.require.option=Require annotations to be sorted before keywords
1315 missorted.modifiers.sort.quickfix=Sort modifiers
1316 nested.method.call.ignore.option=Ignore nested method calls in field initializers
1317 ignore.calls.to.static.methods=Ignore calls to static methods
1318 ignore.calls.to.property.getters=Ignore calls to property getters
1319 redundant.field.initialization.remove.quickfix=Remove initializer
1320 redundant.implements.remove.quickfix=Remove redundant interface declaration
1321 unnecessary.constructor.remove.quickfix=Remove redundant constructor
1322 unnecessary.fully.qualified.name.replace.quickfix=Replace with import
1323 unnecessary.fully.qualified.name.remove.quickfix=Remove qualification
1324 unnecessary.fully.qualified.name.status.bar.escape.highlighting.message={0} fully qualified {0, choice, 1#name|2#names} replaced with import (press Escape to remove highlighting)
1325 unnecessary.parentheses.remove.quickfix=Remove unnecessary parentheses
1326 unnecessary.qualifier.for.this.remove.quickfix=Remove unnecessary qualifier
1327 unnecessary.semicolon.remove.quickfix=Remove unnecessary semicolon
1328 unnecessary.super.constructor.remove.quickfix=Remove unnecessary 'super()'
1329 unnecessary.this.remove.quickfix=Remove unnecessary 'this' qualifier
1330 overly.strong.type.cast.problem.descriptor=Cast to <code>#ref</code> can be weakened to ''{0}'' #loc
1331 field.count.inspection.include.constant.fields.in.count.checkbox=Include constant fields in count
1332 field.count.inspection.static.final.fields.count.as.constant.checkbox='static final' fields count as constant
1333 field.count.inspection.include.enum.constants.in.count=Include enum constants in count
1334 make.method.final.fix.name=Make method ''{0}()'' ''final''
1335 make.class.final.fix.name=Make class ''{0}'' ''final''
1336 non.boolean.method.name.must.not.start.with.question.display.name=Non-boolean method name must not start with question word
1337 non.boolean.method.name.must.not.start.with.question.problem.descriptor=Non-boolean method name <code>#ref</code> starts with a question word #loc
1338 boolean.constructor.simplify.quickfix=Simplify
1339 unnecessary.temporary.on.conversion.from.string.problem.descriptor=<code>#ref</code> #loc can be simplified to ''{0}''
1340 unnecessary.temporary.on.conversion.from.string.fix.name=Replace with ''{0}''
1341 only.report.qualified.static.usages.option=Only report qualified static access from a static context
1342 unqualified,static.usage.only.report.static.usages.option=Only report static access from a non-static context
1343 assignment.to.catch.block.parameter.problem.descriptor=Assignment to 'catch' block parameter <code>#ref</code> #loc
1344 assignment.to.method.parameter.problem.descriptor=Assignment to method parameter <code>#ref</code> #loc
1345 value.of.post.increment.problem.descriptor=Value of post-increment expression <code>#ref</code> is used #loc
1346 value.of.post.decrement.problem.descriptor=Value of post-decrement expression <code>#ref</code> is used #loc
1347 value.of.pre.increment.problem.descriptor=Value of pre-increment expression <code>#ref</code> is used #loc
1348 value.of.pre.decrement.problem.descriptor=Value of pre-decrement expression <code>#ref</code> is used #loc
1349 assignment.replaceable.with.operator.assignment.problem.descriptor=<code>#ref</code> could be simplified to ''{0}'' #loc
1350 assignment.replaceable.with.operator.assignment.ignore.conditional.operators.option=Ignore conditional operators
1351 assignment.replaceable.with.operator.assignment.ignore.obscure.operators.option=Ignore the obscure ^ and % operators
1352 assignment.replaceable.with.operator.replace.quickfix=Replace ''='' with ''{0}=''
1353 object.equality.ignore.between.objects.of.a.type.with.only.private.constructors.option=Ignore '==' between objects of a type with only 'private' constructors
1354 redundant.method.override.display.name=Method is identical to its super method
1355 redundant.method.override.problem.descriptor=Method <code>#ref()</code> is identical to its super method #loc
1356 redundant.method.override.quickfix=Remove redundant method
1357 refused.bequest.problem.descriptor=Method <code>#ref()</code> does not call 'super.#ref()' #loc
1358 refused.bequest.ignore.empty.super.methods.option=Ignore empty super methods
1359 overly.complex.boolean.expression.ignore.option=Ignore pure conjunctions and disjunctions
1360 pointless.indexof.comparison.display.name=Pointless 'indexOf()' comparison
1361 pointless.indexof.comparison.always.true.problem.descriptor=<code>#ref</code> is always true #loc
1362 pointless.indexof.comparison.always.false.problem.descriptor=<code>#ref</code> is always false #loc
1363 reuse.of.local.variable.problem.descriptor=Reuse of local variable <code>#ref</code> #loc
1364 single.character.startswith.display.name=Single character 'startsWith()' or 'endsWith()'
1365 single.character.startswith.problem.descriptor=Single character <code>#ref()</code> could be replaced with 'charAt()' expression #loc
1366 indexof.replaceable.by.contains.display.name='indexOf()' expression is replaceable with 'contains()'
1367 replace.indexof.with.contains.quickfix=Replace 'indexOf()' with 'contains()'
1368 overloaded.methods.with.same.number.parameters.problem.descriptor=Multiple methods named <code>#ref</code> with the same number of parameters #loc
1369 overloaded.vararg.method.problem.descriptor=Overloaded variable argument method <code>#ref()</code> #loc
1370 overloaded.vararg.constructor.problem.descriptor=Overloaded variable argument constructor <code>#ref()</code> #loc
1371 cached.number.constructor.call.display.name=Number constructor call with primitive argument
1372 cached.number.constructor.call.problem.descriptor=Number constructor call with primitive argument #loc
1373 cached.number.constructor.call.quickfix=Replace with ''{0}.valueOf()'' call
1374 cached.number.constructor.call.ignore.string.arguments.option=Ignore new number expressions with a String argument
1375 chained.equality.comparisons.problem.descriptor=Chained equality comparison <code>#ref</code> #loc
1376 confusing.octal.escape.sequence.problem.descriptor=Octal escape sequence <code>#ref</code> immediately followed by digit #loc
1377 field.accessed.synchronized.and.unsynchronized.option=Simple getters and setters are considered field accesses too
1378 method.overrides.package.local.method.display.name=Method overrides package-private method of superclass located in other package
1379 method.overrides.package.local.method.problem.descriptor=Method <code>#ref()</code> overrides a package-private method of a superclass located in another package #loc
1380 suspicious.to.array.call.display.name=Suspicious 'Collection.toArray()' call
1381 suspicious.to.array.call.problem.descriptor=Array of type ''{0}[]'' expected #loc
1382 suspicious.system.arraycopy.display.name=Suspicious 'System.arraycopy()' call
1383 suspicious.system.arraycopy.problem.descriptor1=Parameter 'srcPos' may not be negative #loc
1384 suspicious.system.arraycopy.problem.descriptor2=Parameter 'destPos' may not be negative #loc
1385 suspicious.system.arraycopy.problem.descriptor3=Parameter 'length' may not be negative #loc
1386 suspicious.system.arraycopy.problem.descriptor4=<code>#ref</code> is not of an array type #loc
1387 suspicious.system.arraycopy.problem.descriptor5=<code>#ref</code> is not of an array type #loc
1388 suspicious.system.arraycopy.problem.descriptor6=Source parameter type ''{0}'' is not assignable to destination parameter <code>#ref</code> of type ''{1}'' #loc
1389 raw.use.of.parameterized.type.ignore.new.objects.option=Ignore construction of new objects
1390 raw.use.of.parameterized.type.ignore.type.casts.option=Ignore type casts
1391 raw.use.of.parameterized.type.ignore.uncompilable.option=Ignore where a type parameter would not compile
1392 raw.use.of.parameterized.type.ignore.overridden.parameter.option=Ignore parameter types of overriding methods
1393 method.only.used.from.inner.class.display.name=Private method only used from inner class
1394 method.only.used.from.inner.class.problem.descriptor.anonymous.extending=Method <code>#ref()</code>#loc is only used from an anonymous class extending ''{0}'' #loc
1395 method.only.used.from.inner.class.problem.descriptor.anonymous.implementing=Method <code>#ref()</code>#loc is only used from an anonymous class implementing ''{0}'' #loc
1396 method.only.used.from.inner.class.problem.descriptor=Method <code>#ref()</code>#loc is only used from inner class ''{0}'' #loc
1397 method.only.used.from.inner.class.ignore.option=Ignore methods accessed from an &anonymous class
1398 ignore.static.methods.accessed.from.a.non.static.inner.class=Ignore '&static' methods accessed from a non-'static' inner class
1399 only.report.static.methods=&Only report 'static' methods
1400 format.decode.error.requires.both.0.and.1=requires both {0} and {1}
1401 format.decode.any=any
1402 format.decode.date.time=Date/Time
1403 format.decode.char=char
1404 format.decode.integer.type=integer type
1405 format.decode.floating.point=floating point
1406 single.character.startswith.quickfix=Replace with 'charAt()'
1407 interface.never.implemented.option=Ignore interfaces which only declare constants
1408 size.replaceable.by.isempty.display.name='size() == 0' replaceable with 'isEmpty()'
1409 size.replaceable.by.isempty.quickfix=Replace with 'isEmpty()'
1410 size.replaceable.by.isempty.negation.ignore.option=Ignore expressions which would be replaced with '!isEmpty()'
1411 ignored.classes.table=Ignored classes
1412 choose.class.type.to.ignore=Choose class type to ignore
1413 loop.condition.not.updated.inside.loop.display.name=Loop variable not updated inside loop
1414 loop.variable.not.updated.inside.loop.problem.descriptor=Variable '#ref' is not updated inside loop #loc
1415 loop.condition.not.updated.inside.loop.problem.descriptor=Condition '#ref' is not updated inside loop #loc
1416 utility.class.without.private.constructor.option=Ignore classes with only a main method
1417 super.class.logger.option=Ignore classes with an accessible logger declared in a superclass
1418 static.method.only.used.in.one.class.display.name='static' method only used from one other class
1419 static.method.only.used.in.one.class.problem.descriptor='static' method <code>#ref()</code> is only used from class ''{0}'' #loc
1420 static.method.only.used.in.one.class.problem.descriptor.anonymous.implementing='static' method <code>#ref()</code> is only used from an anonymous class implementing ''{0}'' #loc
1421 static.method.only.used.in.one.class.problem.descriptor.anonymous.extending='static' method <code>#ref()</code> is only used from an anonymous class extending ''{0}'' #loc
1422 static.method.only.used.in.one.class.quickfix=Move method
1423 static.method.only.used.in.one.class.ignore.test.option=Ignore when only used from a test class
1424 static.method.only.used.in.one.class.ignore.anonymous.option=Ignore when only used from an anonymous class
1425 static.method.only.used.in.one.class.ignore.on.conflicts=Ignore when the method cannot be moved without conflicts
1426 unary.plus.display.name=Unary plus
1427 unary.plus.problem.descriptor=Unary <code>#ref</code> operator #loc
1428 await.without.corresponding.signal.display.name='await()' without corresponding 'signal()'
1429 await.without.corresponding.signal.problem.descriptor=Call to <code>#ref</code> without corresponding <code>signal()</code> or <code>signalAll()</code> #loc
1430 signal.without.corresponding.await.display.name='signal()' without corresponding 'await()'
1431 signal.without.corresponding.await.problem.descriptor=Call to <code>#ref</code> without corresponding <code>await()</code> #loc
1432 wait.without.corresponding.notify.display.name='wait()' without corresponding 'notify()'
1433 wait.without.corresponding.notify.problem.descriptor=Call to <code>#ref</code> without corresponding <code>notify()</code> or <code>notifyAll()</code> #loc
1434 notify.without.corresponding.wait.display.name='notify()' without corresponding 'wait()'
1435 notify.without.corresponding.wait.problem.descriptor=Call to <code>#ref</code> without corresponding <code>wait()</code> #loc
1436 integer.multiplication.implicit.cast.to.long.display.name=Integer multiplication or shift implicitly cast to long
1437 integer.multiplication.implicit.cast.to.long.problem.descriptor=#ref: integer multiplication implicitly cast to long #loc
1438 integer.shift.implicit.cast.to.long.problem.descriptor=#ref: integer shift implicitly cast to long #loc
1439 integer.multiplication.implicit.cast.to.long.option=<html>Ignore compile time constant expressions which do not overflow</html>
1440 wait.or.await.without.timeout.display.name='wait()' or 'await()' without timeout
1441 wait.or.await.without.timeout.problem.descriptor=<code>#ref</code> without timeout #loc
1442 method.return.always.constant.display.name=Method returns per-class constant
1443 method.return.always.constant.problem.descriptor=Method <code>#ref()</code> returns a per-class constant
1444 class.with.too.many.dependencies.display.name=Class with too many dependencies
1445 class.with.too.many.dependencies.problem.descriptor=Class ''{0}'' has too many dependencies ({1} > {2})
1446 class.with.too.many.transitive.dependencies.display.name=Class with too many transitive dependencies
1447 class.with.too.many.transitive.dependencies.problem.descriptor=Class ''{0}'' has too many transitive dependencies ({1} > {2})
1448 class.with.too.many.dependents.display.name=Class with too many dependents
1449 class.with.too.many.dependents.problem.descriptor=Class ''{0}'' has too many dependents ({1} > {2})
1450 class.with.too.many.transitive.dependents.display.name=Class with too many transitive dependents
1451 class.with.too.many.transitive.dependents.problem.descriptor=Class ''{0}'' has too many transitive dependencies ({1} > {2})
1452 class.with.too.many.dependencies.max.option=Maximum number of dependencies
1453 class.with.too.many.dependents.max.option=Maximum number of dependents
1454 class.with.too.many.transitive.dependencies.max.option=Maximum number of transitive dependencies
1455 class.with.too.many.transitive.dependents.max.option=Maximum number of transitive dependents
1456 cyclic.class.dependency.display.name=Cyclic class dependency
1457 cyclic.class.dependency.problem.descriptor=Class ''{0}'' is cyclically dependent on {1} other classes
1458 cyclic.class.dependency.1.problem.descriptor=Class ''{0}'' is cyclically dependent on class ''{1}''
1459 cyclic.class.dependency.2.problem.descriptor=Class ''{0}'' is cyclically dependent on classes ''{1}'' and ''{2}''
1460 cyclic.package.dependency.display.name=Cyclic package dependency
1461 cyclic.package.dependency.problem.descriptor=Package ''{0}'' is cyclically dependent on {1} other packages
1462 cyclic.package.dependency.1.problem.descriptor=Package ''{0}'' is cyclically dependent on package ''{1}''
1463 cyclic.package.dependency.2.problem.descriptor=Package ''{0}'' is cyclically dependent on packages ''{1}'' and ''{2}''
1464 class.unconnected.to.package.display.name=Class independent of its package
1465 class.unconnected.to.package.problem.descriptor=Class <code>#ref</code> has no dependencies or dependents in its package
1466 package.with.too.many.classes.display.name=Package with too many classes
1467 package.with.too.many.classes.problem.descriptor=Package ''{0}'' contains too many classes ({1} > {2})
1468 package.with.too.many.classes.max.option=Maximum number of classes:
1469 package.with.too.few.classes.display.name=Package with too few classes
1470 package.with.too.few.classes.problem.descriptor=Package ''{0}'' contains too few classes ({1} < {2})
1471 package.with.too.few.classes.min.option=Minimum number of classes:
1472 module.with.too.many.classes.display.name=Module with too many classes
1473 module.with.too.many.classes.problem.descriptor=Module ''{0}'' contains too many classes ({1} > {2})
1474 module.with.too.many.classes.max.option=Maximum number of classes:
1475 module.with.too.few.classes.display.name=Module with too few classes
1476 module.with.too.few.classes.problem.descriptor=Module ''{0}'' contains too few classes ({1} < {2})
1477 module.with.too.few.classes.min.option=Minimum number of classes:
1478 package.in.multiple.modules.display.name=Package with classes in multiple modules
1479 package.in.multiple.modules.problem.descriptor=Package ''{0}'' has classes in multiple modules
1480 disjoint.package.display.name=Package with disjoint dependency graph
1481 disjoint.package.problem.descriptor=Package {0} can be decomposed into {1} independent packages
1482 package.naming.convention.display.name=Package naming convention
1483 package.naming.convention.problem.descriptor.short=Package name <code>{0}</code> is too short
1484 package.naming.convention.problem.descriptor.long=Package name <code>{0}</code> is too long
1485 package.naming.convention.problem.descriptor.regex.mismatch=Package name <code>{0}</code> doesn''t match regex ''{1}''
1486 cyclic.class.initialization.display.name=Cyclic class initialization dependency
1487 cyclic.class.initialization.problem.descriptor=Initialization of class ''{0}'' is cyclically dependent on {1} other classes
1488 before.or.after.is.public.void.no.arg.display.name=Malformed @Before or @After method
1489 before.or.after.is.public.void.no.arg.problem.descriptor=<code>#ref()</code> has incorrect signature for a @Before or @After method #loc
1490 before.class.or.after.class.is.public.static.void.no.arg.display.name=Malformed @BeforeClass or @AfterClass method
1491 before.class.or.after.class.is.public.static.void.no.arg.problem.descriptor=<code>#ref()</code> has incorrect signature for a @BeforeClass or @AfterClass method #loc
1492 string.constructor.display.name=Redundant String constructor call
1493 string.constructor.problem.descriptor=<code>#ref</code> is redundant #loc
1494 string.constructor.replace.arg.quickfix=Replace with arg
1495 string.constructor.replace.empty.quickfix=Replace with empty string
1496 string.constructor.substring.parameter.option=Ignore string constructor calls with a 'substring()' call argument
1497 design.for.extension.display.name=Design for extension
1498 design.for.extension.problem.descriptor=Method <code>#ref()</code> may be overridden and its functionality ignored #loc
1499 bad.oddness.display.name=Suspicious test for oddness
1500 bad.oddness.problem.descriptor=Test for oddness <code>#ref</code> will fail on negative values #loc
1501 comparator.not.serializable.display.name=Comparator class not declared Serializable
1502 comparator.not.serializable.problem.descriptor=Comparator class <code>#ref</code> is not declared as Serializable #loc
1503 non.serializable.field.in.serializable.class.display.name=Non-serializable field in a Serializable class
1504 non.serializable.field.in.serializable.class.problem.descriptor=Non-serializable field '#ref' in a Serializable class #loc
1505 non.serializable.object.passed.to.object.stream.display.name=Non-serializable object passed to ObjectOutputStream
1506 non.serializable.object.passed.to.object.stream.problem.descriptor=Non-serializable object passed to ObjectOutputStream #loc
1507 non.serializable.object.bound.to.http.session.display.name=Non-serializable object bound to HttpSession
1508 non.serializable.object.bound.to.http.session.problem.descriptor=Non-serializable object bound to HttpSession #loc
1509 reflection.for.unavailable.annotation.display.name=Reflective access to a source-only annotation
1510 reflection.for.unavailable.annotation.problem.descriptor=Annotation '#ref' is not retained for reflective access #loc
1511 access.to.static.field.locked.on.instance.display.name=Access to static field locked on instance data
1512 access.to.static.field.locked.on.instance.problem.descriptor=Access to static field <code>#ref</code> locked on instance data #loc
1513 make.method.ctr.quickfix=Make method constructor
1514 replace.all.dot.display.name=Call to String.replaceAll(".", ...)
1515 replace.all.dot.problem.descriptor=Call to <code>String.#ref(".", ...)</code> #loc
1516 constant.string.intern.display.name=Call to 'intern()' on String constant
1517 constant.string.intern.problem.descriptor=<code>.#ref()</code> on compile-time constant is unnecessary #loc
1518 constant.string.intern.quickfix=Remove 'intern()' call
1519 class.extends.utility.class.display.name=Class extends utility class
1520 class.extends.utility.class.problem.descriptor=Class <code>#ref</code> extends utility class ''{0}'' #loc
1521 class.extends.utility.class.ignore.utility.class.option=Ignore if overriding class is a utility class
1522 public.constructor.in.non.public.class.quickfix=Make constructor ''{0}''
1523 assignment.to.method.parameter.ignore.transformation.option=<html>Ignore if assignment is a transformation of the original parameter</html>
1524 type.parameter.extends.final.class.display.name=Type parameter extends final class
1525 type.parameter.extends.final.class.problem.descriptor1=Type parameter <code>#ref</code> extends ''final'' class ''{0}'' #loc
1526 type.parameter.extends.final.class.problem.descriptor2=Wildcard type argument <code>#ref</code> extends ''final'' class ''{0}'' #loc
1527 type.parameter.extends.final.class.quickfix=Replace type parameter with actual class
1528 double.negation.display.name=Double negation
1529 double.negation.problem.descriptor=Double negation in <code>#ref</code> #loc
1530 double.negation.quickfix=Remove double negation
1531 exception.from.catch.which.doesntwrap.ignore.option=Ignore if result of exception method call is used
1532 exception.from.catch.which.doesntwrap.ignore.cant.wrap.option=Ignore if thrown exception cannot wrap an exception
1533 comparable.implemented.but.equals.not.overridden.display.name=Comparable implemented but 'equals()' not overridden
1534 comparable.implemented.but.equals.not.overridden.problem.descriptor=Class <code>#ref</code> implements 'java.lang.Comparable' but does not override 'equals()' #loc
1535 unqualified.field.access.display.name=Instance field access not qualified with 'this'
1536 unqualified.field.access.problem.descriptor=Instance field access <code>#ref</code> is not qualified with 'this' #loc
1537 unqualified.method.access.display.name=Instance method call not qualified with 'this'
1538 unqualified.method.access.problem.descriptor=Instance method call <code>#ref</code> is not qualified with 'this' #loc
1539 add.this.qualifier.quickfix=Add 'this' qualifier
1540 while.loop.spins.on.field.ignore.non.empty.loops.option=Only warn if the loop is empty
1541 method.may.be.synchronized.problem.descriptor=Method <code>#ref()</code> with synchronized block could be synchronized method #loc
1542 method.may.be.synchronized.display.name=Method with synchronized block could be synchronized method
1543 method.may.be.synchronized.quickfix=Make method synchronized and remove synchronized block
1544 fallthru.in.switch.statement.quickfix=Add 'break'
1545 law.of.demeter.display.name=Method call violates Law of Demeter
1546 law.of.demeter.problem.descriptor=<code>#ref()</code> call violates Law of Demeter #loc
1547 law.of.demeter.ignore.library.calls.option=Ignore calls on library methods
1548 assertequals.between.inconvertible.types.display.name='assertEquals()' between objects of inconvertible types
1549 assertequals.between.inconvertible.types.problem.descriptor=<code>#ref()</code> between objects of inconvertible types ''{0}'' and ''{1}'' #loc
1550 enumeration.can.be.iteration.display.name=Enumeration can be iteration
1551 enumeration.can.be.iteration.problem.descriptor=<code>#ref()</code> can be replaced with ''{0}'' construct #loc
1552 enumeration.can.be.iteration.quickfix=Replace with 'Iterator' construct
1553 equals.hashcode.called.on.url.display.name='equals()' or 'hashCode()' called on 'java.net.URL' object
1554 equals.hashcode.called.on.url.problem.descriptor=Call to <code>#ref()</code> on URL object #loc
1555 collection.contains.url.problem.decriptor={0} <code>#ref</code> may contain URL objects #loc
1556 collection.contains.url.display.name=Map or Set may contain 'java.net.URL' objects
1557 implicit.array.to.string.problem.descriptor=Implicit call to 'toString()' on array <code>#ref</code> #loc
1558 explicit.array.to.string.problem.descriptor=Call to '#ref()' on array #loc
1559 implicit.array.to.string.method.call.problem.descriptor=Implicit call to 'toString()' on array returned by call to <code>#ref</code> #loc
1560 implicit.array.to.string.display.name=Call to 'toString()' on array
1561 implicit.array.to.string.quickfix=Wrap with ''{0}'' expression
1562 suspicious.indent.after.control.statement.problem.descriptor=<code>#ref</code> statement has suspicious indentation #loc
1563 suspicious.indent.after.control.statement.display.name=Suspicious indentation after control statement without braces
1564 unpredictable.big.decimal.constructor.call.display.name=Unpredictable BigDecimal constructor call
1565 unpredictable.big.decimal.constructor.call.problem.descriptor=Unpredictable <code>new #ref()</code> call #loc
1566 unpredictable.big.decimal.constructor.call.ignore.references.option=Ignore constructor calls with variable or method call arguments
1567 unpredictable.big.decimal.constructor.call.ignore.complex.literals.option=Ignore constructor calls with multiple literals (e.g. 0.1 + 0.2)
1568 unpredictable.big.decimal.constructor.call.quickfix=Replace with ''{0}''
1569 unnecessary.unary.minus.display.name=Unnecessary unary minus
1570 unnecessary.unary.minus.problem.descriptor=Unnecessary unary minus #loc
1571 unnecessary.unary.minus.quickfix=Remove unary minus and invert parent operation sign
1572 make.field.final.quickfix=Make ''{0}'' ''final''
1573 increment.decrement.used.as.expression.quickfix=Extract ''{0}'' to separate statement
1574 ignore.classes.in.hierarchy.column.name=Ignore subclasses of
1575 overly.strong.type.cast.ignore.in.matching.instanceof.option=Ignore casts with a matching instanceof expression
1576 return.of.collection.field.quickfix=Replace with ''{0}''
1577 access.to.non.thread.safe.static.field.from.instance.display.name=Non thread-safe static field access
1578 access.to.non.thread.safe.static.field.from.instance.field.problem.descriptor=Access to non thread-safe static field <code>#ref</code> of type ''{0}'' #loc
1579 access.to.non.thread.safe.static.field.from.instance.option.title=Non thread-safe classes
1580 access.to.non.thread.safe.static.field.from.instance.class.chooser.title=Choose non thread-safe class
1581 transient.field.not.initialized.display.name=Transient field is not initialized on deserialization
1582 transient.field.not.initialized.problem.descriptor=Transient field <code>#ref</code> not initialized on deserialization #loc
1583 call.to.string.concat.can.be.replaced.by.operator.display.name=Call to 'String.concat()' can be replaced with '+'
1584 call.to.string.concat.can.be.replaced.by.operator.problem.descriptor=Call to <code>#ref()</code> can be replaced with '+' expression #loc
1585 call.to.string.concat.can.be.replaced.by.operator.quickfix=Replace 'concat()' call with '+'
1586 new.string.buffer.with.char.argument.display.name=StringBuffer constructor call with 'char' argument
1587 new.string.buffer.with.char.argument.problem.descriptor=<code>new #ref()</code> with argument of type 'char' #loc
1588 new.string.buffer.with.char.argument.quickfix=Replace char argument with String literal
1589 comparator.method.parameter.not.used.display.name='Comparator.compare()' method does not use parameter
1590 comparator.method.parameter.not.used.problem.descriptor='compare()' parameter <code>#ref</code> is not used #loc
1591 to.array.call.with.zero.length.array.argument.display.name=Call to 'Collection.toArray()' with zero-length array argument
1592 to.array.call.with.zero.length.array.argument.problem.descriptor=Call to <code>#ref()</code> with zero-length array argument ''{0}'' #loc
1593 to.array.call.with.zero.length.array.argument.quickfix=Replace argument with correctly sized array
1594 throwable.instance.never.thrown.runtime.exception.problem.descriptor=Runtime exception instance <code>#ref</code> is not thrown #loc
1595 throwable.instance.never.thrown.checked.exception.problem.descriptor=Checked exception instance <code>#ref</code> is not thrown #loc
1596 throwable.instance.never.thrown.error.problem.descriptor=Error instance <code>#ref</code> is not thrown #loc
1597 throwable.instance.never.thrown.problem.descriptor=Throwable instance <code>#ref</code> is not thrown #loc
1598 type.may.be.weakened.display.name=Type may be weakened
1599 type.may.be.weakened.problem.descriptor=Type of variable <code>#ref</code> may be weakened to {0} #loc
1600 type.may.be.weakened.method.problem.descriptor=Return type of method <code>#ref()</code> may be weakened to {0} #loc
1601 type.may.be.weakened.parameter.problem.descriptor=Type of parameter <code>#ref</code> may be weakened to {0} #loc
1602 type.may.be.weakened.field.problem.descriptor=Type of field <code>#ref</code> may be weakened to {0} #loc
1603 type.may.be.weakened.quickfix=Weaken type to ''{0}''
1604 type.may.be.weakened.ignore.option=Use &righthand type as weakest type in assignments
1605 type.may.be.weakened.collection.method.option=Use &parameterized type of collection for method call arguments
1606 type.may.be.weakened.do.not.weaken.to.object.option=Do not &weaken to 'java.lang.Object'
1607 ignore.guard.clauses.option=Ignore &guard clauses
1608 ignore.for.equals.methods.option=Ignore for '&equals()' methods
1609 caught.exception.immediately.rethrown.display.name=Caught exception is immediately rethrown
1610 caught.exception.immediately.rethrown.problem.descriptor=Caught exception <code>#ref</code> is immediately rethrown #loc
1611 delete.catch.section.quickfix=Delete 'catch' section
1612 remove.try.catch.quickfix=Remove 'try catch' statement
1613 loop.with.implicit.termination.condition.display.name=Loop with implicit termination condition
1614 loop.with.implicit.termination.condition.dowhile.problem.descriptor=<code>#ref-while</code> loop with implicit termination condition #loc
1615 loop.with.implicit.termination.condition.problem.descriptor=<code>#ref</code> loop with implicit termination condition #loc
1616 loop.with.implicit.termination.condition.quickfix=Make condition explicit
1617 ignore.iterator.loop.variables=Ignore 'java.util.Iterator' loop variables
1618 rename.catch.parameter.to.ignored=Rename 'catch' parameter to 'ignored'
1619 unnecessary.super.qualifier.display.name=Unnecessary 'super' qualifier
1620 unnecessary.super.qualifier.problem.descriptor=Qualifier <code>#ref</code> is unnecessary in this context #loc
1621 unnecessary.super.qualifier.quickfix=Remove unnecessary 'super' qualifier
1622 collections.field.access.replaceable.by.method.call.display.name=Collections.EMPTY_* field access replaceable with 'Collections.empty*()' method call
1623 collections.field.access.replaceable.by.method.call.problem.descriptor=<code>#ref</code> replaceable with ''Collections.{0}'' #loc
1624 collections.field.access.replaceable.by.method.call.quickfix=Replace with ''{0}''
1625 synchronization.on.local.variable.or.method.parameter.display.name=Synchronization on local variable or method parameter
1626 synchronization.on.local.variable.problem.descriptor=Synchronization on local variable <code>#ref</code> #loc
1627 synchronization.on.method.parameter.problem.descriptor=Synchronization on method parameter <code>#ref</code> #loc
1628 too.broad.catch.quickfix=Add ''catch'' clause for ''{0}''
1629 replace.with.catch.clause.for.runtime.exception.quickfix=Replace with 'catch' clause for 'RuntimeException'
1630 too.broad.catch.option=&Only warn on RuntimeException, Exception, Error or Throwable
1631 unnecessary.call.to.string.valueof.display.name=Unnecessary call to 'String.valueOf()'
1632 unnecessary.tostring.call.display.name=Unnecessary call to 'toString()'
1633 unnecessary.call.to.string.valueof.problem.descriptor=<code>#ref</code> can be simplified to ''{0}'' #loc
1634 unnecessary.tostring.call.problem.descriptor=Unnecessary <code>#ref()</code> call #loc
1635 unnecessary.call.to.string.valueof.quickfix=Replace with ''{0}''
1636 throwable.not.thrown.display.name=Throwable not thrown
1637 throwable.result.of.method.call.ignored.problem.descriptor=Result of <code>#ref()</code> not thrown #loc
1638 char.used.in.arithmetic.context.display.name=Char expression used in arithmetic context
1639 char.used.in.arithmetic.context.problem.descriptor='char' <code>#ref</code> used in arithmetic context #loc
1640 char.used.in.arithmetic.context.quickfix=Convert to String literal
1641 char.used.in.arithmetic.context.cast.quickfix=Insert cast to {0}
1642 unnecessary.constant.array.creation.expression.display.name=Redundant 'new' expression in constant array creation
1643 unnecessary.constant.array.creation.expression.problem.descriptor=<code>#ref</code> can be replaced with array initializer expression #loc
1644 unnecessary.constant.array.creation.expression.quickfix=Remove ''new {0}''
1645 unnecessary.constant.array.creation.expression.family.quickfix=Replace with array initializer expression
1646 ambiguous.method.call.display.name=Call to inherited method looks like call to local method
1647 ambiguous.method.call.problem.descriptor=Call to method <code>#ref()</code> from superclass ''{0}'' looks like call to method from class ''{1}'' #loc
1648 ambiguous.method.call.quickfix=Add 'super' qualifier to method call
1649 change.modifier.quickfix=Make ''{0}''
1650 the.whole.project=the whole project
1651 this.class=this class
1652 assertequals.may.be.assertsame.display.name='assertEquals()' may be 'assertSame()'
1653 assertequals.may.be.assertsame.problem.descriptor=<code>#ref()</code> may be 'assertSame()' #loc
1654 logger.initialized.with.foreign.class.quickfix=Replace with ''{0}.class''
1655 logger.initialized.with.foreign.class.problem.descriptor=Logger initialized with foreign class <code>#ref</code> #loc
1656 logger.initialized.with.foreign.class.display.name=Logger initialized with foreign class
1657 logger.factory.method.name=Logger factory method name
1658 logger.factory.class.name=Logger factory class name
1659 make.static.final.quickfix=Make ''{0}'' static final
1660 logging.condition.disagrees.with.log.statement.display.name=Log condition does not match logging call
1661 logging.condition.disagrees.with.log.statement.problem.descriptor=Log condition <code>#ref()</code> does not match ''{0}()'' logging call #loc
1662 log.statement.guarded.by.log.condition.display.name=Logging call not guarded by log condition
1663 log.statement.guarded.by.log.condition.problem.descriptor=<code>#ref()</code> logging calls not guarded by log condition #loc
1664 log.statement.guarded.by.log.condition.quickfix=Surround with log condition
1665 log.statement.guarded.by.log.condition.flag.all.unguarded.option=Flag all unguarded logging calls
1666 key.set.iteration.may.use.entry.set.display.name=Iteration over 'keySet()' may be replaced with 'entrySet()' iteration
1667 key.set.iteration.may.use.entry.set.problem.descriptor=Iteration over <code>#ref</code> may be replaced with 'entrySet()' iteration #loc
1668 key.set.iteration.may.use.entry.set.quickfix=Replace with 'entrySet()' iteration
1669 string.replaceable.by.string.buffer.in.loop.option=Only warn when appending in a loop
1670 declare.collection.as.interface.quickfix=Weaken to ''{0}''
1671 non.exception.name.ends.with.exception.quickfix=Make ''{0}'' extend ''java.lang.Exception''
1672 constant.value.variable.use.display.name=Use of variable whose value is known to be constant
1673 constant.value.variable.use.problem.descriptor=Value of <code>#ref</code> is known to be constant #loc
1674 replace.reference.with.expression.quickfix=Replace with ''{0}''
1675 unnecessary.parentheses.option=Ignore clarifying parentheses
1676 unnecessary.parentheses.conditional.option=Ignore parentheses around the condition of conditional expressions
1677 field.may.be.final.display.name=Field may be 'final'
1678 field.may.be.final.problem.descriptor=Field <code>#ref</code> may be 'final' #loc
1679 cast.that.loses.precision.option=Ignore casts from int to char
1680 variable.not.used.inside.if.display.name=Reference checked for 'null' is not used inside 'if'
1681 variable.not.used.inside.if.problem.descriptor=<code>#ref</code> checked for 'null' is not used inside 'if' #loc
1682 variable.not.used.inside.conditional.problem.descriptor=<code>#ref</code> checked for 'null' is not used inside conditional #loc
1683 boolean.expression.may.be.conditional.display.name=Boolean expression could be replaced with conditional expression
1684 if.may.be.conditional.display.name='if' statement could be replaced with conditional expression
1685 if.may.be.conditional.problem.descriptor=<code>#ref</code> could be replaced with conditional expression #loc
1686 if.may.be.conditional.quickfix=Replace with conditional expression
1687 if.may.be.conditional.report.method.calls.option=Report if statements containing method calls
1688 redundant.string.format.call.display.name=Redundant call to 'String.format()'
1689 redundant.string.format.call.problem.descriptor=Redundant call to <code>#ref</code> #loc
1690 redundant.string.format.call.quickfix=Remove redundant call to 'String.format()'
1691 junit4.test.method.in.class.extending.junit3.testcase.display.name=JUnit 4 test method in class extending JUnit 3 TestCase
1692 junit4.test.method.in.class.extending.junit3.testcase.problem.descriptor=Method <code>#ref()</code> annotated with '@Test' inside class extending JUnit 3 TestCase #loc
1693 ignore.test.method.in.class.extending.junit3.testcase.problem.descriptor=JUnit 3 test method <code>#ref()</code> annotated with '@Ignore' won't be ignored #loc
1694 ignore.test.method.in.class.extending.junit3.testcase.quickfix=Remove ''@Ignore'' and rename method to ''{0}''
1695 convert.junit3.test.class.quickfix=Convert JUnit 3 class ''{0}'' to JUnit 4
1696 remove.junit4.test.annotation.quickfix=Remove '@Test' annotation
1697 remove.junit4.test.annotation.and.rename.quickfix=Remove ''@Test'' annotation and rename to ''{0}''
1698 equals.called.on.enum.constant.display.name='equals()' called on Enum value
1699 equals.called.on.enum.constant.problem.descriptor=<code>#ref()</code> called on Enum value #loc
1700 equals.called.on.enum.constant.quickfix=Replace 'equals()' with '=='
1701 int.literal.may.be.long.literal.display.name='int' literal cast to 'long' could be 'long' literal
1702 int.literal.may.be.long.literal.problem.descriptor=<code>#ref</code> could be replaced with ''{0}'' #loc
1703 int.literal.may.be.long.literal.quickfix=Replace with ''{0}''
1704 constant.assert.condition.display.name='assert' statement condition is constant
1705 constant.assert.condition.problem.descriptor=Assert condition <code>#ref</code> is constant #loc
1706 assert.with.side.effects.display.name='assert' statement with side effects
1707 assert.with.side.effects.problem.descriptor=<code>#ref</code> has side effects #loc
1708 method.count.ignore.getters.setters.option=&Ignore simple getter and setter methods
1709 class.new.instance.display.name=Unsafe call to 'Class.newInstance()'
1710 class.new.instance.problem.descriptor=Call to <code>#ref()</code> may throw undeclared checked exceptions #loc
1711 class.new.instance.quickfix=Replace with 'Class.getConstructor().newInstance()' call
1712 dynamic.regex.replaceable.by.compiled.pattern.display.name=Dynamic regular expression could be replaced by compiled Pattern
1713 dynamic.regex.replaceable.by.compiled.pattern.problem.descriptor=<code>#ref()</code> could be replaced with compiled 'java.util.regex.Pattern' construct #loc
1714 dynamic.regex.replaceable.by.compiled.pattern.quickfix=Replace with call to method of compiled 'Pattern' constant
1715 ignore.serializable.option=Ignore 'java.io.Serializable'
1716 ignore.cloneable.option=Ignore 'java.lang.Cloneable'
1717 listener.may.use.adapter.display.name=Class may extend adapter instead of implementing listener
1718 listener.may.use.adapter.problem.descriptor=Class ''{0}'' may extend ''{1}'' instead of implementing <code>#ref</code> #loc
1719 listener.may.use.adapter.quickfix=Replace with ''extends {0}''
1720 listener.may.use.adapter.emtpy.methods.option=&Only warn when empty implementing methods are found
1721 unnecessary.inherit.doc.display.name=Unnecessary {@inheritDoc} Javadoc Comment
1722 unnecessary.inherit.doc.problem.descriptor=Javadoc comment containing only <code>#ref</code> is unnecessary #loc
1723 unnecessary.inherit.doc.field.invalid.problem.descriptor=<code>#ref</code> is not valid on fields #loc
1724 unnecessary.inherit.doc.constructor.invalid.problem.descriptor=<code>#ref</code> is not valid on constructors #loc
1725 unnecessary.inherit.doc.class.invalid.problem.descriptor=<code>#ref</code> is not valid on classes #loc
1726 unnecessary.inherit.doc.constructor.no.super.problem.descriptor=No super method found to inherit Javadoc from #loc
1727 unnecessary.inherit.doc.quickfix=Remove unnecessary {@inheritDoc}
1728 multiple.exceptions.declared.on.test.method.display.name=Multiple exceptions declared on test method
1729 multiple.exceptions.declared.on.test.method.problem.descriptor=<code>#ref</code> could be replaced with 'throws Exception' #loc
1730 multiple.exceptions.declared.on.test.method.quickfix=Replace with 'throws Exception'
1731 unnecessary.javadoc.link.display.name=Unnecessary Javadoc link
1732 unnecessary.javadoc.link.super.method.problem.descriptor=<code>#ref</code> pointing to super method is unnecessary #loc
1733 unnecessary.javadoc.link.this.method.problem.descriptor=<code>#ref</code> pointing to this method is unnecessary #loc
1734 unnecessary.javadoc.link.this.class.problem.descriptor=<code>#ref</code> pointing to containing class is unnecessary #loc
1735 unnecessary.javadoc.link.quickfix=Remove unnecessary ''{0}''
1736 thread.local.not.static.final.display.name=ThreadLocal field not declared static final
1737 thread.local.not.static.final.problem.descriptor=ThreadLocal <code>#ref</code> is not declared 'static final' #loc
1738 remove.try.finally.block.quickfix=Remove 'try-finally' block
1739 remove.finally.block.quickfix=Remove 'finally' block
1740 remove.leading.zero.to.make.decimal.quickfix=Remove leading zero to make decimal
1741 convert.octal.literal.to.decimal.literal.quickfix=Convert octal literal to decimal literal
1742 ignore.single.field.static.imports.option=Ignore single &field static imports
1743 ignore.single.method.static.imports.option=Ignore single &method static imports
1744 ignore.methods.with.boolean.return.type.option=Ignore methods with 'java.lang.&Boolean' return type
1745 ignore.boolean.methods.in.an.interface.option=Ignore boolean methods in an @&interface
1746 ignore.methods.overriding.super.method=Ignore methods &overriding/implementing a super method
1747 ignore.nullable.parameters.option=Ignore @Nullable parameters
1748 ignored.io.resource.types=Ignored I/O resource types
1749 choose.io.resource.type.to.ignore=Choose I/O resource type to ignore
1750 ignore.accesses.from.the.same.class=Ignore accesses from the same class
1751 ignore.accesses.from.equals.method=Ignore accesses from 'equals()' method
1752 ignore.branches.of.switch.statements=Ignore branches of 'switch' statements
1753 ignore.equals.hashcode.and.tostring=Ignore 'equals()', 'hashCode()' and 'toString()' methods
1754 ignore.methods.in.anonymous.classes=Ignore methods in anonymous classes
1755 class.name=Class name
1756 method.name.regex=Method name regex
1757 choose.class=Choose class
1758 query.column.name=Query names start with
1759 update.column.name=Update names start with
1760 assert.keyword.is.considered.an.assertion='assert' keyword is considered an assertion
1761 expected.exception.never.thrown.display.name=Expected exception never thrown in test method body
1762 expected.exception.never.thrown.problem.descriptor=Expected <code>#ref</code> never thrown in body of ''{0}()'' #loc
1763 choose.logger.class=Choose logger class
1764 logger.class.name=Logger class name
1765 ignore.exceptions.declared.on.library.override.option=Ignore exceptions declared on methods overriding a &library method
1766 allow.resource.to.be.opened.inside.a.try.block=Allow resource to be opened inside a 'try' block
1767 any.method.may.close.resource.argument=Any method may close resource argument
1768 log.method.name=Logging method name
1769 log.condition.text=Log condition text
1770 ignore.if.annotated.by=Ignore if annotated by
1771 ignore.parameter.if.annotated.by=Ignore parameter if it is annotated by
1772 only.weaken.to.an.interface=Only weaken to an interface
1773 unqualified.inner.class.access.display.name=Unqualified inner class access
1774 unqualified.inner.class.access.problem.descriptor=<code>#ref</code> is not qualified with outer class #loc
1775 unqualified.inner.class.access.quickfix=Qualify with outer class
1776 unnecessarily.qualified.inner.class.access.problem.descriptor=''{0}'' is unnecessarily qualified with <code>#ref</code> #loc
1777 unnecessarily.qualified.inner.class.access.display.name=Unnecessarily qualified inner class access
1778 unnecessarily.qualified.inner.class.access.quickfix=Remove qualifier
1779 synchronization.on.static.field.display.name=Synchronization on 'static' field
1780 synchronization.on.static.field.problem.descriptor=Synchronization on 'static' field <code>#ref</code> #loc
1781 assertequals.called.on.arrays.display.name='assertEquals()' called on array
1782 assertequals.called.on.arrays.problem.descriptor=<code>#ref()</code> called on array #loc
1783 assertequals.called.on.arrays.quickfix=Replace with 'assertArrayEquals()'
1784 overly.broad.throws.clause.display.name=Overly broad 'throws' clause
1785 overly.broad.throws.clause.problem.descriptor1=<code>throws #ref</code> is too broad, masking exception ''{0}'' #loc
1786 overly.broad.throws.clause.problem.descriptor2=<code>throws #ref</code> is too broad, masking exceptions ''{0}'' and ''{1}'' #loc
1787 overly.broad.throws.clause.quickfix1=Add specific exceptions
1788 overly.broad.throws.clause.quickfix2=Replace with specific exceptions
1789 overly.broad.throws.clause.ignore.thrown.option=Ignore exceptions which &hide others but are themselves thrown
1790 unnecessarily.qualified.statically.imported.element.display.name=Unnecessarily qualified statically imported element
1791 unnecessarily.qualified.statically.imported.element.problem.descriptor=Statically imported element ''{0}'' is unnecessarily qualified with <code>#ref</code> #loc
1792 unnecessarily.qualified.statically.imported.element.quickfix=Remove unnecessary qualifier
1793 ignore.instanceof.on.library.classes=Ignore instanceof on library classes
1794 assertequals.may.be.assertsame.quickfix=Replace with 'assertSame()'
1795 for.can.be.foreach.option=Report indexed 'java.util.List' loops
1796 for.can.be.foreach.option2=Do not report iterations over untyped collections
1797 cast.conflicts.with.instanceof.quickfix1=Replace ''{0}'' with ''{1}'' in cast
1798 cast.conflicts.with.instanceof.quickfix2=Replace ''{0}'' with ''{1}'' in instanceof
1799 double.checked.locking.quickfix=Make ''{0}'' ''volatile''
1800 double.literal.may.be.float.literal.display.name='double' literal cast to 'float' could be 'float' literal
1801 double.literal.may.be.float.literal.problem.descriptor=<code>#ref</code> could be replaced with ''{0}'' #loc
1802 double.literal.may.be.float.literal.quickfix=Replace with ''{0}''
1803 multiple.declaration.option=Ignore 'for' loop declarations
1804 simplifiable.annotation.display.name=Simplifiable annotation
1805 simplifiable.annotation.problem.descriptor=Unnecessary <code>#ref</code> in annotation #loc
1806 simplifiable.annotation.whitespace.problem.descriptor=Unnecessary whitespace in annotation #loc
1807 simplifiable.annotation.quickfix=Simplify annotation
1808 overloaded.methods.with.same.number.parameters.option=<html>Ignore overloaded methods whose parameter types are definitely incompatible</html>
1809 string.concatenation.in.format.call.display.name=String concatenation as argument to 'format()' call
1810 string.concatenation.in.format.call.problem.descriptor=<code>#ref()</code> call has a String concatenation argument #loc
1811 string.concatenation.in.format.call.quickfix=Replace concatenation with separate argument
1812 string.concatenation.in.message.format.call.display.name=String concatenation as argument to 'MessageFormat.format()' call
1813 string.concatenation.in.message.format.call.problem.descriptor=String concatenation as argument to 'MessageFormat.format()' call #loc
1814 shift.out.of.range.quickfix=Replace ''{0}'' with ''{1}''
1815 boxing.boxed.value.display.name=Boxing of already boxed value
1816 boxing.boxed.value.problem.descriptor=Boxing of already boxed <code>#ref</code> #loc
1817 boxing.boxed.value.quickfix=Remove unnecessary boxing
1818 unnecessary.javadoc.link.option=Ignore inline links to super methods
1819 constant.junit.assert.argument.display.name=Constant JUnit assert argument
1820 constant.junit.assert.argument.problem.descriptor=Argument <code>#ref</code> is constant #loc
1821 test.case.with.no.test.methods.option=Ignore test cases which have superclasses with test methods
1822 package.dot.html.may.be.package.info.display.name='package.html' may be converted to 'package-info.java'
1823 package.dot.html.may.be.package.info.exists.problem.descriptor=<code>package.html</code> is ignored because <code>package-info.java</code> exists
1824 package.dot.html.may.be.package.info.problem.descriptor=<code>package.html</code> may be converted to <code>package-info.java</code>
1825 package.dot.html.may.be.package.info.delete.quickfix=Delete 'package.html'
1826 package.dot.html.delete.command=package.html deletion
1827 package.dot.html.may.be.package.info.convert.quickfix=Convert to 'package-info.java'
1828 package.dot.html.convert.command=package.html to package-info.java conversion
1829 choose.super.class.to.ignore=Choose class
1830 ignore.anonymous.inner.classes=Ignore anonymous inner classes
1831 try.with.identical.catches.display.name=Identical 'catch' branches in 'try' statement
1832 try.with.identical.catches.problem.descriptor=''catch'' branch identical to ''{0}'' branch #loc
1833 if.can.be.switch.display.name='if' replaceable with 'switch'
1834 if.can.be.switch.problem.descriptor=<code>#ref</code> statement replaceable with 'switch' statement #loc
1835 if.can.be.switch.quickfix=Replace with 'switch'
1836 if.can.be.switch.minimum.branch.option=Minimum number of branches:
1837 if.can.be.switch.int.option=Suggest switch on numbers
1838 if.can.be.switch.enum.option=Suggest switch on enums
1839 if.can.be.switch.null.safe.option=Only suggest on null-safe expressions
1840 unnecessarily.qualified.inner.class.access.option=Ignore references for which an import is needed
1841 unqualified.inner.class.access.option=Ignore references to local inner classes
1842 try.with.identical.catches.quickfix=Collapse 'catch' blocks
1843 confusing.else.option=<html>Also report when there are no more statements after the 'if' statement</html>
1844 html.tag.can.be.javadoc.tag.display.name=<code>...</code> can be replaced with {@code ...}
1845 html.tag.can.be.javadoc.tag.problem.descriptor=<code>#ref...\\&lt;/code\\&gt;</code> can be replaced with '{@code ...}' #loc
1846 html.tag.can.be.javadoc.tag.quickfix=Replace with '{@code ...}'
1847 try.finally.can.be.try.with.resources.display.name='try finally' replaceable with 'try' with resources
1848 try.finally.can.be.try.with.resources.problem.descriptor=<code>#ref</code> can use automatic resource management #loc
1849 try.finally.can.be.try.with.resources.quickfix=Replace with 'try' with resources
1850 array.comparison.display.name=Array comparison using '==', instead of 'Arrays.equals()'
1851 array.comparison.problem.descriptor=Array objects are compared using <code>#ref</code>, not 'Arrays.equals()' #loc
1852 array.hash.code.display.name='hashCode()' called on array
1853 array.hash.code.problem.descriptor=<code>#ref()</code> called on array should probably be 'Arrays.hashCode()' #loc
1854 arrays.deep.hash.code.quickfix=Replace with 'Arrays.deepHashCode()'
1855 arrays.hash.code.quickfix=Replace with 'Arrays.hashCode()'
1856 method.can.be.variable.arity.method.display.name=Method can be varargs method
1857 method.can.be.variable.arity.method.problem.descriptor=<code>#ref()</code> can be converted to varargs method #loc
1858 method.can.be.variable.arity.method.ignore.byte.short.option=Ignore methods with a last parameter of type byte[] or short[]
1859 method.can.be.variable.arity.method.ignore.multiple.arrays.option=Ignore methods with multiple array parameters
1860 convert.to.variable.arity.method.quickfix=Convert to varargs method
1861 mismatched.string.builder.query.update.display.name=Mismatched query and update of StringBuilder
1862 mismatched.string.builder.updated.problem.descriptor=Contents of {0} <code>#ref</code> are updated, but never queried #loc
1863 mismatched.string.builder.queried.problem.descriptor=Contents of {0} <code>#ref</code> are queried, but never updated #loc
1864 math.random.cast.to.int.display.name='Math.random()' cast to 'int'
1865 math.random.cast.to.int.problem.descriptor=<code>#ref</code> cast to ''{0}'' is always rounded down to ''0'' #loc
1866 math.random.cast.to.int.quickfix=Add parentheses to perform multiplication before cast
1867 boolean.variable.always.inverted.display.name=Boolean variable is always inverted
1868 boolean.field.always.inverted.problem.descriptor=Boolean field <code>#ref</code> is always inverted #loc
1869 boolean.variable.always.inverted.problem.descriptor=Boolean variable <code>#ref</code> is always inverted #loc
1870 unnecessary.explicit.numeric.cast.display.name=Unnecessary explicit numeric cast
1871 unnecessary.explicit.numeric.cast.problem.descriptor=''{0}'' unnecessarily cast to <code>#ref</code> #loc
1872 unnecessary.explicit.numeric.cast.quickfix=Remove cast
1873 null.thrown.display.name='null' thrown
1874 null.thrown.problem.descriptor=<code>#ref</code> thrown #loc
1875 null.thrown.quickfix=Replace with 'new NullPointerException()'
1876 element.only.used.from.test.code.display.name=Symbol only used from test code
1877 class.only.used.from.test.code.problem.descriptor=class <code>#ref</code> only used from test code #loc
1878 method.only.used.from.test.code.problem.descriptor=method <code>#ref()</code> only called from test code #loc
1879 field.only.used.from.test.code.problem.descriptor=field <code>#ref</code> only accessed from test code #loc
1880 unnecessary.final.on.local.variable.or.parameter.display.name=Unnecessary 'final' on local variable or parameter
1881 unnecessary.final.on.local.variable.problem.descriptor=Unnecessary <code>#ref</code> on variable ''{0}'' #loc
1882 unnecessary.final.on.parameter.problem.descriptor=Unnecessary <code>#ref</code> on parameter ''{0}'' #loc
1883 unnecessary.final.report.local.variables.option=Report local variables
1884 unnecessary.final.report.parameters.option=Report parameters
1885 unnecessary.final.on.parameter.only.interface.option=Only warn on abstract or interface methods
1886 choose.exception.class=Choose Exception class
1887 class.independent.of.module.display.name=Class independent of its module
1888 class.independent.of.module.problem.descriptor=Class <code>#ref</code> has no dependencies or dependents in its module #loc
1889 class.only.used.in.one.module.display.name=Class only used from one other module
1890 class.only.used.in.one.module.problem.descriptor=Class <code>#ref</code> has only dependencies on and/or dependents in module ''{0}'' #loc
1891 empty.directory.display.name=Empty directory
1892 empty.directories.problem.descriptor=Empty directory <code>{0}</code>
1893 empty.directories.only.under.source.roots.option=Only report empty directories located under a source folder
1894 empty.directories.delete.quickfix=Delete empty directory ''{0}''
1895 simplifiable.equals.expression.display.name=Unnecessary 'null' check before 'equals()' call
1896 simplifiable.equals.expression.problem.descriptor=Unnecessary ''null'' check before ''{0}()'' call #loc
1897 simplifiable.equals.expression.quickfix=Flip ''.{0}()'' and remove unnecessary ''null'' check
1898 cast.to.concrete.class.option=Ignore casts to an abstract class type
1899 cast.to.concrete.class.ignore.equals.option=Ignore in equals()
1900 instanceof.interfaces.option=Ignore instanceof abstract class
1901 instance.variable.of.concrete.class.option=Ignore instance fields whose type is an abstract class
1902 local.variable.of.concrete.class.option=Ignore local variables whose type is an abstract class
1903 method.return.of.concrete.class.option=Ignore methods whose return type is an abstract class
1904 parameter.of.concrete.class.option=Ignore parameters whose type is abstract class
1905 static.variable.of.concrete.class.option=Ignore static fields whose type is an abstract class
1906 class.only.used.in.one.package.display.name=Class only used from one other package
1907 class.only.used.in.one.package.problem.descriptor=Class <code>#ref</code> has only dependencies on and/or dependents in package ''{0}'' #loc
1908 unnecessary.return.option=Ignore in then branch of 'if' statement with 'else' branch
1909 usage.of.obsolete.assert.display.name=Usage of obsolete 'junit.framework.Assert' method
1910 use.of.obsolete.assert.problem.descriptor=Call to <code>#ref()</code> from ''{0}'' should be replaced with call to method from ''org.junit.Assert'' #loc
1911 use.of.obsolete.assert.quickfix=Replace with 'org.junit.Assert' method call
1912 properties.object.as.hashtable.set.quickfix=Replace with call to 'setProperty()'
1913 properties.object.as.hashtable.get.quickfix=Replace with call to 'getProperty()'
1914 ignored.junit.test.display.name=JUnit test annotated with '@Ignore'
1915 ignored.junit.test.classproblem.descriptor=Test class ''{0}'' annotated with <code>#ref</code> #loc
1916 ignored.junit.test.method.problem.descriptor=Test method ''{0}()'' annotated with <code>#ref</code> #loc
1917 unclear.binary.expression.display.name=Unclear expression
1918 unclear.binary.expression.problem.descriptor=Expression could use clarifying parentheses #loc
1919 unclear.binary.expression.quickfix=Add clarifying parentheses
1920 new.exception.without.arguments.display.name=Exception constructor called without arguments
1921 new.exception.without.arguments.problem.descriptor=<code>new #ref()</code> without arguments #loc
1922 new.exception.without.arguments.ignore.option=Ignore for exceptions that have no constructors with parameters
1923 absolute.alignment.in.user.interface.display.name=Absolute alignment used in AWT/Swing code
1924 absolute.alignment.in.user.interface.problem.descriptor=Absolute alignment constant <code>{0}.#ref</code> used #loc
1925 absolute.alignment.in.user.interface.quickfix=Replace with ''{0}.{1}''
1926 throws.runtime.exception.display.name=Unchecked exception declared in 'throws' clause
1927 throws.runtime.exception.problem.descriptor=Unchecked exception <code>#ref</code> declared in 'throws' clause #loc
1928 throws.runtime.exception.quickfix=Remove ''{0}'' from ''throws'' clause
1929 throws.runtime.exception.move.quickfix=Move ''{0}'' to Javadoc ''@throws'' tag
1930 empty.class.ignore.parameterization.option=Ignore class if it is a parameterization of a super type
1931 ambiguous.field.access.display.name=Access of inherited field looks like access of element in surrounding code
1932 ambiguous.field.access.hides.local.variable.problem.descriptor=Access of field <code>#ref</code> from superclass ''{0}'' looks like access of local variable #loc
1933 ambiguous.field.access.hides.parameter.problem.descriptor=Access of field <code>#ref</code> from superclass ''{0}'' looks like access of parameter #loc
1934 ambiguous.field.access.hides.field.problem.descriptor=Access of field <code>#ref</code> from superclass ''{0}'' looks like access of field from surrounding class #loc
1935 ambiguous.field.access.quickfix=Add 'super' qualifier to field access
1936 string.builder.replaceable.by.string.quickfix=Replace 'StringBuilder' with 'String'
1937 string.buffer.replaceable.by.string.quickfix=Replace 'StringBuffer' with 'String'
1938 add.0.to.ignore.if.annotated.by.list.quickfix=Add ''{0}'' to ''Ignore if annotated by'' list
1939 non.final.field.in.enum.display.name=Non-'final' field in enum
1940 non.final.field.in.enum.problem.descriptor=non-''final'' field <code>#ref</code> in enum ''{0}'' #loc
1941 externalizable.without.public.no.arg.constructor.display.name=Externalizable class without 'public' no-arg constructor
1942 externalizable.without.public.no.arg.constructor.problem.descriptor=Externalizable class <code>#ref</code> has no 'public' no-arg constructor #loc
1943 make.constructor.public=Make constructor 'public'
1944 string.concatenation.missing.whitespace.display.name=String literal concatenation missing whitespace
1945 string.concatenation.missing.whitespace.problem.descriptor=String literal concatenation missing whitespace #loc
1946 string.concatenation.missing.whitespace.option=Ignore when one or both sides are not literals
1947 negated.equality.expression.display.name=Negated equality expression
1948 negated.equality.expression.problem.descriptor=Negating ''{0}'' #loc
1949 negated.equality.expression.quickfix=Remove negation
1950 negated.conditional.expression.display.name=Negated conditional expression
1951 negated.conditional.expression.problem.descriptor=Negating conditional expression #loc
1952 negated.conditional.expression.quickfix=Remove negation
1953 suspicious.array.cast.display.name=Suspicious array cast
1954 suspicious.array.cast.problem.descriptor=Suspicious cast to <code>#ref</code> #loc
1955 public.constructor.display.name='public' constructor
1956 public.default.constructor.problem.descriptor=Class <code>#ref</code> has 'public' default constructor
1957 public.constructor.problem.descriptor=Public constructor <code>#ref()</code> #loc
1958 public.constructor.quickfix=Replace constructor with factory method
1959 junit3.style.test.method.in.junit4.class.display.name=Old style JUnit test method in JUnit 4 class
1960 junit3.style.test.method.in.junit4.class.problem.descriptor=Old style JUnit test method <code>#ref()</code> in JUnit 4 class #loc
1961 none=none
1962 private=private
1963 package.local.private=package-private \\& private
1964 protected.package.local.private=protected, package-private \\& private
1965 non.final.utility.class.display.name=Utility class is not 'final'
1966 non.final.utility.class.problem.descriptor=Utility class <code>#ref</code> is not 'final' #loc
1967 0.will.no.longer.be.overridable.by.1={0} will no longer be overridable by {1}
1968 0.will.have.incompatible.access.privileges.with.super.1={0} will have incompatible access privileges with super {1}
1969 0.will.no.longer.be.visible.from.overriding.1={0} will no longer be visible from overriding {1}
1970 make.private.quickfix=Make 'private'
1971 arrays.as.list.with.zero.or.one.argument.display.name=Call to 'Arrays.asList()' with too few arguments
1972 arrays.as.list.with.one.argument.problem.descriptor=Call to <code>#ref</code> with only one argument #loc
1973 arrays.as.list.with.zero.arguments.problem.descriptor=Call to <code>#ref</code> with zero arguments #loc
1974 arrays.as.list.with.one.argument.quickfix=Replace with call to 'Collections.singletonList()'
1975 arrays.as.list.with.zero.arguments.quickfix=Replace with call to 'Collections.emptyList()'
1976 ignore.classes.extending.throwable.option=Ignore classes extending 'Throwable'
1977 string.concatenation.argument.to.log.call.display.name=Non-constant string concatenation as argument to logging call
1978 string.concatenation.argument.to.log.call.problem.descriptor=Non-constant string concatenation as argument to <code>#ref()</code> logging call #loc
1979 string.concatenation.argument.to.log.call.quickfix=Replace concatenation with parameterized log message
1980 placeholder.count.matches.argument.count.display.name=Number of placeholders does not match number of arguments in logging call
1981 placeholder.count.matches.argument.count.more.problem.descriptor=More arguments provided ({0}) than placeholders specified ({1}) #loc
1982 placeholder.count.matches.argument.count.fewer.problem.descriptor=Fewer arguments provided ({0}) than placeholders specified ({1}) #loc
1983 assignment.to.superclass.field.display.name=Constructor assigns value to field defined in superclass
1984 assignment.to.superclass.field.problem.descriptor=Assignment to field ''{0}'' defined in superclass ''{1}'' #loc
1985 junit.rule.display.name=Malformed @Rule/@ClassRule field
1986 junit.rule.problem.descriptor=Fields annotated with ''@{0}'' should be {1}
1987 junit.rule.type.problem.descriptor=Field type should be subtype of 'org.junit.rules.TestRule'
1988 junit.datapoint.display.name=Malformed @DataPoint field
1989 junit.datapoint.problem.descriptor={1}s annotated with @DataPoint should be {0}
1990 inner.class.referenced.via.subclass.display.name=Inner class referenced via subclass
1991 inner.class.referenced.via.subclass.problem.descriptor=Inner class <code>#ref</code> declared in class ''{0}'' but referenced via subclass ''{1}'' #loc
1992 inner.class.referenced.via.subclass.quickfix=Rationalize inner class access
1993 boolean.parameter.display.name='public' method with 'boolean' parameter
1994 boolean.parameter.problem.descriptor='public' method <code>#ref()</code> with 'boolean' parameter #loc
1995 boolean.parameters.problem.descriptor='public' method <code>#ref()</code> with 'boolean' parameters #loc
1996 boolean.parameter.constructor.problem.descriptor='public' constructor <code>#ref()</code> with 'boolean' parameter #loc
1997 boolean.parameters.constructor.problem.descriptor='public' constructor <code>#ref()</code> with 'boolean' parameters #loc
1998 boolean.parameter.only.report.multiple.option=Only report methods with multiple boolean parameters
1999 unnecessary.unicode.escape.display.name=Unnecessary unicode escape sequence
2000 unnecessary.unicode.escape.problem.descriptor=Unicode escape sequence <code>#ref</code> can be replaced with ''{0}'' #loc
2001 missing.package.info.display.name=Missing 'package-info.java'
2002 missing.package.info.problem.descriptor=Package ''{0}'' is missing a <code>package-info.java</code> file
2003 missing.package.html.problem.descriptor=Package ''{0}'' is missing a <code>package.html</code> file
2004 package.info.java.without.package.display.name='package-info.java' without 'package' statement
2005 package.info.without.package.problem.descriptor='package-info.java' does not have a 'package' statement
2006 package.info.without.package.quickfix=add ''package {0};''
2007 package.info.without.package.family.quickfix=add package statement
2008 auto.closeable.resource.display.name=AutoCloseable used without 'try'-with-resources
2009 auto.closeable.resource.problem.descriptor=''{0}'' used without ''try''-with-resources statement #loc
2010 auto.closeable.resource.quickfix=Ignore 'AutoCloseable' returned by this method
2011 auto.closeable.resource.returned.option=Ignore AutoCloseable instances returned from all method calls
2012 problematic.varargs.method.display.name=Non-varargs method overrides varargs method
2013 problematic.varargs.method.override.problem.descriptor=Non-varargs method <code>#ref()</code> overrides varargs method #loc
2014 negatively.named.boolean.variable.problem.descriptor=Boolean variable <code>#ref</code> is negatively named #loc
2015 negatively.named.boolean.variable.display.name=Negatively named boolean variable
2016 invert.quickfix.family.name=Invert boolean
2017 invert.method.quickfix=Invert method
2018 invert.quickfix=Invert ''{0}''
2019 throwable.printed.to.system.out.display.name='Throwable' printed to 'System.out'
2020 throwable.printed.to.system.out.problem.descriptor='Throwable' argument <code>#ref</code> to ''System.{0}.{1}()'' call
2021 suppress.for.tests.scope.quickfix=Suppress for 'Tests' scope
2022 implicit.default.charset.usage.display.name=Implicit usage of platform's default charset
2023 implicit.default.charset.usage.problem.descriptor=Call to <code>#ref()</code> uses the platform's default charset
2024 implicit.default.charset.usage.constructor.problem.descriptor=<code>new #ref()</code> call uses the platform's default charset
2025 interface.may.be.annotated.functional.display.name=Interface may be annotated @FunctionalInterface
2026 interface.may.be.annotated.functional.problem.descriptor=Interface <code>#ref</code> may be annotated with @FunctionalInterface
2027 only.report.public.methods.option=Only report 'public' methods
2028 lambda.parameter.hides.member.variable.display.name=Lambda parameter hides field
2029 static.initializer.references.subclass.display.name=Static initializer references subclass
2030 lambda.parameter.hides.member.variable.problem.descriptor=Lambda parameter <code>#ref</code> hides field in class ''{0}'' #loc
2031 lambda.parameter.hides.member.variable.ignore.invisible.option=Ignore fields not actually visible from the lambda
2032 shared.thread.local.random.display.name='ThreadLocalRandom' instance might be shared
2033 shared.thread.local.random.problem.descriptor='ThreadLocalRandom' instance might be shared between threads
2034 native.method.naming.convention.display.name='native' method naming convention
2035 native.method.naming.convention.element.description='native' method
2036 use.of.obsolete.date.time.api.display.name=Use of obsolete date-time API
2037 use.of.obsolete.date.time.api.problem.descriptor=Obsolete date-time type <code>#ref</code> used #loc
2038 warn.on.label=Warn on:
2039 all.levels.option=all log levels
2040 warn.level.and.lower.option=warn level and lower
2041 info.level.and.lower.option=info level and lower
2042 debug.level.and.lower.option=debug level and lower
2043 trace.level.option=trace level
2044 ignored.autocloseable.types.column.label=Ignored AutoCloseable resource types
2045 choose.autocloseable.type.to.ignore.title=Choose AutoCloseable resource type to ignore
2046 big.decimal.method.without.rounding.called.display.name=Call to 'BigDecimal' method without a rounding mode argument
2047 big.decimal.method.without.rounding.called.problem.descriptor='BigDecimal.#ref()' called without a rounding mode argument
2048 bigdecimal.legacy.method.display.name='BigDecimal' legacy method called
2049 bigdecimal.legacy.method.problem.descriptor=Call to 'BigDecimal.#ref()' can use 'RoundingMode' enum constant
2050 bigdecimal.legacy.method.quickfix=Use 'RoundingMode' enum constant
2051 serializable.stores.non.serializable.display.name=Serializable object implicitly stores non-Serializable object
2052 serializable.lambda.stores.non.serializable.problem.descriptor=Serializable lambda implicitly stores non-Serializable object of type ''{0}''
2053 serializable.local.class.stores.non.serializable.problem.descriptor=Serializable local class ''{1}'' implicitly stores non-Serializable object of type ''{0}''
2054 serializable.anonymous.class.stores.non.serializable.problem.descriptor=Serializable anonymous class implicitly stores non-Serializable object of type ''{0}''
2055 assignment.to.lambda.parameter.display.name=Assignment to lambda parameter
2056 assignment.to.lambda.parameter.problem.descriptor=Assignment to lambda parameter <code>#ref</code> #loc
2057 class.with.only.private.constructors.display.name=Class with only 'private' constructors should be declared 'final'
2058 class.with.only.private.constructors.problem.descriptor=Class <code>#ref</code> with only 'private' constructors should be declared 'final'
2059 property.value.set.to.itself.display.name=Property value set to itself
2060 equals.with.itself.display.name='equals()' called on itself
2061 equals.with.itself.problem.descriptor=<code>#ref()</code> called on itself
2062 junit4.method.naming.convention.display.name=JUnit 4 test method naming convention
2063 junit4.method.naming.convention.element.description=JUnit 4 test method
2064 junit3.method.naming.convention.display.name=JUnit 3 test method naming convention
2065 junit3.method.naming.convention.element.description=JUnit 3 test method
2066 introduce.holder.class.quickfix=Introduce holder class
2067 double.brace.initialization.display.name=Double brace initialization
2068 double.brace.initialization.quickfix=Replace with regular initialization
2069 return.of.inner.class.display.name=Return of instance of anonymous, local or inner class
2070 return.of.anonymous.class.problem.descriptor=Return of instance of anonymous class #loc
2071 return.of.local.class.problem.descriptor=Return of instance of local class <code>{0}</code> #loc
2072 return.of.inner.class.problem.descriptor=Return of instance of non-static inner class <code>{0}</code> #loc
2073 return.of.inner.class.ignore.non.public.option=Ignore returns from non-public methods
2074 parameter.type.prevents.overriding.display.name=Parameter type prevents overriding
2075 parameter.type.prevents.overriding.problem.descriptor=Parameter type <code>#ref</code> is located in ''{0}'' while super method parameter type is located in ''{1}'' preventing overriding #loc
2076 parameter.type.prevents.overriding.quickfix=Change type of parameter to ''{0}''
2077 parameter.type.prevents.overriding.family.quickfix=Change type of parameter
2078 suspicious.getter.setter.display.name=Suspicious getter/setter
2079 suspicious.setter.problem.descriptor=Setter <code>#ref()</code> assigns field ''{0}'' #loc
2080 suspicious.getter.problem.descriptor=Getter <code>#ref()</code> returns field ''{0}'' #loc
2081 unnecessary.break.display.name=Unnecessary 'break' statement
2082 unnecessary.break.problem.descriptor=<code>#ref</code> statement is unnecessary #loc
2083 utility.class.can.be.enum.display.name=Utility class can be 'enum'
2084 utility.class.code.can.be.enum.problem.descriptor=Utility class <code>\#ref</code> can be 'enum' #loc
2085 utility.class.code.can.be.enum.quickfix=Convert to 'enum'
2086 non.public.clone.display.name='clone()' method not 'public'
2087 non.public.clone.problem.descriptor=<code>#ref()</code> method not 'public' #loc
2088 only.warn.on.public.clone.methods=Only warn on 'public' clone methods
2089 only.warn.on.protected.clone.methods=Only warn on 'protected' clone methods
2090 clone.returns.class.type.display.name='clone()' should have return type equal to the class it contains
2091 clone.returns.class.type.problem.descriptor=''clone()'' should have return type ''{0}'' #loc
2092 clone.returns.class.type.quickfix=Change return type to ''{0}''
2093 clone.returns.class.type.family.quickfix=Change return type to class type
2094 use.of.clone.display.name=Use of 'clone()' or 'Cloneable'
2095 use.of.clone.call.problem.descriptor=Call to <code>#ref()</code>
2096 use.of.clone.call.method.problem.descriptor=Implementation of <code>#ref()</code>
2097 use.of.clone.reference.problem.descriptor=Use of <code>#ref</code>
2098 dangling.javadoc.display.name=Dangling Javadoc comment
2099 dangling.javadoc.problem.descriptor=Dangling Javadoc comment #loc
2100 dangling.javadoc.convert.quickfix=Replace with block comment
2101 dangling.javadoc.delete.quickfix=Remove dangling comment
2102 equals.replaceable.by.objects.call.display.name='equals()' expression replaceable by 'Objects.equals()' expression
2103 equals.replaceable.by.objects.call.problem.descriptor=<code>#ref</code> replaceable by 'Objects.equals()' expression #loc
2104 equals.replaceable.by.objects.call.quickfix=Replace with 'Objects.equals()' expression
2105 equals.replaceable.by.objects.check.not.null.option=Report only null safe 'equals' calls
2106 array.objects.equals.display.name='Objects.equals()' called on arrays
2107 array.objects.equals.problem.descriptor=<code>Objects.#ref()</code> on arrays should probably be 'Arrays.equals()' #loc
2108 array.objects.deep.equals.problem.descriptor=<code>Objects.#ref()</code> on arrays should probably be 'Arrays.deepEquals()' #loc
2109 extends.throwable.display.name=Class directly extends 'java.lang.Throwable'
2110 anonymous.extends.throwable.problem.descriptor=Anonymous class directly extends 'java.lang.Throwable' #loc
2111 extends.throwable.problem.descriptor=class <code>#ref</code> directly extends 'java.lang.Throwable' #loc
2112 lambda.parameter.naming.convention.display.name=Lambda parameter naming convention
2113 lambda.parameter.naming.convention.element.description=Lambda parameter
2114 assert.message.not.string.display.name='assert' message is not a String
2115 assert.message.of.type.boolean.problem.descriptor=''assert'' message of type ''{0}'' #loc
2116 assert.message.not.string.only.warn.boolean.option=Only warn when 'assert' message is 'boolean' or 'java.lang.Boolean'
2117 suspicious.literal.underscore.display.name=Suspicious underscore in number literal
2118 suspicious.literal.underscore.problem.descriptor=Group in number literal with underscores does not have length 3 #loc
2119 unary.plus.quickfix=Remove unary '+'
2120 super.tear.down.in.finally.display.name='super.tearDown()' not called from 'finally' block
2121 super.tear.down.in.finally.problem.descriptor=<code>#ref()</code> not called from 'finally' block #loc
2122 confusing.floating.point.literal.option=Ignore floating point literals in scientific notation
2123 class.may.be.interface.java8.option=Report classes containing non-abstract methods when using Java 8
2124 simplifiable.boolean.expression.display.name=Simplifiable boolean expression
2125 unnecessary.initcause.display.name=Unnecessary call to 'Throwable.initCause()'
2126 unnecessary.initcause.problem.descriptor=Unnecessary <code>Throwable.#ref()</code> call
2127 unnecessary.initcause.quickfix=Remove 'Throwable.initCause()' call
2128 consider.static.final.fields.constant.option=Consider 'static final' fields constant
2129 atomic.field.updater.not.static.final.display.name=AtomicFieldUpdater field not declared 'static final'
2130 atomic.field.updater.not.static.final.problem.descriptor={0} field <code>#ref</code> is not declared ''static final'' #loc
2131 atomic.field.updater.issues.display.name=AtomicFieldUpdater issues
2132 field.not.found.in.class.problem.descriptor=No field named ''{0}'' found in class ''{1}''
2133 field.incorrect.type.problem.descriptor=Field ''{0}'' does not have type ''{1}''
2134 field.missing.volatile.modifier.problem.descriptor=Field ''{0}'' does not have ''volatile'' modifier
2135 field.has.static.modifier.problem.descriptor=Field ''{0}'' has ''static'' modifier
2136 private.field.not.accessible.problem.descriptor=''private'' field ''{0}'' is not accessible from here
2137 package.local.field.not.accessible=package-private field ''{0}'' is not accessible from here
2138 protected.field.not.accessible.problem.descriptor=''protected'' field ''{0}'' is not accessible from here
2139 interface.clashes.with.object.class.display.name=Interface method clashes with method in 'java.lang.Object'
2140 interface.clashes.with.object.class.problem.descriptor=<code>#ref()</code> clashes with method in 'java.lang.Object'
2141 optional.used.as.field.or.parameter.type.display.name='Optional' used as field or parameter type
2142 optional.used.as.field.type.problem.descriptor=<code>#ref</code> used as type for field ''{0}''
2143 optional.used.as.parameter.type.problem.descriptor=<code>#ref</code> used as type for parameter ''{0}''
2144 lambda.unfriendly.method.overload.display.name=Lambda unfriendly method overload
2145 lambda.unfriendly.method.overload.problem.descriptor=Lambda unfriendly overload of method <code>#ref()</code>
2146 lambda.unfriendly.constructor.overload.problem.descriptor=Lambda unfriendly overload of constructor <code>#ref()</code>
2147 optional.contains.collection.display.name='Optional' contains array or collection
2148 optional.contains.collection.problem.descriptor='Optional' contains collection <code>#ref</code>
2149 optional.contains.array.problem.descriptor='Optional' contains array <code>#ref</code>
2150 optional.get.without.is.present.display.name='Optional.get()' without 'isPresent()' check
2151 optional.get.without.is.present.problem.descriptor=<code>{0}.#ref()</code> without ''isPresent()'' check
2152 synchronization.on.get.class.display.name=Synchronization on 'getClass()'
2153 synchronization.on.get.class.problem.descriptor=Synchronization on <code>#ref()</code> #loc
2154 object.instantiation.inside.equals.or.hashcode.display.name=Object instantiation inside 'equals()' or 'hashCode()'
2155 object.instantiation.inside.equals.or.hashcode.problem.descriptor=Object instantiation inside ''{0}()'' #loc
2156 object.instantiation.inside.equals.or.hashcode.problem.descriptor2=Object instantiation inside ''{0}()'' ({1})#loc
2157 lambda.body.can.be.code.block.name=Lambda body can be code block
2158 lambda.body.can.be.code.block.quickfix=Expand lambda body to {...}
2159 lambda.parameter.type.can.be.specified.name=Lambda parameter type can be specified
2160 lambda.parameter.type.can.be.specified.descriptor=Lambda can be expanded to {0} -> '{'...'}'
2161 lambda.parameter.type.can.be.specified.quickfix=Expand lambda to {0} -> '{'...'}'
2162 lambda.parameter.type.can.be.specified.family.quickfix=Specify lambda parameter type
2163 diamond.can.be.replaced.with.explicit.type.arguments.name=Diamond can be replaced with explicit type arguments
2164 diamond.can.be.replaced.with.explicit.type.arguments.quickfix=Replace '<>' with explicit type arguments
2165 lambda.can.be.replaced.with.anonymous.name=Lambda can be replaced with anonymous class
2166 lambda.can.be.replaced.with.anonymous.quickfix=Replace lambda with anonymous class
2167 method.ref.can.be.replaced.with.lambda.name=Method reference can be replaced with lambda
2168 method.ref.can.be.replaced.with.lambda.quickfix=Replace method reference with lambda
2169 try.statement.with.multiple.resources.name=Try statement with multiple resources can be split
2170 try.statement.with.multiple.resources.quickfix=Split 'try' statement with multiple resources
2171 multi.catch.can.be.split.name=Multi-catch can be split into separate catch blocks
2172 multi.catch.can.be.split.quickfix=Split multi-catch into separate 'catch' blocks
2173 assertion.can.be.if.name=Assertion can be replaced with if statement
2174 assert.can.be.if.quickfix=Replace 'assert' with 'if' statement
2175 if.can.be.assertion.name=If statement can be replaced with assertion
2176 if.can.be.assertion.quickfix=Replace 'if' with 'assert' statement
2177 equality.operator.compares.objects.name=Objects compared with '=='
2178 equality.operator.compares.objects.descriptor=Objects compared with ''{0}''
2179 equality.operator.compares.objects.quickfix=Replace ''{0}'' with ''{1}equals()''
2180 equality.operator.compares.objects.family.quickfix=Replace equality operator with equals()
2181 equality.operator.compares.objects.safe.quickfix=Replace ''{0}'' with safe ''{1}equals()''
2182 equality.operator.compares.objects.safe.family.quickfix=Replace equality operator with safe equals()
2183 single.statement.in.block.name=Code block contains single statement
2184 single.statement.in.block.descriptor=''{0}'' contains single statement
2185 single.statement.in.block.quickfix=Remove braces from ''{0}'' statement
2186 single.statement.in.block.family.quickfix=Remove braces from statement
2187 single.element.annotation.name=Single-element annotation
2188 single.element.annotation.quickfix=Add 'value='
2189 single.element.annotation.family.quickfix=Expand annotation to normal form
2190 array.creation.without.new.keyword.name=Array creation without 'new' expression
2191 array.creation.without.new.keyword.quickfix=Add ''new {0}''
2192 array.creation.without.new.keyword.family.quickfix=Add 'new' expression
2193 malformed.set.up.tear.down.display.name=Malformed 'setUp()' or 'tearDown()'
2194 malformed.set.up.tear.down.problem.descriptor='#ref()' has incorrect signature #loc
2195 method.missing.return.statement.display.name=Method contains logic but is missing a 'return' statement
2196 method.missing.return.statement.problem.descriptor=Method <code>#ref</code> contains logic but is missing a 'return' statement
2197 overly.long.lambda.display.name=Overly long lambda expression
2198 overly.long.lambda.problem.descriptor=Lambda expression is too long (# Non-comment source statements = {0}) #loc
2199 wait.notify.not.in.synchronized.context.display.name='wait()' or 'notify()' while not synchronized
2200 wait.notify.while.not.synchronized.on.problem.descriptor=Call to <code>#ref</code> while not synchronized on ''{0}'' #loc