jdk8-mips64-public/langtools: src/share/classes/com/sun/tools/javac/resources/compiler.properties@bf54daa9dcd8

7153951: Add new lint option -Xlint:auxiliaryclass
Reviewed-by: jjg, mcimadamore, forax

1 #

     2 # Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.

     3 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

4 #

     5 # This code is free software; you can redistribute it and/or modify it

     6 # under the terms of the GNU General Public License version 2 only, as

     7 # published by the Free Software Foundation.  Oracle designates this

     8 # particular file as subject to the "Classpath" exception as provided

     9 # by Oracle in the LICENSE file that accompanied this code.

    10 #

    11 # This code is distributed in the hope that it will be useful, but WITHOUT

    12 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14 # version 2 for more details (a copy is included in the LICENSE file that

    15 # accompanied this code).

    16 #

    17 # You should have received a copy of the GNU General Public License version

    18 # 2 along with this work; if not, write to the Free Software Foundation,

    19 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20 #

    21 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22 # or visit www.oracle.com if you need additional information or have any

    23 # questions.

    24 #

    26 # Messages in this file which use "placeholders" for values (e.g. {0}, {1})

    27 # are preceded by a stylized comment describing the type of the corresponding

    28 # values.

    29 # The types currently in use are

    30 #

    31 # boolean           true or false

    32 # file name         the name of an input file; e.g.   MyFile.java

    33 # message segment   a sub-message; see compiler.misc.*

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

    35 # name              a name, typically a Java identifier

    36 # number            an integer

    37 # option name       the name of a command line option

    38 # source version    a source version number, such as 1.5, 1.6, 1.7

    39 # string            a general string

    40 # symbol            the name of a declared type

    41 # symbol kind       a description of the kind of a declaration; see compiler.misc.kindname.*

    42 # token             the name of a non-terminal in source code; see compiler.misc.token.*

    43 # type              a Java type; e.g. int, X, X<T>

    44 # unused            the value is not used in this message

    45 #

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

    47 # X or Y            alternation; e.g. message segment or type

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

    49 #

    50 # These may be composed: e.g.   list of type or message segment

    51 #

    52 # These comments are verified by the jtreg test test/tools/javac/diags/MessageInfo,

    53 # using info derived from the collected set of examples in test/tools/javac/diags/examples.

    54 # MessageInfo can also be run as a standalone utility providing more facilities

    55 # for manipulating this file. For more details, see MessageInfo.java.

    57 ##

    58 ## errors

    59 ##

    61 # 0: symbol

    62 compiler.err.abstract.cant.be.instantiated=\

    63     {0} is abstract; cannot be instantiated

    65 compiler.err.abstract.meth.cant.have.body=\

    66     abstract methods cannot have a body

    68 compiler.err.already.annotated=\

    69     {0} {1} has already been annotated

    71 # 0: symbol kind, 1: symbol, 2: symbol kind, 3: symbol

    72 compiler.err.already.defined=\

    73     {0} {1} is already defined in {2} {3}

    75 # 0: symbol kind, 1: symbol, 2: symbol kind, 3: symbol kind, 4: symbol

    76 compiler.err.already.defined.in.clinit=\

    77     {0} {1} is already defined in {2} of {3} {4}

    79 # 0: string

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

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

    83 # 0: string

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

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

    87 compiler.err.already.defined.this.unit=\

    88     {0} is already defined in this compilation unit

    90 # 0: type, 1: list of name

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

    92     annotation {0} is missing value for the attribute {1}

    94 # 0: type, 1: list of name

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

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

    98 # 0: type

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

   100     annotation not valid for a value of type {0}

   102 compiler.err.annotation.type.not.applicable=\

   103     annotation type not applicable to this kind of declaration

   105 compiler.err.annotation.value.must.be.annotation=\

   106     annotation value must be an annotation

   108 compiler.err.annotation.value.must.be.class.literal=\

   109     annotation value must be a class literal

   111 compiler.err.annotation.value.must.be.name.value=\

   112     annotation values must be of the form ''name=value''

   114 compiler.err.annotation.value.not.allowable.type=\

   115     annotation value not of an allowable type

   117 compiler.err.anon.class.impl.intf.no.args=\

   118     anonymous class implements interface; cannot have arguments

   120 compiler.err.anon.class.impl.intf.no.typeargs=\

   121     anonymous class implements interface; cannot have type arguments

   123 compiler.err.anon.class.impl.intf.no.qual.for.new=\

   124     anonymous class implements interface; cannot have qualifier for new

   126 # 0: symbol, 1: symbol, 2: symbol

   127 compiler.err.array.and.varargs=\

   128     cannot declare both {0} and {1} in {2}

   130 compiler.err.array.dimension.missing=\

   131     array dimension missing

   133 # 0: type

   134 compiler.err.array.req.but.found=\

   135     array required, but {0} found

   137 compiler.err.attribute.value.must.be.constant=\

   138     attribute value must be constant

   140 # 0: statement type

   141 compiler.err.bad.initializer=\

   142     bad initializer for {0}

   144 compiler.err.break.outside.switch.loop=\

   145     break outside switch or loop

   147 # 0: name

   148 compiler.err.call.must.be.first.stmt.in.ctor=\

   149     call to {0} must be first statement in constructor

   151 # 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

   152 compiler.err.cant.apply.symbol=\

   153     {0} {1} in {4} {5} cannot be applied to given types;\n\

   154     required: {2}\n\

   155     found: {3}\n\

   156     reason: {6}

   158 # 0: symbol kind, 1: name, 2: list of type

   159 compiler.err.cant.apply.symbols=\

   160     no suitable {0} found for {1}({2})

   162 # 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

   163 compiler.misc.cant.apply.symbol=\

   164     {0} {1} in {4} {5} cannot be applied to given types\n\

   165     required: {2}\n\

   166     found: {3}\n\

   167     reason: {6}

   169 # 0: symbol kind, 1: name, 2: list of type

   170 compiler.misc.cant.apply.symbols=\

   171     no suitable {0} found for {1}({2})

   174 # 0: type

   175 compiler.err.cant.access.arg.type.in.functional.desc=\

   176     cannot access parameter type {0} in target functional descriptor

   178 # 0: type

   179 compiler.err.cant.access.return.in.functional.desc=\

   180     cannot access return type {0} in target functional descriptor

   182 # 0: type

   183 compiler.err.cant.access.thrown.in.functional.desc=\

   184     cannot access thrown type {0} in target functional descriptor

   186 # 0: symbol kind, 1: symbol

   187 compiler.misc.no.abstracts=\

   188     no abstract method found in {0} {1}

   190 # 0: symbol kind, 1: symbol

   191 compiler.misc.incompatible.abstracts=\

   192     multiple non-overriding abstract methods found in {0} {1}

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

   195     the target type must be a functional interface

   197 # 0: message segment

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

   199     the target type must be a functional interface\n\

   200     {0}

   202 # 0: symbol, 1: symbol kind, 2: symbol

   203 compiler.misc.invalid.generic.desc.in.functional.intf=\

   204     invalid functional descriptor: method {0} in {1} {2} is generic

   206 # 0: symbol kind, 1: symbol

   207 compiler.misc.incompatible.descs.in.functional.intf=\

   208     incompatible function descriptors found in {0} {1}

   210 # 0: name, 1: list of type, 2: type, 3: list of type

   211 compiler.misc.descriptor=\

   212     descriptor: {2} {0}({1})

   214 # 0: name, 1: list of type, 2: type, 3: list of type

   215 compiler.misc.descriptor.throws=\

   216     descriptor: {2} {0}({1}) throws {3}

   218 # 0: type

   219 compiler.misc.no.suitable.functional.intf.inst=\

   220     cannot infer functional interface descriptor for {0}

   222 # 0: symbol kind, 1: message segment

   223 compiler.err.invalid.mref=\

   224     invalid {0} reference; {1}

   226 # 0: symbol kind, 1: message segment

   227 compiler.misc.invalid.mref=\

   228     invalid {0} reference; {1}

   230 # 0: symbol

   231 compiler.err.cant.assign.val.to.final.var=\

   232     cannot assign a value to final variable {0}

   234 # 0: symbol, 1: message segment

   235 compiler.err.cant.ref.non.effectively.final.var=\

   236     local variables referenced from {1} must be final or effectively final

   239 compiler.misc.lambda=\

   240     a lambda expression

   242 compiler.misc.inner.cls=\

   243     an inner class

   245 # 0: type

   246 compiler.err.cant.deref=\

   247     {0} cannot be dereferenced

   249 compiler.err.cant.extend.intf.annotation=\

   250     ''extends'' not allowed for @interfaces

   252 # 0: symbol

   253 compiler.err.cant.inherit.from.final=\

   254     cannot inherit from final {0}

   256 # 0: symbol

   257 compiler.err.cant.ref.before.ctor.called=\

   258     cannot reference {0} before supertype constructor has been called

   260 compiler.err.cant.ret.val.from.meth.decl.void=\

   261     cannot return a value from method whose result type is void

   263 compiler.err.cant.select.static.class.from.param.type=\

   264     cannot select a static class from a parameterized type

   266 # 0: symbol, 1: string, 2: string

   267 compiler.err.cant.inherit.diff.arg=\

   268     {0} cannot be inherited with different arguments: <{1}> and <{2}>

   270 compiler.err.catch.without.try=\

   271     ''catch'' without ''try''

   273 # 0: symbol kind, 1: symbol

   274 compiler.err.clash.with.pkg.of.same.name=\

   275     {0} {1} clashes with package of same name

   277 compiler.err.class.not.allowed=\

   278     class, interface or enum declaration not allowed here

   280 compiler.err.const.expr.req=\

   281     constant expression required

   283 compiler.err.cont.outside.loop=\

   284     continue outside of loop

   286 # 0: symbol

   287 compiler.err.cyclic.inheritance=\

   288     cyclic inheritance involving {0}

   290 compiler.err.cyclic.annotation.element=\

   291     cyclic annotation element type

   293 # 0: unused

   294 compiler.err.call.to.super.not.allowed.in.enum.ctor=\

   295     call to super not allowed in enum constructor

   297 # 0: type

   298 compiler.err.no.superclass=\

   299     {0} has no superclass

   301 # 0: symbol, 1: type, 2: symbol, 3: type, 4: unused

   302 compiler.err.concrete.inheritance.conflict=\

   303     methods {0} from {1} and {2} from {3} are inherited with the same signature

   305 compiler.err.default.allowed.in.intf.annotation.member=\

   306     default value only allowed in an @interface member

   308 # 0: symbol

   309 compiler.err.doesnt.exist=\

   310     package {0} does not exist

   312 compiler.err.duplicate.annotation=\

   313     duplicate annotation

   315 # 0: name, 1: type

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

   317     duplicate annotation member value {0} in {1}

   319 # 0: type

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

   321     duplicate annotation, the declaration of {0} does not have a ContainedBy annotation

   323 # 0: type, 1: type

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

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

   327 # 0: type, 1: type

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

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

   331 # 0: type, 1: type

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

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

   335 # 0: type, 1: type

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

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

   339 # 0: type

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

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

   343 # 0: type

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

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

   347 # 0: type, 1: number

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

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

   351 # 0: type

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

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

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

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

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

   359 # 0: type, 1: symbol

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

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

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

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

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

   367 # 0: symbol, 1: symbol

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

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

   371 # 0: symbol, 1: symbol

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

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

   375 # 0: symbol, 1: symbol

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

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

   379 # 0: symbol

   380 compiler.err.invalid.containedby.annotation.repeated.and.container.present=\

   381     container {0} must not be present at the same time as the element it contains

   383 # 0: name

   384 compiler.err.duplicate.class=\

   385     duplicate class: {0}

   387 compiler.err.duplicate.case.label=\

   388     duplicate case label

   390 compiler.err.duplicate.default.label=\

   391     duplicate default label

   393 compiler.err.else.without.if=\

   394     ''else'' without ''if''

   396 compiler.err.empty.char.lit=\

   397     empty character literal

   399 # 0: symbol

   400 compiler.err.encl.class.required=\

   401     an enclosing instance that contains {0} is required

   403 compiler.err.enum.annotation.must.be.enum.constant=\

   404     an enum annotation value must be an enum constant

   406 compiler.err.enum.cant.be.instantiated=\

   407     enum types may not be instantiated

   409 compiler.err.enum.label.must.be.unqualified.enum=\

   410     an enum switch case label must be the unqualified name of an enumeration constant

   412 compiler.err.enum.no.subclassing=\

   413     classes cannot directly extend java.lang.Enum

   415 compiler.err.enum.types.not.extensible=\

   416     enum types are not extensible

   418 compiler.err.enum.no.finalize=\

   419     enums cannot have finalize methods

   421 # 0: file name, 1: string

   422 compiler.err.error.reading.file=\

   423     error reading {0}; {1}

   425 # 0: type

   426 compiler.err.except.already.caught=\

   427     exception {0} has already been caught

   429 # 0: type

   430 compiler.err.except.never.thrown.in.try=\

   431     exception {0} is never thrown in body of corresponding try statement

   433 # 0: symbol

   434 compiler.err.final.parameter.may.not.be.assigned=\

   435     final parameter {0} may not be assigned

   437 # 0: symbol

   438 compiler.err.try.resource.may.not.be.assigned=\

   439     auto-closeable resource {0} may not be assigned

   441 # 0: symbol

   442 compiler.err.multicatch.parameter.may.not.be.assigned=\

   443     multi-catch parameter {0} may not be assigned

   445 # 0: type, 1: type

   446 compiler.err.multicatch.types.must.be.disjoint=\

   447     Alternatives in a multi-catch statement cannot be related by subclassing\n\

   448     Alternative {0} is a subclass of alternative {1}

   450 compiler.err.finally.without.try=\

   451     ''finally'' without ''try''

   453 # 0: type, 1: message segment

   454 compiler.err.foreach.not.applicable.to.type=\

   455     for-each not applicable to expression type\n\

   456     required: {1}\n\

   457     found:    {0}

   459 compiler.err.fp.number.too.large=\

   460     floating point number too large

   462 compiler.err.fp.number.too.small=\

   463     floating point number too small

   465 compiler.err.generic.array.creation=\

   466     generic array creation

   468 compiler.err.generic.throwable=\

   469     a generic class may not extend java.lang.Throwable

   471 # 0: symbol

   472 compiler.err.icls.cant.have.static.decl=\

   473     Illegal static declaration in inner class {0}\n\

   474     modifier \''static\'' is only allowed in constant variable declarations

   476 # 0: string

   477 compiler.err.illegal.char=\

   478     illegal character: \\{0}

   480 compiler.err.illegal.char.for.encoding=\

   481     unmappable character for encoding {0}

   483 # 0: set of modifier, 1: set of modifier

   484 compiler.err.illegal.combination.of.modifiers=\

   485     illegal combination of modifiers: {0} and {1}

   487 compiler.err.illegal.enum.static.ref=\

   488     illegal reference to static field from initializer

   490 compiler.err.illegal.esc.char=\

   491     illegal escape character

   493 compiler.err.illegal.forward.ref=\

   494     illegal forward reference

   496 # 0: symbol

   497 compiler.warn.forward.ref=\

   498     reference to variable ''{0}'' before it has been initialized

   500 compiler.err.illegal.self.ref=\

   501     self-reference in initializer

   503 # 0: symbol

   504 compiler.warn.self.ref=\

   505     self-reference in initializer of variable ''{0}''

   507 compiler.err.illegal.generic.type.for.instof=\

   508     illegal generic type for instanceof

   510 # 0: type

   511 compiler.err.illegal.initializer.for.type=\

   512     illegal initializer for {0}

   514 compiler.err.illegal.line.end.in.char.lit=\

   515     illegal line end in character literal

   517 compiler.err.illegal.nonascii.digit=\

   518     illegal non-ASCII digit

   520 compiler.err.illegal.underscore=\

   521     illegal underscore

   523 compiler.err.illegal.dot=\

   524     illegal ''.''

   526 # 0: symbol

   527 compiler.err.illegal.qual.not.icls=\

   528     illegal qualifier; {0} is not an inner class

   530 compiler.err.illegal.start.of.expr=\

   531     illegal start of expression

   533 compiler.err.illegal.start.of.stmt=\

   534     illegal start of statement

   536 compiler.err.illegal.start.of.type=\

   537     illegal start of type

   539 compiler.err.illegal.unicode.esc=\

   540     illegal unicode escape

   542 # 0: symbol

   543 compiler.err.import.requires.canonical=\

   544     import requires canonical name for {0}

   546 compiler.err.improperly.formed.type.param.missing=\

   547     improperly formed type, some parameters are missing

   549 compiler.err.improperly.formed.type.inner.raw.param=\

   550     improperly formed type, type arguments given on a raw type

   552 # 0: type, 1: type

   553 compiler.err.incomparable.types=\

   554     incomparable types: {0} and {1}

   556 # 0: number

   557 compiler.err.int.number.too.large=\

   558     integer number too large: {0}

   560 compiler.err.intf.annotation.members.cant.have.params=\

   561     @interface members may not have parameters

   563 compiler.err.intf.annotation.cant.have.type.params=\

   564     @interface may not have type parameters

   566 compiler.err.intf.annotation.members.cant.have.type.params=\

   567     @interface members may not have type parameters

   569 # 0: symbol, 1: type

   570 compiler.err.intf.annotation.member.clash=\

   571     @interface member clashes with method ''{0}'' in {1}

   573 compiler.err.intf.expected.here=\

   574     interface expected here

   576 compiler.err.intf.meth.cant.have.body=\

   577     interface methods cannot have body

   579 compiler.err.invalid.annotation.member.type=\

   580     invalid type for annotation member

   582 compiler.err.invalid.binary.number=\

   583     binary numbers must contain at least one binary digit

   585 compiler.err.invalid.hex.number=\

   586     hexadecimal numbers must contain at least one hexadecimal digit

   588 compiler.err.invalid.meth.decl.ret.type.req=\

   589     invalid method declaration; return type required

   591 compiler.err.varargs.and.old.array.syntax=\

   592     legacy array notation not allowed on variable-arity parameter

   594 compiler.err.variable.not.allowed=\

   595     variable declaration not allowed here

   597 # 0: name

   598 compiler.err.label.already.in.use=\

   599     label {0} already in use

   601 # 0: symbol

   602 compiler.err.local.var.accessed.from.icls.needs.final=\

   603     local variable {0} is accessed from within inner class; needs to be declared final

   605 compiler.err.local.enum=\

   606     enum types must not be local

   608 compiler.err.cannot.create.array.with.type.arguments=\

   609     cannot create array with type arguments

   611 compiler.err.cannot.create.array.with.diamond=\

   612     cannot create array with ''<>''

   614 #

   615 # limits.  We don't give the limits in the diagnostic because we expect

   616 # them to change, yet we want to use the same diagnostic.  These are all

   617 # detected during code generation.

   618 #

   619 compiler.err.limit.code=\

   620     code too large

   622 compiler.err.limit.code.too.large.for.try.stmt=\

   623     code too large for try statement

   625 compiler.err.limit.dimensions=\

   626     array type has too many dimensions

   628 compiler.err.limit.locals=\

   629     too many local variables

   631 compiler.err.limit.parameters=\

   632     too many parameters

   634 compiler.err.limit.pool=\

   635     too many constants

   637 compiler.err.limit.pool.in.class=\

   638     too many constants in class {0}

   640 compiler.err.limit.stack=\

   641     code requires too much stack

   643 compiler.err.limit.string=\

   644     constant string too long

   646 compiler.err.limit.string.overflow=\

   647     UTF8 representation for string \"{0}...\" is too long for the constant pool

   649 compiler.err.malformed.fp.lit=\

   650     malformed floating point literal

   652 compiler.err.method.does.not.override.superclass=\

   653     method does not override or implement a method from a supertype

   655 compiler.err.missing.meth.body.or.decl.abstract=\

   656     missing method body, or declare abstract

   658 compiler.err.missing.ret.stmt=\

   659     missing return statement

   661 compiler.misc.missing.ret.val=\

   662     missing return value

   664 compiler.err.missing.ret.val=\

   665     missing return value

   667 # 0: set of modifier

   668 compiler.err.mod.not.allowed.here=\

   669     modifier {0} not allowed here

   671 compiler.err.intf.not.allowed.here=\

   672     interface not allowed here

   674 compiler.err.enums.must.be.static=\

   675     enum declarations allowed only in static contexts

   677 # 0: symbol, 1: symbol

   678 compiler.err.name.clash.same.erasure=\

   679     name clash: {0} and {1} have the same erasure

   681 # 0: symbol, 1: symbol, 2: symbol, 3: symbol, 4: unused, 5: unused

   682 compiler.err.name.clash.same.erasure.no.override=\

   683     name clash: {0} in {1} and {2} in {3} have the same erasure, yet neither overrides the other

   685 # 0: symbol, 1: symbol, 2: symbol, 3: symbol, 4: symbol, 5: symbol

   686 compiler.err.name.clash.same.erasure.no.override.1=\

   687     name clash: {0} in {1} overrides a method whose erasure is the same as another method, yet neither overrides the other\n\

   688     first method:  {2} in {3}\n\

   689     second method: {4} in {5}

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

   692 compiler.err.name.clash.same.erasure.no.hide=\

   693     name clash: {0} in {1} and {2} in {3} have the same erasure, yet neither hides the other

   695 compiler.err.name.reserved.for.internal.use=\

   696     {0} is reserved for internal use

   698 compiler.err.native.meth.cant.have.body=\

   699     native methods cannot have a body

   701 # 0: type, 1: type

   702 compiler.err.neither.conditional.subtype=\

   703     incompatible types for ?: neither is a subtype of the other\n\

   704     second operand: {0}\n\

   705     third operand : {1}

   707 # 0: message segment

   708 compiler.misc.incompatible.type.in.conditional=\

   709     bad type in conditional expression; {0}

   711 # 0: type

   712 compiler.misc.incompatible.ret.type.in.lambda=\

   713     bad return type in lambda expression\n\

   714     {0}

   716 # 0: type

   717 compiler.misc.incompatible.ret.type.in.mref=\

   718     bad return type in method reference\n\

   719     {0}

   721 # 0: list of type

   722 compiler.err.incompatible.thrown.types.in.lambda=\

   723     incompatible thrown types {0} in lambda expression

   725 # 0: list of type

   726 compiler.err.incompatible.thrown.types.in.mref=\

   727     incompatible thrown types {0} in method reference

   729 compiler.misc.incompatible.arg.types.in.lambda=\

   730     incompatible parameter types in lambda expression

   732 compiler.err.new.not.allowed.in.annotation=\

   733     ''new'' not allowed in an annotation

   735 compiler.err.no.annotation.member=\

   736     no annotation member {0} in {1}

   738 compiler.err.no.encl.instance.of.type.in.scope=\

   739     no enclosing instance of type {0} is in scope

   741 compiler.err.no.intf.expected.here=\

   742     no interface expected here

   744 compiler.err.no.match.entry=\

   745     {0} has no match in entry in {1}; required {2}

   747 compiler.err.not.annotation.type=\

   748     {0} is not an annotation type

   750 # 0: symbol, 1: symbol

   751 compiler.err.not.def.access.class.intf.cant.access=\

   752     {0} in {1} is defined in an inaccessible class or interface

   754 # 0: symbol, 1: symbol

   755 compiler.misc.not.def.access.class.intf.cant.access=\

   756     {0} in {1} is defined in an inaccessible class or interface

   758 # 0: symbol, 1: list of type, 2: type

   759 compiler.misc.cant.access.inner.cls.constr=\

   760     cannot access constructor {0}({1})\n\

   761     an enclosing instance of type {2} is not in scope

   763 # 0: symbol, 1: symbol

   764 compiler.err.not.def.public.cant.access=\

   765     {0} is not public in {1}; cannot be accessed from outside package

   767 # 0: name

   768 compiler.err.not.loop.label=\

   769     not a loop label: {0}

   771 compiler.err.not.stmt=\

   772     not a statement

   774 # 0: symbol

   775 compiler.err.not.encl.class=\

   776     not an enclosing class: {0}

   778 # 0: name, 1: type, 2: unused

   779 compiler.err.operator.cant.be.applied=\

   780     bad operand type {1} for unary operator ''{0}''

   782 # 0: name, 1: type, 2: type

   783 compiler.err.operator.cant.be.applied.1=\

   784     bad operand types for binary operator ''{0}''\n\

   785     first type:  {1}\n\

   786     second type: {2}

   788 compiler.err.pkg.annotations.sb.in.package-info.java=\

   789     package annotations should be in file package-info.java

   791 # 0: symbol

   792 compiler.err.pkg.clashes.with.class.of.same.name=\

   793     package {0} clashes with class of same name

   795 compiler.err.warnings.and.werror=\

   796     warnings found and -Werror specified

   798 # Errors related to annotation processing

   800 # 0: symbol, 1: string, 2: stack-trace

   801 compiler.err.proc.cant.access=\

   802     cannot access {0}\n\

   803     {1}\n\

   804     Consult the following stack trace for details.\n\

   805     {2}

   807 # 0: symbol, 1: string

   808 compiler.err.proc.cant.access.1=\

   809     cannot access {0}\n\

   810     {1}

   812 # 0: string

   813 compiler.err.proc.cant.find.class=\

   814     Could not find class file for ''{0}''.

   816 # Print a client-generated error message; assumed to be localized, no translation required

   817 # 0: string

   818 compiler.err.proc.messager=\

   819     {0}

   821 # 0: list of string

   822 compiler.err.proc.no.explicit.annotation.processing.requested=\

   823     Class names, ''{0}'', are only accepted if annotation processing is explicitly requested

   825 compiler.err.proc.no.service=\

   826     A ServiceLoader was not usable and is required for annotation processing.

   828 compiler.err.proc.processor.bad.option.name=\

   829     Bad option name ''{0}'' provided by processor ''{1}''

   831 # 0: string

   832 compiler.err.proc.processor.cant.instantiate=\

   833     Could not instantiate an instance of processor ''{0}''

   835 # 0: string

   836 compiler.err.proc.processor.not.found=\

   837     Annotation processor ''{0}'' not found

   839 # 0: string

   840 compiler.err.proc.processor.wrong.type=\

   841     Annotation processor ''{0}'' does not implement javax.annotation.processing.Processor

   843 compiler.err.proc.service.problem=\

   844     Error creating a service loader to load Processors.

   846 compiler.err.proc.bad.config.file=\

   847     Bad service configuration file, or exception thrown while constructing Processor object: {0}

   849 compiler.err.proc.cant.create.loader=\

   850     Could not create class loader for annotation processors: {0}

   852 # 0: unused

   853 compiler.err.qualified.new.of.static.class=\

   854     qualified new of static class

   856 compiler.err.recursive.ctor.invocation=\

   857     recursive constructor invocation

   859 # 0: name, 1: symbol kind, 2: symbol, 3: symbol, 4: symbol kind, 5: symbol, 6: symbol

   860 compiler.err.ref.ambiguous=\

   861     reference to {0} is ambiguous\n\

   862     both {1} {2} in {3} and {4} {5} in {6} match

   864 # 0: name, 1: symbol kind, 2: symbol, 3: symbol, 4: symbol kind, 5: symbol, 6: symbol

   865 compiler.misc.ref.ambiguous=\

   866     reference to {0} is ambiguous\n\

   867     both {1} {2} in {3} and {4} {5} in {6} match

   869 compiler.err.repeated.annotation.target=\

   870     repeated annotation target

   872 compiler.err.repeated.interface=\

   873     repeated interface

   875 compiler.err.repeated.modifier=\

   876     repeated modifier

   878 # 0: symbol, 1: set of modifier, 2: symbol

   879 compiler.err.report.access=\

   880     {0} has {1} access in {2}

   882 compiler.err.ret.outside.meth=\

   883     return outside method

   885 compiler.err.signature.doesnt.match.supertype=\

   886     signature does not match {0}; incompatible supertype

   888 compiler.err.signature.doesnt.match.intf=\

   889     signature does not match {0}; incompatible interfaces

   891 # 0: symbol, 1: symbol, 2: symbol

   892 compiler.err.does.not.override.abstract=\

   893     {0} is not abstract and does not override abstract method {1} in {2}

   895 compiler.err.source.cant.overwrite.input.file=\

   896     error writing source; cannot overwrite input file {0}

   898 compiler.err.stack.sim.error=\

   899     Internal error: stack sim error on {0}

   901 compiler.err.static.imp.only.classes.and.interfaces=\

   902     static import only from classes and interfaces

   904 compiler.err.string.const.req=\

   905     constant string expression required

   907 # 0: symbol, 1: symbol

   908 compiler.err.synthetic.name.conflict=\

   909     the symbol {0} conflicts with a compiler-synthesized symbol in {1}

   911 # 0: symbol, 1: symbol

   912 compiler.warn.synthetic.name.conflict=\

   913     the symbol {0} conflicts with a compiler-synthesized symbol in {1}

   915 compiler.err.throws.not.allowed.in.intf.annotation=\

   916     throws clause not allowed in @interface members

   918 compiler.err.try.without.catch.or.finally=\

   919     ''try'' without ''catch'' or ''finally''

   921 compiler.err.try.without.catch.finally.or.resource.decls=\

   922     ''try'' without ''catch'', ''finally'' or resource declarations

   924 # 0: symbol

   925 compiler.err.type.doesnt.take.params=\

   926     type {0} does not take parameters

   928 compiler.err.type.var.cant.be.deref=\

   929     cannot select from a type variable

   931 compiler.err.type.var.may.not.be.followed.by.other.bounds=\

   932     a type variable may not be followed by other bounds

   934 compiler.err.type.var.more.than.once=\

   935     type variable {0} occurs more than once in result type of {1}; cannot be left uninstantiated

   937 compiler.err.type.var.more.than.once.in.result=\

   938     type variable {0} occurs more than once in type of {1}; cannot be left uninstantiated

   940 # 0: type, 1: type, 2: string

   941 compiler.err.types.incompatible.diff.ret=\

   942     types {0} and {1} are incompatible; both define {2}, but with unrelated return types

   944 compiler.err.unclosed.char.lit=\

   945     unclosed character literal

   947 compiler.err.unclosed.comment=\

   948     unclosed comment

   950 compiler.err.unclosed.str.lit=\

   951     unclosed string literal

   953 # 0: name

   954 compiler.err.unsupported.encoding=\

   955     unsupported encoding: {0}

   957 compiler.err.io.exception=\

   958     error reading source file: {0}

   960 # 0: name

   961 compiler.err.undef.label=\

   962     undefined label: {0}

   964 # 0: message segment, 1: unused

   965 compiler.err.cant.apply.diamond=\

   966     cannot infer type arguments for {0}

   968 # 0: message segment or type, 1: message segment

   969 compiler.err.cant.apply.diamond.1=\

   970     cannot infer type arguments for {0}\n\

   971     reason: {1}

   973 # 0: message segment or type, 1: message segment

   974 compiler.misc.cant.apply.diamond.1=\

   975     cannot infer type arguments for {0}\n\

   976     reason: {1}

   978 compiler.err.unreachable.stmt=\

   979     unreachable statement

   981 compiler.err.initializer.must.be.able.to.complete.normally=\

   982     initializer must be able to complete normally

   984 # 0: type

   985 compiler.err.unreported.exception.need.to.catch.or.throw=\

   986     unreported exception {0}; must be caught or declared to be thrown

   988 # 0: type

   989 compiler.err.unreported.exception.default.constructor=\

   990     unreported exception {0} in default constructor

   992 # 0: type, 1: name

   993 compiler.err.unreported.exception.implicit.close=\

   994     unreported exception {0}; must be caught or declared to be thrown\n\

   995     exception thrown from implicit call to close() on resource variable ''{1}''

   997 compiler.err.unsupported.cross.fp.lit=\

   998     hexadecimal floating-point literals are not supported on this VM

  1000 compiler.err.void.not.allowed.here=\

  1001     ''void'' type not allowed here

  1003 # 0: string

  1004 compiler.err.wrong.number.type.args=\

  1005     wrong number of type arguments; required {0}

  1007 # 0: symbol

  1008 compiler.err.var.might.already.be.assigned=\

  1009     variable {0} might already have been assigned

  1011 # 0: symbol

  1012 compiler.err.var.might.not.have.been.initialized=\

  1013     variable {0} might not have been initialized

  1015 # 0: symbol

  1016 compiler.err.var.might.be.assigned.in.loop=\

  1017     variable {0} might be assigned in loop

  1019 # 0: symbol, 1: message segment

  1020 compiler.err.varargs.invalid.trustme.anno=\

  1021     Invalid {0} annotation. {1}

  1023 # 0: type

  1024 compiler.misc.varargs.trustme.on.reifiable.varargs=\

  1025     Varargs element type {0} is reifiable.

  1027 # 0: symbol

  1028 compiler.misc.varargs.trustme.on.non.varargs.meth=\

  1029     Method {0} is not a varargs method.

  1031 # 0: symbol

  1032 compiler.misc.varargs.trustme.on.virtual.varargs=\

  1033     Instance method {0} is not final.

  1035 # 0: type, 1: symbol kind, 2: symbol

  1036 compiler.misc.inaccessible.varargs.type=\

  1037     formal varargs element type {0} is not accessible from {1} {2}

  1039 # In the following string, {1} will always be the detail message from

  1040 # java.io.IOException.

  1041 # 0: symbol, 1: string

  1042 compiler.err.class.cant.write=\

  1043     error while writing {0}: {1}

  1045 # In the following string, {0} is the name of the class in the Java source.

  1046 # It really should be used two times..

  1047 # 0: name

  1048 compiler.err.class.public.should.be.in.file=\

  1049     class {0} is public, should be declared in a file named {0}.java

  1051 ## All errors which do not refer to a particular line in the source code are

  1052 ## preceded by this string.

  1053 compiler.err.error=\

  1054     error:\u0020

  1056 # The following error messages do not refer to a line in the source code.

  1057 compiler.err.cant.read.file=\

  1058     cannot read: {0}

  1060 #####

  1062 # Fatal Errors

  1064 compiler.misc.fatal.err.no.java.lang=\

  1065     Fatal Error: Unable to find package java.lang in classpath or bootclasspath

  1067 compiler.misc.fatal.err.cant.locate.meth=\

  1068     Fatal Error: Unable to find method {0}

  1070 compiler.misc.fatal.err.cant.locate.field=\

  1071     Fatal Error: Unable to find field {0}

  1073 compiler.misc.fatal.err.cant.locate.ctor=\

  1074     Fatal Error: Unable to find constructor for {0}

  1076 compiler.misc.fatal.err.cant.close=\

  1077     Fatal Error: Cannot close compiler resources

  1079 #####

  1081 ##

  1082 ## miscellaneous strings

  1083 ##

  1085 compiler.misc.source.unavailable=\

  1086     (source unavailable)

  1088 compiler.misc.base.membership=\

  1089     all your base class are belong to us

  1091 # 0: string, 1: string, 2: boolean

  1092 compiler.misc.x.print.processor.info=\

  1093     Processor {0} matches {1} and returns {2}.

  1095 # 0: number, 1: string, 2: set of symbol, 3: boolean

  1096 compiler.misc.x.print.rounds=\

  1097     Round {0}:\n\tinput files: {1}\n\tannotations: {2}\n\tlast round: {3}

  1099 #####

  1101 ## The following string will appear before all messages keyed as:

  1102 ## "compiler.note".

  1104 compiler.note.potential.lambda.found=\

  1105     This anonymous inner class creation can be turned into a lambda expression.

  1107 compiler.note.note=\

  1108     Note:\u0020

  1110 # 0: file name

  1111 compiler.note.deprecated.filename=\

  1112     {0} uses or overrides a deprecated API.

  1114 compiler.note.deprecated.plural=\

  1115     Some input files use or override a deprecated API.

  1117 # The following string may appear after one of the above deprecation

  1118 # messages.

  1119 compiler.note.deprecated.recompile=\

  1120     Recompile with -Xlint:deprecation for details.

  1122 # 0: file name

  1123 compiler.note.deprecated.filename.additional=\

  1124     {0} has additional uses or overrides of a deprecated API.

  1126 compiler.note.deprecated.plural.additional=\

  1127     Some input files additionally use or override a deprecated API.

  1129 # 0: file name

  1130 compiler.note.unchecked.filename=\

  1131     {0} uses unchecked or unsafe operations.

  1133 compiler.note.unchecked.plural=\

  1134     Some input files use unchecked or unsafe operations.

  1136 # The following string may appear after one of the above deprecation

  1137 # messages.

  1138 compiler.note.unchecked.recompile=\

  1139     Recompile with -Xlint:unchecked for details.

  1141 # 0: file name

  1142 compiler.note.unchecked.filename.additional=\

  1143     {0} has additional unchecked or unsafe operations.

  1145 compiler.note.unchecked.plural.additional=\

  1146     Some input files additionally use unchecked or unsafe operations.

  1148 # 0: file name

  1149 compiler.note.sunapi.filename=\

  1150     {0} uses internal proprietary API that may be removed in a future release.

  1152 compiler.note.sunapi.plural=\

  1153     Some input files use internal proprietary API that may be removed in a future release.

  1155 # The following string may appear after one of the above sunapi messages.

  1156 compiler.note.sunapi.recompile=\

  1157     Recompile with -Xlint:sunapi for details.

  1159 # 0: file name

  1160 compiler.note.sunapi.filename.additional=\

  1161     {0} uses additional internal proprietary API that may be removed in a future release.

  1163 compiler.note.sunapi.plural.additional=\

  1164     Some input files additionally use internal proprietary API that may be removed in a future release.

  1166 # Notes related to annotation processing

  1168 # Print a client-generated note; assumed to be localized, no translation required

  1169 # 0: string

  1170 compiler.note.proc.messager=\

  1171     {0}

  1173 #####

  1175 # 0: number

  1176 compiler.misc.count.error=\

  1177     {0} error

  1179 # 0: number

  1180 compiler.misc.count.error.plural=\

  1181     {0} errors

  1183 # 0: number

  1184 compiler.misc.count.warn=\

  1185     {0} warning

  1187 # 0: number

  1188 compiler.misc.count.warn.plural=\

  1189     {0} warnings

  1191 compiler.misc.version.not.available=\

  1192     (version info not available)

  1194 ## extra output when using -verbose (JavaCompiler)

  1196 # 0: symbol

  1197 compiler.misc.verbose.checking.attribution=\

  1198     [checking {0}]

  1200 # 0: string

  1201 compiler.misc.verbose.parsing.done=\

  1202     [parsing completed {0}ms]

  1204 # 0: file name

  1205 compiler.misc.verbose.parsing.started=\

  1206     [parsing started {0}]

  1208 # 0: string

  1209 compiler.misc.verbose.total=\

  1210     [total {0}ms]

  1212 # 0: file name

  1213 compiler.misc.verbose.wrote.file=\

  1214     [wrote {0}]

  1216 ## extra output when using -verbose (Retro)

  1217 compiler.misc.verbose.retro=\

  1218     [retrofitting {0}]

  1220 compiler.misc.verbose.retro.with=\

  1221     \tretrofitting {0} with {1}

  1223 compiler.misc.verbose.retro.with.list=\

  1224     \tretrofitting {0} with type parameters {1}, supertype {2}, interfaces {3}

  1226 ## extra output when using -verbose (code/ClassReader)

  1227 # 0: string

  1228 compiler.misc.verbose.loading=\

  1229     [loading {0}]

  1231 # 0: string

  1232 compiler.misc.verbose.sourcepath=\

  1233     [search path for source files: {0}]

  1235 # 0: string

  1236 compiler.misc.verbose.classpath=\

  1237     [search path for class files: {0}]

  1239 ## extra output when using -checkclassfile (code/ClassReader)

  1240 compiler.misc.ccf.found.later.version=\

  1241     class file has later version than expected: {0}

  1243 compiler.misc.ccf.unrecognized.attribute=\

  1244     unrecognized attribute: {0}

  1246 ## extra output when using -prompt (util/Log)

  1247 compiler.misc.resume.abort=\

  1248     R)esume, A)bort>

  1250 #####

  1252 ##

  1253 ## warnings

  1254 ##

  1256 ## All warning messages are preceded by the following string.

  1257 compiler.warn.warning=\

  1258     warning:\u0020

  1260 ## Warning messages may also include the following prefix to identify a

  1261 ## lint option

  1262 # 0: option name

  1263 compiler.warn.lintOption=\

  1264     [{0}]\u0020

  1266 # 0: symbol

  1267 compiler.warn.constant.SVUID=\

  1268     serialVersionUID must be constant in class {0}

  1270 # 0: file name

  1271 compiler.warn.dir.path.element.not.found=\

  1272     bad path element "{0}": no such directory

  1274 compiler.warn.finally.cannot.complete=\

  1275     finally clause cannot complete normally

  1277 # 0: symbol, 1: symbol

  1278 compiler.warn.has.been.deprecated=\

  1279     {0} in {1} has been deprecated

  1281 # 0: symbol

  1282 compiler.warn.sun.proprietary=\

  1283     {0} is internal proprietary API and may be removed in a future release

  1285 compiler.warn.illegal.char.for.encoding=\

  1286     unmappable character for encoding {0}

  1288 # 0: symbol

  1289 compiler.warn.improper.SVUID=\

  1290     serialVersionUID must be declared static final in class {0}

  1292 # 0: type, 1: type

  1293 compiler.warn.inexact.non-varargs.call=\

  1294     non-varargs call of varargs method with inexact argument type for last parameter;\n\

  1295     cast to {0} for a varargs call\n\

  1296     cast to {1} for a non-varargs call and to suppress this warning

  1298 # 0: list of type

  1299 compiler.warn.unreachable.catch=\

  1300     unreachable catch clause\n\

  1301     thrown type {0} has already been caught

  1303 # 0: list of type

  1304 compiler.warn.unreachable.catch.1=\

  1305     unreachable catch clause\n\

  1306     thrown types {0} have already been caught

  1308 # 0: symbol

  1309 compiler.warn.long.SVUID=\

  1310     serialVersionUID must be of type long in class {0}

  1312 # 0: symbol

  1313 compiler.warn.missing.SVUID=\

  1314     serializable class {0} has no definition of serialVersionUID

  1316 # 0: message segment

  1317 compiler.warn.override.varargs.missing=\

  1318     {0}; overridden method has no ''...''

  1320 # 0: message segment

  1321 compiler.warn.override.varargs.extra=\

  1322     {0}; overriding method is missing ''...''

  1324 compiler.warn.override.bridge=\

  1325     {0}; overridden method is a bridge method

  1327 # 0: symbol

  1328 compiler.warn.pkg-info.already.seen=\

  1329     a package-info.java file has already been seen for package {0}

  1331 # 0: file name

  1332 compiler.warn.path.element.not.found=\

  1333     bad path element "{0}": no such file or directory

  1335 compiler.warn.possible.fall-through.into.case=\

  1336     possible fall-through into case

  1338 # 0: type

  1339 compiler.warn.redundant.cast=\

  1340     redundant cast to {0}

  1342 # 0: number

  1343 compiler.warn.position.overflow=\

  1344     Position encoding overflows at line {0}

  1346 # 0: file name, 1: number, 2: number

  1347 compiler.warn.big.major.version=\

  1348     {0}: major version {1} is newer than {2}, the highest major version supported by this compiler.\n\

  1349     It is recommended that the compiler be upgraded.

  1351 # 0: symbol kind, 1: symbol

  1352 compiler.warn.static.not.qualified.by.type=\

  1353     static {0} should be qualified by type name, {1}, instead of by an expression

  1355 # 0: string

  1356 compiler.warn.source.no.bootclasspath=\

  1357     bootstrap class path not set in conjunction with -source {0}

  1359 # 0: name, 1: number, 2: number, 3: number, 4: number

  1360 compiler.warn.future.attr=\

  1361     {0} attribute introduced in version {1}.{2} class files is ignored in version {3}.{4} class files

  1363 # Warnings related to annotation processing

  1364 # 0: name

  1365 compiler.warn.proc.package.does.not.exist=\

  1366     package {0} does not exist

  1368 # 0: name

  1369 compiler.warn.proc.file.reopening=\

  1370     Attempt to create a file for ''{0}'' multiple times

  1372 # 0: name

  1373 compiler.warn.proc.type.already.exists=\

  1374     A file for type ''{0}'' already exists on the sourcepath or classpath

  1376 # 0: name

  1377 compiler.warn.proc.type.recreate=\

  1378     Attempt to create a file for type ''{0}'' multiple times

  1380 # 0: string

  1381 compiler.warn.proc.illegal.file.name=\

  1382     Cannot create file for illegal name ''{0}''.

  1384 # 0: string, 1: string

  1385 compiler.warn.proc.suspicious.class.name=\

  1386     Creating file for a type whose name ends in {1}: ''{0}''

  1388 # 0: name

  1389 compiler.warn.proc.file.create.last.round=\

  1390     File for type ''{0}'' created in the last round will not be subject to annotation processing.

  1392 # 0: string, 1: string

  1393 compiler.warn.proc.malformed.supported.string=\

  1394     Malformed string ''{0}'' for a supported annotation type returned by processor ''{1}''

  1396 # 0: set of string

  1397 compiler.warn.proc.annotations.without.processors=\

  1398     No processor claimed any of these annotations: {0}

  1400 # 0: source version, 1: string, 2: string

  1401 compiler.warn.proc.processor.incompatible.source.version=\

  1402     Supported source version ''{0}'' from annotation processor ''{1}'' less than -source ''{2}''

  1404 compiler.warn.proc.proc-only.requested.no.procs=\

  1405     Annotation processing without compilation requested but no processors were found.

  1407 compiler.warn.proc.use.implicit=\

  1408     Implicitly compiled files were not subject to annotation processing.\n\

  1409     Use -implicit to specify a policy for implicit compilation.

  1411 compiler.warn.proc.use.proc.or.implicit=\

  1412     Implicitly compiled files were not subject to annotation processing.\n\

  1413     Use -proc:none to disable annotation processing or -implicit to specify a policy for implicit compilation.

  1415 # Print a client-generated warning; assumed to be localized, no translation required

  1416 # 0: string

  1417 compiler.warn.proc.messager=\

  1418     {0}

  1420 # 0: set of name

  1421 compiler.warn.proc.unclosed.type.files=\

  1422     Unclosed files for the types ''{0}''; these types will not undergo annotation processing

  1424 # 0: string

  1425 compiler.warn.proc.unmatched.processor.options=\

  1426     The following options were not recognized by any processor: ''{0}''

  1428 compiler.warn.try.explicit.close.call=\

  1429     explicit call to close() on an auto-closeable resource

  1431 # 0: symbol

  1432 compiler.warn.try.resource.not.referenced=\

  1433     auto-closeable resource {0} is never referenced in body of corresponding try statement

  1435 # 0: type

  1436 compiler.warn.try.resource.throws.interrupted.exc=\

  1437     auto-closeable resource {0} has a member method close() that could throw InterruptedException

  1439 compiler.warn.unchecked.assign=\

  1440     unchecked assignment: {0} to {1}

  1442 # 0: symbol, 1: type

  1443 compiler.warn.unchecked.assign.to.var=\

  1444     unchecked assignment to variable {0} as member of raw type {1}

  1446 # 0: symbol, 1: type

  1447 compiler.warn.unchecked.call.mbr.of.raw.type=\

  1448     unchecked call to {0} as a member of the raw type {1}

  1450 compiler.warn.unchecked.cast.to.type=\

  1451     unchecked cast to type {0}

  1453 # 0: symbol kind, 1: name, 2: list of type, 3: list of type, 4: symbol kind, 5: symbol

  1454 compiler.warn.unchecked.meth.invocation.applied=\

  1455     unchecked method invocation: {0} {1} in {4} {5} is applied to given types\n\

  1456     required: {2}\n\

  1457     found: {3}

  1459 # 0: type

  1460 compiler.warn.unchecked.generic.array.creation=\

  1461     unchecked generic array creation for varargs parameter of type {0}

  1463 # 0: type

  1464 compiler.warn.unchecked.varargs.non.reifiable.type=\

  1465     Possible heap pollution from parameterized vararg type {0}

  1467 # 0: symbol

  1468 compiler.warn.varargs.unsafe.use.varargs.param=\

  1469     Varargs method could cause heap pollution from non-reifiable varargs parameter {0}

  1471 compiler.warn.missing.deprecated.annotation=\

  1472     deprecated item is not annotated with @Deprecated

  1474 compiler.warn.invalid.archive.file=\

  1475     Unexpected file on path: {0}

  1477 compiler.warn.unexpected.archive.file=\

  1478     Unexpected extension for archive file: {0}

  1480 compiler.warn.div.zero=\

  1481     division by zero

  1483 compiler.warn.empty.if=\

  1484     empty statement after if

  1486 compiler.warn.annotation.method.not.found=\

  1487     Cannot find annotation method ''{1}()'' in type ''{0}''

  1489 compiler.warn.annotation.method.not.found.reason=\

  1490     Cannot find annotation method ''{1}()'' in type ''{0}'': {2}

  1492 # 0: symbol, 1: name

  1493 compiler.warn.unknown.enum.constant=\

  1494     unknown enum constant {1}.{2}

  1496 # 0: symbol, 1: name, 2: message segment

  1497 compiler.warn.unknown.enum.constant.reason=\

  1498     unknown enum constant {1}.{2}\n\

  1499     reason: {3}

  1501 # 0: type, 1: type

  1502 compiler.warn.raw.class.use=\

  1503     found raw type: {0}\n\

  1504     missing type arguments for generic class {1}

  1506 # 0: unused, 1: unused

  1507 compiler.warn.diamond.redundant.args=\

  1508     redundant type arguments in new expression (use diamond operator instead).

  1510 # 0: type, 1: type

  1511 compiler.warn.diamond.redundant.args.1=\

  1512     redundant type arguments in new expression (use diamond operator instead).\n\

  1513     explicit: {0}\n\

  1514     inferred: {1}

  1516 # 0: symbol, 1: message segment

  1517 compiler.warn.varargs.redundant.trustme.anno=\

  1518     Redundant {0} annotation. {1}

  1520 #####

  1522 ## The following are tokens which are non-terminals in the language. They should

  1523 ## be named as JLS3 calls them when translated to the appropriate language.

  1524 compiler.misc.token.identifier=\

  1525     <identifier>

  1527 compiler.misc.token.character=\

  1528     <character>

  1530 compiler.misc.token.string=\

  1531     <string>

  1533 compiler.misc.token.integer=\

  1534     <integer>

  1536 compiler.misc.token.long-integer=\

  1537     <long integer>

  1539 compiler.misc.token.float=\

  1540     <float>

  1542 compiler.misc.token.double=\

  1543     <double>

  1545 compiler.misc.token.bad-symbol=\

  1546     <bad symbol>

  1548 compiler.misc.token.end-of-input=\

  1549     <end of input>

  1551 ## The argument to the following string will always be one of the following:

  1552 ## 1. one of the above non-terminals

  1553 ## 2. a keyword (JLS1.8)

  1554 ## 3. a boolean literal (JLS3.10.3)

  1555 ## 4. the null literal (JLS3.10.7)

  1556 ## 5. a Java separator (JLS3.11)

  1557 ## 6. an operator (JLS3.12)

  1558 ##

  1559 ## This is the only place these tokens will be used.

  1560 # 0: token

  1561 compiler.err.expected=\

  1562     {0} expected

  1564 # 0: token, 1: token

  1565 compiler.err.expected2=\

  1566     {0} or {1} expected

  1568 # 0: token, 1: token, 2: token

  1569 compiler.err.expected3=\

  1570     {0}, {1}, or {2} expected

  1572 compiler.err.premature.eof=\

  1573     reached end of file while parsing

  1575 ## The following are related in form, but do not easily fit the above paradigm.

  1576 compiler.err.dot.class.expected=\

  1577     ''.class'' expected

  1579 ## The argument to this string will always be either 'case' or 'default'.

  1580 # 0: token

  1581 compiler.err.orphaned=\

  1582     orphaned {0}

  1584 # 0: name

  1585 compiler.misc.anonymous.class=\

  1586     <anonymous {0}>

  1588 # 0: name, 1: type

  1589 compiler.misc.type.captureof=\

  1590     capture#{0} of {1}

  1592 compiler.misc.type.captureof.1=\

  1593     capture#{0}

  1595 compiler.misc.type.none=\

  1596     <none>

  1598 compiler.misc.unnamed.package=\

  1599     unnamed package

  1601 #####

  1603 # 0: symbol, 1: message segment

  1604 compiler.err.cant.access=\

  1605     cannot access {0}\n\

  1606     {1}

  1608 compiler.misc.bad.class.file.header=\

  1609     bad class file: {0}\n\

  1610     {1}\n\

  1611     Please remove or make sure it appears in the correct subdirectory of the classpath.

  1613 # 0: file name, 1: message segment

  1614 compiler.misc.bad.source.file.header=\

  1615     bad source file: {0}\n\

  1616     {1}\n\

  1617     Please remove or make sure it appears in the correct subdirectory of the sourcepath.

  1619 ## The following are all possible strings for the second argument ({1}) of the

  1620 ## above strings.

  1621 compiler.misc.bad.class.signature=\

  1622     bad class signature: {0}

  1624 #0: symbol, 1: symbol

  1625 compiler.misc.bad.enclosing.class=\

  1626     bad enclosing class for {0}: {1}

  1628 # 0: symbol

  1629 compiler.misc.bad.enclosing.method=\

  1630     bad enclosing method attribute for class {0}

  1632 compiler.misc.bad.runtime.invisible.param.annotations=\

  1633     bad RuntimeInvisibleParameterAnnotations attribute: {0}

  1635 compiler.misc.bad.const.pool.tag=\

  1636     bad constant pool tag: {0}

  1638 compiler.misc.bad.const.pool.tag.at=\

  1639     bad constant pool tag: {0} at {1}

  1641 compiler.misc.bad.signature=\

  1642     bad signature: {0}

  1644 compiler.misc.class.file.wrong.class=\

  1645     class file contains wrong class: {0}

  1647 compiler.misc.class.file.not.found=\

  1648     class file for {0} not found

  1650 # 0: name

  1651 compiler.misc.file.doesnt.contain.class=\

  1652     file does not contain class {0}

  1654 compiler.misc.file.does.not.contain.package=\

  1655     file does not contain package {0}

  1657 compiler.misc.illegal.start.of.class.file=\

  1658     illegal start of class file

  1660 compiler.misc.unable.to.access.file=\

  1661     unable to access file: {0}

  1663 compiler.misc.unicode.str.not.supported=\

  1664     unicode string in class file not supported

  1666 compiler.misc.undecl.type.var=\

  1667     undeclared type variable: {0}

  1669 compiler.misc.wrong.version=\

  1670     class file has wrong version {0}.{1}, should be {2}.{3}

  1672 #####

  1674 # 0: type, 1: type or symbol

  1675 compiler.err.not.within.bounds=\

  1676     type argument {0} is not within bounds of type-variable {1}

  1678 ## The following are all possible strings for the second argument ({1}) of the

  1679 ## above string.

  1681 ## none yet...

  1683 #####

  1685 # 0: message segment

  1686 compiler.err.prob.found.req=\

  1687     incompatible types: {0}

  1689 # 0: message segment, 1: type, 2: type

  1690 compiler.warn.prob.found.req=\

  1691     {0}\n\

  1692     required: {2}\n\

  1693     found:    {1}

  1695 # 0: type, 1: type

  1696 compiler.misc.inconvertible.types=\

  1697     {0} cannot be converted to {1}

  1699 # 0: type, 1: type

  1700 compiler.misc.possible.loss.of.precision=\

  1701     possible lossy conversion from {0} to {1}

  1703 compiler.misc.unchecked.assign=\

  1704     unchecked conversion

  1706 # compiler.misc.storecheck=\

  1707 #     assignment might cause later store checks to fail

  1708 # compiler.misc.unchecked=\

  1709 #     assigned array cannot dynamically check its stores

  1710 compiler.misc.unchecked.cast.to.type=\

  1711     unchecked cast

  1713 # compiler.err.star.expected=\

  1714 #     ''*'' expected

  1715 # compiler.err.no.elem.type=\

  1716 #     \[\*\] cannot have a type

  1718 # 0: type

  1719 compiler.misc.try.not.applicable.to.type=\

  1720     try-with-resources not applicable to variable type\n\

  1721     ({0})

  1723 #####

  1725 # 0: message segment or type, 1: message segment

  1726 compiler.err.type.found.req=\

  1727     unexpected type\n\

  1728     required: {1}\n\

  1729     found:    {0}

  1731 ## The following are all possible strings for the first argument ({0}) of the

  1732 ## above string.

  1733 compiler.misc.type.req.class=\

  1734     class

  1736 compiler.misc.type.req.class.array=\

  1737     class or array

  1739 compiler.misc.type.req.array.or.iterable=\

  1740     array or java.lang.Iterable

  1742 compiler.misc.type.req.ref=\

  1743     reference

  1745 compiler.misc.type.req.exact=\

  1746     class or interface without bounds

  1748 # 0: type

  1749 compiler.misc.type.parameter=\

  1750     type parameter {0}

  1752 #####

  1754 ## The following are all possible strings for the last argument of all those

  1755 ## diagnostics whose key ends in ".1"

  1757 # 0: type, 1: list of type

  1758 compiler.misc.no.unique.maximal.instance.exists=\

  1759     no unique maximal instance exists for type variable {0} with upper bounds {1}

  1761 compiler.misc.no.unique.minimal.instance.exists=\

  1762     no unique minimal instance exists for type variable {0} with lower bounds {1}

  1764 # 0: type, 1: list of type

  1765 compiler.misc.incompatible.upper.bounds=\

  1766     inference variable {0} has incompatible upper bounds {1}

  1768 # 0: type, 1: list of type, 2: list of type

  1769 compiler.misc.incompatible.eq.upper.bounds=\

  1770     inference variable {0} has incompatible bounds\n\

  1771     equality constraints: {1}\n\

  1772     upper bounds: {2}

  1774 # 0: type, 1: list of type, 2: list of type

  1775 compiler.misc.incompatible.eq.lower.bounds=\

  1776     inference variable {0} has incompatible bounds\n\

  1777     equality constraints: {1}\n\

  1778     lower bounds: {2}

  1780 # 0: list of type, 1: type, 2: type

  1781 compiler.misc.infer.no.conforming.instance.exists=\

  1782     no instance(s) of type variable(s) {0} exist so that {1} conforms to {2}

  1784 # 0: list of type, 1: message segment

  1785 compiler.misc.infer.no.conforming.assignment.exists=\

  1786     cannot infer type-variable(s) {0}\n\

  1787     (argument mismatch; {1})

  1789 # 0: list of type

  1790 compiler.misc.infer.arg.length.mismatch=\

  1791     cannot infer type-variable(s) {0}\n\

  1792     (actual and formal argument lists differ in length)

  1794 # 0: list of type, 1: message segment

  1795 compiler.misc.infer.varargs.argument.mismatch=\

  1796     cannot infer type-variable(s) {0}\n\

  1797     (varargs mismatch; {1})

  1799 # 0: type, 1: list of type

  1800 compiler.misc.inferred.do.not.conform.to.upper.bounds=\

  1801     inferred type does not conform to upper bound(s)\n\

  1802     inferred: {0}\n\

  1803     upper bound(s): {1}

  1805 # 0: type, 1: list of type

  1806 compiler.misc.inferred.do.not.conform.to.lower.bounds=\

  1807     inferred type does not conform to lower bound(s)\n\

  1808     inferred: {0}\n\

  1809     lower bound(s): {1}

  1811 # 0: type, 1: list of type

  1812 compiler.misc.inferred.do.not.conform.to.eq.bounds=\

  1813     inferred type does not conform to equality constraint(s)\n\

  1814     inferred: {0}\n\

  1815     equality constraints(s): {1}

  1817 # 0: list of type

  1818 compiler.misc.cyclic.inference=\

  1819     Cannot instantiate inference variables {0} because of an inference loop

  1821 # 0: symbol

  1822 compiler.misc.diamond=\

  1823     {0}<>

  1825 # 0: type

  1826 compiler.misc.diamond.non.generic=\

  1827     cannot use ''<>'' with non-generic class {0}

  1829 # 0: unused

  1830 compiler.misc.diamond.and.explicit.params=\

  1831     cannot use ''<>'' with explicit type parameters for constructor

  1833 # 0: type, 1: list of type

  1834 compiler.misc.explicit.param.do.not.conform.to.bounds=\

  1835     explicit type argument {0} does not conform to declared bound(s) {1}

  1837 compiler.misc.arg.length.mismatch=\

  1838     actual and formal argument lists differ in length

  1840 # 0: message segment

  1841 compiler.misc.no.conforming.assignment.exists=\

  1842     argument mismatch; {0}

  1844 # 0: message segment

  1845 compiler.misc.varargs.argument.mismatch=\

  1846     varargs mismatch; {0}

  1848 #####

  1850 # 0: type, 1: file name

  1851 compiler.warn.auxiliary.class.accessed.from.outside.of.its.source.file=\

  1852     auxiliary class {0} in {1} should not be accessed from outside its own source file

  1855 ## The first argument ({0}) is a "kindname".

  1856 # 0: symbol kind, 1: symbol, 2: symbol

  1857 compiler.err.abstract.cant.be.accessed.directly=\

  1858     abstract {0} {1} in {2} cannot be accessed directly

  1860 ## The first argument ({0}) is a "kindname".

  1861 # 0: symbol kind, 1: symbol

  1862 compiler.err.non-static.cant.be.ref=\

  1863     non-static {0} {1} cannot be referenced from a static context

  1865 # 0: symbol kind, 1: symbol

  1866 compiler.misc.non-static.cant.be.ref=\

  1867     non-static {0} {1} cannot be referenced from a static context

  1869 ## Both arguments ({0}, {1}) are "kindname"s.  {0} is a comma-separated list

  1870 ## of kindnames (the list should be identical to that provided in source.

  1871 compiler.err.unexpected.type=\

  1872     unexpected type\n\

  1873     required: {0}\n\

  1874     found:    {1}

  1876 compiler.err.unexpected.lambda=\

  1877    lambda expression not expected here

  1879 compiler.err.unexpected.mref=\

  1880    method reference not expected here

  1882 ## The first argument {0} is a "kindname" (e.g. 'constructor', 'field', etc.)

  1883 ## The second argument {1} is the non-resolved symbol

  1884 ## The third argument {2} is a list of type parameters (non-empty if {1} is a method)

  1885 ## The fourth argument {3} is a list of argument types (non-empty if {1} is a method)

  1886 # 0: symbol kind, 1: name, 2: unused, 3: unused

  1887 compiler.err.cant.resolve=\

  1888     cannot find symbol\n\

  1889     symbol: {0} {1}

  1891 # 0: symbol kind, 1: name, 2: unused, 3: list of type

  1892 compiler.err.cant.resolve.args=\

  1893     cannot find symbol\n\

  1894     symbol: {0} {1}({3})

  1896 # 0: symbol kind, 1: name, 2: list of type, 3: list of type

  1897 compiler.err.cant.resolve.args.params=\

  1898     cannot find symbol\n\

  1899     symbol: {0} <{2}>{1}({3})

  1901 ## arguments from {0} to {3} have the same meaning as above

  1902 ## The fifth argument {4} is a location subdiagnostic (see below)

  1903 # 0: symbol kind, 1: name, 2: unused, 3: unused, 4: message segment

  1904 compiler.err.cant.resolve.location=\

  1905     cannot find symbol\n\

  1906     symbol:   {0} {1}\n\

  1907     location: {4}

  1909 # 0: symbol kind, 1: name, 2: unused, 3: list of type, 4: message segment

  1910 compiler.err.cant.resolve.location.args=\

  1911     cannot find symbol\n\

  1912     symbol:   {0} {1}({3})\n\

  1913     location: {4}

  1915 # 0: symbol kind, 1: name, 2: list of type, 3: list, 4: message segment

  1916 compiler.err.cant.resolve.location.args.params=\

  1917     cannot find symbol\n\

  1918     symbol:   {0} <{2}>{1}({3})\n\

  1919     location: {4}

  1921 ### Following are replicated/used for method reference diagnostics

  1923 # 0: symbol kind, 1: name, 2: unused, 3: list of type, 4: message segment

  1924 compiler.misc.cant.resolve.location.args=\

  1925     cannot find symbol\n\

  1926     symbol:   {0} {1}({3})\n\

  1927     location: {4}

  1929 # 0: symbol kind, 1: name, 2: list of type, 3: list, 4: message segment

  1930 compiler.misc.cant.resolve.location.args.params=\

  1931     cannot find symbol\n\

  1932     symbol:   {0} <{2}>{1}({3})\n\

  1933     location: {4}

  1935 ##a location subdiagnostic is composed as follows:

  1936 ## The first argument {0} is the location "kindname" (e.g. 'constructor', 'field', etc.)

  1937 ## The second argument {1} is the location name

  1938 ## The third argument {2} is the location type (only when {1} is a variable name)

  1940 # 0: symbol kind, 1: type or symbol, 2: unused

  1941 compiler.misc.location=\

  1942     {0} {1}

  1944 # 0: symbol kind, 1: symbol, 2: type

  1945 compiler.misc.location.1=\

  1946     {0} {1} of type {2}

  1948 ## The following are all possible string for "kindname".

  1949 ## They should be called whatever the JLS calls them after it been translated

  1950 ## to the appropriate language.

  1951 # compiler.misc.kindname.constructor=\

  1952 #     static member

  1953 compiler.misc.kindname.annotation=\

  1954     @interface

  1956 compiler.misc.kindname.constructor=\

  1957     constructor

  1959 compiler.misc.kindname.enum=\

  1960     enum

  1962 compiler.misc.kindname.interface=\

  1963     interface

  1965 compiler.misc.kindname.static=\

  1966     static

  1968 compiler.misc.kindname.type.variable=\

  1969     type variable

  1971 compiler.misc.kindname.type.variable.bound=\

  1972     bound of type variable

  1974 compiler.misc.kindname.variable=\

  1975     variable

  1977 compiler.misc.kindname.value=\

  1978     value

  1980 compiler.misc.kindname.method=\

  1981     method

  1983 compiler.misc.kindname.class=\

  1984     class

  1986 compiler.misc.kindname.package=\

  1987     package

  1989 compiler.misc.kindname.static.init=\

  1990     static initializer

  1992 compiler.misc.kindname.instance.init=\

  1993     instance initializer

  1995 #####

  1997 compiler.misc.no.args=\

  1998     no arguments

  2000 # 0: message segment

  2001 compiler.err.override.static=\

  2002     {0}\n\

  2003     overriding method is static

  2005 # 0: message segment, 1: set of modifier

  2006 compiler.err.override.meth=\

  2007     {0}\n\

  2008     overridden method is {1}

  2010 # 0: message segment, 1: type

  2011 compiler.err.override.meth.doesnt.throw=\

  2012     {0}\n\

  2013     overridden method does not throw {1}

  2015 # In the following string {1} is a space separated list of Java Keywords, as

  2016 # they would have been declared in the source code

  2017 # 0: message segment, 1: set of modifier

  2018 compiler.err.override.weaker.access=\

  2019     {0}\n\

  2020     attempting to assign weaker access privileges; was {1}

  2022 # 0: message segment, 1: type, 2: type

  2023 compiler.err.override.incompatible.ret=\

  2024     {0}\n\

  2025     return type {1} is not compatible with {2}

  2027 # 0: message segment, 1: type, 2: type

  2028 compiler.warn.override.unchecked.ret=\

  2029     {0}\n\

  2030     return type requires unchecked conversion from {1} to {2}

  2032 # 0: message segment, 1: type

  2033 compiler.warn.override.unchecked.thrown=\

  2034     {0}\n\

  2035     overridden method does not throw {1}

  2037 ## The following are all possible strings for the first argument ({0}) of the

  2038 ## above strings.

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

  2040 compiler.misc.cant.override=\

  2041     {0} in {1} cannot override {2} in {3}

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

  2044 compiler.misc.cant.implement=\

  2045     {0} in {1} cannot implement {2} in {3}

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

  2048 compiler.misc.clashes.with=\

  2049     {0} in {1} clashes with {2} in {3}

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

  2052 compiler.misc.unchecked.override=\

  2053     {0} in {1} overrides {2} in {3}

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

  2056 compiler.misc.unchecked.implement=\

  2057     {0} in {1} implements {2} in {3}

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

  2060 compiler.misc.unchecked.clash.with=\

  2061     {0} in {1} overrides {2} in {3}

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

  2064 compiler.misc.varargs.override=\

  2065     {0} in {1} overrides {2} in {3}

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

  2068 compiler.misc.varargs.implement=\

  2069     {0} in {1} implements {2} in {3}

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

  2072 compiler.misc.varargs.clash.with=\

  2073     {0} in {1} overrides {2} in {3}

  2075 # 0: unused

  2076 compiler.misc.diamond.and.anon.class=\

  2077     cannot use ''<>'' with anonymous inner classes

  2079 # 0: symbol kind, 1: symbol, 2: symbol, 3: message segment

  2080 compiler.misc.inapplicable.method=\

  2081     {0} {1}.{2} is not applicable\n\

  2082     ({3})

  2084 ########################################

  2085 # Diagnostics for language feature changes

  2086 ########################################

  2087 # 0: string

  2088 compiler.err.unsupported.fp.lit=\

  2089     hexadecimal floating point literals are not supported in -source {0}\n\

  2090     (use -source 5 or higher to enable hexadecimal floating point literals)

  2092 # 0: string

  2093 compiler.err.unsupported.binary.lit=\

  2094     binary literals are not supported in -source {0}\n\

  2095     (use -source 7 or higher to enable binary literals)

  2097 # 0: string

  2098 compiler.err.unsupported.underscore.lit=\

  2099     underscores in literals are not supported in -source {0}\n\

  2100     (use -source 7 or higher to enable underscores in literals)

  2102 # 0: string

  2103 compiler.err.try.with.resources.not.supported.in.source=\

  2104     try-with-resources is not supported in -source {0}\n\

  2105     (use -source 7 or higher to enable try-with-resources)

  2107 compiler.warn.enum.as.identifier=\

  2108     as of release 5, ''enum'' is a keyword, and may not be used as an identifier\n\

  2109     (use -source 5 or higher to use ''enum'' as a keyword)

  2111 compiler.warn.assert.as.identifier=\

  2112     as of release 1.4, ''assert'' is a keyword, and may not be used as an identifier\n\

  2113     (use -source 1.4 or higher to use ''assert'' as a keyword)

  2115 compiler.err.enum.as.identifier=\

  2116     as of release 5, ''enum'' is a keyword, and may not be used as an identifier\n\

  2117     (use -source 1.4 or lower to use ''enum'' as an identifier)

  2119 compiler.err.assert.as.identifier=\

  2120     as of release 1.4, ''assert'' is a keyword, and may not be used as an identifier\n\

  2121     (use -source 1.3 or lower to use ''assert'' as an identifier)

  2123 # 0: string

  2124 compiler.err.generics.not.supported.in.source=\

  2125     generics are not supported in -source {0}\n\

  2126     (use -source 5 or higher to enable generics)

  2128 # 0: string

  2129 compiler.err.varargs.not.supported.in.source=\

  2130     variable-arity methods are not supported in -source {0}\n\

  2131     (use -source 5 or higher to enable variable-arity methods)

  2133 # 0: string

  2134 compiler.err.annotations.not.supported.in.source=\

  2135     annotations are not supported in -source {0}\n\

  2136     (use -source 5 or higher to enable annotations)

  2138 #308 compiler.err.type.annotations.not.supported.in.source=\

  2139 #308     type annotations are not supported in -source {0}\n\

  2140 #308 (use -source 7 or higher to enable type annotations)

  2142 # 0: string

  2143 compiler.err.foreach.not.supported.in.source=\

  2144     for-each loops are not supported in -source {0}\n\

  2145     (use -source 5 or higher to enable for-each loops)

  2147 # 0: string

  2148 compiler.err.static.import.not.supported.in.source=\

  2149     static import declarations are not supported in -source {0}\n\

  2150     (use -source 5 or higher to enable static import declarations)

  2152 # 0: string

  2153 compiler.err.enums.not.supported.in.source=\

  2154     enums are not supported in -source {0}\n\

  2155     (use -source 5 or higher to enable enums)

  2157 # 0: string

  2158 compiler.err.diamond.not.supported.in.source=\

  2159     diamond operator is not supported in -source {0}\n\

  2160     (use -source 7 or higher to enable diamond operator)

  2162 # 0: string

  2163 compiler.err.multicatch.not.supported.in.source=\

  2164     multi-catch statement is not supported in -source {0}\n\

  2165     (use -source 7 or higher to enable multi-catch statement)

  2167 # 0: string

  2168 compiler.err.string.switch.not.supported.in.source=\

  2169     strings in switch are not supported in -source {0}\n\

  2170     (use -source 7 or higher to enable strings in switch)

  2172 # 0: string

  2173 compiler.err.lambda.not.supported.in.source=\

  2174     lambda expressions are not supported in -source {0}\n\

  2175     (use -source 8 or higher to enable lambda expressions)

  2177 # 0: string

  2178 compiler.err.method.references.not.supported.in.source=\

  2179     method references are not supported in -source {0}\n\

  2180     (use -source 8 or higher to enable method references)

  2182 # 0: string

  2183 compiler.err.default.methods.not.supported.in.source=\

  2184     default methods are not supported in -source {0}\n\

  2185     (use -source 8 or higher to enable default methods)

  2187 ########################################

  2188 # Diagnostics for verbose resolution

  2189 # used by Resolve (debug only)

  2190 ########################################

  2192 # 0: number, 1: symbol, 2: unused

  2193 compiler.misc.applicable.method.found=\

  2194     #{0} applicable method found: {1}

  2196 # 0: number, 1: symbol, 2: message segment

  2197 compiler.misc.applicable.method.found.1=\

  2198     #{0} applicable method found: {1}\n\

  2199     ({2})

  2201 # 0: number, 1: symbol, 2: message segment

  2202 compiler.misc.not.applicable.method.found=\

  2203     #{0} not applicable method found: {1}\n\

  2204     ({2})

  2206 # 0: type

  2207 compiler.misc.partial.inst.sig=\

  2208     partially instantiated to: {0}

  2210 # 0: name, 1: symbol, 2: number, 3: MethodResolutionPhase, 4: list of type or message segment, 5: list of type or message segment

  2211 compiler.note.verbose.resolve.multi=\

  2212     resolving method {0} in type {1} to candidate {2}\n\

  2213     phase: {3}\n\

  2214     with actuals: {4}\n\

  2215     with type-args: {5}\n\

  2216     candidates:

  2218 # 0: name, 1: symbol, 2: unused, 3: MethodResolutionPhase, 4: list of type or message segment, 5: list of type or message segment

  2219 compiler.note.verbose.resolve.multi.1=\

  2220     erroneous resolution for method {0} in type {1}\n\

  2221     phase: {3}\n\

  2222     with actuals: {4}\n\

  2223     with type-args: {5}\n\

  2224     candidates:

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

  2227 compiler.note.deferred.method.inst=\

  2228     Deferred instantiation of method {0}\n\

  2229     instantiated signature: {1}\n\

  2230     target-type: {2}

  2232 ########################################

  2233 # Diagnostics for where clause implementation

  2234 # used by the RichDiagnosticFormatter.

  2235 ########################################

  2237 compiler.misc.type.null=\

  2238     <null>

  2240 # X#n (where n is an int id) is disambiguated tvar name

  2241 # 0: name, 1: number

  2242 compiler.misc.type.var=\

  2243     {0}#{1}

  2245 # CAP#n (where n is an int id) is an abbreviation for 'captured type'

  2246 # 0: number

  2247 compiler.misc.captured.type=\

  2248     CAP#{0}

  2250 # <INT#n> (where n is an int id) is an abbreviation for 'intersection type'

  2251 # 0: number

  2252 compiler.misc.intersection.type=\

  2253     INT#{0}

  2255 # where clause for captured type: contains upper ('extends {1}') and lower

  2256 # ('super {2}') bound along with the wildcard that generated this captured type ({3})

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

  2258 compiler.misc.where.captured=\

  2259     {0} extends {1} super: {2} from capture of {3}

  2261 # compact where clause for captured type: contains upper ('extends {1}') along

  2262 # with the wildcard that generated this captured type ({3})

  2263 # 0: type, 1: type, 2: unused, 3: type

  2264 compiler.misc.where.captured.1=\

  2265     {0} extends {1} from capture of {3}

  2267 # where clause for type variable: contains upper bound(s) ('extends {1}') along with

  2268 # the kindname ({2}) and location ({3}) in which the typevar has been declared

  2269 # 0: type, 1: list of type, 2: symbol kind, 3: symbol

  2270 compiler.misc.where.typevar=\

  2271     {0} extends {1} declared in {2} {3}

  2273 # compact where clause for type variable: contains the kindname ({2}) and location ({3})

  2274 # in which the typevar has been declared

  2275 # 0: type, 1: list of type, 2: symbol kind, 3: symbol

  2276 compiler.misc.where.typevar.1=\

  2277     {0} declared in {2} {3}

  2279 # where clause for fresh type variable: contains upper bound(s) ('extends {1}').

  2280 # Since a fresh type-variable is synthetic - there's no location/kindname here.

  2281 # 0: type, 1: list of type

  2282 compiler.misc.where.fresh.typevar=\

  2283     {0} extends {1}

  2285 # where clause for type variable: contains all the upper bound(s) ('extends {1}')

  2286 # of this intersection type

  2287 # 0: type, 1: list of type

  2288 compiler.misc.where.intersection=\

  2289     {0} extends {1}

  2291 ### Where clause headers ###

  2292 compiler.misc.where.description.captured=\

  2293     where {0} is a fresh type-variable:

  2295 # 0: set of type

  2296 compiler.misc.where.description.typevar=\

  2297     where {0} is a type-variable:

  2299 # 0: set of type

  2300 compiler.misc.where.description.intersection=\

  2301     where {0} is an intersection type:

  2303 # 0: set of type

  2304 compiler.misc.where.description.captured.1=\

  2305     where {0} are fresh type-variables:

  2307 # 0: set of type

  2308 compiler.misc.where.description.typevar.1=\

  2309     where {0} are type-variables:

  2311 compiler.misc.where.description.intersection.1=\

  2312     where {0} are intersection types:

Mercurial > jdk8-mips64-public > langtools / file revision

src/share/classes/com/sun/tools/javac/resources/compiler.properties@bf54daa9dcd8

src/share/classes/com/sun/tools/javac/resources/compiler.properties