#

# Copyright (c) 1999, 2012, 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

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=\

    {0} is already defined in a single-type import

# 0: string

compiler.err.already.defined.static.single.import=\

    {0} is already defined in a static single-type import

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 value for the attribute {1}

# 0: type, 1: list of name

compiler.err.annotation.missing.default.value.1=\

    annotation {0} is missing values for attributes {1}

# 0: type

compiler.err.annotation.not.valid.for.type=\

    annotation not valid for a value 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=\

    attribute value must be constant

# 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.misc.not.a.functional.intf=\

    the target type must be a functional interface

# 0: message segment

compiler.misc.not.a.functional.intf.1=\

    the target type must be a functional interface\n\

    {0}

# 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: type

compiler.misc.secondary.bound.must.be.marker.intf=\

    secondary bound {0} must be a marker interface

# 0: symbol kind, 1: message segment

compiler.err.invalid.mref=\

    invalid {0} reference; {1}

# 0: symbol kind, 1: message segment

compiler.misc.invalid.mref=\

    invalid {0} reference; {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}

compiler.err.cyclic.annotation.element=\

    cyclic annotation element type

# 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 @interface member

# 0: symbol

compiler.err.doesnt.exist=\

    package {0} does not exist

compiler.err.duplicate.annotation=\

    duplicate annotation

# 0: type

compiler.err.duplicate.annotation.invalid.repeated=\

    annotation {0} cannot be repeated\nIt does not define a valid containing annotation.

# 0: name, 1: type

compiler.err.duplicate.annotation.member.value=\

    duplicate annotation member value {0} in {1}

# 0: type, 1: type

compiler.err.duplicate.annotation.missing.container=\

    duplicate annotation, the declaration of {0} does not have a valid {1} annotation

# 0: type, 1: type

compiler.err.invalid.container.no.containedby=\

    invalid contained repeatable annotation, {0} is not annotated with {1}

# 0: type, 1: type

compiler.err.invalid.container.wrong.containedby=\

    invalid contained repeatable annotation, {0} does not match {1}

# 0: type, 1: type

compiler.err.invalid.container.no.containerfor=\

    invalid container for repeating annotations, {0} is not annotated with {1}

# 0: type, 1: type

compiler.err.invalid.container.wrong.containerfor=\

    invalid container for repeating annotations, {0} does not match {1}

# 0: type

compiler.err.invalid.containedby.annotation=\

    duplicate annotation, {0} is annotated with an invalid ContainedBy annotation

# 0: type

compiler.err.invalid.containedby.annotation.no.value=\

    duplicate annotation, {0} is not a valid ContainedBy, no value element method declared

# 0: type, 1: number

compiler.err.invalid.containedby.annotation.multiple.values=\

    duplicate annotation, {0} is not a valid ContainedBy, {1} value element methods declared

# 0: type

compiler.err.invalid.containedby.annotation.invalid.value=\

    duplicate annotation, {0} is not a valid ContainedBy, invalid value element, need a method

# 0: type, 1: type, 2: type

compiler.err.invalid.containedby.annotation.value.return=\

    duplicate annotation, value element of containing annotation {0} should have type {2}, found {1}

# 0: type, 1: symbol

compiler.err.invalid.containedby.annotation.elem.nondefault=\

    containing annotation {0} does not have a default value for element {1}

# 0: symbol, 1: type, 2: symbol, 3: type

compiler.err.invalid.containedby.annotation.retention=\

    containing annotation {0} has shorter retention ({1}) than the contained annotation {2} with retention {3}

# 0: symbol, 1: symbol

compiler.err.invalid.containedby.annotation.not.documented=\

    containing annotation type, {0}, is not @Documented while repeated annotation type, {1}, is

# 0: symbol, 1: symbol

compiler.err.invalid.containedby.annotation.not.inherited=\

    containing annotation type, {0}, is not @Inherited while repeated annotation type, {1}, is

# 0: symbol, 1: symbol

compiler.err.invalid.containedby.annotation.incompatible.target=\

    target of container annotation {0} is not a subset of target of repeated annotation {1}

# 0: symbol

compiler.err.invalid.containedby.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