0.is.not.an.identifier=''{0}'' is not an identifier. annotation.name.is.missing=Annotation attribute of the form 'name=value' expected implicit.class.context.display=Compact source file anonymous.class.context.display=Anonymous in {0} anonymous.class.derived.display=Anonymous class derived from {0} aux.context.display=of {0} class.file.version=ver. {0} bound.not.expected=Unexpected bound catch.without.try='catch' without 'try' class.context.display={0} in {1} class.literal.expected=.class expected context.type.java.comment=Comment context.type.string=String default.language.level.description=SDK default # These constants are used from JavaElementKind # When localizing you may use the parameter #0 which signals the desired grammatical case: # 0 = nominative case (subject) # 1 = accusative case (object) element.abstract_method=abstract method element.annotation=annotation element.anonymous_class=anonymous class element.catch_parameter=catch parameter element.class=class element.type.parameter=type parameter element.type.parameters=type parameters element.constant=constant field element.constructor=constructor element.enum=enum element.enum_constant=enum constant element.expression=expression element.field=field element.for_parameter='for' loop parameter element.initializer=initializer element.interface=interface element.label=label element.lambda_parameter=lambda parameter element.local_variable=local variable element.method=method element.module=module element.package=package element.package.statement=package statement element.parameter=parameter element.pattern_variable=pattern variable element.record=record element.record_component=record component element.record_header=record header element.snippet_body=snippet body element.statement=statement element.unknown=element element.variable=variable element.throws.list=throws list element.extends.list=extends list element.permits.list=permits list element.type.arguments=type arguments element.type.semicolon=semicolon element.receiver.parameter=receiver parameter element.method.call=method call else.without.if='else' without 'if' enum.constant.context=Enum constant ''{0}'' in ''{1}'' expected.array.initializer=Array initializer expected expected.boolean.expression=Boolean expression expected expected.catch.or.finally='catch' or 'finally' expected expected.class.or.interface='class' or 'interface' expected expected.class.reference=Class reference expected expected.colon=':' expected expected.colon.or.arrow=':' or '->' expected expected.comma=',' expected expected.comma.or.rparen=',' or ')' expected expected.comma.or.semicolon=',' or ';' expected expected.dot='.' expected expected.eq='=' expected expected.expression=Expression expected expected.case.label.element=Expression, pattern, 'default' or 'null' expected expected.template.fragment=Template fragment expected expected.gt='>' expected. expected.gt.or.comma='>' or ',' expected expected.identifier=Identifier expected expected.identifier.or.type=Identifier or type expected expected.lbrace='{' expected expected.lbrace.or.semicolon='{' or ';' expected expected.lbracket='[' expected expected.lparen='(' expected expected.lparen.or.lbracket='(' or '[' expected expected.lt.or.lparen='<' or '(' expected expected.module.declaration=Module declaration expected expected.module.statement=Module directive expected expected.package.reference=Package reference expected expected.parameter=Parameter expected expected.parameter.or.rparen=Annotation attribute or ')' expected expected.rbrace='}' expected expected.rbracket=']' expected expected.resource=Resource definition expected expected.rparen=')' expected expected.semicolon=';' expected expected.identifier.or.semicolon=Identifier or ';' expected expected.statement=Statement expected expected.string=String literal expected expected.switch.label='case', 'default' or '}' expected expected.switch.rule=Expression, block or throw statement expected expected.type=Type expected expected.type.parameter=Type parameter expected expected.value=Value expected expected.while='while' expected expected.with='with' expected expected.pattern=Pattern expected filetype.class.description=Java class filetype.class.display.name=Java class filetype.java.module.display.name=Java module filetype.java.description=Java filetype.java.module.description=Java module filetype.jshell.description=JShell snippet finally.without.try='finally' without 'try' import.statement.identifier.or.asterisk.expected.=Identifier or '*' expected java.terms.anonymous.class.base.ref=anonymous {0} javadoc.exception.tag.class.is.not.throwable=Class {0} is not a descendant of Throwable javadoc.exception.tag.exception.is.not.thrown={0} is not declared to be thrown by method {1} javadoc.exception.tag.wrong.tag.value=Wrong tag value javadoc.param.tag.parameter.name.expected=Parameter name expected javadoc.param.tag.type.parameter.gt.expected='>' expected javadoc.param.tag.type.parameter.name.expected=Type parameter name expected javadoc.ref.tag.class.ref.expected=Class reference expected javadoc.value.field.required=@value tag must reference a field javadoc.value.field.with.initializer.required=@value tag must reference a field with a constant initializer javadoc.value.static.field.required=@value tag must reference a static field javadoc.value.tag.jdk15.required=@value tag may not have any arguments when JDK 1.4 or earlier is used local.class.preposition=local method.context.display={0}() in {1} node.abstract.flag.tooltip=Abstract node.annotation.tooltip=Annotation node.anonymous.class.tooltip=Anonymous Class node.class.tooltip=Class node.enum.tooltip=Enum node.exception.tooltip=Exception node.field.tooltip=Field node.final.flag.tooltip=Final node.interface.tooltip=Interface node.simple.source.file.tooltip=Compact source file node.junit.test.tooltip=JUnit Test node.method.tooltip=Method node.record.tooltip=Record node.runnable.class.tooltip=Runnable Class node.static.flag.tooltip=Static psi.error.attempt.to.edit.class.file=Cannot modify compiled element in file ''{0}'' task.background.title.maven=Maven unexpected.identifier=Unexpected identifier unexpected.token=Unexpected token unexpected.tokens=Unexpected tokens error.message.wildcard.not.expected=Unexpected wildcard bad.return.type.in.method.reference=Bad return type in method reference: cannot convert {0} to {1} bad.return.type.in.lambda.expression=Bad return type in lambda expression: {0} cannot be converted to {1} bad.return.type.in.lambda.expression1=Bad return type in lambda expression: {0} cannot be converted to void missing.return.value.lambda=Missing return value unexpected.return.value=Unexpected return value lambda.body.must.be.a.statement.expression=Lambda body must be a statement expression diamond.error.explicit.type.parameters.for.constructor=Cannot use diamonds with explicit type parameters for constructor diamond.error.cannot.infer.arguments=Cannot infer arguments diamond.error.cannot.infer.arguments.unable.to.resolve.constructor=Cannot infer arguments (unable to resolve constructor) diamond.error.anonymous.inner.classes=Cannot use '<>' with anonymous inner classes diamond.error.anonymous.inner.classes.non.private=Cannot use '<>' due to a non-private method which doesn't override or implement a method from a supertype diamond.error.cannot.infer.type.arguments=Cannot infer type arguments for {0} error.incompatible.type.no.type.variable=no instance(s) of type variable(s) exist so that {0} error.incompatible.type.no.type.variable.0=no instance(s) of type variable(s) {0} exist so that {1} type.conforms.to.constraint={0} conforms to {1} type.can.be.converted={0} can be converted to {1} conflicting.conjuncts={0} and {1} error.type.parameter.has.incompatible.upper.bounds=Type parameter {0} has incompatible upper bounds: {1} error.incompatible.upper.bounds=Incompatible upper bounds: {0} error.inference.variable.has.incompatible.bounds=inference variable {0} has incompatible bounds:\n {1}: {2}\n{3}: {4} error.incompatible.type={0} is not compatible with {1} error.incompatible.type.not.a.functional.interface={0} is not a functional interface error.incompatible.type.no.valid.function.type.found=No valid function type can be found for {0} error.incompatible.type.parameter.type.is.not.yet.inferred=Parameter type is not yet inferred: {0} error.incompatible.type.return.type.is.not.yet.inferred=Return type is not yet inferred: {0} error.incompatible.type.unhandled.exception=Unhandled exception: {0} error.incompatible.type.failed.to.resolve.argument=Failed to resolve argument error.incompatible.type.incompatible.parameter.types.in.lambda=Wrong number of lambda parameters: expected {0} but found {1} error.incompatible.type.incompatible.types.expected.void.lambda=Incompatible types: expected void but the lambda body is neither a statement expression nor a void-compatible block error.incompatible.type.expected.value.lambda=Incompatible types: expected not void but the lambda body is a block that is not value-compatible error.incompatible.type.bad.lambda.return.type=Bad return type in lambda expression: {0} cannot be converted to {1} error.incompatible.type.incompatible.parameter.types.in.method.reference=Incompatible parameter types in method reference expression error.incompatible.type.incompatible.types.expected.not.void.got.void.method.reference=Incompatible types: expected not void but compile-time declaration for the method reference has void return type error.incompatible.type.declaration.for.the.method.reference.not.found=No compile-time declaration for the method reference is found error.incompatible.type.expected.non.void.got.void.method.reference=Incompatible types: expected not void but compile-time declaration for the method reference has void return type error.incompatible.type.not.convertible=Incompatible types: {0} is not convertible to {1} error.incompatible.type.incompatible.equality.constraint=Incompatible equality constraint: {0} and {1} list.item.no.module= # {0} = localized element kind ('class', 'field', 'method', etc.); {1} = element name element.kind.and.name={0} {1} command.name.insert.block.statement=Insert Block Statement # suppress inspection "UnusedProperty" annotation.target.ANNOTATION_TYPE=annotation type # suppress inspection "UnusedProperty" annotation.target.CONSTRUCTOR=constructor # suppress inspection "UnusedProperty" annotation.target.FIELD=field annotation.target.LOCAL_VARIABLE=local variable # suppress inspection "UnusedProperty" annotation.target.METHOD=method # suppress inspection "UnusedProperty" annotation.target.MODULE=module # suppress inspection "UnusedProperty" annotation.target.PACKAGE=package # suppress inspection "UnusedProperty" annotation.target.PARAMETER=parameter # suppress inspection "UnusedProperty" annotation.target.RECORD_COMPONENT=record component # suppress inspection "UnusedProperty" annotation.target.TYPE=type # suppress inspection "UnusedProperty" annotation.target.TYPE_PARAMETER=type parameter # suppress inspection "UnusedProperty" annotation.target.TYPE_USE=type use