1 # 2 # Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved. 3 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 # 5 # This code is free software; you can redistribute it and/or modify it 6 # under the terms of the GNU General Public License version 2 only, as 7 # published by the Free Software Foundation. Oracle designates this 8 # particular file as subject to the "Classpath" exception as provided 9 # by Oracle in the LICENSE file that accompanied this code. 10 # 11 # This code is distributed in the hope that it will be useful, but WITHOUT 12 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 # version 2 for more details (a copy is included in the LICENSE file that 15 # accompanied this code). 16 # 17 # You should have received a copy of the GNU General Public License version 18 # 2 along with this work; if not, write to the Free Software Foundation, 19 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 # 21 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 # or visit www.oracle.com if you need additional information or have any 23 # questions. 24 # 25 26 # Messages in this file which use "placeholders" for values (e.g. {0}, {1}) 27 # are preceded by a stylized comment describing the type of the corresponding 28 # values. 29 # The types currently in use are 30 # 31 # boolean true or false 32 # file name the name of an input file; e.g. MyFile.java 33 # message segment a sub-message; see compiler.misc.* 34 # modifier a Java modifier; e.g. public, private, protected 35 # name a name, typically a Java identifier 36 # number an integer 37 # option name the name of a command line option 38 # source version a source version number, such as 1.5, 1.6, 1.7 39 # string a general string 40 # symbol the name of a declared type 41 # symbol kind a description of the kind of a declaration; see compiler.misc.kindname.* 42 # token the name of a non-terminal in source code; see compiler.misc.token.* 43 # type a Java type; e.g. int, X, X<T> 44 # unused the value is not used in this message 45 # 46 # list of X a comma-separated list of items; e.g. list of type 47 # X or Y alternation; e.g. message segment or type 48 # set of X a comma-separated collection of items; e.g. set of modifier 49 # 50 # These may be composed: e.g. list of type or message segment 51 # 52 # These comments are verified by the jtreg test test/tools/javac/diags/MessageInfo, 53 # using info derived from the collected set of examples in test/tools/javac/diags/examples. 54 # MessageInfo can also be run as a standalone utility providing more facilities 55 # for manipulating this file. For more details, see MessageInfo.java. 56 57 ## 58 ## errors 59 ## 60 61 # 0: symbol 62 compiler.err.abstract.cant.be.instantiated=\ 63 {0} is abstract; cannot be instantiated 64 65 compiler.err.abstract.meth.cant.have.body=\ 66 abstract methods cannot have a body 67 68 compiler.err.already.annotated=\ 69 {0} {1} has already been annotated 70 71 # 0: symbol kind, 1: symbol, 2: symbol kind, 3: symbol 72 compiler.err.already.defined=\ 73 {0} {1} is already defined in {2} {3} 74 75 # 0: symbol kind, 1: symbol, 2: symbol kind, 3: symbol kind, 4: symbol 76 compiler.err.already.defined.in.clinit=\ 77 {0} {1} is already defined in {2} of {3} {4} 78 79 # 0: string 80 compiler.err.already.defined.single.import=\ 81 a type with simple name {0} is already defined in a single-type-import 82 83 # 0: string 84 compiler.err.already.defined.static.single.import=\ 85 a type with simple name {0} is already defined in a static single-type-import 86 87 compiler.err.already.defined.this.unit=\ 88 {0} is already defined in this compilation unit 89 90 # 0: type, 1: list of name 91 compiler.err.annotation.missing.default.value=\ 92 annotation @{0} is missing a default value for the element '{1}' 93 94 # 0: type, 1: list of name 95 compiler.err.annotation.missing.default.value.1=\ 96 annotation @{0} is missing default values for elements {1} 97 98 # 0: type 99 compiler.err.annotation.not.valid.for.type=\ 100 annotation not valid for an element of type {0} 101 102 compiler.err.annotation.type.not.applicable=\ 103 annotation type not applicable to this kind of declaration 104 105 compiler.err.annotation.value.must.be.annotation=\ 106 annotation value must be an annotation 107 108 compiler.err.annotation.value.must.be.class.literal=\ 109 annotation value must be a class literal 110 111 compiler.err.annotation.value.must.be.name.value=\ 112 annotation values must be of the form ''name=value'' 113 114 compiler.err.annotation.value.not.allowable.type=\ 115 annotation value not of an allowable type 116 117 compiler.err.anon.class.impl.intf.no.args=\ 118 anonymous class implements interface; cannot have arguments 119 120 compiler.err.anon.class.impl.intf.no.typeargs=\ 121 anonymous class implements interface; cannot have type arguments 122 123 compiler.err.anon.class.impl.intf.no.qual.for.new=\ 124 anonymous class implements interface; cannot have qualifier for new 125 126 # 0: symbol, 1: symbol, 2: symbol 127 compiler.err.array.and.varargs=\ 128 cannot declare both {0} and {1} in {2} 129 130 compiler.err.array.dimension.missing=\ 131 array dimension missing 132 133 # 0: type 134 compiler.err.array.req.but.found=\ 135 array required, but {0} found 136 137 compiler.err.attribute.value.must.be.constant=\ 138 element value must be a constant expression 139 140 # 0: statement type 141 compiler.err.bad.initializer=\ 142 bad initializer for {0} 143 144 compiler.err.break.outside.switch.loop=\ 145 break outside switch or loop 146 147 # 0: name 148 compiler.err.call.must.be.first.stmt.in.ctor=\ 149 call to {0} must be first statement in constructor 150 151 # 0: symbol kind, 1: name, 2: list of type or message segment, 3: list of type or message segment, 4: symbol kind, 5: type, 6: message segment 152 compiler.err.cant.apply.symbol=\ 153 {0} {1} in {4} {5} cannot be applied to given types;\n\ 154 required: {2}\n\ 155 found: {3}\n\ 156 reason: {6} 157 158 # 0: symbol kind, 1: name, 2: list of type 159 compiler.err.cant.apply.symbols=\ 160 no suitable {0} found for {1}({2}) 161 162 # 0: symbol kind, 1: name, 2: list of type or message segment, 3: list of type or message segment, 4: symbol kind, 5: type, 6: message segment 163 compiler.misc.cant.apply.symbol=\ 164 {0} {1} in {4} {5} cannot be applied to given types\n\ 165 required: {2}\n\ 166 found: {3}\n\ 167 reason: {6} 168 169 # 0: symbol kind, 1: name, 2: list of type 170 compiler.misc.cant.apply.symbols=\ 171 no suitable {0} found for {1}({2}) 172 173 # 0: symbol kind, 1: symbol 174 compiler.misc.no.abstracts=\ 175 no abstract method found in {0} {1} 176 177 # 0: symbol kind, 1: symbol 178 compiler.misc.incompatible.abstracts=\ 179 multiple non-overriding abstract methods found in {0} {1} 180 181 compiler.err.bad.functional.intf.anno=\ 182 Unexpected @FunctionalInterface annotation 183 184 # 0: message segment 185 compiler.err.bad.functional.intf.anno.1=\ 186 Unexpected @FunctionalInterface annotation\n\ 187 {0} 188 189 # 0: symbol 190 compiler.misc.not.a.functional.intf=\ 191 {0} is not a functional interface 192 193 # 0: symbol, 1: message segment 194 compiler.misc.not.a.functional.intf.1=\ 195 {0} is not a functional interface\n\ 196 {1} 197 198 # 0: symbol, 1: symbol kind, 2: symbol 199 compiler.misc.invalid.generic.lambda.target=\ 200 invalid functional descriptor for lambda expression\n\ 201 method {0} in {1} {2} is generic 202 203 # 0: symbol kind, 1: symbol 204 compiler.misc.incompatible.descs.in.functional.intf=\ 205 incompatible function descriptors found in {0} {1} 206 207 # 0: name, 1: list of type, 2: type, 3: list of type 208 compiler.misc.descriptor=\ 209 descriptor: {2} {0}({1}) 210 211 # 0: name, 1: list of type, 2: type, 3: list of type 212 compiler.misc.descriptor.throws=\ 213 descriptor: {2} {0}({1}) throws {3} 214 215 # 0: type 216 compiler.misc.no.suitable.functional.intf.inst=\ 217 cannot infer functional interface descriptor for {0} 218 219 # 0: message segment 220 compiler.misc.bad.intersection.target.for.functional.expr=\ 221 bad intersection type target for lambda or method reference\n\ 222 {0} 223 224 # 0: symbol or type 225 compiler.misc.not.an.intf.component=\ 226 component type {0} is not an interface 227 228 # 0: symbol kind, 1: message segment 229 compiler.err.invalid.mref=\ 230 invalid {0} reference\n\ 231 {1} 232 233 # 0: symbol kind, 1: message segment 234 compiler.misc.invalid.mref=\ 235 invalid {0} reference\n\ 236 {1} 237 238 compiler.misc.static.mref.with.targs=\ 239 parameterized qualifier on static method reference 240 241 compiler.misc.static.bound.mref=\ 242 static bound method reference 243 244 # 0: symbol 245 compiler.err.cant.assign.val.to.final.var=\ 246 cannot assign a value to final variable {0} 247 248 # 0: symbol, 1: message segment 249 compiler.err.cant.ref.non.effectively.final.var=\ 250 local variables referenced from {1} must be final or effectively final 251 252 253 compiler.misc.lambda=\ 254 a lambda expression 255 256 compiler.misc.inner.cls=\ 257 an inner class 258 259 # 0: type 260 compiler.err.cant.deref=\ 261 {0} cannot be dereferenced 262 263 compiler.err.cant.extend.intf.annotation=\ 264 ''extends'' not allowed for @interfaces 265 266 # 0: symbol 267 compiler.err.cant.inherit.from.final=\ 268 cannot inherit from final {0} 269 270 # 0: symbol 271 compiler.err.cant.ref.before.ctor.called=\ 272 cannot reference {0} before supertype constructor has been called 273 274 compiler.err.cant.select.static.class.from.param.type=\ 275 cannot select a static class from a parameterized type 276 277 # 0: symbol, 1: string, 2: string 278 compiler.err.cant.inherit.diff.arg=\ 279 {0} cannot be inherited with different arguments: <{1}> and <{2}> 280 281 compiler.err.catch.without.try=\ 282 ''catch'' without ''try'' 283 284 # 0: symbol kind, 1: symbol 285 compiler.err.clash.with.pkg.of.same.name=\ 286 {0} {1} clashes with package of same name 287 288 compiler.err.class.not.allowed=\ 289 class, interface or enum declaration not allowed here 290 291 compiler.err.const.expr.req=\ 292 constant expression required 293 294 compiler.err.cont.outside.loop=\ 295 continue outside of loop 296 297 # 0: symbol 298 compiler.err.cyclic.inheritance=\ 299 cyclic inheritance involving {0} 300 301 compiler.err.cyclic.annotation.element=\ 302 type of element '{0}' is cyclic 303 304 # 0: unused 305 compiler.err.call.to.super.not.allowed.in.enum.ctor=\ 306 call to super not allowed in enum constructor 307 308 # 0: type 309 compiler.err.no.superclass=\ 310 {0} has no superclass. 311 312 # 0: symbol, 1: type, 2: symbol, 3: type, 4: unused 313 compiler.err.concrete.inheritance.conflict=\ 314 methods {0} from {1} and {2} from {3} are inherited with the same signature 315 316 compiler.err.default.allowed.in.intf.annotation.member=\ 317 default value only allowed in an annotation type declaration 318 319 # 0: symbol 320 compiler.err.doesnt.exist=\ 321 package {0} does not exist 322 323 compiler.err.duplicate.annotation=\ 324 duplicate annotation 325 326 # 0: type 327 compiler.err.duplicate.annotation.invalid.repeated=\ 328 annotation {0} cannot be repeated\nIt does not define a valid containing annotation 329 330 # 0: name, 1: type 331 compiler.err.annotation.duplicate.element=\ 332 duplicate element '{0}' in annotation @{1}. 333 334 # 0: type, 1: type 335 compiler.err.duplicate.annotation.missing.containing.type=\ 336 {0} is not a Repeatable annotation type 337 338 # 0: type 339 compiler.err.invalid.repeatable.annotation=\ 340 duplicate annotation: {0} is annotated with an invalid Repeatable annotation 341 342 # 0: symbol or type 343 compiler.err.invalid.repeatable.annotation.no.value=\ 344 {0} is not a valid Repeatable, no value element method declared 345 346 # 0: type, 1: number 347 compiler.err.invalid.repeatable.annotation.multiple.values=\ 348 {0} is not a valid Repeatable, {1} value element methods declared 349 350 # 0: type 351 compiler.err.invalid.repeatable.annotation.invalid.value=\ 352 {0} is not a valid Repeatable: invalid value element 353 354 # 0: symbol type, 1: type, 2: type 355 compiler.err.invalid.repeatable.annotation.value.return=\ 356 containing annotation type ({0}) must declare a 'value' element of type {2} 357 358 # 0: symbol or type, 1: symbol 359 compiler.err.invalid.repeatable.annotation.elem.nondefault=\ 360 containing annotation type ({0}) does not have a default value for element {1} 361 362 # 0: symbol, 1: type, 2: symbol, 3: type 363 compiler.err.invalid.repeatable.annotation.retention=\ 364 retention of containing annotation type ({0}) is shorter retention than the retention of repeatable annotation type ({2}) 365 366 # 0: symbol, 1: symbol 367 compiler.err.invalid.repeatable.annotation.not.documented=\ 368 repeatable annotation type ({1}) is @Documented while containing annotation type ({0}) is not 369 370 # 0: symbol, 1: symbol 371 compiler.err.invalid.repeatable.annotation.not.inherited=\ 372 repeatable annotation type ({1}) is @Inherited while containing annotation type ({0}) is not 373 374 # 0: symbol, 1: symbol 375 compiler.err.invalid.repeatable.annotation.incompatible.target=\ 376 containing annotation type ({0}) is applicable to more targets than repeatable annotation type ({1}) 377 378 # 0: symbol 379 compiler.err.invalid.repeatable.annotation.repeated.and.container.present=\ 380 container {0} must not be present at the same time as the element it contains 381 382 # 0: name 383 compiler.err.duplicate.class=\ 384 duplicate class: {0} 385 386 compiler.err.duplicate.case.label=\ 387 duplicate case label 388 389 compiler.err.duplicate.default.label=\ 390 duplicate default label 391 392 compiler.err.else.without.if=\ 393 ''else'' without ''if'' 394 395 compiler.err.empty.char.lit=\ 396 empty character literal 397 398 # 0: symbol 399 compiler.err.encl.class.required=\ 400 an enclosing instance that contains {0} is required 401 402 compiler.err.enum.annotation.must.be.enum.constant=\ 403 an enum annotation value must be an enum constant 404 405 compiler.err.enum.cant.be.instantiated=\ 406 enum types may not be instantiated 407 408 compiler.err.enum.label.must.be.unqualified.enum=\ 409 an enum switch case label must be the unqualified name of an enumeration constant 410 411 compiler.err.enum.no.subclassing=\ 412 classes cannot directly extend java.lang.Enum 413 414 compiler.err.enum.types.not.extensible=\ 415 enum types are not extensible 416 417 compiler.err.enum.no.finalize=\ 418 enums cannot have finalize methods 419 420 # 0: file name, 1: string 421 compiler.err.error.reading.file=\ 422 error reading {0}; {1} 423 424 # 0: type 425 compiler.err.except.already.caught=\ 426 exception {0} has already been caught 427 428 # 0: type 429 compiler.err.except.never.thrown.in.try=\ 430 exception {0} is never thrown in body of corresponding try statement 431 432 # 0: symbol 433 compiler.err.final.parameter.may.not.be.assigned=\ 434 final parameter {0} may not be assigned 435 436 # 0: symbol 437 compiler.err.try.resource.may.not.be.assigned=\ 438 auto-closeable resource {0} may not be assigned 439 440 # 0: symbol 441 compiler.err.multicatch.parameter.may.not.be.assigned=\ 442 multi-catch parameter {0} may not be assigned 443 444 # 0: type, 1: type 445 compiler.err.multicatch.types.must.be.disjoint=\ 446 Alternatives in a multi-catch statement cannot be related by subclassing\n\ 447 Alternative {0} is a subclass of alternative {1} 448 449 compiler.err.finally.without.try=\ 450 ''finally'' without ''try'' 451 452 # 0: type, 1: message segment 453 compiler.err.foreach.not.applicable.to.type=\ 454 for-each not applicable to expression type\n\ 455 required: {1}\n\ 456 found: {0} 457 458 compiler.err.fp.number.too.large=\ 459 floating point number too large 460 461 compiler.err.fp.number.too.small=\ 462 floating point number too small 463 464 compiler.err.generic.array.creation=\ 465 generic array creation 466 467 compiler.err.generic.throwable=\ 468 a generic class may not extend java.lang.Throwable 469 470 # 0: symbol 471 compiler.err.icls.cant.have.static.decl=\ 472 Illegal static declaration in inner class {0}\n\ 473 modifier \''static\'' is only allowed in constant variable declarations 474 475 # 0: string 476 compiler.err.illegal.char=\ 477 illegal character: ''{0}'' 478 479 compiler.err.illegal.char.for.encoding=\ 480 unmappable character for encoding {0} 481 482 # 0: set of modifier, 1: set of modifier 483 compiler.err.illegal.combination.of.modifiers=\ 484 illegal combination of modifiers: {0} and {1} 485 486 compiler.err.illegal.enum.static.ref=\ 487 illegal reference to static field from initializer 488 489 compiler.err.illegal.esc.char=\ 490 illegal escape character 491 492 compiler.err.illegal.forward.ref=\ 493 illegal forward reference 494 495 # 0: symbol, 1: string 496 compiler.err.not.in.profile=\ 497 {0} is not available in profile ''{1}'' 498 499 # 0: symbol 500 compiler.warn.forward.ref=\ 501 reference to variable ''{0}'' before it has been initialized 502 503 compiler.err.illegal.self.ref=\ 504 self-reference in initializer 505 506 # 0: symbol 507 compiler.warn.self.ref=\ 508 self-reference in initializer of variable ''{0}'' 509 510 compiler.err.illegal.generic.type.for.instof=\ 511 illegal generic type for instanceof 512 513 # 0: type 514 compiler.err.illegal.initializer.for.type=\ 515 illegal initializer for {0} 516 517 compiler.err.illegal.line.end.in.char.lit=\ 518 illegal line end in character literal 519 520 compiler.err.illegal.nonascii.digit=\ 521 illegal non-ASCII digit 522 523 compiler.err.illegal.underscore=\ 524 illegal underscore 525 526 compiler.err.illegal.dot=\ 527 illegal ''.'' 528 529 # 0: symbol 530 compiler.err.illegal.qual.not.icls=\ 531 illegal qualifier; {0} is not an inner class 532 533 compiler.err.illegal.start.of.expr=\ 534 illegal start of expression 535 536 compiler.err.illegal.start.of.stmt=\ 537 illegal start of statement 538 539 compiler.err.illegal.start.of.type=\ 540 illegal start of type 541 542 compiler.err.illegal.unicode.esc=\ 543 illegal unicode escape 544 545 # 0: symbol 546 compiler.err.import.requires.canonical=\ 547 import requires canonical name for {0} 548 549 compiler.err.improperly.formed.type.param.missing=\ 550 improperly formed type, some parameters are missing 551 552 compiler.err.improperly.formed.type.inner.raw.param=\ 553 improperly formed type, type arguments given on a raw type 554 555 # 0: type, 1: type 556 compiler.err.incomparable.types=\ 557 incomparable types: {0} and {1} 558 559 # 0: number 560 compiler.err.int.number.too.large=\ 561 integer number too large: {0} 562 563 compiler.err.intf.annotation.members.cant.have.params=\ 564 elements in annotation type declarations cannot declare formal parameters 565 566 compiler.err.intf.annotation.cant.have.type.params=\ 567 annotation type {0} cannot be generic 568 569 compiler.err.intf.annotation.members.cant.have.type.params=\ 570 elements in annotation type declarations cannot be generic methods 571 572 # 0: symbol, 1: type 573 compiler.err.intf.annotation.member.clash=\ 574 annotation type {1} declares an element with the same name as method {0} 575 576 compiler.err.intf.expected.here=\ 577 interface expected here 578 579 compiler.err.intf.or.array.expected.here=\ 580 interface or array type expected here 581 582 compiler.err.intf.meth.cant.have.body=\ 583 interface abstract methods cannot have body 584 585 compiler.err.annotation.invalid.element.type=\ 586 invalid type for element {0} of annotation type 587 588 compiler.err.invalid.binary.number=\ 589 binary numbers must contain at least one binary digit 590 591 compiler.err.invalid.hex.number=\ 592 hexadecimal numbers must contain at least one hexadecimal digit 593 594 compiler.err.invalid.meth.decl.ret.type.req=\ 595 invalid method declaration; return type required 596 597 compiler.err.varargs.and.old.array.syntax=\ 598 legacy array notation not allowed on variable-arity parameter 599 600 compiler.err.varargs.and.receiver =\ 601 varargs notation not allowed on receiver parameter 602 603 compiler.err.array.and.receiver =\ 604 legacy array notation not allowed on receiver parameter 605 606 compiler.err.variable.not.allowed=\ 607 variable declaration not allowed here 608 609 # 0: name 610 compiler.err.label.already.in.use=\ 611 label {0} already in use 612 613 # 0: symbol 614 compiler.err.local.var.accessed.from.icls.needs.final=\ 615 local variable {0} is accessed from within inner class; needs to be declared final 616 617 compiler.err.local.enum=\ 618 enum types must not be local 619 620 compiler.err.cannot.create.array.with.type.arguments=\ 621 cannot create array with type arguments 622 623 compiler.err.cannot.create.array.with.diamond=\ 624 cannot create array with ''<>'' 625 626 # 627 # limits. We don't give the limits in the diagnostic because we expect 628 # them to change, yet we want to use the same diagnostic. These are all 629 # detected during code generation. 630 # 631 compiler.err.limit.code=\ 632 code too large 633 634 compiler.err.limit.code.too.large.for.try.stmt=\ 635 code too large for try statement 636 637 compiler.err.limit.dimensions=\ 638 array type has too many dimensions 639 640 compiler.err.limit.locals=\ 641 too many local variables 642 643 compiler.err.limit.parameters=\ 644 too many parameters 645 646 compiler.err.limit.pool=\ 647 too many constants 648 649 compiler.err.limit.pool.in.class=\ 650 too many constants in class {0} 651 652 compiler.err.limit.stack=\ 653 code requires too much stack 654 655 compiler.err.limit.string=\ 656 constant string too long 657 658 compiler.err.limit.string.overflow=\ 659 UTF8 representation for string \"{0}...\" is too long for the constant pool 660 661 compiler.err.malformed.fp.lit=\ 662 malformed floating point literal 663 664 compiler.err.method.does.not.override.superclass=\ 665 method does not override or implement a method from a supertype 666 667 compiler.err.missing.meth.body.or.decl.abstract=\ 668 missing method body, or declare abstract 669 670 compiler.err.missing.ret.stmt=\ 671 missing return statement 672 673 # 0: unused 674 compiler.misc.missing.ret.val=\ 675 missing return value 676 677 compiler.misc.unexpected.ret.val=\ 678 unexpected return value 679 680 # 0: set of modifier 681 compiler.err.mod.not.allowed.here=\ 682 modifier {0} not allowed here 683 684 compiler.err.intf.not.allowed.here=\ 685 interface not allowed here 686 687 compiler.err.enums.must.be.static=\ 688 enum declarations allowed only in static contexts 689 690 # 0: symbol, 1: symbol 691 compiler.err.name.clash.same.erasure=\ 692 name clash: {0} and {1} have the same erasure 693 694 # 0: symbol, 1: symbol, 2: symbol, 3: symbol, 4: unused, 5: unused 695 compiler.err.name.clash.same.erasure.no.override=\ 696 name clash: {0} in {1} and {2} in {3} have the same erasure, yet neither overrides the other 697 698 # 0: symbol, 1: symbol, 2: symbol, 3: symbol, 4: symbol, 5: symbol 699 compiler.err.name.clash.same.erasure.no.override.1=\ 700 name clash: {0} in {1} overrides a method whose erasure is the same as another method, yet neither overrides the other\n\ 701 first method: {2} in {3}\n\ 702 second method: {4} in {5} 703 704 # 0: symbol, 1: symbol, 2: symbol, 3: symbol 705 compiler.err.name.clash.same.erasure.no.hide=\ 706 name clash: {0} in {1} and {2} in {3} have the same erasure, yet neither hides the other 707 708 compiler.err.name.reserved.for.internal.use=\ 709 {0} is reserved for internal use 710 711 compiler.err.native.meth.cant.have.body=\ 712 native methods cannot have a body 713 714 # 0: type, 1: type 715 compiler.err.neither.conditional.subtype=\ 716 incompatible types for ?: neither is a subtype of the other\n\ 717 second operand: {0}\n\ 718 third operand : {1} 719 720 # 0: message segment 721 compiler.misc.incompatible.type.in.conditional=\ 722 bad type in conditional expression\n\ 723 {0} 724 725 compiler.misc.conditional.target.cant.be.void=\ 726 target-type for conditional expression cannot be void 727 728 # 0: type 729 compiler.misc.incompatible.ret.type.in.lambda=\ 730 bad return type in lambda expression\n\ 731 {0} 732 733 # 0: type 734 compiler.misc.incompatible.ret.type.in.mref=\ 735 bad return type in method reference\n\ 736 {0} 737 738 # 0: list of type 739 compiler.err.incompatible.thrown.types.in.mref=\ 740 incompatible thrown types {0} in method reference 741 742 compiler.misc.incompatible.arg.types.in.lambda=\ 743 incompatible parameter types in lambda expression 744 745 compiler.misc.incompatible.arg.types.in.mref=\ 746 incompatible parameter types in method reference 747 748 compiler.err.new.not.allowed.in.annotation=\ 749 ''new'' not allowed in an annotation 750 751 compiler.err.no.annotation.member=\ 752 no annotation member {0} in {1} 753 754 compiler.err.no.encl.instance.of.type.in.scope=\ 755 no enclosing instance of type {0} is in scope 756 757 compiler.err.no.intf.expected.here=\ 758 no interface expected here 759 760 compiler.err.no.match.entry=\ 761 {0} has no match in entry in {1}; required {2} 762 763 compiler.err.not.annotation.type=\ 764 {0} is not an annotation type 765 766 # 0: symbol, 1: symbol 767 compiler.err.not.def.access.class.intf.cant.access=\ 768 {0} in {1} is defined in an inaccessible class or interface 769 770 # 0: symbol, 1: symbol 771 compiler.misc.not.def.access.class.intf.cant.access=\ 772 {0} in {1} is defined in an inaccessible class or interface 773 774 # 0: symbol, 1: list of type, 2: type 775 compiler.misc.cant.access.inner.cls.constr=\ 776 cannot access constructor {0}({1})\n\ 777 an enclosing instance of type {2} is not in scope 778 779 # 0: symbol, 1: symbol 780 compiler.err.not.def.public.cant.access=\ 781 {0} is not public in {1}; cannot be accessed from outside package 782 783 # 0: symbol, 1: symbol 784 compiler.misc.not.def.public.cant.access=\ 785 {0} is not public in {1}; cannot be accessed from outside package 786 787 # 0: name 788 compiler.err.not.loop.label=\ 789 not a loop label: {0} 790 791 compiler.err.not.stmt=\ 792 not a statement 793 794 # 0: symbol 795 compiler.err.not.encl.class=\ 796 not an enclosing class: {0} 797 798 # 0: name, 1: type, 2: unused 799 compiler.err.operator.cant.be.applied=\ 800 bad operand type {1} for unary operator ''{0}'' 801 802 # 0: name, 1: type, 2: type 803 compiler.err.operator.cant.be.applied.1=\ 804 bad operand types for binary operator ''{0}''\n\ 805 first type: {1}\n\ 806 second type: {2} 807 808 compiler.err.pkg.annotations.sb.in.package-info.java=\ 809 package annotations should be in file package-info.java 810 811 # 0: symbol 812 compiler.err.pkg.clashes.with.class.of.same.name=\ 813 package {0} clashes with class of same name 814 815 compiler.err.warnings.and.werror=\ 816 warnings found and -Werror specified 817 818 # Errors related to annotation processing 819 820 # 0: symbol, 1: string, 2: stack-trace 821 compiler.err.proc.cant.access=\ 822 cannot access {0}\n\ 823 {1}\n\ 824 Consult the following stack trace for details.\n\ 825 {2} 826 827 # 0: symbol, 1: string 828 compiler.err.proc.cant.access.1=\ 829 cannot access {0}\n\ 830 {1} 831 832 # 0: string 833 compiler.err.proc.cant.find.class=\ 834 Could not find class file for ''{0}''. 835 836 # Print a client-generated error message; assumed to be localized, no translation required 837 # 0: string 838 compiler.err.proc.messager=\ 839 {0} 840 841 # 0: list of string 842 compiler.err.proc.no.explicit.annotation.processing.requested=\ 843 Class names, ''{0}'', are only accepted if annotation processing is explicitly requested 844 845 compiler.err.proc.no.service=\ 846 A ServiceLoader was not usable and is required for annotation processing. 847 848 compiler.err.proc.processor.bad.option.name=\ 849 Bad option name ''{0}'' provided by processor ''{1}'' 850 851 # 0: string 852 compiler.err.proc.processor.cant.instantiate=\ 853 Could not instantiate an instance of processor ''{0}'' 854 855 # 0: string 856 compiler.err.proc.processor.not.found=\ 857 Annotation processor ''{0}'' not found 858 859 # 0: string 860 compiler.err.proc.processor.wrong.type=\ 861 Annotation processor ''{0}'' does not implement javax.annotation.processing.Processor 862 863 compiler.err.proc.service.problem=\ 864 Error creating a service loader to load Processors. 865 866 compiler.err.proc.bad.config.file=\ 867 Bad service configuration file, or exception thrown while constructing Processor object: {0} 868 869 compiler.err.proc.cant.create.loader=\ 870 Could not create class loader for annotation processors: {0} 871 872 # 0: unused 873 compiler.err.qualified.new.of.static.class=\ 874 qualified new of static class 875 876 compiler.err.recursive.ctor.invocation=\ 877 recursive constructor invocation 878 879 # 0: name, 1: symbol kind, 2: symbol, 3: symbol, 4: symbol kind, 5: symbol, 6: symbol 880 compiler.err.ref.ambiguous=\ 881 reference to {0} is ambiguous\n\ 882 both {1} {2} in {3} and {4} {5} in {6} match 883 884 # 0: name, 1: symbol kind, 2: symbol, 3: symbol, 4: symbol kind, 5: symbol, 6: symbol 885 compiler.misc.ref.ambiguous=\ 886 reference to {0} is ambiguous\n\ 887 both {1} {2} in {3} and {4} {5} in {6} match 888 889 compiler.err.repeated.annotation.target=\ 890 repeated annotation target 891 892 compiler.err.repeated.interface=\ 893 repeated interface 894 895 compiler.err.repeated.modifier=\ 896 repeated modifier 897 898 # 0: symbol, 1: set of modifier, 2: symbol 899 compiler.err.report.access=\ 900 {0} has {1} access in {2} 901 902 # 0: symbol, 1: set of modifier, 2: symbol 903 compiler.misc.report.access=\ 904 {0} has {1} access in {2} 905 906 compiler.err.ret.outside.meth=\ 907 return outside method 908 909 compiler.err.signature.doesnt.match.supertype=\ 910 signature does not match {0}; incompatible supertype 911 912 compiler.err.signature.doesnt.match.intf=\ 913 signature does not match {0}; incompatible interfaces 914 915 # 0: number, 1: number 916 compiler.err.method.invoked.with.incorrect.number.arguments=\ 917 method invoked with incorrect number of arguments; expected {0}, found {1} 918 919 # 0: symbol, 1: symbol, 2: symbol 920 compiler.err.does.not.override.abstract=\ 921 {0} is not abstract and does not override abstract method {1} in {2} 922 923 compiler.err.source.cant.overwrite.input.file=\ 924 error writing source; cannot overwrite input file {0} 925 926 compiler.err.stack.sim.error=\ 927 Internal error: stack sim error on {0} 928 929 compiler.err.static.imp.only.classes.and.interfaces=\ 930 static import only from classes and interfaces 931 932 compiler.err.string.const.req=\ 933 constant string expression required 934 935 # 0: symbol, 1: symbol 936 compiler.err.synthetic.name.conflict=\ 937 the symbol {0} conflicts with a compiler-synthesized symbol in {1} 938 939 # 0: symbol, 1: symbol 940 compiler.warn.synthetic.name.conflict=\ 941 the symbol {0} conflicts with a compiler-synthesized symbol in {1} 942 943 compiler.err.throws.not.allowed.in.intf.annotation=\ 944 throws clause not allowed in @interface members 945 946 compiler.err.try.without.catch.or.finally=\ 947 ''try'' without ''catch'' or ''finally'' 948 949 compiler.err.try.without.catch.finally.or.resource.decls=\ 950 ''try'' without ''catch'', ''finally'' or resource declarations 951 952 # 0: symbol 953 compiler.err.type.doesnt.take.params=\ 954 type {0} does not take parameters 955 956 compiler.err.type.var.cant.be.deref=\ 957 cannot select from a type variable 958 959 compiler.err.type.var.may.not.be.followed.by.other.bounds=\ 960 a type variable may not be followed by other bounds 961 962 compiler.err.type.var.more.than.once=\ 963 type variable {0} occurs more than once in result type of {1}; cannot be left uninstantiated 964 965 compiler.err.type.var.more.than.once.in.result=\ 966 type variable {0} occurs more than once in type of {1}; cannot be left uninstantiated 967 968 # 0: type, 1: type, 2: string 969 compiler.err.types.incompatible.diff.ret=\ 970 types {0} and {1} are incompatible; both define {2}, but with unrelated return types 971 972 # 0: kind, 1: type, 2: name, 3: list of type, 4: symbol, 5: symbol 973 compiler.err.types.incompatible.unrelated.defaults=\ 974 {0} {1} inherits unrelated defaults for {2}({3}) from types {4} and {5} 975 976 # 0: kind, 1: type, 2: name, 3: list of type, 4: symbol, 5: symbol 977 compiler.err.types.incompatible.abstract.default=\ 978 {0} {1} inherits abstract and default for {2}({3}) from types {4} and {5} 979 980 # 0: name, 1: kind, 2: symbol 981 compiler.err.default.overrides.object.member=\ 982 default method {0} in {1} {2} overrides a member of java.lang.Object 983 984 # 0: type 985 compiler.err.illegal.static.intf.meth.call=\ 986 illegal static interface method call\n\ 987 the receiver expression should be replaced with the type qualifier ''{0}'' 988 989 # 0: type, 1: message segment 990 compiler.err.illegal.default.super.call=\ 991 bad type qualifier {0} in default super call\n\ 992 {1} 993 994 # 0: symbol, 1: type 995 compiler.misc.overridden.default=\ 996 method {0} is overridden in {1} 997 998 # 0: symbol, 1: type or symbol 999 compiler.misc.redundant.supertype=\ 1000 redundant interface {0} is extended by {1} 1001 1002 compiler.err.unclosed.char.lit=\ 1003 unclosed character literal 1004 1005 compiler.err.unclosed.comment=\ 1006 unclosed comment 1007 1008 compiler.err.unclosed.str.lit=\ 1009 unclosed string literal 1010 1011 # 0: name 1012 compiler.err.unsupported.encoding=\ 1013 unsupported encoding: {0} 1014 1015 compiler.err.io.exception=\ 1016 error reading source file: {0} 1017 1018 # 0: name 1019 compiler.err.undef.label=\ 1020 undefined label: {0} 1021 1022 # 0: message segment, 1: unused 1023 compiler.err.cant.apply.diamond=\ 1024 cannot infer type arguments for {0} 1025 1026 # 0: message segment or type, 1: message segment 1027 compiler.err.cant.apply.diamond.1=\ 1028 cannot infer type arguments for {0}\n\ 1029 reason: {1} 1030 1031 # 0: message segment or type, 1: message segment 1032 compiler.misc.cant.apply.diamond.1=\ 1033 cannot infer type arguments for {0}\n\ 1034 reason: {1} 1035 1036 compiler.err.unreachable.stmt=\ 1037 unreachable statement 1038 1039 compiler.err.initializer.must.be.able.to.complete.normally=\ 1040 initializer must be able to complete normally 1041 1042 # 0: type 1043 compiler.err.unreported.exception.need.to.catch.or.throw=\ 1044 unreported exception {0}; must be caught or declared to be thrown 1045 1046 # 0: type 1047 compiler.err.unreported.exception.default.constructor=\ 1048 unreported exception {0} in default constructor 1049 1050 # 0: type, 1: name 1051 compiler.err.unreported.exception.implicit.close=\ 1052 unreported exception {0}; must be caught or declared to be thrown\n\ 1053 exception thrown from implicit call to close() on resource variable ''{1}'' 1054 1055 compiler.err.unsupported.cross.fp.lit=\ 1056 hexadecimal floating-point literals are not supported on this VM 1057 1058 compiler.err.void.not.allowed.here=\ 1059 ''void'' type not allowed here 1060 1061 # 0: string 1062 compiler.err.wrong.number.type.args=\ 1063 wrong number of type arguments; required {0} 1064 1065 # 0: symbol 1066 compiler.err.var.might.already.be.assigned=\ 1067 variable {0} might already have been assigned 1068 1069 # 0: symbol 1070 compiler.err.var.might.not.have.been.initialized=\ 1071 variable {0} might not have been initialized 1072 1073 # 0: symbol 1074 compiler.err.var.not.initialized.in.default.constructor=\ 1075 variable {0} not initialized in the default constructor 1076 1077 # 0: symbol 1078 compiler.err.var.might.be.assigned.in.loop=\ 1079 variable {0} might be assigned in loop 1080 1081 # 0: symbol, 1: message segment 1082 compiler.err.varargs.invalid.trustme.anno=\ 1083 Invalid {0} annotation. {1} 1084 1085 # 0: type 1086 compiler.misc.varargs.trustme.on.reifiable.varargs=\ 1087 Varargs element type {0} is reifiable. 1088 1089 # 0: symbol 1090 compiler.misc.varargs.trustme.on.non.varargs.meth=\ 1091 Method {0} is not a varargs method. 1092 1093 # 0: symbol 1094 compiler.misc.varargs.trustme.on.virtual.varargs=\ 1095 Instance method {0} is not final. 1096 1097 # 0: type, 1: symbol kind, 2: symbol 1098 compiler.misc.inaccessible.varargs.type=\ 1099 formal varargs element type {0} is not accessible from {1} {2} 1100 1101 # In the following string, {1} will always be the detail message from 1102 # java.io.IOException. 1103 # 0: symbol, 1: string 1104 compiler.err.class.cant.write=\ 1105 error while writing {0}: {1} 1106 1107 # In the following string, {0} is the name of the class in the Java source. 1108 # It really should be used two times.. 1109 # 0: name 1110 compiler.err.class.public.should.be.in.file=\ 1111 class {0} is public, should be declared in a file named {0}.java 1112 1113 ## All errors which do not refer to a particular line in the source code are 1114 ## preceded by this string. 1115 compiler.err.error=\ 1116 error:\u0020 1117 1118 # The following error messages do not refer to a line in the source code. 1119 compiler.err.cant.read.file=\ 1120 cannot read: {0} 1121 1122 ##### 1123 1124 # Fatal Errors 1125 1126 compiler.misc.fatal.err.no.java.lang=\ 1127 Fatal Error: Unable to find package java.lang in classpath or bootclasspath 1128 1129 compiler.misc.fatal.err.cant.locate.meth=\ 1130 Fatal Error: Unable to find method {0} 1131 1132 compiler.misc.fatal.err.cant.locate.field=\ 1133 Fatal Error: Unable to find field {0} 1134 1135 compiler.misc.fatal.err.cant.locate.ctor=\ 1136 Fatal Error: Unable to find constructor for {0} 1137 1138 compiler.misc.fatal.err.cant.close=\ 1139 Fatal Error: Cannot close compiler resources 1140 1141 ##### 1142 1143 ## 1144 ## miscellaneous strings 1145 ## 1146 1147 compiler.misc.source.unavailable=\ 1148 (source unavailable) 1149 1150 compiler.misc.base.membership=\ 1151 all your base class are belong to us 1152 1153 # 0: string, 1: string, 2: boolean 1154 compiler.misc.x.print.processor.info=\ 1155 Processor {0} matches {1} and returns {2}. 1156 1157 # 0: number, 1: string, 2: set of symbol, 3: boolean 1158 compiler.misc.x.print.rounds=\ 1159 Round {0}:\n\tinput files: {1}\n\tannotations: {2}\n\tlast round: {3} 1160 1161 ##### 1162 1163 ## The following string will appear before all messages keyed as: 1164 ## "compiler.note". 1165 1166 compiler.note.compressed.diags=\ 1167 Some messages have been simplified; recompile with -Xdiags:verbose to get full output 1168 1169 compiler.note.potential.lambda.found=\ 1170 This anonymous inner class creation can be turned into a lambda expression. 1171 1172 # 0: boolean, 1: symbol 1173 compiler.note.lambda.stat=\ 1174 Translating lambda expression\n\ 1175 alternate metafactory = {0}\n\ 1176 synthetic method = {1} 1177 1178 # 0: boolean, 1: unused 1179 compiler.note.mref.stat=\ 1180 Translating method reference\n\ 1181 alternate metafactory = {0}\n\ 1182 1183 # 0: boolean, 1: symbol 1184 compiler.note.mref.stat.1=\ 1185 Translating method reference\n\ 1186 alternate metafactory = {0}\n\ 1187 bridge method = {1} 1188 1189 compiler.note.note=\ 1190 Note:\u0020 1191 1192 # 0: file name 1193 compiler.note.deprecated.filename=\ 1194 {0} uses or overrides a deprecated API. 1195 1196 compiler.note.deprecated.plural=\ 1197 Some input files use or override a deprecated API. 1198 1199 # The following string may appear after one of the above deprecation 1200 # messages. 1201 compiler.note.deprecated.recompile=\ 1202 Recompile with -Xlint:deprecation for details. 1203 1204 # 0: file name 1205 compiler.note.deprecated.filename.additional=\ 1206 {0} has additional uses or overrides of a deprecated API. 1207 1208 compiler.note.deprecated.plural.additional=\ 1209 Some input files additionally use or override a deprecated API. 1210 1211 # 0: file name 1212 compiler.note.unchecked.filename=\ 1213 {0} uses unchecked or unsafe operations. 1214 1215 compiler.note.unchecked.plural=\ 1216 Some input files use unchecked or unsafe operations. 1217 1218 # The following string may appear after one of the above deprecation 1219 # messages. 1220 compiler.note.unchecked.recompile=\ 1221 Recompile with -Xlint:unchecked for details. 1222 1223 # 0: file name 1224 compiler.note.unchecked.filename.additional=\ 1225 {0} has additional unchecked or unsafe operations. 1226 1227 compiler.note.unchecked.plural.additional=\ 1228 Some input files additionally use unchecked or unsafe operations. 1229 1230 # 0: file name 1231 compiler.note.sunapi.filename=\ 1232 {0} uses internal proprietary API that may be removed in a future release. 1233 1234 compiler.note.sunapi.plural=\ 1235 Some input files use internal proprietary API that may be removed in a future release. 1236 1237 # The following string may appear after one of the above sunapi messages. 1238 compiler.note.sunapi.recompile=\ 1239 Recompile with -Xlint:sunapi for details. 1240 1241 # 0: file name 1242 compiler.note.sunapi.filename.additional=\ 1243 {0} uses additional internal proprietary API that may be removed in a future release. 1244 1245 compiler.note.sunapi.plural.additional=\ 1246 Some input files additionally use internal proprietary API that may be removed in a future release. 1247 1248 # Notes related to annotation processing 1249 1250 # Print a client-generated note; assumed to be localized, no translation required 1251 # 0: string 1252 compiler.note.proc.messager=\ 1253 {0} 1254 1255 ##### 1256 1257 # 0: number 1258 compiler.misc.count.error=\ 1259 {0} error 1260 1261 # 0: number 1262 compiler.misc.count.error.plural=\ 1263 {0} errors 1264 1265 # 0: number 1266 compiler.misc.count.warn=\ 1267 {0} warning 1268 1269 # 0: number 1270 compiler.misc.count.warn.plural=\ 1271 {0} warnings 1272 1273 compiler.misc.version.not.available=\ 1274 (version info not available) 1275 1276 ## extra output when using -verbose (JavaCompiler) 1277 1278 # 0: symbol 1279 compiler.misc.verbose.checking.attribution=\ 1280 [checking {0}] 1281 1282 # 0: string 1283 compiler.misc.verbose.parsing.done=\ 1284 [parsing completed {0}ms] 1285 1286 # 0: file name 1287 compiler.misc.verbose.parsing.started=\ 1288 [parsing started {0}] 1289 1290 # 0: string 1291 compiler.misc.verbose.total=\ 1292 [total {0}ms] 1293 1294 # 0: file name 1295 compiler.misc.verbose.wrote.file=\ 1296 [wrote {0}] 1297 1298 ## extra output when using -verbose (Retro) 1299 compiler.misc.verbose.retro=\ 1300 [retrofitting {0}] 1301 1302 compiler.misc.verbose.retro.with=\ 1303 \tretrofitting {0} with {1} 1304 1305 compiler.misc.verbose.retro.with.list=\ 1306 \tretrofitting {0} with type parameters {1}, supertype {2}, interfaces {3} 1307 1308 ## extra output when using -verbose (code/ClassReader) 1309 # 0: string 1310 compiler.misc.verbose.loading=\ 1311 [loading {0}] 1312 1313 # 0: string 1314 compiler.misc.verbose.sourcepath=\ 1315 [search path for source files: {0}] 1316 1317 # 0: string 1318 compiler.misc.verbose.classpath=\ 1319 [search path for class files: {0}] 1320 1321 ## extra output when using -checkclassfile (code/ClassReader) 1322 compiler.misc.ccf.found.later.version=\ 1323 class file has later version than expected: {0} 1324 1325 compiler.misc.ccf.unrecognized.attribute=\ 1326 unrecognized attribute: {0} 1327 1328 ## extra output when using -prompt (util/Log) 1329 compiler.misc.resume.abort=\ 1330 R)esume, A)bort> 1331 1332 ##### 1333 1334 ## 1335 ## warnings 1336 ## 1337 1338 ## All warning messages are preceded by the following string. 1339 compiler.warn.warning=\ 1340 warning:\u0020 1341 1342 ## Warning messages may also include the following prefix to identify a 1343 ## lint option 1344 # 0: option name 1345 compiler.warn.lintOption=\ 1346 [{0}]\u0020 1347 1348 # 0: symbol 1349 compiler.warn.constant.SVUID=\ 1350 serialVersionUID must be constant in class {0} 1351 1352 # 0: file name 1353 compiler.warn.dir.path.element.not.found=\ 1354 bad path element "{0}": no such directory 1355 1356 compiler.warn.finally.cannot.complete=\ 1357 finally clause cannot complete normally 1358 1359 # 0: symbol, 1: symbol 1360 compiler.warn.has.been.deprecated=\ 1361 {0} in {1} has been deprecated 1362 1363 # 0: symbol 1364 compiler.warn.sun.proprietary=\ 1365 {0} is internal proprietary API and may be removed in a future release 1366 1367 compiler.warn.illegal.char.for.encoding=\ 1368 unmappable character for encoding {0} 1369 1370 # 0: symbol 1371 compiler.warn.improper.SVUID=\ 1372 serialVersionUID must be declared static final in class {0} 1373 1374 # 0: type, 1: type 1375 compiler.warn.inexact.non-varargs.call=\ 1376 non-varargs call of varargs method with inexact argument type for last parameter;\n\ 1377 cast to {0} for a varargs call\n\ 1378 cast to {1} for a non-varargs call and to suppress this warning 1379 1380 # 0: list of type 1381 compiler.warn.unreachable.catch=\ 1382 unreachable catch clause\n\ 1383 thrown type {0} has already been caught 1384 1385 # 0: list of type 1386 compiler.warn.unreachable.catch.1=\ 1387 unreachable catch clause\n\ 1388 thrown types {0} have already been caught 1389 1390 # 0: symbol 1391 compiler.warn.long.SVUID=\ 1392 serialVersionUID must be of type long in class {0} 1393 1394 # 0: symbol 1395 compiler.warn.missing.SVUID=\ 1396 serializable class {0} has no definition of serialVersionUID 1397 1398 # 0: symbol, 1: symbol, 2: symbol, 3: symbol 1399 compiler.warn.potentially.ambiguous.overload=\ 1400 {0} in {1} is potentially ambiguous with {2} in {3} 1401 1402 # 0: message segment 1403 compiler.warn.override.varargs.missing=\ 1404 {0}; overridden method has no ''...'' 1405 1406 # 0: message segment 1407 compiler.warn.override.varargs.extra=\ 1408 {0}; overriding method is missing ''...'' 1409 1410 compiler.warn.override.bridge=\ 1411 {0}; overridden method is a bridge method 1412 1413 # 0: symbol 1414 compiler.warn.pkg-info.already.seen=\ 1415 a package-info.java file has already been seen for package {0} 1416 1417 # 0: file name 1418 compiler.warn.path.element.not.found=\ 1419 bad path element "{0}": no such file or directory 1420 1421 compiler.warn.possible.fall-through.into.case=\ 1422 possible fall-through into case 1423 1424 # 0: type 1425 compiler.warn.redundant.cast=\ 1426 redundant cast to {0} 1427 1428 # 0: number 1429 compiler.warn.position.overflow=\ 1430 Position encoding overflows at line {0} 1431 1432 # 0: file name, 1: number, 2: number 1433 compiler.warn.big.major.version=\ 1434 {0}: major version {1} is newer than {2}, the highest major version supported by this compiler.\n\ 1435 It is recommended that the compiler be upgraded. 1436 1437 # 0: symbol kind, 1: symbol 1438 compiler.warn.static.not.qualified.by.type=\ 1439 static {0} should be qualified by type name, {1}, instead of by an expression 1440 1441 # 0: string 1442 compiler.warn.source.no.bootclasspath=\ 1443 bootstrap class path not set in conjunction with -source {0} 1444 1445 # 0: string 1446 compiler.warn.option.obsolete.source=\ 1447 source value {0} is obsolete and will be removed in a future release 1448 1449 # 0: string 1450 compiler.warn.option.obsolete.target=\ 1451 target value {0} is obsolete and will be removed in a future release 1452 1453 compiler.warn.option.obsolete.suppression=\ 1454 To suppress warnings about obsolete options, use -Xlint:-options. 1455 1456 # 0: name, 1: number, 2: number, 3: number, 4: number 1457 compiler.warn.future.attr=\ 1458 {0} attribute introduced in version {1}.{2} class files is ignored in version {3}.{4} class files 1459 1460 # Warnings related to annotation processing 1461 # 0: name 1462 compiler.warn.proc.package.does.not.exist=\ 1463 package {0} does not exist 1464 1465 # 0: name 1466 compiler.warn.proc.file.reopening=\ 1467 Attempt to create a file for ''{0}'' multiple times 1468 1469 # 0: name 1470 compiler.warn.proc.type.already.exists=\ 1471 A file for type ''{0}'' already exists on the sourcepath or classpath 1472 1473 # 0: name 1474 compiler.warn.proc.type.recreate=\ 1475 Attempt to create a file for type ''{0}'' multiple times 1476 1477 # 0: string 1478 compiler.warn.proc.illegal.file.name=\ 1479 Cannot create file for illegal name ''{0}''. 1480 1481 # 0: string, 1: string 1482 compiler.warn.proc.suspicious.class.name=\ 1483 Creating file for a type whose name ends in {1}: ''{0}'' 1484 1485 # 0: name 1486 compiler.warn.proc.file.create.last.round=\ 1487 File for type ''{0}'' created in the last round will not be subject to annotation processing. 1488 1489 # 0: string, 1: string 1490 compiler.warn.proc.malformed.supported.string=\ 1491 Malformed string ''{0}'' for a supported annotation type returned by processor ''{1}'' 1492 1493 # 0: set of string 1494 compiler.warn.proc.annotations.without.processors=\ 1495 No processor claimed any of these annotations: {0} 1496 1497 # 0: source version, 1: string, 2: string 1498 compiler.warn.proc.processor.incompatible.source.version=\ 1499 Supported source version ''{0}'' from annotation processor ''{1}'' less than -source ''{2}'' 1500 1501 compiler.warn.proc.proc-only.requested.no.procs=\ 1502 Annotation processing without compilation requested but no processors were found. 1503 1504 compiler.warn.proc.use.implicit=\ 1505 Implicitly compiled files were not subject to annotation processing.\n\ 1506 Use -implicit to specify a policy for implicit compilation. 1507 1508 compiler.warn.proc.use.proc.or.implicit=\ 1509 Implicitly compiled files were not subject to annotation processing.\n\ 1510 Use -proc:none to disable annotation processing or -implicit to specify a policy for implicit compilation. 1511 1512 # Print a client-generated warning; assumed to be localized, no translation required 1513 # 0: string 1514 compiler.warn.proc.messager=\ 1515 {0} 1516 1517 # 0: set of name 1518 compiler.warn.proc.unclosed.type.files=\ 1519 Unclosed files for the types ''{0}''; these types will not undergo annotation processing 1520 1521 # 0: string 1522 compiler.warn.proc.unmatched.processor.options=\ 1523 The following options were not recognized by any processor: ''{0}'' 1524 1525 compiler.warn.try.explicit.close.call=\ 1526 explicit call to close() on an auto-closeable resource 1527 1528 # 0: symbol 1529 compiler.warn.try.resource.not.referenced=\ 1530 auto-closeable resource {0} is never referenced in body of corresponding try statement 1531 1532 # 0: type 1533 compiler.warn.try.resource.throws.interrupted.exc=\ 1534 auto-closeable resource {0} has a member method close() that could throw InterruptedException 1535 1536 compiler.warn.unchecked.assign=\ 1537 unchecked assignment: {0} to {1} 1538 1539 # 0: symbol, 1: type 1540 compiler.warn.unchecked.assign.to.var=\ 1541 unchecked assignment to variable {0} as member of raw type {1} 1542 1543 # 0: symbol, 1: type 1544 compiler.warn.unchecked.call.mbr.of.raw.type=\ 1545 unchecked call to {0} as a member of the raw type {1} 1546 1547 compiler.warn.unchecked.cast.to.type=\ 1548 unchecked cast to type {0} 1549 1550 # 0: symbol kind, 1: name, 2: list of type, 3: list of type, 4: symbol kind, 5: symbol 1551 compiler.warn.unchecked.meth.invocation.applied=\ 1552 unchecked method invocation: {0} {1} in {4} {5} is applied to given types\n\ 1553 required: {2}\n\ 1554 found: {3} 1555 1556 # 0: type 1557 compiler.warn.unchecked.generic.array.creation=\ 1558 unchecked generic array creation for varargs parameter of type {0} 1559 1560 # 0: type 1561 compiler.warn.unchecked.varargs.non.reifiable.type=\ 1562 Possible heap pollution from parameterized vararg type {0} 1563 1564 # 0: symbol 1565 compiler.warn.varargs.unsafe.use.varargs.param=\ 1566 Varargs method could cause heap pollution from non-reifiable varargs parameter {0} 1567 1568 compiler.warn.missing.deprecated.annotation=\ 1569 deprecated item is not annotated with @Deprecated 1570 1571 compiler.warn.invalid.archive.file=\ 1572 Unexpected file on path: {0} 1573 1574 compiler.warn.unexpected.archive.file=\ 1575 Unexpected extension for archive file: {0} 1576 1577 compiler.warn.div.zero=\ 1578 division by zero 1579 1580 compiler.warn.empty.if=\ 1581 empty statement after if 1582 1583 compiler.warn.annotation.method.not.found=\ 1584 Cannot find annotation method ''{1}()'' in type ''{0}'' 1585 1586 compiler.warn.annotation.method.not.found.reason=\ 1587 Cannot find annotation method ''{1}()'' in type ''{0}'': {2} 1588 1589 # 0: symbol, 1: name 1590 compiler.warn.unknown.enum.constant=\ 1591 unknown enum constant {1}.{2} 1592 1593 # 0: symbol, 1: name, 2: message segment 1594 compiler.warn.unknown.enum.constant.reason=\ 1595 unknown enum constant {1}.{2}\n\ 1596 reason: {3} 1597 1598 # 0: type, 1: type 1599 compiler.warn.raw.class.use=\ 1600 found raw type: {0}\n\ 1601 missing type arguments for generic class {1} 1602 1603 # 0: unused, 1: unused 1604 compiler.warn.diamond.redundant.args=\ 1605 redundant type arguments in new expression (use diamond operator instead). 1606 1607 # 0: type, 1: type 1608 compiler.warn.diamond.redundant.args.1=\ 1609 redundant type arguments in new expression (use diamond operator instead).\n\ 1610 explicit: {0}\n\ 1611 inferred: {1} 1612 1613 # 0: symbol, 1: message segment 1614 compiler.warn.varargs.redundant.trustme.anno=\ 1615 Redundant {0} annotation. {1} 1616 1617 ##### 1618 1619 ## The following are tokens which are non-terminals in the language. They should 1620 ## be named as JLS3 calls them when translated to the appropriate language. 1621 compiler.misc.token.identifier=\ 1622 <identifier> 1623 1624 compiler.misc.token.character=\ 1625 <character> 1626 1627 compiler.misc.token.string=\ 1628 <string> 1629 1630 compiler.misc.token.integer=\ 1631 <integer> 1632 1633 compiler.misc.token.long-integer=\ 1634 <long integer> 1635 1636 compiler.misc.token.float=\ 1637 <float> 1638 1639 compiler.misc.token.double=\ 1640 <double> 1641 1642 compiler.misc.token.bad-symbol=\ 1643 <bad symbol> 1644 1645 compiler.misc.token.end-of-input=\ 1646 <end of input> 1647 1648 ## The argument to the following string will always be one of the following: 1649 ## 1. one of the above non-terminals 1650 ## 2. a keyword (JLS1.8) 1651 ## 3. a boolean literal (JLS3.10.3) 1652 ## 4. the null literal (JLS3.10.7) 1653 ## 5. a Java separator (JLS3.11) 1654 ## 6. an operator (JLS3.12) 1655 ## 1656 ## This is the only place these tokens will be used. 1657 # 0: token 1658 compiler.err.expected=\ 1659 {0} expected 1660 1661 # 0: token, 1: token 1662 compiler.err.expected2=\ 1663 {0} or {1} expected 1664 1665 # 0: token, 1: token, 2: token 1666 compiler.err.expected3=\ 1667 {0}, {1}, or {2} expected 1668 1669 compiler.err.premature.eof=\ 1670 reached end of file while parsing 1671 1672 ## The following are related in form, but do not easily fit the above paradigm. 1673 compiler.err.dot.class.expected=\ 1674 ''.class'' expected 1675 1676 ## The argument to this string will always be either 'case' or 'default'. 1677 # 0: token 1678 compiler.err.orphaned=\ 1679 orphaned {0} 1680 1681 # 0: name 1682 compiler.misc.anonymous.class=\ 1683 <anonymous {0}> 1684 1685 # 0: name, 1: type 1686 compiler.misc.type.captureof=\ 1687 capture#{0} of {1} 1688 1689 compiler.misc.type.captureof.1=\ 1690 capture#{0} 1691 1692 compiler.misc.type.none=\ 1693 <none> 1694 1695 compiler.misc.unnamed.package=\ 1696 unnamed package 1697 1698 ##### 1699 1700 # 0: symbol, 1: message segment 1701 compiler.err.cant.access=\ 1702 cannot access {0}\n\ 1703 {1} 1704 1705 compiler.misc.bad.class.file.header=\ 1706 bad class file: {0}\n\ 1707 {1}\n\ 1708 Please remove or make sure it appears in the correct subdirectory of the classpath. 1709 1710 # 0: file name, 1: message segment 1711 compiler.misc.bad.source.file.header=\ 1712 bad source file: {0}\n\ 1713 {1}\n\ 1714 Please remove or make sure it appears in the correct subdirectory of the sourcepath. 1715 1716 ## The following are all possible strings for the second argument ({1}) of the 1717 ## above strings. 1718 compiler.misc.bad.class.signature=\ 1719 bad class signature: {0} 1720 1721 #0: symbol, 1: symbol 1722 compiler.misc.bad.enclosing.class=\ 1723 bad enclosing class for {0}: {1} 1724 1725 # 0: symbol 1726 compiler.misc.bad.enclosing.method=\ 1727 bad enclosing method attribute for class {0} 1728 1729 compiler.misc.bad.runtime.invisible.param.annotations=\ 1730 bad RuntimeInvisibleParameterAnnotations attribute: {0} 1731 1732 compiler.misc.bad.const.pool.tag=\ 1733 bad constant pool tag: {0} 1734 1735 compiler.misc.bad.const.pool.tag.at=\ 1736 bad constant pool tag: {0} at {1} 1737 1738 compiler.misc.bad.signature=\ 1739 bad signature: {0} 1740 1741 compiler.misc.bad.type.annotation.value=\ 1742 bad type annotation target type value: {0} 1743 1744 compiler.misc.class.file.wrong.class=\ 1745 class file contains wrong class: {0} 1746 1747 compiler.misc.class.file.not.found=\ 1748 class file for {0} not found 1749 1750 # 0: name 1751 compiler.misc.file.doesnt.contain.class=\ 1752 file does not contain class {0} 1753 1754 compiler.misc.file.does.not.contain.package=\ 1755 file does not contain package {0} 1756 1757 compiler.misc.illegal.start.of.class.file=\ 1758 illegal start of class file 1759 1760 compiler.misc.unable.to.access.file=\ 1761 unable to access file: {0} 1762 1763 compiler.misc.unicode.str.not.supported=\ 1764 unicode string in class file not supported 1765 1766 compiler.misc.undecl.type.var=\ 1767 undeclared type variable: {0} 1768 1769 compiler.misc.wrong.version=\ 1770 class file has wrong version {0}.{1}, should be {2}.{3} 1771 1772 ##### 1773 1774 # 0: type, 1: type or symbol 1775 compiler.err.not.within.bounds=\ 1776 type argument {0} is not within bounds of type-variable {1} 1777 1778 ## The following are all possible strings for the second argument ({1}) of the 1779 ## above string. 1780 1781 ## none yet... 1782 1783 ##### 1784 1785 # 0: message segment 1786 compiler.err.prob.found.req=\ 1787 incompatible types: {0} 1788 1789 # 0: message segment 1790 compiler.misc.prob.found.req=\ 1791 incompatible types: {0} 1792 1793 # 0: message segment, 1: type, 2: type 1794 compiler.warn.prob.found.req=\ 1795 {0}\n\ 1796 required: {2}\n\ 1797 found: {1} 1798 1799 # 0: type, 1: type 1800 compiler.misc.inconvertible.types=\ 1801 {0} cannot be converted to {1} 1802 1803 # 0: type, 1: type 1804 compiler.misc.possible.loss.of.precision=\ 1805 possible lossy conversion from {0} to {1} 1806 1807 compiler.misc.unchecked.assign=\ 1808 unchecked conversion 1809 1810 # compiler.misc.storecheck=\ 1811 # assignment might cause later store checks to fail 1812 # compiler.misc.unchecked=\ 1813 # assigned array cannot dynamically check its stores 1814 compiler.misc.unchecked.cast.to.type=\ 1815 unchecked cast 1816 1817 # compiler.err.star.expected=\ 1818 # ''*'' expected 1819 # compiler.err.no.elem.type=\ 1820 # \[\*\] cannot have a type 1821 1822 # 0: type 1823 compiler.misc.try.not.applicable.to.type=\ 1824 try-with-resources not applicable to variable type\n\ 1825 ({0}) 1826 1827 ##### 1828 1829 # 0: message segment or type, 1: message segment 1830 compiler.err.type.found.req=\ 1831 unexpected type\n\ 1832 required: {1}\n\ 1833 found: {0} 1834 1835 ## The following are all possible strings for the first argument ({0}) of the 1836 ## above string. 1837 compiler.misc.type.req.class=\ 1838 class 1839 1840 compiler.misc.type.req.class.array=\ 1841 class or array 1842 1843 compiler.misc.type.req.array.or.iterable=\ 1844 array or java.lang.Iterable 1845 1846 compiler.misc.type.req.ref=\ 1847 reference 1848 1849 compiler.misc.type.req.exact=\ 1850 class or interface without bounds 1851 1852 # 0: type 1853 compiler.misc.type.parameter=\ 1854 type parameter {0} 1855 1856 ##### 1857 1858 ## The following are all possible strings for the last argument of all those 1859 ## diagnostics whose key ends in ".1" 1860 1861 # 0: type, 1: list of type 1862 compiler.misc.no.unique.maximal.instance.exists=\ 1863 no unique maximal instance exists for type variable {0} with upper bounds {1} 1864 1865 compiler.misc.no.unique.minimal.instance.exists=\ 1866 no unique minimal instance exists for type variable {0} with lower bounds {1} 1867 1868 # 0: type, 1: list of type 1869 compiler.misc.incompatible.upper.bounds=\ 1870 inference variable {0} has incompatible upper bounds {1} 1871 1872 # 0: type, 1: list of type, 2: list of type 1873 compiler.misc.incompatible.eq.upper.bounds=\ 1874 inference variable {0} has incompatible bounds\n\ 1875 equality constraints: {1}\n\ 1876 upper bounds: {2} 1877 1878 # 0: type, 1: list of type, 2: list of type 1879 compiler.misc.incompatible.eq.lower.bounds=\ 1880 inference variable {0} has incompatible bounds\n\ 1881 equality constraints: {1}\n\ 1882 lower bounds: {2} 1883 1884 # 0: list of type, 1: type, 2: type 1885 compiler.misc.infer.no.conforming.instance.exists=\ 1886 no instance(s) of type variable(s) {0} exist so that {1} conforms to {2} 1887 1888 # 0: list of type, 1: message segment 1889 compiler.misc.infer.no.conforming.assignment.exists=\ 1890 cannot infer type-variable(s) {0}\n\ 1891 (argument mismatch; {1}) 1892 1893 # 0: list of type 1894 compiler.misc.infer.arg.length.mismatch=\ 1895 cannot infer type-variable(s) {0}\n\ 1896 (actual and formal argument lists differ in length) 1897 1898 # 0: list of type, 1: message segment 1899 compiler.misc.infer.varargs.argument.mismatch=\ 1900 cannot infer type-variable(s) {0}\n\ 1901 (varargs mismatch; {1}) 1902 1903 # 0: type, 1: list of type 1904 compiler.misc.inferred.do.not.conform.to.upper.bounds=\ 1905 inferred type does not conform to upper bound(s)\n\ 1906 inferred: {0}\n\ 1907 upper bound(s): {1} 1908 1909 # 0: type, 1: list of type 1910 compiler.misc.inferred.do.not.conform.to.lower.bounds=\ 1911 inferred type does not conform to lower bound(s)\n\ 1912 inferred: {0}\n\ 1913 lower bound(s): {1} 1914 1915 # 0: type, 1: list of type 1916 compiler.misc.inferred.do.not.conform.to.eq.bounds=\ 1917 inferred type does not conform to equality constraint(s)\n\ 1918 inferred: {0}\n\ 1919 equality constraints(s): {1} 1920 1921 # 0: symbol 1922 compiler.misc.diamond=\ 1923 {0}<> 1924 1925 # 0: type 1926 compiler.misc.diamond.non.generic=\ 1927 cannot use ''<>'' with non-generic class {0} 1928 1929 # 0: unused 1930 compiler.misc.diamond.and.explicit.params=\ 1931 cannot use ''<>'' with explicit type parameters for constructor 1932 1933 # 0: unused 1934 compiler.misc.mref.infer.and.explicit.params=\ 1935 cannot use raw constructor reference with explicit type parameters for constructor 1936 1937 # 0: type, 1: list of type 1938 compiler.misc.explicit.param.do.not.conform.to.bounds=\ 1939 explicit type argument {0} does not conform to declared bound(s) {1} 1940 1941 compiler.misc.arg.length.mismatch=\ 1942 actual and formal argument lists differ in length 1943 1944 # 0: message segment 1945 compiler.misc.no.conforming.assignment.exists=\ 1946 argument mismatch; {0} 1947 1948 # 0: message segment 1949 compiler.misc.varargs.argument.mismatch=\ 1950 varargs mismatch; {0} 1951 1952 ##### 1953 1954 # 0: symbol or type, 1: file name 1955 compiler.warn.auxiliary.class.accessed.from.outside.of.its.source.file=\ 1956 auxiliary class {0} in {1} should not be accessed from outside its own source file 1957 1958 ## The first argument ({0}) is a "kindname". 1959 # 0: symbol kind, 1: symbol, 2: symbol 1960 compiler.err.abstract.cant.be.accessed.directly=\ 1961 abstract {0} {1} in {2} cannot be accessed directly 1962 1963 ## The first argument ({0}) is a "kindname". 1964 # 0: symbol kind, 1: symbol 1965 compiler.err.non-static.cant.be.ref=\ 1966 non-static {0} {1} cannot be referenced from a static context 1967 1968 # 0: symbol kind, 1: symbol 1969 compiler.misc.non-static.cant.be.ref=\ 1970 non-static {0} {1} cannot be referenced from a static context 1971 1972 # 0: symbol kind, 1: symbol 1973 compiler.misc.static.method.in.unbound.lookup=\ 1974 static {0} {1} found in unbound lookup 1975 1976 ## Both arguments ({0}, {1}) are "kindname"s. {0} is a comma-separated list 1977 ## of kindnames (the list should be identical to that provided in source. 1978 compiler.err.unexpected.type=\ 1979 unexpected type\n\ 1980 required: {0}\n\ 1981 found: {1} 1982 1983 compiler.err.unexpected.lambda=\ 1984 lambda expression not expected here 1985 1986 compiler.err.unexpected.mref=\ 1987 method reference not expected here 1988 1989 ## The first argument {0} is a "kindname" (e.g. 'constructor', 'field', etc.) 1990 ## The second argument {1} is the non-resolved symbol 1991 ## The third argument {2} is a list of type parameters (non-empty if {1} is a method) 1992 ## The fourth argument {3} is a list of argument types (non-empty if {1} is a method) 1993 # 0: symbol kind, 1: name, 2: unused, 3: unused 1994 compiler.err.cant.resolve=\ 1995 cannot find symbol\n\ 1996 symbol: {0} {1} 1997 1998 # 0: symbol kind, 1: name, 2: unused, 3: list of type 1999 compiler.err.cant.resolve.args=\ 2000 cannot find symbol\n\ 2001 symbol: {0} {1}({3}) 2002 2003 # 0: symbol kind, 1: name, 2: list of type, 3: list of type 2004 compiler.err.cant.resolve.args.params=\ 2005 cannot find symbol\n\ 2006 symbol: {0} <{2}>{1}({3}) 2007 2008 ## arguments from {0} to {3} have the same meaning as above 2009 ## The fifth argument {4} is a location subdiagnostic (see below) 2010 # 0: symbol kind, 1: name, 2: unused, 3: unused, 4: message segment 2011 compiler.err.cant.resolve.location=\ 2012 cannot find symbol\n\ 2013 symbol: {0} {1}\n\ 2014 location: {4} 2015 2016 # 0: symbol kind, 1: name, 2: unused, 3: list of type, 4: message segment 2017 compiler.err.cant.resolve.location.args=\ 2018 cannot find symbol\n\ 2019 symbol: {0} {1}({3})\n\ 2020 location: {4} 2021 2022 # 0: symbol kind, 1: name, 2: list of type, 3: list, 4: message segment 2023 compiler.err.cant.resolve.location.args.params=\ 2024 cannot find symbol\n\ 2025 symbol: {0} <{2}>{1}({3})\n\ 2026 location: {4} 2027 2028 ### Following are replicated/used for method reference diagnostics 2029 2030 # 0: symbol kind, 1: name, 2: unused, 3: list of type, 4: message segment 2031 compiler.misc.cant.resolve.location.args=\ 2032 cannot find symbol\n\ 2033 symbol: {0} {1}({3})\n\ 2034 location: {4} 2035 2036 # 0: symbol kind, 1: name, 2: list of type, 3: list, 4: message segment 2037 compiler.misc.cant.resolve.location.args.params=\ 2038 cannot find symbol\n\ 2039 symbol: {0} <{2}>{1}({3})\n\ 2040 location: {4} 2041 2042 ##a location subdiagnostic is composed as follows: 2043 ## The first argument {0} is the location "kindname" (e.g. 'constructor', 'field', etc.) 2044 ## The second argument {1} is the location name 2045 ## The third argument {2} is the location type (only when {1} is a variable name) 2046 2047 # 0: symbol kind, 1: type or symbol, 2: unused 2048 compiler.misc.location=\ 2049 {0} {1} 2050 2051 # 0: symbol kind, 1: symbol, 2: type 2052 compiler.misc.location.1=\ 2053 {0} {1} of type {2} 2054 2055 ## The following are all possible string for "kindname". 2056 ## They should be called whatever the JLS calls them after it been translated 2057 ## to the appropriate language. 2058 # compiler.misc.kindname.constructor=\ 2059 # static member 2060 compiler.misc.kindname.annotation=\ 2061 @interface 2062 2063 compiler.misc.kindname.constructor=\ 2064 constructor 2065 2066 compiler.misc.kindname.enum=\ 2067 enum 2068 2069 compiler.misc.kindname.interface=\ 2070 interface 2071 2072 compiler.misc.kindname.static=\ 2073 static 2074 2075 compiler.misc.kindname.type.variable=\ 2076 type variable 2077 2078 compiler.misc.kindname.type.variable.bound=\ 2079 bound of type variable 2080 2081 compiler.misc.kindname.variable=\ 2082 variable 2083 2084 compiler.misc.kindname.value=\ 2085 value 2086 2087 compiler.misc.kindname.method=\ 2088 method 2089 2090 compiler.misc.kindname.class=\ 2091 class 2092 2093 compiler.misc.kindname.package=\ 2094 package 2095 2096 compiler.misc.kindname.static.init=\ 2097 static initializer 2098 2099 compiler.misc.kindname.instance.init=\ 2100 instance initializer 2101 2102 ##### 2103 2104 compiler.misc.no.args=\ 2105 no arguments 2106 2107 # 0: message segment 2108 compiler.err.override.static=\ 2109 {0}\n\ 2110 overriding method is static 2111 2112 # 0: message segment, 1: set of modifier 2113 compiler.err.override.meth=\ 2114 {0}\n\ 2115 overridden method is {1} 2116 2117 # 0: message segment, 1: type 2118 compiler.err.override.meth.doesnt.throw=\ 2119 {0}\n\ 2120 overridden method does not throw {1} 2121 2122 # In the following string {1} is a space separated list of Java Keywords, as 2123 # they would have been declared in the source code 2124 # 0: message segment, 1: set of modifier 2125 compiler.err.override.weaker.access=\ 2126 {0}\n\ 2127 attempting to assign weaker access privileges; was {1} 2128 2129 # 0: message segment, 1: type, 2: type 2130 compiler.err.override.incompatible.ret=\ 2131 {0}\n\ 2132 return type {1} is not compatible with {2} 2133 2134 # 0: message segment, 1: type, 2: type 2135 compiler.warn.override.unchecked.ret=\ 2136 {0}\n\ 2137 return type requires unchecked conversion from {1} to {2} 2138 2139 # 0: message segment, 1: type 2140 compiler.warn.override.unchecked.thrown=\ 2141 {0}\n\ 2142 overridden method does not throw {1} 2143 2144 # 0: symbol 2145 compiler.warn.override.equals.but.not.hashcode=\ 2146 Class {0} overrides equals, but neither it nor any superclass overrides hashCode method 2147 2148 ## The following are all possible strings for the first argument ({0}) of the 2149 ## above strings. 2150 # 0: symbol, 1: symbol, 2: symbol, 3: symbol 2151 compiler.misc.cant.override=\ 2152 {0} in {1} cannot override {2} in {3} 2153 2154 # 0: symbol, 1: symbol, 2: symbol, 3: symbol 2155 compiler.misc.cant.implement=\ 2156 {0} in {1} cannot implement {2} in {3} 2157 2158 # 0: symbol, 1: symbol, 2: symbol, 3: symbol 2159 compiler.misc.clashes.with=\ 2160 {0} in {1} clashes with {2} in {3} 2161 2162 # 0: symbol, 1: symbol, 2: symbol, 3: symbol 2163 compiler.misc.unchecked.override=\ 2164 {0} in {1} overrides {2} in {3} 2165 2166 # 0: symbol, 1: symbol, 2: symbol, 3: symbol 2167 compiler.misc.unchecked.implement=\ 2168 {0} in {1} implements {2} in {3} 2169 2170 # 0: symbol, 1: symbol, 2: symbol, 3: symbol 2171 compiler.misc.unchecked.clash.with=\ 2172 {0} in {1} overrides {2} in {3} 2173 2174 # 0: symbol, 1: symbol, 2: symbol, 3: symbol 2175 compiler.misc.varargs.override=\ 2176 {0} in {1} overrides {2} in {3} 2177 2178 # 0: symbol, 1: symbol, 2: symbol, 3: symbol 2179 compiler.misc.varargs.implement=\ 2180 {0} in {1} implements {2} in {3} 2181 2182 # 0: symbol, 1: symbol, 2: symbol, 3: symbol 2183 compiler.misc.varargs.clash.with=\ 2184 {0} in {1} overrides {2} in {3} 2185 2186 # 0: unused 2187 compiler.misc.diamond.and.anon.class=\ 2188 cannot use ''<>'' with anonymous inner classes 2189 2190 # 0: symbol kind, 1: symbol, 2: symbol, 3: message segment 2191 compiler.misc.inapplicable.method=\ 2192 {0} {1}.{2} is not applicable\n\ 2193 ({3}) 2194 2195 ######################################## 2196 # Diagnostics for language feature changes 2197 ######################################## 2198 # 0: string 2199 compiler.err.unsupported.fp.lit=\ 2200 hexadecimal floating point literals are not supported in -source {0}\n\ 2201 (use -source 5 or higher to enable hexadecimal floating point literals) 2202 2203 # 0: string 2204 compiler.err.unsupported.binary.lit=\ 2205 binary literals are not supported in -source {0}\n\ 2206 (use -source 7 or higher to enable binary literals) 2207 2208 # 0: string 2209 compiler.err.unsupported.underscore.lit=\ 2210 underscores in literals are not supported in -source {0}\n\ 2211 (use -source 7 or higher to enable underscores in literals) 2212 2213 # 0: string 2214 compiler.err.try.with.resources.not.supported.in.source=\ 2215 try-with-resources is not supported in -source {0}\n\ 2216 (use -source 7 or higher to enable try-with-resources) 2217 2218 compiler.warn.enum.as.identifier=\ 2219 as of release 5, ''enum'' is a keyword, and may not be used as an identifier\n\ 2220 (use -source 5 or higher to use ''enum'' as a keyword) 2221 2222 compiler.warn.assert.as.identifier=\ 2223 as of release 1.4, ''assert'' is a keyword, and may not be used as an identifier\n\ 2224 (use -source 1.4 or higher to use ''assert'' as a keyword) 2225 2226 compiler.warn.underscore.as.identifier=\ 2227 ''_'' used as an identifier\n\ 2228 (use of ''_'' as an identifier might not be supported in releases after Java SE 8) 2229 2230 compiler.err.enum.as.identifier=\ 2231 as of release 5, ''enum'' is a keyword, and may not be used as an identifier\n\ 2232 (use -source 1.4 or lower to use ''enum'' as an identifier) 2233 2234 compiler.err.assert.as.identifier=\ 2235 as of release 1.4, ''assert'' is a keyword, and may not be used as an identifier\n\ 2236 (use -source 1.3 or lower to use ''assert'' as an identifier) 2237 2238 # TODO 308: make a better error message 2239 compiler.err.this.as.identifier=\ 2240 as of release 8, ''this'' is allowed as the parameter name for the receiver type only, which has to be the first parameter 2241 2242 # 0: symbol 2243 compiler.err.receiver.parameter.not.applicable.constructor.toplevel.class=\ 2244 receiver parameter not applicable for constructor of top-level class 2245 2246 # TODO 308: make a better error message 2247 compiler.err.cant.annotate.static.class=\ 2248 enclosing static nested class cannot be annotated 2249 2250 # TODO 308: make a better error message 2251 # 0: unused 2252 compiler.err.cant.annotate.nested.type=\ 2253 scoping construct for static nested type cannot be annotated 2254 2255 # 0: type, 1: type 2256 compiler.err.incorrect.receiver.name=\ 2257 the receiver name does not match the enclosing class type\n\ 2258 required: {0}\n\ 2259 found: {1} 2260 2261 # 0: type, 1: type 2262 compiler.err.incorrect.receiver.type=\ 2263 the receiver type does not match the enclosing class type\n\ 2264 required: {0}\n\ 2265 found: {1} 2266 2267 # 0: type, 1: type 2268 compiler.err.incorrect.constructor.receiver.type=\ 2269 the receiver type does not match the enclosing outer class type\n\ 2270 required: {0}\n\ 2271 found: {1} 2272 2273 # 0: type, 1: type 2274 compiler.err.incorrect.constructor.receiver.name=\ 2275 the receiver name does not match the enclosing outer class type\n\ 2276 required: {0}\n\ 2277 found: {1} 2278 2279 compiler.err.no.annotations.on.dot.class=\ 2280 no annotations are allowed in the type of a class literal 2281 2282 # 0: string 2283 compiler.err.generics.not.supported.in.source=\ 2284 generics are not supported in -source {0}\n\ 2285 (use -source 5 or higher to enable generics) 2286 2287 # 0: string 2288 compiler.err.varargs.not.supported.in.source=\ 2289 variable-arity methods are not supported in -source {0}\n\ 2290 (use -source 5 or higher to enable variable-arity methods) 2291 2292 # 0: string 2293 compiler.err.annotations.not.supported.in.source=\ 2294 annotations are not supported in -source {0}\n\ 2295 (use -source 5 or higher to enable annotations) 2296 2297 # 0: string 2298 compiler.err.type.annotations.not.supported.in.source=\ 2299 type annotations are not supported in -source {0}\n\ 2300 (use -source 8 or higher to enable type annotations) 2301 2302 # 0: string 2303 compiler.err.repeatable.annotations.not.supported.in.source=\ 2304 repeated annotations are not supported in -source {0}\n\ 2305 (use -source 8 or higher to enable type annotations) 2306 2307 # 0: string 2308 compiler.err.foreach.not.supported.in.source=\ 2309 enhanced for loops are not supported in -source {0}\n\ 2310 (use -source 5 or higher to enable for-each loops) 2311 2312 # 0: string 2313 compiler.err.static.import.not.supported.in.source=\ 2314 static import declarations are not supported in -source {0}\n\ 2315 (use -source 5 or higher to enable static import declarations) 2316 2317 # 0: string 2318 compiler.err.enums.not.supported.in.source=\ 2319 enums are not supported in -source {0}\n\ 2320 (use -source 5 or higher to enable enums) 2321 2322 # 0: string 2323 compiler.err.diamond.not.supported.in.source=\ 2324 diamond operator is not supported in -source {0}\n\ 2325 (use -source 7 or higher to enable diamond operator) 2326 2327 # 0: string 2328 compiler.err.multicatch.not.supported.in.source=\ 2329 multi-catch statement is not supported in -source {0}\n\ 2330 (use -source 7 or higher to enable multi-catch statement) 2331 2332 # 0: string 2333 compiler.err.string.switch.not.supported.in.source=\ 2334 strings in switch are not supported in -source {0}\n\ 2335 (use -source 7 or higher to enable strings in switch) 2336 2337 # 0: string 2338 compiler.err.lambda.not.supported.in.source=\ 2339 lambda expressions are not supported in -source {0}\n\ 2340 (use -source 8 or higher to enable lambda expressions) 2341 2342 # 0: string 2343 compiler.err.method.references.not.supported.in.source=\ 2344 method references are not supported in -source {0}\n\ 2345 (use -source 8 or higher to enable method references) 2346 2347 # 0: string 2348 compiler.err.default.methods.not.supported.in.source=\ 2349 default methods are not supported in -source {0}\n\ 2350 (use -source 8 or higher to enable default methods) 2351 2352 # 0: string 2353 compiler.err.intersection.types.in.cast.not.supported.in.source=\ 2354 intersection types in cast are not supported in -source {0}\n\ 2355 (use -source 8 or higher to enable default methods) 2356 2357 # 0: string 2358 compiler.err.static.intf.methods.not.supported.in.source=\ 2359 static interface methods are not supported in -source {0}\n\ 2360 (use -source 8 or higher to enable static interface methods) 2361 2362 ######################################## 2363 # Diagnostics for verbose resolution 2364 # used by Resolve (debug only) 2365 ######################################## 2366 2367 # 0: number, 1: symbol, 2: unused 2368 compiler.misc.applicable.method.found=\ 2369 #{0} applicable method found: {1} 2370 2371 # 0: number, 1: symbol, 2: message segment 2372 compiler.misc.applicable.method.found.1=\ 2373 #{0} applicable method found: {1}\n\ 2374 ({2}) 2375 2376 # 0: number, 1: symbol, 2: message segment 2377 compiler.misc.not.applicable.method.found=\ 2378 #{0} not applicable method found: {1}\n\ 2379 ({2}) 2380 2381 # 0: type 2382 compiler.misc.partial.inst.sig=\ 2383 partially instantiated to: {0} 2384 2385 # 0: name, 1: symbol, 2: number, 3: MethodResolutionPhase, 4: list of type or message segment, 5: list of type or message segment 2386 compiler.note.verbose.resolve.multi=\ 2387 resolving method {0} in type {1} to candidate {2}\n\ 2388 phase: {3}\n\ 2389 with actuals: {4}\n\ 2390 with type-args: {5}\n\ 2391 candidates: 2392 2393 # 0: name, 1: symbol, 2: unused, 3: MethodResolutionPhase, 4: list of type or message segment, 5: list of type or message segment 2394 compiler.note.verbose.resolve.multi.1=\ 2395 erroneous resolution for method {0} in type {1}\n\ 2396 phase: {3}\n\ 2397 with actuals: {4}\n\ 2398 with type-args: {5}\n\ 2399 candidates: 2400 2401 # 0: symbol, 1: type, 2: type 2402 compiler.note.deferred.method.inst=\ 2403 Deferred instantiation of method {0}\n\ 2404 instantiated signature: {1}\n\ 2405 target-type: {2} 2406 2407 ######################################## 2408 # Diagnostics for where clause implementation 2409 # used by the RichDiagnosticFormatter. 2410 ######################################## 2411 2412 compiler.misc.type.null=\ 2413 <null> 2414 2415 # X#n (where n is an int id) is disambiguated tvar name 2416 # 0: name, 1: number 2417 compiler.misc.type.var=\ 2418 {0}#{1} 2419 2420 # CAP#n (where n is an int id) is an abbreviation for 'captured type' 2421 # 0: number 2422 compiler.misc.captured.type=\ 2423 CAP#{0} 2424 2425 # <INT#n> (where n is an int id) is an abbreviation for 'intersection type' 2426 # 0: number 2427 compiler.misc.intersection.type=\ 2428 INT#{0} 2429 2430 # where clause for captured type: contains upper ('extends {1}') and lower 2431 # ('super {2}') bound along with the wildcard that generated this captured type ({3}) 2432 # 0: type, 1: type, 2: type, 3: type 2433 compiler.misc.where.captured=\ 2434 {0} extends {1} super: {2} from capture of {3} 2435 2436 # compact where clause for captured type: contains upper ('extends {1}') along 2437 # with the wildcard that generated this captured type ({3}) 2438 # 0: type, 1: type, 2: unused, 3: type 2439 compiler.misc.where.captured.1=\ 2440 {0} extends {1} from capture of {3} 2441 2442 # where clause for type variable: contains upper bound(s) ('extends {1}') along with 2443 # the kindname ({2}) and location ({3}) in which the typevar has been declared 2444 # 0: type, 1: list of type, 2: symbol kind, 3: symbol 2445 compiler.misc.where.typevar=\ 2446 {0} extends {1} declared in {2} {3} 2447 2448 # compact where clause for type variable: contains the kindname ({2}) and location ({3}) 2449 # in which the typevar has been declared 2450 # 0: type, 1: list of type, 2: symbol kind, 3: symbol 2451 compiler.misc.where.typevar.1=\ 2452 {0} declared in {2} {3} 2453 2454 # where clause for fresh type variable: contains upper bound(s) ('extends {1}'). 2455 # Since a fresh type-variable is synthetic - there's no location/kindname here. 2456 # 0: type, 1: list of type 2457 compiler.misc.where.fresh.typevar=\ 2458 {0} extends {1} 2459 2460 # where clause for type variable: contains all the upper bound(s) ('extends {1}') 2461 # of this intersection type 2462 # 0: type, 1: list of type 2463 compiler.misc.where.intersection=\ 2464 {0} extends {1} 2465 2466 ### Where clause headers ### 2467 compiler.misc.where.description.captured=\ 2468 where {0} is a fresh type-variable: 2469 2470 # 0: set of type 2471 compiler.misc.where.description.typevar=\ 2472 where {0} is a type-variable: 2473 2474 # 0: set of type 2475 compiler.misc.where.description.intersection=\ 2476 where {0} is an intersection type: 2477 2478 # 0: set of type 2479 compiler.misc.where.description.captured.1=\ 2480 where {0} are fresh type-variables: 2481 2482 # 0: set of type 2483 compiler.misc.where.description.typevar.1=\ 2484 where {0} are type-variables: 2485 2486 compiler.misc.where.description.intersection.1=\ 2487 where {0} are intersection types: 2488 2489 ### 2490 # errors related to doc comments 2491 2492 compiler.err.dc.bad.entity=\ 2493 bad HTML entity 2494 2495 compiler.err.dc.bad.gt=\ 2496 bad use of ''>'' 2497 2498 compiler.err.dc.bad.inline.tag=\ 2499 incorrect use of inline tag 2500 2501 compiler.err.dc.identifier.expected=\ 2502 identifier expected 2503 2504 compiler.err.dc.malformed.html=\ 2505 malformed HTML 2506 2507 compiler.err.dc.missing.semicolon=\ 2508 semicolon missing 2509 2510 compiler.err.dc.no.content=\ 2511 no content 2512 2513 compiler.err.dc.no.tag.name=\ 2514 no tag name after '@' 2515 2516 compiler.err.dc.gt.expected=\ 2517 ''>'' expected 2518 2519 compiler.err.dc.ref.bad.parens=\ 2520 '')'' missing in reference 2521 2522 compiler.err.dc.ref.syntax.error=\ 2523 syntax error in reference 2524 2525 compiler.err.dc.ref.unexpected.input=\ 2526 unexpected text 2527 2528 compiler.err.dc.unexpected.content=\ 2529 unexpected content 2530 2531 compiler.err.dc.unterminated.inline.tag=\ 2532 unterminated inline tag 2533 2534 compiler.err.dc.unterminated.signature=\ 2535 unterminated signature 2536 2537 compiler.err.dc.unterminated.string=\ 2538 unterminated string 2539 2540