langtools/src/share/classes/com/sun/tools/javac/resources/compiler.properties
author mcimadamore
Mon, 24 Jan 2011 15:45:06 +0000
changeset 8046 376310825f60
parent 8045 df2ca0edfbaa
child 8047 c7f08cdb5c3c
permissions -rw-r--r--
6510286: Wording of javac error for inner classes Summary: 'inner classes cannot have static declarations' message needs to be reworked Reviewed-by: jjg
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
10
06bc494ca11e Initial load
duke
parents:
diff changeset
     1
#
8031
d5fe2c1cecfc 6992999: fully remove JSR 308 from langtools
jjg
parents: 7681
diff changeset
     2
# Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
     3
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
06bc494ca11e Initial load
duke
parents:
diff changeset
     4
#
06bc494ca11e Initial load
duke
parents:
diff changeset
     5
# This code is free software; you can redistribute it and/or modify it
06bc494ca11e Initial load
duke
parents:
diff changeset
     6
# under the terms of the GNU General Public License version 2 only, as
5520
86e4b9a9da40 6943119: Rebrand source copyright notices
ohair
parents: 5492
diff changeset
     7
# published by the Free Software Foundation.  Oracle designates this
10
06bc494ca11e Initial load
duke
parents:
diff changeset
     8
# particular file as subject to the "Classpath" exception as provided
5520
86e4b9a9da40 6943119: Rebrand source copyright notices
ohair
parents: 5492
diff changeset
     9
# by Oracle in the LICENSE file that accompanied this code.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    10
#
06bc494ca11e Initial load
duke
parents:
diff changeset
    11
# This code is distributed in the hope that it will be useful, but WITHOUT
06bc494ca11e Initial load
duke
parents:
diff changeset
    12
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
06bc494ca11e Initial load
duke
parents:
diff changeset
    13
# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
06bc494ca11e Initial load
duke
parents:
diff changeset
    14
# version 2 for more details (a copy is included in the LICENSE file that
06bc494ca11e Initial load
duke
parents:
diff changeset
    15
# accompanied this code).
06bc494ca11e Initial load
duke
parents:
diff changeset
    16
#
06bc494ca11e Initial load
duke
parents:
diff changeset
    17
# You should have received a copy of the GNU General Public License version
06bc494ca11e Initial load
duke
parents:
diff changeset
    18
# 2 along with this work; if not, write to the Free Software Foundation,
06bc494ca11e Initial load
duke
parents:
diff changeset
    19
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
06bc494ca11e Initial load
duke
parents:
diff changeset
    20
#
5520
86e4b9a9da40 6943119: Rebrand source copyright notices
ohair
parents: 5492
diff changeset
    21
# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
86e4b9a9da40 6943119: Rebrand source copyright notices
ohair
parents: 5492
diff changeset
    22
# or visit www.oracle.com if you need additional information or have any
86e4b9a9da40 6943119: Rebrand source copyright notices
ohair
parents: 5492
diff changeset
    23
# questions.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    24
#
06bc494ca11e Initial load
duke
parents:
diff changeset
    25
06bc494ca11e Initial load
duke
parents:
diff changeset
    26
##
06bc494ca11e Initial load
duke
parents:
diff changeset
    27
## errors
06bc494ca11e Initial load
duke
parents:
diff changeset
    28
##
06bc494ca11e Initial load
duke
parents:
diff changeset
    29
06bc494ca11e Initial load
duke
parents:
diff changeset
    30
compiler.err.abstract.cant.be.instantiated=\
06bc494ca11e Initial load
duke
parents:
diff changeset
    31
    {0} is abstract; cannot be instantiated
06bc494ca11e Initial load
duke
parents:
diff changeset
    32
compiler.err.abstract.meth.cant.have.body=\
06bc494ca11e Initial load
duke
parents:
diff changeset
    33
    abstract methods cannot have a body
06bc494ca11e Initial load
duke
parents:
diff changeset
    34
compiler.err.already.annotated=\
06bc494ca11e Initial load
duke
parents:
diff changeset
    35
    {0} {1} has already been annotated
06bc494ca11e Initial load
duke
parents:
diff changeset
    36
compiler.err.already.defined=\
06bc494ca11e Initial load
duke
parents:
diff changeset
    37
    {0} is already defined in {1}
06bc494ca11e Initial load
duke
parents:
diff changeset
    38
compiler.err.already.defined.single.import=\
06bc494ca11e Initial load
duke
parents:
diff changeset
    39
    {0} is already defined in a single-type import
06bc494ca11e Initial load
duke
parents:
diff changeset
    40
compiler.err.already.defined.static.single.import=\
06bc494ca11e Initial load
duke
parents:
diff changeset
    41
    {0} is already defined in a static single-type import
06bc494ca11e Initial load
duke
parents:
diff changeset
    42
compiler.err.already.defined.this.unit=\
06bc494ca11e Initial load
duke
parents:
diff changeset
    43
    {0} is already defined in this compilation unit
06bc494ca11e Initial load
duke
parents:
diff changeset
    44
compiler.err.annotation.missing.default.value=\
6345
7d98c298aafd 6975231: Regression test for 6881115 is failing with compiler output not matching expected output
mcimadamore
parents: 6157
diff changeset
    45
    annotation {0} is missing value for the attribute {1}
7d98c298aafd 6975231: Regression test for 6881115 is failing with compiler output not matching expected output
mcimadamore
parents: 6157
diff changeset
    46
