abstract.class.not.allowed=Abstract class is not allowed access.static.via.instance=Access static member via instance reference action.AnActionButton.text.select.annotation.used.for.code.generation=Select annotation used for code generation action.analyzing.cyclic.dependencies.in.scope=Cyclic Dependencies of {0} action.create.new.class=New Java Class action.create.new.class.description=Create new Java class action.create.new.module-info.description=Create new module-info.java action.create.new.module-info.title=module-info.java action.create.new.package-info.description=Create new package-info.java action.create.new.package-info.title=package-info.java action.cyclic.dependency.title=Cyclic Dependency Analysis action.description.copy.whole.thread.dump.to.clipboard=Copy whole thread dump to clipboard action.description.group.by.scope=Group by Scope Type (production, test, libraries) action.description.group.threads.with.identical.stacktraces=Group threads with identical stacktraces action.description.mark.directory.as.a.0.for.generated.files=Mark directory as a {0} for generated files action.description.mark.directory.as.an.ordinary.0=Mark directory as an ordinary {0} action.description.show.only.threads.containing.a.specific.string=Show only threads containing a specific string action.group.by.package=Package action.group.by.scope.type=Group by Scope Type action.implement.method=Implement Method action.implement.methods=Implement methods action.override.method=Override Method action.override.methods=Override Methods action.text.0.on.parameter.1={0} on parameter ''{1}'' action.text.choose.class.in.0=choose class in {0}... action.text.copy.to.clipboard=Copy to Clipboard action.text.edit.template=Edit Template action.text.enter.class.name=enter class name... action.text.generated.root.0=Generated {0} action.text.merge.identical.stacktraces=Merge Identical Stacktraces action.text.show.methods.to.implement=Show methods to implement action.text.show.quick.list=Show Quick list action.text.unmark.generated.0=Unmark Generated {0} action.GotoSuperClass.text=Go to S_uper Class action.GotoSuperClass.MainMenu.text=S_uper Class action.GotoSuperClass.description=Navigate to the declaration of a class that the current class extends or implements add.to.permits.list=Add ''{0}'' to permits list of a sealed class ''{1}'' annotate.intention.chooser.title=Choose annotation to add assignment.to.declared.variable.problem.descriptor=Variable ''{0}'' is initialized with self assignment assignment.to.itself.problem.descriptor=Variable ''{0}'' is assigned to itself assignment.to.itself.quickfix.name=Remove self assignment bean.property=Bean Property boolean.method.is.always.inverted.display.name=Boolean method is always inverted boolean.method.is.always.inverted.problem.descriptor=Boolean method '#ref' is always inverted button.add.blank=Add Blank button.add.class=Add Class... button.add=Add... button.add.package=Add Package... button.add.pattern=Add Pattern... button.annotations=Annotations... button.base.method=&Base Method button.code.patterns=Code patterns... button.current.method=&Current Method button.text.settings=Settings... cast.expression=Cast expression cast.to.0=Cast to ''{0}'' change.color.command.text=Change color change.uid.action.name=Randomly change 'serialVersionUID' initializer checkbox.after.description=After description checkbox.after.parameter.descriptions=After parameter descriptions checkbox.after.return.tag=After return tag checkbox.align.parameter.descriptions=Align parameter descriptions checkbox.align.thrown.exception.descriptions=Align thrown exception descriptions checkbox.annotate.local.variables=Annotate local variables checkbox.collapse.annotations=Annotations checkbox.collapse.anonymous.classes=Anonymous classes checkbox.collapse.closures="Closures" (anonymous classes implementing one method, before Java 8) checkbox.collapse.end.of.line.comments=End of line comments sequence checkbox.collapse.generic.constructor.parameters=Generic constructor and method parameters checkbox.collapse.i18n.messages=I18n strings checkbox.collapse.inferred.type=Replace 'var' with inferred type checkbox.collapse.inner.classes=Inner classes checkbox.collapse.multiline.comments=Multiline comments checkbox.collapse.one.line.methods=One-line methods checkbox.collapse.simple.property.accessors=Simple property accessors checkbox.collapse.suppress.warnings=@SuppressWarnings checkbox.comments.and.javadoc.count.as.content=Comments and javadoc count as content checkbox.deprecated.members=Deprecated members checkbox.do.not.indent.top.level.class.members=Do not indent top level class members checkbox.do.not.wrap.after.single.annotation=Do not wrap after single annotation checkbox.do.not.wrap.one.line.comments=Do not wrap one line comments checkbox.enable.javadoc.formatting=Enable JavaDoc formatting checkbox.enable.leading.asterisks=Enable leading asterisks checkbox.generate.p.on.empty.lines=Generate "

" on empty lines checkbox.html.report.inaccessible.symbols=Report inaccessible symbols
(javadoc tool may be unable to create hyperlink) disable.report.inaccessible.symbols.fix=Don't report inaccessible symbols checkbox.ignore.fields.used.in.multiple.methods=Ignore fields used in multiple methods checkbox.ignore.simple.setters=Ignore simple setters checkbox.insert.imports.for.inner.classes=Insert imports for inner classes checkbox.iterate.unknown.stream.sources.via.stream.iterator=Iterate unknown Stream sources via Stream.iterator() checkbox.keep.empty.lines=Keep empty lines checkbox.keep.empty.param.tags=Keep empty @param tags checkbox.keep.empty.return.tags=Keep empty @return tags checkbox.keep.empty.throws.tags=Keep empty @throws tags checkbox.keep.invalid.tags=Keep invalid tags checkbox.make.generated.local.variables.final=Make generated local variables final checkbox.make.generated.parameters.final=Make generated parameters final checkbox.param.description.on.new.line=Parameter descriptions on new line checkbox.param.indent.on.continuation=Indent continuation lines checkbox.prefer.longer.names=Prefer longer names checkbox.preserve.line.feeds=Preserve line feeds checkbox.spaces.record.header=Record header checkbox.spaces.before.colon.in.foreach=Before colon in foreach checkbox.spaces.inside.one.line.enum=Inside one line enum braces checkbox.suggest.conversion.to.map.computeifabsent=Suggest conversion to Map.computeIfAbsent checkbox.suggest.conversion.to.map.getordefault=Suggest conversion to Map.getOrDefault checkbox.suggest.conversion.to.map.merge=Suggest conversion to Map.merge checkbox.suggest.conversion.to.map.putifabsent=Suggest conversion to Map.putIfAbsent checkbox.suggest.conversion.to.map.replaceall=Suggest conversion to Map.replaceAll checkbox.suggest.replacement.even.if.lambda.may.have.side.effects=Suggest replacement even if lambda may have side effects checkbox.suppress.with.suppresswarnings=Suppress with @SuppressWarnings checkbox.treat.get.k.null.the.same.as.containskey.k.may.change.semantics=Treat 'get(k) != null' the same as 'containsKey(k)' (may change semantics) checkbox.use.fully.qualified.class.names=Use fully qualified class names checkbox.use.single.class.import=Use single class import checkbox.use.throws.rather.than.exception=Use @throws rather than @exception checkbox.warn.if.only.foreach.replacement.is.available=Warn if only 'forEach' replacement is available checkbox.warn.if.the.loop.is.trivial=Warn if the loop is trivial checkbox.wrap.at.right.margin=Wrap at right margin choose.class=Choose class chooser.text.choose.where.to.save.0=Choose where to save ''{0}'' chooser.title.select.path.to.save.jar=Select Path to Save Jar class.decorator.or.has.default.constructor=''{0}'' should have default constructor or implement ''Decorator'' pattern class.filter.editor.add.dialog.title=New Filter class.filter.editor.choose.class.title=Choose Class class.has.no.default.constructor=''{0}'' has no default constructor class.is.not.a.subclass=''{0}'' is not assignable to ''{1}'' class.is.not.concrete=''{0}'' is not a concrete class class.is.not.public=''{0}'' is not public class.not.found.error.message=Class ''{0}'' not found code.style.generation.override.method.signature=Override Method Signature code.style.generation.repeat.synchronized.modifier=Repeat &synchronized modifier code.style.generation.replace.null.check=Replace null-check with Objects::nonNull or Objects::isNull code.style.generation.use.class.isInstance=Use Class::isInstance and Class::cast when possible code.style.generation.use.integer.sum=Use Integer::sum, etc. when possible combobox.paste.insert.imports=&Insert imports on paste: command.create.class.from.template=Create Class From Template command.create.new.subdirectory=Create New Subdirectory command.name.insert.block.statement=Insert block statement command.name.updating.package.statement=Updating package statement comment.the.class.will.be.created.in.the.package.0=The class will be created in the package ''{0}'' completion.class.name.hint.2=Press {0} once more to ignore module dependencies while searching completion.no.suggestions.of.type=No suggestions of type {0} completion.smart.aslist.hint=Press {0} once more to find arrays of {1} completion.smart.chain.hint=Press {0} once more to search across chained method calls completion.smart.hint=Press {0} to show only variants that are suitable by type completion.smart.toar.hint=Press {0} once more to find collections of {1} completion.smart.type.generate.anonymous.body=generate anonymous body completion.unknown.type=Unknown type {0} configurable.EqualsHashCodeTemplatesPanel.display.name=Templates configurable.GenerateToStringConfigurable.display.name=Settings configurable.TemplatesPanel.display.name=Templates label.new.template.name=New template name: dialog.title.create.new.template=Create New Template dialog.title.copy.template=Copy Template configure.annotations.option=Configure Annotations convert.compareto.expression.to.equals.call=Convert 'compareTo()' expression to 'equals()' call convert.compareto.expression.to.equals.call.may.change.semantics=Convert 'compareTo()' expression to 'equals()' call (may change semantics) copy.abstract.method.intention.name=Use existing implementation of ''{0}'' copy.abstract.method.no.existing.implementations.found=No existing implementations found copy.abstract.method.popup.title=Choose implementation to copy copy.abstract.method.title=Use Abstract Method Implementation copy.paste.reference.notification={0} {0, choice, 1#import was|2#imports were} added

