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