mirror of
https://gitflic.ru/project/openide/openide.git
synced 2026-09-27 10:03:11 +07:00
[java-inspections] IDEA-382389 cleanup: remove '#loc' references
GitOrigin-RevId: 53e796b031742bb49dae4080c47ceab815fb0747
This commit is contained in:
Bartek Pacia
committed by
intellij-monorepo-bot
intellij-monorepo-bot
parent
ef2e4e6833
commit
2ab73da394
@@ -10,12 +10,12 @@ 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 non-null variable
|
||||
dataflow.message.assigning.nullable.notannotated=Expression <code>#ref</code> #loc might be null but is assigned to non-annotated field
|
||||
dataflow.message.assigning.nullable.notannotated=Expression <code>#ref</code> 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 non-null variable
|
||||
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.cce.always=Casting <code>{0}</code> to <code>#ref</code> will produce <code>ClassCastException</code> for any non-null value
|
||||
dataflow.message.cce=Casting <code>{0}</code> to <code>#ref</code> may produce <code>ClassCastException</code>
|
||||
dataflow.message.constant.condition.when.reached=Condition <code>#ref</code> is always <code>{0, choice, 0#false|1#true}</code> when reached
|
||||
dataflow.message.constant.condition=Condition <code>#ref</code> 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
|
||||
@@ -23,31 +23,31 @@ dataflow.message.contract.fail.index=The call to '#ref' always fails as an argum
|
||||
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.array.access.sure=Array access <code>#ref</code> will produce <code>NullPointerException</code>
|
||||
dataflow.message.npe.array.access=Array access <code>#ref</code> may produce <code>NullPointerException</code>
|
||||
dataflow.message.npe.field.access.sure=Dereference of <code>#ref</code> will produce <code>NullPointerException</code>
|
||||
dataflow.message.npe.field.access=Dereference of <code>#ref</code> 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.method.invocation.sure=Method invocation <code>#ref</code> will produce <code>NullPointerException</code>
|
||||
dataflow.message.npe.method.invocation=Method invocation <code>#ref</code> 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.npe.methodref.invocation=Method reference invocation <code>#ref</code> may produce <code>NullPointerException</code>
|
||||
dataflow.message.only.switch.label=Switch label <code>#ref</code> 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.nullable.argument.nonannotated=Argument <code>#ref</code> might be null but passed to non-annotated parameter
|
||||
dataflow.message.passing.nullable.argument=Argument <code>#ref</code> 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.assignment.expression=Condition <code>#ref</code> 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.instanceof=Condition <code>#ref</code> 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}
|
||||
@@ -58,11 +58,11 @@ dataflow.message.return.nullable.from.notnullable=Expression <code>#ref</code> m
|
||||
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.message.unboxing.method.reference=Use of <code>#ref</code> would need unboxing which may produce <code>NullPointerException</code>
|
||||
dataflow.message.unboxing=Unboxing of <code>#ref</code> may produce <code>NullPointerException</code>
|
||||
dataflow.message.unreachable.switch.label=Switch label <code>#ref</code> is unreachable
|
||||
dataflow.message.constant.expression=Result of <code>#ref</code> is always ''{0}''
|
||||
dataflow.message.constant.value=Value <code>#ref</code> 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
|
||||
@@ -124,13 +124,13 @@ scope.package=Package {0}
|
||||
0.field.is.always.initialized.not.null=@{0} field is always initialized non-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
|
||||
access.to.field.code.ref.code.outside.of.declared.guards.loc=Access to field <code>#ref</code> outside of declared guards
|
||||
call.to.method.code.ref.code.outside.of.declared.guards.loc=Call to method <code>#ref()</code> outside of declared guards
|
||||
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
|
||||
anonymous.ref.loc.can.be.replaced.with.0=Anonymous #ref can be replaced with {0}
|
||||
anonymous.ref.loc.can.be.replaced.with.lambda=Anonymous #ref can be replaced with lambda
|
||||
assigning.a.collection.of.nullable.elements=Assigning a collection of nullable elements into a collection of non-null elements
|
||||
returning.a.class.with.nullable.arguments=\
|
||||
<html><body>\
|
||||
@@ -152,7 +152,7 @@ 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 <>
|
||||
explicit.type.argument.ref.loc.can.be.replaced.with=Explicit type argument #ref 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>
|
||||
@@ -272,7 +272,7 @@ inspection.nullable.problems.at.reference.list=Nullability annotation is not app
|
||||
inspection.nullable.problems.at.throws=Nullability annotation is not applicable to 'throws' 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.problem.descriptor=Casting <code>{0}</code> to <code>#ref</code> is redundant
|
||||
inspection.redundant.cast.methodref.descriptor=Cast is redundant
|
||||
inspection.redundant.cast.remove.quickfix=Remove redundant cast
|
||||
inspection.redundant.field.initialization.option=Only warn on initialization to null
|
||||
@@ -325,21 +325,21 @@ 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
|
||||
instance.member.guarded.by.static.0.loc=Instance member guarded by static "{0}"
|
||||
instance.member.guarded.by.static.ref.loc=Instance member guarded by static #ref
|
||||
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.final.field.code.ref.code.in.immutable.class.loc=Non-final field <code>#ref</code> in @Immutable class
|
||||
non.final.guarded.by.field.0.loc=Non-final @GuardedBy field "{0}"
|
||||
non.final.guarded.by.field.ref.loc=Non-final @GuardedBy field #ref
|
||||
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 non-null
|
||||
possible.heap.pollution.from.parameterized.vararg.type.loc=Possible heap pollution from parameterized vararg type #loc
|
||||
possible.heap.pollution.from.parameterized.vararg.type.loc=Possible heap pollution from parameterized vararg type
|
||||
redundant.block.marker=Redundant block marker
|
||||
remove.block.marker.comments=Remove block marker comment
|
||||
remove.dependency=Remove dependency
|
||||
@@ -364,8 +364,8 @@ report.when.interface.is.not.annotated.with.functional.interface=Report when int
|
||||
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
|
||||
static.member.guarded.by.instance.0.loc=Static member guarded by instance "{0}"
|
||||
static.member.guarded.by.instance.ref.loc=Static member guarded by instance #ref
|
||||
suppress.all.for.class=Suppress all inspections for class
|
||||
suppress.inspection.class=Suppress for class
|
||||
suppress.inspection.field=Suppress for field
|
||||
@@ -373,8 +373,8 @@ 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
|
||||
unknown.guardedby.reference.0.loc=Unknown @GuardedBy reference "{0}"
|
||||
unknown.guardedby.reference.ref.loc=Unknown @GuardedBy reference #ref
|
||||
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
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -393,7 +393,7 @@ inspection.duplicate.expressions.complexity.threshold=Expression complexity thre
|
||||
inspection.duplicate.expressions.display.name=Multiple occurrences of the same expression
|
||||
inspection.duplicate.expressions.introduce.variable.fix.family.name=Introduce variable
|
||||
inspection.duplicate.expressions.introduce.variable.fix.name=Introduce variable for ''{0}''
|
||||
inspection.duplicate.expressions.message=Multiple occurrences of <code>#ref</code> #loc
|
||||
inspection.duplicate.expressions.message=Multiple occurrences of <code>#ref</code>
|
||||
inspection.duplicate.expressions.replace.other.occurrences.fix.family.name=Replace with variable other occurrences of expression
|
||||
inspection.duplicate.expressions.replace.other.occurrences.fix.name=Replace with ''{0}'' other occurrences of ''{1}''
|
||||
inspection.duplicate.expressions.reuse.variable.fix.family.name=Reuse variable
|
||||
@@ -527,7 +527,7 @@ inspection.manual.min.max.calculation.description=Can be replaced with ''Math.{0
|
||||
inspection.manual.min.max.calculation.disable.for.non.integral=Disable for float and double
|
||||
inspection.map.foreach.display.name=Map.forEach() can be used
|
||||
inspection.map.foreach.option.no.loops=Do not report loops
|
||||
inspection.message.anonymous.ref.loc.can.be.replaced.with.method.reference=Anonymous #ref #loc can be replaced with method reference
|
||||
inspection.message.anonymous.ref.loc.can.be.replaced.with.method.reference=Anonymous #ref can be replaced with method reference
|
||||
inspection.message.can.be.replaced.with.0.constructor=Can be replaced with ''{0}'' constructor
|
||||
inspection.message.can.be.replaced.with.files.readstring=Can be replaced with 'Files.readString()'
|
||||
inspection.message.can.be.replaced.with.optional.of.nullable=Can be replaced with Optional.ofNullable()
|
||||
@@ -576,7 +576,7 @@ inspection.overwritten.key.array.message=Overwritten array element
|
||||
inspection.parameter.can.be.local.display.name=Value passed as parameter never read
|
||||
inspection.parameter.can.be.local.problem.descriptor=Parameter can be converted to a local variable
|
||||
inspection.quickfix.assert.family=Assert
|
||||
inspection.raw.use.of.parameterized.type.problem.descriptor=Raw use of parameterized class <code>#ref</code> #loc
|
||||
inspection.raw.use.of.parameterized.type.problem.descriptor=Raw use of parameterized class <code>#ref</code>
|
||||
raw.variable.type.can.be.generic.family.quickfix=Add generic parameters to the type
|
||||
raw.variable.type.can.be.generic.quickfix=Change type of {0} to {1}
|
||||
raw.variable.type.can.be.generic.cast.quickfix=Change cast type to {0}
|
||||
@@ -591,7 +591,7 @@ inspection.redundant.array.creation.for.varargs.call.descriptor=Redundant array
|
||||
inspection.redundant.array.creation.quickfix=Remove explicit array creation
|
||||
inspection.redundant.explicit.close=Redundant 'close()'
|
||||
inspection.redundant.file.creation.display.name=Redundant 'File' instance creation
|
||||
inspection.redundant.file.creation.description=<code>#ref</code> is redundant #loc
|
||||
inspection.redundant.file.creation.description=<code>#ref</code> is redundant
|
||||
inspection.redundant.file.creation.quickfix=Replace with file name
|
||||
inspection.redundant.null.check.always.fail.message=Null-check will always fail: {0} is never null
|
||||
inspection.redundant.null.check.fix.family.name=Remove redundant null-check
|
||||
@@ -771,12 +771,12 @@ inspection.unused.assignment.option1=Report postfix expressions where the change
|
||||
inspection.unused.assignment.option2=Report redundant initializers
|
||||
inspection.unused.assignment.option3=Report pattern variables whose values are never used
|
||||
inspection.unused.assignment.option4=Report iteration parameters whose values are never used
|
||||
inspection.unused.assignment.problem.descriptor1=Variable <code>#ref</code> #loc is never used
|
||||
inspection.unused.assignment.problem.descriptor2=Variable <code>{0}</code> initializer <code>#ref</code> #loc is redundant
|
||||
inspection.unused.assignment.problem.descriptor3=The value <code>{0}</code> assigned to <code>#ref</code> #loc is never used
|
||||
inspection.unused.assignment.problem.descriptor4=The value changed at <code>#ref</code> #loc is never used
|
||||
inspection.unused.assignment.problem.descriptor5=The value of pattern variable <code>#ref</code> #loc is never used
|
||||
inspection.unused.assignment.problem.descriptor6=The value of foreach iteration parameter <code>#ref</code> #loc is never used
|
||||
inspection.unused.assignment.problem.descriptor1=Variable <code>#ref</code> is never used
|
||||
inspection.unused.assignment.problem.descriptor2=Variable <code>{0}</code> initializer <code>#ref</code> is redundant
|
||||
inspection.unused.assignment.problem.descriptor3=The value <code>{0}</code> assigned to <code>#ref</code> is never used
|
||||
inspection.unused.assignment.problem.descriptor4=The value changed at <code>#ref</code> is never used
|
||||
inspection.unused.assignment.problem.descriptor5=The value of pattern variable <code>#ref</code> is never used
|
||||
inspection.unused.assignment.problem.descriptor6=The value of foreach iteration parameter <code>#ref</code> is never used
|
||||
inspection.unused.assignment.remove.assignment.quickfix=Remove redundant assignment
|
||||
inspection.unused.assignment.remove.assignment.quickfix.title=Remove Redundant Assignment
|
||||
inspection.unused.assignment.remove.initializer.quickfix=Remove redundant initializer
|
||||
|
||||
@@ -61,7 +61,7 @@ jvm.inspections.api.override.only.on.invalid.class.description={0} ''{1}'' is ma
|
||||
|
||||
jvm.inspections.equals.hashcode.called.on.url.display.name=Call to 'equals()' or 'hashCode()' on 'URL' object
|
||||
jvm.inspections.equals.hashcode.called.on.url.problem.descriptor=Call to ''{0}'' on URL object
|
||||
jvm.inspections.collection.contains.url.problem.descriptor=''{0}'' may contain URL objects #loc
|
||||
jvm.inspections.collection.contains.url.problem.descriptor=''{0}'' may contain URL objects
|
||||
|
||||
jvm.inspections.dependency.display.name=Illegal package dependencies
|
||||
jvm.inspections.dependency.edit.rules.text=Edit dependency rule \"{0} \"
|
||||
@@ -141,23 +141,23 @@ jvm.inspections.testonly.method.call=Test-only method is called in production co
|
||||
jvm.inspections.testonly.visiblefortesting=@VisibleForTesting makes little sense on @TestOnly code
|
||||
|
||||
jvm.inspections.test.method.without.assertion.display.name=Test method without assertions
|
||||
jvm.inspections.test.method.without.assertion.problem.descriptor=Test method <code>#ref()</code> contains no assertions #loc
|
||||
jvm.inspections.test.method.without.assertion.problem.descriptor=Test method <code>#ref()</code> contains no assertions
|
||||
|
||||
jvm.inspections.test.case.without.test.methods.display.name=Test class without tests
|
||||
jvm.inspections.test.case.without.test.methods.option=Ignore test cases which have superclasses with test methods
|
||||
jvm.inspections.test.case.without.test.methods.problem.descriptor=Test class <code>#ref</code> has no tests #loc
|
||||
jvm.inspections.test.case.without.test.methods.problem.descriptor=Test class <code>#ref</code> has no tests
|
||||
|
||||
|
||||
jvm.inspections.test.case.with.constructor.display.name=TestCase with non-trivial constructors
|
||||
jvm.inspections.test.case.with.constructor.problem.descriptor=Initialization logic in constructor <code>#ref()</code> instead of 'setup()' life cycle method #loc
|
||||
jvm.inspections.test.case.with.constructor.problem.descriptor=Initialization logic in constructor <code>#ref()</code> instead of 'setup()' life cycle method
|
||||
jvm.inspections.test.case.with.constructor.problem.descriptor.initializer=Initialization logic in initializer instead of 'setup()' life cycle method
|
||||
|
||||
jvm.inspections.test.case.in.product.source.display.name=Test in product source
|
||||
jvm.inspections.test.case.in.product.source.problem.descriptor=Test case <code>#ref</code> should probably be placed in a test source tree #loc
|
||||
jvm.inspections.test.method.in.product.source.problem.descriptor=Test method <code>#ref()</code> should probably be placed in a test source tree #loc
|
||||
jvm.inspections.test.case.in.product.source.problem.descriptor=Test case <code>#ref</code> should probably be placed in a test source tree
|
||||
jvm.inspections.test.method.in.product.source.problem.descriptor=Test method <code>#ref()</code> should probably be placed in a test source tree
|
||||
|
||||
jvm.inspection.logging.string.template.as.argument.display.name=String template as argument to logging call
|
||||
jvm.inspection.logging.string.template.as.argument.problem.descriptor=String template as argument to <code>#ref()</code> logging call #loc
|
||||
jvm.inspection.logging.string.template.as.argument.problem.descriptor=String template as argument to <code>#ref()</code> logging call
|
||||
jvm.inspection.logging.string.template.as.argument.quickfix.name=Replace with placeholders
|
||||
jvm.inspection.logging.string.template.as.argument.skip.on.primitives=Do not warn when only expressions with primitive types, their wrappers or String are included
|
||||
jvm.inspection.logging.string.template.as.argument.skip.on.only.exception=Do not warn when call only with an exception as argument after message argument.
|
||||
@@ -179,18 +179,18 @@ jvm.inspection.log.statement.not.guarded.trace.level.option=trace level
|
||||
jvm.inspection.log.statement.not.guarded.unguarded.constant.option=Process unguarded logging calls with constant messages
|
||||
jvm.inspection.log.statement.not.guarded.unguarded.constant.option.comment=Process all unguarded log calls, not only those with non-constant arguments
|
||||
jvm.inspection.log.statement.not.guarded.log.fix.family.name=Surround with a logging condition
|
||||
jvm.inspection.log.statement.not.guarded.log.problem.descriptor=Logging call not guarded by a logging condition #loc
|
||||
jvm.inspection.log.statement.not.guarded.log.problem.descriptor=Logging call not guarded by a logging condition
|
||||
|
||||
jvm.inspection.log.guarded.display.name=Logging calls guarded by log condition
|
||||
jvm.inspection.log.guarded.warn.if.fix.possible=Warn only if a fix is available
|
||||
jvm.inspection.log.guarded.problem.descriptor=Logging call guarded by log condition #loc
|
||||
jvm.inspection.log.guarded.problem.descriptor=Logging call guarded by log condition
|
||||
jvm.inspection.log.guarded.fix.family.name=Unwrap log guard condition
|
||||
|
||||
jvm.inspection.logging.placeholder.count.matches.argument.count.display.name=Number of placeholders does not match number of arguments in logging call
|
||||
jvm.inspection.logging.placeholder.count.matches.argument.count.more.problem.descriptor=More arguments provided ({0}) than placeholders specified ({1}) #loc
|
||||
jvm.inspection.logging.placeholder.count.matches.argument.count.fewer.problem.partial.descriptor=Fewer arguments provided ({0}) than placeholders specified (at least {1}) #loc
|
||||
jvm.inspection.logging.placeholder.count.matches.argument.count.fewer.problem.descriptor=Fewer arguments provided ({0}) than placeholders specified ({1}) #loc
|
||||
jvm.inspection.logging.placeholder.count.matches.argument.count.incorrect.problem.descriptor=Illegal format string specifier #loc
|
||||
jvm.inspection.logging.placeholder.count.matches.argument.count.more.problem.descriptor=More arguments provided ({0}) than placeholders specified ({1})
|
||||
jvm.inspection.logging.placeholder.count.matches.argument.count.fewer.problem.partial.descriptor=Fewer arguments provided ({0}) than placeholders specified (at least {1})
|
||||
jvm.inspection.logging.placeholder.count.matches.argument.count.fewer.problem.descriptor=Fewer arguments provided ({0}) than placeholders specified ({1})
|
||||
jvm.inspection.logging.placeholder.count.matches.argument.count.incorrect.problem.descriptor=Illegal format string specifier
|
||||
jvm.inspection.logging.placeholder.count.matches.argument.count.slf4j.throwable.option=SLF4J uses Log4j 2 as implementation
|
||||
jvm.inspection.logging.placeholder.count.matches.argument.count.slf4j.throwable.option.auto=Check automatically
|
||||
jvm.inspection.logging.placeholder.count.matches.argument.count.slf4j.throwable.option.yes=Yes
|
||||
@@ -213,9 +213,9 @@ jvm.inspection.test.failed.line.display.name=Failed line in test
|
||||
jvm.inspections.thread.run.display.name=Call to 'Thread.run()'
|
||||
|
||||
jvm.inspections.serializable.class.without.serialversionuid.display.name=Serializable class without 'serialVersionUID'
|
||||
jvm.inspections.serializable.class.without.serialversionuid.problem.descriptor=<code>#ref</code> does not define a 'serialVersionUID' field #loc
|
||||
jvm.inspections.serializable.class.without.serialversionuid.problem.descriptor=<code>#ref</code> does not define a 'serialVersionUID' field
|
||||
|
||||
jvm.inspections.string.touppercase.tolowercase.without.locale.description=<code>String.{0}()</code> called without specifying a Locale using internationalized strings #loc
|
||||
jvm.inspections.string.touppercase.tolowercase.without.locale.description=<code>String.{0}()</code> called without specifying a Locale using internationalized strings
|
||||
|
||||
jvm.inspections.api.display.name=Usages of API which isn't available at the configured language level
|
||||
assertequals.between.inconvertible.types.display.name='assertEquals()' between objects of inconvertible types
|
||||
@@ -225,7 +225,7 @@ jvm.inspections.1.7.problem.descriptor=Usage of generified after 1.6 API which w
|
||||
jvm.inspections.1.8.problem.descriptor=Default {0, choice, 0#|1#method is|2# methods are} not overridden. It would cause compilation problems with JDK {1}
|
||||
jvm.inspections.1.8.problem.single.descriptor=Default method ''{0}'' is not overridden. It would cause compilation problems with JDK {1}
|
||||
|
||||
jvm.inspections.assertequals.between.inconvertible.types.problem.descriptor=<code>#ref()</code> between objects of inconvertible types ''{0}'' and ''{1}'' #loc
|
||||
jvm.inspections.assertequals.between.inconvertible.types.problem.descriptor=<code>#ref()</code> between objects of inconvertible types ''{0}'' and ''{1}''
|
||||
jvm.inspections.assertnotsame.between.inconvertible.types.problem.descriptor=Redundant assertion: incompatible types are compared ''{0}'' and ''{1}''
|
||||
jvm.inspections.assertnotequals.between.inconvertible.types.problem.descriptor=Possibly redundant assertion: incompatible types are compared ''{0}'' and ''{1}''
|
||||
|
||||
@@ -243,8 +243,8 @@ jvm.inspections.dependency.intention.description=Opens a dialog to configure dep
|
||||
jvm.class.filter.choose.calls=Similar Log Calls:
|
||||
|
||||
inspection.suppression.annotation.display.name=Inspection suppression annotation
|
||||
inspection.suppression.annotation.problem.descriptor=Annotation suppresses {0} #loc
|
||||
inspection.suppression.comment.problem.descriptor=Comment suppresses {0} #loc
|
||||
inspection.suppression.annotation.problem.descriptor=Annotation suppresses {0}
|
||||
inspection.suppression.comment.problem.descriptor=Comment suppresses {0}
|
||||
ignored.suppressions=Ignored suppressions:
|
||||
remove.suppress.comment.fix.family.name=Remove //{0}
|
||||
allow.suppressions.fix.family.name=Allow suppressions
|
||||
|
||||
@@ -87,7 +87,7 @@ quickfix.text.title.capitalization=Properly capitalize ''{0}''
|
||||
rename.prefix.based.property.key.error.message=Could not rename property key ''{1}'' based on prefix ''{0}'' by name ''{2}'', change prefix first
|
||||
resource.bundle.contains.locales.with.suspicious.locale.languages.desciptor=Resource bundle contains locales with suspicious locale languages
|
||||
unused.message.format.parameter.display.name=Missing message format parameter
|
||||
unused.message.format.parameter.problem.descriptor=Using parameter {0} without using parameter {1} in <code>#ref<code> #loc
|
||||
unused.message.format.parameter.problem.descriptor=Using parameter {0} without using parameter {1} in <code>#ref<code>
|
||||
unsupported.character.display.name=Unsupported character
|
||||
unsupported.character.problem.descriptor=Unsupported characters for the charset ''{0}''
|
||||
unsupported.character.inspection.fix.description=Convert to escape sequences
|
||||
|
||||
Reference in New Issue
Block a user