#
# Copyright (c) 1999, 2011, 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<T>
# 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
{0} is abstract; cannot be instantiated
abstract methods cannot have a body
{0} {1} has already been annotated
# 0: symbol kind, 1: symbol, 2: symbol kind, 3: symbol
{0} {1} is already defined in {2} {3}
# 0: symbol kind, 1: symbol, 2: symbol kind, 3: symbol kind, 4: symbol
{0} {1} is already defined in {2} of {3} {4}
# 0: string
{0} is already defined in a single-type import
# 0: string
{0} is already defined in a static single-type import
{0} is already defined in this compilation unit
# 0: type, 1: list of name
annotation {0} is missing value for the attribute {1}
# 0: type, 1: list of name
annotation {0} is missing values for attributes {1}
# 0: type
annotation not valid for a value of type {0}
annotation type not applicable to this kind of declaration
annotation value must be an annotation
annotation value must be a class literal
annotation values must be of the form ''name=value''
annotation value not of an allowable type
anonymous class implements interface; cannot have arguments
anonymous class implements interface; cannot have type arguments
anonymous class implements interface; cannot have qualifier for new
# 0: symbol, 1: symbol, 2: symbol
cannot declare both {0} and {1} in {2}
array dimension missing
# 0: type
array required, but {0} found
assigning from wildcard {0}
assigning to wildcard {0}
attribute value must be constant
break outside switch or loop
# 0: name
call to {0} must be first statement in constructor
{0} {1} in {4} {5} cannot be applied to given types\n\
required: {2}\n\
found: {3}
# 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
{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
no suitable {0} found for {1}({2})
# 0: symbol
cannot assign a value to final variable {0}
# 0: type
{0} cannot be dereferenced
''extends'' not allowed for @interfaces
# 0: symbol
cannot inherit from final {0}
# 0: symbol
cannot reference {0} before supertype constructor has been called
cannot return a value from method whose result type is void
cannot select a static class from a parameterized type
# 0: symbol, 1: string, 2: string
{0} cannot be inherited with different arguments: <{1}> and <{2}>
''catch'' without ''try''
# 0: symbol kind, 1: symbol
{0} {1} clashes with package of same name
constant expression required
continue outside of loop
# 0: symbol
cyclic inheritance involving {0}
cyclic annotation element type
# 0: unused
call to super not allowed in enum constructor
# 0: type
{0} has no superclass
MethodHandle API building requires -target 7 runtimes or better; current is -target {0}
# 0: symbol, 1: type, 2: symbol, 3: type, 4: unused
methods {0} from {1} and {2} from {3} are inherited with the same signature
default value only allowed in an @interface member
# 0: symbol
package {0} does not exist
duplicate annotation
# 0: name, 1: type
duplicate annotation member value {0} in {1}
# 0: name
duplicate class: {0}
duplicate case label
duplicate default label
''else'' without ''if''
empty character literal
# 0: symbol
an enclosing instance that contains {0} is required
an enum annotation value must be an enum constant
enum types may not be instantiated
an enum switch case label must be the unqualified name of an enumeration constant
classes cannot directly extend java.lang.Enum
enum types are not extensible
enums cannot have finalize methods
# 0: file name, 1: string
error reading {0}; {1}
# 0: type
exception {0} has already been caught
# 0: type
exception {0} is never thrown in body of corresponding try statement
# 0: symbol
final parameter {0} may not be assigned
# 0: symbol
auto-closeable resource {0} may not be assigned
# 0: symbol
multi-catch parameter {0} may not be assigned
# 0: type, 1: type
Alternatives in a multi-catch statement cannot be related by subclassing\n\
Alternative {0} is a subclass of alternative {1}
''finally'' without ''try''
# 0: type, 1: message segment
for-each not applicable to expression type\n\
required: {1}\n\
found: {0}
floating point number too large
floating point number too small
generic array creation
a generic class may not extend java.lang.Throwable
# 0: symbol
Illegal static declaration in inner class {0}\n\
modifier \''static\'' is only allowed in constant variable declarations
# 0: string
illegal character: \\{0}
unmappable character for encoding {0}
# 0: set of modifier, 1: set of modifier
illegal combination of modifiers: {0} and {1}
illegal reference to static field from initializer
illegal escape character
illegal forward reference
# 0: symbol
reference to variable ''{0}'' before it has been initialized
self-reference in initializer
# 0: symbol
self-reference in initializer of variable ''{0}''
illegal generic type for instanceof
# 0: type
illegal initializer for {0}
illegal line end in character literal
illegal non-ASCII digit
illegal underscore
# 0: symbol
illegal qualifier; {0} is not an inner class
illegal start of expression
illegal start of type
illegal unicode escape
# 0: symbol
import requires canonical name for {0}
improperly formed type, some parameters are missing
improperly formed type, type arguments given on a raw type
# 0: type, 1: type
incomparable types: {0} and {1}
# 0: number
integer number too large: {0}
internal error; cannot instantiate {0} at {1} to ({2})
@interface members may not have parameters
@interface may not have type parameters
@interface members may not have type parameters
# 0: symbol, 1: type
@interface member clashes with method ''{0}'' in {1}
interface expected here
interface methods cannot have body
invalid type for annotation member
binary numbers must contain at least one binary digit
hexadecimal numbers must contain at least one hexadecimal digit
invalid method declaration; return type required
legacy array notation not allowed on variable-arity parameter
# 0: name
label {0} already in use
# 0: symbol
local variable {0} is accessed from within inner class; needs to be declared final
enum types must not be local
cannot create array with type arguments
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.
#
code too large
code too large for try statement
array type has too many dimensions
too many local variables
too many parameters
too many constants
too many constants in class {0}
code requires too much stack
constant string too long
UTF8 representation for string \"{0}...\" is too long for the constant pool
malformed floating point literal
method does not override or implement a method from a supertype
missing method body, or declare abstract
missing return statement
missing return value
# 0: set of modifier
modifier {0} not allowed here
interface not allowed here
enum declarations allowed only in static contexts
# 0: symbol, 1: symbol
name clash: {0} and {1} have the same erasure
# 0: symbol, 1: symbol, 2: symbol, 3: symbol, 4: unused, 5: unused
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
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
name clash: {0} in {1} and {2} in {3} have the same erasure, yet neither hides the other
{0} is reserved for internal use
native methods cannot have a body
# 0: type, 1: type
incompatible types for ?: neither is a subtype of the other\n\
second operand: {0}\n\
third operand : {1}
''new'' not allowed in an annotation
no annotation member {0} in {1}
no enclosing instance of type {0} is in scope
no interface expected here
{0} has no match in entry in {1}; required {2}
{0} is not an annotation type
# 0: symbol, 1: symbol
{0} in {1} is defined in an inaccessible class or interface
# 0: symbol, 1: symbol
{0} is not public in {1}; cannot be accessed from outside package
# 0: name
not a loop label: {0}
not a statement
# 0: symbol
not an enclosing class: {0}
# 0: name, 1: type, 2: unused
bad operand type {1} for unary operator ''{0}''
# 0: name, 1: type, 2: type
bad operand types for binary operator ''{0}''\n\
first type: {1}\n\
second type: {2}
package annotations should be in file package-info.java
# 0: symbol
package {0} clashes with class of same name
warnings found and -Werror specified
# Errors related to annotation processing
# 0: symbol, 1: string, 2: stack-trace
cannot access {0}\n\
{1}\n\
Consult the following stack trace for details.\n\
{2}
# 0: symbol, 1: string
cannot access {0}\n\
{1}
# 0: string
Could not find class file for ''{0}''.
# Print a client-generated error message; assumed to be localized, no translation required
# 0: string
{0}
# 0: list of string
Class names, ''{0}'', are only accepted if annotation processing is explicitly requested
A service loader class could not be found.\n\
Either java.util.ServiceLoader or sun.misc.Service must be available.
Bad option name ''{0}'' provided by processor ''{1}''
# 0: string
Could not instantiate an instance of processor ''{0}''
Exception thrown while constructing Processor object: {0}
# 0: string
Annotation processor ''{0}'' not found
# 0: string
Annotation processor ''{0}'' does not implement javax.annotation.processing.Processor
Error creating a service loader to load Processors.
Bad service configuration file, or exception thrown while constructing Processor object: {0}
Could not create class loader for annotation processors: {0}
# 0: unused
qualified new of static class
recursive constructor invocation
# 0: name, 1: symbol kind, 2: symbol, 3: symbol, 4: symbol kind, 5: symbol, 6: symbol
reference to {0} is ambiguous, both {1} {2} in {3} and {4} {5} in {6} match
repeated annotation target
repeated interface
repeated modifier
# 0: symbol, 1: set of modifier, 2: symbol
{0} has {1} access in {2}
return outside method
signature does not match {0}; incompatible supertype
signature does not match {0}; incompatible interfaces
# 0: symbol, 1: symbol, 2: symbol
{0} is not abstract and does not override abstract method {1} in {2}
error writing source; cannot overwrite input file {0}
Internal error: stack sim error on {0}
static import only from classes and interfaces
constant string expression required
# 0: symbol, 1: symbol
the symbol {0} conflicts with a compiler-synthesized symbol in {1}
# 0: symbol, 1: symbol
the symbol {0} conflicts with a compiler-synthesized symbol in {1}
throws clause not allowed in @interface members
''try'' without ''catch'' or ''finally''
''try'' without ''catch'', ''finally'' or resource declarations
# 0: symbol
type {0} does not take parameters
cannot select from a type variable
a type variable may not be followed by other bounds
type variable {0} occurs more than once in result type of {1}; cannot be left uninstantiated
type variable {0} occurs more than once in type of {1}; cannot be left uninstantiated
# 0: type, 1: type, 2: string
types {0} and {1} are incompatible; both define {2}, but with unrelated return types
unclosed character literal
unclosed comment
unclosed string literal
# 0: name
unsupported encoding: {0}
error reading source file: {0}
# 0: name
undefined label: {0}
cannot infer type arguments for {0}
# 0: type, 1: message segment
cannot infer type arguments for {0};\n\
reason: {1}
# 0: list of type, 1: message segment
invalid inferred types for {0}; {1}
# 0: message segment, 1: unused
cannot infer type arguments for {0}
# 0: message segment, 1: message segment
cannot infer type arguments for {0};\n\
reason: {1}
unreachable statement
initializer must be able to complete normally
# 0: type
unreported exception {0}; must be caught or declared to be thrown
# 0: type
unreported exception {0} in default constructor
# 0: type, 1: name
unreported exception {0}; must be caught or declared to be thrown\n\
exception thrown from implicit call to close() on resource variable ''{1}''
hexadecimal floating-point literals are not supported on this VM
''void'' type not allowed here
# 0: string
wrong number of type arguments; required {0}
# 0: symbol
variable {0} might already have been assigned
# 0: symbol
variable {0} might not have been initialized
# 0: symbol
variable {0} might be assigned in loop
# 0: symbol, 1: message segment
Invalid {0} annotation. {1}
# 0: type
Varargs element type {0} is reifiable.
# 0: symbol
Method {0} is not a varargs method.
# 0: symbol
Instance method {0} is not final.
# 0: type, 1: kind, 2: symbol
formal varargs element type {0} is not accessible from {1} {2}
# In the following string, {1} will always be the detail message from
# 0: symbol, 1: string
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
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.
error:\u0020
# The following error messages do not refer to a line in the source code.
cannot read: {0}
#####
# Fatal Errors
Fatal Error: Unable to find package java.lang in classpath or bootclasspath
Fatal Error: Unable to find method {0}
Fatal Error: Unable to find field {0}
Fatal Error: Unable to find constructor for {0}
Fatal Error: Cannot close class loader for annotation processors
#####
##
## miscellaneous strings
##
(source unavailable)
all your base class are belong to us
# 0: string, 1: string, 2: boolean
Processor {0} matches {1} and returns {2}.
# 0: number, 1: string, 2: set of symbol, 3: boolean
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".
Note:\u0020
# 0: file name
{0} uses or overrides a deprecated API.
Some input files use or override a deprecated API.
# The following string may appear after one of the above deprecation
# messages.
Recompile with -Xlint:deprecation for details.
# 0: file name
{0} has additional uses or overrides of a deprecated API.
Some input files additionally use or override a deprecated API.
# 0: file name
{0} uses unchecked or unsafe operations.
Some input files use unchecked or unsafe operations.
# The following string may appear after one of the above deprecation
# messages.
Recompile with -Xlint:unchecked for details.
# 0: file name
{0} has additional unchecked or unsafe operations.
Some input files additionally use unchecked or unsafe operations.
# 0: file name
{0} uses internal proprietary API that may be removed in a future release.
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.
Recompile with -Xlint:sunapi for details.
# 0: file name
{0} uses additional internal proprietary API that may be removed in a future release.
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
{0}
#####
# 0: number
{0} error
# 0: number
{0} errors
# 0: number
{0} warning
# 0: number
{0} warnings
(version info not available)
## extra output when using -verbose (JavaCompiler)
# 0: symbol
[checking {0}]
# 0: string
[parsing completed {0}ms]
# 0: file name
[parsing started {0}]
# 0: string
[total {0}ms]
# 0: file name
[wrote {0}]
## extra output when using -verbose (Retro)
[retrofitting {0}]
\tretrofitting {0} with {1}
\tretrofitting {0} with type parameters {1}, supertype {2}, interfaces {3}
## extra output when using -verbose (code/ClassReader)
# 0: string
[loading {0}]
# 0: string
[search path for source files: {0}]
# 0: string
[search path for class files: {0}]
## extra output when using -checkclassfile (code/ClassReader)
class file has later version than expected: {0}
unrecognized attribute: {0}
## extra output when using -prompt (util/Log)
R)esume, A)bort>
#####
##
## warnings
##
## All warning messages are preceded by the following string.
warning:\u0020
## Warning messages may also include the following prefix to identify a
## lint option
# 0: option name
[{0}]\u0020
# 0: symbol
serialVersionUID must be constant in class {0}
# 0: file name
bad path element "{0}": no such directory
finally clause cannot complete normally
# 0: symbol, 1: symbol
{0} in {1} has been deprecated
# 0: symbol
{0} is internal proprietary API and may be removed in a future release
unmappable character for encoding {0}
# 0: symbol
serialVersionUID must be declared static final in class {0}
# 0: type, 1: type
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
unreachable catch clause\n\
thrown type {0} has already been caught
# 0: list of type
unreachable catch clause\n\
thrown types {0} have already been caught
# 0: symbol
serialVersionUID must be of type long in class {0}
# 0: symbol
serializable class {0} has no definition of serialVersionUID
# 0: message segment
{0}; overridden method has no ''...''
# 0: message segment
{0}; overriding method is missing ''...''
{0}; overridden method is a bridge method
# 0: symbol
a package-info.java file has already been seen for package {0}
# 0: file name
bad path element "{0}": no such file or directory
possible fall-through into case
# 0: type
redundant cast to {0}
# 0: number
Position encoding overflows at line {0}
# 0: file name, 1: number, 2: number
{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
static {0} should be qualified by type name, {1}, instead of by an expression
# 0: string
bootstrap class path not set in conjunction with -source {0}
# 0: name, 1: number, 2: number, 3: number, 4: number
{0} attribute introduced in version {1}.{2} class files is ignored in version {3}.{4} class files
# Warnings related to annotation processing
# 0: name
package {0} does not exist
# 0: name
Attempt to create a file for ''{0}'' multiple times
# 0: name
A file for type ''{0}'' already exists on the sourcepath or classpath
# 0: name
Attempt to create a file for type ''{0}'' multiple times
# 0: string
Cannot create file for illegal name ''{0}''.
# 0: string, 1: string
Creating file for a type whose name ends in {1}: ''{0}''
# 0: name
File for type ''{0}'' created in the last round will not be subject to annotation processing.
# 0: string, 1: string
Malformed string ''{0}'' for a supported annotation type returned by processor ''{1}''
# 0: set of string
No processor claimed any of these annotations: {0}
# 0: source version, 1: string, 2: string
Supported source version ''{0}'' from annotation processor ''{1}'' less than -source ''{2}''
Annotation processing without compilation requested but no processors were found.
Implicitly compiled files were not subject to annotation processing.\n\
Use -implicit to specify a policy for implicit compilation.
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
{0}
# 0: set of name
Unclosed files for the types ''{0}''; these types will not undergo annotation processing
# 0: string
The following options were not recognized by any processor: ''{0}''
explicit call to close() on an auto-closeable resource
# 0: symbol
auto-closeable resource {0} is never referenced in body of corresponding try statement
# 0: type
auto-closeable resource {0} has a member method close() that could throw InterruptedException
unchecked assignment: {0} to {1}
# 0: symbol, 1: type
unchecked assignment to variable {0} as member of raw type {1}
# 0: symbol, 1: type
unchecked call to {0} as a member of the raw type {1}
unchecked cast to type {0}
# 0: symbol kind, 1: name, 2: list of type, 3: list of type, 4: symbol kind, 5: symbol
unchecked method invocation: {0} {1} in {4} {5} is applied to given types\n\
required: {2}\n\
found: {3}
# 0: type
unchecked generic array creation for varargs parameter of type {0}
# 0: type
Possible heap pollution from parameterized vararg type {0}
# 0: symbol
Varargs method could cause heap pollution from non-reifiable varargs parameter {0}
deprecated item is not annotated with @Deprecated
Unexpected file on path: {0}
Unexpected extension for archive file: {0}
division by zero
empty statement after if
Cannot find annotation method ''{1}()'' in type ''{0}''
Cannot find annotation method ''{1}()'' in type ''{0}'': {2}
# 0: symbol, 1: name
unknown enum constant {1}.{2}
# 0: symbol, 1: name, 2: message segment
unknown enum constant {1}.{2}\n\
reason: {3}
# 0: type, 1: type
found raw type: {0}\n\
missing type arguments for generic class {1}
# 0: unused, 1: unused
redundant type arguments in new expression (use diamond operator instead).
# 0: type, 1: type
redundant type arguments in new expression (use diamond operator instead).\n\
explicit: {0}\n\
inferred: {1}
# 0: symbol, 1: message segment
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.
<identifier>
<character>
<string>
<integer>
<long integer>
<float>
<double>
<bad symbol>
<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
{0} expected
# 0: token, 1: token
{0} or {1} expected
# 0: token, 1: token, 2: token
{0}, {1}, or {2} expected
reached end of file while parsing
## The following are related in form, but do not easily fit the above paradigm.
''.class'' expected
## The argument to this string will always be either 'case' or 'default'.
# 0: token
orphaned {0}
# 0: name
<anonymous {0}>
# 0: name, 1: type
capture#{0} of {1}
capture#{0}
<none>
unnamed package
#####
# 0: symbol, 1: message segment
cannot access {0}\n\
{1}
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
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.
bad class signature: {0}
#0: symbol, 1: symbol
bad enclosing class for {0}: {1}
# 0: symbol
bad enclosing method attribute for class {0}
bad RuntimeInvisibleParameterAnnotations attribute: {0}
bad constant pool tag: {0}
bad constant pool tag: {0} at {1}
bad signature: {0}
class file contains wrong class: {0}
class file for {0} not found
# 0: name
file does not contain class {0}
file does not contain package {0}
illegal start of class file
unable to access file: {0}
unicode string in class file not supported
undeclared type variable: {0}
class file has wrong version {0}.{1}, should be {2}.{3}
#####
# 0: type, 1: type or symbol
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, 1: type, 2: type
{0}\n\
required: {2}\n\
found: {1}
# 0: message segment, 1: type, 2: type
{0}\n\
required: {2}\n\
found: {1}
{0} {3}\n\
required: {2}\n\
found: {1}
## The following are all possible strings for the first argument ({0}) of the
## above strings.
incompatible types
# 0: message segment
incompatible types; {0}
inconvertible types
possible loss of precision
unchecked conversion
# assignment might cause later store checks to fail
# assigned array cannot dynamically check its stores
unchecked cast
assignment from super-bound type {0}
assignment to extends-bound type {0}
# ''*'' expected
# \[\*\] cannot have a type
try-with-resources not applicable to variable type
#####
# 0: message segment or type, 1: message segment
unexpected type\n\
required: {1}\n\
found: {0}
## The following are all possible strings for the first argument ({0}) of the
## above string.
class
class or array
array or java.lang.Iterable
reference
class or interface without bounds
# 0: type
type parameter {0}
#####
## The following are all possible strings for the last argument of all those
## diagnostics whose key ends in ".1"
undetermined type
type variable {0} has undetermined type
# 0: type, 1: list of type
no unique maximal instance exists for type variable {0} with upper bounds {1}
no unique minimal instance exists for type variable {0} with lower bounds {1}
# 0: type, 1: list of type
inference variable {0} has incompatible upper bounds {1}
# 0: list of type, 1: type, 2: type
no instance(s) of type variable(s) {0} exist so that {1} conforms to {2}
# 0: list of type, 1: type, 2: type
no instance(s) of type variable(s) {0} exist so that argument type {1} conforms to formal parameter type {2}
cannot instantiate from arguments because actual and formal argument lists differ in length
# 0: type, 1: list of type
inferred type does not conform to declared bound(s)\n\
inferred: {0}\n\
bound(s): {1}
# 0: symbol
{0}<>
# 0: type
cannot use ''<>'' with non-generic class {0}
cannot use ''<>'' with explicit type parameters for constructor
# 0: type, 1: list of type
explicit type argument {0} does not conform to declared bound(s) {1}
actual and formal argument lists differ in length
# 0: type, 1: type
actual argument {0} cannot be converted to {1} by method invocation conversion
# 0: type, 1: type
argument type {0} does not conform to vararg element type {1}
#####
## The first argument ({0}) is a "kindname".
# 0: symbol kind, 1: symbol, 2: symbol
abstract {0} {1} in {2} cannot be accessed directly
## The first argument ({0}) is a "kindname".
# 0: symbol kind, 1: symbol
non-static {0} {1} cannot be referenced from a static context
## 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.
unexpected type\n\
required: {0}\n\
found: {1}
## 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
cannot find symbol\n\
symbol: {0} {1}
# 0: symbol kind, 1: name, 2: unused, 3: list of type
cannot find symbol\n\
symbol: {0} {1}({3})
# 0: symbol kind, 1: name, 2: list of type, 3: list of type
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
cannot find symbol\n\
symbol: {0} {1}\n\
location: {4}
# 0: symbol kind, 1: name, 2: unused, 3: list of type, 4: message segment
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
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: symbol, 2: unused
{0} {1}
# 0: symbol kind, 1: symbol, 2: type
{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.
# static member
@interface
constructor
enum
interface
static
type variable
bound of type variable
variable
value
method
class
package
static initializer
instance initializer
#####
no arguments
# 0: message segment
{0}\n\
overriding method is static
# 0: message segment, 1: set of modifier
{0}\n\
overridden method is {1}
# 0: message segment, 1: type
{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
{0}\n\
attempting to assign weaker access privileges; was {1}
# 0: message segment, 1: type, 2: type
{0}\n\
return type {1} is not compatible with {2}
# 0: message segment, 1: type, 2: type
{0}\n\
return type requires unchecked conversion from {1} to {2}
# 0: message segment, 1: type
{0}\n\
overridden method does not throw {1}
## The following are all possible strings for the first argument ({0}) of the
## above strings.
# 0: symbol, 1: symbol, 2: symbol, 3: symbol
{0} in {1} cannot override {2} in {3}
# 0: symbol, 1: symbol, 2: symbol, 3: symbol
{0} in {1} cannot implement {2} in {3}
# 0: symbol, 1: symbol, 2: symbol, 3: symbol
{0} in {1} clashes with {2} in {3}
# 0: symbol, 1: symbol, 2: symbol, 3: symbol
{0} in {1} overrides {2} in {3}
# 0: symbol, 1: symbol, 2: symbol, 3: symbol
{0} in {1} implements {2} in {3}
# 0: symbol, 1: symbol, 2: symbol, 3: symbol
{0} in {1} overrides {2} in {3}
# 0: symbol, 1: symbol, 2: symbol, 3: symbol
{0} in {1} overrides {2} in {3}
# 0: symbol, 1: symbol, 2: symbol, 3: symbol
{0} in {1} implements {2} in {3}
# 0: symbol, 1: symbol, 2: symbol, 3: symbol
{0} in {1} overrides {2} in {3}
cannot use ''<>'' with anonymous inner classes
# 0: symbol kind, 1: symbol, 2: symbol, 3: message segment
{0} {1}.{2} is not applicable\n\
({3})
########################################
# Diagnostics for language feature changes
########################################
# 0: string
hexadecimal floating point literals are not supported in -source {0}\n\
(use -source 5 or higher to enable hexadecimal floating point literals)
# 0: string
binary literals are not supported in -source {0}\n\
(use -source 7 or higher to enable binary literals)
# 0: string
underscores in literals are not supported in -source {0}\n\
(use -source 7 or higher to enable underscores in literals)
# 0: string
try-with-resources is not supported in -source {0}\n\
(use -source 7 or higher to enable try-with-resources)
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)
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)
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)
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)
# 0: string
generics are not supported in -source {0}\n\
(use -source 5 or higher to enable generics)
# 0: string
variable-arity methods are not supported in -source {0}\n\
(use -source 5 or higher to enable variable-arity methods)
# 0: string
annotations are not supported in -source {0}\n\
(use -source 5 or higher to enable annotations)
#308 type annotations are not supported in -source {0}\n\
#308 (use -source 7 or higher to enable type annotations)
# 0: string
for-each loops are not supported in -source {0}\n\
(use -source 5 or higher to enable for-each loops)
# 0: string
static import declarations are not supported in -source {0}\n\
(use -source 5 or higher to enable static import declarations)
# 0: string
enums are not supported in -source {0}\n\
(use -source 5 or higher to enable enums)
# 0: string
diamond operator is not supported in -source {0}\n\
(use -source 7 or higher to enable diamond operator)
# 0: string
multi-catch statement is not supported in -source {0}\n\
(use -source 7 or higher to enable multi-catch statement)
# 0: string
strings in switch are not supported in -source {0}\n\
(use -source 7 or higher to enable strings in switch)
########################################
# Diagnostics for where clause implementation
# used by the RichDiagnosticFormatter.
########################################
<null>
# X#n (where n is an int id) is disambiguated tvar name
# 0: name, 1: number
{0}#{1}
# CAP#n (where n is an int id) is an abbreviation for 'captured type'
# 0: number
CAP#{0}
# <INT#n> (where n is an int id) is an abbreviation for 'intersection type'
# 0: number
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
{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
{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
{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} declared in {2} {3}
# where clause for type variable: contains all the upper bound(s) ('extends {1}')
# of this intersection type
# 0: type, 1: list of type
{0} extends {1}
### Where clause headers ###
where {0} is a fresh type-variable:
# 0: set of type
where {0} is a type-variable:
# 0: set of type
where {0} is an intersection type:
# 0: set of type
where {0} are fresh type-variables:
# 0: set of type
where {0} are type-variables:
where {0} are intersection types: