add.explicit.type.arguments=Add explicit type arguments

# suppress inspection "UnusedProperty"
annotation.target.ANNOTATION_TYPE=annotation type
# suppress inspection "UnusedProperty"
annotation.target.CONSTRUCTOR=constructor
# suppress inspection "UnusedProperty"
annotation.target.FIELD=field
# suppress inspection "UnusedProperty"
annotation.target.LOCAL_VARIABLE=local variable
# suppress inspection "UnusedProperty"
annotation.target.METHOD=method
# suppress inspection "UnusedProperty"
annotation.target.MODULE=module
# suppress inspection "UnusedProperty"
annotation.target.PACKAGE=package
# suppress inspection "UnusedProperty"
annotation.target.PARAMETER=parameter
# suppress inspection "UnusedProperty"
annotation.target.RECORD_COMPONENT=record component
# suppress inspection "UnusedProperty"
annotation.target.TYPE=type
# suppress inspection "UnusedProperty"
annotation.target.TYPE_PARAMETER=type parameter
# suppress inspection "UnusedProperty"
annotation.target.TYPE_USE=type use

change.type.arguments=Change type arguments
change.type.arguments.to.0=Change type arguments to <{0}>
convert.0.to.float=Convert ''{0}'' to float

dataflow.message.array.index.out.of.bounds=Array index is out of bounds
dataflow.message.arraystore=Storing element of type <code>{0}</code> to array of <code>{1}</code> elements may produce <code>ArrayStoreException</code>
dataflow.message.assigning.null.notannotated=Assigning <code>null</code> value to non-annotated field
dataflow.message.assigning.null=<code>null</code> is assigned to a variable that is annotated with @NotNull
dataflow.message.assigning.nullable.notannotated=Expression <code>#ref</code> #loc might be null but is assigned to non-annotated field
dataflow.message.assigning.nullable=Expression <code>#ref</code> might evaluate to null but is assigned to a variable that is annotated with @NotNull
dataflow.message.cce.always=Casting <code>{0}</code> to <code>#ref</code> #loc will produce <code>ClassCastException</code> for any non-null value
dataflow.message.cce=Casting <code>{0}</code> to <code>#ref</code> #loc may produce <code>ClassCastException</code>
dataflow.message.constant.condition.when.reached=Condition <code>#ref</code> #loc is always <code>{0, choice, 0#false|1#true}</code> when reached
dataflow.message.constant.condition=Condition <code>#ref</code> #loc is always <code>{0, choice, 0#false|1#true}</code>
dataflow.message.constant.method.reference=Method reference result is always ''{0}''
dataflow.message.constant.no.ref=Condition is always {0, choice, 0#false|1#true}
dataflow.message.contract.fail.index=The call to '#ref' always fails as index is out of bounds
dataflow.message.contract.fail=The call to '#ref' always fails, according to its method contracts
dataflow.message.immutable.modified=Immutable object is modified
dataflow.message.immutable.passed=Immutable object is passed where mutable is expected
dataflow.message.npe.array.access.sure=Array access <code>#ref</code> #loc will produce <code>NullPointerException</code>
dataflow.message.npe.array.access=Array access <code>#ref</code> #loc may produce <code>NullPointerException</code>
dataflow.message.npe.field.access.sure=Dereference of <code>#ref</code> #loc will produce <code>NullPointerException</code>
dataflow.message.npe.field.access=Dereference of <code>#ref</code> #loc may produce <code>NullPointerException</code>
dataflow.message.npe.inner.class.construction.sure=Inner class construction will produce <code>NullPointerException</code>
dataflow.message.npe.inner.class.construction=Inner class construction may produce <code>NullPointerException</code>
dataflow.message.npe.method.invocation.sure=Method invocation <code>#ref</code> #loc will produce <code>NullPointerException</code>
dataflow.message.npe.method.invocation=Method invocation <code>#ref</code> #loc may produce <code>NullPointerException</code>
dataflow.message.npe.methodref.invocation=Method reference invocation <code>#ref</code> #loc may produce <code>NullPointerException</code>
dataflow.message.only.switch.label=Switch label <code>#ref</code> #loc is the only reachable in the whole switch
dataflow.message.passing.null.argument.nonannotated=Passing <code>null</code> argument to non-annotated parameter
dataflow.message.passing.null.argument=Passing <code>null</code> argument to parameter annotated as @NotNull
dataflow.message.passing.nullable.argument.methodref.nonannotated=Method reference argument might be null but passed to non-annotated parameter
dataflow.message.passing.nullable.argument.methodref=Method reference argument might be null
dataflow.message.passing.nullable.argument.nonannotated=Argument <code>#ref</code> #loc might be null but passed to non-annotated parameter
dataflow.message.passing.nullable.argument=Argument <code>#ref</code> #loc might be null
dataflow.message.pointless.assignment.expression=Condition <code>#ref</code> #loc at the left side of assignment expression is always <code>{0}</code>. Can be simplified
dataflow.message.pointless.same.arguments=Arguments of '#ref' are the same. Calling this method with the same arguments is meaningless.
dataflow.message.redundant.assignment=Variable is already assigned to this value
dataflow.message.redundant.instanceof=Condition <code>#ref</code> #loc is redundant and can be replaced with a null check
dataflow.message.redundant.update=Variable update does nothing
dataflow.message.return.null.from.notnull=<code>null</code> is returned by the method declared as @{0}
dataflow.message.return.null.from.notnullable=<code>null</code> is returned by the method which is not declared as @{0}
dataflow.message.return.nullable.from.notnull.function=Function may return null, but it's not allowed here
dataflow.message.return.nullable.from.notnull=Expression <code>#ref</code> might evaluate to null but is returned by the method declared as @{0}
dataflow.message.return.nullable.from.notnullable=Expression <code>#ref</code> might evaluate to null but is returned by the method which is not declared as @{0}
dataflow.message.storing.array.null=<code>null</code> is stored to an array of @NotNull elements
dataflow.message.storing.array.nullable=Expression <code>#ref</code> might evaluate to null but is stored to an array of @NotNull elements
dataflow.message.unboxing.method.reference=Use of <code>#ref</code> #loc would need unboxing which may produce <code>NullPointerException</code>
dataflow.message.unboxing=Unboxing of <code>#ref</code> #loc may produce <code>NullPointerException</code>
dataflow.message.unreachable.switch.label=Switch label <code>#ref</code> #loc is unreachable
dataflow.method.fails.with.null.argument=Method will throw an exception when parameter is null
dataflow.not.precise={0} is complex: data flow results could be imprecise
dataflow.too.complex={0} is too complex to analyze by data flow algorithm

delete.repeated.0=Delete repeated ''{0}''
delete.repeated.interface=Delete repeated interface
exception.removal.will.break.source.code.proceed.anyway=Exception removal will break source code. Proceed anyway?

feature.generics=Generics
feature.annotations=Annotations
feature.static.imports=Static imports
feature.for.each=For-each loops
feature.varargs=Variable arity methods
feature.hex.fp.literals=Hexadecimal floating point literals
feature.diamond.types=Diamond types
feature.multi.catch=Multi-catches
feature.try.with.resources=Try-with-resources
feature.binary.literals=Binary literals
feature.underscores.in.literals=Underscores in literals
feature.extension.methods=Extension methods
feature.method.references=Method references
feature.lambda.expressions=Lambda expressions
feature.type.annotations=Type annotations
feature.type.receivers=Receiver parameters
feature.intersections.in.casts=Intersection types in casts
feature.static.interface.calls=Static interface method calls
feature.try.with.resources.refs=Resource references
feature.modules=Modules
feature.lvti=Local variable type inference
feature.text.blocks=Text block literals
feature.enhanced.switch=Enhanced 'switch' blocks
feature.switch.expressions='switch' expressions
feature.records=Records
feature.patterns.instanceof=Patterns in 'instanceof'
feature.text.block.escape.sequences='\\s' and '\\' escape sequences

find.searching.for.references.to.class.progress=Searching for references to class {0}...
find.usages.panel.title.derived.classes=Derived Classes
find.usages.panel.title.derived.interfaces=Derived Interfaces
find.usages.panel.title.implementing.classes=Implementing Classes
find.usages.panel.title.implementing.methods=Implementing Methods
find.usages.panel.title.overloaded.methods.usages=Overloaded Methods Usages
find.usages.panel.title.overriding.methods=Overriding Methods
get.class.in.accessible.message.class.0.is.not.accessible.from.module=Class ''{0}'' is not accessible from module ''{1}''
get.class.in.accessible.message.class.0.is.not.accessible.here=Class ''{0}'' is not accessible here

inspection.i18n.quickfix.annotate=Annotate...
inspection.i18n.quickfix.annotate.as=Annotate as @{0}
inspection.i18n.quickfix.annotate.element=Annotate {0} ''{1}''...
inspection.i18n.quickfix.annotate.element.as=Annotate {0} ''{1}'' as @{2}
inspection.reference.default.package=<default>
error.message.invalid.java.type=Invalid Java type
move.0.to.the.beginning=Move ''{0}'' to the beginning
move.to.front=Move to front
processing.method.usages=Processing Method Usages...
qualify.0=Qualify {0}
qualify.with.0.this=Qualify with {0}.this
remove.annotation=Remove annotation
remove.left.side.of.assignment=Remove left side of assignment
replace.get.class.with.class.literal=Replace getClass() with .class literal
service.provides=Provides service <a href="#javaClass/{0}">{0}</a><br><div style='margin-top: 5px'><font size='2'>Click to navigate</font></div>
service.uses=Uses service <a href="#javaClass/{0}">{0}</a><br><div style='margin-top: 5px'><font size='2'>Click to navigate</font></div>
suppress.for.parameter=Suppress for parameter
suppress.for.statement.with.comment=Suppress for statement with comment
intention.add.annotation.family=Add Annotation
intention.text.remove.annotation=Remove

0.field.is.always.initialized.not.null=@{0} field is always initialized not-null
access.can.be.0=Access can be {0}
access.to.field.code.ref.code.outside.of.declared.guards.loc=Access to field <code>#ref</code> outside of declared guards #loc
annotate.as.safevarargs=Annotate as @SafeVarargs
annotate.overridden.methods.parameters.family.name=Annotate overridden method parameters
annotate.overridden.methods.parameters=Annotate overridden method parameters as ''@{0}''
anonymous.ref.loc.can.be.replaced.with.0=Anonymous #ref #loc can be replaced with {0}
anonymous.ref.loc.can.be.replaced.with.lambda=Anonymous #ref #loc can be replaced with lambda
assigning.a.collection.of.nullable.elements=Assigning a collection of nullable elements into a collection of non-null elements
comparision.between.object.and.primitive=Comparision between Object and primitive is illegal and is accepted in java 7 only
custom.exception.class.should.have.a.constructor=Custom exception class should have a constructor with a single message parameter of String type
delimiters.argument.contains.duplicated.characters=Delimiters argument contains duplicated characters
deprecated.class.usage.group.xml=XML
deprecated.member.0.is.still.used=Deprecated member ''{0}'' is still used
detach.library.quickfix.name=Detach library
detach.library.roots.quickfix.name=Detach unused library roots
don.t.report.unused.jars.inside.used.library=Don't report unused jars inside used library
explicit.type.argument.ref.loc.can.be.replaced.with=Explicit type argument #ref #loc can be replaced with <>
exports.to.itself.delete.module.ref.fix=Delete reference to module ''{0}''
exports.to.itself.delete.statement.fix=Delete directive
html.classes.exposed.with.code.module.info.code.html=<html>Classes exposed with <code>module-info</code></html>
html.ignore.overrides.of.deprecated.abstract.methods=<html>Ignore overrides of deprecated abstract methods from non-deprecated supers</html>
ignore.casts.in.suspicious.collections.method.calls=Ignore casts in suspicious collections method calls
ignore.exceptions.thrown.by.entry.points.methods=Ignore exceptions thrown by entry points methods
ignore.in.the.same.outermost.class=Ignore in the same outermost class
ignore.inside.deprecated.members=Ignore inside deprecated members
ignore.inside.non.static.imports=Ignore inside non-static imports
ignore.members.of.deprecated.classes=Ignore members of deprecated classes
ignore.operation.which.results.in.negative.value=Ignore '<<' operation which results in negative value
inspection.annotate.method.quickfix.family.name=Annotate method
inspection.annotate.overridden.method.and.self.quickfix.family.name=Annotate overridden methods and self
inspection.annotate.overridden.method.quickfix.family.name=Annotate overridden methods
inspection.c.style.array.declarations.option=Ignore C-style declarations in variables
inspection.can.be.final.accept.quickfix=Make final
inspection.can.be.final.option1=Report methods
inspection.can.be.final.option2=Report fields
inspection.can.be.final.option=Report classes
inspection.can.be.local.parameter.problem.descriptor=Parameter <code>#ref</code> can have <code>final</code> modifier
inspection.can.be.local.variable.problem.descriptor=Variable <code>#ref</code> can have <code>final</code> modifier
inspection.can.be.replaced.with.message=Can be replaced with ''{0}''
inspection.class.getclass.display.name=Class.getClass() call
inspection.class.getclass.fix.remove.name=Remove 'getClass()' call
inspection.class.getclass.fix.replace.name=Replace with 'Class.class'
inspection.class.getclass.message='getClass()' is called on Class instance
inspection.class.has.no.to.string.method.description=Class ''{0}'' does not override ''toString()'' method
inspection.class.has.no.to.string.method.exclude.classes.reg.exp.option=Exclude classes (reg exp):
inspection.class.has.no.to.string.method.ignore.abstract.classes.option=Ignore abstract classes
inspection.class.has.no.to.string.method.ignore.deprecated.classes.option=Ignore deprecated classes
inspection.class.has.no.to.string.method.ignore.enum.classes.option=Ignore enum classes
inspection.class.has.no.to.string.method.ignore.exception.classes.option=Ignore exception classes
inspection.class.has.no.to.string.method.ignore.inner.classes.option=Ignore inner classes
inspection.class.has.no.to.string.method.ignore.test.classes.option=Ignore test classes
inspection.common.if.parts.disable.highlight.tail.call=Do not highlight common parts, if tail statement is call
inspection.common.if.parts.family.else.if.description='else if' can be merged
inspection.common.if.parts.family.else.if=Merge 'else if' statement
inspection.common.if.parts.family=Extract common parts of 'if' statement
inspection.common.if.parts.settings.highlight.when.tail.call=Highlight when last common statement is call
inspection.compiler.javac.quirks.anno.array.comma.fix=Remove trailing comma
inspection.compiler.javac.quirks.anno.array.comma.problem=Trailing comma in annotation array initializer may cause compilation error in some Javac versions (e.g. JDK 5 and JDK 6).
inspection.compiler.javac.quirks.name=Javac quirks
inspection.compiler.javac.quirks.qualifier.type.args.fix=Remove generic parameter
inspection.compiler.javac.quirks.qualifier.type.args.problem=Generics in qualifier reference may cause compilation error in some Javac versions (e.g. JDK 5 and JDK 6).
inspection.constant.on.wrong.side.of.a.comparison.side.option=Constant should be on this side of a comparison:
inspection.contract.display.name=Contract issues
inspection.data.flow.redundant.instanceof.quickfix=Replace with a null check
inspection.data.flow.simplify.boolean.expression.quickfix=Simplify boolean expression
inspection.data.flow.simplify.to.assignment.quickfix.name=Simplify to normal assignment
inspection.data.flow.turn.off.constant.references.quickfix=Don't report values which are guaranteed to be constant
inspection.data.flow.turn.off.nullable.returning.notnull.quickfix=Don't report nullable methods which always return not-null value
inspection.data.flow.turn.off.true.asserts.quickfix=Don't report always true assertions
inspection.duplicate.throws.display.name=Duplicate throws
inspection.duplicate.throws.ignore.subclassing.option=Ignore exceptions subclassing others
inspection.duplicate.throws.more.general.problem=There is a more general exception, ''{0}'', in the throws list already.
inspection.duplicate.throws.problem=Duplicate throws
inspection.equals.hashcode.only.one.defined.problem.descriptor=Class has {0} defined but does not define {1}
inspection.export.results.can.be.final.description=Declaration can have final modifier
inspection.field.not.used.in.to.string.description2=Field ''{0}'' is not used in ''toString()'' method
inspection.field.not.used.in.to.string.description=Method ''{0}'' is not used in ''toString()'' method
inspection.implicit.subclass.display.forClass=Class ''{0}'' could be implicitly subclassed and must not be final
inspection.implicit.subclass.display.name=Final declaration can't be overridden at runtime
inspection.implicit.subclass.extendable=Make ''{0}'' overridable
inspection.implicit.subclass.make.class.extendable=Make class ''{0}'' {1,choice,0#|1#and method {2} |1<and {1} required methods }extendable
inspection.infinite.loop.option=Ignore when placed in Thread.run
inspection.java.module.naming.terminal.digits=Module name component ''{0}'' should avoid terminal digits
inspection.java.module.naming=Java module naming conventions
inspection.local.can.be.final.display.name=Local variable or parameter can be final
inspection.local.can.be.final.option1=Report method parameters
inspection.local.can.be.final.option2=Report catch parameters
inspection.local.can.be.final.option3=Report foreach parameters
inspection.local.can.be.final.option4=Report variables which are implicit final
inspection.local.can.be.final.option=Report local variables
inspection.module.exports.package.to.itself=Module exports/opens package to itself
inspection.nullable.problems.NotNull.parameter.overrides.Nullable=Parameter annotated @{0} must not override @{1} parameter
inspection.nullable.problems.NotNull.parameter.overrides.not.annotated=Parameter annotated @{0} should not override non-annotated parameter
inspection.nullable.problems.NotNull.parameter.receives.null.literal=Parameter annotated @{0} should not receive ''null'' as an argument
inspection.nullable.problems.Nullable.NotNull.conflict=Cannot annotate with both @{0} and @{1}
inspection.nullable.problems.Nullable.method.overrides.NotNull=Method annotated with @{0} must not override @{1} method
inspection.nullable.problems.annotated.field.constructor.parameter.not.annotated=Constructor parameter for @{0} field might be annotated @{0} itself
inspection.nullable.problems.annotated.field.getter.conflict=Getter for @{0} field is annotated @{1}
inspection.nullable.problems.annotated.field.getter.not.annotated=Getter for @{0} field might be annotated @{0} itself
inspection.nullable.problems.annotated.field.setter.parameter.conflict=Setter parameter for @{0} field is annotated @{1}
inspection.nullable.problems.annotated.field.setter.parameter.not.annotated=Setter parameter for @{0} field might be annotated @{0} itself
inspection.nullable.problems.method.overrides.NotNull=Not annotated method overrides method annotated with @{0}
inspection.nullable.problems.parameter.overrides.NotNull=Not annotated parameter overrides @{0} parameter
inspection.nullable.problems.primitive.type.annotation=Primitive type members cannot be annotated
inspection.objects.equals.can.be.simplified.display.name=Objects.equals() can be replaced with equals()
inspection.redundant.cast.problem.descriptor=Casting {0} to {1} is redundant
inspection.redundant.cast.remove.quickfix=Remove redundant cast(s)
inspection.redundant.field.initialization.option=Only warn on initialization to null
inspection.redundant.requires.statement.description=Redundant directive ''requires {0}''
inspection.redundant.requires.statement.fix.family=Delete redundant 'requires' directive
inspection.redundant.requires.statement.fix.name=Delete directive ''requires {0}''
inspection.redundant.throws.problem.descriptor1=The declared exception {0} is never thrown in this method, nor in its derivables
inspection.redundant.throws.problem.descriptor2=The declared exception {0} is never thrown
inspection.redundant.throws.problem.descriptor=The declared exception {0} is never thrown in method implementations
inspection.redundant.throws.remove.quickfix=Remove unnecessary 'throws' declarations
inspection.redundant.type.display.name=Redundant type arguments
inspection.redundant.type.no.generics.method.reference.problem.descriptor=Type arguments are redundant for the non-generic method reference
inspection.redundant.type.no.generics.problem.descriptor=Type arguments are redundant for the non-generic method call
inspection.redundant.type.problem.descriptor=Explicit type arguments can be inferred
inspection.redundant.type.remove.quickfix=Remove type arguments
inspection.reference.anonymous.name=anonymous ({0})
inspection.reference.implicit.constructor.name=implicit constructor of {0}
inspection.reference.jsp.holder.method.anonymous.name=<% page content %>
inspection.requires.auto.module.message='requires' directive for an automatic module
inspection.requires.auto.module.option=Highlight only transitive dependencies
inspection.requires.auto.module.transitive='requires transitive' directive for an automatic module
inspection.requires.auto.module=Dependencies on automatic modules
inspection.same.return.value.display.name=Method returns the same value
inspection.same.return.value.problem.descriptor1=Method and all its derivables always return {0}
inspection.same.return.value.problem.descriptor2=All implementations of this method always return {0}
inspection.same.return.value.problem.descriptor=Method always returns {0}
inspection.surround.requirenonnull.quickfix=Replace with ''Objects.requireNonNull({0})''
inspection.suspicious.array.method.call.display.name=Suspicious Arrays method calls
inspection.suspicious.array.method.call.problem.arrays=Array types are incompatible: arrays are always different
inspection.suspicious.array.method.call.problem.element=Element type is not compatible with array type
inspection.suspicious.collections.method.calls.display.name=Suspicious collections method calls
inspection.suspicious.collections.method.calls.problem.descriptor1=Suspicious call to ''{0}''
inspection.suspicious.collections.method.calls.problem.descriptor=''{0}'' may not contain {2} of type ''{1}''
inspection.suspicious.getter.setter.field.option=Only warn when field matching getter/setter name is present
inspection.suspicious.integer.div.assignment.option=Report suspicious but possibly exact divisions
inspection.test.only.problems.display.name=Test-only class or method call in production code
inspection.test.only.problems.test.only.class.reference=Test-only class is referenced in production code
inspection.test.only.problems.test.only.field.reference=Test-only field is referenced in production code
inspection.test.only.problems.test.only.method.call=Test-only method is called in production code
inspection.unary.plus.unary.binary.option=Only report in confusing binary or unary expression context
inspection.unnecessary.super.qualifier.option=Ignore clarification 'super' qualifier
inspection.use.compare.method.fix.family.name=Replace with single comparison method
inspection.visibility.accept.quickfix=Accept suggested access level
inspection.visibility.compose.suggestion=Can be {0}
inspection.visibility.option.constants=Suggest weaker visibility for constants
inspection.visibility.option.package.private.members=Suggest package-private visibility level for class members
inspection.visibility.package.private.top.level.classes=Suggest package-private visibility level for top-level classes
inspection.visibility.private.inner.members=<html>Suggest private for inner class members when referenced from outer class only</html>
instance.member.guarded.by.static.0.loc=Instance member guarded by static "{0}" #loc
instance.member.guarded.by.static.ref.loc=Instance member guarded by static #ref #loc
junit.rule.classrule.option=Report @ClassRule problems
junit.rule.rule.option=Report @Rule problems
make.0.default.annotation=Make "{0}" default annotation
make.default.the.last.case.family.name=Make 'default' the last case
make.final.and.annotate.as.safevarargs=Make final and annotate as @SafeVarargs
method.reference.mapped.to.comparator=Method reference mapped to Comparator interface does not fulfill the Comparator contract
module.0.with.language.level.1.depends.on.module.2.with.language.level.3=Module {0} with language level {1} depends on module {2} with language level {3}
non.final.field.code.ref.code.in.immutable.class.loc=Non-final field <code>#ref</code> in @Immutable class  #loc
non.final.guarded.by.field.0.loc=Non-final @GuardedBy field "{0}" #loc
non.final.guarded.by.field.ref.loc=Non-final @GuardedBy field #ref #loc
non.null.type.argument.is.expected=Non-null type argument is expected
not.annotated.method.is.used.as.an.override.for.a.method.annotated.with.0=Not annotated method is used as an override for a method annotated with {0}
nullable.stuff.problems.overridden.method.parameters.are.not.annotated=Overridden method parameters are not annotated
nullable.stuff.problems.overridden.methods.are.not.annotated=Overridden methods are not annotated
parameter.can.be.null=Parameter can be null
parameter.is.always.not.null=Parameter is always not-null
possible.heap.pollution.from.parameterized.vararg.type.loc=Possible heap pollution from parameterized vararg type #loc
redundant.block.marker=Redundant block marker
remove.block.marker.comments=Remove block marker comments
remove.dependency=Remove dependency
remove.switch.branch.0=Remove switch branch ''{0}''
remove.switch.label.0=Remove switch label ''{0}''
remove.switch.label=Remove switch label
replace.0.with=Replace ''''{0}'''' with ''''=''''
replace.anonymous.class.with.lambda.alternative=Replace anonymous class with lambda alternative
replace.operator.assignment.with.assignment=Replace Operator Assignment with Assignment
replace.stringtokenizer.delimiters.parameter.with.unique.symbols=Replace StringTokenizer delimiters parameter with unique symbols
replace.var.with.explicit.type=Replace 'var' with explicit type
replace.with.0=Replace with {0}
replace.with.comparator=Replace with comparator
replace.with.constant.value=Replace with constant value
replace.with.expression.lambda=Replace with expression lambda
replace.with.lambda=Replace with lambda
report.suspicious.but.possibly.correct.method.calls=&Report suspicious but possibly correct method calls
report.when.interface.is.not.annotated.with.functional.interface=Report when interface is not annotated with @FunctionalInterface
searching.for.overriding.methods=Searching for Overriding Methods
statement.lambda.can.be.replaced.with.expression.lambda=Statement lambda can be replaced with expression lambda
static.inheritrance.fix.replace.progress=Replacing usages of {0}
static.member.guarded.by.instance.0.loc=Static member guarded by instance "{0}" #loc
static.member.guarded.by.instance.ref.loc=Static member guarded by instance #ref #loc
suppress.all.for.class=Suppress all inspections for class
suppress.inspection.class=Suppress for class
suppress.inspection.field=Suppress for field
suppress.inspection.member=Suppress for member
suppress.inspection.method=Suppress for method
suppress.inspection.module=Suppress for module declaration
suspected.module.dependency.problem.descriptor=Module ''{0}'' does not depend on module ''{1}''. Though ''{1}'' was not inspected for exported dependencies needed for scope ''{2}''
unknown.guardedby.reference.0.loc=Unknown @GuardedBy reference "{0}" #loc
unknown.guardedby.reference.ref.loc=Unknown @GuardedBy reference #ref #loc
unnecessary.module.dependency.display.name=Unnecessary module dependency
unnecessary.module.dependency.problem.descriptor=Module ''{0}'' sources do not depend on module ''{1}'' sources
unused.import.display.name=Unused import
unused.import.statement=Unused import statement
unused.library.display.name=Unused library
unused.library.problem.descriptor=Unused library ''{0}''
unused.library.roots.problem.descriptor=Unused roots {0} from library ''{1}''
var.can.be.replaced.with.explicit.type='var' can be replaced with explicit type
vararg.method.call.with.50.poly.arguments=Vararg method call with 50+ poly arguments may cause compilation and analysis slowdown
visible.for.testing.makes.little.sense.on.test.only.code=@VisibleForTesting makes little sense on @TestOnly code