add.explicit.type.arguments=Add explicit type arguments
add.explicit.type.arguments.then=Add explicit type arguments to then-branch call
add.explicit.type.arguments.else=Add explicit type arguments to else-branch call

change.type.arguments=Change type arguments
change.type.arguments.to.0=Change type arguments to <{0}>

dataflow.message.array.index.out.of.bounds=Array index is out of bounds
dataflow.message.negative.array.size=Negative array size
dataflow.message.arraystore=Storing element of type <code>{0}</code> to array of <code>{1}</code> elements will 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.fail=The call to '#ref' always fails with an exception
dataflow.message.contract.fail.index=The call to '#ref' always fails as an argument 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.template.invocation.sure=Template processor invocation will produce <code>NullPointerException</code>
dataflow.message.npe.template.invocation=Template processor invocation 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.passing.non.null.argument.to.optional='Optional.ofNullable()' with non-null argument should be replaced with 'Optional.of()'
dataflow.message.passing.null.argument.to.optional='Optional.ofNullable()' with null argument should be replaced with 'Optional.empty()'
dataflow.message.pointless.assignment.expression=Condition <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.pointless.same.argument.and.result=Result of ''#ref'' is the same as the {0,choice,1#first|2#second} argument making the call meaningless
dataflow.message.redundant.assignment=Variable is already assigned to this value
dataflow.message.redundant.instanceof=Condition <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.notnull.from.nullable=@{0} method ''{1}'' always returns a non-null value
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.nullable.argument.methodref=Passing an argument to the method reference requires unboxing which may produce <code>NullPointerException</code>
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.message.constant.expression=Result of <code>#ref</code> #loc is always ''{0}''
dataflow.message.constant.value=Value <code>#ref</code> #loc is always ''{0}''
dataflow.method.fails.with.null.argument=Method will throw an exception when parameter is null
dataflow.message.unknown.nullability=\ (unknown nullability)
dataflow.message.stream.consumed.always=Stream has already been linked or consumed
dataflow.message.stream.consumed=Stream might have already been linked or consumed
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.handler.will.become.unreachable=Catch section will become unreachable

find.searching.for.references.to.class.progress=Searching for references to class {0}\u2026
find.usages.panel.title.derived.classes.cap=Derived classes
find.usages.panel.title.derived.classes=derived classes
find.usages.panel.title.derived.interfaces.cap=Derived interfaces
find.usages.panel.title.derived.interfaces=derived interfaces
find.usages.panel.title.implementing.classes.cap=Implementing classes
find.usages.panel.title.implementing.classes=implementing classes
find.usages.panel.title.implementing.methods.cap=Implementing methods
find.usages.panel.title.implementing.methods=implementing methods
find.usages.panel.title.overloaded.methods.usages.cap=Overloaded methods
find.usages.panel.title.overloaded.methods.usages=overloaded methods
find.usages.panel.title.overriding.methods.cap=Overriding methods
find.usages.panel.title.overriding.methods=overriding methods
find.usages.panel.title.base.methods.cap=Usages of base method
find.usages.panel.title.base.methods=usages of base method
message.class.inaccessible.from.module=Class ''{0}'' is not accessible from module ''{1}''
message.class.inaccessible=Class ''{0}'' is not accessible here

inspection.i18n.quickfix.annotate=Annotate\u2026
inspection.i18n.quickfix.annotate.as=Annotate as ''@{0}''
inspection.i18n.quickfix.annotate.element=Annotate {0} ''{1}''\u2026
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\u2026
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
service.uses=Uses service
service.click.to.navigate=Click to navigate
suppress.for.parameter=Suppress for parameter
suppress.for.statement.with.comment=Suppress for statement with comment
intention.add.annotation.family=Add annotation
intention.add.type.annotation.family=Add type annotation
intention.text.remove.annotation=Remove

scope.package=Package {0}

