#

# Copyright (c) 1999, 2015, 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 simple types currently in use are:

#

# boolean           true or false

# diagnostic        a sub-message; see compiler.misc.*

# fragment          similar to 'message segment', but with more specific type

# modifier          a Java modifier; e.g. public, private, protected

# file              a file URL

# file object       a file URL - similar to 'file' but typically used for source/class files, hence more specific

# 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       the kind of a symbol (i.e. method, variable)

# kind name         an informative 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>

# object            a Java object (unspecified)

# unused            the value is not used in this message

#

# The following compound types are also used:

#

# list of X         a comma-separated list of items; e.g. list of type

# set of X          a comma-separated collection of items; e.g. set of modifier

#

# These may be composed:

#

# list of type or message segment

#

# The following type aliases are supported:

#

# message segment --> diagnostic or fragment

# file name --> file or file object

#

# Custom comments are supported in parenthesis i.e.

#

# number (classfile major version)

#

# These comments are used internally in order to generate an enum-like class declaration containing

# a method/field for each of the diagnostic keys listed here. Those methods/fields can then be used

# by javac code to build diagnostics in a type-safe fashion.

#

# In addition, 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

compiler.err.cant.inherit.from.anon=\

    cannot inherit from anonymous class

# 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: string (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

# 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.err.try.with.resources.expr.needs.var=\

    the try-with-resources resource must either be a variable declaration or an expression denoting \

a reference to a final or effectively final variable

# 0: symbol

compiler.err.try.with.resources.expr.effectively.final.var=\

    variable {0} used as a try-with-resources resource neither final nor 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 or 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=\