compiler.err.annotation.missing.default.value.1=\
7d98c298aafd 6975231: Regression test for 6881115 is failing with compiler output not matching expected output
mcimadamore
parents: 6157
diff changeset
    47
    annotation {0} is missing values for attributes {1}
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    48
compiler.err.annotation.not.valid.for.type=\
06bc494ca11e Initial load
duke
parents:
diff changeset
    49
    annotation not valid for a value of type {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
    50
compiler.err.annotation.type.not.applicable=\
06bc494ca11e Initial load
duke
parents:
diff changeset
    51
    annotation type not applicable to this kind of declaration
06bc494ca11e Initial load
duke
parents:
diff changeset
    52
compiler.err.annotation.value.must.be.annotation=\
06bc494ca11e Initial load
duke
parents:
diff changeset
    53
    annotation value must be an annotation
06bc494ca11e Initial load
duke
parents:
diff changeset
    54
compiler.err.annotation.value.must.be.class.literal=\
06bc494ca11e Initial load
duke
parents:
diff changeset
    55
    annotation value must be a class literal
06bc494ca11e Initial load
duke
parents:
diff changeset
    56
compiler.err.annotation.value.must.be.name.value=\
06bc494ca11e Initial load
duke
parents:
diff changeset
    57
    annotation values must be of the form ''name=value''
06bc494ca11e Initial load
duke
parents:
diff changeset
    58
compiler.err.annotation.value.not.allowable.type=\
06bc494ca11e Initial load
duke
parents:
diff changeset
    59
    annotation value not of an allowable type
06bc494ca11e Initial load
duke
parents:
diff changeset
    60
compiler.err.anon.class.impl.intf.no.args=\
06bc494ca11e Initial load
duke
parents:
diff changeset
    61
    anonymous class implements interface; cannot have arguments
06bc494ca11e Initial load
duke
parents:
diff changeset
    62
compiler.err.anon.class.impl.intf.no.typeargs=\
06bc494ca11e Initial load
duke
parents:
diff changeset
    63
    anonymous class implements interface; cannot have type arguments
06bc494ca11e Initial load
duke
parents:
diff changeset
    64
compiler.err.anon.class.impl.intf.no.qual.for.new=\
06bc494ca11e Initial load
duke
parents:
diff changeset
    65
    anonymous class implements interface; cannot have qualifier for new
06bc494ca11e Initial load
duke
parents:
diff changeset
    66
compiler.err.array.and.varargs=\
06bc494ca11e Initial load
duke
parents:
diff changeset
    67
    cannot declare both {0} and {1} in {2}
06bc494ca11e Initial load
duke
parents:
diff changeset
    68
compiler.err.array.dimension.missing=\
06bc494ca11e Initial load
duke
parents:
diff changeset
    69
    array dimension missing
06bc494ca11e Initial load
duke
parents:
diff changeset
    70
compiler.err.array.req.but.found=\
06bc494ca11e Initial load
duke
parents:
diff changeset
    71
    array required, but {0} found
06bc494ca11e Initial load
duke
parents:
diff changeset
    72
06bc494ca11e Initial load
duke
parents:
diff changeset
    73
compiler.err.assignment.from.super-bound=\
06bc494ca11e Initial load
duke
parents:
diff changeset
    74
    assigning from wildcard {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
    75
compiler.err.assignment.to.extends-bound=\
06bc494ca11e Initial load
duke
parents:
diff changeset
    76
    assigning to wildcard {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
    77
compiler.err.attribute.value.must.be.constant=\
06bc494ca11e Initial load
duke
parents:
diff changeset
    78
    attribute value must be constant
06bc494ca11e Initial load
duke
parents:
diff changeset
    79
06bc494ca11e Initial load
duke
parents:
diff changeset
    80
compiler.err.break.outside.switch.loop=\
06bc494ca11e Initial load
duke
parents:
diff changeset
    81
    break outside switch or loop
06bc494ca11e Initial load
duke
parents:
diff changeset
    82
06bc494ca11e Initial load
duke
parents:
diff changeset
    83
compiler.err.call.must.be.first.stmt.in.ctor=\
06bc494ca11e Initial load
duke
parents:
diff changeset
    84
    call to {0} must be first statement in constructor
06bc494ca11e Initial load
duke
parents:
diff changeset
    85
compiler.err.cant.apply.symbol=\
939
38e24969c7e9 6717241: some diagnostic argument is prematurely converted into a String object
mcimadamore
parents: 735
diff changeset
    86
    {0} {1} in {4} {5} cannot be applied to given types\n\
38e24969c7e9 6717241: some diagnostic argument is prematurely converted into a String object
mcimadamore
parents: 735
diff changeset
    87
    required: {2}\n\
38e24969c7e9 6717241: some diagnostic argument is prematurely converted into a String object
mcimadamore
parents: 735
diff changeset
    88
    found: {3}
3140
15a274b13051 6638712: Inference with wildcard types causes selection of inapplicable method
mcimadamore
parents: 2984
diff changeset
    89
compiler.err.cant.apply.symbol.1=\
939
38e24969c7e9 6717241: some diagnostic argument is prematurely converted into a String object
mcimadamore
parents: 735
diff changeset
    90
    {0} {1} in {4} {5} cannot be applied to given types;\n\
38e24969c7e9 6717241: some diagnostic argument is prematurely converted into a String object
mcimadamore
parents: 735
diff changeset
    91
    required: {2}\n\
38e24969c7e9 6717241: some diagnostic argument is prematurely converted into a String object
mcimadamore
parents: 735
diff changeset
    92
    found: {3}\n\
38e24969c7e9 6717241: some diagnostic argument is prematurely converted into a String object
mcimadamore
parents: 735
diff changeset
    93
    reason: {6}
6710
b14e6fe7b290 5088624: cannot find symbol message should be more intelligent
mcimadamore
parents: 6592
diff changeset
    94
compiler.err.cant.apply.symbols=\
b14e6fe7b290 5088624: cannot find symbol message should be more intelligent
mcimadamore
parents: 6592
diff changeset
    95
    no suitable {0} found for {1}({2})
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    96
compiler.err.cant.assign.val.to.final.var=\
06bc494ca11e Initial load
duke
parents:
diff changeset
    97
    cannot assign a value to final variable {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
    98
compiler.err.cant.deref=\
06bc494ca11e Initial load
duke
parents:
diff changeset
    99
    {0} cannot be dereferenced
06bc494ca11e Initial load
duke
parents:
diff changeset
   100
compiler.err.cant.extend.intf.annotation=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   101
    ''extends'' not allowed for @interfaces
06bc494ca11e Initial load
duke
parents:
diff changeset
   102
compiler.err.cant.inherit.from.final=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   103
    cannot inherit from final {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   104
compiler.err.cant.ref.before.ctor.called=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   105
    cannot reference {0} before supertype constructor has been called
06bc494ca11e Initial load
duke
parents:
diff changeset
   106
compiler.err.cant.ret.val.from.meth.decl.void=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   107
    cannot return a value from method whose result type is void
06bc494ca11e Initial load
duke
parents:
diff changeset
   108
compiler.err.cant.select.static.class.from.param.type=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   109
    cannot select a static class from a parameterized type
06bc494ca11e Initial load
duke
parents:
diff changeset
   110
compiler.err.cant.inherit.diff.arg=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   111
    {0} cannot be inherited with different arguments: <{1}> and <{2}>
06bc494ca11e Initial load
duke
parents:
diff changeset
   112
compiler.err.catch.without.try=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   113
    ''catch'' without ''try''
06bc494ca11e Initial load
duke
parents:
diff changeset
   114
compiler.err.clash.with.pkg.of.same.name=\
8045
df2ca0edfbaa 6968793: issues with diagnostics
mcimadamore
parents: 8038
diff changeset
   115
    {0} {1} clashes with package of same name
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   116
compiler.err.const.expr.req=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   117
    constant expression required
06bc494ca11e Initial load
duke
parents:
diff changeset
   118
compiler.err.cont.outside.loop=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   119
    continue outside of loop
06bc494ca11e Initial load
duke
parents:
diff changeset
   120
compiler.err.cyclic.inheritance=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   121
    cyclic inheritance involving {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   122
compiler.err.cyclic.annotation.element=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   123
    cyclic annotation element type
06bc494ca11e Initial load
duke
parents:
diff changeset
   124
compiler.err.call.to.super.not.allowed.in.enum.ctor=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   125
    call to super not allowed in enum constructor
06bc494ca11e Initial load
duke
parents:
diff changeset
   126
compiler.err.no.superclass=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   127
    {0} has no superclass
06bc494ca11e Initial load
duke
parents:
diff changeset
   128
8038
4a2973290d71 6949040: java.dyn package must be compiled with -target 7 or better
mcimadamore
parents: 8036
diff changeset
   129
compiler.err.wrong.target.for.polymorphic.signature.definition=\
6592
dc56420a69bc 6979327: method handle invocation should use casts instead of type parameters to specify return type
mcimadamore
parents: 6581
diff changeset
   130
    MethodHandle API building requires -target 7 runtimes or better; current is -target {0}
dc56420a69bc 6979327: method handle invocation should use casts instead of type parameters to specify return type
mcimadamore
parents: 6581
diff changeset
   131
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   132
compiler.err.concrete.inheritance.conflict=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   133
    methods {0} from {1} and {2} from {3} are inherited with the same signature
06bc494ca11e Initial load
duke
parents:
diff changeset
   134
06bc494ca11e Initial load
duke
parents:
diff changeset
   135
compiler.err.default.allowed.in.intf.annotation.member=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   136
    default value only allowed in an @interface member
06bc494ca11e Initial load
duke
parents:
diff changeset
   137
compiler.err.doesnt.exist=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   138
    package {0} does not exist
06bc494ca11e Initial load
duke
parents:
diff changeset
   139
compiler.err.duplicate.annotation=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   140
    duplicate annotation
06bc494ca11e Initial load
duke
parents:
diff changeset
   141
compiler.err.duplicate.annotation.member.value=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   142
    duplicate annotation member value {0} in {1}
06bc494ca11e Initial load
duke
parents:
diff changeset
   143
compiler.err.duplicate.class=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   144
    duplicate class: {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   145
compiler.err.duplicate.case.label=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   146
    duplicate case label
06bc494ca11e Initial load
duke
parents:
diff changeset
   147
compiler.err.duplicate.default.label=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   148
    duplicate default label
06bc494ca11e Initial load
duke
parents:
diff changeset
   149
06bc494ca11e Initial load
duke
parents:
diff changeset
   150
compiler.err.else.without.if=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   151
    ''else'' without ''if''
06bc494ca11e Initial load
duke
parents:
diff changeset
   152
compiler.err.empty.char.lit=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   153
    empty character literal
06bc494ca11e Initial load
duke
parents:
diff changeset
   154
compiler.err.encl.class.required=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   155
    an enclosing instance that contains {0} is required
06bc494ca11e Initial load
duke
parents:
diff changeset
   156
compiler.err.enum.annotation.must.be.enum.constant=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   157
    an enum annotation value must be an enum constant
06bc494ca11e Initial load
duke
parents:
diff changeset
   158
06bc494ca11e Initial load
duke
parents:
diff changeset
   159
compiler.err.enum.cant.be.instantiated=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   160
    enum types may not be instantiated
06bc494ca11e Initial load
duke
parents:
diff changeset
   161
compiler.err.enum.label.must.be.unqualified.enum=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   162
    an enum switch case label must be the unqualified name of an enumeration constant
06bc494ca11e Initial load
duke
parents:
diff changeset
   163
compiler.err.enum.no.subclassing=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   164
    classes cannot directly extend java.lang.Enum
06bc494ca11e Initial load
duke
parents:
diff changeset
   165
compiler.err.enum.types.not.extensible=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   166
    enum types are not extensible
06bc494ca11e Initial load
duke
parents:
diff changeset
   167
compiler.err.enum.no.finalize=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   168
    enums cannot have finalize methods
06bc494ca11e Initial load
duke
parents:
diff changeset
   169
compiler.err.error.reading.file=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   170
    error reading {0}; {1}
06bc494ca11e Initial load
duke
parents:
diff changeset
   171
compiler.err.except.already.caught=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   172
    exception {0} has already been caught
06bc494ca11e Initial load
duke
parents:
diff changeset
   173
compiler.err.except.never.thrown.in.try=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   174
    exception {0} is never thrown in body of corresponding try statement
06bc494ca11e Initial load
duke
parents:
diff changeset
   175
06bc494ca11e Initial load
duke
parents:
diff changeset
   176
compiler.err.final.parameter.may.not.be.assigned=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   177
    final parameter {0} may not be assigned
7211
163fe60f63de 6970016: Clean up ARM/try-with-resources implementation
mcimadamore
parents: 7203
diff changeset
   178
compiler.err.try.resource.may.not.be.assigned=\
163fe60f63de 6970016: Clean up ARM/try-with-resources implementation
mcimadamore
parents: 7203
diff changeset
   179
    auto-closeable resource {0} may not be assigned
5492
515e4b33b335 6943289: Project Coin: Improved Exception Handling for Java (aka 'multicatch')
mcimadamore
parents: 5321
diff changeset
   180
compiler.err.multicatch.parameter.may.not.be.assigned=\
515e4b33b335 6943289: Project Coin: Improved Exception Handling for Java (aka 'multicatch')
mcimadamore
parents: 5321
diff changeset
   181
    multi-catch parameter {0} may not be assigned
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   182
compiler.err.finally.without.try=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   183
    ''finally'' without ''try''
06bc494ca11e Initial load
duke
parents:
diff changeset
   184
compiler.err.foreach.not.applicable.to.type=\
8045
df2ca0edfbaa 6968793: issues with diagnostics
mcimadamore
parents: 8038
diff changeset
   185
    for-each not applicable to expression type\n\
df2ca0edfbaa 6968793: issues with diagnostics
mcimadamore
parents: 8038
diff changeset
   186
    required: {1}\n\
df2ca0edfbaa 6968793: issues with diagnostics
mcimadamore
parents: 8038
diff changeset
   187
    found:    {0}
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   188
compiler.err.fp.number.too.large=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   189
    floating point number too large
06bc494ca11e Initial load
duke
parents:
diff changeset
   190
compiler.err.fp.number.too.small=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   191
    floating point number too small
06bc494ca11e Initial load
duke
parents:
diff changeset
   192
06bc494ca11e Initial load
duke
parents:
diff changeset
   193
compiler.err.generic.array.creation=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   194
    generic array creation
06bc494ca11e Initial load
duke
parents:
diff changeset
   195
compiler.err.generic.throwable=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   196
    a generic class may not extend java.lang.Throwable
06bc494ca11e Initial load
duke
parents:
diff changeset
   197
06bc494ca11e Initial load
duke
parents:
diff changeset
   198
compiler.err.icls.cant.have.static.decl=\
8046
376310825f60 6510286: Wording of javac error for inner classes
mcimadamore
parents: 8045
diff changeset
   199
    Illegal static declaration in inner class {0}\n\
376310825f60 6510286: Wording of javac error for inner classes
mcimadamore
parents: 8045
diff changeset
   200
    modifier \''static\'' is only allowed in constant variable declarations
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   201
compiler.err.illegal.char=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   202
    illegal character: \\{0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   203
compiler.err.illegal.char.for.encoding=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   204
    unmappable character for encoding {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   205
compiler.err.illegal.combination.of.modifiers=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   206
    illegal combination of modifiers: {0} and {1}
06bc494ca11e Initial load
duke
parents:
diff changeset
   207
compiler.err.illegal.enum.static.ref=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   208
    illegal reference to static field from initializer
06bc494ca11e Initial load
duke
parents:
diff changeset
   209
compiler.err.illegal.esc.char=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   210
    illegal escape character
06bc494ca11e Initial load
duke
parents:
diff changeset
   211
compiler.err.illegal.forward.ref=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   212
    illegal forward reference
06bc494ca11e Initial load
duke
parents:
diff changeset
   213
compiler.warn.forward.ref=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   214
    reference to variable ''{0}'' before it has been initialized
1045
56f6e84f7825 6676362: Spurious forward reference error with final var + instance variable initializer
mcimadamore
parents: 939
diff changeset
   215
compiler.err.illegal.self.ref=\
56f6e84f7825 6676362: Spurious forward reference error with final var + instance variable initializer
mcimadamore
parents: 939
diff changeset
   216
    self-reference in initializer
56f6e84f7825 6676362: Spurious forward reference error with final var + instance variable initializer
mcimadamore
parents: 939
diff changeset
   217
compiler.warn.self.ref=\
56f6e84f7825 6676362: Spurious forward reference error with final var + instance variable initializer
mcimadamore
parents: 939
diff changeset
   218
    self-reference in initializer of variable ''{0}''
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   219
compiler.err.illegal.generic.type.for.instof=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   220
    illegal generic type for instanceof
06bc494ca11e Initial load
duke
parents:
diff changeset
   221
compiler.err.illegal.initializer.for.type=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   222
    illegal initializer for {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   223
compiler.err.illegal.line.end.in.char.lit=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   224
    illegal line end in character literal
06bc494ca11e Initial load
duke
parents:
diff changeset
   225
compiler.err.illegal.nonascii.digit=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   226
    illegal non-ASCII digit
3895
3b3c2a1e5e8a 6860965: Project Coin: binary literals
jjg
parents: 3765
diff changeset
   227
compiler.err.illegal.underscore=\
3b3c2a1e5e8a 6860965: Project Coin: binary literals
jjg
parents: 3765
diff changeset
   228
    illegal underscore
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   229
compiler.err.illegal.qual.not.icls=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   230
    illegal qualifier; {0} is not an inner class
06bc494ca11e Initial load
duke
parents:
diff changeset
   231
compiler.err.illegal.start.of.expr=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   232
    illegal start of expression
06bc494ca11e Initial load
duke
parents:
diff changeset
   233
compiler.err.illegal.start.of.type=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   234
    illegal start of type
06bc494ca11e Initial load
duke
parents:
diff changeset
   235
compiler.err.illegal.unicode.esc=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   236
    illegal unicode escape
06bc494ca11e Initial load
duke
parents:
diff changeset
   237
compiler.err.import.requires.canonical=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   238
    import requires canonical name for {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   239
compiler.err.improperly.formed.type.param.missing=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   240
    improperly formed type, some parameters are missing
06bc494ca11e Initial load
duke
parents:
diff changeset
   241
compiler.err.improperly.formed.type.inner.raw.param=\
8045
df2ca0edfbaa 6968793: issues with diagnostics
mcimadamore
parents: 8038
diff changeset
   242
    improperly formed type, type arguments given on a raw type
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   243
compiler.err.incomparable.types=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   244
    incomparable types: {0} and {1}
06bc494ca11e Initial load
duke
parents:
diff changeset
   245
compiler.err.int.number.too.large=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   246
    integer number too large: {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   247
compiler.err.internal.error.cant.instantiate=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   248
    internal error; cannot instantiate {0} at {1} to ({2})
06bc494ca11e Initial load
duke
parents:
diff changeset
   249
compiler.err.intf.annotation.members.cant.have.params=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   250
    @interface members may not have parameters
06bc494ca11e Initial load
duke
parents:
diff changeset
   251
compiler.err.intf.annotation.cant.have.type.params=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   252
    @interface may not have type parameters
06bc494ca11e Initial load
duke
parents:
diff changeset
   253
compiler.err.intf.annotation.members.cant.have.type.params=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   254
    @interface members may not have type parameters
06bc494ca11e Initial load
duke
parents:
diff changeset
   255
compiler.err.intf.annotation.member.clash=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   256
    @interface member clashes with method ''{0}'' in {1}
06bc494ca11e Initial load
duke
parents:
diff changeset
   257
compiler.err.intf.expected.here=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   258
    interface expected here
06bc494ca11e Initial load
duke
parents:
diff changeset
   259
compiler.err.intf.meth.cant.have.body=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   260
    interface methods cannot have body
06bc494ca11e Initial load
duke
parents:
diff changeset
   261
compiler.err.invalid.annotation.member.type=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   262
    invalid type for annotation member
4072
70eaf9773f81 6891079: Compiler allows invalid binary literals 0b and oBL
jjg
parents: 3895
diff changeset
   263
compiler.err.invalid.binary.number=\
70eaf9773f81 6891079: Compiler allows invalid binary literals 0b and oBL
jjg
parents: 3895
diff changeset
   264
    binary numbers must contain at least one binary digit
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   265
compiler.err.invalid.hex.number=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   266
    hexadecimal numbers must contain at least one hexadecimal digit
06bc494ca11e Initial load
duke
parents:
diff changeset
   267
compiler.err.invalid.meth.decl.ret.type.req=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   268
    invalid method declaration; return type required
06bc494ca11e Initial load
duke
parents:
diff changeset
   269
06bc494ca11e Initial load
duke
parents:
diff changeset
   270
compiler.err.label.already.in.use=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   271
    label {0} already in use
06bc494ca11e Initial load
duke
parents:
diff changeset
   272
compiler.err.local.var.accessed.from.icls.needs.final=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   273
    local variable {0} is accessed from within inner class; needs to be declared final
06bc494ca11e Initial load
duke
parents:
diff changeset
   274
compiler.err.local.enum=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   275
    enum types must not be local
06bc494ca11e Initial load
duke
parents:
diff changeset
   276
compiler.err.cannot.create.array.with.type.arguments=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   277
    cannot create array with type arguments
06bc494ca11e Initial load
duke
parents:
diff changeset
   278
06bc494ca11e Initial load
duke
parents:
diff changeset
   279
#
06bc494ca11e Initial load
duke
parents:
diff changeset
   280
# limits.  We don't give the limits in the diagnostic because we expect
06bc494ca11e Initial load
duke
parents:
diff changeset
   281
# them to change, yet we want to use the same diagnostic.  These are all
06bc494ca11e Initial load
duke
parents:
diff changeset
   282
# detected during code generation.
06bc494ca11e Initial load
duke
parents:
diff changeset
   283
#
06bc494ca11e Initial load
duke
parents:
diff changeset
   284
compiler.err.limit.code=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   285
    code too large
06bc494ca11e Initial load
duke
parents:
diff changeset
   286
compiler.err.limit.code.too.large.for.try.stmt=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   287
    code too large for try statement
06bc494ca11e Initial load
duke
parents:
diff changeset
   288
compiler.err.limit.dimensions=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   289
    array type has too many dimensions
06bc494ca11e Initial load
duke
parents:
diff changeset
   290
compiler.err.limit.locals=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   291
    too many local variables
06bc494ca11e Initial load
duke
parents:
diff changeset
   292
compiler.err.limit.parameters=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   293
    too many parameters
06bc494ca11e Initial load
duke
parents:
diff changeset
   294
compiler.err.limit.pool=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   295
    too many constants
06bc494ca11e Initial load
duke
parents:
diff changeset
   296
compiler.err.limit.pool.in.class=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   297
    too many constants in class {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   298
compiler.err.limit.stack=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   299
    code requires too much stack
06bc494ca11e Initial load
duke
parents:
diff changeset
   300
compiler.err.limit.string=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   301
    constant string too long
06bc494ca11e Initial load
duke
parents:
diff changeset
   302
compiler.err.limit.string.overflow=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   303
    UTF8 representation for string \"{0}...\" is too long for the constant pool
06bc494ca11e Initial load
duke
parents:
diff changeset
   304
06bc494ca11e Initial load
duke
parents:
diff changeset
   305
compiler.err.malformed.fp.lit=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   306
    malformed floating point literal
06bc494ca11e Initial load
duke
parents:
diff changeset
   307
compiler.err.method.does.not.override.superclass=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   308
    method does not override or implement a method from a supertype
06bc494ca11e Initial load
duke
parents:
diff changeset
   309
compiler.err.missing.meth.body.or.decl.abstract=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   310
    missing method body, or declare abstract
06bc494ca11e Initial load
duke
parents:
diff changeset
   311
compiler.err.missing.ret.stmt=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   312
    missing return statement
06bc494ca11e Initial load
duke
parents:
diff changeset
   313
compiler.err.missing.ret.val=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   314
    missing return value
06bc494ca11e Initial load
duke
parents:
diff changeset
   315
compiler.err.mod.not.allowed.here=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   316
    modifier {0} not allowed here
06bc494ca11e Initial load
duke
parents:
diff changeset
   317
compiler.err.intf.not.allowed.here=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   318
    interface not allowed here
06bc494ca11e Initial load
duke
parents:
diff changeset
   319
compiler.err.enums.must.be.static=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   320
    enum declarations allowed only in static contexts
06bc494ca11e Initial load
duke
parents:
diff changeset
   321
06bc494ca11e Initial load
duke
parents:
diff changeset
   322
compiler.err.name.clash.same.erasure=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   323
    name clash: {0} and {1} have the same erasure
06bc494ca11e Initial load
duke
parents:
diff changeset
   324
compiler.err.name.clash.same.erasure.no.override=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   325
    name clash: {0} in {1} and {2} in {3} have the same erasure, yet neither overrides the other
06bc494ca11e Initial load
duke
parents:
diff changeset
   326
compiler.err.name.reserved.for.internal.use=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   327
    {0} is reserved for internal use
06bc494ca11e Initial load
duke
parents:
diff changeset
   328
compiler.err.native.meth.cant.have.body=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   329
    native methods cannot have a body
06bc494ca11e Initial load
duke
parents:
diff changeset
   330
compiler.err.neither.conditional.subtype=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   331
incompatible types for ?: neither is a subtype of the other\n\
06bc494ca11e Initial load
duke
parents:
diff changeset
   332
second operand: {0}\n\
06bc494ca11e Initial load
duke
parents:
diff changeset
   333
third operand : {1}
06bc494ca11e Initial load
duke
parents:
diff changeset
   334
compiler.err.new.not.allowed.in.annotation=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   335
    ''new'' not allowed in an annotation
06bc494ca11e Initial load
duke
parents:
diff changeset
   336
compiler.err.no.annotation.member=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   337
    no annotation member {0} in {1}
06bc494ca11e Initial load
duke
parents:
diff changeset
   338
compiler.err.no.encl.instance.of.type.in.scope=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   339
    no enclosing instance of type {0} is in scope
06bc494ca11e Initial load
duke
parents:
diff changeset
   340
compiler.err.no.intf.expected.here=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   341
    no interface expected here
06bc494ca11e Initial load
duke
parents:
diff changeset
   342
compiler.err.no.match.entry=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   343
    {0} has no match in entry in {1}; required {2}
06bc494ca11e Initial load
duke
parents:
diff changeset
   344
compiler.err.not.annotation.type=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   345
    {0} is not an annotation type
06bc494ca11e Initial load
duke
parents:
diff changeset
   346
compiler.err.not.def.access.class.intf.cant.access=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   347
    {0} in {1} is defined in an inaccessible class or interface
06bc494ca11e Initial load
duke
parents:
diff changeset
   348
compiler.err.not.def.public.cant.access=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   349
    {0} is not public in {1}; cannot be accessed from outside package
06bc494ca11e Initial load
duke
parents:
diff changeset
   350
compiler.err.not.loop.label=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   351
    not a loop label: {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   352
compiler.err.not.stmt=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   353
    not a statement
06bc494ca11e Initial load
duke
parents:
diff changeset
   354
compiler.err.not.encl.class=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   355
    not an enclosing class: {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   356
06bc494ca11e Initial load
duke
parents:
diff changeset
   357
compiler.err.operator.cant.be.applied=\
8045
df2ca0edfbaa 6968793: issues with diagnostics
mcimadamore
parents: 8038
diff changeset
   358
    bad operand type {1} for unary operator ''{0}''
df2ca0edfbaa 6968793: issues with diagnostics
mcimadamore
parents: 8038
diff changeset
   359
compiler.err.operator.cant.be.applied.1=\
df2ca0edfbaa 6968793: issues with diagnostics
mcimadamore
parents: 8038
diff changeset
   360
    bad operand types for binary operator ''{0}''\n\
df2ca0edfbaa 6968793: issues with diagnostics
mcimadamore
parents: 8038
diff changeset
   361
    first type:  {1}\n\
df2ca0edfbaa 6968793: issues with diagnostics
mcimadamore
parents: 8038
diff changeset
   362
    second type: {2}
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   363
06bc494ca11e Initial load
duke
parents:
diff changeset
   364
compiler.err.pkg.annotations.sb.in.package-info.java=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   365
    package annotations should be in file package-info.java
06bc494ca11e Initial load
duke
parents:
diff changeset
   366
compiler.err.pkg.clashes.with.class.of.same.name=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   367
    package {0} clashes with class of same name
06bc494ca11e Initial load
duke
parents:
diff changeset
   368
1996
c855318a4b03 6595666: fix -Werror
jjg
parents: 1538
diff changeset
   369
compiler.err.warnings.and.werror=\
c855318a4b03 6595666: fix -Werror
jjg
parents: 1538
diff changeset
   370
    warnings found and -Werror specified
c855318a4b03 6595666: fix -Werror
jjg
parents: 1538
diff changeset
   371
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   372
# Errors related to annotation processing
06bc494ca11e Initial load
duke
parents:
diff changeset
   373
06bc494ca11e Initial load
duke
parents:
diff changeset
   374
compiler.err.proc.cant.access=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   375
cannot access {0}\n\
06bc494ca11e Initial load
duke
parents:
diff changeset
   376
{1}\n\
06bc494ca11e Initial load
duke
parents:
diff changeset
   377
Consult the following stack trace for details.\n\
06bc494ca11e Initial load
duke
parents:
diff changeset
   378
{2}
06bc494ca11e Initial load
duke
parents:
diff changeset
   379
06bc494ca11e Initial load
duke
parents:
diff changeset
   380
compiler.err.proc.cant.find.class=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   381
    Could not find class file for ''{0}''.
06bc494ca11e Initial load
duke
parents:
diff changeset
   382
06bc494ca11e Initial load
duke
parents:
diff changeset
   383
# Print a client-generated error message; assumed to be localized, no translation required
06bc494ca11e Initial load
duke
parents:
diff changeset
   384
compiler.err.proc.messager=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   385
    {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   386
06bc494ca11e Initial load
duke
parents:
diff changeset
   387
compiler.err.proc.no.explicit.annotation.processing.requested=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   388
    Class names, ''{0}'', are only accepted if annotation processing is explicitly requested
06bc494ca11e Initial load
duke
parents:
diff changeset
   389
06bc494ca11e Initial load
duke
parents:
diff changeset
   390
compiler.err.proc.no.service=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   391
    A service loader class could not be found.\n\
06bc494ca11e Initial load
duke
parents:
diff changeset
   392
    Either java.util.ServiceLoader or sun.misc.Service must be available.
06bc494ca11e Initial load
duke
parents:
diff changeset
   393
06bc494ca11e Initial load
duke
parents:
diff changeset
   394
compiler.err.proc.processor.bad.option.name=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   395
    Bad option name ''{0}'' provided by processor ''{1}''
06bc494ca11e Initial load
duke
parents:
diff changeset
   396
06bc494ca11e Initial load
duke
parents:
diff changeset
   397
compiler.err.proc.processor.cant.instantiate=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   398
    Could not instantiate an instance of processor ''{0}''
06bc494ca11e Initial load
duke
parents:
diff changeset
   399
06bc494ca11e Initial load
duke
parents:
diff changeset
   400
compiler.err.proc.processor.constructor.error=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   401
    Exception thrown while constructing Processor object: {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   402
06bc494ca11e Initial load
duke
parents:
diff changeset
   403
compiler.err.proc.processor.not.found=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   404
    Annotation processor ''{0}'' not found
06bc494ca11e Initial load
duke
parents:
diff changeset
   405
06bc494ca11e Initial load
duke
parents:
diff changeset
   406
compiler.err.proc.processor.wrong.type=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   407
    Annotation processor ''{0}'' does not implement javax.annotation.processing.Processor
06bc494ca11e Initial load
duke
parents:
diff changeset
   408
06bc494ca11e Initial load
duke
parents:
diff changeset
   409
compiler.err.proc.service.problem=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   410
    Error creating a service loader to load Processors.
06bc494ca11e Initial load
duke
parents:
diff changeset
   411
06bc494ca11e Initial load
duke
parents:
diff changeset
   412
compiler.err.proc.bad.config.file=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   413
    Bad service configuration file, or exception thrown while constructing Processor object: {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   414
06bc494ca11e Initial load
duke
parents:
diff changeset
   415
compiler.err.proc.cant.create.loader=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   416
    Could not create class loader for annotation processors: {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   417
06bc494ca11e Initial load
duke
parents:
diff changeset
   418
compiler.err.qualified.new.of.static.class=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   419
    qualified new of static class
06bc494ca11e Initial load
duke
parents:
diff changeset
   420
06bc494ca11e Initial load
duke
parents:
diff changeset
   421
compiler.err.recursive.ctor.invocation=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   422
    recursive constructor invocation
06bc494ca11e Initial load
duke
parents:
diff changeset
   423
compiler.err.ref.ambiguous=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   424
    reference to {0} is ambiguous, both {1} {2} in {3} and {4} {5} in {6} match
06bc494ca11e Initial load
duke
parents:
diff changeset
   425
compiler.err.repeated.annotation.target=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   426
    repeated annotation target
06bc494ca11e Initial load
duke
parents:
diff changeset
   427
compiler.err.repeated.interface=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   428
    repeated interface
06bc494ca11e Initial load
duke
parents:
diff changeset
   429
compiler.err.repeated.modifier=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   430
    repeated modifier
06bc494ca11e Initial load
duke
parents:
diff changeset
   431
compiler.err.report.access=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   432
    {0} has {1} access in {2}
06bc494ca11e Initial load
duke
parents:
diff changeset
   433
compiler.err.ret.outside.meth=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   434
    return outside method
06bc494ca11e Initial load
duke
parents:
diff changeset
   435
06bc494ca11e Initial load
duke
parents:
diff changeset
   436
compiler.err.signature.doesnt.match.supertype=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   437
    signature does not match {0}; incompatible supertype
06bc494ca11e Initial load
duke
parents:
diff changeset
   438
compiler.err.signature.doesnt.match.intf=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   439
    signature does not match {0}; incompatible interfaces
06bc494ca11e Initial load
duke
parents:
diff changeset
   440
compiler.err.does.not.override.abstract=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   441
    {0} is not abstract and does not override abstract method {1} in {2}
06bc494ca11e Initial load
duke
parents:
diff changeset
   442
compiler.err.source.cant.overwrite.input.file=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   443
    error writing source; cannot overwrite input file {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   444
compiler.err.stack.sim.error=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   445
    Internal error: stack sim error on {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   446
compiler.err.static.imp.only.classes.and.interfaces=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   447
    static import only from classes and interfaces
4142
bd950c8f4fb3 6827009: Project Coin: Strings in Switch
darcy
parents: 4072
diff changeset
   448
compiler.err.string.const.req=\
bd950c8f4fb3 6827009: Project Coin: Strings in Switch
darcy
parents: 4072
diff changeset
   449
    constant string expression required
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   450
compiler.err.synthetic.name.conflict=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   451
    the symbol {0} conflicts with a compiler-synthesized symbol in {1}
3557
a803afefa115 6521805: Regression: JDK5/JDK6 javac allows write access to outer class reference
mcimadamore
parents: 3554
diff changeset
   452
compiler.warn.synthetic.name.conflict=\
a803afefa115 6521805: Regression: JDK5/JDK6 javac allows write access to outer class reference
mcimadamore
parents: 3554
diff changeset
   453
    the symbol {0} conflicts with a compiler-synthesized symbol in {1}
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   454
06bc494ca11e Initial load
duke
parents:
diff changeset
   455
compiler.err.throws.not.allowed.in.intf.annotation=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   456
    throws clause not allowed in @interface members
06bc494ca11e Initial load
duke
parents:
diff changeset
   457
compiler.err.try.without.catch.or.finally=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   458
    ''try'' without ''catch'' or ''finally''
6148
3a8158299c51 6911256: Project Coin: Support Automatic Resource Management (ARM) blocks in the compiler
darcy
parents: 6145
diff changeset
   459
compiler.err.try.without.catch.finally.or.resource.decls=\
3a8158299c51 6911256: Project Coin: Support Automatic Resource Management (ARM) blocks in the compiler
darcy
parents: 6145
diff changeset
   460
    ''try'' without ''catch'', ''finally'' or resource declarations
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   461
compiler.err.type.doesnt.take.params=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   462
    type {0} does not take parameters
06bc494ca11e Initial load
duke
parents:
diff changeset
   463
compiler.err.type.var.cant.be.deref=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   464
    cannot select from a type variable
06bc494ca11e Initial load
duke
parents:
diff changeset
   465
compiler.err.type.var.may.not.be.followed.by.other.bounds=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   466
    a type variable may not be followed by other bounds
06bc494ca11e Initial load
duke
parents:
diff changeset
   467
compiler.err.type.var.more.than.once=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   468
    type variable {0} occurs more than once in result type of {1}; cannot be left uninstantiated
06bc494ca11e Initial load
duke
parents:
diff changeset
   469
compiler.err.type.var.more.than.once.in.result=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   470
    type variable {0} occurs more than once in type of {1}; cannot be left uninstantiated
06bc494ca11e Initial load
duke
parents:
diff changeset
   471
compiler.err.types.incompatible.diff.ret=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   472
    types {0} and {1} are incompatible; both define {2}, but with unrelated return types
06bc494ca11e Initial load
duke
parents:
diff changeset
   473
06bc494ca11e Initial load
duke
parents:
diff changeset
   474
compiler.err.unclosed.char.lit=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   475
    unclosed character literal
06bc494ca11e Initial load
duke
parents:
diff changeset
   476
compiler.err.unclosed.comment=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   477
    unclosed comment
06bc494ca11e Initial load
duke
parents:
diff changeset
   478
compiler.err.unclosed.str.lit=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   479
    unclosed string literal
06bc494ca11e Initial load
duke
parents:
diff changeset
   480
compiler.err.unknown.enum.constant=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   481
    in class file {0}: unknown enum constant {1}.{2}
06bc494ca11e Initial load
duke
parents:
diff changeset
   482
compiler.err.unsupported.encoding=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   483
    unsupported encoding: {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   484
compiler.err.io.exception=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   485
    error reading source file: {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   486
compiler.err.undef.label=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   487
    undefined label: {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   488
compiler.err.undetermined.type=\
8045
df2ca0edfbaa 6968793: issues with diagnostics
mcimadamore
parents: 8038
diff changeset
   489
    cannot infer type arguments for {0}
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   490
compiler.err.undetermined.type.1=\
8045
df2ca0edfbaa 6968793: issues with diagnostics
mcimadamore
parents: 8038
diff changeset
   491
    cannot infer type arguments for {0};\n\
df2ca0edfbaa 6968793: issues with diagnostics
mcimadamore
parents: 8038
diff changeset
   492
    reason: {1}
3140
15a274b13051 6638712: Inference with wildcard types causes selection of inapplicable method
mcimadamore
parents: 2984
diff changeset
   493
compiler.err.invalid.inferred.types=\
15a274b13051 6638712: Inference with wildcard types causes selection of inapplicable method
mcimadamore
parents: 2984
diff changeset
   494
    invalid inferred types for {0}; {1}
5321
c8efe769cb3b 6939620: Switch to 'complex' diamond inference scheme
mcimadamore
parents: 5320
diff changeset
   495
compiler.err.cant.apply.diamond=\
c8efe769cb3b 6939620: Switch to 'complex' diamond inference scheme
mcimadamore
parents: 5320
diff changeset
   496
    cannot infer type arguments for {0}
c8efe769cb3b 6939620: Switch to 'complex' diamond inference scheme
mcimadamore
parents: 5320
diff changeset
   497
compiler.err.cant.apply.diamond.1=\
c8efe769cb3b 6939620: Switch to 'complex' diamond inference scheme
mcimadamore
parents: 5320
diff changeset
   498
    cannot infer type arguments for {0};\n\
c8efe769cb3b 6939620: Switch to 'complex' diamond inference scheme
mcimadamore
parents: 5320
diff changeset
   499
    reason: {1}
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   500
compiler.err.unreachable.stmt=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   501
    unreachable statement
06bc494ca11e Initial load
duke
parents:
diff changeset
   502
compiler.err.initializer.must.be.able.to.complete.normally=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   503
    initializer must be able to complete normally
06bc494ca11e Initial load
duke
parents:
diff changeset
   504
compiler.err.unreported.exception.need.to.catch.or.throw=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   505
    unreported exception {0}; must be caught or declared to be thrown
06bc494ca11e Initial load
duke
parents:
diff changeset
   506
compiler.err.unreported.exception.default.constructor=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   507
    unreported exception {0} in default constructor
06bc494ca11e Initial load
duke
parents:
diff changeset
   508
compiler.err.unsupported.cross.fp.lit=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   509
    hexadecimal floating-point literals are not supported on this VM
06bc494ca11e Initial load
duke
parents:
diff changeset
   510
compiler.err.void.not.allowed.here=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   511
    ''void'' type not allowed here
06bc494ca11e Initial load
duke
parents:
diff changeset
   512
06bc494ca11e Initial load
duke
parents:
diff changeset
   513
compiler.err.wrong.number.type.args=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   514
    wrong number of type arguments; required {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   515
06bc494ca11e Initial load
duke
parents:
diff changeset
   516
compiler.err.var.might.already.be.assigned=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   517
    variable {0} might already have been assigned
06bc494ca11e Initial load
duke
parents:
diff changeset
   518
compiler.err.var.might.not.have.been.initialized=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   519
    variable {0} might not have been initialized
06bc494ca11e Initial load
duke
parents:
diff changeset
   520
compiler.err.var.might.be.assigned.in.loop=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   521
    variable {0} might be assigned in loop
06bc494ca11e Initial load
duke
parents:
diff changeset
   522
7643
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7624
diff changeset
   523
compiler.err.varargs.invalid.trustme.anno=\
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7624
diff changeset
   524
    Invalid {0} annotation. {1}
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7624
diff changeset
   525
compiler.misc.varargs.trustme.on.reifiable.varargs=\
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7624
diff changeset
   526
    Varargs element type {0} is reifiable.
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7624
diff changeset
   527
compiler.misc.varargs.trustme.on.non.varargs.meth=\
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7624
diff changeset
   528
    Method {0} is not a varargs method.
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7624
diff changeset
   529
compiler.misc.varargs.trustme.on.virtual.varargs=\
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7624
diff changeset
   530
    Instance method {0} is not final.
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7624
diff changeset
   531
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   532
# In the following string, {1} will always be the detail message from
06bc494ca11e Initial load
duke
parents:
diff changeset
   533
# java.io.IOException.
06bc494ca11e Initial load
duke
parents:
diff changeset
   534
compiler.err.class.cant.write=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   535
    error while writing {0}: {1}
06bc494ca11e Initial load
duke
parents:
diff changeset
   536
06bc494ca11e Initial load
duke
parents:
diff changeset
   537
# In the following string, {0} is the name of the class in the Java source.
06bc494ca11e Initial load
duke
parents:
diff changeset
   538
# It really should be used two times..
06bc494ca11e Initial load
duke
parents:
diff changeset
   539
compiler.err.class.public.should.be.in.file=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   540
    class {0} is public, should be declared in a file named {0}.java
06bc494ca11e Initial load
duke
parents:
diff changeset
   541
06bc494ca11e Initial load
duke
parents:
diff changeset
   542
## All errors which do not refer to a particular line in the source code are
06bc494ca11e Initial load
duke
parents:
diff changeset
   543
## preceded by this string.
06bc494ca11e Initial load
duke
parents:
diff changeset
   544
compiler.err.error=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   545
    error:\u0020
06bc494ca11e Initial load
duke
parents:
diff changeset
   546
06bc494ca11e Initial load
duke
parents:
diff changeset
   547
# The following error messages do not refer to a line in the source code.
06bc494ca11e Initial load
duke
parents:
diff changeset
   548
compiler.err.cant.read.file=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   549
    cannot read: {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   550
06bc494ca11e Initial load
duke
parents:
diff changeset
   551
#####
06bc494ca11e Initial load
duke
parents:
diff changeset
   552
06bc494ca11e Initial load
duke
parents:
diff changeset
   553
# Fatal Errors
06bc494ca11e Initial load
duke
parents:
diff changeset
   554
06bc494ca11e Initial load
duke
parents:
diff changeset
   555
compiler.misc.fatal.err.no.java.lang=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   556
    Fatal Error: Unable to find package java.lang in classpath or bootclasspath
06bc494ca11e Initial load
duke
parents:
diff changeset
   557
compiler.misc.fatal.err.cant.locate.meth=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   558
    Fatal Error: Unable to find method {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   559
compiler.misc.fatal.err.cant.locate.field=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   560
    Fatal Error: Unable to find field {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   561
compiler.misc.fatal.err.cant.locate.ctor=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   562
    Fatal Error: Unable to find constructor for {0}
6581
f58f0ce45802 6980707: Reduce use of IOException in JavaCompiler
jjg
parents: 6345
diff changeset
   563
compiler.misc.fatal.err.cant.close.loader=\
f58f0ce45802 6980707: Reduce use of IOException in JavaCompiler
jjg
parents: 6345
diff changeset
   564
    Fatal Error: Cannot close class loader for annotation processors
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   565
06bc494ca11e Initial load
duke
parents:
diff changeset
   566
#####
06bc494ca11e Initial load
duke
parents:
diff changeset
   567
06bc494ca11e Initial load
duke
parents:
diff changeset
   568
##
06bc494ca11e Initial load
duke
parents:
diff changeset
   569
## miscellaneous strings
06bc494ca11e Initial load
duke
parents:
diff changeset
   570
##
06bc494ca11e Initial load
duke
parents:
diff changeset
   571
06bc494ca11e Initial load
duke
parents:
diff changeset
   572
compiler.misc.source.unavailable=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   573
    (source unavailable)
06bc494ca11e Initial load
duke
parents:
diff changeset
   574
compiler.misc.base.membership=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   575
    all your base class are belong to us
06bc494ca11e Initial load
duke
parents:
diff changeset
   576
compiler.misc.x.print.processor.info=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   577
    Processor {0} matches {1} and returns {2}.
06bc494ca11e Initial load
duke
parents:
diff changeset
   578
compiler.misc.x.print.rounds=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   579
    Round {0}:\n\tinput files: {1}\n\tannotations: {2}\n\tlast round: {3}
06bc494ca11e Initial load
duke
parents:
diff changeset
   580
06bc494ca11e Initial load
duke
parents:
diff changeset
   581
#####
06bc494ca11e Initial load
duke
parents:
diff changeset
   582
06bc494ca11e Initial load
duke
parents:
diff changeset
   583
## The following string will appear before all messages keyed as:
06bc494ca11e Initial load
duke
parents:
diff changeset
   584
## "compiler.note".
06bc494ca11e Initial load
duke
parents:
diff changeset
   585
compiler.note.note=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   586
    Note:\u0020
06bc494ca11e Initial load
duke
parents:
diff changeset
   587
06bc494ca11e Initial load
duke
parents:
diff changeset
   588
compiler.note.deprecated.filename=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   589
    {0} uses or overrides a deprecated API.
06bc494ca11e Initial load
duke
parents:
diff changeset
   590
compiler.note.deprecated.plural=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   591
    Some input files use or override a deprecated API.
06bc494ca11e Initial load
duke
parents:
diff changeset
   592
# The following string may appear after one of the above deprecation
06bc494ca11e Initial load
duke
parents:
diff changeset
   593
# messages.
06bc494ca11e Initial load
duke
parents:
diff changeset
   594
compiler.note.deprecated.recompile=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   595
    Recompile with -Xlint:deprecation for details.
06bc494ca11e Initial load
duke
parents:
diff changeset
   596
06bc494ca11e Initial load
duke
parents:
diff changeset
   597
compiler.note.deprecated.filename.additional=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   598
    {0} has additional uses or overrides of a deprecated API.
06bc494ca11e Initial load
duke
parents:
diff changeset
   599
compiler.note.deprecated.plural.additional=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   600
    Some input files additionally use or override a deprecated API.
06bc494ca11e Initial load
duke
parents:
diff changeset
   601
06bc494ca11e Initial load
duke
parents:
diff changeset
   602
compiler.note.unchecked.filename=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   603
    {0} uses unchecked or unsafe operations.
06bc494ca11e Initial load
duke
parents:
diff changeset
   604
compiler.note.unchecked.plural=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   605
    Some input files use unchecked or unsafe operations.
06bc494ca11e Initial load
duke
parents:
diff changeset
   606
# The following string may appear after one of the above deprecation
06bc494ca11e Initial load
duke
parents:
diff changeset
   607
# messages.
06bc494ca11e Initial load
duke
parents:
diff changeset
   608
compiler.note.unchecked.recompile=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   609
    Recompile with -Xlint:unchecked for details.
06bc494ca11e Initial load
duke
parents:
diff changeset
   610
06bc494ca11e Initial load
duke
parents:
diff changeset
   611
compiler.note.unchecked.filename.additional=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   612
    {0} has additional unchecked or unsafe operations.
06bc494ca11e Initial load
duke
parents:
diff changeset
   613
compiler.note.unchecked.plural.additional=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   614
    Some input files additionally use unchecked or unsafe operations.
06bc494ca11e Initial load
duke
parents:
diff changeset
   615
3661
104c425e96aa 6873845: refine access to symbol file
jjg
parents: 3560
diff changeset
   616
compiler.note.sunapi.filename=\
5848
c5a4ce47e780 6960407: Potential rebranding issues in openjdk/langtools repository sources
jjg
parents: 5846
diff changeset
   617
    {0} uses internal proprietary API that may be removed in a future release.
3661
104c425e96aa 6873845: refine access to symbol file
jjg
parents: 3560
diff changeset
   618
compiler.note.sunapi.plural=\
5848
c5a4ce47e780 6960407: Potential rebranding issues in openjdk/langtools repository sources
jjg
parents: 5846
diff changeset
   619
    Some input files use internal proprietary API that may be removed in a future release.
3661
104c425e96aa 6873845: refine access to symbol file
jjg
parents: 3560
diff changeset
   620
# The following string may appear after one of the above sunapi messages.
104c425e96aa 6873845: refine access to symbol file
jjg
parents: 3560
diff changeset
   621
compiler.note.sunapi.recompile=\
104c425e96aa 6873845: refine access to symbol file
jjg
parents: 3560
diff changeset
   622
    Recompile with -Xlint:sunapi for details.
104c425e96aa 6873845: refine access to symbol file
jjg
parents: 3560
diff changeset
   623
104c425e96aa 6873845: refine access to symbol file
jjg
parents: 3560
diff changeset
   624
compiler.note.sunapi.filename.additional=\
5848
c5a4ce47e780 6960407: Potential rebranding issues in openjdk/langtools repository sources
jjg
parents: 5846
diff changeset
   625
    {0} uses additional internal proprietary API that may be removed in a future release.
3661
104c425e96aa 6873845: refine access to symbol file
jjg
parents: 3560
diff changeset
   626
compiler.note.sunapi.plural.additional=\
5848
c5a4ce47e780 6960407: Potential rebranding issues in openjdk/langtools repository sources
jjg
parents: 5846
diff changeset
   627
    Some input files additionally use internal proprietary API that may be removed in a future release.
3661
104c425e96aa 6873845: refine access to symbol file
jjg
parents: 3560
diff changeset
   628
104c425e96aa 6873845: refine access to symbol file
jjg
parents: 3560
diff changeset
   629
# Notes related to annotation processing
104c425e96aa 6873845: refine access to symbol file
jjg
parents: 3560
diff changeset
   630
104c425e96aa 6873845: refine access to symbol file
jjg
parents: 3560
diff changeset
   631
# Print a client-generated note; assumed to be localized, no translation required
104c425e96aa 6873845: refine access to symbol file
jjg
parents: 3560
diff changeset
   632
compiler.note.proc.messager=\
104c425e96aa 6873845: refine access to symbol file
jjg
parents: 3560
diff changeset
   633
    {0}
104c425e96aa 6873845: refine access to symbol file
jjg
parents: 3560
diff changeset
   634
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   635
#####
06bc494ca11e Initial load
duke
parents:
diff changeset
   636
06bc494ca11e Initial load
duke
parents:
diff changeset
   637
compiler.misc.count.error=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   638
    {0} error
06bc494ca11e Initial load
duke
parents:
diff changeset
   639
compiler.misc.count.error.plural=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   640
    {0} errors
06bc494ca11e Initial load
duke
parents:
diff changeset
   641
compiler.misc.count.warn=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   642
    {0} warning
06bc494ca11e Initial load
duke
parents:
diff changeset
   643
compiler.misc.count.warn.plural=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   644
    {0} warnings
06bc494ca11e Initial load
duke
parents:
diff changeset
   645
6031
50004868a787 6964768: need test program to validate javac resource bundles
jjg
parents: 5848
diff changeset
   646
compiler.misc.version.not.available=\
50004868a787 6964768: need test program to validate javac resource bundles
jjg
parents: 5848
diff changeset
   647
    (version info not available)
50004868a787 6964768: need test program to validate javac resource bundles
jjg
parents: 5848
diff changeset
   648
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   649
## extra output when using -verbose (JavaCompiler)
06bc494ca11e Initial load
duke
parents:
diff changeset
   650
06bc494ca11e Initial load
duke
parents:
diff changeset
   651
compiler.misc.verbose.checking.attribution=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   652
    [checking {0}]
06bc494ca11e Initial load
duke
parents:
diff changeset
   653
compiler.misc.verbose.parsing.done=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   654
    [parsing completed {0}ms]
06bc494ca11e Initial load
duke
parents:
diff changeset
   655
compiler.misc.verbose.parsing.started=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   656
    [parsing started {0}]
06bc494ca11e Initial load
duke
parents:
diff changeset
   657
compiler.misc.verbose.total=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   658
    [total {0}ms]
06bc494ca11e Initial load
duke
parents:
diff changeset
   659
compiler.misc.verbose.wrote.file=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   660
    [wrote {0}]
06bc494ca11e Initial load
duke
parents:
diff changeset
   661
06bc494ca11e Initial load
duke
parents:
diff changeset
   662
## extra output when using -verbose (Retro)
06bc494ca11e Initial load
duke
parents:
diff changeset
   663
compiler.misc.verbose.retro=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   664
    [retrofitting {0}]
06bc494ca11e Initial load
duke
parents:
diff changeset
   665
compiler.misc.verbose.retro.with=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   666
    \tretrofitting {0} with {1}
06bc494ca11e Initial load
duke
parents:
diff changeset
   667
compiler.misc.verbose.retro.with.list=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   668
    \tretrofitting {0} with type parameters {1}, supertype {2}, interfaces {3}
06bc494ca11e Initial load
duke
parents:
diff changeset
   669
06bc494ca11e Initial load
duke
parents:
diff changeset
   670
## extra output when using -verbose (code/ClassReader)
06bc494ca11e Initial load
duke
parents:
diff changeset
   671
compiler.misc.verbose.loading=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   672
    [loading {0}]
06bc494ca11e Initial load
duke
parents:
diff changeset
   673
06bc494ca11e Initial load
duke
parents:
diff changeset
   674
compiler.misc.verbose.sourcepath=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   675
    [search path for source files: {0}]
06bc494ca11e Initial load
duke
parents:
diff changeset
   676
06bc494ca11e Initial load
duke
parents:
diff changeset
   677
compiler.misc.verbose.classpath=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   678
    [search path for class files: {0}]
06bc494ca11e Initial load
duke
parents:
diff changeset
   679
06bc494ca11e Initial load
duke
parents:
diff changeset
   680
## extra output when using -checkclassfile (code/ClassReader)
06bc494ca11e Initial load
duke
parents:
diff changeset
   681
compiler.misc.ccf.found.later.version=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   682
    class file has later version than expected: {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   683
compiler.misc.ccf.unrecognized.attribute=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   684
    unrecognized attribute: {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   685
06bc494ca11e Initial load
duke
parents:
diff changeset
   686
## extra output when using -prompt (util/Log)
06bc494ca11e Initial load
duke
parents:
diff changeset
   687
compiler.misc.resume.abort=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   688
    R)esume, A)bort>
06bc494ca11e Initial load
duke
parents:
diff changeset
   689
06bc494ca11e Initial load
duke
parents:
diff changeset
   690
#####
06bc494ca11e Initial load
duke
parents:
diff changeset
   691
06bc494ca11e Initial load
duke
parents:
diff changeset
   692
##
06bc494ca11e Initial load
duke
parents:
diff changeset
   693
## warnings
06bc494ca11e Initial load
duke
parents:
diff changeset
   694
##
06bc494ca11e Initial load
duke
parents:
diff changeset
   695
06bc494ca11e Initial load
duke
parents:
diff changeset
   696
## All warning messages are preceded by the following string.
06bc494ca11e Initial load
duke
parents:
diff changeset
   697
compiler.warn.warning=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   698
    warning:\u0020
06bc494ca11e Initial load
duke
parents:
diff changeset
   699
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
   700
## Warning messages may also include the following prefix to identify a
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
   701
## lint option
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
   702
compiler.warn.lintOption=\
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
   703
    [{0}]\u0020
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
   704
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   705
compiler.warn.constant.SVUID=\
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
   706
    serialVersionUID must be constant in class {0}
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   707
06bc494ca11e Initial load
duke
parents:
diff changeset
   708
compiler.warn.dir.path.element.not.found=\
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
   709
    bad path element "{0}": no such directory
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   710
06bc494ca11e Initial load
duke
parents:
diff changeset
   711
compiler.warn.finally.cannot.complete=\
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
   712
    finally clause cannot complete normally
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   713
06bc494ca11e Initial load
duke
parents:
diff changeset
   714
compiler.warn.has.been.deprecated=\
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
   715
    {0} in {1} has been deprecated
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   716
06bc494ca11e Initial load
duke
parents:
diff changeset
   717
compiler.warn.sun.proprietary=\
5848
c5a4ce47e780 6960407: Potential rebranding issues in openjdk/langtools repository sources
jjg
parents: 5846
diff changeset
   718
    {0} is internal proprietary API and may be removed in a future release
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   719
06bc494ca11e Initial load
duke
parents:
diff changeset
   720
compiler.warn.illegal.char.for.encoding=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   721
    unmappable character for encoding {0}
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
   722
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   723
compiler.warn.improper.SVUID=\
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
   724
    serialVersionUID must be declared static final in class {0}
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   725
06bc494ca11e Initial load
duke
parents:
diff changeset
   726
compiler.warn.inexact.non-varargs.call=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   727
non-varargs call of varargs method with inexact argument type for last parameter;\n\
06bc494ca11e Initial load
duke
parents:
diff changeset
   728
cast to {0} for a varargs call\n\
06bc494ca11e Initial load
duke
parents:
diff changeset
   729
cast to {1} for a non-varargs call and to suppress this warning
06bc494ca11e Initial load
duke
parents:
diff changeset
   730
06bc494ca11e Initial load
duke
parents:
diff changeset
   731
compiler.warn.long.SVUID=\
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
   732
    serialVersionUID must be of type long in class {0}
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   733
06bc494ca11e Initial load
duke
parents:
diff changeset
   734
compiler.warn.missing.SVUID=\
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
   735
    serializable class {0} has no definition of serialVersionUID
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   736
06bc494ca11e Initial load
duke
parents:
diff changeset
   737
compiler.warn.override.varargs.missing=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   738
    {0}; overridden method has no ''...''
06bc494ca11e Initial load
duke
parents:
diff changeset
   739
compiler.warn.override.varargs.extra=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   740
    {0}; overriding method is missing ''...''
06bc494ca11e Initial load
duke
parents:
diff changeset
   741
compiler.warn.override.bridge=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   742
    {0}; overridden method is a bridge method
06bc494ca11e Initial load
duke
parents:
diff changeset
   743
06bc494ca11e Initial load
duke
parents:
diff changeset
   744
compiler.warn.pkg-info.already.seen=\
4692
4df6242d3940 6307206: missing lint control for pkg-info
jjg
parents: 4142
diff changeset
   745
    a package-info.java file has already been seen for package {0}
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
   746
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   747
compiler.warn.path.element.not.found=\
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
   748
    bad path element "{0}": no such file or directory
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
   749
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   750
compiler.warn.possible.fall-through.into.case=\
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
   751
    possible fall-through into case
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   752
06bc494ca11e Initial load
duke
parents:
diff changeset
   753
compiler.warn.redundant.cast=\
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
   754
    redundant cast to {0}
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   755
06bc494ca11e Initial load
duke
parents:
diff changeset
   756
compiler.warn.position.overflow=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   757
    Position encoding overflows at line {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   758
06bc494ca11e Initial load
duke
parents:
diff changeset
   759
compiler.warn.big.major.version=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   760
    {0}: major version {1} is newer than {2}, the highest major version supported by this compiler.\n\
06bc494ca11e Initial load
duke
parents:
diff changeset
   761
    It is recommended that the compiler be upgraded.
06bc494ca11e Initial load
duke
parents:
diff changeset
   762
5002
12a9e8562200 4880220: Add a warning when accessing a static method via an reference
jjg
parents: 4692
diff changeset
   763
compiler.warn.static.not.qualified.by.type=\
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
   764
    static {0} should be qualified by type name, {1}, instead of by an expression
5002
12a9e8562200 4880220: Add a warning when accessing a static method via an reference
jjg
parents: 4692
diff changeset
   765
7335
8b390fd27190 6900037: javac should warn if earlier -source is used and bootclasspath not set
jjg
parents: 7330
diff changeset
   766
compiler.warn.source.no.bootclasspath=\
8b390fd27190 6900037: javac should warn if earlier -source is used and bootclasspath not set
jjg
parents: 7330
diff changeset
   767
    bootstrap class path not set in conjunction with -source {0}
8b390fd27190 6900037: javac should warn if earlier -source is used and bootclasspath not set
jjg
parents: 7330
diff changeset
   768
7624
c31b0ea95b37 6999210: javac should be able to warn of anomalous conditions in classfiles
jjg
parents: 7335
diff changeset
   769
compiler.warn.future.attr=\
c31b0ea95b37 6999210: javac should be able to warn of anomalous conditions in classfiles
jjg
parents: 7335
diff changeset
   770
    {0} attribute introduced in version {1}.{2} class files is ignored in version {3}.{4} class files
c31b0ea95b37 6999210: javac should be able to warn of anomalous conditions in classfiles
jjg
parents: 7335
diff changeset
   771
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   772
# Warnings related to annotation processing
06bc494ca11e Initial load
duke
parents:
diff changeset
   773
compiler.warn.proc.package.does.not.exist=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   774
    package {0} does not exist
06bc494ca11e Initial load
duke
parents:
diff changeset
   775
compiler.warn.proc.file.reopening=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   776
    Attempt to create a file for ''{0}'' multiple times
06bc494ca11e Initial load
duke
parents:
diff changeset
   777
06bc494ca11e Initial load
duke
parents:
diff changeset
   778
compiler.warn.proc.type.already.exists=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   779
    A file for type ''{0}'' already exists on the sourcepath or classpath
06bc494ca11e Initial load
duke
parents:
diff changeset
   780
06bc494ca11e Initial load
duke
parents:
diff changeset
   781
compiler.warn.proc.type.recreate=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   782
    Attempt to create a file for type ''{0}'' multiple times
06bc494ca11e Initial load
duke
parents:
diff changeset
   783
06bc494ca11e Initial load
duke
parents:
diff changeset
   784
compiler.warn.proc.illegal.file.name=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   785
    Cannot create file for illegal name ''{0}''.
06bc494ca11e Initial load
duke
parents:
diff changeset
   786
6157
218670cd9b1c 6972556: warning for using a file name instead of a binary name for Filer.createSourceFile
jjg
parents: 6151
diff changeset
   787
compiler.warn.proc.suspicious.class.name=\
218670cd9b1c 6972556: warning for using a file name instead of a binary name for Filer.createSourceFile
jjg
parents: 6151
diff changeset
   788
    Creating file for a type whose name ends in {1}: ''{0}''
218670cd9b1c 6972556: warning for using a file name instead of a binary name for Filer.createSourceFile
jjg
parents: 6151
diff changeset
   789
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   790
compiler.warn.proc.file.create.last.round=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   791
    File for type ''{0}'' created in the last round will not be subject to annotation processing.
06bc494ca11e Initial load
duke
parents:
diff changeset
   792
06bc494ca11e Initial load
duke
parents:
diff changeset
   793
compiler.warn.proc.malformed.supported.string=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   794
    Malformed string ''{0}'' for a supported annotation type returned by processor ''{1}''
06bc494ca11e Initial load
duke
parents:
diff changeset
   795
06bc494ca11e Initial load
duke
parents:
diff changeset
   796
compiler.warn.proc.annotations.without.processors=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   797
    No processor claimed any of these annotations: {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   798
06bc494ca11e Initial load
duke
parents:
diff changeset
   799
compiler.warn.proc.processor.incompatible.source.version=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   800
    Supported source version ''{0}'' from annotation processor ''{1}'' less than -source ''{2}''
06bc494ca11e Initial load
duke
parents:
diff changeset
   801
06bc494ca11e Initial load
duke
parents:
diff changeset
   802
compiler.warn.proc.proc-only.requested.no.procs=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   803
    Annotation processing without compilation requested but no processors were found.
06bc494ca11e Initial load
duke
parents:
diff changeset
   804
06bc494ca11e Initial load
duke
parents:
diff changeset
   805
compiler.warn.proc.use.implicit=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   806
Implicitly compiled files were not subject to annotation processing.\n\
06bc494ca11e Initial load
duke
parents:
diff changeset
   807
Use -implicit to specify a policy for implicit compilation.
06bc494ca11e Initial load
duke
parents:
diff changeset
   808
06bc494ca11e Initial load
duke
parents:
diff changeset
   809
compiler.warn.proc.use.proc.or.implicit=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   810
Implicitly compiled files were not subject to annotation processing.\n\
06bc494ca11e Initial load
duke
parents:
diff changeset
   811
Use -proc:none to disable annotation processing or -implicit to specify a policy for implicit compilation.
06bc494ca11e Initial load
duke
parents:
diff changeset
   812
06bc494ca11e Initial load
duke
parents:
diff changeset
   813
# Print a client-generated warning; assumed to be localized, no translation required
06bc494ca11e Initial load
duke
parents:
diff changeset
   814
compiler.warn.proc.messager=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   815
    {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   816
06bc494ca11e Initial load
duke
parents:
diff changeset
   817
compiler.warn.proc.unclosed.type.files=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   818
    Unclosed files for the types ''{0}''; these types will not undergo annotation processing
06bc494ca11e Initial load
duke
parents:
diff changeset
   819
06bc494ca11e Initial load
duke
parents:
diff changeset
   820
compiler.warn.proc.unmatched.processor.options=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   821
    The following options were not recognized by any processor: ''{0}''
06bc494ca11e Initial load
duke
parents:
diff changeset
   822
7211
163fe60f63de 6970016: Clean up ARM/try-with-resources implementation
mcimadamore
parents: 7203
diff changeset
   823
compiler.warn.try.explicit.close.call=\
163fe60f63de 6970016: Clean up ARM/try-with-resources implementation
mcimadamore
parents: 7203
diff changeset
   824
    explicit call to close() on an auto-closeable resource
163fe60f63de 6970016: Clean up ARM/try-with-resources implementation
mcimadamore
parents: 7203
diff changeset
   825
compiler.warn.try.resource.not.referenced=\
163fe60f63de 6970016: Clean up ARM/try-with-resources implementation
mcimadamore
parents: 7203
diff changeset
   826
    auto-closeable resource {0} is never referenced in body of corresponding try statement
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   827
compiler.warn.unchecked.assign=\
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
   828
    unchecked assignment: {0} to {1}
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   829
compiler.warn.unchecked.assign.to.var=\
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
   830
    unchecked assignment to variable {0} as member of raw type {1}
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   831
compiler.warn.unchecked.call.mbr.of.raw.type=\
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
   832
    unchecked call to {0} as a member of the raw type {1}
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   833
compiler.warn.unchecked.cast.to.type=\
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
   834
    unchecked cast to type {0}
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   835
compiler.warn.unchecked.meth.invocation.applied=\
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
   836
    unchecked method invocation: {0} {1} in {4} {5} is applied to given types\n\
1534
e923a41e84cc 6758789: Some method resolution diagnostic should be improved
mcimadamore
parents: 1358
diff changeset
   837
    required: {2}\n\
e923a41e84cc 6758789: Some method resolution diagnostic should be improved
mcimadamore
parents: 1358
diff changeset
   838
    found: {3}
e923a41e84cc 6758789: Some method resolution diagnostic should be improved
mcimadamore
parents: 1358
diff changeset
   839
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   840
compiler.warn.unchecked.generic.array.creation=\
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
   841
    unchecked generic array creation for varargs parameter of type {0}
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   842
7643
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7624
diff changeset
   843
compiler.warn.unchecked.varargs.non.reifiable.type=\
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
   844
    Possible heap pollution from parameterized vararg type {0}
5846
6df0e6bcb388 6945418: Project Coin: Simplified Varargs Method Invocation
mcimadamore
parents: 5520
diff changeset
   845
7643
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7624
diff changeset
   846
compiler.warn.varargs.unsafe.use.varargs.param=\
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7624
diff changeset
   847
    Varargs method could cause heap pollution from non-reifiable varargs parameter {0}
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7624
diff changeset
   848
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   849
compiler.warn.missing.deprecated.annotation=\
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
   850
    deprecated item is not annotated with @Deprecated
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   851
06bc494ca11e Initial load
duke
parents:
diff changeset
   852
compiler.warn.invalid.archive.file=\
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
   853
    Unexpected file on path: {0}
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   854
06bc494ca11e Initial load
duke
parents:
diff changeset
   855
compiler.warn.unexpected.archive.file=\
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
   856
    Unexpected extension for archive file: {0}
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   857
06bc494ca11e Initial load
duke
parents:
diff changeset
   858
compiler.warn.div.zero=\
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
   859
    division by zero
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   860
06bc494ca11e Initial load
duke
parents:
diff changeset
   861
compiler.warn.empty.if=\
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
   862
    empty statement after if
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   863
06bc494ca11e Initial load
duke
parents:
diff changeset
   864
compiler.warn.annotation.method.not.found=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   865
    Cannot find annotation method ''{1}()'' in type ''{0}''
06bc494ca11e Initial load
duke
parents:
diff changeset
   866
06bc494ca11e Initial load
duke
parents:
diff changeset
   867
compiler.warn.annotation.method.not.found.reason=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   868
    Cannot find annotation method ''{1}()'' in type ''{0}'': {2}
06bc494ca11e Initial load
duke
parents:
diff changeset
   869
1358
a51c5f89f8af 6747671: -Xlint:rawtypes
mcimadamore
parents: 1357
diff changeset
   870
compiler.warn.raw.class.use=\
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
   871
    found raw type: {0}\n\
8045
df2ca0edfbaa 6968793: issues with diagnostics
mcimadamore
parents: 8038
diff changeset
   872
    missing type arguments for generic class {1}
1358
a51c5f89f8af 6747671: -Xlint:rawtypes
mcimadamore
parents: 1357
diff changeset
   873
7081
94cfc5b65bed 6939780: add a warning to detect diamond sites
mcimadamore
parents: 7072
diff changeset
   874
compiler.warn.diamond.redundant.args=\
94cfc5b65bed 6939780: add a warning to detect diamond sites
mcimadamore
parents: 7072
diff changeset
   875
    redundant type arguments in new expression (use diamond operator instead).
94cfc5b65bed 6939780: add a warning to detect diamond sites
mcimadamore
parents: 7072
diff changeset
   876
compiler.warn.diamond.redundant.args.1=\
94cfc5b65bed 6939780: add a warning to detect diamond sites
mcimadamore
parents: 7072
diff changeset
   877
    redundant type arguments in new expression (use diamond operator instead).\n\
94cfc5b65bed 6939780: add a warning to detect diamond sites
mcimadamore
parents: 7072
diff changeset
   878
    explicit: {0}\n\
94cfc5b65bed 6939780: add a warning to detect diamond sites
mcimadamore
parents: 7072
diff changeset
   879
    inferred: {1}
94cfc5b65bed 6939780: add a warning to detect diamond sites
mcimadamore
parents: 7072
diff changeset
   880
7643
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7624
diff changeset
   881
compiler.warn.varargs.redundant.trustme.anno=\
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7624
diff changeset
   882
    Redundant {0} annotation. {1}
a067a0cda531 6993978: Project Coin: Compiler support of annotation to reduce varargs warnings
mcimadamore
parents: 7624
diff changeset
   883
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   884
#####
06bc494ca11e Initial load
duke
parents:
diff changeset
   885
06bc494ca11e Initial load
duke
parents:
diff changeset
   886
## The following are tokens which are non-terminals in the language. They should
06bc494ca11e Initial load
duke
parents:
diff changeset
   887
## be named as JLS3 calls them when translated to the appropriate language.
06bc494ca11e Initial load
duke
parents:
diff changeset
   888
compiler.misc.token.identifier=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   889
    <identifier>
06bc494ca11e Initial load
duke
parents:
diff changeset
   890
compiler.misc.token.character=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   891
    <character>
06bc494ca11e Initial load
duke
parents:
diff changeset
   892
compiler.misc.token.string=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   893
    <string>
06bc494ca11e Initial load
duke
parents:
diff changeset
   894
compiler.misc.token.integer=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   895
    <integer>
06bc494ca11e Initial load
duke
parents:
diff changeset
   896
compiler.misc.token.long-integer=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   897
    <long integer>
06bc494ca11e Initial load
duke
parents:
diff changeset
   898
compiler.misc.token.float=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   899
    <float>
06bc494ca11e Initial load
duke
parents:
diff changeset
   900
compiler.misc.token.double=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   901
    <double>
06bc494ca11e Initial load
duke
parents:
diff changeset
   902
compiler.misc.token.bad-symbol=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   903
    <bad symbol>
06bc494ca11e Initial load
duke
parents:
diff changeset
   904
compiler.misc.token.end-of-input=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   905
    <end of input>
06bc494ca11e Initial load
duke
parents:
diff changeset
   906
06bc494ca11e Initial load
duke
parents:
diff changeset
   907
## The argument to the following string will always be one of the following:
06bc494ca11e Initial load
duke
parents:
diff changeset
   908
## 1. one of the above non-terminals
06bc494ca11e Initial load
duke
parents:
diff changeset
   909
## 2. a keyword (JLS1.8)
06bc494ca11e Initial load
duke
parents:
diff changeset
   910
## 3. a boolean literal (JLS3.10.3)
06bc494ca11e Initial load
duke
parents:
diff changeset
   911
## 4. the null literal (JLS3.10.7)
06bc494ca11e Initial load
duke
parents:
diff changeset
   912
## 5. a Java separator (JLS3.11)
06bc494ca11e Initial load
duke
parents:
diff changeset
   913
## 6. an operator (JLS3.12)
06bc494ca11e Initial load
duke
parents:
diff changeset
   914
##
06bc494ca11e Initial load
duke
parents:
diff changeset
   915
## This is the only place these tokens will be used.
06bc494ca11e Initial load
duke
parents:
diff changeset
   916
compiler.err.expected=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   917
    {0} expected
06bc494ca11e Initial load
duke
parents:
diff changeset
   918
compiler.err.expected2=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   919
    {0} or {1} expected
06bc494ca11e Initial load
duke
parents:
diff changeset
   920
compiler.err.expected3=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   921
    {0}, {1}, or {2} expected
06bc494ca11e Initial load
duke
parents:
diff changeset
   922
06bc494ca11e Initial load
duke
parents:
diff changeset
   923
compiler.err.premature.eof=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   924
    reached end of file while parsing
06bc494ca11e Initial load
duke
parents:
diff changeset
   925
06bc494ca11e Initial load
duke
parents:
diff changeset
   926
## The following are related in form, but do not easily fit the above paradigm.
06bc494ca11e Initial load
duke
parents:
diff changeset
   927
compiler.err.dot.class.expected=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   928
    ''.class'' expected
06bc494ca11e Initial load
duke
parents:
diff changeset
   929
06bc494ca11e Initial load
duke
parents:
diff changeset
   930
## The argument to this string will always be either 'case' or 'default'.
06bc494ca11e Initial load
duke
parents:
diff changeset
   931
compiler.err.orphaned=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   932
    orphaned {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   933
06bc494ca11e Initial load
duke
parents:
diff changeset
   934
compiler.misc.anonymous.class=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   935
    <anonymous {0}>
06bc494ca11e Initial load
duke
parents:
diff changeset
   936
1357
e2d4f3e1f805 6735840: Need a type/symbol visitor printer
mcimadamore
parents: 1045
diff changeset
   937
compiler.misc.type.captureof=\
e2d4f3e1f805 6735840: Need a type/symbol visitor printer
mcimadamore
parents: 1045
diff changeset
   938
    capture#{0} of {1}
e2d4f3e1f805 6735840: Need a type/symbol visitor printer
mcimadamore
parents: 1045
diff changeset
   939
2221
cd6557bcaa0a 6799605: Basic/Raw formatters should use type/symbol printer instead of toString()
mcimadamore
parents: 2085
diff changeset
   940
compiler.misc.type.captureof.1=\
cd6557bcaa0a 6799605: Basic/Raw formatters should use type/symbol printer instead of toString()
mcimadamore
parents: 2085
diff changeset
   941
    capture#{0}
cd6557bcaa0a 6799605: Basic/Raw formatters should use type/symbol printer instead of toString()
mcimadamore
parents: 2085
diff changeset
   942
1357
e2d4f3e1f805 6735840: Need a type/symbol visitor printer
mcimadamore
parents: 1045
diff changeset
   943
compiler.misc.type.none=\
e2d4f3e1f805 6735840: Need a type/symbol visitor printer
mcimadamore
parents: 1045
diff changeset
   944
    <none>
e2d4f3e1f805 6735840: Need a type/symbol visitor printer
mcimadamore
parents: 1045
diff changeset
   945
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   946
compiler.misc.unnamed.package=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   947
    unnamed package
06bc494ca11e Initial load
duke
parents:
diff changeset
   948
06bc494ca11e Initial load
duke
parents:
diff changeset
   949
#####
06bc494ca11e Initial load
duke
parents:
diff changeset
   950
06bc494ca11e Initial load
duke
parents:
diff changeset
   951
compiler.err.cant.access=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   952
cannot access {0}\n\
06bc494ca11e Initial load
duke
parents:
diff changeset
   953
{1}
06bc494ca11e Initial load
duke
parents:
diff changeset
   954
06bc494ca11e Initial load
duke
parents:
diff changeset
   955
compiler.misc.bad.class.file.header=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   956
bad class file: {0}\n\
06bc494ca11e Initial load
duke
parents:
diff changeset
   957
{1}\n\
06bc494ca11e Initial load
duke
parents:
diff changeset
   958
Please remove or make sure it appears in the correct subdirectory of the classpath.
169
ff76730e430e 6668794: javac puts localized text in raw diagnostics
jjg
parents: 10
diff changeset
   959
compiler.misc.bad.source.file.header=\
ff76730e430e 6668794: javac puts localized text in raw diagnostics
jjg
parents: 10
diff changeset
   960
bad source file: {0}\n\
ff76730e430e 6668794: javac puts localized text in raw diagnostics
jjg
parents: 10
diff changeset
   961
{1}\n\
ff76730e430e 6668794: javac puts localized text in raw diagnostics
jjg
parents: 10
diff changeset
   962
Please remove or make sure it appears in the correct subdirectory of the sourcepath.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   963
06bc494ca11e Initial load
duke
parents:
diff changeset
   964
## The following are all possible strings for the second argument ({1}) of the
06bc494ca11e Initial load
duke
parents:
diff changeset
   965
## above strings.
06bc494ca11e Initial load
duke
parents:
diff changeset
   966
compiler.misc.bad.class.signature=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   967
    bad class signature: {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   968
compiler.misc.bad.enclosing.method=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   969
    bad enclosing method attribute: {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   970
compiler.misc.bad.runtime.invisible.param.annotations=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   971
    bad RuntimeInvisibleParameterAnnotations attribute: {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   972
compiler.misc.bad.const.pool.tag=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   973
    bad constant pool tag: {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   974
compiler.misc.bad.const.pool.tag.at=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   975
    bad constant pool tag: {0} at {1}
06bc494ca11e Initial load
duke
parents:
diff changeset
   976
compiler.misc.bad.signature=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   977
    bad signature: {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   978
compiler.misc.class.file.wrong.class=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   979
    class file contains wrong class: {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   980
compiler.misc.class.file.not.found=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   981
    class file for {0} not found
06bc494ca11e Initial load
duke
parents:
diff changeset
   982
compiler.misc.file.doesnt.contain.class=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   983
    file does not contain class {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   984
compiler.misc.file.does.not.contain.package=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   985
    file does not contain package {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   986
compiler.misc.illegal.start.of.class.file=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   987
    illegal start of class file
06bc494ca11e Initial load
duke
parents:
diff changeset
   988
compiler.misc.unable.to.access.file=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   989
    unable to access file: {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   990
compiler.misc.unicode.str.not.supported=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   991
    unicode string in class file not supported
06bc494ca11e Initial load
duke
parents:
diff changeset
   992
compiler.misc.undecl.type.var=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   993
    undeclared type variable: {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
   994
compiler.misc.wrong.version=\
06bc494ca11e Initial load
duke
parents:
diff changeset
   995
    class file has wrong version {0}.{1}, should be {2}.{3}
06bc494ca11e Initial load
duke
parents:
diff changeset
   996
06bc494ca11e Initial load
duke
parents:
diff changeset
   997
#####
06bc494ca11e Initial load
duke
parents:
diff changeset
   998
06bc494ca11e Initial load
duke
parents:
diff changeset
   999
compiler.err.not.within.bounds=\
8045
df2ca0edfbaa 6968793: issues with diagnostics
mcimadamore
parents: 8038
diff changeset
  1000
    type argument {0} is not within bounds of type-variable {1}
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1001
06bc494ca11e Initial load
duke
parents:
diff changeset
  1002
## The following are all possible strings for the second argument ({1}) of the
06bc494ca11e Initial load
duke
parents:
diff changeset
  1003
## above string.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1004
06bc494ca11e Initial load
duke
parents:
diff changeset
  1005
## none yet...
06bc494ca11e Initial load
duke
parents:
diff changeset
  1006
06bc494ca11e Initial load
duke
parents:
diff changeset
  1007
#####
06bc494ca11e Initial load
duke
parents:
diff changeset
  1008
06bc494ca11e Initial load
duke
parents:
diff changeset
  1009
compiler.err.prob.found.req=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1010
{0}\n\
2085
4792e12a8ca2 6769027: Source line should be displayed immediately after the first diagnostic line
mcimadamore
parents: 1996
diff changeset
  1011
required: {2}\n\
4792e12a8ca2 6769027: Source line should be displayed immediately after the first diagnostic line
mcimadamore
parents: 1996
diff changeset
  1012
found:    {1}
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1013
compiler.warn.prob.found.req=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1014
{0}\n\
2085
4792e12a8ca2 6769027: Source line should be displayed immediately after the first diagnostic line
mcimadamore
parents: 1996
diff changeset
  1015
required: {2}\n\
4792e12a8ca2 6769027: Source line should be displayed immediately after the first diagnostic line
mcimadamore
parents: 1996
diff changeset
  1016
found:    {1}
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1017
compiler.err.prob.found.req.1=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1018
{0} {3}\n\
2085
4792e12a8ca2 6769027: Source line should be displayed immediately after the first diagnostic line
mcimadamore
parents: 1996
diff changeset
  1019
required: {2}\n\
4792e12a8ca2 6769027: Source line should be displayed immediately after the first diagnostic line
mcimadamore
parents: 1996
diff changeset
  1020
found:    {1}
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1021
06bc494ca11e Initial load
duke
parents:
diff changeset
  1022
## The following are all possible strings for the first argument ({0}) of the
06bc494ca11e Initial load
duke
parents:
diff changeset
  1023
## above strings.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1024
compiler.misc.incompatible.types=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1025
    incompatible types
06bc494ca11e Initial load
duke
parents:
diff changeset
  1026
compiler.misc.incompatible.types.1=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1027
    incompatible types; {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
  1028
compiler.misc.inconvertible.types=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1029
    inconvertible types
06bc494ca11e Initial load
duke
parents:
diff changeset
  1030
compiler.misc.possible.loss.of.precision=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1031
    possible loss of precision
06bc494ca11e Initial load
duke
parents:
diff changeset
  1032
06bc494ca11e Initial load
duke
parents:
diff changeset
  1033
compiler.misc.unchecked.assign=\
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
  1034
    unchecked conversion
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1035
# compiler.misc.storecheck=\
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
  1036
#     assignment might cause later store checks to fail
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1037
# compiler.misc.unchecked=\
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
  1038
#     assigned array cannot dynamically check its stores
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1039
compiler.misc.unchecked.cast.to.type=\
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
  1040
    unchecked cast
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1041
06bc494ca11e Initial load
duke
parents:
diff changeset
  1042
compiler.misc.assignment.from.super-bound=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1043
    assignment from super-bound type {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
  1044
compiler.misc.assignment.to.extends-bound=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1045
    assignment to extends-bound type {0}
06bc494ca11e Initial load
duke
parents:
diff changeset
  1046
# compiler.err.star.expected=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1047
#     ''*'' expected
06bc494ca11e Initial load
duke
parents:
diff changeset
  1048
# compiler.err.no.elem.type=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1049
#     \[\*\] cannot have a type
06bc494ca11e Initial load
duke
parents:
diff changeset
  1050
7211
163fe60f63de 6970016: Clean up ARM/try-with-resources implementation
mcimadamore
parents: 7203
diff changeset
  1051
compiler.misc.try.not.applicable.to.type=\
163fe60f63de 6970016: Clean up ARM/try-with-resources implementation
mcimadamore
parents: 7203
diff changeset
  1052
    try-with-resources not applicable to variable type
163fe60f63de 6970016: Clean up ARM/try-with-resources implementation
mcimadamore
parents: 7203
diff changeset
  1053
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1054
#####
06bc494ca11e Initial load
duke
parents:
diff changeset
  1055
06bc494ca11e Initial load
duke
parents:
diff changeset
  1056
compiler.err.type.found.req=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1057
unexpected type\n\
2085
4792e12a8ca2 6769027: Source line should be displayed immediately after the first diagnostic line
mcimadamore
parents: 1996
diff changeset
  1058
required: {1}\n\
4792e12a8ca2 6769027: Source line should be displayed immediately after the first diagnostic line
mcimadamore
parents: 1996
diff changeset
  1059
found:    {0}
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1060
06bc494ca11e Initial load
duke
parents:
diff changeset
  1061
## The following are all possible strings for the first argument ({0}) of the
06bc494ca11e Initial load
duke
parents:
diff changeset
  1062
## above string.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1063
compiler.misc.type.req.class=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1064
    class
06bc494ca11e Initial load
duke
parents:
diff changeset
  1065
compiler.misc.type.req.class.array=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1066
    class or array
8045
df2ca0edfbaa 6968793: issues with diagnostics
mcimadamore
parents: 8038
diff changeset
  1067
compiler.misc.type.req.array.or.iterable=\
df2ca0edfbaa 6968793: issues with diagnostics
mcimadamore
parents: 8038
diff changeset
  1068
    array or java.lang.Iterable
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1069
compiler.misc.type.req.ref=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1070
    reference
06bc494ca11e Initial load
duke
parents:
diff changeset
  1071
compiler.misc.type.req.exact=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1072
    class or interface without bounds
06bc494ca11e Initial load
duke
parents:
diff changeset
  1073
compiler.misc.type.parameter=\
939
38e24969c7e9 6717241: some diagnostic argument is prematurely converted into a String object
mcimadamore
parents: 735
diff changeset
  1074
    type parameter {0}
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1075
06bc494ca11e Initial load
duke
parents:
diff changeset
  1076
#####
06bc494ca11e Initial load
duke
parents:
diff changeset
  1077
06bc494ca11e Initial load
duke
parents:
diff changeset
  1078
## The following are all possible strings for the last argument of all those
06bc494ca11e Initial load
duke
parents:
diff changeset
  1079
## diagnostics whose key ends in ".1"
06bc494ca11e Initial load
duke
parents:
diff changeset
  1080
compiler.misc.undetermined.type=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1081
    undetermined type
6031
50004868a787 6964768: need test program to validate javac resource bundles
jjg
parents: 5848
diff changeset
  1082
compiler.misc.type.variable.has.undetermined.type=\
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1083
    type variable {0} has undetermined type
06bc494ca11e Initial load
duke
parents:
diff changeset
  1084
compiler.misc.no.unique.maximal.instance.exists=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1085
    no unique maximal instance exists for type variable {0} with upper bounds {1}
06bc494ca11e Initial load
duke
parents:
diff changeset
  1086
compiler.misc.no.unique.minimal.instance.exists=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1087
    no unique minimal instance exists for type variable {0} with lower bounds {1}
6710
b14e6fe7b290 5088624: cannot find symbol message should be more intelligent
mcimadamore
parents: 6592
diff changeset
  1088
compiler.misc.infer.no.conforming.instance.exists=\
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1089
    no instance(s) of type variable(s) {0} exist so that {1} conforms to {2}
6710
b14e6fe7b290 5088624: cannot find symbol message should be more intelligent
mcimadamore
parents: 6592
diff changeset
  1090
compiler.misc.infer.no.conforming.assignment.exists=\
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1091
    no instance(s) of type variable(s) {0} exist so that argument type {1} conforms to formal parameter type {2}
6710
b14e6fe7b290 5088624: cannot find symbol message should be more intelligent
mcimadamore
parents: 6592
diff changeset
  1092
compiler.misc.infer.arg.length.mismatch=\
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1093
    cannot instantiate from arguments because actual and formal argument lists differ in length
06bc494ca11e Initial load
duke
parents:
diff changeset
  1094
compiler.misc.inferred.do.not.conform.to.bounds=\
3140
15a274b13051 6638712: Inference with wildcard types causes selection of inapplicable method
mcimadamore
parents: 2984
diff changeset
  1095
    inferred type does not conform to declared bound(s)\n\
15a274b13051 6638712: Inference with wildcard types causes selection of inapplicable method
mcimadamore
parents: 2984
diff changeset
  1096
    inferred: {0}\n\
15a274b13051 6638712: Inference with wildcard types causes selection of inapplicable method
mcimadamore
parents: 2984
diff changeset
  1097
    bound(s): {1}
15a274b13051 6638712: Inference with wildcard types causes selection of inapplicable method
mcimadamore
parents: 2984
diff changeset
  1098
compiler.misc.inferred.do.not.conform.to.params=\
3540
dceac8629a56 6862608: rich diagnostic sometimes contain wrong type variable numbering
mcimadamore
parents: 3149
diff changeset
  1099
    actual arguments do not conform to inferred formal arguments\n\
3140
15a274b13051 6638712: Inference with wildcard types causes selection of inapplicable method
mcimadamore
parents: 2984
diff changeset
  1100
    required: {0}\n\
15a274b13051 6638712: Inference with wildcard types causes selection of inapplicable method
mcimadamore
parents: 2984
diff changeset
  1101
    found: {1}
5321
c8efe769cb3b 6939620: Switch to 'complex' diamond inference scheme
mcimadamore
parents: 5320
diff changeset
  1102
compiler.misc.diamond=\
c8efe769cb3b 6939620: Switch to 'complex' diamond inference scheme
mcimadamore
parents: 5320
diff changeset
  1103
    {0}<>
c8efe769cb3b 6939620: Switch to 'complex' diamond inference scheme
mcimadamore
parents: 5320
diff changeset
  1104
compiler.misc.diamond.invalid.arg=\
c8efe769cb3b 6939620: Switch to 'complex' diamond inference scheme
mcimadamore
parents: 5320
diff changeset
  1105
    type argument {0} inferred for {1} is not allowed in this context
c8efe769cb3b 6939620: Switch to 'complex' diamond inference scheme
mcimadamore
parents: 5320
diff changeset
  1106
compiler.misc.diamond.invalid.args=\
c8efe769cb3b 6939620: Switch to 'complex' diamond inference scheme
mcimadamore
parents: 5320
diff changeset
  1107
    type arguments {0} inferred for {1} are not allowed in this context
6710
b14e6fe7b290 5088624: cannot find symbol message should be more intelligent
mcimadamore
parents: 6592
diff changeset
  1108
b14e6fe7b290 5088624: cannot find symbol message should be more intelligent
mcimadamore
parents: 6592
diff changeset
  1109
compiler.misc.explicit.param.do.not.conform.to.bounds=\
b14e6fe7b290 5088624: cannot find symbol message should be more intelligent
mcimadamore
parents: 6592
diff changeset
  1110
    explicit type argument {0} does not conform to declared bound(s) {1}
b14e6fe7b290 5088624: cannot find symbol message should be more intelligent
mcimadamore
parents: 6592
diff changeset
  1111
b14e6fe7b290 5088624: cannot find symbol message should be more intelligent
mcimadamore
parents: 6592
diff changeset
  1112
compiler.misc.arg.length.mismatch=\
b14e6fe7b290 5088624: cannot find symbol message should be more intelligent
mcimadamore
parents: 6592
diff changeset
  1113
    actual and formal argument lists differ in length
b14e6fe7b290 5088624: cannot find symbol message should be more intelligent
mcimadamore
parents: 6592
diff changeset
  1114
compiler.misc.no.conforming.assignment.exists=\
b14e6fe7b290 5088624: cannot find symbol message should be more intelligent
mcimadamore
parents: 6592
diff changeset
  1115
    actual argument {0} cannot be converted to {1} by method invocation conversion
b14e6fe7b290 5088624: cannot find symbol message should be more intelligent
mcimadamore
parents: 6592
diff changeset
  1116
compiler.misc.varargs.argument.mismatch=\
b14e6fe7b290 5088624: cannot find symbol message should be more intelligent
mcimadamore
parents: 6592
diff changeset
  1117
    argument type {0} does not conform to vararg element type {1}
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1118
#####
06bc494ca11e Initial load
duke
parents:
diff changeset
  1119
06bc494ca11e Initial load
duke
parents:
diff changeset
  1120
## The first argument ({0}) is a "kindname".
06bc494ca11e Initial load
duke
parents:
diff changeset
  1121
compiler.err.abstract.cant.be.accessed.directly=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1122
    abstract {0} {1} in {2} cannot be accessed directly
06bc494ca11e Initial load
duke
parents:
diff changeset
  1123
06bc494ca11e Initial load
duke
parents:
diff changeset
  1124
## The first argument ({0}) is a "kindname".
06bc494ca11e Initial load
duke
parents:
diff changeset
  1125
compiler.err.non-static.cant.be.ref=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1126
    non-static {0} {1} cannot be referenced from a static context
06bc494ca11e Initial load
duke
parents:
diff changeset
  1127
06bc494ca11e Initial load
duke
parents:
diff changeset
  1128
## Both arguments ({0}, {1}) are "kindname"s.  {0} is a comma-separated list
06bc494ca11e Initial load
duke
parents:
diff changeset
  1129
## of kindnames (the list should be identical to that provided in source.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1130
compiler.err.unexpected.type=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1131
unexpected type\n\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1132
required: {0}\n\
2085
4792e12a8ca2 6769027: Source line should be displayed immediately after the first diagnostic line
mcimadamore
parents: 1996
diff changeset
  1133
found:    {1}
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1134
939
38e24969c7e9 6717241: some diagnostic argument is prematurely converted into a String object
mcimadamore
parents: 735
diff changeset
  1135
## The first argument {0} is a "kindname" (e.g. 'constructor', 'field', etc.)
38e24969c7e9 6717241: some diagnostic argument is prematurely converted into a String object
mcimadamore
parents: 735
diff changeset
  1136
## The second argument {1} is the non-resolved symbol
38e24969c7e9 6717241: some diagnostic argument is prematurely converted into a String object
mcimadamore
parents: 735
diff changeset
  1137
## The third argument {2} is a list of type parameters (non-empty if {1} is a method)
38e24969c7e9 6717241: some diagnostic argument is prematurely converted into a String object
mcimadamore
parents: 735
diff changeset
  1138
## The fourth argument {3} is a list of argument types (non-empty if {1} is a method)
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1139
compiler.err.cant.resolve=\
939
38e24969c7e9 6717241: some diagnostic argument is prematurely converted into a String object
mcimadamore
parents: 735
diff changeset
  1140
    cannot find symbol\n\
38e24969c7e9 6717241: some diagnostic argument is prematurely converted into a String object
mcimadamore
parents: 735
diff changeset
  1141
    symbol: {0} {1}
38e24969c7e9 6717241: some diagnostic argument is prematurely converted into a String object
mcimadamore
parents: 735
diff changeset
  1142
38e24969c7e9 6717241: some diagnostic argument is prematurely converted into a String object
mcimadamore
parents: 735
diff changeset
  1143
compiler.err.cant.resolve.args=\
38e24969c7e9 6717241: some diagnostic argument is prematurely converted into a String object
mcimadamore
parents: 735
diff changeset
  1144
    cannot find symbol\n\
38e24969c7e9 6717241: some diagnostic argument is prematurely converted into a String object
mcimadamore
parents: 735
diff changeset
  1145
    symbol: {0} {1}({3})
38e24969c7e9 6717241: some diagnostic argument is prematurely converted into a String object
mcimadamore
parents: 735
diff changeset
  1146
38e24969c7e9 6717241: some diagnostic argument is prematurely converted into a String object
mcimadamore
parents: 735
diff changeset
  1147
compiler.err.cant.resolve.args.params=\
38e24969c7e9 6717241: some diagnostic argument is prematurely converted into a String object
mcimadamore
parents: 735
diff changeset
  1148
    cannot find symbol\n\
38e24969c7e9 6717241: some diagnostic argument is prematurely converted into a String object
mcimadamore
parents: 735
diff changeset
  1149
    symbol: {0} <{2}>{1}({3})
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1150
939
38e24969c7e9 6717241: some diagnostic argument is prematurely converted into a String object
mcimadamore
parents: 735
diff changeset
  1151
## arguments from {0} to {3} have the same meaning as above
8045
df2ca0edfbaa 6968793: issues with diagnostics
mcimadamore
parents: 8038
diff changeset
  1152
## The fifth argument {4} is a location subdiagnostic (see below)
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1153
compiler.err.cant.resolve.location=\
939
38e24969c7e9 6717241: some diagnostic argument is prematurely converted into a String object
mcimadamore
parents: 735
diff changeset
  1154
    cannot find symbol\n\
2085
4792e12a8ca2 6769027: Source line should be displayed immediately after the first diagnostic line
mcimadamore
parents: 1996
diff changeset
  1155
    symbol:   {0} {1}\n\
8045
df2ca0edfbaa 6968793: issues with diagnostics
mcimadamore
parents: 8038
diff changeset
  1156
    location: {4}
939
38e24969c7e9 6717241: some diagnostic argument is prematurely converted into a String object
mcimadamore
parents: 735
diff changeset
  1157
38e24969c7e9 6717241: some diagnostic argument is prematurely converted into a String object
mcimadamore
parents: 735
diff changeset
  1158
compiler.err.cant.resolve.location.args=\
38e24969c7e9 6717241: some diagnostic argument is prematurely converted into a String object
mcimadamore
parents: 735
diff changeset
  1159
    cannot find symbol\n\
2085
4792e12a8ca2 6769027: Source line should be displayed immediately after the first diagnostic line
mcimadamore
parents: 1996
diff changeset
  1160
    symbol:   {0} {1}({3})\n\
8045
df2ca0edfbaa 6968793: issues with diagnostics
mcimadamore
parents: 8038
diff changeset
  1161
    location: {4}
939
38e24969c7e9 6717241: some diagnostic argument is prematurely converted into a String object
mcimadamore
parents: 735
diff changeset
  1162
38e24969c7e9 6717241: some diagnostic argument is prematurely converted into a String object
mcimadamore
parents: 735
diff changeset
  1163
compiler.err.cant.resolve.location.args.params=\
38e24969c7e9 6717241: some diagnostic argument is prematurely converted into a String object
mcimadamore
parents: 735
diff changeset
  1164
    cannot find symbol\n\
2085
4792e12a8ca2 6769027: Source line should be displayed immediately after the first diagnostic line
mcimadamore
parents: 1996
diff changeset
  1165
    symbol:   {0} <{2}>{1}({3})\n\
8045
df2ca0edfbaa 6968793: issues with diagnostics
mcimadamore
parents: 8038
diff changeset
  1166
    location: {4}
df2ca0edfbaa 6968793: issues with diagnostics
mcimadamore
parents: 8038
diff changeset
  1167
df2ca0edfbaa 6968793: issues with diagnostics
mcimadamore
parents: 8038
diff changeset
  1168
##a location subdiagnostic is composed as follows:
df2ca0edfbaa 6968793: issues with diagnostics
mcimadamore
parents: 8038
diff changeset
  1169
## The first argument {0} is the location "kindname" (e.g. 'constructor', 'field', etc.)
df2ca0edfbaa 6968793: issues with diagnostics
mcimadamore
parents: 8038
diff changeset
  1170
## The second argument {1} is the location name
df2ca0edfbaa 6968793: issues with diagnostics
mcimadamore
parents: 8038
diff changeset
  1171
## The third argument {2} is the location type (only when {1} is a variable name)
df2ca0edfbaa 6968793: issues with diagnostics
mcimadamore
parents: 8038
diff changeset
  1172
df2ca0edfbaa 6968793: issues with diagnostics
mcimadamore
parents: 8038
diff changeset
  1173
compiler.misc.location=\
df2ca0edfbaa 6968793: issues with diagnostics
mcimadamore
parents: 8038
diff changeset
  1174
    {0} {1}
df2ca0edfbaa 6968793: issues with diagnostics
mcimadamore
parents: 8038
diff changeset
  1175
compiler.misc.location.1=\
df2ca0edfbaa 6968793: issues with diagnostics
mcimadamore
parents: 8038
diff changeset
  1176
    {0} {1} of type {2}
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1177
06bc494ca11e Initial load
duke
parents:
diff changeset
  1178
## The following are all possible string for "kindname".
06bc494ca11e Initial load
duke
parents:
diff changeset
  1179
## They should be called whatever the JLS calls them after it been translated
06bc494ca11e Initial load
duke
parents:
diff changeset
  1180
## to the appropriate language.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1181
# compiler.misc.kindname.constructor=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1182
#     static member
06bc494ca11e Initial load
duke
parents:
diff changeset
  1183
compiler.misc.kindname.annotation=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1184
    @interface
06bc494ca11e Initial load
duke
parents:
diff changeset
  1185
compiler.misc.kindname.constructor=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1186
    constructor
6031
50004868a787 6964768: need test program to validate javac resource bundles
jjg
parents: 5848
diff changeset
  1187
compiler.misc.kindname.enum=\
50004868a787 6964768: need test program to validate javac resource bundles
jjg
parents: 5848
diff changeset
  1188
    enum
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1189
compiler.misc.kindname.interface=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1190
    interface
06bc494ca11e Initial load
duke
parents:
diff changeset
  1191
compiler.misc.kindname.static=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1192
    static
06bc494ca11e Initial load
duke
parents:
diff changeset
  1193
compiler.misc.kindname.type.variable=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1194
    type variable
06bc494ca11e Initial load
duke
parents:
diff changeset
  1195
compiler.misc.kindname.type.variable.bound=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1196
    bound of type variable
06bc494ca11e Initial load
duke
parents:
diff changeset
  1197
compiler.misc.kindname.variable=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1198
    variable
06bc494ca11e Initial load
duke
parents:
diff changeset
  1199
compiler.misc.kindname.value=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1200
    value
06bc494ca11e Initial load
duke
parents:
diff changeset
  1201
compiler.misc.kindname.method=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1202
    method
06bc494ca11e Initial load
duke
parents:
diff changeset
  1203
compiler.misc.kindname.class=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1204
    class
06bc494ca11e Initial load
duke
parents:
diff changeset
  1205
compiler.misc.kindname.package=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1206
    package
06bc494ca11e Initial load
duke
parents:
diff changeset
  1207
#####
06bc494ca11e Initial load
duke
parents:
diff changeset
  1208
1534
e923a41e84cc 6758789: Some method resolution diagnostic should be improved
mcimadamore
parents: 1358
diff changeset
  1209
compiler.misc.no.args=\
e923a41e84cc 6758789: Some method resolution diagnostic should be improved
mcimadamore
parents: 1358
diff changeset
  1210
    no arguments
e923a41e84cc 6758789: Some method resolution diagnostic should be improved
mcimadamore
parents: 1358
diff changeset
  1211
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1212
compiler.err.override.static=\
3560
bbfccbd92afe 6199153: Generic throws and overriding
mcimadamore
parents: 3557
diff changeset
  1213
    {0}\n\
bbfccbd92afe 6199153: Generic throws and overriding
mcimadamore
parents: 3557
diff changeset
  1214
    overriding method is static
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1215
compiler.err.override.meth=\
3560
bbfccbd92afe 6199153: Generic throws and overriding
mcimadamore
parents: 3557
diff changeset
  1216
    {0}\n\
bbfccbd92afe 6199153: Generic throws and overriding
mcimadamore
parents: 3557
diff changeset
  1217
    overridden method is {1}
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1218
06bc494ca11e Initial load
duke
parents:
diff changeset
  1219
compiler.err.override.meth.doesnt.throw=\
3560
bbfccbd92afe 6199153: Generic throws and overriding
mcimadamore
parents: 3557
diff changeset
  1220
    {0}\n\
bbfccbd92afe 6199153: Generic throws and overriding
mcimadamore
parents: 3557
diff changeset
  1221
    overridden method does not throw {1}
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1222
06bc494ca11e Initial load
duke
parents:
diff changeset
  1223
# In the following string {1} is a space separated list of Java Keywords, as
06bc494ca11e Initial load
duke
parents:
diff changeset
  1224
# they would have been declared in the source code
06bc494ca11e Initial load
duke
parents:
diff changeset
  1225
compiler.err.override.weaker.access=\
3560
bbfccbd92afe 6199153: Generic throws and overriding
mcimadamore
parents: 3557
diff changeset
  1226
    {0}\n\
bbfccbd92afe 6199153: Generic throws and overriding
mcimadamore
parents: 3557
diff changeset
  1227
    attempting to assign weaker access privileges; was {1}
bbfccbd92afe 6199153: Generic throws and overriding
mcimadamore
parents: 3557
diff changeset
  1228
bbfccbd92afe 6199153: Generic throws and overriding
mcimadamore
parents: 3557
diff changeset
  1229
compiler.err.override.incompatible.ret=\
bbfccbd92afe 6199153: Generic throws and overriding
mcimadamore
parents: 3557
diff changeset
  1230
    {0}\n\
bbfccbd92afe 6199153: Generic throws and overriding
mcimadamore
parents: 3557
diff changeset
  1231
    return type {1} is not compatible with {2}
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1232
3560
bbfccbd92afe 6199153: Generic throws and overriding
mcimadamore
parents: 3557
diff changeset
  1233
compiler.warn.override.unchecked.ret=\
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
  1234
    {0}\n\
3560
bbfccbd92afe 6199153: Generic throws and overriding
mcimadamore
parents: 3557
diff changeset
  1235
    return type requires unchecked conversion from {1} to {2}
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1236
3560
bbfccbd92afe 6199153: Generic throws and overriding
mcimadamore
parents: 3557
diff changeset
  1237
compiler.warn.override.unchecked.thrown=\
6151
dd513881e71d 6957438: improve code for generating warning messages containing option names
jjg
parents: 6148
diff changeset
  1238
    {0}\n\
3560
bbfccbd92afe 6199153: Generic throws and overriding
mcimadamore
parents: 3557
diff changeset
  1239
    overridden method does not throw {1}
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1240
06bc494ca11e Initial load
duke
parents:
diff changeset
  1241
## The following are all possible strings for the first argument ({0}) of the
06bc494ca11e Initial load
duke
parents:
diff changeset
  1242
## above strings.
06bc494ca11e Initial load
duke
parents:
diff changeset
  1243
compiler.misc.cant.override=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1244
    {0} in {1} cannot override {2} in {3}
06bc494ca11e Initial load
duke
parents:
diff changeset
  1245
compiler.misc.cant.implement=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1246
    {0} in {1} cannot implement {2} in {3}
06bc494ca11e Initial load
duke
parents:
diff changeset
  1247
compiler.misc.clashes.with=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1248
    {0} in {1} clashes with {2} in {3}
06bc494ca11e Initial load
duke
parents:
diff changeset
  1249
compiler.misc.unchecked.override=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1250
    {0} in {1} overrides {2} in {3}
06bc494ca11e Initial load
duke
parents:
diff changeset
  1251
compiler.misc.unchecked.implement=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1252
    {0} in {1} implements {2} in {3}
06bc494ca11e Initial load
duke
parents:
diff changeset
  1253
compiler.misc.unchecked.clash.with=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1254
    {0} in {1} overrides {2} in {3}
06bc494ca11e Initial load
duke
parents:
diff changeset
  1255
compiler.misc.varargs.override=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1256
    {0} in {1} overrides {2} in {3}
06bc494ca11e Initial load
duke
parents:
diff changeset
  1257
compiler.misc.varargs.implement=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1258
    {0} in {1} implements {2} in {3}
06bc494ca11e Initial load
duke
parents:
diff changeset
  1259
compiler.misc.varargs.clash.with=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1260
    {0} in {1} overrides {2} in {3}
5321
c8efe769cb3b 6939620: Switch to 'complex' diamond inference scheme
mcimadamore
parents: 5320
diff changeset
  1261
compiler.misc.non.denotable.type=\
c8efe769cb3b 6939620: Switch to 'complex' diamond inference scheme
mcimadamore
parents: 5320
diff changeset
  1262
    Non-denotable type {0} not allowed here
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1263
6710
b14e6fe7b290 5088624: cannot find symbol message should be more intelligent
mcimadamore
parents: 6592
diff changeset
  1264
compiler.misc.inapplicable.method=\
b14e6fe7b290 5088624: cannot find symbol message should be more intelligent
mcimadamore
parents: 6592
diff changeset
  1265
    {0} {1}.{2} is not applicable\n\
b14e6fe7b290 5088624: cannot find symbol message should be more intelligent
mcimadamore
parents: 6592
diff changeset
  1266
    ({3})
b14e6fe7b290 5088624: cannot find symbol message should be more intelligent
mcimadamore
parents: 6592
diff changeset
  1267
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1268
########################################
06bc494ca11e Initial load
duke
parents:
diff changeset
  1269
# Diagnostics for language feature changes
06bc494ca11e Initial load
duke
parents:
diff changeset
  1270
########################################
06bc494ca11e Initial load
duke
parents:
diff changeset
  1271
compiler.err.unsupported.fp.lit=\
3895
3b3c2a1e5e8a 6860965: Project Coin: binary literals
jjg
parents: 3765
diff changeset
  1272
    hexadecimal floating point literals are not supported in -source {0}\n\
3b3c2a1e5e8a 6860965: Project Coin: binary literals
jjg
parents: 3765
diff changeset
  1273
(use -source 5 or higher to enable hexadecimal floating point literals)
3b3c2a1e5e8a 6860965: Project Coin: binary literals
jjg
parents: 3765
diff changeset
  1274
3b3c2a1e5e8a 6860965: Project Coin: binary literals
jjg
parents: 3765
diff changeset
  1275
compiler.err.unsupported.binary.lit=\
3b3c2a1e5e8a 6860965: Project Coin: binary literals
jjg
parents: 3765
diff changeset
  1276
    binary literals are not supported in -source {0}\n\
3b3c2a1e5e8a 6860965: Project Coin: binary literals
jjg
parents: 3765
diff changeset
  1277
(use -source 7 or higher to enable binary literals)
3b3c2a1e5e8a 6860965: Project Coin: binary literals
jjg
parents: 3765
diff changeset
  1278
3b3c2a1e5e8a 6860965: Project Coin: binary literals
jjg
parents: 3765
diff changeset
  1279
compiler.err.unsupported.underscore.lit=\
3b3c2a1e5e8a 6860965: Project Coin: binary literals
jjg
parents: 3765
diff changeset
  1280
    underscores in literals are not supported in -source {0}\n\
3b3c2a1e5e8a 6860965: Project Coin: binary literals
jjg
parents: 3765
diff changeset
  1281
(use -source 7 or higher to enable underscores in literals)
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1282
7211
163fe60f63de 6970016: Clean up ARM/try-with-resources implementation
mcimadamore
parents: 7203
diff changeset
  1283
compiler.err.try.with.resources.not.supported.in.source=\
163fe60f63de 6970016: Clean up ARM/try-with-resources implementation
mcimadamore
parents: 7203
diff changeset
  1284
    try-with-resources is not supported in -source {0}\n\
163fe60f63de 6970016: Clean up ARM/try-with-resources implementation
mcimadamore
parents: 7203
diff changeset
  1285
(use -source 7 or higher to enable try-with-resources)
6148
3a8158299c51 6911256: Project Coin: Support Automatic Resource Management (ARM) blocks in the compiler
darcy
parents: 6145
diff changeset
  1286
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1287
compiler.warn.enum.as.identifier=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1288
    as of release 5, ''enum'' is a keyword, and may not be used as an identifier\n\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1289
(use -source 5 or higher to use ''enum'' as a keyword)
06bc494ca11e Initial load
duke
parents:
diff changeset
  1290
06bc494ca11e Initial load
duke
parents:
diff changeset
  1291
compiler.warn.assert.as.identifier=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1292
    as of release 1.4, ''assert'' is a keyword, and may not be used as an identifier\n\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1293
(use -source 1.4 or higher to use ''assert'' as a keyword)
06bc494ca11e Initial load
duke
parents:
diff changeset
  1294
06bc494ca11e Initial load
duke
parents:
diff changeset
  1295
compiler.err.enum.as.identifier=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1296
    as of release 5, ''enum'' is a keyword, and may not be used as an identifier\n\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1297
(use -source 1.4 or lower to use ''enum'' as an identifier)
06bc494ca11e Initial load
duke
parents:
diff changeset
  1298
06bc494ca11e Initial load
duke
parents:
diff changeset
  1299
compiler.err.assert.as.identifier=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1300
    as of release 1.4, ''assert'' is a keyword, and may not be used as an identifier\n\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1301
(use -source 1.3 or lower to use ''assert'' as an identifier)
06bc494ca11e Initial load
duke
parents:
diff changeset
  1302
06bc494ca11e Initial load
duke
parents:
diff changeset
  1303
compiler.err.generics.not.supported.in.source=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1304
    generics are not supported in -source {0}\n\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1305
(use -source 5 or higher to enable generics)
06bc494ca11e Initial load
duke
parents:
diff changeset
  1306
06bc494ca11e Initial load
duke
parents:
diff changeset
  1307
compiler.err.varargs.not.supported.in.source=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1308
    variable-arity methods are not supported in -source {0}\n\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1309
(use -source 5 or higher to enable variable-arity methods)
06bc494ca11e Initial load
duke
parents:
diff changeset
  1310
06bc494ca11e Initial load
duke
parents:
diff changeset
  1311
compiler.err.annotations.not.supported.in.source=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1312
    annotations are not supported in -source {0}\n\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1313
(use -source 5 or higher to enable annotations)
06bc494ca11e Initial load
duke
parents:
diff changeset
  1314
7072
4863847e93a5 6987760: remove 308 support from JDK7
jjg
parents: 6710
diff changeset
  1315
#308 compiler.err.type.annotations.not.supported.in.source=\
4863847e93a5 6987760: remove 308 support from JDK7
jjg
parents: 6710
diff changeset
  1316
#308     type annotations are not supported in -source {0}\n\
4863847e93a5 6987760: remove 308 support from JDK7
jjg
parents: 6710
diff changeset
  1317
#308 (use -source 7 or higher to enable type annotations)
3149
0cd06d598d6f 6843077: JSR 308: Annotations on types
jjg
parents: 3140
diff changeset
  1318
10
06bc494ca11e Initial load
duke
parents:
diff changeset
  1319
compiler.err.foreach.not.supported.in.source=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1320
    for-each loops are not supported in -source {0}\n\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1321
(use -source 5 or higher to enable for-each loops)
06bc494ca11e Initial load
duke
parents:
diff changeset
  1322
06bc494ca11e Initial load
duke
parents:
diff changeset
  1323
compiler.err.static.import.not.supported.in.source=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1324
    static import declarations are not supported in -source {0}\n\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1325
(use -source 5 or higher to enable static import declarations)
06bc494ca11e Initial load
duke
parents:
diff changeset
  1326
06bc494ca11e Initial load
duke
parents:
diff changeset
  1327
compiler.err.enums.not.supported.in.source=\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1328
    enums are not supported in -source {0}\n\
06bc494ca11e Initial load
duke
parents:
diff changeset
  1329
(use -source 5 or higher to enable enums)
2984
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1330
6031
50004868a787 6964768: need test program to validate javac resource bundles
jjg
parents: 5848
diff changeset
  1331
compiler.err.diamond.not.supported.in.source=\
50004868a787 6964768: need test program to validate javac resource bundles
jjg
parents: 5848
diff changeset
  1332
    diamond operator is not supported in -source {0}\n\
6145
e52c4da245c9 6968789: incorrect text in "diamond not supported" message
jjg
parents: 6031
diff changeset
  1333
(use -source 7 or higher to enable diamond operator)
6031
50004868a787 6964768: need test program to validate javac resource bundles
jjg
parents: 5848
diff changeset
  1334
5492
515e4b33b335 6943289: Project Coin: Improved Exception Handling for Java (aka 'multicatch')
mcimadamore
parents: 5321
diff changeset
  1335
compiler.err.multicatch.not.supported.in.source=\
515e4b33b335 6943289: Project Coin: Improved Exception Handling for Java (aka 'multicatch')
mcimadamore
parents: 5321
diff changeset
  1336
    multi-catch statement is not supported in -source {0}\n\
515e4b33b335 6943289: Project Coin: Improved Exception Handling for Java (aka 'multicatch')
mcimadamore
parents: 5321
diff changeset
  1337
(use -source 7 or higher to enable multi-catch statement)
515e4b33b335 6943289: Project Coin: Improved Exception Handling for Java (aka 'multicatch')
mcimadamore
parents: 5321
diff changeset
  1338
4142
bd950c8f4fb3 6827009: Project Coin: Strings in Switch
darcy
parents: 4072
diff changeset
  1339
compiler.err.string.switch.not.supported.in.source=\
bd950c8f4fb3 6827009: Project Coin: Strings in Switch
darcy
parents: 4072
diff changeset
  1340
    strings in switch are not supported in -source {0}\n\
bd950c8f4fb3 6827009: Project Coin: Strings in Switch
darcy
parents: 4072
diff changeset
  1341
(use -source 7 or higher to enable strings in switch)
bd950c8f4fb3 6827009: Project Coin: Strings in Switch
darcy
parents: 4072
diff changeset
  1342
2984
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1343
########################################
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1344
# Diagnostics for where clause implementation
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1345
# used by the RichDiagnosticFormatter.
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1346
########################################
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1347
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1348
compiler.misc.type.null=\
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1349
    <null>
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1350
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1351
# X#n (where n is an int id) is disambiguated tvar name
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1352
compiler.misc.type.var=\
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1353
    {0}#{1}
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1354
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1355
# CAP#n (where n is an int id) is an abbreviation for 'captured type'
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1356
compiler.misc.captured.type=\
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1357
    CAP#{0}
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1358
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1359
# <INT#n> (where n is an int id) is an abbreviation for 'intersection type'
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1360
compiler.misc.intersection.type=\
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1361
    INT#{0}
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1362
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1363
# where clause for captured type: contains upper ('extends {1}') and lower
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1364
# ('super {2}') bound along with the wildcard that generated this captured type ({3})
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1365
compiler.misc.where.captured=\
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1366
    {0} extends {1} super: {2} from capture of {3}
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1367
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1368
# compact where clause for captured type: contains upper ('extends {1}') along
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1369
# with the wildcard that generated this captured type ({3})
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1370
compiler.misc.where.captured.1=\
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1371
    {0} extends {1} from capture of {3}
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1372
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1373
# where clause for type variable: contains upper bound(s) ('extends {1}') along with
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1374
# the kindname ({2}) and location ({3}) in which the typevar has been declared
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1375
compiler.misc.where.typevar=\
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1376
    {0} extends {1} declared in {2} {3}
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1377
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1378
# compact where clause for type variable: contains the kindname ({2}) and location ({3})
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1379
# in which the typevar has been declared
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1380
compiler.misc.where.typevar.1=\
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1381
    {0} declared in {2} {3}
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1382
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1383
# where clause for type variable: contains all the upper bound(s) ('extends {1}')
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1384
# of this intersection type
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1385
compiler.misc.where.intersection=\
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1386
    {0} extends {1}
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1387
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1388
### Where clause headers ###
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1389
compiler.misc.where.description.captured=\
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1390
    where {0} is a fresh type-variable:
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1391
compiler.misc.where.description.typevar=\
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1392
    where {0} is a type-variable:
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1393
compiler.misc.where.description.intersection=\
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1394
    where {0} is an intersection type:
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1395
compiler.misc.where.description.captured.1=\
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1396
    where {0} are fresh type-variables:
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1397
compiler.misc.where.description.typevar.1=\
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1398
    where {0} are type-variables:
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1399
compiler.misc.where.description.intersection.1=\
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1400
    where {0} are intersection types:
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1401
e15ff3a34054 6722234: javac diagnostics need better integration with the type-system
mcimadamore
parents: 2723
diff changeset
  1402