0.field.is.always.initialized.not.null=@{0} field is always initialized not-null
access.can.be.0=Access can be ''{0}''
access.can.be.package.private=Access can be package-private
access.to.field.code.ref.code.outside.of.declared.guards.loc=Access to field <code>#ref</code> outside of declared guards #loc
call.to.method.code.ref.code.outside.of.declared.guards.loc=Call to method <code>#ref()</code> outside of declared guards #loc
annotate.as.safevarargs=Annotate as '@SafeVarargs'
annotate.overridden.methods.parameters.family.name=Annotate overriding method parameters
annotate.overridden.methods.parameters=Annotate overriding method parameters as ''@{0}''
anonymous.ref.loc.can.be.replaced.with.0=Anonymous #ref #loc can be replaced with {0}
anonymous.ref.loc.can.be.replaced.with.lambda=Anonymous #ref #loc can be replaced with lambda
assigning.a.collection.of.nullable.elements=Assigning a collection of nullable elements into a collection of non-null elements
nullable.stuff.error.overriding.nullable.with.notnull=Overriding a collection of nullable elements with a collection of non-null elements
nullable.stuff.error.overriding.notnull.with.nullable=Overriding a collection of not-null elements with a collection of nullable elements
comparision.between.object.and.primitive=Comparison 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=StringTokenizer '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 clarifying casts
ignore.exceptions.thrown.by.entry.points.methods=Ignore exceptions thrown by entry point methods
ignore.in.the.same.outermost.class=Ignore in the same outermost class
ignore.in.the.same.project=Ignore API declared in this project
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.method.quickfix.name=Annotate method with ''@{0}''
inspection.annotate.overridden.method.and.self.quickfix.family.name=Annotate overriding methods and self
inspection.annotate.overridden.method.and.self.quickfix.name=Annotate overriding methods and self with ''@{0}''
inspection.annotate.overridden.method.quickfix.family.name=Annotate overriding methods
inspection.annotate.overridden.method.quickfix.name=Annotate overriding methods with ''@{0}''
inspection.annotate.overridden.method.nullable.quickfix.name=Annotate overriding methods as ''@{0}''
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=Suspicious '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.records.option=Ignore records
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.else.if.invert=Merge 'else if' statement inverting the second condition
inspection.common.if.parts.family=Extract common parts of 'if' statement
inspection.common.if.parts.settings.highlight.when.tail.call=Highlight when the last common statement is a call
inspection.common.if.parts.settings.highlight.else.if=Highlight else-if chains that can be simplified
inspection.compiler.javac.quirks.anno.array.comma.fix=Remove trailing comma
inspection.compiler.javac.quirks.anno.array.comma.problem=Trailing comma in annotation array initializers can cause compilation errors when using older javac versions (for example 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 references may cause compilation errors when using older javac versions (for example JDK 5 and JDK 6)
inspection.compiler.javac.quirks.illegal.forward.reference=Forward references may cause compilation errors when using older javac versions (for example JDK 5 and JDK 6)
inspection.quirk.method.reference.return.type.message=Target method return type mentions inaccessible class {0}, this will cause an IllegalAccessError at runtime
# | is replaced with 'left' or 'right'
inspection.constant.on.wrong.side.of.a.comparison.side.option=Constant should be on the|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.expression.can.be.replaced.with.message=Expression can be replaced with ''{0}''
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 ''{0}'' should not use terminal digits to encode version information
inspection.java.module.naming=Java module name violates convention
inspection.java.module.definition=Java module definition problems
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=<html>Report variables which are implicitly final<br/>(multi-catch or try-with-resources parameters)</html>
inspection.local.can.be.final.option5=Report pattern variables
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.nullable.problems.nullable.instantiation.of.notnull=Not-null type parameter ''{0}'' cannot be instantiated with @{1} type
inspection.nullable.problems.nullable.instantiation.of.notnull.container=Not-null type parameter ''{0}'' cannot be instantiated under @{1}
inspection.nullable.problems.redundant.annotation.under.container=Redundant nullability annotation in the scope of @{0}
inspection.nullable.problems.receiver.annotation=Receiver parameter is inherently not-null
inspection.nullable.problems.applied.to.package=Annotation on fully-qualified name must be placed before the last component
inspection.nullable.problems.outer.type=Outer type is inherently not-null
inspection.nullable.problems.at.class=Nullability annotation is not applicable to classes
inspection.nullable.problems.at.constructor=Nullability annotation is not applicable to constructors
inspection.nullable.problems.at.enum.constant=Nullability annotation is not applicable to enum constants
inspection.nullable.problems.at.wildcard=Nullability annotation is not applicable to wildcard type
inspection.nullable.problems.at.local.variable=Nullability annotation is not applicable to local variables
inspection.nullable.problems.at.type.parameter=Nullability annotation is not applicable to type parameters
inspection.nullable.problems.at.reference.list=Nullability annotation is not applicable to extends/implements clause
inspection.nullable.problems.constructor.not.compatible.non.null.type.argument=Constructor is not compatible with a non-null type argument
inspection.objects.equals.can.be.simplified.display.name='Objects.equals()' can be replaced with 'equals()'
inspection.redundant.cast.problem.descriptor=Casting <code>{0}</code> to <code>#ref</code> #loc is redundant
inspection.redundant.cast.methodref.descriptor=Cast 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 <code>#ref</code> is never thrown in this method, nor in its overriding methods
inspection.redundant.throws.problem.descriptor2=The declared exception <code>#ref</code> is never thrown
inspection.redundant.throws.problem.descriptor=The declared exception <code>#ref</code> is never thrown in any method implementation
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.anonymous.class=anonymous class
inspection.reference.implicit.class=compact source file ''{0}''
inspection.reference.implicit.constructor.name=implicit constructor of {0}
inspection.reference.lambda.name=lambda ({0})
inspection.reference.default.lambda.name=lambda
inspection.reference.method.reference.name=method reference ({0})
inspection.reference.default.method.reference.name=method reference
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 always returns the same value
inspection.same.return.value.problem.descriptor1=Method <code>#ref()</code> and all its overriding methods always return <code>{0}</code>
inspection.same.return.value.problem.descriptor2=All implementations of method <code>#ref()</code> always return <code>{0}</code>
inspection.same.return.value.problem.descriptor=Method <code>#ref()</code> always returns <code>{0}</code>
inspection.surround.requirenonnull.quickfix=Replace with ''Objects.requireNonNull({0})''
inspection.suspicious.array.method.call.display.name=Suspicious 'Arrays' method call
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 collection method call
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.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.use.compare.method.option.double=Suggest 'Double.compare()' and 'Float.compare()'
inspection.use.compare.method.turn.off.double=Do not suggest Double.compare() and Float.compare() methods
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=Suggest 'private' for inner class members when referenced from outer class only
instance.member.guarded.by.static.0.loc=Instance member guarded by static "{0}" #loc
instance.member.guarded.by.static.ref.loc=Instance member guarded by static #ref #loc
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
nullable.stuff.problems.overridden.method.parameters.are.not.annotated=Overriding method parameters are not annotated
nullable.stuff.problems.overridden.methods.are.not.annotated=Overriding methods are not annotated
parameter.can.be.null=Parameter can be null
parameter.is.always.not.null=Parameter is always 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 comment
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=Remove duplication from 'delimiters' argument
replace.var.with.explicit.type=Replace 'var' with explicit type
replace.with.0=Replace with {0}
replace.with.stream.api.fix=Collapse loop with stream ''{0}()''
replace.with.comparator=Replace with comparator
replace.with.constant.value=Replace with constant value
replace.with.constant.value.title=Replace with Constant Value
replace.with.expression.lambda=Replace with expression lambda
replace.with.lambda=Replace with lambda
replace.with.boolean.equals=Replace with Boolean.equals
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}''
missorted.imports.inspection.display.name=Missorted imports
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
inspection.inconsistent.language.level.display.name=Inconsistent language level settings
inspection.weaker.access.display.name=Declaration access can be weaker
inspection.can.be.final.display.name=Declaration can have 'final' modifier
inspection.redundant.throws.display.name=Redundant 'throws' clause
inspection.java.9.redundant.requires.statement.display.name=Redundant 'requires' directive in module-info
inspection.numeric.overflow.display.name=Numeric overflow
inspection.redundant.cast.display.name=Redundant type cast
inspection.deprecated.is.still.used.display.name=Deprecated member is still used
inspection.message.scheduled.for.removal.annotation.can.be.replaced.by.attribute=@ScheduledForRemoval annotation can be replaced with 'forRemoval' attribute in @Deprecated annotation
inspection.message.scheduled.for.removal.annotation.can.be.removed=@ScheduledForRemoval annotation can be removed
inspection.fix.name.remove.scheduled.for.removal.annotation.by.attribute=Replace @ScheduledForRemoval with 'forRemoval' attribute in @Deprecated annotation
inspection.name.redundant.scheduled.for.removal.annotation=Redundant @ScheduledForRemoval annotation
inspection.deprecated.class.usage.inspection.display.name=Deprecated API usage in XML
inspection.field.access.not.guarded.display.name=Unguarded field access or method call
inspection.instance.guarded.by.static.display.name=Instance member guarded by static field
inspection.non.final.field.in.immutable.display.name=Non-final field in '@Immutable' class
inspection.non.final.guard.display.name=Non-final '@GuardedBy' field
inspection.static.guarded.by.instance.display.name=Static member guarded by instance field or this
inspection.unknown.guard.display.name=Unknown '@GuardedBy' field
inspection.use.compare.method.display.name='compare()' method can be used to compare numbers
inspection.convert.2.diamond.display.name=Explicit type can be replaced with '<>'
inspection.convert.2.lambda.display.name=Anonymous type can be replaced with lambda
inspection.invalid.comparator.method.reference.display.name=Invalid method reference used for 'Comparator'
inspection.safe.varargs.detector.display.name=Possible heap pollution from parameterized vararg type
inspection.block.marker.comments.display.name=Block marker comment
inspection.string.tokenizer.delimiter.display.name=Duplicated delimiters in 'StringTokenizer'
inspection.anonymous.has.lambda.alternative.display.name=Anonymous type has shorter lambda alternative
inspection.java.8.list.sort.display.name='Collections.sort()' can be replaced with 'List.sort()'
inspection.class.has.no.to.string.method.display.name=Class does not override 'toString()' method
inspection.field.not.used.in.to.string.display.name=Field not used in 'toString()' method
inspection.contract.checker.clause.syntax=A contract clause must be in form arg1, \u2026, argN -> return-value
inspection.contract.checker.unknown.return.value=Return value should be one of: {0}. Found: {1}
inspection.contract.checker.unknown.constraint=Constraint should be one of: {0}. Found: {1}
inspection.contract.checker.empty.constraint=Constraint should not be empty
inspection.contract.checker.unreachable.contract.clause=Contract clause ''{0}'' is unreachable: previous contracts cover all possible cases
inspection.contract.checker.contract.clause.never.satisfied=Contract clause ''{0}'' is never satisfied as its conditions are covered by previous contracts
inspection.contract.checker.pure.method.mutation.contract=Pure method cannot have mutation contract
inspection.contract.checker.parameter.count.mismatch=Method takes {0} parameters, while contract clause ''{1}'' expects {2}
inspection.contract.checker.primitive.parameter.nullability=Parameter ''{0}'' has primitive type ''{1}'', so ''{2}'' is not applicable
inspection.contract.checker.inferred.notnull.parameter.null=Parameter ''{0}'' is inferred to be not-null, so ''null'' is not applicable
inspection.contract.checker.notnull.parameter.null=Parameter ''{0}'' is annotated as not-null, so ''null'' is not applicable
inspection.contract.checker.inferred.notnull.parameter.notnull=Parameter ''{0}'' is inferred to be not-null, so ''!null'' is always satisfied
inspection.contract.checker.notnull.parameter.notnull=Parameter ''{0}'' is annotated as not-null, so ''!null'' is always satisfied
inspection.contract.checker.boolean.condition.for.nonboolean.parameter=Parameter ''{0}'' has ''{1}'' type (expected boolean)
inspection.contract.checker.contract.violated=Contract clause ''{0}'' is violated
inspection.contract.checker.no.exception.thrown=Contract clause ''{0}'' is violated: no exception is thrown
inspection.contract.checker.method.always.fails.trivial=Return value of clause ''{0}'' could be replaced with ''fail'' as method always fails
inspection.contract.checker.method.always.fails.nontrivial=Return value of clause ''{0}'' could be replaced with ''fail'' as method always fails in this case
contract.return.validator.not.applicable.for.constructor=not applicable to constructor
contract.return.validator.not.applicable.static=not applicable to static method
contract.return.validator.not.applicable.primitive=not applicable to primitive return type ''{0}''
contract.return.validator.return.type.must.be.boolean=method return type must be 'boolean'
contract.return.validator.method.return.incompatible.with.method.containing.class=method return type should be compatible with method containing class
contract.return.validator.too.few.parameters=not applicable to method that has {0, choice, 0#no parameters|1#one parameter|2#{0} parameters}
contract.return.validator.incompatible.return.parameter.type=return type ''{0}'' must be convertible from parameter type ''{1}''
contract.return.value.validation.prefix=Contract return value ''{0}'':
suspicious.invocation.handler.implementation.display.name=Suspicious 'InvocationHandler' implementation
suspicious.invocation.handler.implementation.method.unused.message=Method is never used in 'invoke()': it's unlikely that 'hashCode()', 'equals()' and 'toString()' are implemented correctly
suspicious.invocation.handler.implementation.type.mismatch.message=Incompatible type might be returned when proxying method ''{0}()'': required: {1}; got: {2}
suspicious.invocation.handler.implementation.null.returned.for.toString.message=Null might be returned when proxying method 'toString()': this is discouraged
suspicious.invocation.handler.implementation.null.returned.message=Null might be returned when proxying method ''{0}()'': this may cause NullPointerException
error.class.not.found=Class {0} not found
intention.name.qualify.expression=Qualify {0} expression with ''{1}''
nullability.null=null
nullability.nullable=nullable
nullability.non.null=non-null
duplication.policy.ask=Ask
duplication.policy.replace=Replace existing
duplication.policy.generate.duplicate=Generate duplicating method
dftype.presentation.empty.optional=empty Optional
dftype.presentation.present.optional=present Optional
mutability.unknown=unknown
mutability.modifiable=modifiable
mutability.must.not.modify=input parameter that should not be modified
mutability.unmodifiable.view=unmodifiable view
mutability.unmodifiable=unmodifiable
special.field.array.length=Array length
special.field.string.length=String length
special.field.collection.size=Size
special.field.unboxed.value=Unboxed value
special.field.optional.value=Optional value
special.field.enum.ordinal=Enum ordinal
special.field.consumed.stream=Linked or consumed stream
special.field.instantiable.class=Instantiable class
text.unused.import.in.template=Unused import (specified in template)
text.raw.ctor.reference.with.type.parameters=Raw constructor reference with explicit type parameters for constructor

dfa.find.cause.unable=Unable to find the cause
dfa.find.cause.cast.may.fail=cast may fail
dfa.find.cause.may.be.null=may be null
dfa.find.cause.call.always.fails=call always fails
dfa.find.cause.one.of.the.following.happens=one of the following happens:
dfa.find.cause.an.execution.might.exist.where=an execution might exist where:
dfa.find.cause.value.is.always.the.same=value is always {0}
dfa.find.cause.size.is.always.zero=size is always zero
dfa.find.cause.value.x.is.always.the.same=value ''{0}'' is always ''{1}''
dfa.find.cause.compile.time.constant=it''s compile-time constant which evaluates to ''{0}''
dfa.find.cause.equality.established.from.condition=''{0}'' was established from condition
dfa.find.cause.was.assigned.to=''{0}'' was assigned to ''{1}''
dfa.find.cause.was.assigned=''{0}'' was assigned
dfa.find.cause.operand.of.boolean.expression.is.the.same=operand #{0} of {1, choice, 0#and|1#or}-chain is {2}
dfa.find.cause.comparison.arguments.are.the.same=comparison arguments are the same
dfa.find.cause.comparison.arguments.are.different.constants=comparison arguments are different constants
dfa.find.cause.variable.is.initialized={0} ''{1}'' is initialized to {2}
dfa.find.cause.object.kind.generic=an object
dfa.find.cause.object.kind.expression=an expression
dfa.find.cause.object.kind.method.return=method return
dfa.find.cause.type.known={0} type is {1}
# ___PLACE___ is replaced with dfa.find.cause.place.*
dfa.find.cause.type.is.known.from.place=type of ''{0}'' is known from ___PLACE___
dfa.find.cause.condition.is.known.from.place=it''s known that ''{0}'' from ___PLACE___
dfa.find.cause.range.is.known.from.place=range is known from ___PLACE___
dfa.find.cause.value.is.known.from.place=''{0}'' is known to be ''{1}'' from ___PLACE___
dfa.find.cause.place.line.number=line #{0}
dfa.find.cause.place.here=here
dfa.find.cause.values.cannot.be.equal.because=values cannot be equal because {0}
dfa.find.cause.condition.was.checked.before=condition ''{0}'' was checked before
dfa.find.cause.condition.was.deduced=condition ''{0}'' was deduced
dfa.find.cause.was.passed.as.non.null.parameter=''{0}'' was passed as an argument to a method accepting non-null parameter
dfa.find.cause.was.dereferenced=''{0}'' was dereferenced
dfa.find.cause.instanceof.implies.non.nullity=the 'instanceof' check implies non-nullity
dfa.find.cause.nullability.inferred={0} ''{1}'' was inferred to be ''{2}''
dfa.find.cause.nullability.externally.annotated={0} ''{1}'' is externally annotated as ''{2}''
dfa.find.cause.nullability.explicitly.annotated={0} ''{1}'' is annotated as ''{2}''
dfa.find.cause.nullability.inherited.from.container={0} ''{1}'' inherits container annotation, thus ''{2}''
dfa.find.cause.nullability.inherited.from.class={0} ''{1}'' inherits annotation from class {2}, thus ''{3}''
dfa.find.cause.nullability.inherited.from.package={0} ''{1}'' inherits annotation from package {2}, thus ''{3}''
dfa.find.cause.nullability.inherited.from.named.element={0} ''{1}'' inherits from {2}, thus ''{3}''
dfa.find.cause.field.initializer.nullability=field ''{0}'' is initialized to ''{1}'' value
dfa.find.cause.field.assigned.nullability=field ''{0}'' is known to be always initialized to ''{1}'' value
# E.g. "length of parameter"
dfa.find.cause.special.field.of.something={0} of {1}
dfa.find.cause.array.length.is.always.non.negative=array length is always non-negative
dfa.find.cause.string.length.is.always.non.negative=string length is always non-negative
dfa.find.cause.collection.size.is.always.non.negative=collection size is always non-negative
dfa.find.cause.range.is.specified.by.annotation=the range of ''{0}'' is specified by annotation as {1}
# %s is replaced with value range like {0..255} or 'odd', etc. (see long.range.set.presentation.* above)
dfa.find.cause.result.of.primitive.cast.template=result of ''({0})'' cast is %s
dfa.find.cause.result.of.numeric.operation.template=result of ''{0}'' is %s
dfa.find.cause.left.operand.range.template=left operand is %s
dfa.find.cause.right.operand.range.template=right operand is %s
dfa.find.cause.numeric.cast.operand.template=cast operand is %s
dfa.find.cause.numeric.range.generic.template=value is %s
# Here {0} is replaced with dfa.find.cause.nonnull.expression.kind.*
dfa.find.cause.obviously.non.null.expression=expression cannot be null as it''s {0}
dfa.find.cause.nonnull.expression.kind.newly.created.object=newly created object
dfa.find.cause.nonnull.expression.kind.literal=literal
dfa.find.cause.nonnull.expression.kind.primitive.type=a value of primitive type ''{0}''
dfa.find.cause.nonnull.expression.kind.concatenation=concatenation
dfa.find.cause.nonnull.expression.kind.this.object='this' object
# Here {0} is replaced with dfa.find.cause.contract.kind.*
# {1} = method or constructor; {2} is name
dfa.find.cause.contract.trivial=according to {0}, {1} ''{2}'' always returns ''{3}'' value
# Here {0} is replaced with dfa.find.cause.contract.kind.*
# {1} = method or constructor; {2} is name
dfa.find.cause.contract.throws.on.condition=according to {0}, {1} ''{2}'' throws exception when {3}
# Here {0} is replaced with dfa.find.cause.contract.kind.*
# {1} = method or constructor; {2} is name
dfa.find.cause.contract.returns.on.condition=according to {0}, {1} ''{2}'' returns ''{3}'' when {4}
dfa.find.cause.contract.kind.explicit=contract
dfa.find.cause.contract.kind.inferred=inferred contract
dfa.find.cause.contract.kind.hard.coded=hard-coded contract
dfa.find.cause.primitive.boxed=primitive value was boxed

type.constraint.assignability.explanation.exact={0} is already known to be {1}
type.constraint.assignability.explanation.exact.subtype={0} type is exactly {1} which is a subtype of {2}
type.constraint.assignability.explanation.exact.not.subtype={0} type is exactly {1} which is not a subtype of {2}
type.constraint.assignability.explanation.subtype.of.subtype={0} is already known to be {1} which is a subtype of {2}
type.constraint.assignability.explanation.not.instance.of={0} is known to be not {1}
type.constraint.assignability.explanation.not.instance.of.supertype={0} is known to be not {1} which is a supertype of {2}
type.constraint.assignability.explanation.definitely.inconvertible={0} is known to be {1} which is definitely incompatible with {2}
inspection.message.javac.quick.intersection.type.problem=Intersection type ''{0}'' cannot be instantiated, because ''{1}'' is final
suggest.package.private.visibility.level.for.classes.in.exported.packages.java.9=Suggest package-private visibility level for classes in exported packages (Java 9+)
generate.members.position.at.caret=At caret
generate.members.position.after.equals.and.hashcode=After equals() and hashCode()
generate.members.position.at.the.end.of.class=At the end of class

navigate.to.overridden.methods.title=Overriding methods of {0}
subclasses.search.progress.title=Searching for overridden methods
progress.title.searching.for.overridden.methods=Searching for overridden methods
arguments.count.mismatch=Expected {0, choice, 0#no arguments|1#1 argument|1<{0} arguments} but found {1}
inspection.message.nullable.method.implements.non.null.method=Nullable method ''{0}'' from ''{1}'' implements non-null method from ''{2}''
inspection.message.non.annotated.method.implements.non.null.method=Non-annotated method ''{0}'' from ''{1}'' implements non-null method from ''{2}''
inspection.message.non.null.parameter.should.not.override.nullable.parameter=Non-null parameter ''{0}'' in method ''{1}'' from ''{2}'' should not override nullable parameter from ''{3}''
inspection.message.non.annotated.parameter.should.not.override.non.null.parameter=Non-annotated parameter ''{0}'' in method ''{1}'' from ''{2}'' should not override non-null parameter from ''{3}''
inspection.message.non.null.parameter.should.not.override.non.annotated.parameter=Non-null parameter ''{0}'' in method ''{1}'' from ''{2}'' should not override non-annotated parameter from ''{3}''
element.kind.keys=keys
element.kind.values=values
element.kind.objects=objects
mutation.signature.problem.static.method.cannot.mutate.this=Static method cannot mutate 'this'
mutation.signature.problem.reference.to.parameter.invalid=Reference to parameter #{0} is invalid
mutation.signature.problem.parameter.has.immutable.type=Parameter #{0} has immutable type ''{1}''
mutation.signature.problem.invalid.token=Invalid token: {0}; supported are ''this'', ''io'', ''param1'', ''param2'', and so on.
required.type=Required type
provided.type=Provided
type.mismatch.reason=reason: {0}
inspection.message.code.generation.different.nullability.annotation.will.be.used=The generated code will use ''@{1}'' instead of ''@{0}''
change.visibility.level=Make {0} {1}
inspection.redundant.tostring.option.notnull.qualifier=Report only when qualifier is known to be not-null
highlighting.try.blocks=Highlighting try blocks\u2026
intention.family.name.remove.new.family.name=Remove 'new'
inspection.unsatisfied.range.display.name=Return value is outside of declared range
inspection.unsatisfied.range.message=Return value range ''{0}'' is outside of declared range ''{1}''
inspection.unsatisfied.range.message.value=Return value ''{0}'' is outside of declared range ''{1}''
intention.family.name.move.annotation.to.array=Move annotation to array
intention.family.name.move.annotation.to.upper.bound=Move annotation to upper bound
move.annotations.to.package.info.file.family.name=Move annotations to 'package-info.java'

inspection.redundant.requires.statement.message.transitive.dependencies.on.can.be.used.directly=Transitive dependencies on ''{0}'' can be used directly.
inspection.redundant.requires.statement.message.module.unused=No usages of module packages are found.
inspection.redundant.requires.statement.message.java.base.implicitly.required='java.base' is implicitly required.
reassign.variable.display.name=Reassigned variable
intention.family.name.remove.repeating.call=Remove repeating call
intention.name.remove.repeating.call=Remove repeating call ''{0}()''
intention.family.name.replace.with.expression=Replace with expression
intention.name.make.variable.effectively.final=Make variable effectively final

uast.language.display.name=JVM languages
inspection.extract.method.inspection.name=Method can be extracted
inspection.extract.method.nothing=nothing
inspection.extract.method.preview.html=Extract {0} statements to a method, which accepts {1} and returns <b>{2}</b>
inspection.extract.method.message=It''s possible to extract method returning ''{0}'' from a long surrounding method
inspection.extract.method.option.min.length=Minimum length of code to extract:|symbols
inspection.extract.method.option.max.parameters=Maximum number of parameters:
inspection.extract.method.dont.suggest.parameters=Don''t suggest extracting method with {0} or more parameters
inspection.extract.method.dont.suggest.length=Don\u2019t suggest extracting methods as short as this
notification.file.system.issue=File Operation Issue
notification.content.cannot.move.file=Cannot move ''{0}'' into ''{1}'': {2}
intention.family.name.replace.with.unnamed.pattern=Replace with unnamed pattern
intention.name.ignore.exception=Ignore exception ''{0}''
intention.name.move.members.into.class=Move {0, choice, 1#member|2#members} into class
intention.family.name.move.members.into.class=Move members into class
chooser.popup.title.select.class.to.move.members.to=Select Target Class
intention.family.name.move.members.to=Move members to {0}
inspection.name.can.be.replaced.with.long.hashcode=Standard 'hashCode()' method can be used
inspection.depends.on.the.java.feature=This inspection depends on the Java feature ''{0}'', which is available since Java {1}.
inspection.depends.on.the.java.features=This inspection depends on the following Java features:
inspection.depends.on.the.java.features.minimal.version=These features are available since Java {0}.
inspection.data.flow.warn.when.reading.a.value.guaranteed.to.be.constant=Warn when constant is stored in variable
inspection.message.expression.compared.to.itself.description=Expression is compared to itself
intention.name.do.not.report.conditions.with.possible.side.effect=Do not report conditions with possible side-effect
dfa.find.cause.or.another=or {0}
dfa.find.cause.and.another=and {0}
safe.varargs.not.suppress.potentially.unsafe.operations=@SafeVarargs do not suppress potentially unsafe operations
safe.varargs.on.reifiable.type=@SafeVarargs is not applicable to reifiable types
inspection.unreachable.catch.name=Unreachable catch section
inspection.unreachable.catch.message=Unreachable section: {1, choice, 0#exception|2#exceptions} ''{0}'' {1, choice, 0#has|2#have} already been caught
module.service.unused=Service interface provided but not exported or used
module.ambiguous=Ambiguous module reference: {0}