abstract.class.not.allowed=Abstract class is not allowed access.static.via.instance=Access static member via instance reference 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}\u2026 action.text.copy.to.clipboard=Copy to Clipboard action.text.edit.template=Edit Template action.text.enter.class.name=enter class name\u2026 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.unmark.generated.0=Unmark Generated {0} action.GotoSuperClass.text=Go to S_uper Class or Interface action.GotoSuperClass.MainMenu.text=S_uper Class or Interface action.GotoSuperClass.description=Navigate to the declaration of a class that the current class extends or implements add.to.permits.list.family.name=Add class to permits list add.to.permits.list=Add ''{0}'' to permits list of 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.array.element.to.itself.problem.descriptor=Array element is assigned to itself bean.property=Bean Property boolean.method.is.always.inverted.display.name=Boolean method is always inverted boolean.method.is.always.inverted.problem.descriptor=Calls to boolean method '#ref()' are always inverted button.add.blank=Add Blank button.add.class=Add Class\u2026 button.add=Add\u2026 button.add.package=Add Package\u2026 button.add.pattern=Add Pattern\u2026 button.annotations=Annotations\u2026 button.base.method=&Base Method button.code.patterns=Code patterns\u2026 button.current.method=&Current Method button.text.settings=Settings\u2026 cast.expression=Insert 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.spaces.around.annotation.eq=Around '=' in annotation value pair 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.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.chains=Ignore chainable methods 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.declare.var.type=Use 'var' for local variable declaration 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.within.deconstruction.list=Deconstruction list checkbox.spaces.inside.block.braces.when.body.is.present=Inside block braces when body is present checkbox.spaces.before.colon.in.foreach=Before colon in foreach checkbox.spaces.before.deconstruction.list=Deconstruction list 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.don.t.warn.in.case.of.multiline.lambda=Don't warn if the parameter of 'List.replaceAll()' is multiline lambda 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.preserve.module.import=Preserve module imports 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} completion.provider.method.declaration.type=provider() method declaration 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\u2026 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\u2026 deannotate.intention.action.family.name=Deannotate deannotate.intention.chooser.title=Choose Annotation to Delete 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.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.choose.logger = Choose Logger 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.missing.tests=Create Missing Tests dialog.title.edit.method.contract=Edit Method Contract dialog.title.edit.range=Edit Range of ''{0}'' dialog.title.infer.nullity=Infer Nullity action.title.infer.nullity.annotations=Infer Nullity Annotations 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 dialog.title.testdatapath.method.generate=Generate methods from @TestDataPath dialog.title.testdatapath.file.generate=Generate files from class to @TestDataPath 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.blank.lines.field.in.interface=Before field in interface editbox.blank.lines.field.without.annotations=Before field without annotations: editbox.blank.lines.field.with.annotations=Before field with annotations: 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.attempt.to.generate.constructor.for.implicit.class=Cannot add constructor to an implicitly declared 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=O&verloaded methods find.options.include.accessors.checkbox=Search for &accessors find.options.include.accessors.base.checkbox=S&earch for base methods of accessors find.options.include.accessors.base.checkbox.comment=Use top-level hierarchy methods as find usage targets by default find.options.search.overriding.methods.checkbox=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.search.for.base.methods.checkbox=S&earch for base method usages find.what.search.for.base.methods.checkbox.comment=Use top-level hierarchy methods as find usage targets by default 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.type.comparison.label=For class type comparison in equals() method generate: generate.equals.hashcode.comparison.table=\
instanceofgetClass()\
Allows instances of subclasses to equal instances of the superclassyesno\
Allows instances of different subclasses to equal each otheryesno\
Overriding the generated equals() method does not break its contractnoyes\
Avoids extra null checkyesno\
Obeys\\ the\\ Liskov\\ substitution\\ principleyesno\
generate.equals.hashcode.instanceof.type.comparison=&instanceof expression generate.equals.hashcode.getclass.type.comparison=get&Class() comparison expression generate.equals.hashcode.accept.sublcasses.explanation=While generally incompliant to the contract of Object.equals(), accepting
\ subclasses may be necessary for the 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 when available 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.wizard.title=Generate equals() generate.hashcode.wizard.title=Generate 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.logger.no.place.found.dialog.title = No Places Found generate.logger.no.place.found.dialog.message = Could not find places to insert logger generate.logger.specify.place.popup.title=Choose Place 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 generated toString() ($classname) generate.tostring.getters.in.generated.code=Use getters in generated toString() when available ($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() generate.quickfix.files=Create QF scenarios(with '.after' suffix) generate.select.default.modifier.text=Select modifier generate.file.extension.text=Enter file extension: .php, .java, .kt, .cpp .... generate.file.extension.validation.error=File extension ''{0}'' isn''t valid. It must start from ''.'', can''t contain space symbols or be blank generate.method.nosuites.warn=No test suites were found in @TestDataPath("{0}") generate.method.nofiles.warn=No test methods were found in class {0} 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.layout.on.demand.import.from.same.package.first=Place on-demand import before single-class imports from the same package import.statically=Import statically include.accessors=&Include Accessors infer.nullity.progress=Post-processing results\u2026 insert.override.annotation=Insert @&Override annotation 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.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 loop inspection.conditional.break.in.infinite.loop.no.conversion.with.do.while=Don't suggest to replace with 'do while' inspection.conditional.break.in.infinite.loop.allow.condition.fusion=Allow merging with existing loop condition inspection.conditional.break.in.infinite.loop.suggest.conversion.when.if.is.single.stmt.in.loop=Suggest conversion when 'if' is a single statement in loop inspection.convert.to.local.quickfix=Convert to local inspection.data.flow.display.name=Nullability and data flow problems inspection.data.flow.optional.of.nullable.misuse.display.name=Use of Optional.ofNullable with null or not-null argument inspection.data.flow.constant.values.display.name=Constant values inspection.data.flow.unreachable.code.display.name=Unreachable code inspection.data.flow.unreachable.code.option.ignore.trivial.name=Ignore trivial exit statements inspection.data.flow.unreachable.code.option.ignore.trivial.description=Do not report unreachable statements like return 0, break, etc., as they could be necessary to satisfy Java control flow rules. inspection.data.flow.unreachable.code.option.respect.suppression.name=Respect 'Constant value' inspection suppressions inspection.data.flow.unreachable.code.option.respect.suppression.description=Try to avoid reporting unreachable code if it caused by a constant condition, where a corresponding warning is suppressed. 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.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.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.equals.hashcode.generate.equals.quickfix.preview=Opens a dialog to configure 'equals()' generation. inspection.equals.hashcode.generate.hashcode.quickfix.preview=Opens a dialog to configure 'hashCode()' generation. 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.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.missingJavadoc.display.name=Missing Javadoc inspection.replace.javadoc.display.name=Comment replaceable with Javadoc inspection.missingJavadoc.label.minimalVisibility=Minimal visibility: inspection.missingJavadoc.label.requiredTags=Required tags: inspection.javadocDeclaration.display.name=Javadoc declaration 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.snippet.tag.is.not.available='@snippet' tag is not available at this language level 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.blank.lines.display.name=Blank line should be replaced with

to break lines inspection.javadoc.blank.lines.message=Blank line will be ignored inspection.replace.with.javadoc=Replace with Javadoc comment inspection.replace.with.javadoc.comment=Comment can be converted to Javadoc inspection.javadoc.blank.lines.fix.name=Insert

inspection.javadoc.blank.lines.fix.family.name=Replace blank lines with

inspection.javadoc.link.as.plain.text.display.name=Link specified as plain text inspection.javadoc.link.as.plain.text.message=Link specified as plain text 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.fix.title=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.implicit.description=When checked, fields that are known to be initialized implicitly (e.g. via dependency injection) will not be reported inspection.notnull.field.not.initialized.option.setup=Ignore fields initialized in setUp() method inspection.notnull.field.not.initialized.option.setup.description=When checked, fields in test case classes that are initialized in setup methods (e.g. annotated via @Before or @BeforeEach) will not be reported. 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 vice versa 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.optional.get.without.is.present.method.reference.message=#ref without 'isPresent()' check inspection.overflowing.loop.index.inspection.description=Loop executes zero or billions of times inspection.overflowing.loop.index.inspection.name=Loop executes zero or billions of times inspection.overwritten.key.map.message=Duplicate Map key inspection.overwritten.key.set.message=Duplicate Set element inspection.overwritten.key.array.message=Overwritten array element inspection.parameter.can.be.local.display.name=Value passed as parameter never read inspection.parameter.can.be.local.problem.descriptor=Parameter can be converted to a local variable inspection.quickfix.assert.family=Assert inspection.raw.use.of.parameterized.type.problem.descriptor=Raw use of parameterized class #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.variable.type.can.be.generic.cast.quickfix=Change cast type to {0} raw.variable.type.can.be.generic.cast.quickfix.family=Parameterize cast type 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=Ignore 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 is a previous 'distinct()' call in the chain inspection.redundant.stream.optional.call.explanation.distinct.set=elements will be distinct anyway when collected to a 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 is a subsequent ''{0}()'' call which overrides this call inspection.redundant.stream.optional.call.explanation.parallel.source=the stream was created via 'parallelStream()', so it's already parallel inspection.redundant.stream.optional.call.explanation.sequential.source=the stream was created via 'stream()', so it's already sequential 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.parallel=subsequent ''{0}()'' operation doesn''t depend on the sort order for parallel streams inspection.redundant.stream.optional.call.explanation.sorted.twice=there is a subsequent 'sorted()' call in the chain inspection.redundant.stream.optional.call.explanation.unordered=there is a previous '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.bind.name=Merge the ''{0}()'' step with the previous ''{1}()'' step inspection.redundant.stream.optional.call.fix.name=Remove ''{0}()'' call inspection.redundant.stream.optional.call.fix.replace.terminal=Replace the terminal operation inspection.redundant.stream.optional.call.fix.replace.terminal.text=Replace the terminal operation with ''{0}()'' inspection.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 always ''{0}'' inspection.simplifiable.comparator.comparing.message=Unnecessary ''{0}()'' call inspection.simplifiable.comparator.display.name=Comparator method can be simplified inspection.simplifiable.comparator.entry.comparator.message=''{0}'' can be used instead inspection.simplifiable.comparator.fix.comparing.family.name=Remove redundant call inspection.simplifiable.comparator.fix.entry.comparator.family.name=Use predefined 'Map.Entry' comparator inspection.simplifiable.comparator.fix.remove.name=Remove ''{0}()'' call inspection.simplifiable.comparator.fix.replace.name=Remove ''{0}()'' call and use ''{1}()'' inspection.simplifiable.comparator.fix.reversed.family.name=Simplify comparator method replacing 'max' with 'min' inspection.simplifiable.comparator.fix.reversed.name=Replace with ''{0}'' simplifying the comparator inspection.simplifiable.comparator.reversed.message=Comparator method can be simplified if ''{0}()'' call is replaced with ''{1}()'' inspection.simplify.collector.fix.family.name=Simplify cascaded collector inspection.simplify.collector.fix.name=Use ''Collectors.{0}()'' collector inspection.simplify.collector.message=Can be simplified using ''{0}()'' collector inspection.simplify.foreach.display.name=Simplifiable forEach() call inspection.sorted.collection.with.non.comparable.keys.display.name=Sorted collection with non-comparable elements inspection.sorted.collection.with.non.comparable.keys.message=Construction of sorted collection with non-comparable elements inspection.sorted.collection.with.non.comparable.keys.option.type.parameters=Don't report non-comparable type parameters inspection.surround.if.family=Surround with if inspection.surround.if.quickfix=Surround with ''if ({0}{1})'' inspection.suspicious.list.remove.display.name=Suspicious 'List.remove()' in loop inspection.switch.expression.backward.expression.migration.inspection.name='switch' expression can be replaced with old style 'switch' statement inspection.switch.expression.backward.migration.inspection.name=Enhanced 'switch' inspection.switch.expression.backward.statement.migration.inspection.name='switch' statement can be replaced with old style 'switch' statement inspection.switch.expression.migration.inspection.name=Statement can be replaced with enhanced 'switch' inspection.switch.expression.migration.inspection.switch.description=Switch statement can be replaced with enhanced 'switch' inspection.switch.expression.migration.warn.only.on.expression=Show warning only if conversion to expression is possible inspection.switch.expression.migration.option.expression.max.statements=Do not report switches having more than {0} {0, choice, 1#statement|2#statements} in a single branch inspection.switch.expression.migration.expression.max.statements=Maximum number of statements in one branch to convert to switch expression inspection.switch.labeled.rule.can.be.code.block.display.name=Labeled switch rule can have code block inspection.switch.labeled.rule.can.be.code.block.expression.message=Labeled rule's result expression can be wrapped with code block inspection.switch.labeled.rule.can.be.code.block.fix.expression.name=Wrap labeled rule's result expression with code block inspection.switch.labeled.rule.can.be.code.block.fix.statement.name=Wrap labeled rule's statement with code block inspection.switch.labeled.rule.can.be.code.block.statement.message=Labeled rule's statement can be wrapped with code block inspection.text.block.backward.migration.message=Text block can be converted to regular string literal inspection.text.block.backward.migration.name=Text block can be replaced with regular string literal inspection.text.block.migration.string.message=String can be replaced with text block inspection.text.block.migration.concatenation.message=Concatenation can be replaced with text block inspection.text.block.migration.name=Text block can be used inspection.text.block.migration.suggest.literal.replacement=Report single string literals inspection.string.template.migration.string.message=String can be replaced with template inspection.string.template.reverse.migration.string.message=String template can be replaced with string concatenation inspection.string.template.migration.concatenation.message=Concatenation can be replaced with string template inspection.string.template.migration.name=String template can be used inspection.string.template.reverse.migration.name=String template can be concatenated string inspection.implicit.to.explicit.class.backward.migration.name=Implicitly declared class can be replaced with ordinary class inspection.implicit.to.explicit.class.backward.migration.fix.name=Convert implicitly declared class into regular class inspection.explicit.to.implicit.class.migration.name=Explicit class declaration can be converted into implicitly declared class inspection.explicit.to.implicit.class.migration.fix.name=Convert into implicitly declared class inspection.inconsistent.text.block.indent.name=Inconsistent whitespace indentation in text block inspection.inconsistent.text.block.indent.message=Text block indent consists of tabs and spaces inspection.inconsistent.text.block.indent.spaces.to.tabs.one.to.one.fix=Replace spaces with tabs (1 space = 1 tab) inspection.inconsistent.text.block.indent.spaces.to.tabs.many.to.one.fix=Replace spaces with tabs ({0} spaces = 1 tab) inspection.inconsistent.text.block.indent.tabs.to.spaces.one.to.one.fix=Replace tabs with spaces (1 tab = 1 space) inspection.inconsistent.text.block.indent.tabs.to.spaces.one.to.many.fix=Replace tabs with spaces (1 tab = {0} spaces) inspection.suspicious.return.byte.input.stream.name = Suspicious byte value returned from 'InputStream.read()' inspection.suspicious.return.byte.input.stream.convert.to.unsigned = Convert to an unsigned byte inspection.trailing.whitespaces.in.text.block.name=Trailing whitespace in text block inspection.trailing.whitespaces.in.text.block.message=Trailing whitespace characters inside text block inspection.trailing.whitespaces.in.text.block.remove.whitespaces=Remove trailing whitespace characters inspection.trailing.whitespaces.in.text.block.replaces.whitespaces.with.escapes=Escape trailing whitespace characters inspection.undeclared.service.usage.message=Usage of service ''{0}'' is not declared in module-info inspection.undeclared.service.usage.name=Usage of service not declared in 'module-info' inspection.unused.assignment.option=Report prefix expressions that can be replaced with a binary expression inspection.unused.assignment.option1=Report postfix expressions where the changed value is not used inspection.unused.assignment.option2=Report redundant initializers inspection.unused.assignment.option3=Report pattern variables whose values are never used inspection.unused.assignment.option4=Report iteration parameters whose values are never used inspection.unused.assignment.problem.descriptor1=Variable #ref #loc is never used inspection.unused.assignment.problem.descriptor2=Variable {0} initializer #ref #loc is redundant inspection.unused.assignment.problem.descriptor3=The value {0} assigned to #ref #loc is never used inspection.unused.assignment.problem.descriptor4=The value changed at #ref #loc is never used inspection.unused.assignment.problem.descriptor5=The value of pattern variable #ref #loc is never used inspection.unused.assignment.problem.descriptor6=The value of foreach iteration parameter #ref #loc is never used inspection.unused.assignment.remove.assignment.quickfix=Remove redundant assignment inspection.unused.assignment.remove.assignment.quickfix.title=Remove Redundant Assignment inspection.unused.assignment.remove.initializer.quickfix=Remove redundant initializer inspection.unused.assignment.remove.initializer.quickfix.title=Remove Redundant Initializer inspection.unused.parameter.problem.descriptor=Parameter #ref is not used inspection.unused.parameter.composer=Parameter #ref is not used in any implementation inspection.unused.parameter.composer1=Parameter #ref is not used in this method nor in any of its overriding methods inspection.unused.parameter.delete.family=Safe delete unused parameter(s) inspection.unused.parameter.delete.quickfix=Safe delete unused parameter ''{0}'' inspection.unused.return.value.display.name=Method can be made '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.unused.symbol.check.parameters.excluding.hierarchy=Excluding hierarchy inspection.empty.module.info.file=Empty 'module-info.java' file inspection.unresolved.module.dependencies.problem.descriptor=Unresolved module dependencies inspection.auto.add.module.requirements.quickfix=Fill in module dependencies 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.annotation.method.from.usage=Create @interface method ''{0}()'' 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.family=Extract Set from comparison chain intention.extract.set.from.comparison.chain.popup.title=Extract Set from Comparison Chain intention.family.add.javadoc=Add Javadoc 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 presence 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=Move into anonymous object 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\u2026 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.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}()''\u2026 intention.text.add.range.to.0=Add range to ''{0}''\u2026 intention.text.annotate.externally=Annotate externally intention.text.collapse.repeating.annotations=Collapse repeating annotations intention.text.create.a.class.in.0=Create a class in ''{0}'' intention.text.create.a.class.in.package.preview=Opens a dialog to create a class in package ''{0}'' intention.text.edit.method.contract.of.0=Edit method contract of ''{0}()''\u2026 intention.text.edit.range.of.0=Edit range of ''{0}''\u2026 intention.text.fix.method.0.parameters.with.bounded.wildcards=Fix method ''{0}'' parameters with bounded wildcards intention.text.generate.missing.test.methods=Generate missing test methods 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 #intention categories intention.category.annotations=Java/Annotations intention.category.comments=Java/Comments intention.category.concurrency=Java/Concurrency intention.category.collections=Java/Collections intention.category.conditional.operator=Java/Conditions intention.category.control.flow=Java/Control flow intention.category.declaration=Java/Declaration intention.category.expressions=Java/Expressions intention.category.i18n=Java/Internationalization intention.category.imports=Java/Imports intention.category.junit=Java/JUnit intention.category.other=Java/Other intention.category.refactorings=Java/Refactorings intention.category.streams=Java/Streams intention.category.strings=Java/Strings intention.category.try.statements=Java/Try statements 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.level={0} (Preview) java.preview.features.notification.title=Java preview features java.preview.features.warning=Newer IDE versions may discontinue support for Java preview features. When Java {0} is released, support for the {1} (Preview) language level may be dropped. java.preview.features.unsupported.title=Unsupported Java preview features java.preview.features.unsupported=Java language level {0} (Preview) used in this project is not supported anymore. \ Code insight for the preview features may work incorrectly.
\ It''s strongly encouraged to migrate to newer Java version or stop using preview features. java.terms.exception=exception java.terms.region=region 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} java.configurable.logger.unspecified=Unspecified java.configurable.logger.not.found=Logger was not found inside the project java.configurable.logger.identifier.long=Identifier is too long 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=From class: javadoc.description.copied.from.field=From field: javadoc.description.copied.from.interface=From interface: #short index to be shown on the inferred annotation in the documentation popup javadoc.description.inferred.annotation.hint=i javadoc.generate.arguments=Command line arguments: javadoc.generate.exited=\n"javadoc" finished with exit code $EXIT_CODE$ javadoc.generate.heap.size=&Maximum heap size: 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.separator=JavaDoc Options 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.scope.row=Visibility level: 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.generate.ok=Generate javadoc.generate.validation.error=Specify the output directory. 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: jvm.logging.configurable.display.name = JVM Logging jvm.logging.configurable.id = jvm.logging jvm.logging.configurable.java.group.display.name = Java 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.configurable.logger.type=Logger: label.configurable.logger.generation.variable.name= Variable name: label.contract=&Contract: label.enter.fully.qualified.class.name=Enter fully qualified class name label.entry.points=Entry points: label.forbid.api.usages=Forbid usages of API newer than label.forbid.api.usages.project=(according to project settings) 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 method visibility: label.method=Method ''{0}'' label.ignore.complicated.fix=Ignore when a quick-fix cannot be provided label.minimal.reported.method.usage.count=Minimal method usage count to report parameter: 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 link.configurable.logger.generator.display.name = Settings 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 methods.to.override.generate.javadoc=Generate missing JavaDoc 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.notnull.annotation.used.label=Annotation used for code generation: nullable.stuff.inspection.navigate.null.argument.usages.fix.family.name=Navigate to 'null' argument usages nullable.stuff.inspection.navigate.null.argument.usages.fix.family.preview=Shows a list of usages where 'null' is passed as an argument. 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 tooltip.reassigned.local.variable=Reassigned local variable options.java.attribute.descriptor.reassigned.parameter=Parameters//Reassigned parameter tooltip.reassigned.parameter=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.attribute.descriptor.public=Visibility//Public options.java.attribute.descriptor.protected=Visibility//Protected options.java.attribute.descriptor.package.private=Visibility//Package-private options.java.attribute.descriptor.private=Visibility//Private 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 package.pattern.provider.hint.label=Use *.txt to match all 'txt' files in the project, file:path_in_project//* to match all files in a directory recursively, src:foo..* to match all classes in a package recursively. packaging.jlink.artifact.name=JLink packaging.jlink.artifact.title=Run-time image (JLink) packaging.jlink.compression.level=Compression level packaging.jlink.compression.zero.level=No compression packaging.jlink.compression.first.level=String sharing packaging.jlink.compression.second.level=Zip 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 title.related.problems.inlay.hints=Related Problems progress.creating.class=Creating class {0} progress.title.check.applicability=Check applicability\u2026 progress.title.download.library.descriptor=Download Library Descriptor progress.title.find.references.in.implement.extends.lists=Find References in Implement/Extends Lists\u2026 progress.title.finding.cause=Finding cause progress.title.looking.for.libraries=Looking for Libraries progress.title.optimize.imports=Optimize Imports\u2026 progress.title.preprocess.usages=Preprocess Usages progress.title.search.for.overriding.methods=Search for overriding methods\u2026 progress.title.searching.for.sub.classes=Searching for Subclasses 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\u2026 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 \u2026 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.link=Replace URL with link 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 scheduled.thread.pool.executor.with.zero.core.threads.display.name='ScheduledThreadPoolExecutor' with zero core threads scheduled.thread.pool.executor.with.zero.core.threads.description='ScheduledThreadPoolExecutor' should not have zero core threads scope.hierarchy=Hierarchy of {0} sdk.cannot.create=Cannot Create SDK sdk.java.no.classes=Cannot find JDK classes in ''{0}'' sdk.configured.external.config.title=JDK is configured ({0}) sdk.configured=''{0}'' is set as project JDK. 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 as arguments 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.implicit.types.local=Implicit types settings.inlay.java.implicit.types.local.description=Local variables declared with the var keyword when the inferred type may not be clear from the right part of the assignment, for example, when using a factory method. settings.inlay.java.implicit.types.lambda=Lambda types settings.inlay.java.implicit.types.lambda.description=Show inlay hints for lambda parameter types. settings.inlay.java.methods.with.same.named.numbered.parameters=Methods with same-named numbered parameters 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 # suppress inspection "UnusedProperty" inlay.parameters.java.method.name.contains.parameter.name=Methods that take a single argument when the expected argument is clear from the method name, like in accessor methods. # suppress inspection "UnusedProperty" inlay.parameters.java.multiple.params.same.type=Calls to methods with more than one non-literal argument of the same type. # suppress inspection "UnusedProperty" inlay.parameters.java.build.like.method=Methods that return an instance of the class they operate on, for example, calls in StringBuilder chains or intermediate operations in Java 8 Stream API. # suppress inspection "UnusedProperty" inlay.parameters.java.simple.sequentially.numbered=Methods that take multiple parameters, whose names consist of one letter followed by a number. # suppress inspection "UnusedProperty" inlay.parameters.java.enums=Enum constant declarations that use a parametrized constructor. # suppress inspection "UnusedProperty" inlay.parameters.java.new.expr=Calls to parametrized constructors. # suppress inspection "UnusedProperty" inlay.parameters.java.clear.expression.type=Method calls that use a complex expression as an argument, for example, the ternary operator or a Java 13 switch statement. inlay.MethodChainsInlayProvider.description=Method return types in call chains. inlay.annotation.hints.inferred.annotations=Annotations that IDE generates by scanning libraries and project code. These annotations help you understand code contracts and improve the capabilities of static analysis. They include:
@Contract
@Nullable
@NotNull
@Unmodifiable
@UnmodifiableView

