com.sun.tools.javac.resources.compiler.properties Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jdk.compiler Show documentation
Show all versions of jdk.compiler Show documentation
Maven repackaging of OpenJDK's jdk.compiler module
The newest version!
#
# Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License version 2 only, as
# published by the Free Software Foundation. Oracle designates this
# particular file as subject to the "Classpath" exception as provided
# by Oracle in the LICENSE file that accompanied this code.
#
# This code is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
# version 2 for more details (a copy is included in the LICENSE file that
# accompanied this code).
#
# You should have received a copy of the GNU General Public License version
# 2 along with this work; if not, write to the Free Software Foundation,
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
# or visit www.oracle.com if you need additional information or have any
# questions.
#
# Messages in this file which use "placeholders" for values (e.g. {0}, {1})
# are preceded by a stylized comment describing the type of the corresponding
# values.
# The types currently in use are
#
# boolean true or false
# file name the name of an input file; e.g. MyFile.java
# message segment a sub-message; see compiler.misc.*
# modifier a Java modifier; e.g. public, private, protected
# name a name, typically a Java identifier
# number an integer
# option name the name of a command line option
# source version a source version number, such as 1.5, 1.6, 1.7
# string a general string
# symbol the name of a declared type
# symbol kind a description of the kind of a declaration; see compiler.misc.kindname.*
# token the name of a non-terminal in source code; see compiler.misc.token.*
# type a Java type; e.g. int, X, X
# unused the value is not used in this message
#
# list of X a comma-separated list of items; e.g. list of type
# X or Y alternation; e.g. message segment or type
# set of X a comma-separated collection of items; e.g. set of modifier
#
# These may be composed: e.g. list of type or message segment
#
# These comments are verified by the jtreg test test/tools/javac/diags/MessageInfo,
# using info derived from the collected set of examples in test/tools/javac/diags/examples.
# MessageInfo can also be run as a standalone utility providing more facilities
# for manipulating this file. For more details, see MessageInfo.java.
##
## errors
##
# 0: symbol
compiler.err.abstract.cant.be.instantiated=\
{0} is abstract; cannot be instantiated
compiler.err.abstract.meth.cant.have.body=\
abstract methods cannot have a body
compiler.err.already.annotated=\
{0} {1} has already been annotated
# 0: symbol kind, 1: symbol, 2: symbol kind, 3: symbol
compiler.err.already.defined=\
{0} {1} is already defined in {2} {3}
# 0: symbol kind, 1: symbol, 2: symbol kind, 3: symbol kind, 4: symbol
compiler.err.already.defined.in.clinit=\
{0} {1} is already defined in {2} of {3} {4}
# 0: string
compiler.err.already.defined.single.import=\
a type with the same simple name is already defined by the single-type-import of {0}
# 0: string
compiler.err.already.defined.static.single.import=\
a type with the same simple name is already defined by the static single-type-import of {0}
compiler.err.already.defined.this.unit=\
{0} is already defined in this compilation unit
# 0: type, 1: list of name
compiler.err.annotation.missing.default.value=\
annotation @{0} is missing a default value for the element ''{1}''
# 0: type, 1: list of name
compiler.err.annotation.missing.default.value.1=\
annotation @{0} is missing default values for elements {1}
# 0: type
compiler.err.annotation.not.valid.for.type=\
annotation not valid for an element of type {0}
compiler.err.annotation.type.not.applicable=\
annotation type not applicable to this kind of declaration
compiler.err.annotation.value.must.be.annotation=\
annotation value must be an annotation
compiler.err.annotation.value.must.be.class.literal=\
annotation value must be a class literal
compiler.err.annotation.value.must.be.name.value=\
annotation values must be of the form ''name=value''
compiler.err.annotation.value.not.allowable.type=\
annotation value not of an allowable type
compiler.err.anon.class.impl.intf.no.args=\
anonymous class implements interface; cannot have arguments
compiler.err.anon.class.impl.intf.no.typeargs=\
anonymous class implements interface; cannot have type arguments
compiler.err.anon.class.impl.intf.no.qual.for.new=\
anonymous class implements interface; cannot have qualifier for new
# 0: symbol, 1: symbol, 2: symbol
compiler.err.array.and.varargs=\
cannot declare both {0} and {1} in {2}
compiler.err.array.dimension.missing=\
array dimension missing
# 0: type
compiler.err.array.req.but.found=\
array required, but {0} found
compiler.err.attribute.value.must.be.constant=\
element value must be a constant expression
# 0: statement type
compiler.err.bad.initializer=\
bad initializer for {0}
compiler.err.break.outside.switch.loop=\
break outside switch or loop
# 0: name
compiler.err.call.must.be.first.stmt.in.ctor=\
call to {0} must be first statement in constructor
# 0: symbol kind, 1: name, 2: list of type or message segment, 3: list of type or message segment, 4: symbol kind, 5: type, 6: message segment
compiler.err.cant.apply.symbol=\
{0} {1} in {4} {5} cannot be applied to given types;\n\
required: {2}\n\
found: {3}\n\
reason: {6}
# 0: symbol kind, 1: name, 2: list of type
compiler.err.cant.apply.symbols=\
no suitable {0} found for {1}({2})
# 0: symbol kind, 1: name, 2: list of type or message segment, 3: list of type or message segment, 4: symbol kind, 5: type, 6: message segment
compiler.misc.cant.apply.symbol=\
{0} {1} in {4} {5} cannot be applied to given types\n\
required: {2}\n\
found: {3}\n\
reason: {6}
# 0: symbol kind, 1: name, 2: list of type
compiler.misc.cant.apply.symbols=\
no suitable {0} found for {1}({2})
# 0: symbol kind, 1: symbol
compiler.misc.no.abstracts=\
no abstract method found in {0} {1}
# 0: symbol kind, 1: symbol
compiler.misc.incompatible.abstracts=\
multiple non-overriding abstract methods found in {0} {1}
compiler.err.bad.functional.intf.anno=\
Unexpected @FunctionalInterface annotation
# 0: message segment
compiler.err.bad.functional.intf.anno.1=\
Unexpected @FunctionalInterface annotation\n\
{0}
# 0: symbol
compiler.misc.not.a.functional.intf=\
{0} is not a functional interface
# 0: symbol, 1: message segment
compiler.misc.not.a.functional.intf.1=\
{0} is not a functional interface\n\
{1}
# 0: symbol, 1: symbol kind, 2: symbol
compiler.misc.invalid.generic.lambda.target=\
invalid functional descriptor for lambda expression\n\
method {0} in {1} {2} is generic
# 0: symbol kind, 1: symbol
compiler.misc.incompatible.descs.in.functional.intf=\
incompatible function descriptors found in {0} {1}
# 0: name, 1: list of type, 2: type, 3: list of type
compiler.misc.descriptor=\
descriptor: {2} {0}({1})
# 0: name, 1: list of type, 2: type, 3: list of type
compiler.misc.descriptor.throws=\
descriptor: {2} {0}({1}) throws {3}
# 0: type
compiler.misc.no.suitable.functional.intf.inst=\
cannot infer functional interface descriptor for {0}
# 0: message segment
compiler.misc.bad.intersection.target.for.functional.expr=\
bad intersection type target for lambda or method reference\n\
{0}
# 0: symbol or type
compiler.misc.not.an.intf.component=\
component type {0} is not an interface
# 0: symbol kind, 1: message segment
compiler.err.invalid.mref=\
invalid {0} reference\n\
{1}
# 0: symbol kind, 1: message segment
compiler.misc.invalid.mref=\
invalid {0} reference\n\
{1}
compiler.misc.static.mref.with.targs=\
parameterized qualifier on static method reference
compiler.misc.static.bound.mref=\
static bound method reference
# 0: symbol
compiler.err.cant.assign.val.to.final.var=\
cannot assign a value to final variable {0}
# 0: symbol, 1: message segment
compiler.err.cant.ref.non.effectively.final.var=\
local variables referenced from {1} must be final or effectively final
compiler.misc.lambda=\
a lambda expression
compiler.misc.inner.cls=\
an inner class
# 0: type
compiler.err.cant.deref=\
{0} cannot be dereferenced
compiler.err.cant.extend.intf.annotation=\
''extends'' not allowed for @interfaces
# 0: symbol
compiler.err.cant.inherit.from.final=\
cannot inherit from final {0}
# 0: symbol
compiler.err.cant.ref.before.ctor.called=\
cannot reference {0} before supertype constructor has been called
compiler.err.cant.select.static.class.from.param.type=\
cannot select a static class from a parameterized type
# 0: symbol, 1: string, 2: string
compiler.err.cant.inherit.diff.arg=\
{0} cannot be inherited with different arguments: <{1}> and <{2}>
compiler.err.catch.without.try=\
''catch'' without ''try''
# 0: symbol kind, 1: symbol
compiler.err.clash.with.pkg.of.same.name=\
{0} {1} clashes with package of same name
compiler.err.class.not.allowed=\
class, interface or enum declaration not allowed here
compiler.err.const.expr.req=\
constant expression required
compiler.err.cont.outside.loop=\
continue outside of loop
# 0: symbol
compiler.err.cyclic.inheritance=\
cyclic inheritance involving {0}
# 0: symbol
compiler.err.cyclic.annotation.element=\
type of element {0} is cyclic
# 0: unused
compiler.err.call.to.super.not.allowed.in.enum.ctor=\
call to super not allowed in enum constructor
# 0: type
compiler.err.no.superclass=\
{0} has no superclass.
# 0: symbol, 1: type, 2: symbol, 3: type, 4: unused
compiler.err.concrete.inheritance.conflict=\
methods {0} from {1} and {2} from {3} are inherited with the same signature
compiler.err.default.allowed.in.intf.annotation.member=\
default value only allowed in an annotation type declaration
# 0: symbol
compiler.err.doesnt.exist=\
package {0} does not exist
# 0: type
compiler.err.duplicate.annotation.invalid.repeated=\
annotation {0} is not a valid repeatable annotation
# 0: name, 1: type
compiler.err.duplicate.annotation.member.value=\
duplicate element ''{0}'' in annotation @{1}.
# 0: name, 1: unused
compiler.err.duplicate.annotation.missing.container=\
{0} is not a repeatable annotation type
# 0: type, 1: unused
compiler.err.invalid.repeatable.annotation=\
duplicate annotation: {0} is annotated with an invalid @Repeatable annotation
# 0: symbol or type
compiler.err.invalid.repeatable.annotation.no.value=\
{0} is not a valid @Repeatable, no value element method declared
# 0: type, 1: number
compiler.err.invalid.repeatable.annotation.multiple.values=\
{0} is not a valid @Repeatable, {1} element methods named ''value'' declared
# 0: type
compiler.err.invalid.repeatable.annotation.invalid.value=\
{0} is not a valid @Repeatable: invalid value element
# 0: symbol type, 1: unused, 2: type
compiler.err.invalid.repeatable.annotation.value.return=\
containing annotation type ({0}) must declare an element named ''value'' of type {2}
# 0: symbol or type, 1: symbol
compiler.err.invalid.repeatable.annotation.elem.nondefault=\
containing annotation type ({0}) does not have a default value for element {1}
# 0: symbol, 1: unused, 2: symbol, 3: unused
compiler.err.invalid.repeatable.annotation.retention=\
retention of containing annotation type ({0}) is shorter than the retention of repeatable annotation type ({2})
# 0: symbol, 1: symbol
compiler.err.invalid.repeatable.annotation.not.documented=\
repeatable annotation type ({1}) is @Documented while containing annotation type ({0}) is not
# 0: symbol, 1: symbol
compiler.err.invalid.repeatable.annotation.not.inherited=\
repeatable annotation type ({1}) is @Inherited while containing annotation type ({0}) is not
# 0: symbol, 1: symbol
compiler.err.invalid.repeatable.annotation.incompatible.target=\
containing annotation type ({0}) is applicable to more targets than repeatable annotation type ({1})
# 0: symbol
compiler.err.invalid.repeatable.annotation.repeated.and.container.present=\
container {0} must not be present at the same time as the element it contains
# 0: name
compiler.err.duplicate.class=\
duplicate class: {0}
compiler.err.duplicate.case.label=\
duplicate case label
compiler.err.duplicate.default.label=\
duplicate default label
compiler.err.else.without.if=\
''else'' without ''if''
compiler.err.empty.char.lit=\
empty character literal
# 0: symbol
compiler.err.encl.class.required=\
an enclosing instance that contains {0} is required
compiler.err.enum.annotation.must.be.enum.constant=\
an enum annotation value must be an enum constant
compiler.err.enum.cant.be.instantiated=\
enum types may not be instantiated
compiler.err.enum.label.must.be.unqualified.enum=\
an enum switch case label must be the unqualified name of an enumeration constant
compiler.err.enum.no.subclassing=\
classes cannot directly extend java.lang.Enum
compiler.err.enum.types.not.extensible=\
enum types are not extensible
compiler.err.enum.no.finalize=\
enums cannot have finalize methods
# 0: file name, 1: string
compiler.err.error.reading.file=\
error reading {0}; {1}
# 0: type
compiler.err.except.already.caught=\
exception {0} has already been caught
# 0: type
compiler.err.except.never.thrown.in.try=\
exception {0} is never thrown in body of corresponding try statement
# 0: symbol
compiler.err.final.parameter.may.not.be.assigned=\
final parameter {0} may not be assigned
# 0: symbol
compiler.err.try.resource.may.not.be.assigned=\
auto-closeable resource {0} may not be assigned
# 0: symbol
compiler.err.multicatch.parameter.may.not.be.assigned=\
multi-catch parameter {0} may not be assigned
# 0: type, 1: type
compiler.err.multicatch.types.must.be.disjoint=\
Alternatives in a multi-catch statement cannot be related by subclassing\n\
Alternative {0} is a subclass of alternative {1}
compiler.err.finally.without.try=\
''finally'' without ''try''
# 0: type, 1: message segment
compiler.err.foreach.not.applicable.to.type=\
for-each not applicable to expression type\n\
required: {1}\n\
found: {0}
compiler.err.fp.number.too.large=\
floating point number too large
compiler.err.fp.number.too.small=\
floating point number too small
compiler.err.generic.array.creation=\
generic array creation
compiler.err.generic.throwable=\
a generic class may not extend java.lang.Throwable
# 0: symbol
compiler.err.icls.cant.have.static.decl=\
Illegal static declaration in inner class {0}\n\
modifier \''static\'' is only allowed in constant variable declarations
# 0: string
compiler.err.illegal.char=\
illegal character: ''{0}''
compiler.err.illegal.char.for.encoding=\
unmappable character for encoding {0}
# 0: set of modifier, 1: set of modifier
compiler.err.illegal.combination.of.modifiers=\
illegal combination of modifiers: {0} and {1}
compiler.err.illegal.enum.static.ref=\
illegal reference to static field from initializer
compiler.err.illegal.esc.char=\
illegal escape character
compiler.err.illegal.forward.ref=\
illegal forward reference
# 0: symbol, 1: string
compiler.err.not.in.profile=\
{0} is not available in profile ''{1}''
# 0: symbol
compiler.warn.forward.ref=\
reference to variable ''{0}'' before it has been initialized
compiler.err.illegal.self.ref=\
self-reference in initializer
# 0: symbol
compiler.warn.self.ref=\
self-reference in initializer of variable ''{0}''
compiler.err.illegal.generic.type.for.instof=\
illegal generic type for instanceof
# 0: type
compiler.err.illegal.initializer.for.type=\
illegal initializer for {0}
compiler.err.illegal.line.end.in.char.lit=\
illegal line end in character literal
compiler.err.illegal.nonascii.digit=\
illegal non-ASCII digit
compiler.err.illegal.underscore=\
illegal underscore
compiler.err.illegal.dot=\
illegal ''.''
# 0: symbol
compiler.err.illegal.qual.not.icls=\
illegal qualifier; {0} is not an inner class
compiler.err.illegal.start.of.expr=\
illegal start of expression
compiler.err.illegal.start.of.stmt=\
illegal start of statement
compiler.err.illegal.start.of.type=\
illegal start of type
compiler.err.illegal.unicode.esc=\
illegal unicode escape
# 0: symbol
compiler.err.import.requires.canonical=\
import requires canonical name for {0}
compiler.err.improperly.formed.type.param.missing=\
improperly formed type, some parameters are missing
compiler.err.improperly.formed.type.inner.raw.param=\
improperly formed type, type arguments given on a raw type
# 0: type, 1: type
compiler.err.incomparable.types=\
incomparable types: {0} and {1}
# 0: number
compiler.err.int.number.too.large=\
integer number too large: {0}
compiler.err.intf.annotation.members.cant.have.params=\
elements in annotation type declarations cannot declare formal parameters
# 0: symbol
compiler.err.intf.annotation.cant.have.type.params=\
annotation type {0} cannot be generic
compiler.err.intf.annotation.members.cant.have.type.params=\
elements in annotation type declarations cannot be generic methods
# 0: symbol, 1: type
compiler.err.intf.annotation.member.clash=\
annotation type {1} declares an element with the same name as method {0}
compiler.err.intf.expected.here=\
interface expected here
compiler.err.intf.meth.cant.have.body=\
interface abstract methods cannot have body
# 0: symbol
compiler.err.invalid.annotation.member.type=\
invalid type for element {0} of annotation type
compiler.err.invalid.binary.number=\
binary numbers must contain at least one binary digit
compiler.err.invalid.hex.number=\
hexadecimal numbers must contain at least one hexadecimal digit
compiler.err.invalid.meth.decl.ret.type.req=\
invalid method declaration; return type required
compiler.err.varargs.and.old.array.syntax=\
legacy array notation not allowed on variable-arity parameter
compiler.err.varargs.and.receiver =\
varargs notation not allowed on receiver parameter
compiler.err.array.and.receiver =\
legacy array notation not allowed on receiver parameter
compiler.err.variable.not.allowed=\
variable declaration not allowed here
# 0: name
compiler.err.label.already.in.use=\
label {0} already in use
# 0: symbol
compiler.err.local.var.accessed.from.icls.needs.final=\
local variable {0} is accessed from within inner class; needs to be declared final
compiler.err.local.enum=\
enum types must not be local
compiler.err.cannot.create.array.with.type.arguments=\
cannot create array with type arguments
compiler.err.cannot.create.array.with.diamond=\
cannot create array with ''<>''
#
# limits. We don't give the limits in the diagnostic because we expect
# them to change, yet we want to use the same diagnostic. These are all
# detected during code generation.
#
compiler.err.limit.code=\
code too large
compiler.err.limit.code.too.large.for.try.stmt=\
code too large for try statement
compiler.err.limit.dimensions=\
array type has too many dimensions
compiler.err.limit.locals=\
too many local variables
compiler.err.limit.parameters=\
too many parameters
compiler.err.limit.pool=\
too many constants
compiler.err.limit.pool.in.class=\
too many constants in class {0}
compiler.err.limit.stack=\
code requires too much stack
compiler.err.limit.string=\
constant string too long
compiler.err.limit.string.overflow=\
UTF8 representation for string \"{0}...\" is too long for the constant pool
compiler.err.malformed.fp.lit=\
malformed floating point literal
compiler.err.method.does.not.override.superclass=\
method does not override or implement a method from a supertype
compiler.err.missing.meth.body.or.decl.abstract=\
missing method body, or declare abstract
compiler.err.missing.ret.stmt=\
missing return statement
# 0: unused
compiler.misc.missing.ret.val=\
missing return value
compiler.misc.unexpected.ret.val=\
unexpected return value
# 0: set of modifier
compiler.err.mod.not.allowed.here=\
modifier {0} not allowed here
compiler.err.intf.not.allowed.here=\
interface not allowed here
compiler.err.enums.must.be.static=\
enum declarations allowed only in static contexts
# 0: symbol, 1: symbol
compiler.err.name.clash.same.erasure=\
name clash: {0} and {1} have the same erasure
# 0: symbol, 1: symbol, 2: symbol, 3: symbol, 4: unused, 5: unused
compiler.err.name.clash.same.erasure.no.override=\
name clash: {0} in {1} and {2} in {3} have the same erasure, yet neither overrides the other
# 0: symbol, 1: symbol, 2: symbol, 3: symbol, 4: symbol, 5: symbol
compiler.err.name.clash.same.erasure.no.override.1=\
name clash: {0} in {1} overrides a method whose erasure is the same as another method, yet neither overrides the other\n\
first method: {2} in {3}\n\
second method: {4} in {5}
# 0: symbol, 1: symbol, 2: symbol, 3: symbol
compiler.err.name.clash.same.erasure.no.hide=\
name clash: {0} in {1} and {2} in {3} have the same erasure, yet neither hides the other
compiler.err.name.reserved.for.internal.use=\
{0} is reserved for internal use
compiler.err.native.meth.cant.have.body=\
native methods cannot have a body
# 0: type, 1: type
compiler.err.neither.conditional.subtype=\
incompatible types for ?: neither is a subtype of the other\n\
second operand: {0}\n\
third operand : {1}
# 0: message segment
compiler.misc.incompatible.type.in.conditional=\
bad type in conditional expression\n\
{0}
compiler.misc.conditional.target.cant.be.void=\
target-type for conditional expression cannot be void
# 0: type
compiler.misc.incompatible.ret.type.in.lambda=\
bad return type in lambda expression\n\
{0}
# 0: type
compiler.misc.incompatible.ret.type.in.mref=\
bad return type in method reference\n\
{0}
# 0: list of type
compiler.err.incompatible.thrown.types.in.mref=\
incompatible thrown types {0} in method reference
compiler.misc.incompatible.arg.types.in.lambda=\
incompatible parameter types in lambda expression
compiler.misc.incompatible.arg.types.in.mref=\
incompatible parameter types in method reference
compiler.err.new.not.allowed.in.annotation=\
''new'' not allowed in an annotation
compiler.err.no.annotation.member=\
no annotation member {0} in {1}
compiler.err.no.encl.instance.of.type.in.scope=\
no enclosing instance of type {0} is in scope
compiler.err.no.intf.expected.here=\
no interface expected here
compiler.err.no.match.entry=\
{0} has no match in entry in {1}; required {2}
compiler.err.not.annotation.type=\
{0} is not an annotation type
# 0: symbol, 1: symbol
compiler.err.not.def.access.class.intf.cant.access=\
{0} in {1} is defined in an inaccessible class or interface
# 0: symbol, 1: symbol
compiler.misc.not.def.access.class.intf.cant.access=\
{0} in {1} is defined in an inaccessible class or interface
# 0: symbol, 1: list of type, 2: type
compiler.misc.cant.access.inner.cls.constr=\
cannot access constructor {0}({1})\n\
an enclosing instance of type {2} is not in scope
# 0: symbol, 1: symbol
compiler.err.not.def.public.cant.access=\
{0} is not public in {1}; cannot be accessed from outside package
# 0: symbol, 1: symbol
compiler.misc.not.def.public.cant.access=\
{0} is not public in {1}; cannot be accessed from outside package
# 0: name
compiler.err.not.loop.label=\
not a loop label: {0}
compiler.err.not.stmt=\
not a statement
# 0: symbol
compiler.err.not.encl.class=\
not an enclosing class: {0}
# 0: name, 1: type, 2: unused
compiler.err.operator.cant.be.applied=\
bad operand type {1} for unary operator ''{0}''
# 0: name, 1: type, 2: type
compiler.err.operator.cant.be.applied.1=\
bad operand types for binary operator ''{0}''\n\
first type: {1}\n\
second type: {2}
compiler.err.pkg.annotations.sb.in.package-info.java=\
package annotations should be in file package-info.java
# 0: symbol
compiler.err.pkg.clashes.with.class.of.same.name=\
package {0} clashes with class of same name
compiler.err.warnings.and.werror=\
warnings found and -Werror specified
# Errors related to annotation processing
# 0: symbol, 1: string, 2: stack-trace
compiler.err.proc.cant.access=\
cannot access {0}\n\
{1}\n\
Consult the following stack trace for details.\n\
{2}
# 0: symbol, 1: string
compiler.err.proc.cant.access.1=\
cannot access {0}\n\
{1}
# 0: string
compiler.err.proc.cant.find.class=\
Could not find class file for ''{0}''.
# Print a client-generated error message; assumed to be localized, no translation required
# 0: string
compiler.err.proc.messager=\
{0}
# 0: list of string
compiler.err.proc.no.explicit.annotation.processing.requested=\
Class names, ''{0}'', are only accepted if annotation processing is explicitly requested
compiler.err.proc.no.service=\
A ServiceLoader was not usable and is required for annotation processing.
compiler.err.proc.processor.bad.option.name=\
Bad option name ''{0}'' provided by processor ''{1}''
# 0: string
compiler.err.proc.processor.cant.instantiate=\
Could not instantiate an instance of processor ''{0}''
# 0: string
compiler.err.proc.processor.not.found=\
Annotation processor ''{0}'' not found
# 0: string
compiler.err.proc.processor.wrong.type=\
Annotation processor ''{0}'' does not implement javax.annotation.processing.Processor
compiler.err.proc.service.problem=\
Error creating a service loader to load Processors.
compiler.err.proc.bad.config.file=\
Bad service configuration file, or exception thrown while constructing Processor object: {0}
compiler.err.proc.cant.create.loader=\
Could not create class loader for annotation processors: {0}
# 0: unused
compiler.err.qualified.new.of.static.class=\
qualified new of static class
compiler.err.recursive.ctor.invocation=\
recursive constructor invocation
# 0: name, 1: symbol kind, 2: symbol, 3: symbol, 4: symbol kind, 5: symbol, 6: symbol
compiler.err.ref.ambiguous=\
reference to {0} is ambiguous\n\
both {1} {2} in {3} and {4} {5} in {6} match
# 0: name, 1: symbol kind, 2: symbol, 3: symbol, 4: symbol kind, 5: symbol, 6: symbol
compiler.misc.ref.ambiguous=\
reference to {0} is ambiguous\n\
both {1} {2} in {3} and {4} {5} in {6} match
compiler.err.repeated.annotation.target=\
repeated annotation target
compiler.err.repeated.interface=\
repeated interface
compiler.err.repeated.modifier=\
repeated modifier
# 0: symbol, 1: set of modifier, 2: symbol
compiler.err.report.access=\
{0} has {1} access in {2}
# 0: symbol, 1: set of modifier, 2: symbol
compiler.misc.report.access=\
{0} has {1} access in {2}
compiler.err.ret.outside.meth=\
return outside method
compiler.err.signature.doesnt.match.supertype=\
signature does not match {0}; incompatible supertype
compiler.err.signature.doesnt.match.intf=\
signature does not match {0}; incompatible interfaces
# 0: number, 1: number
compiler.err.method.invoked.with.incorrect.number.arguments=\
method invoked with incorrect number of arguments; expected {0}, found {1}
# 0: symbol, 1: symbol, 2: symbol
compiler.err.does.not.override.abstract=\
{0} is not abstract and does not override abstract method {1} in {2}
compiler.err.source.cant.overwrite.input.file=\
error writing source; cannot overwrite input file {0}
compiler.err.stack.sim.error=\
Internal error: stack sim error on {0}
compiler.err.static.imp.only.classes.and.interfaces=\
static import only from classes and interfaces
compiler.err.string.const.req=\
constant string expression required
# 0: symbol, 1: symbol
compiler.err.synthetic.name.conflict=\
the symbol {0} conflicts with a compiler-synthesized symbol in {1}
# 0: symbol, 1: symbol
compiler.warn.synthetic.name.conflict=\
the symbol {0} conflicts with a compiler-synthesized symbol in {1}
compiler.err.throws.not.allowed.in.intf.annotation=\
throws clause not allowed in @interface members
compiler.err.try.without.catch.or.finally=\
''try'' without ''catch'' or ''finally''
compiler.err.try.without.catch.finally.or.resource.decls=\
''try'' without ''catch'', ''finally'' or resource declarations
# 0: symbol
compiler.err.type.doesnt.take.params=\
type {0} does not take parameters
compiler.err.type.var.cant.be.deref=\
cannot select from a type variable
compiler.err.type.var.may.not.be.followed.by.other.bounds=\
a type variable may not be followed by other bounds
compiler.err.type.var.more.than.once=\
type variable {0} occurs more than once in result type of {1}; cannot be left uninstantiated
compiler.err.type.var.more.than.once.in.result=\
type variable {0} occurs more than once in type of {1}; cannot be left uninstantiated
# 0: type, 1: type, 2: string
compiler.err.types.incompatible.diff.ret=\
types {0} and {1} are incompatible; both define {2}, but with unrelated return types
# 0: kind, 1: type, 2: name, 3: list of type, 4: symbol, 5: symbol
compiler.err.types.incompatible.unrelated.defaults=\
{0} {1} inherits unrelated defaults for {2}({3}) from types {4} and {5}
# 0: kind, 1: type, 2: name, 3: list of type, 4: symbol, 5: symbol
compiler.err.types.incompatible.abstract.default=\
{0} {1} inherits abstract and default for {2}({3}) from types {4} and {5}
# 0: name, 1: kind, 2: symbol
compiler.err.default.overrides.object.member=\
default method {0} in {1} {2} overrides a member of java.lang.Object
# 0: type
compiler.err.illegal.static.intf.meth.call=\
illegal static interface method call\n\
the receiver expression should be replaced with the type qualifier ''{0}''
# 0: type, 1: message segment
compiler.err.illegal.default.super.call=\
bad type qualifier {0} in default super call\n\
{1}
# 0: symbol, 1: type
compiler.misc.overridden.default=\
method {0} is overridden in {1}
# 0: symbol, 1: type or symbol
compiler.misc.redundant.supertype=\
redundant interface {0} is extended by {1}
compiler.err.unclosed.char.lit=\
unclosed character literal
compiler.err.unclosed.comment=\
unclosed comment
compiler.err.unclosed.str.lit=\
unclosed string literal
# 0: name
compiler.err.unsupported.encoding=\
unsupported encoding: {0}
compiler.err.io.exception=\
error reading source file: {0}
# 0: name
compiler.err.undef.label=\
undefined label: {0}
# 0: message segment, 1: unused
compiler.err.cant.apply.diamond=\
cannot infer type arguments for {0}
# 0: message segment or type, 1: message segment
compiler.err.cant.apply.diamond.1=\
cannot infer type arguments for {0}\n\
reason: {1}
# 0: message segment or type, 1: message segment
compiler.misc.cant.apply.diamond.1=\
cannot infer type arguments for {0}\n\
reason: {1}
compiler.err.unreachable.stmt=\
unreachable statement
compiler.err.initializer.must.be.able.to.complete.normally=\
initializer must be able to complete normally
# 0: type
compiler.err.unreported.exception.need.to.catch.or.throw=\
unreported exception {0}; must be caught or declared to be thrown
# 0: type
compiler.err.unreported.exception.default.constructor=\
unreported exception {0} in default constructor
# 0: type, 1: name
compiler.err.unreported.exception.implicit.close=\
unreported exception {0}; must be caught or declared to be thrown\n\
exception thrown from implicit call to close() on resource variable ''{1}''
compiler.err.unsupported.cross.fp.lit=\
hexadecimal floating-point literals are not supported on this VM
compiler.err.void.not.allowed.here=\
''void'' type not allowed here
# 0: string
compiler.err.wrong.number.type.args=\
wrong number of type arguments; required {0}
# 0: symbol
compiler.err.var.might.already.be.assigned=\
variable {0} might already have been assigned
# 0: symbol
compiler.err.var.might.not.have.been.initialized=\
variable {0} might not have been initialized
# 0: symbol
compiler.err.var.not.initialized.in.default.constructor=\
variable {0} not initialized in the default constructor
# 0: symbol
compiler.err.var.might.be.assigned.in.loop=\
variable {0} might be assigned in loop
# 0: symbol, 1: message segment
compiler.err.varargs.invalid.trustme.anno=\
Invalid {0} annotation. {1}
# 0: type
compiler.misc.varargs.trustme.on.reifiable.varargs=\
Varargs element type {0} is reifiable.
# 0: symbol
compiler.misc.varargs.trustme.on.non.varargs.meth=\
Method {0} is not a varargs method.
# 0: symbol
compiler.misc.varargs.trustme.on.virtual.varargs=\
Instance method {0} is not final.
# 0: type, 1: symbol kind, 2: symbol
compiler.misc.inaccessible.varargs.type=\
formal varargs element type {0} is not accessible from {1} {2}
# In the following string, {1} will always be the detail message from
# java.io.IOException.
# 0: symbol, 1: string
compiler.err.class.cant.write=\
error while writing {0}: {1}
# In the following string, {0} is the name of the class in the Java source.
# It really should be used two times..
# 0: name
compiler.err.class.public.should.be.in.file=\
class {0} is public, should be declared in a file named {0}.java
## All errors which do not refer to a particular line in the source code are
## preceded by this string.
compiler.err.error=\
error:\u0020
# The following error messages do not refer to a line in the source code.
compiler.err.cant.read.file=\
cannot read: {0}
#####
# Fatal Errors
compiler.misc.fatal.err.no.java.lang=\
Fatal Error: Unable to find package java.lang in classpath or bootclasspath
compiler.misc.fatal.err.cant.locate.meth=\
Fatal Error: Unable to find method {0}
compiler.misc.fatal.err.cant.locate.field=\
Fatal Error: Unable to find field {0}
compiler.misc.fatal.err.cant.locate.ctor=\
Fatal Error: Unable to find constructor for {0}
compiler.misc.fatal.err.cant.close=\
Fatal Error: Cannot close compiler resources
#####
##
## miscellaneous strings
##
compiler.misc.source.unavailable=\
(source unavailable)
compiler.misc.base.membership=\
all your base class are belong to us
# 0: string, 1: string, 2: boolean
compiler.misc.x.print.processor.info=\
Processor {0} matches {1} and returns {2}.
# 0: number, 1: string, 2: set of symbol, 3: boolean
compiler.misc.x.print.rounds=\
Round {0}:\n\tinput files: {1}\n\tannotations: {2}\n\tlast round: {3}
#####
## The following string will appear before all messages keyed as:
## "compiler.note".
compiler.note.compressed.diags=\
Some messages have been simplified; recompile with -Xdiags:verbose to get full output
compiler.note.potential.lambda.found=\
This anonymous inner class creation can be turned into a lambda expression.
# 0: boolean, 1: symbol
compiler.note.lambda.stat=\
Translating lambda expression\n\
alternate metafactory = {0}\n\
synthetic method = {1}
# 0: boolean, 1: unused
compiler.note.mref.stat=\
Translating method reference\n\
alternate metafactory = {0}\n\
# 0: boolean, 1: symbol
compiler.note.mref.stat.1=\
Translating method reference\n\
alternate metafactory = {0}\n\
bridge method = {1}
compiler.note.note=\
Note:\u0020
# 0: file name
compiler.note.deprecated.filename=\
{0} uses or overrides a deprecated API.
compiler.note.deprecated.plural=\
Some input files use or override a deprecated API.
# The following string may appear after one of the above deprecation
# messages.
compiler.note.deprecated.recompile=\
Recompile with -Xlint:deprecation for details.
# 0: file name
compiler.note.deprecated.filename.additional=\
{0} has additional uses or overrides of a deprecated API.
compiler.note.deprecated.plural.additional=\
Some input files additionally use or override a deprecated API.
# 0: file name
compiler.note.unchecked.filename=\
{0} uses unchecked or unsafe operations.
compiler.note.unchecked.plural=\
Some input files use unchecked or unsafe operations.
# The following string may appear after one of the above deprecation
# messages.
compiler.note.unchecked.recompile=\
Recompile with -Xlint:unchecked for details.
# 0: file name
compiler.note.unchecked.filename.additional=\
{0} has additional unchecked or unsafe operations.
compiler.note.unchecked.plural.additional=\
Some input files additionally use unchecked or unsafe operations.
# 0: file name
compiler.note.sunapi.filename=\
{0} uses internal proprietary API that may be removed in a future release.
compiler.note.sunapi.plural=\
Some input files use internal proprietary API that may be removed in a future release.
# The following string may appear after one of the above sunapi messages.
compiler.note.sunapi.recompile=\
Recompile with -Xlint:sunapi for details.
# 0: file name
compiler.note.sunapi.filename.additional=\
{0} uses additional internal proprietary API that may be removed in a future release.
compiler.note.sunapi.plural.additional=\
Some input files additionally use internal proprietary API that may be removed in a future release.
# Notes related to annotation processing
# Print a client-generated note; assumed to be localized, no translation required
# 0: string
compiler.note.proc.messager=\
{0}
#####
# 0: number
compiler.misc.count.error=\
{0} error
# 0: number
compiler.misc.count.error.plural=\
{0} errors
# 0: number
compiler.misc.count.warn=\
{0} warning
# 0: number
compiler.misc.count.warn.plural=\
{0} warnings
compiler.misc.version.not.available=\
(version info not available)
## extra output when using -verbose (JavaCompiler)
# 0: symbol
compiler.misc.verbose.checking.attribution=\
[checking {0}]
# 0: string
compiler.misc.verbose.parsing.done=\
[parsing completed {0}ms]
# 0: file name
compiler.misc.verbose.parsing.started=\
[parsing started {0}]
# 0: string
compiler.misc.verbose.total=\
[total {0}ms]
# 0: file name
compiler.misc.verbose.wrote.file=\
[wrote {0}]
## extra output when using -verbose (Retro)
compiler.misc.verbose.retro=\
[retrofitting {0}]
compiler.misc.verbose.retro.with=\
\tretrofitting {0} with {1}
compiler.misc.verbose.retro.with.list=\
\tretrofitting {0} with type parameters {1}, supertype {2}, interfaces {3}
## extra output when using -verbose (code/ClassReader)
# 0: string
compiler.misc.verbose.loading=\
[loading {0}]
# 0: string
compiler.misc.verbose.sourcepath=\
[search path for source files: {0}]
# 0: string
compiler.misc.verbose.classpath=\
[search path for class files: {0}]
## extra output when using -checkclassfile (code/ClassReader)
compiler.misc.ccf.found.later.version=\
class file has later version than expected: {0}
compiler.misc.ccf.unrecognized.attribute=\
unrecognized attribute: {0}
## extra output when using -prompt (util/Log)
compiler.misc.resume.abort=\
R)esume, A)bort>
#####
##
## warnings
##
## All warning messages are preceded by the following string.
compiler.warn.warning=\
warning:\u0020
## Warning messages may also include the following prefix to identify a
## lint option
# 0: option name
compiler.warn.lintOption=\
[{0}]\u0020
# 0: symbol
compiler.warn.constant.SVUID=\
serialVersionUID must be constant in class {0}
# 0: file name
compiler.warn.dir.path.element.not.found=\
bad path element "{0}": no such directory
compiler.warn.finally.cannot.complete=\
finally clause cannot complete normally
# 0: symbol, 1: symbol
compiler.warn.has.been.deprecated=\
{0} in {1} has been deprecated
# 0: symbol
compiler.warn.sun.proprietary=\
{0} is internal proprietary API and may be removed in a future release
compiler.warn.illegal.char.for.encoding=\
unmappable character for encoding {0}
# 0: symbol
compiler.warn.improper.SVUID=\
serialVersionUID must be declared static final in class {0}
# 0: type, 1: type
compiler.warn.inexact.non-varargs.call=\
non-varargs call of varargs method with inexact argument type for last parameter;\n\
cast to {0} for a varargs call\n\
cast to {1} for a non-varargs call and to suppress this warning
# 0: list of type
compiler.warn.unreachable.catch=\
unreachable catch clause\n\
thrown type {0} has already been caught
# 0: list of type
compiler.warn.unreachable.catch.1=\
unreachable catch clause\n\
thrown types {0} have already been caught
# 0: symbol
compiler.warn.long.SVUID=\
serialVersionUID must be of type long in class {0}
# 0: symbol
compiler.warn.missing.SVUID=\
serializable class {0} has no definition of serialVersionUID
# 0: symbol, 1: symbol, 2: symbol, 3: symbol
compiler.warn.potentially.ambiguous.overload=\
{0} in {1} is potentially ambiguous with {2} in {3}
# 0: message segment
compiler.warn.override.varargs.missing=\
{0}; overridden method has no ''...''
# 0: message segment
compiler.warn.override.varargs.extra=\
{0}; overriding method is missing ''...''
compiler.warn.override.bridge=\
{0}; overridden method is a bridge method
# 0: symbol
compiler.warn.pkg-info.already.seen=\
a package-info.java file has already been seen for package {0}
# 0: file name
compiler.warn.path.element.not.found=\
bad path element "{0}": no such file or directory
compiler.warn.possible.fall-through.into.case=\
possible fall-through into case
# 0: type
compiler.warn.redundant.cast=\
redundant cast to {0}
# 0: number
compiler.warn.position.overflow=\
Position encoding overflows at line {0}
# 0: file name, 1: number, 2: number
compiler.warn.big.major.version=\
{0}: major version {1} is newer than {2}, the highest major version supported by this compiler.\n\
It is recommended that the compiler be upgraded.
# 0: symbol kind, 1: symbol
compiler.warn.static.not.qualified.by.type=\
static {0} should be qualified by type name, {1}, instead of by an expression
# 0: string
compiler.warn.source.no.bootclasspath=\
bootstrap class path not set in conjunction with -source {0}
# 0: string
compiler.warn.option.obsolete.source=\
source value {0} is obsolete and will be removed in a future release
# 0: string
compiler.warn.option.obsolete.target=\
target value {0} is obsolete and will be removed in a future release
compiler.warn.option.obsolete.suppression=\
To suppress warnings about obsolete options, use -Xlint:-options.
# 0: name, 1: number, 2: number, 3: number, 4: number
compiler.warn.future.attr=\
{0} attribute introduced in version {1}.{2} class files is ignored in version {3}.{4} class files
# Warnings related to annotation processing
# 0: name
compiler.warn.proc.package.does.not.exist=\
package {0} does not exist
# 0: name
compiler.warn.proc.file.reopening=\
Attempt to create a file for ''{0}'' multiple times
# 0: name
compiler.warn.proc.type.already.exists=\
A file for type ''{0}'' already exists on the sourcepath or classpath
# 0: name
compiler.warn.proc.type.recreate=\
Attempt to create a file for type ''{0}'' multiple times
# 0: string
compiler.warn.proc.illegal.file.name=\
Cannot create file for illegal name ''{0}''.
# 0: string, 1: string
compiler.warn.proc.suspicious.class.name=\
Creating file for a type whose name ends in {1}: ''{0}''
# 0: name
compiler.warn.proc.file.create.last.round=\
File for type ''{0}'' created in the last round will not be subject to annotation processing.
# 0: string, 1: string
compiler.warn.proc.malformed.supported.string=\
Malformed string ''{0}'' for a supported annotation type returned by processor ''{1}''
# 0: set of string
compiler.warn.proc.annotations.without.processors=\
No processor claimed any of these annotations: {0}
# 0: source version, 1: string, 2: string
compiler.warn.proc.processor.incompatible.source.version=\
Supported source version ''{0}'' from annotation processor ''{1}'' less than -source ''{2}''
compiler.warn.proc.proc-only.requested.no.procs=\
Annotation processing without compilation requested but no processors were found.
compiler.warn.proc.use.implicit=\
Implicitly compiled files were not subject to annotation processing.\n\
Use -implicit to specify a policy for implicit compilation.
compiler.warn.proc.use.proc.or.implicit=\
Implicitly compiled files were not subject to annotation processing.\n\
Use -proc:none to disable annotation processing or -implicit to specify a policy for implicit compilation.
# Print a client-generated warning; assumed to be localized, no translation required
# 0: string
compiler.warn.proc.messager=\
{0}
# 0: set of name
compiler.warn.proc.unclosed.type.files=\
Unclosed files for the types ''{0}''; these types will not undergo annotation processing
# 0: string
compiler.warn.proc.unmatched.processor.options=\
The following options were not recognized by any processor: ''{0}''
compiler.warn.try.explicit.close.call=\
explicit call to close() on an auto-closeable resource
# 0: symbol
compiler.warn.try.resource.not.referenced=\
auto-closeable resource {0} is never referenced in body of corresponding try statement
# 0: type
compiler.warn.try.resource.throws.interrupted.exc=\
auto-closeable resource {0} has a member method close() that could throw InterruptedException
compiler.warn.unchecked.assign=\
unchecked assignment: {0} to {1}
# 0: symbol, 1: type
compiler.warn.unchecked.assign.to.var=\
unchecked assignment to variable {0} as member of raw type {1}
# 0: symbol, 1: type
compiler.warn.unchecked.call.mbr.of.raw.type=\
unchecked call to {0} as a member of the raw type {1}
compiler.warn.unchecked.cast.to.type=\
unchecked cast to type {0}
# 0: symbol kind, 1: name, 2: list of type, 3: list of type, 4: symbol kind, 5: symbol
compiler.warn.unchecked.meth.invocation.applied=\
unchecked method invocation: {0} {1} in {4} {5} is applied to given types\n\
required: {2}\n\
found: {3}
# 0: type
compiler.warn.unchecked.generic.array.creation=\
unchecked generic array creation for varargs parameter of type {0}
# 0: type
compiler.warn.unchecked.varargs.non.reifiable.type=\
Possible heap pollution from parameterized vararg type {0}
# 0: symbol
compiler.warn.varargs.unsafe.use.varargs.param=\
Varargs method could cause heap pollution from non-reifiable varargs parameter {0}
compiler.warn.missing.deprecated.annotation=\
deprecated item is not annotated with @Deprecated
compiler.warn.invalid.archive.file=\
Unexpected file on path: {0}
compiler.warn.unexpected.archive.file=\
Unexpected extension for archive file: {0}
compiler.warn.div.zero=\
division by zero
compiler.warn.empty.if=\
empty statement after if
compiler.warn.annotation.method.not.found=\
Cannot find annotation method ''{1}()'' in type ''{0}''
compiler.warn.annotation.method.not.found.reason=\
Cannot find annotation method ''{1}()'' in type ''{0}'': {2}
# 0: symbol, 1: name
compiler.warn.unknown.enum.constant=\
unknown enum constant {1}.{2}
# 0: symbol, 1: name, 2: message segment
compiler.warn.unknown.enum.constant.reason=\
unknown enum constant {1}.{2}\n\
reason: {3}
# 0: type, 1: type
compiler.warn.raw.class.use=\
found raw type: {0}\n\
missing type arguments for generic class {1}
# 0: unused, 1: unused
compiler.warn.diamond.redundant.args=\
redundant type arguments in new expression (use diamond operator instead).
# 0: type, 1: type
compiler.warn.diamond.redundant.args.1=\
redundant type arguments in new expression (use diamond operator instead).\n\
explicit: {0}\n\
inferred: {1}
# 0: symbol, 1: message segment
compiler.warn.varargs.redundant.trustme.anno=\
Redundant {0} annotation. {1}
#####
## The following are tokens which are non-terminals in the language. They should
## be named as JLS3 calls them when translated to the appropriate language.
compiler.misc.token.identifier=\
compiler.misc.token.character=\
compiler.misc.token.string=\
compiler.misc.token.integer=\
compiler.misc.token.long-integer=\
compiler.misc.token.float=\
compiler.misc.token.double=\
compiler.misc.token.bad-symbol=\
compiler.misc.token.end-of-input=\
## The argument to the following string will always be one of the following:
## 1. one of the above non-terminals
## 2. a keyword (JLS1.8)
## 3. a boolean literal (JLS3.10.3)
## 4. the null literal (JLS3.10.7)
## 5. a Java separator (JLS3.11)
## 6. an operator (JLS3.12)
##
## This is the only place these tokens will be used.
# 0: token
compiler.err.expected=\
{0} expected
# 0: token, 1: token
compiler.err.expected2=\
{0} or {1} expected
# 0: token, 1: token, 2: token
compiler.err.expected3=\
{0}, {1}, or {2} expected
compiler.err.premature.eof=\
reached end of file while parsing
## The following are related in form, but do not easily fit the above paradigm.
compiler.err.dot.class.expected=\
''.class'' expected
## The argument to this string will always be either 'case' or 'default'.
# 0: token
compiler.err.orphaned=\
orphaned {0}
# 0: name
compiler.misc.anonymous.class=\
# 0: name, 1: type
compiler.misc.type.captureof=\
capture#{0} of {1}
compiler.misc.type.captureof.1=\
capture#{0}
compiler.misc.type.none=\
compiler.misc.unnamed.package=\
unnamed package
#####
# 0: symbol, 1: message segment
compiler.err.cant.access=\
cannot access {0}\n\
{1}
# 0: file name, 1: message segment
compiler.misc.bad.class.file.header=\
bad class file: {0}\n\
{1}\n\
Please remove or make sure it appears in the correct subdirectory of the classpath.
# 0: file name, 1: message segment
compiler.misc.bad.source.file.header=\
bad source file: {0}\n\
{1}\n\
Please remove or make sure it appears in the correct subdirectory of the sourcepath.
## The following are all possible strings for the second argument ({1}) of the
## above strings.
compiler.misc.bad.class.signature=\
bad class signature: {0}
#0: symbol, 1: symbol
compiler.misc.bad.enclosing.class=\
bad enclosing class for {0}: {1}
# 0: symbol
compiler.misc.bad.enclosing.method=\
bad enclosing method attribute for class {0}
compiler.misc.bad.runtime.invisible.param.annotations=\
bad RuntimeInvisibleParameterAnnotations attribute: {0}
compiler.misc.bad.const.pool.tag=\
bad constant pool tag: {0}
compiler.misc.bad.const.pool.tag.at=\
bad constant pool tag: {0} at {1}
compiler.misc.bad.signature=\
bad signature: {0}
compiler.misc.bad.type.annotation.value=\
bad type annotation target type value: {0}
compiler.misc.class.file.wrong.class=\
class file contains wrong class: {0}
compiler.misc.class.file.not.found=\
class file for {0} not found
# 0: classfile major version, 1: classfile minor version
compiler.misc.invalid.default.interface=\
default method found in version {0}.{1} classfile
# 0: classfile major version, 1: classfile minor version
compiler.misc.invalid.static.interface=\
static method found in version {0}.{1} classfile
# 0: name
compiler.misc.file.doesnt.contain.class=\
file does not contain class {0}
compiler.misc.file.does.not.contain.package=\
file does not contain package {0}
compiler.misc.illegal.start.of.class.file=\
illegal start of class file
compiler.misc.unable.to.access.file=\
unable to access file: {0}
compiler.misc.unicode.str.not.supported=\
unicode string in class file not supported
compiler.misc.undecl.type.var=\
undeclared type variable: {0}
compiler.misc.wrong.version=\
class file has wrong version {0}.{1}, should be {2}.{3}
#####
# 0: type, 1: type or symbol
compiler.err.not.within.bounds=\
type argument {0} is not within bounds of type-variable {1}
## The following are all possible strings for the second argument ({1}) of the
## above string.
## none yet...
#####
# 0: message segment
compiler.err.prob.found.req=\
incompatible types: {0}
# 0: message segment
compiler.misc.prob.found.req=\
incompatible types: {0}
# 0: message segment, 1: type, 2: type
compiler.warn.prob.found.req=\
{0}\n\
required: {2}\n\
found: {1}
# 0: type, 1: type
compiler.misc.inconvertible.types=\
{0} cannot be converted to {1}
# 0: type, 1: type
compiler.misc.possible.loss.of.precision=\
possible lossy conversion from {0} to {1}
compiler.misc.unchecked.assign=\
unchecked conversion
# compiler.misc.storecheck=\
# assignment might cause later store checks to fail
# compiler.misc.unchecked=\
# assigned array cannot dynamically check its stores
compiler.misc.unchecked.cast.to.type=\
unchecked cast
# compiler.err.star.expected=\
# ''*'' expected
# compiler.err.no.elem.type=\
# \[\*\] cannot have a type
# 0: type
compiler.misc.try.not.applicable.to.type=\
try-with-resources not applicable to variable type\n\
({0})
#####
# 0: message segment or type, 1: message segment
compiler.err.type.found.req=\
unexpected type\n\
required: {1}\n\
found: {0}
## The following are all possible strings for the first argument ({0}) of the
## above string.
compiler.misc.type.req.class=\
class
compiler.misc.type.req.class.array=\
class or array
compiler.misc.type.req.array.or.iterable=\
array or java.lang.Iterable
compiler.misc.type.req.ref=\
reference
compiler.misc.type.req.exact=\
class or interface without bounds
# 0: type
compiler.misc.type.parameter=\
type parameter {0}
#####
## The following are all possible strings for the last argument of all those
## diagnostics whose key ends in ".1"
# 0: type, 1: list of type
compiler.misc.no.unique.maximal.instance.exists=\
no unique maximal instance exists for type variable {0} with upper bounds {1}
compiler.misc.no.unique.minimal.instance.exists=\
no unique minimal instance exists for type variable {0} with lower bounds {1}
# 0: type, 1: list of type
compiler.misc.incompatible.upper.bounds=\
inference variable {0} has incompatible upper bounds {1}
# 0: type, 1: list of type, 2: list of type
compiler.misc.incompatible.eq.upper.bounds=\
inference variable {0} has incompatible bounds\n\
equality constraints: {1}\n\
upper bounds: {2}
# 0: type, 1: list of type, 2: list of type
compiler.misc.incompatible.eq.lower.bounds=\
inference variable {0} has incompatible bounds\n\
equality constraints: {1}\n\
lower bounds: {2}
# 0: list of type, 1: type, 2: type
compiler.misc.infer.no.conforming.instance.exists=\
no instance(s) of type variable(s) {0} exist so that {1} conforms to {2}
# 0: list of type, 1: message segment
compiler.misc.infer.no.conforming.assignment.exists=\
cannot infer type-variable(s) {0}\n\
(argument mismatch; {1})
# 0: list of type
compiler.misc.infer.arg.length.mismatch=\
cannot infer type-variable(s) {0}\n\
(actual and formal argument lists differ in length)
# 0: list of type, 1: message segment
compiler.misc.infer.varargs.argument.mismatch=\
cannot infer type-variable(s) {0}\n\
(varargs mismatch; {1})
# 0: type, 1: list of type
compiler.misc.inferred.do.not.conform.to.upper.bounds=\
inferred type does not conform to upper bound(s)\n\
inferred: {0}\n\
upper bound(s): {1}
# 0: type, 1: list of type
compiler.misc.inferred.do.not.conform.to.lower.bounds=\
inferred type does not conform to lower bound(s)\n\
inferred: {0}\n\
lower bound(s): {1}
# 0: type, 1: list of type
compiler.misc.inferred.do.not.conform.to.eq.bounds=\
inferred type does not conform to equality constraint(s)\n\
inferred: {0}\n\
equality constraints(s): {1}
# 0: symbol
compiler.misc.diamond=\
{0}<>
# 0: type
compiler.misc.diamond.non.generic=\
cannot use ''<>'' with non-generic class {0}
# 0: unused
compiler.misc.diamond.and.explicit.params=\
cannot use ''<>'' with explicit type parameters for constructor
# 0: unused
compiler.misc.mref.infer.and.explicit.params=\
cannot use raw constructor reference with explicit type parameters for constructor
# 0: type, 1: list of type
compiler.misc.explicit.param.do.not.conform.to.bounds=\
explicit type argument {0} does not conform to declared bound(s) {1}
compiler.misc.arg.length.mismatch=\
actual and formal argument lists differ in length
# 0: message segment
compiler.misc.no.conforming.assignment.exists=\
argument mismatch; {0}
# 0: message segment
compiler.misc.varargs.argument.mismatch=\
varargs mismatch; {0}
#####
# 0: symbol or type, 1: file name
compiler.warn.auxiliary.class.accessed.from.outside.of.its.source.file=\
auxiliary class {0} in {1} should not be accessed from outside its own source file
## The first argument ({0}) is a "kindname".
# 0: symbol kind, 1: symbol, 2: symbol
compiler.err.abstract.cant.be.accessed.directly=\
abstract {0} {1} in {2} cannot be accessed directly
## The first argument ({0}) is a "kindname".
# 0: symbol kind, 1: symbol
compiler.err.non-static.cant.be.ref=\
non-static {0} {1} cannot be referenced from a static context
# 0: symbol kind, 1: symbol
compiler.misc.non-static.cant.be.ref=\
non-static {0} {1} cannot be referenced from a static context
# 0: symbol kind, 1: symbol
compiler.misc.static.method.in.unbound.lookup=\
static {0} {1} found in unbound lookup
## Both arguments ({0}, {1}) are "kindname"s. {0} is a comma-separated list
## of kindnames (the list should be identical to that provided in source.
compiler.err.unexpected.type=\
unexpected type\n\
required: {0}\n\
found: {1}
compiler.err.unexpected.lambda=\
lambda expression not expected here
compiler.err.unexpected.mref=\
method reference not expected here
## The first argument {0} is a "kindname" (e.g. 'constructor', 'field', etc.)
## The second argument {1} is the non-resolved symbol
## The third argument {2} is a list of type parameters (non-empty if {1} is a method)
## The fourth argument {3} is a list of argument types (non-empty if {1} is a method)
# 0: symbol kind, 1: name, 2: unused, 3: unused
compiler.err.cant.resolve=\
cannot find symbol\n\
symbol: {0} {1}
# 0: symbol kind, 1: name, 2: unused, 3: list of type
compiler.err.cant.resolve.args=\
cannot find symbol\n\
symbol: {0} {1}({3})
# 0: symbol kind, 1: name, 2: list of type, 3: list of type
compiler.err.cant.resolve.args.params=\
cannot find symbol\n\
symbol: {0} <{2}>{1}({3})
## arguments from {0} to {3} have the same meaning as above
## The fifth argument {4} is a location subdiagnostic (see below)
# 0: symbol kind, 1: name, 2: unused, 3: unused, 4: message segment
compiler.err.cant.resolve.location=\
cannot find symbol\n\
symbol: {0} {1}\n\
location: {4}
# 0: symbol kind, 1: name, 2: unused, 3: list of type, 4: message segment
compiler.err.cant.resolve.location.args=\
cannot find symbol\n\
symbol: {0} {1}({3})\n\
location: {4}
# 0: symbol kind, 1: name, 2: list of type, 3: list, 4: message segment
compiler.err.cant.resolve.location.args.params=\
cannot find symbol\n\
symbol: {0} <{2}>{1}({3})\n\
location: {4}
### Following are replicated/used for method reference diagnostics
# 0: symbol kind, 1: name, 2: unused, 3: list of type, 4: message segment
compiler.misc.cant.resolve.location.args=\
cannot find symbol\n\
symbol: {0} {1}({3})\n\
location: {4}
# 0: symbol kind, 1: name, 2: list of type, 3: list, 4: message segment
compiler.misc.cant.resolve.location.args.params=\
cannot find symbol\n\
symbol: {0} <{2}>{1}({3})\n\
location: {4}
##a location subdiagnostic is composed as follows:
## The first argument {0} is the location "kindname" (e.g. 'constructor', 'field', etc.)
## The second argument {1} is the location name
## The third argument {2} is the location type (only when {1} is a variable name)
# 0: symbol kind, 1: type or symbol, 2: unused
compiler.misc.location=\
{0} {1}
# 0: symbol kind, 1: symbol, 2: type
compiler.misc.location.1=\
{0} {1} of type {2}
## The following are all possible string for "kindname".
## They should be called whatever the JLS calls them after it been translated
## to the appropriate language.
# compiler.misc.kindname.constructor=\
# static member
compiler.misc.kindname.annotation=\
@interface
compiler.misc.kindname.constructor=\
constructor
compiler.misc.kindname.enum=\
enum
compiler.misc.kindname.interface=\
interface
compiler.misc.kindname.static=\
static
compiler.misc.kindname.type.variable=\
type variable
compiler.misc.kindname.type.variable.bound=\
bound of type variable
compiler.misc.kindname.variable=\
variable
compiler.misc.kindname.value=\
value
compiler.misc.kindname.method=\
method
compiler.misc.kindname.class=\
class
compiler.misc.kindname.package=\
package
compiler.misc.kindname.static.init=\
static initializer
compiler.misc.kindname.instance.init=\
instance initializer
#####
compiler.misc.no.args=\
no arguments
# 0: message segment
compiler.err.override.static=\
{0}\n\
overriding method is static
# 0: message segment, 1: set of modifier
compiler.err.override.meth=\
{0}\n\
overridden method is {1}
# 0: message segment, 1: type
compiler.err.override.meth.doesnt.throw=\
{0}\n\
overridden method does not throw {1}
# In the following string {1} is a space separated list of Java Keywords, as
# they would have been declared in the source code
# 0: message segment, 1: set of modifier
compiler.err.override.weaker.access=\
{0}\n\
attempting to assign weaker access privileges; was {1}
# 0: message segment, 1: type, 2: type
compiler.err.override.incompatible.ret=\
{0}\n\
return type {1} is not compatible with {2}
# 0: message segment, 1: type, 2: type
compiler.warn.override.unchecked.ret=\
{0}\n\
return type requires unchecked conversion from {1} to {2}
# 0: message segment, 1: type
compiler.warn.override.unchecked.thrown=\
{0}\n\
overridden method does not throw {1}
# 0: symbol
compiler.warn.override.equals.but.not.hashcode=\
Class {0} overrides equals, but neither it nor any superclass overrides hashCode method
## The following are all possible strings for the first argument ({0}) of the
## above strings.
# 0: symbol, 1: symbol, 2: symbol, 3: symbol
compiler.misc.cant.override=\
{0} in {1} cannot override {2} in {3}
# 0: symbol, 1: symbol, 2: symbol, 3: symbol
compiler.misc.cant.implement=\
{0} in {1} cannot implement {2} in {3}
# 0: symbol, 1: symbol, 2: symbol, 3: symbol
compiler.misc.clashes.with=\
{0} in {1} clashes with {2} in {3}
# 0: symbol, 1: symbol, 2: symbol, 3: symbol
compiler.misc.unchecked.override=\
{0} in {1} overrides {2} in {3}
# 0: symbol, 1: symbol, 2: symbol, 3: symbol
compiler.misc.unchecked.implement=\
{0} in {1} implements {2} in {3}
# 0: symbol, 1: symbol, 2: symbol, 3: symbol
compiler.misc.unchecked.clash.with=\
{0} in {1} overrides {2} in {3}
# 0: symbol, 1: symbol, 2: symbol, 3: symbol
compiler.misc.varargs.override=\
{0} in {1} overrides {2} in {3}
# 0: symbol, 1: symbol, 2: symbol, 3: symbol
compiler.misc.varargs.implement=\
{0} in {1} implements {2} in {3}
# 0: symbol, 1: symbol, 2: symbol, 3: symbol
compiler.misc.varargs.clash.with=\
{0} in {1} overrides {2} in {3}
# 0: unused
compiler.misc.diamond.and.anon.class=\
cannot use ''<>'' with anonymous inner classes
# 0: symbol kind, 1: symbol, 2: symbol, 3: message segment
compiler.misc.inapplicable.method=\
{0} {1}.{2} is not applicable\n\
({3})
########################################
# Diagnostics for language feature changes
########################################
# 0: string
compiler.err.unsupported.fp.lit=\
hexadecimal floating point literals are not supported in -source {0}\n\
(use -source 5 or higher to enable hexadecimal floating point literals)
# 0: string
compiler.err.unsupported.binary.lit=\
binary literals are not supported in -source {0}\n\
(use -source 7 or higher to enable binary literals)
# 0: string
compiler.err.unsupported.underscore.lit=\
underscores in literals are not supported in -source {0}\n\
(use -source 7 or higher to enable underscores in literals)
# 0: string
compiler.err.try.with.resources.not.supported.in.source=\
try-with-resources is not supported in -source {0}\n\
(use -source 7 or higher to enable try-with-resources)
compiler.warn.enum.as.identifier=\
as of release 5, ''enum'' is a keyword, and may not be used as an identifier\n\
(use -source 5 or higher to use ''enum'' as a keyword)
compiler.warn.assert.as.identifier=\
as of release 1.4, ''assert'' is a keyword, and may not be used as an identifier\n\
(use -source 1.4 or higher to use ''assert'' as a keyword)
compiler.warn.underscore.as.identifier=\
''_'' used as an identifier\n\
(use of ''_'' as an identifier might not be supported in releases after Java SE 8)
compiler.err.underscore.as.identifier.in.lambda=\
''_'' used as an identifier\n\
(use of ''_'' as an identifier is forbidden for lambda parameters)
compiler.err.enum.as.identifier=\
as of release 5, ''enum'' is a keyword, and may not be used as an identifier\n\
(use -source 1.4 or lower to use ''enum'' as an identifier)
compiler.err.assert.as.identifier=\
as of release 1.4, ''assert'' is a keyword, and may not be used as an identifier\n\
(use -source 1.3 or lower to use ''assert'' as an identifier)
# TODO 308: make a better error message
compiler.err.this.as.identifier=\
as of release 8, ''this'' is allowed as the parameter name for the receiver type only, which has to be the first parameter
# 0: symbol
compiler.err.receiver.parameter.not.applicable.constructor.toplevel.class=\
receiver parameter not applicable for constructor of top-level class
# TODO 308: make a better error message
# 0: symbol
compiler.err.cant.type.annotate.scoping.1=\
scoping construct cannot be annotated with type-use annotation: {0}
# TODO 308: make a better error message
# 0: list of symbol
compiler.err.cant.type.annotate.scoping=\
scoping construct cannot be annotated with type-use annotations: {0}
# 0: type, 1: type
compiler.err.incorrect.receiver.name=\
the receiver name does not match the enclosing class type\n\
required: {0}\n\
found: {1}
# 0: type, 1: type
compiler.err.incorrect.receiver.type=\
the receiver type does not match the enclosing class type\n\
required: {0}\n\
found: {1}
# 0: type, 1: type
compiler.err.incorrect.constructor.receiver.type=\
the receiver type does not match the enclosing outer class type\n\
required: {0}\n\
found: {1}
# 0: type, 1: type
compiler.err.incorrect.constructor.receiver.name=\
the receiver name does not match the enclosing outer class type\n\
required: {0}\n\
found: {1}
compiler.err.no.annotations.on.dot.class=\
no annotations are allowed in the type of a class literal
# 0: string
compiler.err.generics.not.supported.in.source=\
generics are not supported in -source {0}\n\
(use -source 5 or higher to enable generics)
# 0: string
compiler.err.varargs.not.supported.in.source=\
variable-arity methods are not supported in -source {0}\n\
(use -source 5 or higher to enable variable-arity methods)
# 0: string
compiler.err.annotations.not.supported.in.source=\
annotations are not supported in -source {0}\n\
(use -source 5 or higher to enable annotations)
# 0: string
compiler.err.type.annotations.not.supported.in.source=\
type annotations are not supported in -source {0}\n\
(use -source 8 or higher to enable type annotations)
# 0: string
compiler.err.repeatable.annotations.not.supported.in.source=\
repeated annotations are not supported in -source {0}\n\
(use -source 8 or higher to enable repeated annotations)
# 0: string
compiler.err.foreach.not.supported.in.source=\
enhanced for loops are not supported in -source {0}\n\
(use -source 5 or higher to enable for-each loops)
# 0: string
compiler.err.static.import.not.supported.in.source=\
static import declarations are not supported in -source {0}\n\
(use -source 5 or higher to enable static import declarations)
# 0: string
compiler.err.enums.not.supported.in.source=\
enums are not supported in -source {0}\n\
(use -source 5 or higher to enable enums)
# 0: string
compiler.err.diamond.not.supported.in.source=\
diamond operator is not supported in -source {0}\n\
(use -source 7 or higher to enable diamond operator)
# 0: string
compiler.err.multicatch.not.supported.in.source=\
multi-catch statement is not supported in -source {0}\n\
(use -source 7 or higher to enable multi-catch statement)
# 0: string
compiler.err.string.switch.not.supported.in.source=\
strings in switch are not supported in -source {0}\n\
(use -source 7 or higher to enable strings in switch)
# 0: string
compiler.err.lambda.not.supported.in.source=\
lambda expressions are not supported in -source {0}\n\
(use -source 8 or higher to enable lambda expressions)
# 0: string
compiler.err.method.references.not.supported.in.source=\
method references are not supported in -source {0}\n\
(use -source 8 or higher to enable method references)
# 0: string
compiler.err.default.methods.not.supported.in.source=\
default methods are not supported in -source {0}\n\
(use -source 8 or higher to enable default methods)
# 0: string
compiler.err.intersection.types.in.cast.not.supported.in.source=\
intersection types in cast are not supported in -source {0}\n\
(use -source 8 or higher to enable default methods)
# 0: string
compiler.err.static.intf.methods.not.supported.in.source=\
static interface methods are not supported in -source {0}\n\
(use -source 8 or higher to enable static interface methods)
########################################
# Diagnostics for verbose resolution
# used by Resolve (debug only)
########################################
# 0: number, 1: symbol, 2: unused
compiler.misc.applicable.method.found=\
#{0} applicable method found: {1}
# 0: number, 1: symbol, 2: message segment
compiler.misc.applicable.method.found.1=\
#{0} applicable method found: {1}\n\
({2})
# 0: number, 1: symbol, 2: message segment
compiler.misc.not.applicable.method.found=\
#{0} not applicable method found: {1}\n\
({2})
# 0: type
compiler.misc.partial.inst.sig=\
partially instantiated to: {0}
# 0: name, 1: symbol, 2: number, 3: MethodResolutionPhase, 4: list of type or message segment, 5: list of type or message segment
compiler.note.verbose.resolve.multi=\
resolving method {0} in type {1} to candidate {2}\n\
phase: {3}\n\
with actuals: {4}\n\
with type-args: {5}\n\
candidates:
# 0: name, 1: symbol, 2: unused, 3: MethodResolutionPhase, 4: list of type or message segment, 5: list of type or message segment
compiler.note.verbose.resolve.multi.1=\
erroneous resolution for method {0} in type {1}\n\
phase: {3}\n\
with actuals: {4}\n\
with type-args: {5}\n\
candidates:
# 0: symbol, 1: type, 2: type
compiler.note.deferred.method.inst=\
Deferred instantiation of method {0}\n\
instantiated signature: {1}\n\
target-type: {2}
########################################
# Diagnostics for where clause implementation
# used by the RichDiagnosticFormatter.
########################################
compiler.misc.type.null=\
# X#n (where n is an int id) is disambiguated tvar name
# 0: name, 1: number
compiler.misc.type.var=\
{0}#{1}
# CAP#n (where n is an int id) is an abbreviation for 'captured type'
# 0: number
compiler.misc.captured.type=\
CAP#{0}
# (where n is an int id) is an abbreviation for 'intersection type'
# 0: number
compiler.misc.intersection.type=\
INT#{0}
# where clause for captured type: contains upper ('extends {1}') and lower
# ('super {2}') bound along with the wildcard that generated this captured type ({3})
# 0: type, 1: type, 2: type, 3: type
compiler.misc.where.captured=\
{0} extends {1} super: {2} from capture of {3}
# compact where clause for captured type: contains upper ('extends {1}') along
# with the wildcard that generated this captured type ({3})
# 0: type, 1: type, 2: unused, 3: type
compiler.misc.where.captured.1=\
{0} extends {1} from capture of {3}
# where clause for type variable: contains upper bound(s) ('extends {1}') along with
# the kindname ({2}) and location ({3}) in which the typevar has been declared
# 0: type, 1: list of type, 2: symbol kind, 3: symbol
compiler.misc.where.typevar=\
{0} extends {1} declared in {2} {3}
# compact where clause for type variable: contains the kindname ({2}) and location ({3})
# in which the typevar has been declared
# 0: type, 1: list of type, 2: symbol kind, 3: symbol
compiler.misc.where.typevar.1=\
{0} declared in {2} {3}
# where clause for fresh type variable: contains upper bound(s) ('extends {1}').
# Since a fresh type-variable is synthetic - there's no location/kindname here.
# 0: type, 1: list of type
compiler.misc.where.fresh.typevar=\
{0} extends {1}
# where clause for type variable: contains all the upper bound(s) ('extends {1}')
# of this intersection type
# 0: type, 1: list of type
compiler.misc.where.intersection=\
{0} extends {1}
### Where clause headers ###
compiler.misc.where.description.captured=\
where {0} is a fresh type-variable:
# 0: set of type
compiler.misc.where.description.typevar=\
where {0} is a type-variable:
# 0: set of type
compiler.misc.where.description.intersection=\
where {0} is an intersection type:
# 0: set of type
compiler.misc.where.description.captured.1=\
where {0} are fresh type-variables:
# 0: set of type
compiler.misc.where.description.typevar.1=\
where {0} are type-variables:
compiler.misc.where.description.intersection.1=\
where {0} are intersection types:
###
# errors related to doc comments
compiler.err.dc.bad.entity=\
bad HTML entity
compiler.err.dc.bad.gt=\
bad use of ''>''
compiler.err.dc.bad.inline.tag=\
incorrect use of inline tag
compiler.err.dc.identifier.expected=\
identifier expected
compiler.err.dc.malformed.html=\
malformed HTML
compiler.err.dc.missing.semicolon=\
semicolon missing
compiler.err.dc.no.content=\
no content
compiler.err.dc.no.tag.name=\
no tag name after '@'
compiler.err.dc.gt.expected=\
''>'' expected
compiler.err.dc.ref.bad.parens=\
'')'' missing in reference
compiler.err.dc.ref.syntax.error=\
syntax error in reference
compiler.err.dc.ref.unexpected.input=\
unexpected text
compiler.err.dc.unexpected.content=\
unexpected content
compiler.err.dc.unterminated.inline.tag=\
unterminated inline tag
compiler.err.dc.unterminated.signature=\
unterminated signature
compiler.err.dc.unterminated.string=\
unterminated string
© 2015 - 2024 Weber Informatics LLC | Privacy Policy