messages.JavaErrorBundle.properties Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of symbol-processing-aa Show documentation
Show all versions of symbol-processing-aa Show documentation
KSP implementation on Kotlin Analysis API
# @interface (annotation) related messages
annotation.not.allowed.here=Annotations are not allowed here
annotation.unknown.method=Cannot resolve method ''{0}''
annotation.missing.method=Cannot find method ''{0}''
annotation.illegal.array.initializer=Illegal initializer for ''{0}''
annotation.duplicate.annotation=Duplicate annotation
annotation.duplicate.attribute=Duplicate attribute ''{0}''
annotation.missing.attribute={0} missing though required
annotation.not.applicable=''@{0}'' not applicable to {1}
annotation.non.constant.attribute.value=Attribute value must be constant
annotation.non.class.literal.attribute.value=Attribute value must be a class literal
annotation.non.enum.constant.attribute.value=Attribute value must be an enum constant
annotation.invalid.annotation.member.type=Invalid type ''{0}'' for annotation member
annotation.cyclic.element.type=Cyclic annotation element type
annotation.annotation.type.expected=Annotation type expected
annotation.members.may.not.have.throws.list=@interface members may not have throws list
annotation.may.not.have.extends.list=@interface may not have extends list
annotation.not.allowed.ref=Annotation not applicable to this kind of reference
annotation.not.allowed.static=Static member qualifying type may not be annotated
annotation.not.allowed.void='void' type may not be annotated
annotation.not.allowed.var='var' type may not be annotated
annotation.not.allowed.class=Class literal type may not be annotated
annotation.container.no.value=Invalid container annotation ''{0}'': no ''value'' method declared
annotation.container.bad.type=Invalid container annotation ''{0}'': ''value'' method should have type ''{1}''
annotation.container.low.retention=Container annotation ''{0}'' has shorter retention (''{1}'') than the contained annotation
annotation.container.wide.target=Target of container annotation ''{0}'' is not a subset of target of this annotation
annotation.container.abstract=Container annotation ''{0}'' does not have a default value for ''{1}''
annotation.container.missed.annotation=Container annotation ''{0}'' does not have required @{1} annotation
annotation.duplicate.explained=Duplicate annotation. {0}
annotation.non.repeatable=The declaration of ''{0}'' does not have a valid java.lang.annotation.Repeatable annotation
annotation.container.wrong.place=Container annotation ''{0}'' must not be present at the same time as the element it contains
annotation.container.not.applicable=Container annotation ''@{0}'' is not applicable to {1}
receiver.wrong.context=Receivers are not allowed outside of method parameter list
receiver.static.context=The receiver cannot be used in a static context
receiver.wrong.position=The receiver should be the first parameter
receiver.type.mismatch=The receiver type does not match the enclosing class type
receiver.name.mismatch=The receiver name does not match the enclosing class type
# generics related messages
generics.holder.type=Type
generics.holder.method=Method
generics.inferred.type.for.type.parameter.is.not.within.its.bound.extend=Inferred type ''{2}'' for type parameter ''{0}'' is not within its bound; should extend ''{1}''
generics.inferred.type.for.type.parameter.is.not.within.its.bound.implement=Inferred type ''{2}'' for type parameter ''{0}'' is not within its bound; should implement ''{1}''
generics.type.parameter.is.not.within.its.bound.extend=Type parameter ''{0}'' is not within its bound; should extend ''{1}''
generics.type.parameter.is.not.within.its.bound.implement=Type parameter ''{0}'' is not within its bound; should implement ''{1}''
# {0} - Type (class) or Method
generics.type.or.method.does.not.have.type.parameters={0} ''{1}'' does not have type parameters
generics.wrong.number.of.type.arguments=Wrong number of type arguments: {0}; required: {1}
generics.cannot.be.inherited.with.different.type.arguments=''{0}'' cannot be inherited with different type arguments: ''{1}'' and ''{2}''
generics.cannot.be.inherited.as.raw.and.generic=''{0}'' cannot be inherited as a raw type and with generic type arguments ''{1}''
generics.select.static.class.from.parameterized.type=Cannot select static class ''{0}'' from parameterized type
generics.methods.have.same.erasure={0}; both methods have same erasure
generics.methods.have.same.erasure.override={0}; both methods have same erasure, yet neither overrides the other
generics.methods.have.same.erasure.hide={0}; both methods have same erasure, yet neither hides the other
generics.type.parameter.cannot.be.instantiated=Type parameter ''{0}'' cannot be instantiated directly
wildcard.type.cannot.be.instantiated=Wildcard type ''{0}'' cannot be instantiated directly
generics.wildcard.not.expected=No wildcard expected
generics.wildcards.may.be.used.only.as.reference.parameters=Wildcards may be used only as reference parameters
generics.type.argument.cannot.be.of.primitive.type=Type argument cannot be of primitive type
generics.unchecked.assignment=Unchecked assignment: ''{0}'' to ''{1}''
generics.unchecked.cast=Unchecked cast: ''{0}'' to ''{1}''
generics.unchecked.call.to.member.of.raw.type=Unchecked call to ''{0}'' as a member of raw type ''{1}''
generics.unchecked.call=Unchecked method ''{0}'' invocation
generics.diamond.not.applicable=Diamond operator is not applicable for non-parameterized types
generics.reference.parameters.not.allowed=Reference parameters are not allowed here
foreach.not.applicable=foreach not applicable to type ''{0}''
illegal.to.access.static.member.from.enum.constructor.or.instance.initializer=It is illegal to access static member ''{0}'' from enum constructor or instance initializer
enum.types.cannot.be.instantiated=Enum types cannot be instantiated
generic.array.creation=Generic array creation
array.creation.with.type.arguments=Cannot create array with type arguments
generics.enum.may.not.have.type.parameters=Enum may not have type parameters
generics.annotation.members.may.not.have.type.parameters=@interface members may not have type parameters
annotation.may.not.have.type.parameters=@interface may not have type parameters
generics.duplicate.type.parameter=Duplicate type parameter: ''{0}''
generics.cannot.catch.type.parameters=Cannot catch type parameters
generics.cannot.instanceof.type.parameters=Class or array expected
illegal.generic.type.for.instanceof=Illegal generic type for instanceof
unsafe.cast.in.instanceof=''{0}'' cannot be safely cast to ''{1}''
instanceof.pattern.supertype=Pattern type ''{0}'' is a supertype of expression type ''{1}''
instanceof.pattern.equals=Pattern type ''{0}'' is the same as expression type
cannot.select.dot.class.from.type.variable=Cannot select from a type variable
method.does.not.override.super=Method does not override method from its superclass
call.to.super.is.not.allowed.in.enum.constructor=Call to super is not allowed in enum constructor
bad.qualifier.in.super.method.reference.overridden=Bad type qualifier in default super call: method {0} is overridden in {1}
bad.qualifier.in.super.method.reference.extended=Bad type qualifier in default super call: redundant interface {0} is extended by {1}
vararg.not.last.parameter=Vararg parameter must be the last in the list
modifiers.for.enum.constants=No modifiers allowed for enum constants
generics.type.arguments.on.raw.type=Type arguments given on a raw type
generics.type.arguments.on.raw.method=Type arguments given on a raw method
classes.extends.prohibited.super=Classes cannot directly extend ''{0}''
unchecked.overriding.incompatible.return.type=Unchecked overriding: return type requires unchecked conversion. Found ''{0}'', required ''{1}''
interface.expected=Interface expected here
no.interface.expected=No interface expected here
class.expected=Class name expected here
implements.after.interface=No implements clause allowed for interface
extends.after.enum=No extends clause allowed for enum
permits.after.enum=No permits clause allowed for enum
class.must.be.abstract=Class ''{0}'' must either be declared abstract or implement abstract method ''{1}'' in ''{2}''
enum.constant.must.implement.method=Enum constant ''{0}'' must implement abstract method ''{1}'' in ''{2}''
class.must.implement.method=Class ''{0}'' must implement abstract method ''{1}'' in ''{2}''
abstract.cannot.be.instantiated=''{0}'' is abstract; cannot be instantiated
duplicate.class.in.other.file=Duplicate class found in the file ''{0}''
duplicate.class=Duplicate class: ''{0}''
public.class.should.be.named.after.file=Class ''{0}'' is public, should be declared in a file named ''{0}.java''
inheritance.from.final.class=Cannot inherit from {1} ''{0}''
package.name.file.path.mismatch=Package name ''{0}'' does not correspond to the file path ''{1}''
missing.package.statement=Missing package statement: ''{0}''
cyclic.inheritance=Cyclic inheritance involving ''{0}''
class.already.imported=''{0}'' is already defined in this compilation unit
class.cannot.extend.multiple.classes=Class cannot extend multiple classes
not.allowed.in.interface=Not allowed in interface
qualified.new.of.static.class=Qualified new of static class
invalid.qualified.new=Invalid qualified new
class.name.expected=Class name expected
no.enclosing.instance.in.scope=No enclosing instance of type ''{0}'' is in scope
is.not.an.enclosing.class=''{0}'' is not an enclosing class
cannot.be.referenced.from.static.context=''{0}'' cannot be referenced from a static context
no.default.constructor.available=There is no default constructor available in ''{0}''
missing.return.statement=Missing return statement
unreachable.statement=Unreachable statement
variable.not.initialized=Variable ''{0}'' might not have been initialized
variable.already.assigned=Variable ''{0}'' might already have been assigned to
variable.assigned.in.loop=Variable ''{0}'' might be assigned in loop
assignment.to.final.variable=Cannot assign a value to final variable ''{0}''
variable.must.be.final=Variable ''{0}'' is accessed from within inner class, needs to be declared final
variable.must.be.final.or.effectively.final=Variable ''{0}'' is accessed from within inner class, needs to be final or effectively final
lambda.variable.must.be.final=Variable used in lambda expression should be final or effectively final
resource.variable.must.be.final=Variable used as a try-with-resources resource should be final or effectively final
guarded.pattern.variable.must.be.final=Variable used in guarded pattern should be final or effectively final
declaration.or.variable.expected=Declaration, final or effectively final variable expected
initializer.must.be.able.to.complete.normally=Initializer must be able to complete normally
weaker.privileges={0}; attempting to assign weaker access privileges (''{1}''); was ''{2}''
incompatible.return.type=attempting to use incompatible return type
final.method.override=''{0}'' cannot override ''{1}'' in ''{2}''; overridden method is final
overridden.method.does.not.throw={0}; overridden method does not throw ''{1}''
exception.is.never.thrown=Exception ''{0}'' is never thrown in the method
wrong.method.arguments=''{0}'' in ''{1}'' cannot be applied to ''{2}''
method.call.expected=Method call expected
ambiguous.method.call=Ambiguous method call: both ''{0}'' and ''{1}'' match
ambiguous.reference=Reference to ''{0}'' is ambiguous, both ''{1}'' and ''{2}'' match
cannot.resolve.method=Cannot resolve method ''{0}''
ambiguous.method.call.no.match=Cannot resolve method ''{0}'' in ''{1}''
missing.method.body=Missing method body, or declare abstract
abstract.method.in.non.abstract.class=Abstract method in non-abstract class
missing.return.type=Invalid method declaration; return type required
duplicate.method=''{0}'' is already defined in ''{1}''
constructor.call.must.be.first.statement=Call to ''{0}'' must be first statement in constructor body
direct.abstract.method.access=Abstract method ''{0}'' cannot be accessed directly
unrelated.overriding.methods.return.types=methods have unrelated return types
overrides.deprecated.method=Overrides deprecated method in ''{0}''
overrides.marked.for.removal.method=Overrides method that is deprecated and marked for removal in ''{0}''
deprecated.default.constructor=Default constructor in ''{0}'' is deprecated
marked.for.removal.default.constructor=Default constructor in ''{0}'' is deprecated and marked for removal
recursive.constructor.invocation=Recursive constructor invocation
wrong.constructor.arguments=''{0}'' cannot be applied to ''{1}''
cannot.resolve.constructor=Cannot resolve constructor ''{0}''
invalid.package.annotation.containing.file=Package annotations should be in file package-info.java
repeated.annotation.target=Repeated annotation target
clash.methods.message=''{0}'' clashes with ''{1}''
clash.methods.message.show.classes=''{0}'' in ''{2}'' clashes with ''{1}'' in ''{3}''
package.clashes.with.class=Package ''{0}'' clashes with class of same name
class.clashes.with.package=Class ''{0}'' clashes with package of same name
# {0} - colspan, {1} - method1, {2} - class1, {3} - method2, {4} - class2
ambiguous.method.html.tooltip=\
\
Ambiguous method call. Both {1}in {2}\\ and \
{3}in {4}\\ match \
# {0} - left raw type, {1} - required type arguments row, {2} - right raw type, {3} - found type arguments row, {4} - reason, {5} - greyed title color
incompatible.types.html.tooltip=\
\
Required type: {0} {1}Provided: {2} {3}
{4}
interface.methods.cannot.have.body=Interface abstract methods cannot have body
abstract.methods.cannot.have.a.body=Abstract methods cannot have a body
native.methods.cannot.have.a.body=Native methods cannot have a body
static.methods.in.interfaces.should.have.body=Static methods in interfaces should have a body
private.methods.in.interfaces.should.have.body=Private methods in interfaces should have a body
extension.method.should.have.a.body=Extension method should have a body
extension.method.in.class=Extension methods can only be used within an interface
instance.method.cannot.override.static.method=Instance method ''{0}'' in ''{1}'' cannot override static method ''{2}'' in ''{3}''
static.method.cannot.override.instance.method=Static method ''{0}'' in ''{1}'' cannot override instance method ''{2}'' in ''{3}''
inconvertible.type.cast=Inconvertible types; cannot cast ''{0}'' to ''{1}''
variable.expected=Variable expected
binary.operator.not.applicable=Operator ''{0}'' cannot be applied to ''{1}'', ''{2}''
unary.operator.not.applicable=Operator ''{0}'' cannot be applied to ''{1}''
return.outside.method=Return outside method
return.from.void.method=Cannot return a value from a method with void result type
missing.return.value=Missing return value
return.outside.switch.expr=Return outside of enclosing switch expression
#{0} - exceptions list (comma separated), {1} - exceptions count in the list, {2} - exception source
unhandled.exceptions=Unhandled {1, choice, 0#exception|2#exceptions}: {0}
unhandled.close.exceptions=Unhandled {1, choice, 0#exception|2#exceptions} from {2}: {0}
variable.already.defined=Variable ''{0}'' is already defined in the scope
break.outside.switch.or.loop=Break outside switch or loop
yield.unexpected=Yield outside of switch expression
yield.void=Expression type should not be 'void'
break.outside.switch.expr=Break out of switch expression is not allowed
continue.outside.loop=Continue outside of loop
continue.outside.switch.expr=Continue outside of enclosing switch expression
class.member.declared.outside=Class member declared outside of a class
not.loop.label=Not a loop label: ''{0}''
incompatible.modifiers=Illegal combination of modifiers: ''{0}'' and ''{1}''
modifier.not.allowed=Modifier ''{0}'' not allowed here
exception.never.thrown.try=Exception ''{0}'' is never thrown in the corresponding try block
exception.already.caught.warn=Unreachable section: {1, choice, 0#exception|2#exceptions} ''{0}'' {1, choice, 0#has|2#have} already been caught
not.a.statement=Not a statement
invalid.statement=Invalid statement
incompatible.types=Incompatible types. Found: ''{1}'', required: ''{0}''
unexpected.type=Unexpected type. Found: ''{1}'', required: ''{0}''
incompatible.types.reason.ambiguous.method.reference=
reason: method reference is ambiguous: both ''{0}'' and ''{1}'' match
incompatible.switch.null.type=''{0}'' cannot be converted to ''{1}''
inaccessible.type=''{0}'' is inaccessible here
valid.switch.selector.types=byte, char, short or int
valid.switch.17.selector.types=char, byte, short, int, Character, Byte, Short, Integer, String, or an enum
switch.illegal.fall.through.from=Illegal fall-through from a pattern
switch.illegal.fall.through.to=Illegal fall-through to a pattern
switch.dominance.of.preceding.label=Label is dominated by a preceding case label ''{0}''
switch.total.pattern.and.default.exist='switch' has both a total pattern and a default label
switch.class.or.array.type.expected=class or array
switch.invalid.selector.types=Selector type of ''{0}'' is not supported
dot.expected.after.super.or.this='.' expected
unqualified.super.disallowed=Unqualified super reference is not allowed in extension method
static.interface.method.call.qualifier=Static method may be invoked on containing interface class only
non.static.symbol.referenced.from.static.context=Non-static {0} ''{1}'' cannot be referenced from a static context
private.symbol=''{0}'' has private access in ''{1}''
protected.symbol=''{0}'' has protected access in ''{1}''
package.local.symbol=''{0}'' is not public in ''{1}''. Cannot be accessed from outside package
visibility.access.problem=Cannot access ''{0}'' in ''{1}''
visibility.module.access.problem=Access to ''{0}'' in ''{1}'' is prevented by {2}
array.type.expected=Array type expected; found: ''{0}''
type.pattern.expected=Type pattern expected
expression.expected=Expression expected
array.initializer.not.allowed=Array initializer is not allowed here
case.statement.outside.switch=Case statement outside switch
qualified.enum.constant.in.switch=An enum switch case label must be the unqualified name of an enumeration constant
constant.expression.required=Constant expression required
switch.constant.expression.required=Constant expression, pattern or null is required
duplicate.total.pattern.label=Duplicate total pattern
duplicate.default.switch.label=Duplicate default label
duplicate.switch.label=Duplicate label ''{0}''
switch.expr.empty='switch' expression does not have any case clauses
switch.statement.empty='switch' statement does not have any case clauses
switch.expr.incomplete='switch' expression does not cover all possible input values
switch.statement.incomplete='switch' statement does not cover all possible input values
switch.expr.no.result=Switch expression does not have any result expressions
switch.expr.should.produce.result=Switch expression should produce result in all execution paths
switch.expr.rule.should.produce.result=Switch expression rule should produce result in all execution paths
illegal.forward.reference=Illegal forward reference
illegal.self.reference=Illegal self reference
unknown.class=Unknown class: ''{0}''
illegal.type.void=Illegal type: 'void'
member.referenced.before.constructor.called=Cannot reference ''{0}'' before supertype constructor has been called
label.without.statement=Label without statement
duplicate.label=Label ''{0}'' already in use
unclosed.comment=Unclosed comment
exception.already.caught=Exception ''{0}'' has already been caught
exception.must.be.disjoint=Types in multi-catch must be disjoint: ''{0}'' is a subclass of ''{1}''
statement.must.be.prepended.with.case.label=Statement must be prepended with case label
different.case.kinds.in.switch=Different case kinds used in the switch
void.type.is.not.allowed='void' type is not allowed here
single.import.class.conflict=''{0}'' is already defined in a single-type import
numeric.overflow.in.expression=Numeric overflow in expression
static.member.accessed.via.instance.reference=Static member ''{0}.{1}'' accessed via instance reference
unresolved.label=Undefined label: ''{0}''
deprecated.symbol=''{0}'' is deprecated
marked.for.removal.symbol=''{0}'' is deprecated and marked for removal
qualifier.must.be.expression=Qualifier must be an expression
cannot.resolve.symbol=Cannot resolve symbol ''{0}''
class.is.already.defined.in.single.static.import=Class ''{0}'' is already defined in a single static import
class.is.ambiguous.in.single.static.import=Class ''{0}'' is ambiguous in a single static import
field.is.already.defined.in.single.static.import=Field ''{0}'' is already defined in a single static import
field.is.ambiguous.in.single.static.import=Field ''{0}'' is ambiguous in a single static import
annotation.interface.members.may.not.have.parameters=@interface members may not have parameters
class.in.default.package=Class ''{0}'' is in the default package
local.variable.is.never.used=Variable ''{0}'' is never used
local.variable.is.not.used.for.reading=Variable ''{0}'' is assigned but never accessed
local.variable.is.not.assigned=Variable ''{0}'' is never assigned
private.field.is.not.used=Private field ''{0}'' is never used
field.is.not.used=Field ''{0}'' is never used
field.is.not.used.for.reading={0} field ''{1}'' is assigned but never accessed
private.field.is.not.assigned=Private field ''{0}'' is never assigned
parameter.is.not.used=Parameter ''{0}'' is never used
parameter.excluding.hierarchy.disable.text=Do not highlight parameters for inherited methods
pattern.variable.is.not.used=Pattern variable ''{0}'' is never used
private.method.is.not.used=Private method ''{0}'' is never used
method.is.not.used=Method ''{0}'' is never used
constructor.is.not.used=Constructor ''{0}'' is never used
private.constructor.is.not.used=Private constructor ''{0}'' is never used
private.inner.class.is.not.used=Private inner class ''{0}'' is never used
private.inner.interface.is.not.used=Private inner interface ''{0}'' is never used
type.parameter.is.not.used=Type parameter ''{0}'' is never used
local.class.is.not.used=Local class ''{0}'' is never used
class.is.not.used=Class ''{0}'' is never used
interface.is.not.used=Interface ''{0}'' is never used
enum.is.not.used=Enum ''{0}'' is never used
hexadecimal.numbers.must.contain.at.least.one.hexadecimal.digit=Hexadecimal numbers must contain at least one hexadecimal digit
binary.numbers.must.contain.at.least.one.hexadecimal.digit=Binary numbers must contain at least one binary digit
integer.number.too.large=Integer number too large
long.number.too.large=Long number too large
malformed.floating.point.literal=Malformed floating point literal
illegal.escape.character.in.character.literal=Illegal escape character in character literal
too.many.characters.in.character.literal=Too many characters in character literal
empty.character.literal=Empty character literal
illegal.line.end.in.string.literal=Illegal line end in string literal
unclosed.char.literal=Unclosed character literal
illegal.escape.character.in.string.literal=Illegal escape character in string literal
floating.point.number.too.large=Floating point number too large
floating.point.number.too.small=Floating point number too small
illegal.underscore=Illegal underscore
text.block.new.line=Illegal text block start: missing new line after opening quotes
text.block.unclosed=Unclosed text block
# suppress inspection "UnusedProperty"
expected.identifier=Identifier expected
# suppress inspection "UnusedProperty"
unexpected.token=Unexpected token
expected.identifier.or.type=Identifier or type expected
# suppress inspection "UnusedProperty"
expected.rbracket=']' expected
# suppress inspection "UnusedProperty"
expected.expression=Expression expected
expected.semicolon=';' expected
# suppress inspection "UnusedProperty"
expected.lparen='(' expected
# suppress inspection "UnusedProperty"
expected.rparen=')' expected
# suppress inspection "UnusedProperty"
expected.rbrace='}' expected
# suppress inspection "UnusedProperty"
expected.lbrace='{' expected
expected.parameter=Parameter expected
expected.comma=',' expected
# suppress inspection "UnusedProperty"
expected.lparen.or.lbracket='(' or '[' expected
# suppress inspection "UnusedProperty"
else.without.if='else' without 'if'
# suppress inspection "UnusedProperty"
catch.without.try='catch' without 'try'
# suppress inspection "UnusedProperty"
finally.without.try='finally' without 'try'
# suppress inspection "UnusedProperty"
expected.statement=Statement expected
# suppress inspection "UnusedProperty"
expected.while='while' expected
# suppress inspection "UnusedProperty"
expected.catch.or.finally='catch' or 'finally' expected
# suppress inspection "UnusedProperty"
expected.boolean.expression=Boolean expression expected
# suppress inspection "UnusedProperty"
expected.switch.label='case', 'default' or '}' expected
# suppress inspection "UnusedProperty"
expected.switch.rule=Expression, block or throw statement expected
error.cannot.resolve.class=Cannot resolve class ''{0}''
error.cannot.resolve.class.or.package=Cannot resolve class or package ''{0}''
expected.class.or.package=Expected class or package
suspicious.name.assignment=''{0}'' should probably not be assigned to ''{1}''
suspicious.name.parameter=''{0}'' should probably not be passed as parameter ''{1}''
suspicious.name.return=''{0}'' should probably not be returned from method ''{1}''
type.parameter.cannot.be.followed.by.other.bounds=Type parameter cannot be followed by other bounds
generic.extend.exception=Generic class may not extend 'java.lang.Throwable'
illegal.initializer=Illegal initializer for ''{0}''
class.cannot.inherit.from.its.type.parameter=Class cannot inherit from its type parameter
cannot.resolve.package=Cannot resolve package {0}
override.not.allowed.in.interfaces=@Override is not allowed when implementing interface method
declaration.not.allowed=Declaration not allowed here
underscore.identifier.error=As of Java 9, '_' is a keyword, and may not be used as an identifier
underscore.lambda.identifier=Use of '_' as a lambda parameter name is not allowed
assert.identifier.warn=Use of 'assert' as an identifier is not supported in releases since Java 1.4
enum.identifier.warn=Use of 'enum' as an identifier is not supported in releases since Java 1.5
underscore.identifier.warn=Use of '_' as an identifier is not supported in releases since Java 9
# {0} = restricted identifier, like 'var', {1} = java version like '10'
restricted.identifier.warn=Use of ''{0}'' as a class name is not supported in releases since Java {1}
module.unwanted.modifier.warn=Modifiers on 'requires java.base' are prohibited in releases since Java 10
yield.unqualified.method.warn=Unqualified call to 'yield' method is not supported in releases since Java 14
module.no.package=A module file should not have 'package' statement
module.file.wrong.name=Module declaration should be in a file named 'module-info.java'
module.file.duplicate='module-info.java' already exists in the module
module.duplicate.requires=Duplicate ''requires'': {0}
module.duplicate.exports=Duplicate ''exports'': {0}
module.duplicate.opens=Duplicate ''opens'': {0}
module.duplicate.uses=Duplicate ''uses'': {0}
module.duplicate.provides=Duplicate ''provides'': {0}
module.duplicate.exports.target=Duplicate ''exports'' target: {0}
module.duplicate.opens.target=Duplicate ''opens'' target: {0}
module.duplicate.impl=Duplicate implementation: {0}
module.file.wrong.location=Module declaration should be located in a module's source root
module.open.duplicate.text=Go to duplicate
module.not.found=Module not found: {0}
module.ambiguous=Ambiguous module reference: {0}
module.not.on.path=Module is not in dependencies: {0}
module.cyclic.dependence=Cyclic dependence: {0}
module.opens.in.weak.module='opens' is not allowed in an open module
package.not.found=Package not found: {0}
package.is.empty=Package is empty: {0}
module.service.enum=The service definition is an enum: {0}
module.service.alien=The service implementation must be defined in the same module as the provides directive
module.service.impl=The service implementation type must be a subtype of the service interface type, or have a public static no-args 'provider' method
module.service.abstract=The service implementation is an abstract class: {0}
module.service.inner=The service implementation is an inner class: {0}
module.service.no.ctor=The service implementation does not have a public default constructor: {0}
module.service.provider.type=The ''provider'' method return type must be a subtype of the service interface type: {0}
module.service.unused=Service interface provided but not exported or used
module.conflicting.reads=Module ''{0}'' reads package ''{1}'' from both ''{2}'' and ''{3}''
module.conflicting.packages=Package ''{0}'' exists in another module: {1}
module.access.to.unnamed=Package ''{0}'' is declared in the unnamed module, but module ''{1}'' does not read it
module.access.from.named=Package ''{0}'' is declared in module ''{1}'', which does not export it to module ''{2}''
module.access.from.unnamed=Package ''{0}'' is declared in module ''{1}'', which does not export it to the unnamed module
module.access.does.not.read=Package ''{0}'' is declared in module ''{1}'', but module ''{2}'' does not read it
module.access.not.in.graph=Package ''{0}'' is declared in module ''{1}'', which is not in the module graph
module.access.bad.name=Package ''{0}'' is declared in module with an invalid name (''{1}'')
restricted.identifier=''{0}'' is a restricted identifier and cannot be used for type declarations
restricted.identifier.reference=Illegal reference to restricted type ''{0}''
lvti.no.initializer=Cannot infer type: 'var' on variable without initializer
lvti.lambda=Cannot infer type: lambda expression requires an explicit target type
lvti.method.ref=Cannot infer type: method reference requires an explicit target type
lvti.compound='var' is not allowed in a compound declaration
lvti.array='var' is not allowed as an element type of an array
lvti.null=Cannot infer type: variable initializer is 'null'
lvti.void=Cannot infer type: variable initializer is 'void'
lvti.selfReferenced=Cannot infer type: variable initializer is self-referencing
record.no.header=Record has no header declared
record.header.regular.class=Record header declared for non-record
record.extends=No extends clause allowed for record
record.component.vararg.not.last=Vararg record component must be the last in the list
record.component.cstyle.declaration=C-style record component declaration is not allowed
record.component.restricted.name=Illegal record component name ''{0}''
record.instance.initializer=Instance initializer is not allowed in record
record.instance.field=Instance field is not allowed in record
record.accessor.wrong.return.type=Incorrect component accessor return type. Expected: ''{0}'', found: ''{1}''
record.canonical.constructor.wrong.parameter.type=Incorrect parameter type for record component ''{0}''. Expected: ''{1}'', found: ''{2}''
record.canonical.constructor.wrong.parameter.name=Canonical constructor parameter names must match record component names. Expected: ''{0}'', found: ''{1}''
record.constructor.call.in.canonical=Canonical constructor cannot delegate to another constructor
record.no.constructor.call.in.non.canonical=Non-canonical record constructor must delegate to another constructor
record.special.method.type.parameters={0} cannot have type parameters
record.special.method.non.public={0} must be ''public''
record.special.method.stronger.access={0} access level cannot be more restrictive than the record access level (''{1}'')
record.special.method.throws={0} cannot declare thrown exceptions
record.canonical.constructor=Canonical constructor
record.compact.constructor=Compact constructor
record.accessor=Record component accessor
record.component.not.initialized=Record component ''{0}'' might not be initialized in canonical constructor
compact.constructor.in.regular.class=Parameter list expected
record.compact.constructor.return='return' statement is not allowed in compact constructor
record.permits=No permits clause allowed for record
insufficient.language.level={0} are not supported at language level ''{1}''
cannot.select.from.a.type.parameter=Cannot select from a type parameter
method.reference.expression.is.not.expected=Method reference expression is not expected here
not.a.functional.interface={0} is not a functional interface
cannot.find.class=Cannot find class {0}
cannot.infer.functional.interface.type=Cannot infer functional interface type
lambda.expression.not.expected=Lambda expression not expected here
lambda.parameters.consistency.message=Cannot mix 'var' and explicitly typed parameters in lambda expression
target.method.is.generic=Target method is generic
multiple.non.overriding.abstract.methods.found.in.0=Multiple non-overriding abstract methods found in {0}
multiple.non.overriding.abstract.methods.found.in.interface.0=Multiple non-overriding abstract methods found in interface {0}
no.target.method.found=No target method found
target.type.of.a.lambda.conversion.must.be.an.interface=Target type of a lambda conversion must be an interface
incompatible.parameter.types.in.lambda=Incompatible parameter types in lambda expression: expected {0} but found {1}
incompatible.parameter.types.in.lambda.wrong.number.of.parameters=Incompatible parameter types in lambda expression: wrong number of parameters: expected {0} but found {1}
an.enclosing.instance.of.type.not.in.scope.method.reference.context=An enclosing instance of type {0} is not in scope
parameterized.qualifier.on.static.method.reference.context=Parameterized qualifier on static method reference
static.method.referenced.through.receiver.method.reference.context=Static method referenced through receiver
static.method.referenced.through.non.static.qualifier.method.reference.context=Static method referenced through non-static qualifier
non.static.method.cannot.be.referenced.from.a.static.context.method.reference.context=Non-static method cannot be referenced from a static context
abstract.method.0.cannot.be.accessed.directly.method.reference.context=Abstract method ''{0}'' cannot be accessed directly
error.interface.member.clashes=@interface member clashes with ''{0}'' in {1}
anonymous.class.implements.interface.cannot.have.type.arguments=Anonymous class implements interface; cannot have type arguments
formal.varargs.element.type.inaccessible.here=Formal varargs element type {0} is inaccessible here
unexpected.type.class.expected=Unexpected type: class is expected
repeated.interface=Repeated interface
class.cannot.be.inherited.with.different.arguments={0} cannot be inherited with different arguments: {1}
bad.type.in.switch.expression=Bad type in switch expression: {0} cannot be converted to {1}
switch.expression.cannot.be.void=Target type for switch expression cannot be void
annotation.on.static.member.qualifying.type.family.name=Move type annotation
not.inner.class=''{0}'' is not an inner class
anonymous.class.implements.interface.cannot.have.qualifier=Anonymous class implements interface; cannot have qualifier for new
qualified.class.reference.not.allowed.in.qualified.new=Qualified class reference is not allowed in qualified new
actual.type.argument.contradict.inferred.type=Actual type argument and inferred type contradict each other
default.method.overrides.object.member=Default method ''{0}'' overrides a member of ''java.lang.Object''
two.methods.are.inherited.with.same.signature=Methods {0} from {1} and {2} from {3} are inherited with the same signature
cannot.select.from.parameterized.type=Cannot select from parameterized type
safevarargs.not.allowed.non.final.instance.methods=@SafeVarargs is not allowed on non-final instance methods
safevarargs.not.suppress.potentially.unsafe.operations=@SafeVarargs do not suppress potentially unsafe operations
safevarargs.not.applicable.for.reifiable.types=@SafeVarargs is not applicable for reifiable types
type.parameter.has.incompatible.upper.bounds=Type parameter {0} has incompatible upper bounds: {1}
safevarargs.not.allowed.on.methods.with.fixed.arity=@SafeVarargs is not allowed on methods with fixed arity
functional.interface.must.not.be.sealed.error.description=Functional interface can''t be declared as ''{0}''
sealed.type.inheritor.expected.modifiers={0}, {1} or {2} modifiers expected
not.allowed.in.sealed.hierarchy={0} is not allowed in the sealed hierarchy
invalid.permits.clause=Invalid permits clause: ''{0}'' must be sealed
invalid.permits.clause.direct.implementation=Invalid permits clause: ''{0}'' must directly {1, choice, 1#extend|2#implement} ''{2}''
sealed.must.have.inheritors=Sealed class must have subclasses
permit.list.must.contain.outside.inheritors=Sealed class permits clause must contain all subclasses
permitted.subclass.must.have.modifier=All sealed class subclasses must either be final, sealed or non-sealed
permits.list.generics.are.not.allowed=Generics are not allowed in permits list
sealed.cannot.be.functional.interface=Sealed class can not be used as functional interface
local.classes.must.not.extend.sealed.classes=Local classes must not extend sealed classes
anonymous.classes.must.not.extend.sealed.classes=Anonymous classes must not extend sealed classes
class.not.allowed.to.extend.sealed.class.from.another.package=Class is not allowed to extend sealed class from another package
class.not.allowed.to.extend.sealed.class.from.another.module=Class is not allowed to extend sealed class from another module
annotation.cannot.be.local=Local annotations are not allowed
create.class.action.this.not.valid.java.qualified.name=This is not a valid Java qualified name
text.class.inherits.abstract.and.default={0} inherits abstract and default for {1} from types {2} and {3}
text.class.inherits.unrelated.defaults={0} inherits unrelated defaults for {1} from types {2}
text.improper.formed.type=Improper formed type; some type parameters are missing
text.class.is.not.accessible={0} is not accessible in current context
text.class.cannot.access=Cannot access {0}
auto.closeable.resource=auto-closeable resource
annotation.type.permits=No permits clause allowed for annotation type
safevararg.annotation.cannot.be.applied.for.record.component=@SafeVarargs annotation cannot be applied for a record component