Review Added Imports... cyclic.dependencies.progress.text=Building dependencies graph cyclic.dependencies.scope.dialog.module.button={0} &module ''{1}'' cyclic.dependencies.scope.dialog.project.button={0} the whole &project cyclic.dependencies.scope.dialog.title=Specify {0} Scope cyclic.dependencies.scope.include.test.sources.option=Include &test sources cyclic.dependencies.tree.cycle.node.text=cycle cyclic.dependencies.usage.view.initial.text=Select package to analyze from the left tree cyclic.dependencies.usage.view.root.node.text=Usages of package ''{0}'' in package ''{1}'' dataflow.from.here=Dataflow from Here dataflow.to.here=Dataflow to Here deannotate.intention.action.text=Deannotate {0} deannotate.intention.action.several.text=Deannotate... deannotate.intention.action.family.name=Deannotate deannotate.intention.chooser.title=Choose annotation to delete default.file.template.description=Default File template default.file.template.display.name=Default File Template Usage default.file.template.edit.template=Edit template... default.file.template.replace.with.actual.file.template=Replace with actual file template default.package.presentable.name= dependencies.libraries.node.text=Libraries dependencies.tree.node.default.package.abbreviation= dialog.create.class.destination.package.label=Destination package: dialog.create.class.label=Create {0}: dialog.create.class.name=Create {0} {1} dialog.create.class.package.chooser.title=Choose Destination Package dialog.create.field.from.parameter.already.exists.text=Use existing field ''{0}''? dialog.create.field.from.parameter.already.exists.use.existing.button=Use Existing Field dialog.create.field.from.parameter.already.exists.title=Field Already Exists dialog.create.field.from.parameter.declare.final.checkbox=Declare &final dialog.create.field.from.parameter.field.name.label=Name: dialog.create.field.from.parameter.field.type.label=Field of type: dialog.create.field.from.parameter.title=Create Field dialog.edit.template.checkbox.smart.type.completion=Type-matching c&ompletion dialog.edit.template.checkbox.use.static.import=Use static &import if possible dialog.import.on.paste.title=Select Classes to Import dialog.import.on.paste.title2=Select Elements to Import dialog.import.on.paste.title3=Select Import to Remove dialog.message.0.update.existing.class={0}. Update existing class? dialog.message.create.test.in.the.same.source.root=Create test in the same source root? dialog.message.infer.nullity.annotations.requires.the.project.language.level=Infer Nullity Annotations requires the project language level be set to 1.5 or greater. dialog.message.jetbrains.annotations.library.is.missing=JetBrains annotations library is missing.\nWithout the library, IntelliJ IDEA cannot run the analysis. Would you like to add it? dialog.message.no.places.found.to.infer.nullable.notnull=No places found to infer @Nullable/@NotNull dialog.paste.on.import.text=The code fragment which you have pasted uses classes that are not accessible by imports in the new context.
Select classes that you want to import to the new file. dialog.paste.on.import.text2=The code fragment which you have pasted uses elements that are not accessible by imports in the new context.
Select elements that you want to import to the new file. dialog.paste.on.import.text3=The code fragment which you have pasted introduced new imports in the current context.
Select imports that you want to eliminate. dialog.title.choose.0.parameters=Choose {0} Parameters dialog.title.choose.class=Choose Class dialog.title.configure.annotations=Configure Annotations dialog.title.configure.code.patterns=Configure Code Patterns dialog.title.create.class.in.package=Create Class in Package dialog.title.create.missed.tests=Create Missed Tests dialog.title.edit.method.contract=Edit Method Contract dialog.title.edit.range=Edit Range dialog.title.infer.nullity=Infer Nullity action.description.infer.nullity.annotations=Infer Nullity Annotations dialog.title.infer.nullity.results=Infer Nullity Results dialog.title.no.test.roots.found=No Test Roots Found dialog.title.process.duplicates=Process Duplicates dialog.title.super.method.found=Super Method Found do.not.import.inner.classes.for=Exclude inner classes by short name: do.not.import.inner.classes.no.classes=No inner classes defined editbox.blanklines.around.initializer=Around initializer: editbox.class.count.to.use.import.with.star=Class count to use import with '*': editbox.names.count.to.use.static.import.with.star=Names count to use static import with '*': enum.not.allowed=Enum is not allowed error.attempt.to.generate.constructor.for.anonymous.class=Cannot add constructor to an anonymous class error.hint.no.expression.found=No expression found error.package.already.contains.package-info=''package-info.java'' already exists for package ''{0}'' error.package.already.contains.package.html=Package ''{0}'' already has a ''package.html'' file. Create ''package-info.java'' anyway? error.package.html.found.title=Found 'package.html' error.text.this.is.not.a.valid.java.class.name=This is not a valid Java class name exclude.0.from.completion=Exclude ''{0}'' from completion exclude.accessors=&Exclude Accessors exclude.from.completion.group=Exclude from auto-import and completion: exclude.from.imports.no.exclusions=Add a class, package, or member exclude.from.imports.no.exclusions.2=to exclude from auto-import and completion exclude.table.mask=Class, package, or member exclude.table.scope.column=Scope export.to.html.generate.hyperlinks.checkbox=Generate &hyperlinks to classes external.annotation.prompt=External annotation prompt external.annotations.external.option=Add &externally external.annotations.in.code.option=Add in &code external.annotations.root.chooser.description=External annotations would be saved in appropriate folder external.annotations.root.chooser.title=Select External Annotations Root for {0} external.annotations.suggestion.message=If you do not want annotations in your code you may use external storage.
\ To configure external annotations please specify root directory where files with annotations would be placed find.field.accessors.prompt=Search for accessors of field ''{0}''? find.field.accessors.title=Field Accessors Found find.options.include.overloaded.methods.checkbox=Include o&verloaded methods find.parameter.usages.in.overriding.methods.prompt=Do you want to search usages of parameter ''{0}'' in overriding methods? find.parameter.usages.in.overriding.methods.title=Search in Overriding Methods find.what.derived.classes.checkbox=&Derived classes find.what.derived.interfaces.checkbox=&Derived interfaces find.what.fields.usages.checkbox=Usages of &fields find.what.group=Find find.what.implementing.classes.checkbox=&Implementing classes find.what.implementing.methods.checkbox=&Implementing methods find.what.implicit.to.string.checkbox=I&mplicit calls find.what.methods.usages.checkbox=Usages of &methods find.what.overriding.methods.checkbox=Over&riding methods find.what.usages.checkbox=&Usages find.what.usages.of.classes.and.interfaces=Usages of &classes and interfaces generate.button.title=Generate generate.constructor.fields.chooser.title=Choose Fields to Initialize by Constructor generate.constructor.super.constructor.chooser.title=Choose Super Class Constructor generate.delegate.target.chooser.title=Select Target to Generate Delegates for generate.equals.and.hashcode.already.defined.title=Generate equals() and hashCode() generate.equals.and.hashcode.already.defined.warning=Methods ''boolean equals(Object)'' and ''int hashCode()'' are already defined\nfor class {0}. Do you want to delete them and proceed? generate.equals.and.hashcode.already.defined.warning.anonymous=Methods 'boolean equals(Object)' and 'int hashCode()' are already defined\nfor this anonymous class. Do you want to delete them and proceed? generate.equals.hashcode.accept.sublcasses=Accept &subclasses as parameter to equals() method generate.equals.hashcode.accept.sublcasses.explanation=While generally incompliant to Object.equals() specification accepting
subclasses might be necessary for generated \ method to work correctly
with frameworks, which generate Proxy subclasses like Hibernate. generate.equals.hashcode.equals.fields.chooser.title=Choose &fields to be included in equals() generate.equals.hashcode.hashcode.fields.chooser.title=Choose &fields to be included in hashCode() generate.equals.hashcode.internal.error=Internal error generate.equals.hashcode.non.null.fields.chooser.title=Select all non-null &fields generate.equals.hashcode.template=&Template: generate.equals.hashcode.use.getters=Use &getters during code generation generate.equals.hashcode.warning.hashcode.for.arrays.is.not.supported=hashCode () for arrays is not supported generate.equals.hashcode.wizard.title=Generate equals() and hashCode() generate.equals.template.title=Equals Template: generate.equals.warning.equals.for.nested.arrays.not.supported=equals() for nested arrays is not supported generate.equals.warning.generated.equals.could.be.incorrect=Generated equals() for Object[] can be incorrect generate.getter.fields.chooser.title=Select Fields to Generate Getters generate.getter.setter.title=Select Fields to Generate Getters and Setters generate.getter.template=&Getter template: generate.hashcode.template.title=HashCode Template: generate.record.constructor.title=Generate Records Constructor generate.setter.fields.chooser.title=Select Fields to Generate Setters generate.setter.template=&Setter template: generate.tostring.already.exist.border=When method already exists generate.tostring.available.implicit.variables.label=Available implicit variables:
{0} generate.tostring.exclude..transient=Exclude transient fields generate.tostring.exclude.by.field.name=Exclude fields by name (reg exp) generate.tostring.exclude.by.field.type=Exclude fields by type name (reg exp) generate.tostring.exclude.by.name=Exclude methods by name (reg exp) generate.tostring.exclude.by.return.type=Exclude methods by return type name (reg exp) generate.tostring.exclude.constant.fields=Exclude constant fields generate.tostring.exclude.enum.fields=Exclude enum fields generate.tostring.exclude.logger=Exclude logger fields (Log4j, JDK Logging, Jakarta Commons Logging) generate.tostring.exclude.static.fields=Exclude static fields generate.tostring.fully.qualified.class.name=Use fully qualified class name in code generation ($classname) generate.tostring.getters.in.generated.code=Enable getters in code generation ($methods) generate.tostring.handle.exception.error.message=An unrecoverable exception was thrown while performing the action - see IDEA log for details (stacktrace should be in idea.log):\n{0} generate.tostring.handle.exception.plugin.warning.message=A PluginException was thrown while performing the action - see IDEA log for details (stacktrace should be in idea.log):\n{0} generate.tostring.handle.exception.velocity.error.message=Velocity error generating code - see IDEA log for more details (stacktrace should be in idea.log):\n{0} generate.tostring.insert.border=Where to insert? generate.tostring.method.already.exists.dialog.me\=ssage=Replace existing {0} method generate.tostring.method.already.exists.dialog.title=Method Already Exists generate.tostring.move.to.generated.checkbox=Move caret to generated method generate.tostring.settings=Settings generate.tostring.sort.ascending=Ascending generate.tostring.sort.checkbox=Sort elements generate.tostring.sort.descending=Descending generate.tostring.sort.super=Super class members first generate.tostring.tab.title=toString() Generation Settings generate.tostring.template.label=Template: generate.tostring.title=Generate toString() goto.super.class.chooser.title=Choose super class or interface group.javadoc.alignment=Alignment group.javadoc.blank.lines=Blank lines group.javadoc.invalid.tags=Invalid tags group.javadoc.other=Other gutter.implemented.method=Implemented method gutter.implementing.method=Implementing method gutter.overridden.method=Overridden method gutter.overriding.method=Overriding method gutter.service=Service gutter.sibling.inherited.method=Sibling inherited method highlight.exceptions.thrown.chooser.title=Choose Exception Classes to Highlight highlight.imported.classes.chooser.title=Choose Imported Classes to Highlight highlight.imported.members.chooser.title=Choose Imported Members to Highlight highlight.overridden.classes.chooser.title=Choose Classes to Highlight Overridden Methods from icon.preview=Icon preview ignore.imports.and.formatting=Ignore imports and formatting illegal.name.validation.info=Illegal name: {0} import.layout.static.imports.separately=Layout static imports separately import.statically=Import statically include.accessors=&Include Accessors infer.nullity.progress=Post-processing results... insert.override.annotation=Insert @&Override annotation inspection.1.5.display.name=Usages of API which isn't available at the configured language level inspection.1.5.problem.descriptor=Usage of API documented as @since {0}+ inspection.1.7.problem.descriptor=Usage of generified after 1.6 API which would cause compilation problems with JDK {0} inspection.1.8.problem.descriptor=Default {0, choice, 0#|1#method is|2# methods are} not overridden. It would cause compilation problems with JDK {1} inspection.1.8.problem.single.descriptor=Default method ''{0}'' is not overridden. It would cause compilation problems with JDK {1} inspection.assert.quickfix=Assert ''{0}'' inspection.capturing.cleaner=Runnable passed to Cleaner.register() captures ''{0}'' reference inspection.capturing.cleaner.description=Cleaner captures object reference inspection.cast.can.be.removed.narrowing.variable.type.fix.family.name=Change variable type and remove cast inspection.cast.can.be.removed.narrowing.variable.type.fix.name=Change type of ''{0}'' to ''{1}'' and remove cast inspection.cast.can.be.removed.narrowing.variable.type.message=Cast may be removed by changing the type of ''{0}'' to ''{1}'' inspection.cast.can.be.removed.narrowing.variable.type.name=Too weak variable type leads to unnecessary cast inspection.charset.object.can.be.used.display.name=Standard 'Charset' object can be used inspection.charset.object.can.be.used.fix.family.name=Use Charset constant inspection.charset.object.can.be.used.fix.name=Replace with ''{0}'' inspection.charset.object.can.be.used.message={0} can be used instead inspection.collection.factories.fix.family.name=Replace with collection factory call inspection.collection.factories.fix.name=Replace with ''{0}.{1}()'' call inspection.collection.factories.message=Can be replaced with ''{0}.{1}()'' call inspection.collection.factories.option.ignore.non.constant=Only report when content is constant inspection.collection.factories.option.suggest.ofentries=Suggest 'Map.ofEntries()' inspection.collection.used.as.vararg.display.name=Iterable is used as vararg inspection.collection.used.as.vararg.message=Iterable is passed as vararg: probably an array was intended inspection.comparator.result.comparison.display.name=Suspicious usage of compare method inspection.comparator.result.comparison.fix.family.name=Fix comparator result comparison inspection.comparator.result.comparison.problem.display.name=Comparison of compare method result with specific constant inspection.conditional.break.in.infinite.loop=Move condition to loop inspection.conditional.break.in.infinite.loop.description=Conditional break inside infinite loop inspection.conditional.break.in.infinite.loop.no.conversion.with.do.while=Don't suggest to replace with 'do while' inspection.convert.to.basic.latin=Convert to Basic Latin inspection.convert.to.local.quickfix=Convert to local inspection.data.flow.display.name=Constant conditions \\& exceptions inspection.data.flow.filter.notnull.quickfix=Insert 'filter(Objects::nonNull)' step inspection.data.flow.nullable.quickfix.option=Suggest @Nullable annotation for methods/fields/parameters where nullable values are used inspection.data.flow.true.asserts.option=Don't report assertions with condition statically proven to be always true inspection.data.flow.ignore.assert.statements=Ignore assert statements inspection.data.flow.warn.when.reading.a.value.guaranteed.to.be.constant=Warn when reading a value guaranteed to be constant inspection.data.flow.treat.non.annotated.members.and.parameters.as.nullable=Treat non-annotated members and parameters as @Nullable inspection.data.flow.report.not.null.required.parameter.with.null.literal.argument.usages=Report not-null required parameter with null-literal argument usages inspection.data.flow.report.nullable.methods.that.always.return.a.non.null.value=Report nullable methods that always return a non-null value inspection.data.flow.report.problems.that.happen.only.on.some.code.paths=Report problems that happen only on some code paths inspection.data.flow.use.computeifpresent.quickfix=Replace 'compute' with 'computeIfPresent' inspection.dead.code.option.applet=Applets inspection.dead.code.option.external=Classes with usages in non-Java files inspection.dead.code.option.main=void main(String args[]) methods inspection.dead.code.option.servlet=Servlets inspection.default.annotation.param=Default annotation parameter value inspection.duplicate.branches.in.switch.default.message=Branch in 'switch' is a duplicate of the default branch inspection.duplicate.branches.in.switch.delete.fix.family.name=Delete redundant 'switch' branches inspection.duplicate.branches.in.switch.delete.fix.name=Delete redundant 'switch' branch inspection.duplicate.branches.in.switch.display.name=Duplicate branches in 'switch' inspection.duplicate.branches.in.switch.merge.fix.family.name=Merge duplicate branches in 'switch' inspection.duplicate.branches.in.switch.merge.fix.name=Merge with ''{0}'' inspection.duplicate.branches.in.switch.merge.with.default.fix.name=Merge with the default 'switch' branch inspection.duplicate.branches.in.switch.message=Duplicate branch in 'switch' inspection.duplicate.expressions.complexity.threshold=Expression complexity threshold 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 #ref #loc 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 inspection.duplicate.expressions.reuse.variable.fix.name=Reuse variable ''{0}'' for ''{1}'' inspection.empty.method.delete.quickfix=Delete unnecessary method(s) inspection.empty.method.problem.descriptor=Method only calls its super inspection.empty.method.problem.descriptor1=Empty method overrides empty method inspection.empty.method.problem.descriptor2=The method is empty inspection.empty.method.problem.descriptor3=The method and all its derivables are empty inspection.empty.method.problem.descriptor4=All implementations of this method are empty inspection.endless.stream.description=Non-short-circuit operation consumes infinite stream inspection.equals.hashcode.display.name='equals()' and 'hashCode()' not paired inspection.equals.hashcode.generate.equals.quickfix=Generate 'equals()' inspection.equals.hashcode.generate.hashcode.quickfix=Generate 'hashCode()' inspection.excessive.lambda.fix.family.name=Replace lambda with constant inspection.excessive.lambda.fix.name=Use ''{0}'' method without lambda inspection.excessive.lambda.message=Excessive lambda usage inspection.explicit.argument.can.be.lambda.fix.family.name=Replace explicit argument with function inspection.explicit.argument.can.be.lambda.fix.name=Use ''{0}'' method with functional argument inspection.explicit.argument.can.be.lambda.message=Explicit argument can be converted to lambda inspection.explicit.array.filling.description=Can be replaced with single ''Arrays.{0}()'' method call inspection.explicit.array.filling.fix.family.name=Replace loop with ''Arrays.{0}()'' method call inspection.explicit.array.filling.no.suggestion.for.set.all=Do not suggest to use 'Arrays.setAll()' inspection.explicit.array.filling.redundant.loop.description=Redundant initialization of a newly created array inspection.explicit.array.filling.suggest.set.all=Suggest 'Arrays.setAll()' inspection.export.results.callees=Call chain inspection.export.results.implicit.constructor=implicit constructor of inspection.export.results.overrides.library.methods=Overrides library methods inspection.export.results.package=package inspection.export.results.type.references=The following uses this type inspection.field.can.be.local.display.name=Field can be local inspection.field.can.be.local.problem.descriptor=Field can be converted to a local variable inspection.field.can.be.local.quickfix.constructor=Convert field to local variable in constructor inspection.field.can.be.local.quickfix.initializer=Convert field to local variable in initializer section inspection.field.can.be.local.quickfix.one.method=Convert field to local variable in method ''{0}'' inspection.fold.expression.fix.family.name=Fold expression inspection.fold.expression.into.stream.display.name=Expression can be folded into Stream chain inspection.fold.expression.into.stream.fix.name=Fold expression into Stream chain inspection.fold.expression.into.string.display.name=Expression can be folded into 'String.join' inspection.fold.expression.into.string.fix.name=Fold expression into 'String.join' inspection.forward.compatibility.name=Forward compatibility inspection.fuse.stream.operations.display.name=Subsequent steps can be fused into Stream API chain inspection.fuse.stream.operations.fix.family.name=Fuse more statements to the Stream API chain inspection.fuse.stream.operations.fix.name=Fuse {0} into the Stream API chain inspection.fuse.stream.operations.message=Stream may be extended replacing {0} inspection.fuse.stream.operations.option.strict.mode=Do not suggest 'toList()' or 'toSet()' collectors inspection.handle.signature.change.type.fix.name=Change type to ''{0}'' inspection.handle.signature.field.cannot.resolve=Cannot resolve field ''{0}'' inspection.handle.signature.field.not.static=Field ''{0}'' is not static inspection.handle.signature.field.static=Field ''{0}'' is static inspection.handle.signature.field.type=The type of field ''{0}'' is ''{1}'' inspection.handle.signature.method.abstract=Method ''{0}'' is abstract in ''{1}'' inspection.handle.signature.method.not.static=Method ''{0}'' is not static inspection.handle.signature.method.static=Method ''{0}'' is static inspection.handle.signature.name=MethodHandle/VarHandle type mismatch inspection.handle.signature.not.subclass=Caller class ''{0}'' must be a subclass of ''{1}'' inspection.handle.signature.replace.with.fix.name=Replace with ''{0}'' inspection.handle.signature.use.constructor.fix.family.name=Use one of constructor overloads inspection.handle.signature.use.constructor.fix.name=Use constructor ''{0}'' inspection.handle.signature.use.method.fix.family.name=Use one of method overloads inspection.handle.signature.use.method.fix.name=Use method ''{0}'' inspection.idempotent.loop.body=Idempotent loop body inspection.illegal.character=Illegal character inspection.suspicious.ternary.in.varargs.display.name=Suspicious ternary operator in varargs method call inspection.suspicious.ternary.in.varargs.description=Ternary operator in varargs call contains array and non-array branches inspection.suspicious.ternary.in.varargs.quickfix=Wrap in array initializer inspection.insert.literal.underscores.display.name=Unreadable numeric literal inspection.insert.literal.underscores.family.name=Insert underscores into numeric literal inspection.javadoc.dialog.title=Edit Additional Javadoc Tags inspection.javadoc.display.name=Declaration has Javadoc problems inspection.javadoc.label.text=Additional Javadoc tags: inspection.javadoc.lint.display.name=HTML problems in Javadoc (DocLint) inspection.javadoc.method.problem.missing.param.tag=Required tag @param is missing for parameter {0} inspection.javadoc.method.problem.missing.tag.description={0} tag description is missing inspection.javadoc.option.ignore.deprecated=Ignore elements marked as @deprecated inspection.javadoc.option.ignore.period=Ignore period problems inspection.javadoc.option.ignore.self.ref=Ignore Javadoc pointing to itself inspection.javadoc.option.ignore.simple=Ignore simple property accessors inspection.javadoc.option.ignore.throws=Ignore duplicate 'throws' tag inspection.javadoc.option.tab.title=Class inspection.javadoc.option.tab.title.field=Field inspection.javadoc.option.tab.title.inner.class=Inner class inspection.javadoc.option.tab.title.method=Method inspection.javadoc.option.tab.title.module=Module inspection.javadoc.option.tab.title.package=Package inspection.javadoc.problem.add.param.tag=Add tag @param for parameter ''{0}'' inspection.javadoc.problem.add.param.tag.family=Add missing Javadoc param tag inspection.javadoc.problem.add.tag=Add tag @{0} {1} inspection.javadoc.problem.add.tag.family=Add missing Javadoc tag inspection.javadoc.problem.cannot.resolve=Cannot resolve symbol {0} inspection.javadoc.problem.descriptor=Required Javadoc is absent inspection.javadoc.problem.descriptor1=Period in the documentation is missing. The period is used by the Javadoc tool to generate the comment for the overview page inspection.javadoc.problem.disallowed.tag=Tag {0} is not allowed here inspection.javadoc.problem.duplicate.param=Duplicate @param tag for parameter ''{0}'' inspection.javadoc.problem.duplicate.tag=Duplicate @{0} tag inspection.javadoc.problem.duplicate.throws=Duplicate @throws or @exception tag for exception ''{0}'' inspection.javadoc.problem.inaccessible=Symbol {0} is inaccessible from here inspection.javadoc.problem.missing.tag=Required tag {0} is missing inspection.javadoc.problem.missing.tag.description={0} is missing after @{1} tag inspection.javadoc.problem.name.expected=Name expected inspection.javadoc.problem.pointing.to.itself=Javadoc pointing to itself inspection.javadoc.problem.see.tag.expecting.ref=Class/method reference, quoted text, or HTML link are expected after @see tag inspection.javadoc.problem.wrong.tag=Wrong tag {0} inspection.javadoc.ref.display.name=Declaration has problems in Javadoc references inspection.javadoc.required.tags.option.title=Required Tags inspection.javadoc.throws.or.exception.option=@throws or @exception inspection.join.declaration.and.assignment.display.name=Assignment can be joined with declaration inspection.join.declaration.and.assignment.fix.family.name=Join declaration and assignment inspection.join.declaration.and.assignment.message=Assignment can be joined with declaration of ''{0}'' inspection.labeled.switch.rule.redundant.code.block.display.name=Labeled switch rule has redundant code block inspection.labeled.switch.rule.redundant.code.block.message=Labeled rule's code block is redundant inspection.labeled.switch.rule.redundant.code.fix.name=Unwrap code block of labeled rule inspection.lambda.to.method.call.fix.family.name=Replace lambda expression with method call inspection.lambda.to.method.call.fix.name=Replace lambda expression with ''{0}'' inspection.manual.min.max.calculation.description=Can be replaced with ''Math.{0}'' call 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.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() inspection.message.can.be.replaced.with.single.expression.in.functional.style=Can be replaced with single expression in functional style inspection.message.can.be.replaced.with.string.repeat=Can be replaced with 'String.repeat()' inspection.message.lambda.parameter.type.is.redundant=Lambda parameter type is redundant inspection.message.pseudo.functional.style.code=Pseudo functional style code inspection.message.redundant.default.parameter.value.assignment=Redundant default parameter value assignment inspection.message.replace.optional.with.if.statements=Replace Optional with if statements inspection.no.jdk.error.message=The JDK is not configured properly for this project. Inspection cannot proceed. inspection.no.modules.error.message=This project contains no modules. Inspection cannot proceed. inspection.notnull.field.not.initialized.display.name=@NotNull field is not initialized inspection.notnull.field.not.initialized.option.implicit=Ignore fields which could be initialized implicitly inspection.notnull.field.not.initialized.option.setup=Ignore fields initialized in setUp() method inspection.null.value.for.optional.assigned.ignore.fix.name=Do not warn when comparing Optional with null inspection.null.value.for.optional.assigned.message=Optional value is compared with null inspection.null.value.for.optional.context.assignment=assignment inspection.null.value.for.optional.context.declaration=declaration inspection.null.value.for.optional.context.lambda=lambda expression inspection.null.value.for.optional.context.parameter=parameter inspection.null.value.for.optional.context.return=return statement inspection.null.value.for.optional.fix.family.name=Replace with empty Optional method inspection.null.value.for.optional.message=Null is used for ''Optional'' type in {0} inspection.null.value.for.optional.option.comparisons=Report comparison of Optional with null inspection.nullable.problems.display.name=@NotNull/@Nullable problems inspection.nullable.problems.ignore.external.notnull=&Ignore external @NotNull inspection.nullable.problems.method.overrides.notnull.option=Report @NotNull ¶meters overriding @Nullable and
@Nullable methods overriding @NotNull inspection.nullable.problems.method.overrides.option=Report non-&annotated parameters or methods overriding @NotNull inspection.nullable.problems.not.annotated.getters.for.annotated.fields=Report non-annotated &setter parameters or getters of annotated fields inspection.nullable.problems.notnull.overrides.option=Report @NotNull ¶meters overriding non-annotated inspection.nullable.problems.notnull.parameters.with.null.literal.option=Report @NotNull parameters with null-literal argument usages inspection.optional.get.without.is.present.message={0}.#ref() without ''isPresent()'' check inspection.overflowing.loop.index.inspection.description=Loop executes zero or billions times inspection.overflowing.loop.index.inspection.name=Loop executes zero or billions times inspection.overwritten.key.map.message=Duplicate Map key inspection.overwritten.key.set.message=Duplicate Set 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.pseudo.functional.style.add.methods.after.quick.fix=After quick fix: inspection.pseudo.functional.style.add.methods.before.quick.fix=Before quick fix: inspection.pseudo.functional.style.add.methods.fully.qualified.class.name=Fully qualified class name: inspection.pseudo.functional.style.add.methods.method.name=Method name: inspection.pseudo.functional.style.add.methods.stream.api.replacement=Stream API replacement: inspection.quickfix.assert.family=Assert inspection.raw.use.of.parameterized.type.problem.descriptor=Raw use of parameterized class #ref #loc 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.use.of.parameterized.type.ignore.new.objects.option=Ignore construction of new objects raw.use.of.parameterized.type.ignore.type.casts.option=Ignore type casts raw.use.of.parameterized.type.ignore.uncompilable.option=Ignore where a type parameter would not compile raw.use.of.parameterized.type.ignore.overridden.parameter.option=Ignore parameter types of overriding methods raw.use.of.parameterized.type.ignore.quickfix.not.available.option=Do not warn when automatic quick-fix is not available inspection.redundant.array.creation.display.name=Redundant array creation inspection.redundant.array.creation.for.varargs.call.descriptor=Redundant array creation for calling varargs method 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=#ref is redundant #loc 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 inspection.redundant.null.check.fix.notnull.family.name=Remove erroneous '!= null' inspection.redundant.null.check.message=Redundant null-check: {0} is never null inspection.redundant.operation.on.empty.array.message=Array #ref is always empty inspection.redundant.operation.on.empty.collection.message=Collection #ref is always empty inspection.redundant.operation.on.empty.container.display.name=Redundant operation on empty container inspection.redundant.operation.on.empty.map.message=Map #ref is always empty inspection.redundant.record.constructor.can.be.compact.message=Canonical constructor can be converted to compact form inspection.redundant.record.constructor.canonical.message=Redundant canonical constructor inspection.redundant.record.constructor.compact.message=Redundant compact constructor inspection.redundant.record.constructor.description=Redundant record constructor inspection.redundant.record.constructor.fix.family.name=Convert canonical constructor to compact form inspection.redundant.record.constructor.statement.message=Redundant field assignment in compact constructor inspection.redundant.stream.optional.call.explanation.at.most.one=stream contains at most one element inspection.redundant.stream.optional.call.explanation.distinct=there already was a 'distinct' call in the chain inspection.redundant.stream.optional.call.explanation.distinct.set=elements will be distinct anyways when collected to the Set inspection.redundant.stream.optional.call.explanation.filter=predicate is always true inspection.redundant.stream.optional.call.explanation.map.flatMap=previous 'map' call can replace the 'flatMap' step inspection.redundant.stream.optional.call.explanation.parallel=there''s subsequent ''{0}'' call which overrides this call inspection.redundant.stream.optional.call.explanation.parallel.single=stream created from single element will not be parallelized inspection.redundant.stream.optional.call.explanation.sorted=subsequent ''{0}'' call doesn''t depend on the sort order inspection.redundant.stream.optional.call.explanation.sorted.twice=stream content is sorted again after that inspection.redundant.stream.optional.call.explanation.unordered=there already was an 'unordered' call in the chain inspection.redundant.stream.optional.call.fix.collect.to.ordered.family.name=Collect to 'LinkedHashSet' inspection.redundant.stream.optional.call.fix.family.name=Remove redundant chain call inspection.redundant.stream.optional.call.fix.name=Remove ''{0}'' call inspection.redundant.stream.optional.call.message=Redundant ''{0}'' call inspection.redundant.stream.optional.call.message.with.explanation=Redundant ''{0}'' call: {1} inspection.redundant.stream.optional.call.option.streamboxing=Report redundant boxing in Stream.map inspection.reflect.handle.invocation.argument.not.array=Argument is not an array type inspection.reflect.handle.invocation.argument.not.exact=Argument type should be exactly ''{0}'' inspection.reflect.handle.invocation.primitive.argument.null=Argument of type ''{0}'' cannot be ''null'' inspection.reflect.handle.invocation.receiver.incompatible=Call receiver type is incompatible: ''{0}'' is expected inspection.reflect.handle.invocation.receiver.null=Call receiver is 'null' inspection.reflect.handle.invocation.result.not.assignable=Should be cast to ''{0}'' or its superclass inspection.reflect.handle.invocation.result.not.exact=Should be cast to ''{0}'' inspection.reflect.handle.invocation.result.null=Returned value is always 'null' inspection.reflect.handle.invocation.result.void=Return type is 'void' inspection.reflection.invocation.argument.count={0,choice,0#No arguments are|1#One argument is|1<{0} arguments are} expected inspection.reflection.invocation.argument.not.assignable=Argument is not assignable to ''{0}'' inspection.reflection.invocation.array.not.assignable=Array {0,choice,1#item has|1#ref is not used in any implementation inspection.unused.parameter.composer1=Parameter #ref is not used in either this method or any of its derived methods inspection.unused.parameter.delete.quickfix=Delete unused parameter(s) inspection.unused.return.value.display.name=Method can be void inspection.unused.return.value.make.void.quickfix=Make method 'void' inspection.unused.return.value.problem.descriptor=Return value of the method is never used inspection.unused.symbol.check.accessors=Getters/setters inspection.unused.symbol.check.classes=Classes: inspection.unused.symbol.check.fields=Fields: inspection.unused.symbol.check.inner.classes=Inner classes: inspection.unused.symbol.check.localvars=Local variables inspection.unused.symbol.check.methods=Methods: inspection.unused.symbol.check.parameters=Parameters in inspection.value.based.warnings=Value-based warnings inspection.preview.feature=Preview Feature warning inspection.value.based.warnings.synchronization=Attempt to synchronize on an instance of a value-based class inspection.variable.assigned.to.itself.display.name=Variable is assigned to itself inspection.wrapper.type.may.be.primitive.fix.name=Convert wrapper type to primitive inspection.wrapper.type.may.be.primitive.name=Type may be primitive intention.add.explicit.type.arguments.family=Add explicit type arguments intention.add.on.demand.static.import.family=Add on-demand static import intention.add.on.demand.static.import.text=Add on-demand static import for ''{0}'' intention.add.single.member.import.text=Add import for ''{0}'' intention.add.single.member.static.import.family=Add single-member static import intention.add.single.member.static.import.text=Add static import for ''{0}'' intention.assign.field.from.parameter.family=Assign parameter to field intention.assign.field.from.parameter.text=Assign parameter to field ''{0}'' intention.bind.fields.from.parameters.family=Bind parameters to fields intention.bind.fields.from.parameters.text=Bind {0} parameters to fields intention.break.string.on.line.breaks.text=Break string on '\\n' intention.compose.function.family=Replace nested function call with composition intention.compose.function.text=Replace nested function call with andThen call intention.convert.color.representation.family=Convert Color representation intention.convert.color.representation.text=Convert to ''new Color{0}'' intention.convert.compact.constructor.to.canonical=Convert compact constructor to canonical intention.convert.to.single.return.name=Transform body to single exit-point form intention.convert.to.single.return.progress.title=Transform body to single exit-point form intention.convert.to.single.return.command.text=Transform Body To Single Exit-Point Form intention.create.field.from.parameter.family=Create field for parameter intention.create.field.from.parameter.text=Create field for parameter ''{0}'' intention.create.test.dialog.choose.super.class=Choose Superclass intention.create.test.dialog.class.name=Class name: intention.create.test.dialog.fix.library=Fix intention.create.test.dialog.generate=Generate: intention.create.test.dialog.java=Java intention.create.test.dialog.library.not.found={0} library not found in the module intention.create.test.dialog.select.methods=Generate test &methods for: intention.create.test.dialog.setUp=set&Up/@Before intention.create.test.dialog.show.inherited=Show &inherited methods intention.create.test.dialog.super.class=Superclass: intention.create.test.dialog.tearDown=tear&Down/@After intention.create.test.dialog.testing.library=Testing &library: intention.encapsulate.field.text=Encapsulate field intention.error.cannot.create.class.message=Cannot Create Class ''{0}'' intention.error.cannot.create.class.title=Failed to Create Class intention.extract.if.condition.family=Extract If Condition intention.extract.if.condition.text=Extract if ({0}) intention.extract.map.step.family=Extract to separate mapping method intention.extract.map.step.text=Extract variable ''{0}'' to ''{1}'' operation intention.extract.method.text=Extract method intention.extract.set.from.comparison.chain.duplicates={0} has detected {1} code {1,choice,1#fragment|2#fragments} in this class that can be replaced using newly created Set. Would you like to replace {1,choice,1#it|2#them}? intention.extract.set.from.comparison.chain.family=Extract Set from comparison chain intention.family.add.javadoc=Add Javadoc intention.family.convert.0.path.to.1=Convert {0} path to {1} intention.family.copy.abstract.method.implementation=Copy abstract method implementation intention.family.create.a.class.in.package=Create a class in package intention.family.edit.method.contract=Edit method contract intention.family.edit.range=Edit range intention.family.expand.static.import=Expand static import intention.family.fix.bounded.wildcards=Fix bounded wildcards intention.family.make.external.annotations.explicit=Make External Annotations Explicit intention.family.make.inferred.annotations.explicit=Make Inferred Annotations Explicit intention.family.move.it=Move it intention.family.put.arguments.on.one.line=Put arguments on one line intention.family.put.arguments.on.separate.lines=Put arguments on separate lines intention.family.put.parameters.on.one.line=Put parameters on one line intention.family.put.parameters.on.separate.lines=Put parameters on separate lines intention.family.put.record.components.on.one.line=Put record components on one line intention.family.put.record.components.on.separate.lines=Put record components on separate lines intention.family.replace.optional.ispresent.condition.with.functional.style.expression=Replace Optional.isPresent() condition with functional style expression intention.family.sort.content=Sort content intention.family.swap.if.statements=Swap 'if' statements intention.family.unimplement.interface.class=Unimplement Interface/Class intention.family.variable.access.from.inner.class=Variable accessFromInnerClass intention.implement.abstract.class.default.text=Implement abstract class intention.implement.abstract.class.family=Implement abstract class or interface intention.implement.abstract.method.command.name=Implement method intention.implement.abstract.method.error.no.classes.message=There are no classes found where this method can be implemented intention.implement.abstract.method.error.no.classes.title=No Classes Found intention.implement.abstract.method.family=Implement abstract method intention.implement.abstract.method.searching.for.descendants.progress=Searching For Descendants... intention.implement.abstract.method.text=Implement method ''{0}'' intention.inline.map.family=Inline stream mapping method intention.inline.map.inline.text=Inline ''{0}'' body into the next ''{1}'' call intention.inline.map.merge.text=Merge ''{0}'' call and ''{1}'' call intention.introduce.variable.text=Introduce local variable intention.invert.if.condition=Invert 'if' condition intention.merge.filter.family=Merge filters intention.merge.filter.text=Merge filter chain intention.move.field.assignment.to.declaration=Move assignment to field declaration intention.move.initializer.to.constructor=Move initializer to constructor intention.move.initializer.to.set.up=Move initializer to setUp method intention.override.method.text=Override method ''{0}'' intention.replace.cast.with.var.family=Replace cast with variable intention.replace.cast.with.var.text=Replace ''{0}'' with ''{1}'' intention.replace.concatenation.with.formatted.output.family=Replace concatenation with formatted output intention.replace.concatenation.with.formatted.output.text=Replace '+' with 'java.text.MessageFormat.format()' intention.split.declaration.assignment.text=Split into declaration and assignment intention.split.declaration.family=Split declaration intention.split.filter.family=Split filter intention.split.filter.text=Split into filter chain intention.split.if.family=Split 'if' intention.split.if.text=Split into 2 'if' statements intention.split.switch.branch.with.several.case.values.copy.text=Copy 'switch' branch intention.split.switch.branch.with.several.case.values.family=Split switch branch with several case values into individual 'switch' branches intention.split.switch.branch.with.several.case.values.split.text=Split values of 'switch' branch intention.surround.resource.with.ARM.block=Surround with try-with-resources block intention.surround.with.ARM.block.template=try-with-resources intention.text.add.method.contract.to.0=Add method contract to ''{0}'' intention.text.add.range.to.0=Add range to ''{0}'' intention.text.annotate.externally=Annotate Externally intention.text.collapse.repeating.annotations=Collapse repeating annotations intention.text.convert.path.to.0=Convert path to {0} intention.text.create.a.class.in.0=Create a class in ''{0}'' intention.text.edit.method.contract.of.0=Edit method contract of ''{0}'' intention.text.edit.range.of.0=Edit range of ''{0}'' intention.text.fix.method.0.parameters.with.bounded.wildcards=Fix method ''{0}'' parameters with bounded wildcards intention.text.generate.missed.test.methods=Generate missed test methods intention.text.insert.0.annotation=Insert ''{0}'' intention.text.replace.implements.with.static.import=Replace implements with static import intention.text.replace.static.import.with.qualified.access.to.0=Replace static import with qualified access to {0} intention.text.unimplement.0=Unimplement {0} intention.text.implements.list.remove.others=Remove other ''{0}'' references intention.unroll.loop.family=Unroll loop intention.unwrap.else.branch=Unwrap 'else' branch intention.unwrap.else.branch.changes.semantics=Unwrap 'else' branch (changes semantics) intention.use.single.member.static.import.text=Use static import for ''{0}'' intention.wrap.with.unmodifiable=Wrap with unmodifiable collection or map intention.wrap.with.unmodifiable.list=Wrap with unmodifiable list intention.wrap.with.unmodifiable.map=Wrap with unmodifiable map intention.wrap.with.unmodifiable.set=Wrap with unmodifiable set interface.not.allowed=Interface is not allowed java.line.markers=Java line markers java.preview.features.accept.notification.link=Accept java.preview.features.alert.title=Experimental Feature Alert java.preview.features.legal.notice=You must accept the terms of legal notice of the beta Java specification to enable support for "{0}".