Documentation (TODO: change link to OpenIDE) inlay.annotation.hints.external.annotations=Annotations that are stored outside your source code.
These annotations are useful when you need an annotation, but adding it to the source code is not an option (for example, when working with a library code).

Documentation (TODO: change link to OpenIDE) 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.preview=Adds ''@{0}'' to a list of annotations that will be ignored by this inspection 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.template=try / catch surround.with.cast=Surround With Cast 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=Variable declaration title.naming.variable=Variable 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 IDE 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 new.line.when.body.is.presented=New line when body is presented unwrap.anonymous=Unwrap 'anonymous\u2026' 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 generate.type.use.before.type=Put generated annotations with target TYPE_USE between the modifiers and the type generate.type.use.before.type.description=Annotations with target TYPE_USE will be placed after any modifiers and directly
before the type. When disabled, they will be placed before any modifiers. wrapping.annotation.enums=Enum field annotations wrapping.annotation.parameters=Annotation parameters wrapping.record.components=Record components wrapping.multi.catch.types=Types in multi-catch wrapping.deconstruction.patterns=Deconstruction patterns align.types.in.multi.catch=Align types in multi-catch wrapping.text.blocks=Text blocks wrapping.switch.statement.or.expression='switch' statement/expression wrapping.semicolon.after.call.chain=Move ';' to the new line wrong.package.statement=Wrong package statement title.code.vision=Code vision title.code.vision.inlay.hints=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.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.else='else' position live.template.context.expression=Expression live.template.context.declaration=Declaration inspection.unused.display.name=Unused declaration 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=Guava pseudo-functional call can be converted to Stream API call inspection.overwritten.key.display.name=Overwritten Map, Set, or array 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.list.replace.all.display.name=Loop can be replaced with 'List.replaceAll()' inspection.java.8.map.api.display.name=Simplifiable '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 style 'Optional.isPresent()' 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.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' inspection.slow.list.contains.all.description=Call to 'list.containsAll(collection)' may have poor performance inspection.slow.list.contains.all.fix.family.name=Wrap in 'HashSet' constructor inspection.slow.list.contains.all.fix.name=Wrap ''{0}'' in ''HashSet'' constructor 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.find.similar.stack.call.diverged=Line numbers are likely diverged. Try to find the current location inside ''{0}.{1}()'' action.find.similar.stack.call.methods=Similar Methods to ''{0}.{1}()'' action.find.similar.stack.call.similar.calls=Possible Locations Inside ''{0}.{1}()'' action.find.similar.stack.call.methods.not.found=No similar methods to ''{0}.{1}()'' action.find.similar.stack.call.location.not.found=No similar location inside ''{0}.{1}()'' 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.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 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.pattern.variables.can.be.replaced.with.cast.preserve.option=Try to preserve unused variables from patterns during quickfix inspection.message.pattern.variables.can.be.replaced.with.cast=Using 'instanceof' with patterns inspection.message.pattern.variables.can.be.replaced.with.cast.family.name=Replace without patterns inspection.message.pattern.variables.can.be.replaced.with.cast.fix.name=Replace ''{0}'' with casts 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 record class class.can.be.record.quick.fix=Convert to record class class.can.be.record.suggest.renaming.accessors=Suggest renaming accessor methods class.can.be.record.conversion.make.member.more.accessible=If members become more accessible: class.can.be.record.conversion.strategy.do.not.convert=Do not suggest conversion class.can.be.record.conversion.strategy.show.members=Show conflicts view class.can.be.record.conversion.strategy.convert.silently=Convert silently class.can.be.record.suppress.conversion.if.annotated=Suppress conversion if class is annotated by: class.can.be.record.suppress.conversion.if.annotated.fix.name=Suppress record conversion if annotated by ''{0}'' 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 not a valid type type.migration.dialog.message.void.not.applicable=Only method return types can be migrated to 'void' type.migration.dialog.message.vararg.type.not.applicable=Only the last parameter of a method can be migrated to a vararg type type.migration.dialog.message.disjunction.type.not.applicable=Only a catch block parameter can be migrated to a union type 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.expression.presentation=expression ''{0}'' change.signature.from.usage.short.name= Change signature of {0}({1}) default.param.value.warning={0} 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 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' simplify.optional.chain.inspection.fix.name.remove.redundant.optional.chain=Remove redundant Optional chain simplify.optional.chain.inspection.fix.description.optional.chain.can.be.eliminated=Optional chain can be eliminated simplify.optional.chain.inspection.fix.description.replace.with.value.of.name=Replace with 'String.valueOf()' simplify.optional.chain.inspection.fix.description.replace.with.value.of.description=Optional chain can be replaced with 'String.valueOf()' 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} will 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=The initializer of final {0} will be left behind. 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 import.layout.panel.module.imports=module imports edit.contract.dialog.hint=Please specify the contract text