\ The implementation of an early-draft specification developed under the Java Community Process (JCP) is made available for testing and evaluation purposes only and is not compatible with any specification of the JCP.{1} java.preview.features.notification.title=Java preview features java.preview.features.warning=Newer IDE versions may discontinue support for preview features. When Java {0} is released, the support for {1} (Preview) language level might be dropped java.terms.exception=exception java.terms.instance.initializer=instance initializer java.terms.of.annotation.type={0} of annotation type {1} java.terms.of.anonymous.class={0} of anonymous class java.terms.of.class={0} of class {1} java.terms.of.enum={0} of enum {1} java.terms.of.interface={0} of interface {1} java.terms.static.initializer=static initializer java.terms.type.parameter=type parameter java.terms.variable.of.method={0} of {1} javadoc.candidates.not.found=No candidates found for method call {0}. javadoc.constructor.candidates=Candidates for new {0}() are:
{1} javadoc.deprecated=Deprecated javadoc.description.copied.from.class=Description copied from class: javadoc.description.copied.from.field=Description copied from field: javadoc.description.copied.from.interface=Description copied from interface: javadoc.generate.arguments=&Other command line arguments: javadoc.generate.exited=\n"javadoc" finished with exit code $EXIT_CODE$ javadoc.generate.heap.size=&Maximum heap size (Mb): javadoc.generate.include.jdk.library.sources.in.sourcepath.option=Include JDK and library sources in -sourcepath javadoc.generate.link.to.jdk.documentation.option=Link to JDK documentation (use -link option) javadoc.generate.locale=&Locale: javadoc.generate.no.classes.in.selected.packages.error=Selected scope contain no Java classes javadoc.generate.no.jdk=Cannot generate JavaDoc - no Java SDK is configured for the project. Please specify a Java SDK in Settings | Project Structure. javadoc.generate.no.javadoc.tool=Cannot generate JavaDoc - no javadoc tool found at {0} or {1}. Please specify a valid Java SDK in Settings | Project Structure. javadoc.generate.open.in.browser=Open &generated documentation in browser javadoc.generate.options.hierarchy=Generate hierarchy tree javadoc.generate.options.index=Generate index javadoc.generate.options.index.per.letter=Separate index per letter javadoc.generate.options.navigator=Generate navigation bar javadoc.generate.output.directory=Output &directory: javadoc.generate.output.directory.browse=Browse Output Directory javadoc.generate.sources.progress=Looking for sources to generate Javadoc javadoc.generate.tag.list.deprecated=deprecated list javadoc.generate.temp.file.error=Cannot create temporary file javadoc.generate.temp.file.does.not.exist=Temporary file doesn''t exist or cannot be opened javadoc.generate.title=Generate JavaDoc javadoc.method.in.class={0} in class {1} javadoc.method.in.interface={0} in interface {1} javadoc.method.overrides=Overrides: javadoc.method.specified.by=Specified by: javadoc.option.automatically.insert.closing.tag.javadoc=Automatically insert closing tag in JavaDoc javadoc.option.javadoc.title=JavaDoc javadoc.see.also=See Also: javadoc.settings.title=Javadoc javadoc.since=Since: javadoc.author=Author: javadoc.version=Version: javadoc.apiNote=API Note: javadoc.implNote=Implementation Note: javadoc.implSpec=Implementation Requirements: javadoc.type.parameters=Type parameters: jrt.node.short=[JRT] label.add.math.max.0.count.to.avoid.possible.semantics.change=Add Math.max(0, count) to avoid possible semantics change label.class.filter.editor.add.dialog.filter.pattern=Enter the filter pattern: label.contract=Contract: label.enter.fully.qualified.class.name=Enter fully qualified class name label.entry.points=Entry points: label.forbid.api.usages=Forbid API usages: label.from.inclusive=From (inclusive): label.implementation=Implementation: label.implements.method.of_class_or_interface.name=implements method of {0, choice, 0#interface|1#class} ''{1}''. label.implements.method.of_interfaces=implements methods of the following classes/interfaces: label.maximal.reported.method.visibility=Maximal reported method visibility: label.method=Method ''{0}'' label.minimal.reported.method.usage.count=Minimal reported method usage count: label.minimal.reported.method.visibility=Minimal reported method visibility: label.mutates=Mutates: label.name.prefix=Name prefix: label.name.suffix=Name suffix: label.naming.field=Field: label.naming.local.variable=Local variable: label.naming.parameter=Parameter: label.naming.static.field=Static field: label.naming.subclass=Subclass: label.naming.test.class=Test class: label.overrides.method.of_class_or_interface.name=overrides method of {0, choice, 0#interface|1#class} ''{1}''. label.show.import.popup.for=Show auto-import tooltip for: label.to.inclusive=To (inclusive): label.unused.declaration.reachable.from.tests.option=When entry points are in test sources, mark callees as: line.marker.recursive.call=Recursive call line.marker.type.external.annotations=External annotations line.marker.type.inferred.contract.annotations=Inferred contract annotations line.marker.type.inferred.nullability.annotations=Inferred nullability annotations listbox.import.package=Package listbox.import.static=Static listbox.import.with.subpackages=With Subpackages # suppress inspection "UnusedProperty" macro.array.variable=arrayVariable() macro.class.name=Class name macro.classpath.entry=Entry in the classpath the element belongs to macro.component.type.of.array=componentTypeOf(Array) macro.descendant.classes.enum=descendantClassesEnum(String) macro.expression.type=expressionType(Expression) macro.file.fully.qualified.package=File fully qualified package macro.file.package=File package macro.guess.element.type.of.container=guessElementType(Container) macro.iterable.component.type=iterableComponentType(ArrayOrIterable) # suppress inspection "UnusedProperty" macro.iterable.variable=iterableVariable() macro.javadoc.output.directory=JavaDoc output directory macro.project.classpath=Project's classpath macro.variable.of.type=variableOfType(Type) methods.to.implement.chooser.title=Select Methods to Implement methods.to.override.chooser.title=Select Methods to Override methods.to.override.implement.chooser.title=Select Methods to Override/Implement module.not.in.requirements=The module ''{0}'' does not have the module ''{1}'' in requirements module.package.not.exported=The module ''{0}'' does not export the package ''{1}'' to the module ''{2}'' module.package.not.open=The module ''{0}'' does not open the package ''{1}'' to the module ''{2}'' module.type.java.description=Java modules are used for developing JVM-based desktop and web applications, including applications that use Java EE and other enterprise development frameworks. module.type.java.name=Java Module navigate.to.duplicate.fix=Navigate to duplicate no.methods.overriding.0.are.found=No methods overriding {0, choice, 0#|1# ''''{1}''''|2#these classes} are found no.patterns=No class patterns configured node.call.hierarchy.unknown.jsp=unknown jsp node.hierarchy.java.lang.object=All classes are derived from java.lang.Object notification.navigation.to.overriding.classes=Navigation to overriding classes is not possible during index update notification.navigation.to.overriding.methods=Navigation to overriding methods is not possible during index update notification.text.full.thread.dump.was.successfully.copied.to.clipboard=Full thread dump was successfully copied to clipboard nullable.notnull.annotations.panel.title={0} Annotations nullable.notnull.annotations.runtime.instrumentation.tooltip=Add runtime assertions for notnull-annotated methods and parameters nullable.notnull.configuration.dialog.title=Nullable/NotNull Configuration nullable.stuff.inspection.navigate.null.argument.usages.fix.family.name=Navigate to 'null' argument usages nullable.stuff.inspection.navigate.null.argument.usages.view.name=''null'' argument usages for parameter {0} offline.inspections.jdk.not.found={0} not found offline.inspections.library.urls.were.not.resolved=Roots {0} of the library ''{1}'' from module ''{2}'' were not resolved offline.inspections.library.was.not.resolved=Please configure library ''{0}'' which is used in module ''{1}'' offline.inspections.no.source.roots=No source roots detected for module ''{0}'' options.java.attribute.descriptor.abstract.class=Classes and Interfaces//Abstract class options.java.attribute.descriptor.abstract.method=Methods//Abstract method options.java.attribute.descriptor.annotation.attribute.name=Annotations//Annotation attribute name options.java.attribute.descriptor.annotation.name=Annotations//Annotation name options.java.attribute.descriptor.anonymous.class=Classes and Interfaces//Anonymous class options.java.attribute.descriptor.class=Classes and Interfaces//Class options.java.attribute.descriptor.constructor.call=Methods//Constructor call options.java.attribute.descriptor.constructor.declaration=Methods//Constructor declaration options.java.attribute.descriptor.enum=Classes and Interfaces//Enum options.java.attribute.descriptor.implicit.anonymous.parameter=Parameters//Implicit anonymous class parameter options.java.attribute.descriptor.inherited.method=Methods//Inherited method options.java.attribute.descriptor.instance.field=Class Fields//Instance field options.java.attribute.descriptor.instance.final.field=Class Fields//Instance final field options.java.attribute.descriptor.interface=Classes and Interfaces//Interface options.java.attribute.descriptor.javadoc.comment=Comments//JavaDoc//Text options.java.attribute.descriptor.javadoc.markup=Comments//JavaDoc//Markup options.java.attribute.descriptor.javadoc.tag=Comments//JavaDoc//Tag options.java.attribute.descriptor.javadoc.tag.value=Comments//JavaDoc//Tag value options.java.attribute.descriptor.lambda.parameter=Parameters//Lambda parameter options.java.attribute.descriptor.method.call=Methods//Method call options.java.attribute.descriptor.method.declaration=Methods//Method declaration options.java.attribute.descriptor.method.imported.call=Methods//Static imported method call options.java.attribute.descriptor.reassigned.local.variable=Variables//Reassigned local variable options.java.attribute.descriptor.reassigned.parameter=Parameters//Reassigned parameter options.java.attribute.descriptor.static.field=Class Fields//Static field options.java.attribute.descriptor.static.final.field=Class Fields//Constant (static final field) options.java.attribute.descriptor.static.final.imported.field=Class Fields//Constant (static final imported field) options.java.attribute.descriptor.static.imported.field=Class Fields//Static imported field options.java.attribute.descriptor.static.method=Methods//Static method options.java.attribute.descriptor.type.parameter=Parameters//Type parameter options.java.display.name=Java override.implement.broken.file.template.message=Please Correct "Overridden/Implemented Method Body" Template override.implement.broken.file.template.title=File Template Error package.dependencies.production.node.text=Production Classes package.dependencies.test.node.text=Test Classes packaging.jlink.artifact.name=JLink packaging.jlink.artifact.title=Run-time image packaging.jlink.compression.level=Compression level packaging.jlink.verbose.tracing=Enable verbose tracing paste.class.command.name=Paste class ''{0}'' please.report.a.bug=Please report a bug popup.title.choose.framework=Choose Framework popup.title.choose.test=Choose Test popup.title.select.a.jar.file=Select a JAR File popup.title.select.qualified.name=Select Qualified Name postfix.template.language.level.title=Minimum language level: press.0.to.see.inheritors.of.1=Press {0} to see inheritors of {1} press.0.to.see.non.imported.classes=Press {0} to see non-imported classes pressing.0.twice.without.a.class.qualifier=Pressing {0} twice without a class qualifier would show all accessible static methods project.problems.hint.text={0} related {0, choice, 0#problem|2#problems} project.problems.window.title=Problems Related to {0} project.problems.fix.text=Show related problems project.problems.fix.description=Found problems related to ''{0}'' project.problems.title=Related problems project.problems.settings=Settings... progress.creating.class=Creating class {0} progress.title.check.applicability=Check applicability... progress.title.download.library.descriptor=Download Library Descriptor progress.title.find.references.in.implement.extends.lists=Find References in Implement/Extends Lists... progress.title.finding.cause=Finding cause progress.title.looking.for.jdk.locations=Looking for JDK locations... progress.title.looking.for.libraries=Looking for Libraries progress.title.optimize.imports=Optimize Imports... progress.title.preprocess.usages=Preprocess Usages progress.title.search.for.overriding.methods=Search for overriding methods... progress.title.searching.for.sub.classes=Searching for Sub-Classes prompt.choose.base.class.of.the.hierarchy=Choose Base Class of the Hierarchy to Search In prompt.create.non.existing.package=Package {0} does not exist.\nDo you want to create it? prompt.delete.class={0,choice,1#class|2#classes} prompt.delete.field={0,choice,1#field|2#fields} prompt.delete.interface={0,choice,1#interface|2#interfaces} prompt.delete.method={0,choice,1#method|2#methods} prompt.delete.package={0,choice,1#package|2#packages} prompt.delete.type.parameter={0,choice,1#type parameter|2#type parameters} #{1} presents an action verb with preposition: "to refactor" is the default value, RefactorinBundle:to.refactor prompt.do.you.want.to.action_verb.the.method.from_class=Do you want {1} the base {0,choice,1#method|2#methods} instead? psi.search.overriding.progress=Searching for Overriding Methods... quickfix.add.variable.family.name=Initialize variable quickfix.add.variable.text=Initialize variable ''{0}'' quickfix.family.avoid.mutation.using.stream.api=Avoid mutation using Stream API quickfix.family.change.javadoc.to=Change to ... quickfix.family.find.cause=Find cause quickfix.family.remove.javadoc.tag=Remove tag quickfix.family.remove.redundant.parameter=Remove redundant parameter quickfix.family.remove.redundant.parameter.types=Remove redundant parameter types quickfix.family.replace.cast.type=Replace cast type quickfix.family.replace.inefficient.stream.count=Replace inefficient Stream.count() quickfix.family.replace.optional.chain.with.if.statements=Replace Optional chain with if statements quickfix.family.replace.stream.api.chain.with.loop=Replace Stream API chain with loop quickfix.family.replace.with.java.stream.api.pipeline=Replace with Java Stream API pipeline quickfix.family.replace.with.magic.constant=Replace with magic constant quickfix.family.replace.with.method.reference=Replace with method reference quickfix.family.replace.with.optional.of.nullable.chain=Replace with Optional.ofNullable() chain quickfix.family.replace.with.stream.api.equivalent=Replace with Stream API equivalent quickfix.family.simplify.foreach.lambda=Simplify forEach lambda quickfix.family.simplify.stream.call.chain=Simplify stream call chain quickfix.family.use.flatmap=Use 'flatMap' quickfix.family.wrap.with.mutable.collection=Wrap with mutable collection quickfix.name.find.jar.on.web=Find JAR on web quickfix.text.0.may.not.work.before.jdk.11.0.2={0} (may not work before JDK 11.0.2) quickfix.text.avoid.mutation.using.stream.api.0.operation=Avoid mutation using Stream API ''{0}'' operation quickfix.text.remove.javadoc.0=Remove ''@{0}'' tag quickfix.text.remove.javadoc.0.1=Remove @{0} {1} quickfix.text.remove.not.null.annotation=Remove not-null annotation quickfix.text.replace.0.stream.with.1.2=Replace {0}.stream() with {1}.{2}() quickfix.text.replace.collect.0.with.1.2=Replace ''collect({0}())'' with ''{1}''{2} quickfix.text.replace.filter.0.is.present.with.any.match=Replace ''filter().{0}().isPresent()'' with ''anyMatch()'' quickfix.text.replace.stream.0.with.1.2=Replace ''stream().{0}()'' with ''{1}()''{2} quickfix.text.suffix.may.change.semantics=\ (may change semantics) quickfix.text.wrap.0.with.1=Wrap ''{0}'' with ''{1}'' quickfix.text.replace.url.with.html=Replace URL with HTML link radio.button.higher.than=Higher than: radio.button.respecting.to.project.language.level.settings=Respecting to project language level settings radio.button.subclass.of.0=Subclass of ''{0}'' radio.button.unused.declaration.unused.option=unused radio.button.unused.declaration.used.option=used radio.button.with.provider.method=With 'provider()' method radio.use.fully.qualified.class.names.in.javadoc=Use fully qualified class names in JavaDoc: radio.use.fully.qualified.class.names.in.javadoc.always=Always radio.use.fully.qualified.class.names.in.javadoc.if.not.imported=If not already imported radio.use.fully.qualified.class.names.in.javadoc.never=Never, use short name and add import scope.hierarchy=Hierarchy of {0} sdk.cannot.create=Cannot Create SDK sdk.java.no.classes=Cannot find JDK classes in ''{0}'' section.title.inspection.suspicious.names.ignore.methods=Ignore methods: set.language.level=Set language level set.language.level.to.0=Set language level to {0} settings.completion.ml.java.display.name=Java settings.inlay.java.annotations=Annotations settings.inlay.java.builder.like.methods=Builder-like methods settings.inlay.java.complex.expressions.binary.functional.array.access.and.other=Complex expressions: binary, functional, array access and other settings.inlay.java.enum.constants=Enum constants settings.inlay.java.external.annotations=External annotations settings.inlay.java.inferred.annotations=Inferred annotations settings.inlay.java.inheritors=Inheritors settings.inlay.java.insert.annotation=Insert annotation settings.inlay.java.method.chains=Method chains settings.inlay.java.implicit.types=Implicit types settings.inlay.java.methods.with.same.named.numbered.parameters=Methods with same-named numbered parameters settings.inlay.java.minimal.unique.type.count.to.show.hints=Minimal unique type count to show hints settings.inlay.java.new.expressions='New' expressions settings.inlay.java.non.literals.in.case.of.multiple.parameters.with.the.same.type=Non-literals in case of multiple parameters with the same type settings.inlay.java.parameters.with.names.that.are.contained.in.the.method.name=Parameters with names that are contained in the method name settings.inlay.java.show.hints.for=Show hints for: settings.inlay.java.show.parameter.hints.for=Show parameter hints for: settings.inlay.java.show.parameter.hints.when.expression.type.is.clear.description=Array initializer, switch, conditional, reference, instance of, assignment, call, qualified, type cast, class object access expressions. settings.inlay.java.turn.off.external.annotations=Turn off external annotations settings.inlay.java.turn.off.inferred.annotations=Turn off inferred annotations settings.inlay.java.usages=Usages show.import.popup.for.classes=&Classes show.import.popup.for.static.methods.and.fields=&Static methods and fields exclude.import.wildcard.comment=Use the * wildcard to exclude all members of a specified class or package special.annotations.annotations.list=Additional special annotations: special.annotations.list.add.annotation.class=Add Annotation Class special.annotations.list.annotation.class=Annotation Class special.annotations.list.annotation.pattern.message=Add annotations pattern special.annotations.list.annotation.pattern=Add Annotations Pattern special.annotations.list.remove.pattern=Remove spi.extension.error.message=Registered extension should implement {0} filetype.spi.description=Service Provider Interface spi.no.provider.error.message=No service provider "{0}" found status.bar.overridden.methods.highlighted.message={0} overridden {0, choice, 1#method|2#methods} found (press {1} again to remove the highlighting, Escape to remove all highlighting) surround.with.dowhile.template=do / while surround.with.for.template=for surround.with.ifelse.expression.template=if (expr) {...} else {...} surround.with.not.instanceof.template=!(expr instanceof Type) surround.with.runnable.template=Runnable surround.with.synchronized.template=synchronized surround.with.try.catch.finally.template=try / catch / finally surround.with.try.catch.incorrect.template.message=Invalid File Template for Catch Body! surround.with.try.catch.incorrect.template.title=Surround With Try / Catch surround.with.try.catch.template=try / catch tab.title.entry.points=Entry points tab.title.members.to.report=Members to report table.cell.constructors=constructors title.cannot.create.class=Cannot Create Class title.import.layout=Import Layout title.javadoc=JavaDoc title.naming=Naming title.naming.final.modifier=Final Modifier title.naming.functional.expressions=Lambda Body title.package.not.found=Package Not Found title.packages=Packages title.packages.to.use.import.with=Packages to Use Import with '*' to.import.a.method.statically.press.0=To import a method statically, press {0} unscramble.detect.analyze.threaddump.from.clipboard.item=Automatically detect and analyze thread dumps copied to the clipboard outside of IntelliJ IDEA unscramble.log.path.label=&Log file: unscramble.no.unscrambler.item= unscramble.normalize.button=&Normalize unscramble.stacktrace.caption=Put a stack trace or a complete thread dump here: unscramble.unscrambled.deadlock.tab= unscramble.unscrambled.stacktrace.tab= unscramble.unscrambled.threaddump.tab= unscramble.unscrambler.combobox=Un&scrambler: unscramble.use.unscrambler.checkbox=&Unscramble stack trace unwrap.anonymous=Unwrap 'anonymous...' unwrap.array.initializer=Unwrap array initializer unwrap.conditional=Unwrap 'f ? a : b' unwrap.lambda=Unwrap 'lambda...' unwrap.synchronized=Unwrap 'synchronized...' unwrap.switch.expression=Unwrap 'switch' expression unwrap.switch.statement=Unwrap 'switch' statement usage.target.exception=Exception usage.target.package.in.directory={0} (in {1}) use.external.annotations=Use &external annotations wrapping.annotation.parameters=Annotation parameters wrapping.record.components=Record components wrapping.text.blocks=Text blocks wrong.package.statement=Wrong package statement title.code.vision=Code vision highlight.throws.popup.throwing.places=Places throwing {0} highlight.throws.popup.usages=Usages of {0} psi.error.incorrect.class.template.message=Cannot create {0} - incorrect {1} template. presentable.text.anonymous.class=Anonymous class presentable.text.code.from.context=Code from {0} presentable.text.code.display=Code presentable.text.invalid.element.name=INVALID inspection.simplify.for.each.replace=Replace with {0} inspection.simplify.for.each.extract.intermediate.operations=Extract intermediate operations inspection.message.can.be.replaced.with.files.writestring=Can be replaced with 'Files.writeString()' inspection.notnull.field.not.initialized.message={0} fields must be initialized highlight.throws.class.name=Highlight Throws {0} class.patterns.panel.add.class=Add Class multiple.usages.of.static.import.found=Multiple Usages of the Static Import Found external.annotations.roots=Annotation Roots inspection.stream.api.migration.can.be.replaced.with.call=Can be replaced with ''{0}'' call highlight.suppressed.warnings.choose.inspections=Choose Inspections to Highlight Suppressed Problems from inspection.magic.constants.should.be.one.of.values=Should be one of: {0}{1,choice,0#|1# or their combination} live.template.context.consumer.function=Consumer function live.template.context.statement=Statement live.template.context.expression=Expression live.template.context.declaration=Declaration inspection.unused.display.name=Unused declaration inspection.empty.method.display.name=Empty method inspection.unused.assignment.display.name=Unused assignment inspection.unchecked.warning.display.name=Unchecked warning inspection.convert.2.streamapi.display.name=Loop can be collapsed with Stream API inspection.optional.to.if.display.name='Optional' can be replaced with sequence of 'if' statements inspection.stream.to.loop.display.name=Stream API call chain can be replaced with loop inspection.anonymous.2.method.ref.display.name=Anonymous type can be replaced with method reference inspection.convert.2.method.ref.display.name=Lambda can be replaced with method reference inspection.lambda.can.be.method.call.display.name=Lambda can be replaced with method call inspection.functional.expression.can.be.folded.display.name=Functional expression can be folded inspection.trivial.functional.expression.usage.display.name=Trivial usage of functional expression inspection.magic.constant.display.name=Magic Constant inspection.static.pseudo.functional.style.method.display.name=Pseudo functional expression using static class inspection.overwritten.key.display.name=Overwritten Map key or Set element inspection.collection.add.all.can.be.replaced.with.constructor.display.name=Redundant 'Collection.addAll()' call inspection.manual.min.max.calculation.display.name=Manual min/max calculation inspection.explicit.array.filling.display.name=Explicit array filling inspection.java.8.collection.remove.if.display.name=Loop can be replaced with 'Collection.removeIf()' inspection.java.8.map.api.display.name=Simplify 'Map' operations inspection.string.repeat.can.be.used.display.name=String.repeat() can be used inspection.read.write.string.can.be.used.display.name='Files.readString()' or 'Files.writeString()' can be used inspection.java.9.collection.factory.display.name=Immutable collection creation can be replaced with collection factory call inspection.explicit.argument.can.be.lambda.display.name=Explicit argument can be lambda inspection.excessive.lambda.usage.display.name=Excessive lambda usage inspection.redundant.stream.optional.call.display.name=Redundant step in Stream or Optional call chain inspection.obvious.null.check.display.name=Null-check method is called with obviously non-null argument inspection.simplify.stream.api.call.chains.display.name=Stream API call chain can be simplified inspection.simplify.optional.call.chains.display.name=Optional call chain can be simplified inspection.simplify.collector.display.name=Simplifiable collector inspection.use.bulk.operation.display.name=Bulk operation can be used instead of iteration inspection.comparator.combinators.display.name='Comparator' combinator can be used inspection.replace.inefficient.stream.count.display.name=Inefficient Stream API call chains ending with count() inspection.redundant.lambda.parameter.type.display.name=Redundant lambda parameter types inspection.wrapper.type.may.be.primitive.display.name=Wrapper type may be primitive inspection.optional.get.without.is.present.display.name=Optional.get() is called without isPresent() check inspection.optional.is.present.display.name=Non functional 'Optional.isPresent()' style usage inspection.conditional.can.be.optional.display.name=Conditional can be replaced with Optional inspection.optional.assigned.to.null.display.name=Null value for Optional type inspection.excessive.range.check.display.name=Excessive range check inspection.condition.covered.by.further.condition.display.name=Condition is covered by further condition inspection.move.field.assignment.to.initializer.display.name=Field assignment can be moved to initializer inspection.test.failed.line.display.name=Failed line in test inspection.frequently.used.inheritor.inspection.display.name=Class may extend a commonly used base class inspection.slow.abstract.set.remove.all.description=Call to 'set.removeAll(list)' may work slowly inspection.slow.abstract.set.remove.all.fix.family.name=Use 'Set.remove' instead of 'Set.removeAll' slice.filter.parse.error.null.filter.not.applicable.for.primitive.type=''null'' filter is not applicable for primitive type {0} slice.filter.parse.error.not.null.filter.not.applicable.for.primitive.type=''!null'' filter is not applicable for primitive type {0} slice.filter.parse.error.enum.constant.not.found=Enum constant not found: {0} slice.filter.parse.error.incorrect.expression=Incorrect expression: {0} slice.filter.parse.error.incorrect.constant.type=Incorrect constant type (required: {0}) slice.filter.parse.error.expression.must.evaluate.to.constant=Expression must evaluate to a constant: {0} slice.filter.parse.error.incorrect.constant.expected.number=Incorrect constant (expected number): {0} action.dfa.from.stacktrace.text=Find why ''{0}'' could be {1} slice.usage.message.assertion.violated=(assertion violated!) slice.usage.message.in.file.stopped.here=(in {0} file - stopped here) slice.usage.message.tracking.container.contents=(Tracking container ''{0}{1}'' contents) slice.usage.message.location=in {0} intention.name.move.into.if.branches=Move up into 'if' statement branches intention.name.collapse.into.loop=Collapse into loop intention.family.name.make.sealed=Seal class intention.error.make.sealed.class.is.used.in.functional.expression=Class is used in functional expression intention.make.sealed.class.hint.title=Make Sealed intention.error.make.sealed.class.has.anonymous.or.local.inheritors=Some of the inheritors are anonymous or local intention.error.make.sealed.class.different.packages=Module is unnamed and some of the inheritors are in the different package intention.error.make.sealed.class.inheritors.not.in.java.file=Some of the inheritors are not in java files intention.error.make.sealed.class.different.modules=Some of the inheritors are in different modules intention.error.make.sealed.class.interface.has.no.inheritors=Interface has no inheritors intention.make.sealed.class.task.title.set.inheritors.modifiers=Setting inheritors modifiers intention.family.name.move.member.into.class=Move member into class inspection.fill.permits.list.no.missing.inheritors=Sealed class has no missing inheritors inspection.fill.permits.list.display.name=Same file subclasses are missing from permits clause of a sealed class inspection.fill.permits.list.fix.name=Add missing subclasses to the permits clause update.external.annotations=Update External Annotations intention.create.switch.statement=Create switch statement sort.threads.by.type=Sort Threads by Type sort.threads.by.name=Sort Threads by Name inspection.message.record.can.be.converted.to.class=Record can be converted to class intention.family.name.convert.record.to.class=Convert record to class class.can.be.record.display.name=Class can be a record class.can.be.record.quick.fix=Convert to a record class.can.be.record.suggest.renaming.accessors=Suggest renaming get/is-accessors class.can.be.record.conversion.weakens.member=When conversion weakens the member access level: class.can.be.record.conversion.strategy.do.not.convert=Do not suggest conversion to record class.can.be.record.conversion.strategy.show.members=Show affected members in conflicts view class.can.be.record.conversion.strategy.convert.silently=Convert silently extracted.class.should.have.unique.name=Extracted class should have unique name. Name ''{0}'' is already in use by one of the inner classes invalid.extracted.class.name=''{0}'' is invalid extracted class name caller.chooser.referenced.code.title=Referenced Code dialog.title.choose.annotation=Choose {0} Annotation unchecked.warning.inspection.settings.ignore.unchecked.assignment=Ignore unchecked assignment unchecked.warning.inspection.settings.ignore.unchecked.generics.array.creation.for.vararg.parameter=Ignore unchecked generics array creation for vararg parameter unchecked.warning.inspection.settings.ignore.unchecked.call.as.member.of.raw.type=Ignore unchecked call as member of raw type unchecked.warning.inspection.settings.ignore.unchecked.cast=Ignore unchecked cast unchecked.warning.inspection.settings.ignore.unchecked.overriding=Ignore unchecked overriding unchecked.warning.inspection.reason.expr.has.raw.type.so.result.erased=. Reason: ''{0}'' has raw type, so result of {1} is erased unchecked.warning.inspection.message.unchecked.generics.array.creation.for.varargs.parameter=Unchecked generics array creation for varargs parameter type.migration.dialog.message.invalid.type=''{0}'' is an invalid type type.migration.dialog.message.void.not.applicable='void' is not applicable stream.to.loop.inspection.message.replace.stream.api.chain.with.loop=Replace Stream API chain with loop stream.to.loop.inspection.message.replace.foreach.call.with.loop=Replace 'forEach' call with loop todo.index.not.available=N/A simplify.stream.inspection.message.can.be.replaced=''{0}'' can be replaced with ''{1}'' simplify.stream.inspection.message.can.be.replaced.may.change.semantics=''{0}'' can be replaced with ''{1}'' (may change semantics) inspection.message.filter.is.present.chain.can.be.replaced.with.anymatch=The ''filter().{0}().isPresent()'' chain can be replaced with ''anyMatch()'' simplify.stream.match.negation.fix.name=Replace {0} with {1}(...) simplify.stream.collection.creation.fix.name=Replace with ''{0}'' constructor simplify.stream.simple.stream.of.fix.name.use.stream.element.explicitly=Use Stream element explicitly simplify.stream.simple.stream.of.message=Unnecessary single-element Stream simplify.stream.replace.with.element.iteration.fix.message=Can be replaced with element iteration simplify.stream.remove.boolean.identity.fix.name=Merge with previous 'map' call simplify.stream.remove.boolean.identity.fix.message=Can be merged with previous 'map' call simplify.stream.replace.support.with.collection.fix.name=Replace with ''{0}.{1}'' call simplify.stream.replace.support.with.collection.fix.message=Can be replaced with ''{0}.{1}'' call simplify.stream.swap.filter.and.map.fix.name=Swap 'filter()' and 'map()' simplify.stream.swap.filter.and.map.fix.message='filter()' and 'map()' can be swapped simplify.stream.inspection.iterate.take.while.fix.name=Replace with three-arg 'iterate()' simplify.stream.inspection.iterate.take.while.fix.message=Can be replaced with three-arg 'iterate()' side.effects.pattern.message=\n\nThere are possible side effects found in {0}
\nYou can:\n
\n-\\ Remove variable usages along with all expressions involved, or
\n-\\ Transform expressions assigned to variable into the statements on their own.
\n

\n That is,
\n \n \n \n \n
{1};
\n becomes:
\n \n \n \n \n
{2};
\n
\n\n side.effects.non.fixable.message= There are possible side effects found in expression ''{0}''
You can Remove class reference along with whole expressions involved side.effects.expression.presentation=expression ''{0}'' change.signature.from.usage.short.name= Change signature of {0}({1}) default.param.value.warning={0, choice, 0#Constructor|1#Method} with the chosen signature already exists qualify.static.constant.access=Qualify static constant access qualify.static.access.command.name=Qualify Static Access qualify.static.call.fix.text=Qualify static call side.effects.expressions.assigned.to.the.variable=expressions assigned to the variable ''{0}'' pull.members.up.fix.name=Pull members up extract.superclass.command.name=Extract superclass extract.interface.command.name=Extract interface choose.super.class.popup.title=Choose super class intention.name.pull.method.up.and.make.it.abstract.conditionally=Pull method ''{0}'' to ''{1}''{2, choice, 0# and make it abstract|1#} intention.name.extract.method.to.new.interface=Extract method ''{0}'' to new interface intention.name.pull.method.up.make.it.abstract=Pull method ''{0}'' up and make it abstract intention.name.pull.method.up=Pull method ''{0}'' up intention.name.copy.to.final.temp.variable=Copy ''{0}'' to {1, choice, 0#|1#effectively }final temp variable intention.name.make.variable.final=Make {1, choice, 0#''''{0}''''|1#variables} final intention.name.transform.variables.into.final.one.element.array=Transform {1, choice, 0#''''{0}''''|1#variables} into final one element array type.information.value=Value type.information.not.equal.to=Not equal to type.information.range=Range type.information.nullability=Nullability type.information.constraints=Constraints type.information.mutability=Mutability type.information.locality=Locality type.information.local.object=local object type.information.type=Type simplify.optional.chain.inspection.remove.redundant.steps.from.optional.chain=Remove redundant steps from optional chain simplify.optional.chain.inspection.to.x=Simplify optional chain to ''{0}'' simplify.optional.chain.inspection.map.or.else.description=Optional chain can be simplified simplify.optional.chain.inspection.optional.rewrapping.name=Unwrap simplify.optional.chain.inspection.optional.rewrapping.description=Unnecessary Optional rewrapping simplify.optional.chain.inspection.or.else.return.fix.name=Replace null check with {0}({1}) simplify.optional.chain.inspection.or.else.return.fix.description=Null check can be eliminated simplify.optional.chain.inspection.or.else.non.null.fix.name=Replace null check with ifPresent() simplify.optional.chain.inspection.or.else.non.null.fix.description=Null check can be eliminated with 'ifPresent' generate.test.support.method.error.no.template.found.for.framework=No template found for {0}:{1} generate.test.support.method.error.method.already.exists=Method {0} already exists generate.test.support.method.error.cannot.generate.method=Cannot generate method: {0} base.package.project.wizard.error.x.not.valid.package={0} is not a valid package name class.patterns.separator.mark.code.as.entry.point.if.qualified.name.matches=Mark Code as Entry Point if Qualified Name Matches class.patterns.error.method.pattern.0.must.be.a.valid.java.identifier=Method pattern ''{0}'' must be a valid java identifier, only ''*'' are accepted as placeholders class.patterns.error.class.pattern.0.must.be.a.valid.java.qualifier=Pattern must be a valid java qualified name, only '*' are accepted as placeholders code.style.generation.settings.error.not.valid.identifier.part.in.prefix=Not a valid java identifier part in prefix ''{0}'' code.style.generation.settings.error.not.valid.identifier.part.in.suffix=Not a valid java identifier part in suffix ''{0}'' hide.out.of.cyclic.packages.action.text=Hide Packages Without Cyclic Dependencies hide.out.of.cyclic.packages.action.description=Hide packages without cyclic dependencies generate.missed.tests.action.error.no.tests.found=No tests found. generate.missed.tests.action.failed.to.detect.framework=Failed to detect test framework for {0} pull.up.accessible.conflict={0} won''t be accessible pull.up.accessible.conflict.1={0} won''t be accessible from {1} pull.up.concrete.inherit.abstract.method.conflict=Concrete ''{0}'' would inherit a new abstract method pull.up.members.usage.view.description.code.references.node=Class to pull up members to "{0}" pull.up.members.usage.view.description.processed.elements.node=Pull up members from class {0} refactoring.method.reference.to.lambda.conflict=Method reference will be converted to lambda introduce.variable.change.semantics.warning=Extracting selected expression would change the semantic of the whole expression. introduce.variable.change.type.adv=Press {0} to change type introduce.variable.reassign.adv=Press {0} to reassign existing variable introduce.functional.variable.accessibility.conflict=Variable {0} is not effectively final and won''t be accessible inside functional expression introduce.functional.variable.interface.chooser.title=Choose Applicable Functional Interface: {0} -> {1} introduce.functional.variable.nothing.found.message=No applicable functional interfaces found introduce.parameter.object.no.accessor.conflict.message={0, choice, 0#Getter|1#Setter} for field ''{1}'' is required push.down.anonymous.conflict=Unable to push implements to anonymous class push.down.static.nonstatic.conflict=Static {0} can''t be pushed to non-static {1} push.down.missed.implementation.conflict=Non abstract {0} will miss implementation of {1} push.down.super.method.call.changed.conflict=Super method call will resolve to another method move.classes.invalid.destination.package.name.message=''{0}'' is invalid destination package name move.classes.destination.class.not.found.message=Destination class not found move.class.import.from.default.package.conflict={0} won''t be accessible from the default package destination.combo.test.root.not.expected.conflict=Test root is selected while the source root is expected destination.combo.source.root.not.expected.conflict=Source root is selected while the test root is expected leave.in.same.source.root.item=Leave in same source root move.inner.select.target.package.title=Select Target Package move.member.enum.conflict=Enum type won't be applicable in the current context move.member.final.initializer.conflict=final variable initializer won't be available after move. rename.package.invalid.name.error=Not a valid package name rename.package.ignored.name.warning=Trying to create a package with ignored name, result will not be visible rename.package.class.already.exist.conflict=Class with qualified name ''{0}'' already exist rename.package.command.name=Rename package class.filter.editor.table.model.column.name.pattern=Pattern class.filter.editor.table.model.column.name.isActive=Is Active create.class.mapping.dialog.title=Choose {0} Class import.layout.panel.up.button=Up import.layout.panel.down.button=Down import.layout.panel.blank.line.entry= import.layout.panel.all.other.imports=all other imports edit.contract.dialog.hint=Please specify the contract text

Example: _, null -> false
See intention action description for more details edit.range.dialog.message=Please specify the value range

Leave ''from'' or ''to'' empty if it''s unrestricted edit.range.error.invalid.value=Invalid value edit.range.value.should.be.less.than=Should not be less than {0} edit.range.value.should.be.bigger.than=Should not be bigger than {0} edit.range.should.not.be.less.than.from=Should not be less than 'from' generate.constructor.already.exists=Constructor already exists generate.equals.no.fields.for.generation=No fields to include in equals/hashCode have been found generate.getter.and.setter.error.setters.for.read.only.not.generated=Setters for read-only fields were not generated generate.getter.and.setter.error.no.fields=No fields have been found to generate getters/setters for generate.getter.and.setter.error.no.fields.without.getters.and.setters=No fields without getter/setter were found generate.getter.error.no.fields=No fields have been found to generate getters for generate.getter.error.no.fields.without.getters=No fields without getter were found generate.getter.setter.header.visibility.hint.=Visibility is applied according to File | Settings | Editor | Code Style | Java | Code Generation generate.members.nothing.to.insert=Nothing found to insert generate.setters.no.fields=No fields have been found to generate setters for generate.setters.no.fields.without.setters=No fields without setter were found implement.abstract.method.potential.implementations.with.weaker.access=Potential implementations with weaker access privileges are found: {0} implement.method.no.methods.to.implement=No methods to implement have been found action.sort.by.percent.classes.which.overrides.method.text=Sort by Percent of Classes which Overrides a Method action.sort.by.percent.classes.which.overrides.method.description=Sort by Percent of Classes which Overrides a Method override.methods.error.no.methods=No methods to override have been found base.package.parameter.wizard.label=Base &package: type.migration.multi.root.toolwindow.title=Migrate Type of {0} type.migration.single.root.toolwindow.title=Migrate Type of {0} from ''{1}'' to ''{2}'' type.migration.processed.elements.header=Root for type migration type.migration.cannon.convert.tooltip=Cannot convert type of expression {0}{3, choice, 0#|1# from '<'b'>'{1}'<'/b'>' to '<'b'>'{2}'<'/b'>'}
type.migration.replaced.notification=Replaced with {0} type.migration.cannot.convert.tooltip=Cannot convert type of the expression from {0} to {1} type.migration.getter.rename.suggestion.text=Do migrate getter name from ''{0}'' to ''{1}'' since return type is migrated to ''{2}''? type.migration.getter.rename.suggestion.never.migrate.method.names=Never Migrate Method Names type.migration.getter.rename.suggestion.always.migrate.method.names=Always Migrate Method Names hint.text.press.to.go.through.inlined.occurrences=Press {0} to go through {1} inlined occurrences hint.text.occurrences.were.inlined={0} occurrences were inlined action.expand.static.import.text=Expand Static Import class.cannot.be.inlined.because.a.call.to.its.constructor.is.unresolved=Class cannot be inlined because a call to its constructor is unresolved class.cannot.be.inlined.because.it.is.used.as.a.this.qualifier=Class cannot be inlined because it is used as a 'this' qualifier class.cannot.be.inlined.because.it.is.used.in.a.throws.clause=Class cannot be inlined because it is used in a 'throws' clause class.cannot.be.inlined.because.it.is.used.in.a.catch.clause=Class cannot be inlined because it is used in a 'catch' clause class.cannot.be.inlined.because.it.has.usages.of.its.class.literal=Class cannot be inlined because it has usages of its class literal class.cannot.be.inlined.because.it.has.static.initializers=Class cannot be inlined because it has static initializers class.cannot.be.inlined.because.it.has.usages.of.fields.not.inherited.from.its.superclass=Class cannot be inlined because it has usages of fields not inherited from its superclass class.cannot.be.inlined.because.it.has.static.fields.with.non.constant.initializers=Class cannot be inlined because it has static fields with non-constant initializers class.cannot.be.inlined.because.it.has.static.non.final.fields=Class cannot be inlined because it has static non-final fields class.cannot.be.inlined.because.it.has.usages.of.its.inner.classes=Class cannot be inlined because it has usages of its inner classes class.cannot.be.inlined.because.it.has.static.inner.classes=Class cannot be inlined because it has static inner classes class.cannot.be.inlined.because.it.has.static.methods=Class cannot be inlined because it has static methods class.cannot.be.inlined.because.there.are.usages.of.its.methods.not.inherited.from.its.superclass.or.interface=Class cannot be inlined because there are usages of its methods not inherited from its superclass or interface class.cannot.be.inlined.because.its.constructor.contains.return.statements=Class cannot be inlined because its constructor contains 'return' statements class.cannot.be.inlined.because.an.interface.implemented.by.it.cannot.be.resolved=Class cannot be inlined because an interface implemented by it cannot be resolved class.cannot.be.inlined.because.its.superclass.cannot.be.resolved=Class cannot be inlined because its superclass cannot be resolved library.classes.cannot.be.inlined=Library classes cannot be inlined enums.cannot.be.inlined=Enums cannot be inlined interfaces.cannot.be.inlined=Interfaces cannot be inlined annotation.types.cannot.be.inlined=Annotation types cannot be inlined type.parameters.cannot.be.inlined=Type parameters cannot be inlined postfix.template.editor.choose.class.title=Choose Class null.check.surrounder.description=if (expr != null) {...} push.method.down.command.name=Push method down... replace.implements.with.static.import.field.usages.progress=Find Constant Field Usages... show.siblings.choose.super.class.title=Choose super class or interface show.siblings.find.usages.method.title=Super methods show.siblings.find.usages.class.title=Super classes/interfaces switch.stmt.template.description=switch (expr) {...} wrap.return.value.created.class.not.accessible.conflict=Created class won't be accessible in the call place wrap.return.value.existing.class.does.not.have.getter.conflict=Existing class does not have getter for selected field wrap.return.value.existing.class.does.not.have.appropriate.constructor.conflict=Existing class does not have appropriate constructor wrap.return.value.anonymous.class.presentation=Anonymous {0} empty.title=Empty separator.annotations.to.copy=Annotations to Copy action.go.to.implementation.text=Go to implementation(s) action.go.to.subclass.text=Go to subclass(es) action.go.to.overriding.methods.text=Go to overriding methods action.go.to.super.method.text=Go to super method tooltip.recursive.call=Recursive call label.compact.constructor=Compact constructor label.canonical.constructor=Canonical constructor edit.contract.dialog.checkbox.pure.method=Method is pure (has no side effects) separator.mark.as.entry.point.if.annotated.by=Mark as entry point if annotated by: separator.mark.field.as.implicitly.written.if.annotated.by=Mark field as implicitly written if annotated by: rename.super.methods.chooser.popup.title={0} has super methods rename.super.base.chooser.popup.title={0}{1, choice, 0# implements|1# overrides} method of {2} add.methods.dialog.or=\ or command.name.delegate.detected.change=Delegate encapsulate.fields.dialog.javadoc.title=Javadoc find.jar.hint.text.no.libraries.found.for.fqn=No libraries found for ''{0}'' dependant.sdk.unsatisfied.dependency.message=You need to configure a Java SDK first javadoc.gen.error.modules.without.module.info=IDEA cannot generate Javadoc as modules {0} do not contain module-info.java file javadoc.gen.error.module.source.path.is.not.evaluated=IDEA cannot generate Javadoc as module-source-path cannot be evaluated generate.members.implement.command=implement code.style.settings.angle.spacing.brackets=Angle brackets code.style.settings.spacing.after.closing.angle.bracket=After closing angle bracket code.style.settings.spacing.around.type.bounds=Around type bounds non.code.annotations.explanation.external.and.inferred=External and inferred annotations non.code.annotations.explanation.external.and.inferred.available=External and inferred annotations available. non.code.annotations.explanation.external=External annotations non.code.annotations.explanation.external.available=External annotations available. non.code.annotations.explanation.inferred=Inferred annotations non.code.annotations.explanation.inferred.available=Inferred annotations available. non.code.annotations.explanation.full.signature=Full signature: type.migration.command.name=TypeMigration dfa.constraint.not.null=not-null dfa.constraint.0.not.null={0} (not-null) dfa.constraint.null.or.0=null or {0} label.class.pattern.syntax.explanation=Leave the method blank to represent constructors\nAny * will match against one or more characters in the qualified name (including dots) dialog.message.modules.dont.refer.to.existing.annotations.library={0, choice, 0#Module|2#Modules} {1} {0, choice, 0#doesn''t|2#don''t} refer to the existing ''{2}'' library with IntelliJ IDEA nullity annotations. Would you like to add the {0, choice, 0#dependency|2#dependencies} now? tab.title.slices.grouped.by.nullness=\ (Grouped by Nullness) exclude.0.from.auto.import=Exclude ''{0}'' from auto-import column.name.method.entry.point=Method column.name.class.entry.point=Class column.name.with.subclasses.entry.point=With Subclasses code.vision.implementations.hint={0, choice, 1#1 implementation|2#{0,number} implementations} code.vision.inheritors.hint={0, choice, 1#1 inheritor|2#{0,number} inheritors} code.vision.overrides.hint={0, choice, 1#1 override|2#{0,number} overrides} hint.text.tostring.method.could.not.be.created.from.template=''toString()'' method could not be created from template ''{0}'' hint.text.tostring.template.invalid=toString() template ''{0}'' is invalid command.name.generate.tostring=Generate toString() column.name.ignore.suppressions=Ignore suppressions hint.text.removed.imports=Removed {0} {1, choice, 0#import|1#imports} hint.text.added.imports=, added {0} {1, choice, 0#import|1#imports} hint.text.rearranged.imports=Rearranged imports enum.constant.ordinal=Enum constant ordinal: tab.title.infer.nullity.preview=Infer Nullity Preview inspection.message.full.description=Full description popup.title.debug.recent.tests=Debug Recent Tests list.item.suite=[suite] {0} list.item.configuration=[configuration] {0} no.jre.description= popup.content.tests.were.not.found.in.module.use.instead=Tests were not found in module ''{0}''.\nUse {1, choice, 0#module {2} |1#one of\n{3}\n}instead postfix.template.provider.name=Java postfix.template.condition.void.name=void postfix.template.condition.non.void.name=non void postfix.template.condition.boolean.name=boolean postfix.template.condition.number.name=number postfix.template.condition.not.primitive.type.name=not primitive type postfix.template.condition.array.name=array inspection.redundant.unmodifiable.call.display.name=Redundant usage of the ''{0}'' wrapper inspection.redundant.unmodifiable.call.description=Redundant usage of unmodifiable collection wrappers inspection.redundant.unmodifiable.call.unwrap.argument.quickfix=Unwrap argument completion.override.implement.methods=Override/Implement methods... lambda.tree.node.presentation=Lambda inspection.meaningless.record.annotation.description=Meaningless record annotation inspection.meaningless.record.annotation.message.method.and.parameter=Annotation has no effect: its targets are METHOD and PARAMETER but both accessor and canonical constructor are explicitly declared inspection.meaningless.record.annotation.message.method=Annotation has no effect: its target is METHOD but the corresponding accessor is explicitly declared inspection.meaningless.record.annotation.message.parameter=Annotation has no effect: its target is PARAMETER but the canonical constructor is explicitly declared header.method.to.be.converted=Method to be converted accessible.name.change.modifier=Change Modifier usages.telescope={0,choice, 0#no usages|1#1 usage|2#{0,number} usages} press.to.navigate=Press {0} to navigate label.jvm.method.name=JVM method name link.configure.classes.excluded.from.completion=Configure classes excluded from completion exception.navigation.fetching.target.position=Fetching target position inspection.preview.feature.0.is.preview.api.message={0} is a preview API and may be removed in a future release progress.title.detect.overridden.methods=Check overriding methods