Example: _, null -> false
See intention action description for more details edit.contract.dialog.mutates.hint=Specify comma-separated elements that can be mutated

Example: this,param1

Leave empty for unspecified side effects. edit.range.dialog.message=Leave empty if 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.greater.than.to=Should not be greater than 'to' 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.getter.setter.generate.all.annotations=Copy &all annotations generate.getter.setter.generate.all.annotations.tooltip=Copy all applicable annotations from fields. Otherwise, only nullability annotations will be copied 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 Percentage of Subclasses That Override the Method action.sort.by.percent.classes.which.overrides.method.description=Sort by percentage of subclasses that override the 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.cannot.convert.message=Cannot convert type of expression {0}{3, choice, 0#|1# from '<'b'>'{1}'<'/b'>'} to {2} type.migration.cannot.convert.vararg.message=Cannot convert call {0} from vararg to non-vararg type.migration.replaced.notification=Replaced with {0} type.migration.cannot.convert.tooltip=Cannot convert type of expression from {0} to {1} type.migration.cannot.convert.vararg.tooltip=Cannot convert call from vararg to non-vararg type.migration.getter.rename.suggestion.text=Rename getter from ''{0}'' to ''{1}'' since the 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 records.cannot.be.inlined=Record classes 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\u2026 replace.implements.with.static.import.field.usages.progress=Find Constant Field Usages\u2026 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.functional.implementation.text=Find Functional Interface Implementations 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.impure.method=Method may produce &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.available=External and inferred annotations available. non.code.annotations.explanation.external.available=External annotations available. 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 IDE 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() 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=Tests were not found in module ''{0}''.\n popup.content.tests.were.not.found.in.module.use.instead=Use {0, choice, 0#module {1} |1#one of\n{2}\n}instead popup.content.tests.were.not.found.in.module.search.in.dependencies=Search across module dependencies 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\u2026 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} label.jvm.method.name=JVM method name label.jvm.field.name=JVM field name label.jvm.class.name=JVM class name link.configure.classes.excluded.from.completion=Configure classes excluded from completion 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 intention.name.iterate.over=Iterate over {0} advanced.settings.group.compiler=Compiler advanced.setting.compiler.lower.process.priority=Run compilation with lower priority advanced.setting.compiler.lower.process.priority.description=Run external JPS process with IDLE priority on Windows and nice level 10 on Linux/macOS advanced.setting.compiler.automake.allow.when.app.running=Allow auto-make to start even if developed application is currently running advanced.setting.compiler.automake.allow.when.app.running.description=Automatically started make may eventually delete some classes that are required by the application advanced.setting.compiler.unified.ic.implementation=Enable unified Java/Kotlin incremental compilation implementation advanced.setting.compiler.unified.ic.implementation.description=External JPS process will use new incremental compilation implementation that can handle both Java- and Kotlin-produced bytecode advanced.settings.group.java=Java advanced.setting.code.vision.java.minimal.usages=Code Vision: Minimum usages required to show inlay hints advanced.setting.java.completion.qualifier.as.argument=Enable completion for static methods, which uses qualifier as a first argument advanced.setting.java.sdkmanrc.watcher=Start listening for changes in configuration files ('.sdkmanrc', '.tool-versions', \u2026) on project opening dialog.title.check.functional.interface.candidates=Check Functional Interface Candidates\u2026 popup.title.select.target.code.block=Select Target Code Block target.code.block.presentable.text=Containing block conflict.message.method.will.override.method.base.class=Renamed {0} will override method of the base {1} progress.title.looking.for.jdk=Looking for JDK\u2026 dialog.title.check.configuration=Check Configuration\u2026 dialog.message.template.not.found=Template not found dialog.message.template.not.applicable=Template is not applicable dialog.message.class.not.found=Template class ''{0}'' not found notification.content.was.set.up=JDK ''{0}'' was set up for the project notification.content.change.jdk=Change JDK button.to.another.directory=To &Directory button.to.another.source.root=To &Source Root where.do.you.want.to.move.directory.prompt={0}\n\nWould you like to move the directory to another source root or another directory? loading.additional.annotations=Loading additional annotations\u2026 tooltip.anonymous=Anonymous tooltip.has.several.functional.implementations=Has several functional implementations tooltip.implements.method=Implements method tooltip.implements.method.in=Implements method in tooltip.is.functionally.implemented.in=Is functionally implemented in tooltip.is.implemented.by=Is implemented by tooltip.is.implemented.by.several.subclasses=Is implemented by several subclasses tooltip.is.implemented.in=Is implemented in tooltip.is.implemented.in.several.subclasses=Is implemented in several subclasses tooltip.is.overridden.by.several.subclasses=Is overridden by several subclasses tooltip.is.overridden.in=Is overridden in tooltip.is.overridden.in.several.subclasses=Is overridden in several subclasses tooltip.is.subclassed.by=Is subclassed by tooltip.overrides.method=Overrides method tooltip.overrides.method.in=Overrides method in tooltip.via.subclass=via subclass progress.title.calculate.applicable.types=Calculate applicable types\u2026 completion.inner.scope.tail.text=\ (from {0} block) completion.inner.scope=inner javadoc.documentation.url.checked=The following documentation {0, choice, 1#URL was|2#URLs were} checked: javadoc.edit.api.docs.paths=Edit API docs paths intention.family.name.move.class.to.test.root=Move class to test root intention.name.move.class.to.test.root=Move ''{0}'' to test root megabytes.unit=megabytes java.platform.module.system.name=Java Platform Module System dialog.title.move.directory=Move Directory progress.title.checking.if.class.exists=Check target class ''{0}'' exists quickfix.find.cause.description=Attempts to highlight code elements that resulted in this warning and explain how exactly they contribute. completion.generate.via.wizard=(generate via wizard) notification.group.jdk.resolve.problems=Failed to resolve JDK notification.group.jshell=JShell problem occurred notification.group.repository=JAR files synchronized with repository notification.group.source.searcher=Failed to find sources for JAR file notification.group.language.level=Preview Java language level requires accepting license notification.group.preview.features=Preview Java language level may be discontinued notification.group.redundant.exports=Redundant exports/opens can be removed notification.group.setup.jdk=JDK configured notification.group.setup.external.annotations=Failed to load external annotations notification.group.testintegration=Failed to generate tests for @TestDataPath notification.group.legacy.library=Legacy library depends on IDE installation notification.group.arch.checker=JDK and system architectures are different arch.checker.notification.title=The selected JDK can cause slow builds arch.checker.notification.content=The JDK ''{0}'' ({1}) does not match the system architecture ({2}). arch.checker.notification.project.structure=Configure JDK inspection.io.stream.constructor.description='InputStream' and 'OutputStream' can be constructed using 'Files' methods inspection.input.stream.constructor.message='InputStream' can be constructed using 'Files.newInputStream()' inspection.output.stream.constructor.message='OutputStream' can be constructed using 'Files.newOutputStream()' inspection.bulk.file.attributes.read.description=Bulk 'Files.readAttributes()' call can be used inspection.replace.with.bulk.file.attributes.read.fix.family.name=Replace with bulk 'Files.readAttributes()' call inspection.bulk.file.attributes.read.message=Multiple file attribute calls can be replaced with single 'Files.readAttributes()' call external.annotations.problem.title=Unable to read external annotations external.annotations.problem.parse.error=File: {0}
Problem: {1} external.annotations.open.file=Open annotations file intention.family.name.set.explicit.variable.type=Set explicit variable type intention.name.set.variable.type=Set variable type to ''{0}'' introduce.parameter.inlay.title.delegate=Delegate introduce.parameter.inlay.tooltip.delegate=Delegate via overloading method introduce.parameter.advertisement.text=Press {0} to delegate via overloading method or {1} to show more options progress.title.collect.method.overriders=Collect method overriders\u2026 remove.var.keyword.text=Remove 'var' error.message.ide.does.not.support.starting.processes.using.old.java=IDE doesn''t support starting Java processes using Java {0}, \ the minimum supported version is 1.7. Change the run configuration to use a newer Java version. intention.family.name.upgrade.jdk=Upgrade JDK intention.name.upgrade.jdk.to=Upgrade JDK to {0}+ intention.family.name.box.primitive.in.conditional.branch=Box primitive value in conditional branch environment.key.description.project.jdk=Absolute path to project JDK environment.key.description.project.jdk.name=IDE-visible name of project JDK. progress.title.detecting.jdk=Detecting JDK progress.title.restore.references=Restoring references increase.language.level.preview.description=Language level for module ''{0}'' will be changed to ''{1}'' open.settings.dialog.for.module.preview.text=Open settings dialog for module ''{0}'' button.add.dependency=Add Dependency adds.ext.library.preview=Adds library ''{0}'' to module ''{1}'' adds.ext.library.preview.import=Adds library ''{0}'' to the dependencies of module ''{1}'' and imports ''{2}'' adds.module.dependencies.preview=Adds {0, choice, 1#module ''''{1}''''|2#one of {2}} to the dependencies of module ''{3}'' and imports unresolved classes adds.library.preview=Adds {0, choice, 1#library ''''{1}''''|2#one of {2}} to the dependencies of module ''{3}'' and imports unresolved ''{4}'' adds.library.preview.no.import=Adds {0, choice, 1#library ''''{1}''''|2#one of {2}} to the dependencies of module ''{3}'' notification.content.added.annotations=Added {0} {0, choice, 1#annotation|2#annotations} java.method.chains.inlay.provider.name=Method chains java.implicit.types.local.inlay.provider.name=Implicit types java.implicit.types.lambda.inlay.provider.name=Lambda parameter types intention.make.final.fixer.stream=Make ''{0}'' effectively final using stream API intention.make.final.fixer.if=Make ''{0}'' effectively final by moving initializer to the ''if'' statement package.classes=Package classes: invert.quickfix.preview=Opens a dialog to invert the selected boolean and choose its new name. validator.text.not.valid.class.name=Not a valid class name validator.text.class.not.found=Class not found validator.text.no.annotation=Must be annotation validator.text.wrong.superclass=Wrong superclass compiler.options=Compiler options vm.option.description.requires=\ (requires {0}) vm.option.description.option=Option: vm.option.description.category=Category: vm.option.description.type=Type: vm.option.description.default.value=Default value: vm.option.description.description=Description: vm.option.description.standard=Standard vm.option.description.product=Product vm.option.description.diagnostic=Diagnostic vm.option.description.experimental=Experimental hint.text.not.valid.java.identifier=Not a valid Java identifier command.name.replace.type=Replace Type java.completion.tag={0, choice, 1#Tag:|2#Tags:} intention.family.name.dismiss=Dismiss intention.family.name.ignore.project=Do not show again in this project fix.move.to.source.root=Move to source root warning.java.file.outside.source.root=Java file is located outside of the module source root, so it won't be compiled inspection.message.snippet.file.not.found=Snippet file ''{0}'' is not found inspection.message.snippet.region.not.found=Region is not found javadoc.snippet.not.found=Snippet not found: {0} javadoc.snippet.region.not.found=Region not found: {0} javadoc.snippet.error.unknown.enum.value=@{0}: unknown {1} ''{2}''; only {3} are supported javadoc.snippet.error.markup.tag.expected=Markup tag or attribute expected javadoc.snippet.error.unsupported.attribute=@{0}: unsupported attribute: ''{1}'' javadoc.snippet.error.duplicate.attribute=@{0}: duplicate attribute: ''{1}'' javadoc.snippet.error.missing.required.attribute=@{0}: missing ''{1}'' attribute javadoc.snippet.error.both.substring.and.regex=@{0}: either regex or substring should be specified but not both javadoc.snippet.error.malformed.regular.expression=@{0}: malformed regular expression: {1} javadoc.snippet.error.malformed.replacement=@{0}: malformed regular expression replacement ''{1}'': {2} javadoc.snippet.error.regex.too.complex=@{0}: too complex regular expression ''{1}'' intention.family.name.synchronize.inline.snippet=Synchronize inline snippet inspection.message.external.snippet.differs.from.inline.snippet=External snippet differs from inline snippet package.chooser.modal.progress.title=Searching for packages\u2026 convert.number.hex=hex convert.number.binary=binary convert.number.octal=octal convert.number.decimal=decimal convert.number.plain.format=plain format convert.number.scientific.format=scientific format delete.initializer.completely=Delete initializer completely delete.assignment.completely=Delete assignment completely popup.title.remove.unused.variable=Remove Unused Variable intention.family.name.extract.possible.side.effects=Extract possible side effects intention.family.name.delete.possible.side.effects=Delete possible side effects intention.extract.set.from.comparison.chain.replace.only.this=Replace only this occurrence intention.extract.set.from.comparison.chain.replace.all=Replace all occurrences intention.text.replace.all.delete.import=Replace all and delete the import intention.text.replace.this.occurrence.keep.import=Replace this occurrence and keep the import popup.title.choose.target.class=Choose Target Class tooltip.incorrect.file.template=Incorrect ''{0}'' file template label.ignored.exceptions=Ignored exceptions: intention.family.name.add.main.method=Add 'main' method intention.sequenced.collection.can.be.used.display.name=SequencedCollection method can be used intention.sequenced.collection.can.be.used.fix.name=Replace with SequencedCollection method call inspection.mapping.before.count.family.name=Mapping call before count() inspection.mapping.before.count.message=The ''{0}()'' call does not change the final count and might be optimized out. unknown.library=Unknown Library intention.name.delete.method=Delete method ''{0}()'' intention.name.delete.method.title=Delete Method ''{0}()'' intention.name.delete.method.with.callees=\u2026 along with other private methods used only there intention.name.delete.method.only=\u2026 and nothing else intention.family.name.delete.private.method=Delete private method checkbox.check.for.jdk.updates=Check for JDK updates intention.family.name.rename.to.ignored=Rename to ignored tooltip.variable.used=Variable ''{0}'' is used advanced.setting.java.show.irrelevant.templates.in.source.roots=Show irrelevant New File templates in Java source roots