1 # 2 # Copyright (c) 1999, 2018, 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 simple types currently in use are: 30 # 31 # annotation annotation compound 32 # boolean true or false 33 # diagnostic a sub-message; see compiler.misc.* 34 # fragment similar to 'message segment', but with more specific type 35 # modifier a Java modifier; e.g. public, private, protected 36 # file a file URL 37 # file object a file URL - similar to 'file' but typically used for source/class files, hence more specific 38 # flag a Flags.Flag instance 39 # name a name, typically a Java identifier 40 # number an integer 41 # option name the name of a command line option 42 # path a path 43 # profile a profile name 44 # source a source version number, such as 1.5, 1.6, 1.7, taken from a com.sun.tools.javac.code.Source 45 # source version a source version number, such as 1.5, 1.6, 1.7, taken from a javax.lang.model.SourceVersion 46 # string a general string 47 # symbol the name of a declared type 48 # symbol kind the kind of a symbol (i.e. method, variable) 49 # kind name an informative description of the kind of a declaration; see compiler.misc.kindname.* 50 # target a target version number, such as 1.5, 1.6, 1.7, taken from a com.sun.tools.javac.jvm.Target 51 # token the name of a non-terminal in source code; see compiler.misc.token.* 52 # type a Java type; e.g. int, X, X<T> 53 # url a URL 54 # object a Java object (unspecified) 55 # unused the value is not used in this message 56 # 57 # The following compound types are also used: 58 # 59 # collection of X a comma-separated collection of items; e.g. collection of type 60 # list of X a comma-separated list of items; e.g. list of type 61 # set of X a comma-separated set of items; e.g. set of modifier 62 # 63 # These may be composed: 64 # 65 # list of type or message segment 66 # 67 # The following type aliases are supported: 68 # 69 # message segment --> diagnostic or fragment 70 # file name --> file, path or file object 71 # 72 # Custom comments are supported in parenthesis i.e. 73 # 74 # number (classfile major version) 75 # 76 # These comments are used internally in order to generate an enum-like class declaration containing 77 # a method/field for each of the diagnostic keys listed here. Those methods/fields can then be used 78 # by javac code to build diagnostics in a type-safe fashion. 79 # 80 # In addition, these comments are verified by the jtreg test test/tools/javac/diags/MessageInfo, 81 # using info derived from the collected set of examples in test/tools/javac/diags/examples. 82 # MessageInfo can also be run as a standalone utility providing more facilities 83 # for manipulating this file. For more details, see MessageInfo.java. 84 85 ## 86 ## errors 87 ## 88 89 # 0: symbol 90 compiler.err.abstract.cant.be.instantiated=\ 91 {0} is abstract; cannot be instantiated 92 93 compiler.err.abstract.meth.cant.have.body=\ 94 abstract methods cannot have a body 95 96 # 0: kind name, 1: symbol 97 compiler.err.already.annotated=\ 98 {0} {1} has already been annotated 99 100 # 0: kind name, 1: symbol, 2: kind name, 3: symbol 101 compiler.err.already.defined=\ 102 {0} {1} is already defined in {2} {3} 103 104 # 0: kind name, 1: symbol, 2: kind name, 3: kind name, 4: symbol 105 compiler.err.already.defined.in.clinit=\ 106 {0} {1} is already defined in {2} of {3} {4} 107 108 # 0: symbol 109 compiler.err.already.defined.single.import=\ 110 a type with the same simple name is already defined by the single-type-import of {0} 111 112 # 0: symbol 113 compiler.err.already.defined.static.single.import=\ 114 a type with the same simple name is already defined by the static single-type-import of {0} 115 116 # 0: symbol 117 compiler.err.already.defined.this.unit=\ 118 {0} is already defined in this compilation unit 119 120 # 0: type, 1: list of name 121 compiler.err.annotation.missing.default.value=\ 122 annotation @{0} is missing a default value for the element ''{1}'' 123 124 # 0: type, 1: list of name 125 compiler.err.annotation.missing.default.value.1=\ 126 annotation @{0} is missing default values for elements {1} 127 128 # 0: type 129 compiler.err.annotation.not.valid.for.type=\ 130 annotation not valid for an element of type {0} 131 132 compiler.err.annotation.type.not.applicable=\ 133 annotation type not applicable to this kind of declaration 134 135 # 0: type 136 compiler.err.annotation.type.not.applicable.to.type=\ 137 annotation @{0} not applicable in this type context 138 139 compiler.err.annotation.value.must.be.annotation=\ 140 annotation value must be an annotation 141 142 compiler.err.annotation.value.must.be.class.literal=\ 143 annotation value must be a class literal 144 145 compiler.err.annotation.value.must.be.name.value=\ 146 annotation values must be of the form ''name=value'' 147 148 compiler.err.annotation.value.not.allowable.type=\ 149 annotation value not of an allowable type 150 151 compiler.err.expression.not.allowable.as.annotation.value=\ 152 expression not allowed as annotation value 153 154 compiler.err.anon.class.impl.intf.no.args=\ 155 anonymous class implements interface; cannot have arguments 156 157 compiler.err.anon.class.impl.intf.no.typeargs=\ 158 anonymous class implements interface; cannot have type arguments 159 160 compiler.err.anon.class.impl.intf.no.qual.for.new=\ 161 anonymous class implements interface; cannot have qualifier for new 162 163 compiler.err.cant.inherit.from.anon=\ 164 cannot inherit from anonymous class 165 166 # 0: symbol, 1: symbol, 2: symbol 167 compiler.err.array.and.varargs=\ 168 cannot declare both {0} and {1} in {2} 169 170 compiler.err.array.dimension.missing=\ 171 array dimension missing 172 173 compiler.err.illegal.array.creation.both.dimension.and.initialization=\ 174 array creation with both dimension expression and initialization is illegal 175 176 # 0: type 177 compiler.err.array.req.but.found=\ 178 array required, but {0} found 179 180 compiler.err.attribute.value.must.be.constant=\ 181 element value must be a constant expression 182 183 # 0: string (statement type) 184 compiler.err.bad.initializer=\ 185 bad initializer for {0} 186 187 compiler.err.break.outside.switch.loop=\ 188 break outside switch or loop 189 190 compiler.err.break.missing.value=\ 191 break is missing a value to return from switch expression 192 193 compiler.err.break.outside.switch.expression=\ 194 break is jumping outside of the enclosing switch expression 195 196 compiler.err.continue.outside.switch.expression=\ 197 continue is jumping outside of the enclosing switch expression 198 199 compiler.err.return.outside.switch.expression=\ 200 return is returning outside of the enclosing switch expression 201 202 # 0: name 203 compiler.err.break.ambiguous.target=\ 204 {0} is ambiguously both a valid expression and a valid label 205 206 compiler.err.break.expr.not.immediate=\ 207 expression break not immediately enclosed by a switch expression 208 209 compiler.err.break.complex.value.no.switch.expression=\ 210 value break outside of switch expression 211 212 compiler.err.switch.expression.empty=\ 213 switch expression does not have any case clauses 214 215 # 0: name 216 compiler.err.call.must.be.first.stmt.in.ctor=\ 217 call to {0} must be first statement in constructor 218 219 # 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 220 compiler.err.cant.apply.symbol=\ 221 {0} {1} in {4} {5} cannot be applied to given types;\n\ 222 required: {2}\n\ 223 found: {3}\n\ 224 reason: {6} 225 226 # 0: symbol kind, 1: name, 2: list of type 227 compiler.err.cant.apply.symbols=\ 228 no suitable {0} found for {1}({2}) 229 230 # 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 231 compiler.misc.cant.apply.symbol=\ 232 {0} {1} in {4} {5} cannot be applied to given types\n\ 233 required: {2}\n\ 234 found: {3}\n\ 235 reason: {6} 236 237 # 0: symbol kind, 1: name, 2: list of type 238 compiler.misc.cant.apply.symbols=\ 239 no suitable {0} found for {1}({2}) 240 241 # 0: kind name, 1: symbol 242 compiler.misc.no.abstracts=\ 243 no abstract method found in {0} {1} 244 245 # 0: kind name, 1: symbol 246 compiler.misc.incompatible.abstracts=\ 247 multiple non-overriding abstract methods found in {0} {1} 248 249 compiler.err.bad.functional.intf.anno=\ 250 Unexpected @FunctionalInterface annotation 251 252 # 0: message segment 253 compiler.err.bad.functional.intf.anno.1=\ 254 Unexpected @FunctionalInterface annotation\n\ 255 {0} 256 257 # 0: message segment 258 compiler.err.anonymous.diamond.method.does.not.override.superclass=\ 259 method does not override or implement a method from a supertype\n\ 260 {0} 261 262 # 0: symbol 263 compiler.misc.not.a.functional.intf=\ 264 {0} is not a functional interface 265 266 # 0: symbol, 1: message segment 267 compiler.misc.not.a.functional.intf.1=\ 268 {0} is not a functional interface\n\ 269 {1} 270 271 # 0: type, 1: kind name, 2: symbol 272 compiler.misc.invalid.generic.lambda.target=\ 273 invalid functional descriptor for lambda expression\n\ 274 method {0} in {1} {2} is generic 275 276 # 0: kind name, 1: symbol 277 compiler.misc.incompatible.descs.in.functional.intf=\ 278 incompatible function descriptors found in {0} {1} 279 280 # 0: name, 1: list of type, 2: type, 3: list of type 281 compiler.misc.descriptor=\ 282 descriptor: {2} {0}({1}) 283 284 # 0: name, 1: list of type, 2: type, 3: list of type 285 compiler.misc.descriptor.throws=\ 286 descriptor: {2} {0}({1}) throws {3} 287 288 # 0: type 289 compiler.misc.no.suitable.functional.intf.inst=\ 290 cannot infer functional interface descriptor for {0} 291 292 # 0: message segment 293 compiler.misc.bad.intersection.target.for.functional.expr=\ 294 bad intersection type target for lambda or method reference\n\ 295 {0} 296 297 # 0: symbol or type 298 compiler.misc.not.an.intf.component=\ 299 component type {0} is not an interface 300 301 # 0: kind name, 1: message segment 302 compiler.err.invalid.mref=\ 303 invalid {0} reference\n\ 304 {1} 305 306 # 0: kind name, 1: message segment 307 compiler.misc.invalid.mref=\ 308 invalid {0} reference\n\ 309 {1} 310 311 compiler.misc.static.mref.with.targs=\ 312 parameterized qualifier on static method reference 313 314 # 0: symbol 315 compiler.err.cant.assign.val.to.final.var=\ 316 cannot assign a value to final variable {0} 317 318 compiler.err.cant.assign.val.to.this=\ 319 cannot assign to ''this'' 320 321 # 0: symbol, 1: message segment 322 compiler.err.cant.ref.non.effectively.final.var=\ 323 local variables referenced from {1} must be final or effectively final 324 325 compiler.err.try.with.resources.expr.needs.var=\ 326 the try-with-resources resource must either be a variable declaration or an expression denoting \ 327 a reference to a final or effectively final variable 328 329 # 0: symbol 330 compiler.err.try.with.resources.expr.effectively.final.var=\ 331 variable {0} used as a try-with-resources resource neither final nor effectively final 332 333 334 compiler.misc.lambda=\ 335 a lambda expression 336 337 compiler.misc.inner.cls=\ 338 an inner class 339 340 # 0: type 341 compiler.err.cant.deref=\ 342 {0} cannot be dereferenced 343 344 compiler.err.cant.extend.intf.annotation=\ 345 ''extends'' not allowed for @interfaces 346 347 compiler.err.annotation.decl.not.allowed.here=\ 348 annotation type declaration not allowed here 349 350 # 0: symbol 351 compiler.err.cant.inherit.from.final=\ 352 cannot inherit from final {0} 353 354 # 0: symbol or string 355 compiler.err.cant.ref.before.ctor.called=\ 356 cannot reference {0} before supertype constructor has been called 357 358 compiler.err.cant.select.static.class.from.param.type=\ 359 cannot select a static class from a parameterized type 360 361 # 0: symbol, 1: string, 2: string 362 compiler.err.cant.inherit.diff.arg=\ 363 {0} cannot be inherited with different arguments: <{1}> and <{2}> 364 365 compiler.err.catch.without.try=\ 366 ''catch'' without ''try'' 367 368 # 0: kind name, 1: symbol 369 compiler.err.clash.with.pkg.of.same.name=\ 370 {0} {1} clashes with package of same name 371 372 compiler.err.class.not.allowed=\ 373 class, interface or enum declaration not allowed here 374 375 compiler.err.const.expr.req=\ 376 constant expression required 377 378 compiler.err.cont.outside.loop=\ 379 continue outside of loop 380 381 # 0: symbol or type 382 compiler.err.cyclic.inheritance=\ 383 cyclic inheritance involving {0} 384 385 # 0: symbol 386 compiler.err.cyclic.annotation.element=\ 387 type of element {0} is cyclic 388 389 # 0: symbol 390 compiler.err.call.to.super.not.allowed.in.enum.ctor=\ 391 call to super not allowed in enum constructor 392 393 # 0: type 394 compiler.err.no.superclass=\ 395 {0} has no superclass. 396 397 # 0: symbol, 1: type, 2: symbol, 3: type, 4: type 398 compiler.err.concrete.inheritance.conflict=\ 399 methods {0} from {1} and {2} from {3} are inherited with the same signature 400 401 compiler.err.default.allowed.in.intf.annotation.member=\ 402 default value only allowed in an annotation type declaration 403 404 # 0: symbol 405 compiler.err.doesnt.exist=\ 406 package {0} does not exist 407 408 # 0: type 409 compiler.err.duplicate.annotation.invalid.repeated=\ 410 annotation {0} is not a valid repeatable annotation 411 412 # 0: name, 1: type 413 compiler.err.duplicate.annotation.member.value=\ 414 duplicate element ''{0}'' in annotation @{1}. 415 416 # 0: type 417 compiler.err.duplicate.annotation.missing.container=\ 418 {0} is not a repeatable annotation type 419 420 # 0: symbol 421 compiler.err.invalid.repeatable.annotation=\ 422 duplicate annotation: {0} is annotated with an invalid @Repeatable annotation 423 424 # 0: symbol or type 425 compiler.err.invalid.repeatable.annotation.no.value=\ 426 {0} is not a valid @Repeatable, no value element method declared 427 428 # 0: type, 1: number 429 compiler.err.invalid.repeatable.annotation.multiple.values=\ 430 {0} is not a valid @Repeatable, {1} element methods named ''value'' declared 431 432 # 0: type 433 compiler.err.invalid.repeatable.annotation.invalid.value=\ 434 {0} is not a valid @Repeatable: invalid value element 435 436 # 0: symbol or type, 1: type, 2: type 437 compiler.err.invalid.repeatable.annotation.value.return=\ 438 containing annotation type ({0}) must declare an element named ''value'' of type {2} 439 440 # 0: symbol or type, 1: symbol 441 compiler.err.invalid.repeatable.annotation.elem.nondefault=\ 442 containing annotation type ({0}) does not have a default value for element {1} 443 444 # 0: symbol, 1: string, 2: symbol, 3: string 445 compiler.err.invalid.repeatable.annotation.retention=\ 446 retention of containing annotation type ({0}) is shorter than the retention of repeatable annotation type ({2}) 447 448 # 0: symbol, 1: symbol 449 compiler.err.invalid.repeatable.annotation.not.documented=\ 450 repeatable annotation type ({1}) is @Documented while containing annotation type ({0}) is not 451 452 # 0: symbol, 1: symbol 453 compiler.err.invalid.repeatable.annotation.not.inherited=\ 454 repeatable annotation type ({1}) is @Inherited while containing annotation type ({0}) is not 455 456 # 0: symbol, 1: symbol 457 compiler.err.invalid.repeatable.annotation.incompatible.target=\ 458 containing annotation type ({0}) is applicable to more targets than repeatable annotation type ({1}) 459 460 # 0: symbol 461 compiler.err.invalid.repeatable.annotation.repeated.and.container.present=\ 462 container {0} must not be present at the same time as the element it contains 463 464 # 0: type, 1: symbol 465 compiler.err.invalid.repeatable.annotation.not.applicable=\ 466 container {0} is not applicable to element {1} 467 468 # 0: type 469 compiler.err.invalid.repeatable.annotation.not.applicable.in.context=\ 470 container {0} is not applicable in this type context 471 472 # 0: name 473 compiler.err.duplicate.class=\ 474 duplicate class: {0} 475 476 # 0: name, 1: name 477 compiler.err.same.binary.name=\ 478 classes: {0} and {1} have the same binary name 479 480 compiler.err.duplicate.case.label=\ 481 duplicate case label 482 483 compiler.err.duplicate.default.label=\ 484 duplicate default label 485 486 compiler.err.else.without.if=\ 487 ''else'' without ''if'' 488 489 compiler.err.empty.char.lit=\ 490 empty character literal 491 492 # 0: symbol 493 compiler.err.encl.class.required=\ 494 an enclosing instance that contains {0} is required 495 496 compiler.err.enum.annotation.must.be.enum.constant=\ 497 an enum annotation value must be an enum constant 498 499 compiler.err.enum.cant.be.instantiated=\ 500 enum types may not be instantiated 501 502 compiler.err.enum.label.must.be.unqualified.enum=\ 503 an enum switch case label must be the unqualified name of an enumeration constant 504 505 compiler.err.enum.no.subclassing=\ 506 classes cannot directly extend java.lang.Enum 507 508 compiler.err.enum.types.not.extensible=\ 509 enum types are not extensible 510 511 compiler.err.enum.no.finalize=\ 512 enums cannot have finalize methods 513 514 # 0: file name, 1: string 515 compiler.err.error.reading.file=\ 516 error reading {0}; {1} 517 518 # 0: type 519 compiler.err.except.already.caught=\ 520 exception {0} has already been caught 521 522 # 0: type 523 compiler.err.except.never.thrown.in.try=\ 524 exception {0} is never thrown in body of corresponding try statement 525 526 # 0: symbol 527 compiler.err.final.parameter.may.not.be.assigned=\ 528 final parameter {0} may not be assigned 529 530 # 0: symbol 531 compiler.err.try.resource.may.not.be.assigned=\ 532 auto-closeable resource {0} may not be assigned 533 534 # 0: symbol 535 compiler.err.multicatch.parameter.may.not.be.assigned=\ 536 multi-catch parameter {0} may not be assigned 537 538 # 0: type, 1: type 539 compiler.err.multicatch.types.must.be.disjoint=\ 540 Alternatives in a multi-catch statement cannot be related by subclassing\n\ 541 Alternative {0} is a subclass of alternative {1} 542 543 compiler.err.finally.without.try=\ 544 ''finally'' without ''try'' 545 546 # 0: type, 1: message segment 547 compiler.err.foreach.not.applicable.to.type=\ 548 for-each not applicable to expression type\n\ 549 required: {1}\n\ 550 found: {0} 551 552 compiler.err.fp.number.too.large=\ 553 floating point number too large 554 555 compiler.err.fp.number.too.small=\ 556 floating point number too small 557 558 compiler.err.generic.array.creation=\ 559 generic array creation 560 561 compiler.err.generic.throwable=\ 562 a generic class may not extend java.lang.Throwable 563 564 # 0: symbol 565 compiler.err.icls.cant.have.static.decl=\ 566 Illegal static declaration in inner class {0}\n\ 567 modifier \''static\'' is only allowed in constant variable declarations 568 569 # 0: string 570 compiler.err.illegal.char=\ 571 illegal character: ''{0}'' 572 573 # 0: string, 1: string 574 compiler.err.illegal.char.for.encoding=\ 575 unmappable character (0x{0}) for encoding {1} 576 577 # 0: set of flag, 1: set of flag 578 compiler.err.illegal.combination.of.modifiers=\ 579 illegal combination of modifiers: {0} and {1} 580 581 compiler.err.illegal.enum.static.ref=\ 582 illegal reference to static field from initializer 583 584 compiler.err.illegal.esc.char=\ 585 illegal escape character 586 587 compiler.err.illegal.forward.ref=\ 588 illegal forward reference 589 590 # 0: symbol, 1: object 591 compiler.err.not.in.profile=\ 592 {0} is not available in profile ''{1}'' 593 594 # 0: symbol 595 compiler.warn.forward.ref=\ 596 reference to variable ''{0}'' before it has been initialized 597 598 compiler.err.illegal.self.ref=\ 599 self-reference in initializer 600 601 # 0: symbol 602 compiler.warn.self.ref=\ 603 self-reference in initializer of variable ''{0}'' 604 605 compiler.err.illegal.generic.type.for.instof=\ 606 illegal generic type for instanceof 607 608 # 0: type 609 compiler.err.illegal.initializer.for.type=\ 610 illegal initializer for {0} 611 612 compiler.err.illegal.line.end.in.char.lit=\ 613 illegal line end in character literal 614 615 compiler.err.illegal.nonascii.digit=\ 616 illegal non-ASCII digit 617 618 compiler.err.illegal.underscore=\ 619 illegal underscore 620 621 compiler.err.illegal.dot=\ 622 illegal ''.'' 623 624 # 0: symbol 625 compiler.err.illegal.qual.not.icls=\ 626 illegal qualifier; {0} is not an inner class 627 628 compiler.err.illegal.start.of.expr=\ 629 illegal start of expression 630 631 compiler.err.illegal.start.of.stmt=\ 632 illegal start of statement 633 634 compiler.err.illegal.start.of.type=\ 635 illegal start of type 636 637 compiler.err.illegal.parenthesized.expression=\ 638 illegal parenthesized expression 639 640 compiler.err.illegal.unicode.esc=\ 641 illegal unicode escape 642 643 # 0: symbol 644 compiler.err.import.requires.canonical=\ 645 import requires canonical name for {0} 646 647 compiler.err.improperly.formed.type.param.missing=\ 648 improperly formed type, some parameters are missing 649 650 compiler.err.improperly.formed.type.inner.raw.param=\ 651 improperly formed type, type arguments given on a raw type 652 653 # 0: type, 1: type 654 compiler.err.incomparable.types=\ 655 incomparable types: {0} and {1} 656 657 # 0: string 658 compiler.err.int.number.too.large=\ 659 integer number too large 660 661 compiler.err.intf.annotation.members.cant.have.params=\ 662 elements in annotation type declarations cannot declare formal parameters 663 664 # 0: symbol 665 compiler.err.intf.annotation.cant.have.type.params=\ 666 annotation type {0} cannot be generic 667 668 compiler.err.intf.annotation.members.cant.have.type.params=\ 669 elements in annotation type declarations cannot be generic methods 670 671 # 0: symbol, 1: type 672 compiler.err.intf.annotation.member.clash=\ 673 annotation type {1} declares an element with the same name as method {0} 674 675 compiler.err.intf.expected.here=\ 676 interface expected here 677 678 compiler.err.intf.meth.cant.have.body=\ 679 interface abstract methods cannot have body 680 681 compiler.err.invalid.annotation.member.type=\ 682 invalid type for annotation type element 683 684 compiler.err.invalid.binary.number=\ 685 binary numbers must contain at least one binary digit 686 687 compiler.err.invalid.hex.number=\ 688 hexadecimal numbers must contain at least one hexadecimal digit 689 690 compiler.err.invalid.meth.decl.ret.type.req=\ 691 invalid method declaration; return type required 692 693 compiler.err.varargs.and.old.array.syntax=\ 694 legacy array notation not allowed on variable-arity parameter 695 696 compiler.err.varargs.and.receiver =\ 697 varargs notation not allowed on receiver parameter 698 699 compiler.err.varargs.must.be.last =\ 700 varargs parameter must be the last parameter 701 702 compiler.err.array.and.receiver =\ 703 legacy array notation not allowed on receiver parameter 704 705 compiler.err.wrong.receiver =\ 706 wrong receiver parameter name 707 708 compiler.err.variable.not.allowed=\ 709 variable declaration not allowed here 710 711 # 0: name 712 compiler.err.label.already.in.use=\ 713 label {0} already in use 714 715 # 0: symbol 716 compiler.err.local.var.accessed.from.icls.needs.final=\ 717 local variable {0} is accessed from within inner class; needs to be declared final 718 719 compiler.err.local.enum=\ 720 enum types must not be local 721 722 compiler.err.cannot.create.array.with.type.arguments=\ 723 cannot create array with type arguments 724 725 compiler.err.cannot.create.array.with.diamond=\ 726 cannot create array with ''<>'' 727 728 compiler.err.invalid.module.directive=\ 729 module directive keyword or ''}'' expected 730 731 # 732 # limits. We don't give the limits in the diagnostic because we expect 733 # them to change, yet we want to use the same diagnostic. These are all 734 # detected during code generation. 735 # 736 compiler.err.limit.code=\ 737 code too large 738 739 compiler.err.limit.code.too.large.for.try.stmt=\ 740 code too large for try statement 741 742 compiler.err.limit.dimensions=\ 743 array type has too many dimensions 744 745 compiler.err.limit.locals=\ 746 too many local variables 747 748 compiler.err.limit.parameters=\ 749 too many parameters 750 751 compiler.err.limit.pool=\ 752 too many constants 753 754 compiler.err.limit.pool.in.class=\ 755 too many constants in class {0} 756 757 compiler.err.limit.stack=\ 758 code requires too much stack 759 760 compiler.err.limit.string=\ 761 constant string too long 762 763 # 0: string 764 compiler.err.limit.string.overflow=\ 765 UTF8 representation for string \"{0}...\" is too long for the constant pool 766 767 compiler.err.malformed.fp.lit=\ 768 malformed floating point literal 769 770 compiler.err.method.does.not.override.superclass=\ 771 method does not override or implement a method from a supertype 772 773 compiler.err.static.methods.cannot.be.annotated.with.override=\ 774 static methods cannot be annotated with @Override 775 776 compiler.err.missing.meth.body.or.decl.abstract=\ 777 missing method body, or declare abstract 778 779 compiler.err.missing.ret.stmt=\ 780 missing return statement 781 782 # 0: type 783 compiler.misc.missing.ret.val=\ 784 missing return value 785 786 compiler.misc.unexpected.ret.val=\ 787 unexpected return value 788 789 # 0: set of flag 790 compiler.err.mod.not.allowed.here=\ 791 modifier {0} not allowed here 792 793 # 0: name 794 compiler.err.modifier.not.allowed.here=\ 795 modifier {0} not allowed here 796 797 compiler.err.intf.not.allowed.here=\ 798 interface not allowed here 799 800 compiler.err.enums.must.be.static=\ 801 enum declarations allowed only in static contexts 802 803 # 0: symbol, 1: symbol 804 compiler.err.name.clash.same.erasure=\ 805 name clash: {0} and {1} have the same erasure 806 807 # 0: name, 1: list of type, 2: symbol, 3: name, 4: list of type, 5: symbol 808 compiler.err.name.clash.same.erasure.no.override=\ 809 name clash: {0}({1}) in {2} and {3}({4}) in {5} have the same erasure, yet neither overrides the other 810 811 # 0: string, 1: name, 2: name, 3: list of type, 4: symbol, 5: name, 6: list of type, 7: symbol 812 compiler.err.name.clash.same.erasure.no.override.1=\ 813 name clash: {0} {1} has two methods with the same erasure, yet neither overrides the other\n\ 814 first method: {2}({3}) in {4}\n\ 815 second method: {5}({6}) in {7} 816 817 # 0: symbol, 1: symbol, 2: symbol, 3: symbol 818 compiler.err.name.clash.same.erasure.no.hide=\ 819 name clash: {0} in {1} and {2} in {3} have the same erasure, yet neither hides the other 820 821 compiler.err.name.reserved.for.internal.use=\ 822 {0} is reserved for internal use 823 824 compiler.err.native.meth.cant.have.body=\ 825 native methods cannot have a body 826 827 828 # 0: message segment 829 compiler.misc.incompatible.type.in.conditional=\ 830 bad type in conditional expression\n\ 831 {0} 832 833 compiler.misc.conditional.target.cant.be.void=\ 834 target-type for conditional expression cannot be void 835 836 compiler.misc.switch.expression.target.cant.be.void=\ 837 target-type for switch expression cannot be void 838 839 # 0: message segment 840 compiler.misc.incompatible.type.in.switch.expression=\ 841 bad type in switch expression\n\ 842 {0} 843 844 # 0: message segment 845 compiler.misc.incompatible.ret.type.in.lambda=\ 846 bad return type in lambda expression\n\ 847 {0} 848 849 compiler.misc.stat.expr.expected=\ 850 lambda body is not compatible with a void functional interface\n\ 851 (consider using a block lambda body, or use a statement expression instead) 852 853 # 0: message segment 854 compiler.misc.incompatible.ret.type.in.mref=\ 855 bad return type in method reference\n\ 856 {0} 857 858 compiler.err.lambda.body.neither.value.nor.void.compatible=\ 859 lambda body is neither value nor void compatible 860 861 # 0: list of type 862 compiler.err.incompatible.thrown.types.in.mref=\ 863 incompatible thrown types {0} in functional expression 864 865 compiler.misc.incompatible.arg.types.in.lambda=\ 866 incompatible parameter types in lambda expression 867 868 compiler.misc.incompatible.arg.types.in.mref=\ 869 incompatible parameter types in method reference 870 871 compiler.err.new.not.allowed.in.annotation=\ 872 ''new'' not allowed in an annotation 873 874 # 0: name, 1: type 875 compiler.err.no.annotation.member=\ 876 no annotation member {0} in {1} 877 878 # 0: symbol 879 compiler.err.no.encl.instance.of.type.in.scope=\ 880 no enclosing instance of type {0} is in scope 881 882 compiler.err.no.intf.expected.here=\ 883 no interface expected here 884 885 compiler.err.no.match.entry=\ 886 {0} has no match in entry in {1}; required {2} 887 888 # 0: type 889 compiler.err.not.annotation.type=\ 890 {0} is not an annotation type 891 892 # 0: symbol, 1: symbol, 2: message segment 893 compiler.err.not.def.access.package.cant.access=\ 894 {0} is not visible\n\ 895 ({2}) 896 897 # 0: symbol, 1: symbol, 2: message segment 898 compiler.misc.not.def.access.package.cant.access=\ 899 {0} is not visible\n\ 900 ({2}) 901 902 # 0: symbol, 1: message segment 903 compiler.err.package.not.visible=\ 904 package {0} is not visible\n\ 905 ({1}) 906 907 # 0: symbol, 1: message segment 908 compiler.misc.package.not.visible=\ 909 package {0} is not visible\n\ 910 ({1}) 911 912 # {0} - current module 913 # {1} - package in which the invisible class is declared 914 # {2} - module in which {1} is declared 915 # 0: symbol, 1: symbol, 2: symbol 916 compiler.misc.not.def.access.does.not.read=\ 917 package {1} is declared in module {2}, but module {0} does not read it 918 919 # {0} - package in which the invisible class is declared 920 # {1} - module in which {0} is declared 921 # 0: symbol, 1: symbol 922 compiler.misc.not.def.access.does.not.read.from.unnamed=\ 923 package {0} is declared in module {1}, which is not in the module graph 924 925 # {0} - package in which the invisible class is declared 926 # {1} - current module 927 # 0: symbol, 1: symbol 928 compiler.misc.not.def.access.does.not.read.unnamed=\ 929 package {0} is declared in the unnamed module, but module {0} does not read it 930 931 # {0} - package in which the invisible class is declared 932 # {1} - module in which {0} is declared 933 # 0: symbol, 1: symbol 934 compiler.misc.not.def.access.not.exported=\ 935 package {0} is declared in module {1}, which does not export it 936 937 # {0} - package in which the invisible class is declared 938 # {1} - module in which {0} is declared 939 # 0: symbol, 1: symbol 940 compiler.misc.not.def.access.not.exported.from.unnamed=\ 941 package {0} is declared in module {1}, which does not export it 942 943 # {0} - package in which the invisible class is declared 944 # {1} - module in which {0} is declared 945 # {2} - current module 946 # 0: symbol, 1: symbol, 2: symbol 947 compiler.misc.not.def.access.not.exported.to.module=\ 948 package {0} is declared in module {1}, which does not export it to module {2} 949 950 # {0} - package in which the invisible class is declared 951 # {1} - module in which {0} is declared 952 # 0: symbol, 1: symbol 953 compiler.misc.not.def.access.not.exported.to.module.from.unnamed=\ 954 package {0} is declared in module {1}, which does not export it to the unnamed module 955 956 # 0: symbol, 1: symbol 957 compiler.err.not.def.access.class.intf.cant.access=\ 958 {1}.{0} is defined in an inaccessible class or interface 959 960 # 0: symbol, 1: symbol 961 compiler.misc.not.def.access.class.intf.cant.access=\ 962 {1}.{0} is defined in an inaccessible class or interface 963 964 # 0: symbol, 1: symbol, 2: symbol, 3: message segment 965 compiler.err.not.def.access.class.intf.cant.access.reason=\ 966 {1}.{0} in package {2} is not accessible\n\ 967 ({3}) 968 969 # 0: symbol, 1: symbol, 2: symbol, 3: message segment 970 compiler.misc.not.def.access.class.intf.cant.access.reason=\ 971 {1}.{0} in package {2} is not accessible\n\ 972 ({3}) 973 974 # 0: symbol, 1: list of type, 2: type 975 compiler.misc.cant.access.inner.cls.constr=\ 976 cannot access constructor {0}({1})\n\ 977 an enclosing instance of type {2} is not in scope 978 979 # 0: symbol, 1: symbol 980 compiler.err.not.def.public.cant.access=\ 981 {0} is not public in {1}; cannot be accessed from outside package 982 983 # 0: symbol, 1: symbol 984 compiler.err.not.def.public=\ 985 {0} is not public in {1} 986 987 # 0: symbol, 1: symbol 988 compiler.misc.not.def.public.cant.access=\ 989 {0} is not public in {1}; cannot be accessed from outside package 990 991 # 0: name 992 compiler.err.not.loop.label=\ 993 not a loop label: {0} 994 995 compiler.err.not.stmt=\ 996 not a statement 997 998 # 0: symbol 999 compiler.err.not.encl.class=\ 1000 not an enclosing class: {0} 1001 1002 # 0: name, 1: type 1003 compiler.err.operator.cant.be.applied=\ 1004 bad operand type {1} for unary operator ''{0}'' 1005 1006 # 0: name, 1: type, 2: type 1007 compiler.err.operator.cant.be.applied.1=\ 1008 bad operand types for binary operator ''{0}''\n\ 1009 first type: {1}\n\ 1010 second type: {2} 1011 1012 compiler.err.pkg.annotations.sb.in.package-info.java=\ 1013 package annotations should be in file package-info.java 1014 1015 compiler.err.no.pkg.in.module-info.java=\ 1016 package declarations not allowed in file module-info.java 1017 1018 # 0: symbol 1019 compiler.err.pkg.clashes.with.class.of.same.name=\ 1020 package {0} clashes with class of same name 1021 1022 compiler.err.warnings.and.werror=\ 1023 warnings found and -Werror specified 1024 1025 # Errors related to annotation processing 1026 1027 # 0: symbol, 1: message segment, 2: string (stack-trace) 1028 compiler.err.proc.cant.access=\ 1029 cannot access {0}\n\ 1030 {1}\n\ 1031 Consult the following stack trace for details.\n\ 1032 {2} 1033 1034 # 0: symbol, 1: message segment 1035 compiler.err.proc.cant.access.1=\ 1036 cannot access {0}\n\ 1037 {1} 1038 1039 # 0: string 1040 compiler.err.proc.cant.find.class=\ 1041 Could not find class file for ''{0}''. 1042 1043 # Print a client-generated error message; assumed to be localized, no translation required 1044 # 0: string 1045 compiler.err.proc.messager=\ 1046 {0} 1047 1048 # 0: string 1049 compiler.misc.exception.message=\ 1050 {0} 1051 1052 compiler.misc.user.selected.completion.failure=\ 1053 user-selected completion failure by class name 1054 1055 # 0: collection of string 1056 compiler.err.proc.no.explicit.annotation.processing.requested=\ 1057 Class names, ''{0}'', are only accepted if annotation processing is explicitly requested 1058 1059 compiler.err.proc.no.service=\ 1060 A ServiceLoader was not usable and is required for annotation processing. 1061 1062 # 0: string, 1: string 1063 compiler.err.proc.processor.bad.option.name=\ 1064 Bad option name ''{0}'' provided by processor ''{1}'' 1065 1066 # 0: string 1067 compiler.err.proc.processor.cant.instantiate=\ 1068 Could not instantiate an instance of processor ''{0}'' 1069 1070 # 0: string 1071 compiler.err.proc.processor.not.found=\ 1072 Annotation processor ''{0}'' not found 1073 1074 # 0: string 1075 compiler.err.proc.processor.wrong.type=\ 1076 Annotation processor ''{0}'' does not implement javax.annotation.processing.Processor 1077 1078 compiler.err.proc.service.problem=\ 1079 Error creating a service loader to load Processors. 1080 1081 # 0: string 1082 compiler.err.proc.bad.config.file=\ 1083 Bad service configuration file, or exception thrown while constructing Processor object: {0} 1084 1085 compiler.err.proc.cant.create.loader=\ 1086 Could not create class loader for annotation processors: {0} 1087 1088 # 0: symbol 1089 compiler.err.qualified.new.of.static.class=\ 1090 qualified new of static class 1091 1092 compiler.err.recursive.ctor.invocation=\ 1093 recursive constructor invocation 1094 1095 # 0: name, 1: symbol kind, 2: symbol, 3: symbol, 4: symbol kind, 5: symbol, 6: symbol 1096 compiler.err.ref.ambiguous=\ 1097 reference to {0} is ambiguous\n\ 1098 both {1} {2} in {3} and {4} {5} in {6} match 1099 1100 # 0: name, 1: symbol kind, 2: symbol, 3: symbol, 4: symbol kind, 5: symbol, 6: symbol 1101 compiler.misc.ref.ambiguous=\ 1102 reference to {0} is ambiguous\n\ 1103 both {1} {2} in {3} and {4} {5} in {6} match 1104 1105 compiler.err.repeated.annotation.target=\ 1106 repeated annotation target 1107 1108 compiler.err.repeated.interface=\ 1109 repeated interface 1110 1111 compiler.err.repeated.modifier=\ 1112 repeated modifier 1113 1114 # 0: symbol, 1: set of modifier, 2: symbol 1115 compiler.err.report.access=\ 1116 {0} has {1} access in {2} 1117 1118 # 0: symbol, 1: set of modifier, 2: symbol 1119 compiler.misc.report.access=\ 1120 {0} has {1} access in {2} 1121 1122 compiler.err.ret.outside.meth=\ 1123 return outside method 1124 1125 compiler.err.signature.doesnt.match.supertype=\ 1126 signature does not match {0}; incompatible supertype 1127 1128 compiler.err.signature.doesnt.match.intf=\ 1129 signature does not match {0}; incompatible interfaces 1130 1131 # 0: symbol, 1: symbol, 2: symbol 1132 compiler.err.does.not.override.abstract=\ 1133 {0} is not abstract and does not override abstract method {1} in {2} 1134 1135 # 0: file object 1136 compiler.err.source.cant.overwrite.input.file=\ 1137 error writing source; cannot overwrite input file {0} 1138 1139 # 0: symbol 1140 compiler.err.stack.sim.error=\ 1141 Internal error: stack sim error on {0} 1142 1143 compiler.err.static.imp.only.classes.and.interfaces=\ 1144 static import only from classes and interfaces 1145 1146 compiler.err.string.const.req=\ 1147 constant string expression required 1148 1149 # 0: symbol, 1: fragment 1150 compiler.err.cannot.generate.class=\ 1151 error while generating class {0}\n\ 1152 ({1}) 1153 1154 # 0: symbol, 1: symbol 1155 compiler.misc.synthetic.name.conflict=\ 1156 the symbol {0} conflicts with a compiler-synthesized symbol in {1} 1157 1158 # 0: symbol, 1: type 1159 compiler.misc.illegal.signature=\ 1160 illegal signature attribute for type {1} 1161 1162 compiler.err.throws.not.allowed.in.intf.annotation=\ 1163 throws clause not allowed in @interface members 1164 1165 compiler.err.try.without.catch.finally.or.resource.decls=\ 1166 ''try'' without ''catch'', ''finally'' or resource declarations 1167 1168 # 0: symbol 1169 compiler.err.type.doesnt.take.params=\ 1170 type {0} does not take parameters 1171 1172 compiler.err.type.var.cant.be.deref=\ 1173 cannot select from a type variable 1174 1175 compiler.err.type.var.may.not.be.followed.by.other.bounds=\ 1176 a type variable may not be followed by other bounds 1177 1178 compiler.err.type.var.more.than.once=\ 1179 type variable {0} occurs more than once in result type of {1}; cannot be left uninstantiated 1180 1181 compiler.err.type.var.more.than.once.in.result=\ 1182 type variable {0} occurs more than once in type of {1}; cannot be left uninstantiated 1183 1184 # 0: type, 1: type, 2: fragment 1185 compiler.err.types.incompatible=\ 1186 types {0} and {1} are incompatible;\n\ 1187 {2} 1188 1189 # 0: name, 1: list of type 1190 compiler.misc.incompatible.diff.ret=\ 1191 both define {0}({1}), but with unrelated return types 1192 1193 # 0: kind name, 1: type, 2: name, 3: list of type, 4: symbol, 5: symbol 1194 compiler.misc.incompatible.unrelated.defaults=\ 1195 {0} {1} inherits unrelated defaults for {2}({3}) from types {4} and {5} 1196 1197 # 0: kind name, 1: type, 2: name, 3: list of type, 4: symbol, 5: symbol 1198 compiler.misc.incompatible.abstract.default=\ 1199 {0} {1} inherits abstract and default for {2}({3}) from types {4} and {5} 1200 1201 # 0: name, 1: kind name, 2: symbol 1202 compiler.err.default.overrides.object.member=\ 1203 default method {0} in {1} {2} overrides a member of java.lang.Object 1204 1205 # 0: type 1206 compiler.err.illegal.static.intf.meth.call=\ 1207 illegal static interface method call\n\ 1208 the receiver expression should be replaced with the type qualifier ''{0}'' 1209 1210 # 0: symbol or type, 1: message segment 1211 compiler.err.illegal.default.super.call=\ 1212 bad type qualifier {0} in default super call\n\ 1213 {1} 1214 1215 # 0: symbol, 1: type 1216 compiler.misc.overridden.default=\ 1217 method {0} is overridden in {1} 1218 1219 # 0: symbol, 1: type or symbol 1220 compiler.misc.redundant.supertype=\ 1221 redundant interface {0} is extended by {1} 1222 1223 compiler.err.unclosed.char.lit=\ 1224 unclosed character literal 1225 1226 compiler.err.unclosed.comment=\ 1227 unclosed comment 1228 1229 compiler.err.unclosed.str.lit=\ 1230 unclosed string literal 1231 1232 # 0: string 1233 compiler.err.unsupported.encoding=\ 1234 unsupported encoding: {0} 1235 1236 compiler.err.io.exception=\ 1237 error reading source file: {0} 1238 1239 # 0: name 1240 compiler.err.undef.label=\ 1241 undefined label: {0} 1242 1243 compiler.err.illegal.ref.to.var.type=\ 1244 illegal reference to restricted type ''var'' 1245 1246 compiler.err.var.not.allowed=\ 1247 ''var'' not allowed here\n\ 1248 as of release 10, ''var'' is a restricted local variable type and cannot be used for type declarations 1249 1250 compiler.warn.var.not.allowed=\ 1251 as of release 10, ''var'' is a restricted local variable type and cannot be used for type declarations or as the element type of an array 1252 1253 # 0: name (variable), 1: message segment 1254 compiler.err.cant.infer.local.var.type=\ 1255 cannot infer type for local variable {0}\n\ 1256 ({1}) 1257 1258 compiler.err.var.not.allowed.here=\ 1259 ''var'' is not allowed here 1260 1261 compiler.err.var.not.allowed.array=\ 1262 ''var'' is not allowed as an element type of an array 1263 1264 compiler.err.var.not.allowed.compound=\ 1265 ''var'' is not allowed in a compound declaration 1266 1267 # 0: fragment 1268 compiler.err.invalid.lambda.parameter.declaration=\ 1269 invalid lambda parameter declaration\n\ 1270 ({0}) 1271 1272 compiler.misc.implicit.and.explicit.not.allowed=\ 1273 cannot mix implicitly-typed and explicitly-typed parameters 1274 1275 compiler.misc.var.and.explicit.not.allowed=\ 1276 cannot mix ''var'' and explicitly-typed parameters 1277 1278 compiler.misc.var.and.implicit.not.allowed=\ 1279 cannot mix ''var'' and implicitly-typed parameters 1280 1281 compiler.misc.local.cant.infer.null=\ 1282 variable initializer is ''null'' 1283 1284 compiler.misc.local.cant.infer.void=\ 1285 variable initializer is ''void'' 1286 1287 compiler.misc.local.missing.init=\ 1288 cannot use ''var'' on variable without initializer 1289 1290 compiler.misc.local.lambda.missing.target=\ 1291 lambda expression needs an explicit target-type 1292 1293 compiler.misc.local.mref.missing.target=\ 1294 method reference needs an explicit target-type 1295 1296 compiler.misc.local.array.missing.target=\ 1297 array initializer needs an explicit target-type 1298 1299 compiler.misc.local.self.ref=\ 1300 cannot use ''var'' on self-referencing variable 1301 1302 # 0: message segment, 1: unused 1303 compiler.err.cant.apply.diamond=\ 1304 cannot infer type arguments for {0} 1305 1306 # 0: message segment or type, 1: message segment 1307 compiler.err.cant.apply.diamond.1=\ 1308 cannot infer type arguments for {0}\n\ 1309 reason: {1} 1310 1311 # 0: message segment or type, 1: message segment 1312 compiler.misc.cant.apply.diamond.1=\ 1313 cannot infer type arguments for {0}\n\ 1314 reason: {1} 1315 1316 compiler.err.unreachable.stmt=\ 1317 unreachable statement 1318 1319 compiler.err.not.exhaustive=\ 1320 the switch expression does not cover all possible input values 1321 1322 compiler.err.initializer.must.be.able.to.complete.normally=\ 1323 initializer must be able to complete normally 1324 1325 compiler.err.initializer.not.allowed=\ 1326 initializers not allowed in interfaces 1327 1328 # 0: type 1329 compiler.err.unreported.exception.need.to.catch.or.throw=\ 1330 unreported exception {0}; must be caught or declared to be thrown 1331 1332 # 0: type 1333 compiler.err.unreported.exception.default.constructor=\ 1334 unreported exception {0} in default constructor 1335 1336 # 0: type, 1: name 1337 compiler.err.unreported.exception.implicit.close=\ 1338 unreported exception {0}; must be caught or declared to be thrown\n\ 1339 exception thrown from implicit call to close() on resource variable ''{1}'' 1340 1341 compiler.err.unsupported.cross.fp.lit=\ 1342 hexadecimal floating-point literals are not supported on this VM 1343 1344 compiler.err.void.not.allowed.here=\ 1345 ''void'' type not allowed here 1346 1347 # 0: string 1348 compiler.err.wrong.number.type.args=\ 1349 wrong number of type arguments; required {0} 1350 1351 # 0: symbol 1352 compiler.err.var.might.already.be.assigned=\ 1353 variable {0} might already have been assigned 1354 1355 # 0: symbol 1356 compiler.err.var.might.not.have.been.initialized=\ 1357 variable {0} might not have been initialized 1358 1359 # 0: symbol 1360 compiler.err.var.not.initialized.in.default.constructor=\ 1361 variable {0} not initialized in the default constructor 1362 1363 # 0: symbol 1364 compiler.err.var.might.be.assigned.in.loop=\ 1365 variable {0} might be assigned in loop 1366 1367 # 0: symbol, 1: message segment 1368 compiler.err.varargs.invalid.trustme.anno=\ 1369 Invalid {0} annotation. {1} 1370 1371 # 0: type 1372 compiler.misc.varargs.trustme.on.reifiable.varargs=\ 1373 Varargs element type {0} is reifiable. 1374 1375 # 0: symbol 1376 compiler.misc.varargs.trustme.on.non.varargs.meth=\ 1377 Method {0} is not a varargs method. 1378 1379 # 0: symbol 1380 compiler.misc.varargs.trustme.on.virtual.varargs=\ 1381 Instance method {0} is neither final nor private. 1382 1383 # 0: symbol 1384 compiler.misc.varargs.trustme.on.virtual.varargs.final.only=\ 1385 Instance method {0} is not final. 1386 1387 # 0: type, 1: symbol kind, 2: symbol 1388 compiler.misc.inaccessible.varargs.type=\ 1389 formal varargs element type {0} is not accessible from {1} {2} 1390 1391 # In the following string, {1} will always be the detail message from 1392 # java.io.IOException. 1393 # 0: symbol, 1: string 1394 compiler.err.class.cant.write=\ 1395 error while writing {0}: {1} 1396 1397 # In the following string, {0} is the name of the class in the Java source. 1398 # It really should be used two times.. 1399 # 0: kind name, 1: name 1400 compiler.err.class.public.should.be.in.file=\ 1401 {0} {1} is public, should be declared in a file named {1}.java 1402 1403 ## All errors which do not refer to a particular line in the source code are 1404 ## preceded by this string. 1405 compiler.err.error=\ 1406 error:\u0020 1407 1408 # The following error messages do not refer to a line in the source code. 1409 compiler.err.cant.read.file=\ 1410 cannot read: {0} 1411 1412 # 0: string 1413 compiler.err.plugin.not.found=\ 1414 plug-in not found: {0} 1415 1416 # 0: path 1417 compiler.warn.locn.unknown.file.on.module.path=\ 1418 unknown file on module path: {0} 1419 1420 1421 # 0: path 1422 compiler.err.locn.bad.module-info=\ 1423 problem reading module-info.class in {0} 1424 1425 # 0: path 1426 compiler.err.locn.cant.read.directory=\ 1427 cannot read directory {0} 1428 1429 # 0: path 1430 compiler.err.locn.cant.read.file=\ 1431 cannot read file {0} 1432 1433 # 0: path 1434 compiler.err.locn.cant.get.module.name.for.jar=\ 1435 cannot determine module name for {0} 1436 1437 # 0: path 1438 compiler.err.multi-module.outdir.cannot.be.exploded.module=\ 1439 in multi-module mode, the output directory cannot be an exploded module: {0} 1440 1441 # 0: path 1442 compiler.warn.outdir.is.in.exploded.module=\ 1443 the output directory is within an exploded module: {0} 1444 1445 # 0: file object 1446 compiler.err.locn.module-info.not.allowed.on.patch.path=\ 1447 module-info.class not allowed on patch path: {0} 1448 1449 # 0: string 1450 compiler.err.locn.invalid.arg.for.xpatch=\ 1451 invalid argument for --patch-module option: {0} 1452 1453 compiler.err.file.sb.on.source.or.patch.path.for.module=\ 1454 file should be on source path, or on patch path for module 1455 1456 ##### 1457 1458 # Fatal Errors 1459 1460 compiler.misc.fatal.err.no.java.lang=\ 1461 Fatal Error: Unable to find package java.lang in classpath or bootclasspath 1462 1463 # 0: name 1464 compiler.misc.fatal.err.cant.locate.meth=\ 1465 Fatal Error: Unable to find method {0} 1466 1467 # 0: name 1468 compiler.misc.fatal.err.cant.locate.field=\ 1469 Fatal Error: Unable to find field {0} 1470 1471 # 0: type 1472 compiler.misc.fatal.err.cant.locate.ctor=\ 1473 Fatal Error: Unable to find constructor for {0} 1474 1475 compiler.misc.fatal.err.cant.close=\ 1476 Fatal Error: Cannot close compiler resources 1477 1478 ##### 1479 1480 ## 1481 ## miscellaneous strings 1482 ## 1483 1484 compiler.misc.diamond.anonymous.methods.implicitly.override=\ 1485 (due to <>, every non-private method declared in this anonymous class must override or implement a method from a supertype) 1486 1487 compiler.misc.source.unavailable=\ 1488 (source unavailable) 1489 1490 compiler.misc.base.membership=\ 1491 all your base class are belong to us 1492 1493 # 0: string, 1: string, 2: boolean 1494 compiler.misc.x.print.processor.info=\ 1495 Processor {0} matches {1} and returns {2}. 1496 1497 # 0: number, 1: string, 2: set of symbol, 3: boolean 1498 compiler.misc.x.print.rounds=\ 1499 Round {0}:\n\tinput files: {1}\n\tannotations: {2}\n\tlast round: {3} 1500 1501 # 0: file name 1502 compiler.warn.file.from.future=\ 1503 Modification date is in the future for file {0} 1504 1505 ##### 1506 1507 ## The following string will appear before all messages keyed as: 1508 ## "compiler.note". 1509 1510 compiler.note.compressed.diags=\ 1511 Some messages have been simplified; recompile with -Xdiags:verbose to get full output 1512 1513 # 0: boolean, 1: symbol 1514 compiler.note.lambda.stat=\ 1515 Translating lambda expression\n\ 1516 alternate metafactory = {0}\n\ 1517 synthetic method = {1} 1518 1519 # 0: boolean, 1: unused 1520 compiler.note.mref.stat=\ 1521 Translating method reference\n\ 1522 alternate metafactory = {0}\n\ 1523 1524 # 0: boolean, 1: symbol 1525 compiler.note.mref.stat.1=\ 1526 Translating method reference\n\ 1527 alternate metafactory = {0}\n\ 1528 bridge method = {1} 1529 1530 compiler.note.note=\ 1531 Note:\u0020 1532 1533 # 0: file name 1534 compiler.note.deprecated.filename=\ 1535 {0} uses or overrides a deprecated API. 1536 1537 compiler.note.deprecated.plural=\ 1538 Some input files use or override a deprecated API. 1539 1540 # The following string may appear after one of the above deprecation 1541 # messages. 1542 compiler.note.deprecated.recompile=\ 1543 Recompile with -Xlint:deprecation for details. 1544 1545 # 0: file name 1546 compiler.note.deprecated.filename.additional=\ 1547 {0} has additional uses or overrides of a deprecated API. 1548 1549 compiler.note.deprecated.plural.additional=\ 1550 Some input files additionally use or override a deprecated API. 1551 1552 # 0: file name 1553 compiler.note.removal.filename=\ 1554 {0} uses or overrides a deprecated API that is marked for removal. 1555 1556 compiler.note.removal.plural=\ 1557 Some input files use or override a deprecated API that is marked for removal. 1558 1559 # The following string may appear after one of the above removal messages. 1560 compiler.note.removal.recompile=\ 1561 Recompile with -Xlint:removal for details. 1562 1563 # 0: file name 1564 compiler.note.removal.filename.additional=\ 1565 {0} has additional uses or overrides of a deprecated API that is marked for removal. 1566 1567 compiler.note.removal.plural.additional=\ 1568 Some input files additionally use or override a deprecated API that is marked for removal. 1569 1570 # 0: file name 1571 compiler.note.unchecked.filename=\ 1572 {0} uses unchecked or unsafe operations. 1573 1574 compiler.note.unchecked.plural=\ 1575 Some input files use unchecked or unsafe operations. 1576 1577 # The following string may appear after one of the above unchecked messages. 1578 compiler.note.unchecked.recompile=\ 1579 Recompile with -Xlint:unchecked for details. 1580 1581 # 0: file name 1582 compiler.note.unchecked.filename.additional=\ 1583 {0} has additional unchecked or unsafe operations. 1584 1585 compiler.note.unchecked.plural.additional=\ 1586 Some input files additionally use unchecked or unsafe operations. 1587 1588 # 0: file name 1589 compiler.note.preview.filename=\ 1590 {0} uses preview language features. 1591 1592 compiler.note.preview.plural=\ 1593 Some input files use preview language features. 1594 1595 # The following string may appear after one of the above deprecation 1596 # messages. 1597 compiler.note.preview.recompile=\ 1598 Recompile with -Xlint:preview for details. 1599 1600 # 0: file name 1601 compiler.note.preview.filename.additional=\ 1602 {0} has additional uses of preview language features. 1603 1604 compiler.note.preview.plural.additional=\ 1605 Some input files additionally use preview language features. 1606 1607 # Notes related to annotation processing 1608 1609 # Print a client-generated note; assumed to be localized, no translation required 1610 # 0: string 1611 compiler.note.proc.messager=\ 1612 {0} 1613 1614 # 0: string, 1: string, 2: string 1615 compiler.note.multiple.elements=\ 1616 Multiple elements named ''{1}'' in modules ''{2}'' were found by javax.lang.model.util.Elements.{0}. 1617 1618 ##### 1619 1620 # 0: number 1621 compiler.misc.count.error=\ 1622 {0} error 1623 1624 # 0: number 1625 compiler.misc.count.error.plural=\ 1626 {0} errors 1627 1628 # 0: number 1629 compiler.misc.count.warn=\ 1630 {0} warning 1631 1632 # 0: number 1633 compiler.misc.count.warn.plural=\ 1634 {0} warnings 1635 1636 compiler.misc.version.not.available=\ 1637 (version info not available) 1638 1639 ## extra output when using -verbose (JavaCompiler) 1640 1641 # 0: symbol 1642 compiler.misc.verbose.checking.attribution=\ 1643 [checking {0}] 1644 1645 # 0: string 1646 compiler.misc.verbose.parsing.done=\ 1647 [parsing completed {0}ms] 1648 1649 # 0: file name 1650 compiler.misc.verbose.parsing.started=\ 1651 [parsing started {0}] 1652 1653 # 0: string 1654 compiler.misc.verbose.total=\ 1655 [total {0}ms] 1656 1657 # 0: file name 1658 compiler.misc.verbose.wrote.file=\ 1659 [wrote {0}] 1660 1661 ## extra output when using -verbose (code/ClassReader) 1662 # 0: string 1663 compiler.misc.verbose.loading=\ 1664 [loading {0}] 1665 1666 # 0: string 1667 compiler.misc.verbose.sourcepath=\ 1668 [search path for source files: {0}] 1669 1670 # 0: string 1671 compiler.misc.verbose.classpath=\ 1672 [search path for class files: {0}] 1673 1674 ## extra output when using -prompt (util/Log) 1675 compiler.misc.resume.abort=\ 1676 R)esume, A)bort> 1677 1678 ##### 1679 1680 ## 1681 ## warnings 1682 ## 1683 1684 ## All warning messages are preceded by the following string. 1685 compiler.warn.warning=\ 1686 warning:\u0020 1687 1688 ## Warning messages may also include the following prefix to identify a 1689 ## lint option 1690 # 0: option name 1691 compiler.warn.lintOption=\ 1692 [{0}]\u0020 1693 1694 # 0: symbol 1695 compiler.warn.constant.SVUID=\ 1696 serialVersionUID must be constant in class {0} 1697 1698 # 0: path 1699 compiler.warn.dir.path.element.not.found=\ 1700 bad path element "{0}": no such directory 1701 1702 # 0: file name 1703 compiler.warn.dir.path.element.not.directory=\ 1704 bad path element "{0}": not a directory 1705 1706 compiler.warn.finally.cannot.complete=\ 1707 finally clause cannot complete normally 1708 1709 # 0: name 1710 compiler.warn.poor.choice.for.module.name=\ 1711 module name component {0} should avoid terminal digits 1712 1713 # 0: string 1714 compiler.warn.incubating.modules=\ 1715 using incubating module(s): {0} 1716 1717 # 0: symbol, 1: symbol 1718 compiler.warn.has.been.deprecated=\ 1719 {0} in {1} has been deprecated 1720 1721 # 0: symbol, 1: symbol 1722 compiler.warn.has.been.deprecated.for.removal=\ 1723 {0} in {1} has been deprecated and marked for removal 1724 1725 # 0: symbol 1726 compiler.warn.has.been.deprecated.module=\ 1727 module {0} has been deprecated 1728 1729 # 0: symbol 1730 compiler.warn.has.been.deprecated.for.removal.module=\ 1731 module {0} has been deprecated and marked for removal 1732 1733 # 0: symbol 1734 compiler.warn.sun.proprietary=\ 1735 {0} is internal proprietary API and may be removed in a future release 1736 1737 compiler.warn.illegal.char.for.encoding=\ 1738 unmappable character for encoding {0} 1739 1740 # 0: symbol 1741 compiler.warn.improper.SVUID=\ 1742 serialVersionUID must be declared static final in class {0} 1743 1744 # 0: type, 1: type 1745 compiler.warn.inexact.non-varargs.call=\ 1746 non-varargs call of varargs method with inexact argument type for last parameter;\n\ 1747 cast to {0} for a varargs call\n\ 1748 cast to {1} for a non-varargs call and to suppress this warning 1749 1750 # 0: list of type 1751 compiler.warn.unreachable.catch=\ 1752 unreachable catch clause\n\ 1753 thrown type {0} has already been caught 1754 1755 # 0: list of type 1756 compiler.warn.unreachable.catch.1=\ 1757 unreachable catch clause\n\ 1758 thrown types {0} have already been caught 1759 1760 # 0: symbol 1761 compiler.warn.long.SVUID=\ 1762 serialVersionUID must be of type long in class {0} 1763 1764 # 0: symbol 1765 compiler.warn.missing.SVUID=\ 1766 serializable class {0} has no definition of serialVersionUID 1767 1768 # 0: symbol, 1: symbol, 2: symbol, 3: symbol 1769 compiler.warn.potentially.ambiguous.overload=\ 1770 {0} in {1} is potentially ambiguous with {2} in {3} 1771 1772 # 0: message segment 1773 compiler.warn.override.varargs.missing=\ 1774 {0}; overridden method has no ''...'' 1775 1776 # 0: message segment 1777 compiler.warn.override.varargs.extra=\ 1778 {0}; overriding method is missing ''...'' 1779 1780 # 0: message segment 1781 compiler.warn.override.bridge=\ 1782 {0}; overridden method is a bridge method 1783 1784 # 0: symbol 1785 compiler.warn.pkg-info.already.seen=\ 1786 a package-info.java file has already been seen for package {0} 1787 1788 # 0: path 1789 compiler.warn.path.element.not.found=\ 1790 bad path element "{0}": no such file or directory 1791 1792 compiler.warn.possible.fall-through.into.case=\ 1793 possible fall-through into case 1794 1795 # 0: type 1796 compiler.warn.redundant.cast=\ 1797 redundant cast to {0} 1798 1799 # 0: number 1800 compiler.warn.position.overflow=\ 1801 Position encoding overflows at line {0} 1802 1803 # 0: file name, 1: number, 2: number 1804 compiler.warn.big.major.version=\ 1805 {0}: major version {1} is newer than {2}, the highest major version supported by this compiler.\n\ 1806 It is recommended that the compiler be upgraded. 1807 1808 # 0: kind name, 1: symbol 1809 compiler.warn.static.not.qualified.by.type=\ 1810 static {0} should be qualified by type name, {1}, instead of by an expression 1811 1812 # 0: string 1813 compiler.warn.source.no.bootclasspath=\ 1814 bootstrap class path not set in conjunction with -source {0} 1815 1816 # 0: string 1817 compiler.warn.option.obsolete.source=\ 1818 source value {0} is obsolete and will be removed in a future release 1819 1820 # 0: target 1821 compiler.warn.option.obsolete.target=\ 1822 target value {0} is obsolete and will be removed in a future release 1823 1824 # 0: string, 1: string 1825 compiler.err.option.removed.source=\ 1826 Source option {0} is no longer supported. Use {1} or later. 1827 1828 # 0: target, 1: target 1829 compiler.err.option.removed.target=\ 1830 Target option {0} is no longer supported. Use {1} or later. 1831 1832 1833 # 0: target, 1: target 1834 compiler.warn.option.parameters.unsupported=\ 1835 -parameters is not supported for target value {0}. Use {1} or later. 1836 1837 compiler.warn.option.obsolete.suppression=\ 1838 To suppress warnings about obsolete options, use -Xlint:-options. 1839 1840 # 0: name, 1: number, 2: number, 3: number, 4: number 1841 compiler.warn.future.attr=\ 1842 {0} attribute introduced in version {1}.{2} class files is ignored in version {3}.{4} class files 1843 1844 compiler.warn.requires.automatic=\ 1845 requires directive for an automatic module 1846 1847 compiler.warn.requires.transitive.automatic=\ 1848 requires transitive directive for an automatic module 1849 1850 # Warnings related to annotation processing 1851 # 0: string 1852 compiler.warn.proc.package.does.not.exist=\ 1853 package {0} does not exist 1854 1855 # 0: string 1856 compiler.warn.proc.file.reopening=\ 1857 Attempt to create a file for ''{0}'' multiple times 1858 1859 # 0: string 1860 compiler.warn.proc.type.already.exists=\ 1861 A file for type ''{0}'' already exists on the sourcepath or classpath 1862 1863 # 0: string 1864 compiler.warn.proc.type.recreate=\ 1865 Attempt to create a file for type ''{0}'' multiple times 1866 1867 # 0: string 1868 compiler.warn.proc.illegal.file.name=\ 1869 Cannot create file for illegal name ''{0}''. 1870 1871 # 0: string, 1: string 1872 compiler.warn.proc.suspicious.class.name=\ 1873 Creating file for a type whose name ends in {1}: ''{0}'' 1874 1875 # 0: string 1876 compiler.warn.proc.file.create.last.round=\ 1877 File for type ''{0}'' created in the last round will not be subject to annotation processing. 1878 1879 # 0: string, 1: string 1880 compiler.warn.proc.malformed.supported.string=\ 1881 Malformed string ''{0}'' for a supported annotation type returned by processor ''{1}'' 1882 1883 # 0: set of string 1884 compiler.warn.proc.annotations.without.processors=\ 1885 No processor claimed any of these annotations: {0} 1886 1887 # 0: source version, 1: string, 2: string 1888 compiler.warn.proc.processor.incompatible.source.version=\ 1889 Supported source version ''{0}'' from annotation processor ''{1}'' less than -source ''{2}'' 1890 1891 compiler.warn.proc.proc-only.requested.no.procs=\ 1892 Annotation processing without compilation requested but no processors were found. 1893 1894 compiler.warn.proc.use.implicit=\ 1895 Implicitly compiled files were not subject to annotation processing.\n\ 1896 Use -implicit to specify a policy for implicit compilation. 1897 1898 compiler.warn.proc.use.proc.or.implicit=\ 1899 Implicitly compiled files were not subject to annotation processing.\n\ 1900 Use -proc:none to disable annotation processing or -implicit to specify a policy for implicit compilation. 1901 1902 # Print a client-generated warning; assumed to be localized, no translation required 1903 # 0: string 1904 compiler.warn.proc.messager=\ 1905 {0} 1906 1907 # 0: set of string 1908 compiler.warn.proc.unclosed.type.files=\ 1909 Unclosed files for the types ''{0}''; these types will not undergo annotation processing 1910 1911 # 0: string 1912 compiler.warn.proc.unmatched.processor.options=\ 1913 The following options were not recognized by any processor: ''{0}'' 1914 1915 compiler.warn.try.explicit.close.call=\ 1916 explicit call to close() on an auto-closeable resource 1917 1918 # 0: symbol 1919 compiler.warn.try.resource.not.referenced=\ 1920 auto-closeable resource {0} is never referenced in body of corresponding try statement 1921 1922 # 0: type 1923 compiler.warn.try.resource.throws.interrupted.exc=\ 1924 auto-closeable resource {0} has a member method close() that could throw InterruptedException 1925 1926 compiler.warn.unchecked.assign=\ 1927 unchecked assignment: {0} to {1} 1928 1929 # 0: symbol, 1: type 1930 compiler.warn.unchecked.assign.to.var=\ 1931 unchecked assignment to variable {0} as member of raw type {1} 1932 1933 # 0: symbol, 1: type 1934 compiler.warn.unchecked.call.mbr.of.raw.type=\ 1935 unchecked call to {0} as a member of the raw type {1} 1936 1937 compiler.warn.unchecked.cast.to.type=\ 1938 unchecked cast to type {0} 1939 1940 # 0: kind name, 1: name, 2: object, 3: object, 4: kind name, 5: symbol 1941 compiler.warn.unchecked.meth.invocation.applied=\ 1942 unchecked method invocation: {0} {1} in {4} {5} is applied to given types\n\ 1943 required: {2}\n\ 1944 found: {3} 1945 1946 # 0: type 1947 compiler.warn.unchecked.generic.array.creation=\ 1948 unchecked generic array creation for varargs parameter of type {0} 1949 1950 # 0: type 1951 compiler.warn.unchecked.varargs.non.reifiable.type=\ 1952 Possible heap pollution from parameterized vararg type {0} 1953 1954 # 0: symbol 1955 compiler.warn.varargs.unsafe.use.varargs.param=\ 1956 Varargs method could cause heap pollution from non-reifiable varargs parameter {0} 1957 1958 compiler.warn.missing.deprecated.annotation=\ 1959 deprecated item is not annotated with @Deprecated 1960 1961 # 0: kind name 1962 compiler.warn.deprecated.annotation.has.no.effect=\ 1963 @Deprecated annotation has no effect on this {0} declaration 1964 1965 # 0: string 1966 compiler.warn.invalid.path=\ 1967 Invalid filename: {0} 1968 1969 # 0: path 1970 compiler.warn.invalid.archive.file=\ 1971 Unexpected file on path: {0} 1972 1973 # 0: path 1974 compiler.warn.unexpected.archive.file=\ 1975 Unexpected extension for archive file: {0} 1976 1977 # 0: path 1978 compiler.err.no.zipfs.for.archive=\ 1979 No file system provider is available to handle this file: {0} 1980 1981 compiler.warn.div.zero=\ 1982 division by zero 1983 1984 compiler.warn.empty.if=\ 1985 empty statement after if 1986 1987 # 0: type, 1: name 1988 compiler.warn.annotation.method.not.found=\ 1989 Cannot find annotation method ''{1}()'' in type ''{0}'' 1990 1991 # 0: type, 1: name, 2: message segment 1992 compiler.warn.annotation.method.not.found.reason=\ 1993 Cannot find annotation method ''{1}()'' in type ''{0}'': {2} 1994 1995 # 0: file object, 1: symbol, 2: name 1996 compiler.warn.unknown.enum.constant=\ 1997 unknown enum constant {1}.{2} 1998 1999 # 0: file object, 1: symbol, 2: name, 3: message segment 2000 compiler.warn.unknown.enum.constant.reason=\ 2001 unknown enum constant {1}.{2}\n\ 2002 reason: {3} 2003 2004 # 0: type, 1: type 2005 compiler.warn.raw.class.use=\ 2006 found raw type: {0}\n\ 2007 missing type arguments for generic class {1} 2008 2009 compiler.warn.diamond.redundant.args=\ 2010 Redundant type arguments in new expression (use diamond operator instead). 2011 2012 compiler.warn.local.redundant.type=\ 2013 Redundant type for local variable (replace explicit type with ''var''). 2014 2015 compiler.warn.potential.lambda.found=\ 2016 This anonymous inner class creation can be turned into a lambda expression. 2017 2018 compiler.warn.method.redundant.typeargs=\ 2019 Redundant type arguments in method call. 2020 2021 # 0: symbol, 1: message segment 2022 compiler.warn.varargs.redundant.trustme.anno=\ 2023 Redundant {0} annotation. {1} 2024 2025 # 0: symbol 2026 compiler.warn.access.to.member.from.serializable.element=\ 2027 access to member {0} from serializable element can be publicly accessible to untrusted code 2028 2029 # 0: symbol 2030 compiler.warn.access.to.member.from.serializable.lambda=\ 2031 access to member {0} from serializable lambda can be publicly accessible to untrusted code 2032 2033 ##### 2034 2035 ## The following are tokens which are non-terminals in the language. They should 2036 ## be named as JLS3 calls them when translated to the appropriate language. 2037 compiler.misc.token.identifier=\ 2038 <identifier> 2039 2040 compiler.misc.token.character=\ 2041 <character> 2042 2043 compiler.misc.token.string=\ 2044 <string> 2045 2046 compiler.misc.token.integer=\ 2047 <integer> 2048 2049 compiler.misc.token.long-integer=\ 2050 <long integer> 2051 2052 compiler.misc.token.float=\ 2053 <float> 2054 2055 compiler.misc.token.double=\ 2056 <double> 2057 2058 compiler.misc.token.bad-symbol=\ 2059 <bad symbol> 2060 2061 compiler.misc.token.end-of-input=\ 2062 <end of input> 2063 2064 ## The argument to the following string will always be one of the following: 2065 ## 1. one of the above non-terminals 2066 ## 2. a keyword (JLS1.8) 2067 ## 3. a boolean literal (JLS3.10.3) 2068 ## 4. the null literal (JLS3.10.7) 2069 ## 5. a Java separator (JLS3.11) 2070 ## 6. an operator (JLS3.12) 2071 ## 2072 ## This is the only place these tokens will be used. 2073 # 0: token 2074 compiler.err.expected=\ 2075 {0} expected 2076 2077 # 0: string 2078 compiler.err.expected.str=\ 2079 {0} expected 2080 2081 # 0: token, 1: token 2082 compiler.err.expected2=\ 2083 {0} or {1} expected 2084 2085 # 0: token, 1: token, 2: token 2086 compiler.err.expected3=\ 2087 {0}, {1}, or {2} expected 2088 2089 compiler.err.premature.eof=\ 2090 reached end of file while parsing 2091 2092 ## The following are related in form, but do not easily fit the above paradigm. 2093 compiler.err.expected.module=\ 2094 ''module'' expected 2095 2096 compiler.err.expected.module.or.open=\ 2097 ''module'' or ''open'' expected 2098 2099 compiler.err.dot.class.expected=\ 2100 ''.class'' expected 2101 2102 ## The argument to this string will always be either 'case' or 'default'. 2103 # 0: token 2104 compiler.err.orphaned=\ 2105 orphaned {0} 2106 2107 # 0: name 2108 compiler.misc.anonymous.class=\ 2109 <anonymous {0}> 2110 2111 # 0: name, 1: type 2112 compiler.misc.type.captureof=\ 2113 capture#{0} of {1} 2114 2115 compiler.misc.type.captureof.1=\ 2116 capture#{0} 2117 2118 compiler.misc.type.none=\ 2119 <none> 2120 2121 compiler.misc.unnamed.package=\ 2122 unnamed package 2123 2124 compiler.misc.unnamed.module=\ 2125 unnamed module 2126 2127 ##### 2128 2129 # 0: symbol, 1: message segment 2130 compiler.err.cant.access=\ 2131 cannot access {0}\n\ 2132 {1} 2133 2134 # 0: name 2135 compiler.misc.bad.class.file=\ 2136 class file is invalid for class {0} 2137 2138 # 0: file name, 1: string (expected constant pool entry type), 2: number (constant pool index) 2139 compiler.misc.bad.const.pool.entry=\ 2140 bad constant pool entry in {0}\n\ 2141 expected {1} at index {2} 2142 2143 # 0: file name, 1: message segment 2144 compiler.misc.bad.class.file.header=\ 2145 bad class file: {0}\n\ 2146 {1}\n\ 2147 Please remove or make sure it appears in the correct subdirectory of the classpath. 2148 2149 # 0: file name, 1: message segment 2150 compiler.misc.bad.source.file.header=\ 2151 bad source file: {0}\n\ 2152 {1}\n\ 2153 Please remove or make sure it appears in the correct subdirectory of the sourcepath. 2154 2155 ## The following are all possible strings for the second argument ({1}) of the 2156 ## above strings. 2157 compiler.misc.bad.class.signature=\ 2158 bad class signature: {0} 2159 2160 #0: symbol, 1: symbol 2161 compiler.misc.bad.enclosing.class=\ 2162 bad enclosing class for {0}: {1} 2163 2164 # 0: symbol 2165 compiler.misc.bad.enclosing.method=\ 2166 bad enclosing method attribute for class {0} 2167 2168 compiler.misc.bad.runtime.invisible.param.annotations=\ 2169 bad RuntimeInvisibleParameterAnnotations attribute: {0} 2170 2171 compiler.misc.bad.const.pool.tag=\ 2172 bad constant pool tag: {0} 2173 2174 compiler.misc.bad.const.pool.tag.at=\ 2175 bad constant pool tag: {0} at {1} 2176 2177 compiler.misc.bad.signature=\ 2178 bad signature: {0} 2179 2180 compiler.misc.bad.type.annotation.value=\ 2181 bad type annotation target type value: {0} 2182 2183 compiler.misc.bad.module-info.name=\ 2184 bad class name 2185 2186 compiler.misc.class.file.wrong.class=\ 2187 class file contains wrong class: {0} 2188 2189 compiler.misc.module.info.invalid.super.class=\ 2190 module-info with invalid super class 2191 2192 # 0: name 2193 compiler.misc.class.file.not.found=\ 2194 class file for {0} not found 2195 2196 # 0: string (constant value), 1: symbol (constant field), 2: type (field type) 2197 compiler.misc.bad.constant.range=\ 2198 constant value ''{0}'' for {1} is outside the expected range for {2} 2199 2200 # 0: string (constant value), 1: symbol (constant field), 2: string (expected class) 2201 compiler.misc.bad.constant.value=\ 2202 bad constant value ''{0}'' for {1}, expected {2} 2203 2204 # 0: string (classfile major version), 1: string (classfile minor version) 2205 compiler.misc.invalid.default.interface=\ 2206 default method found in version {0}.{1} classfile 2207 2208 # 0: string (classfile major version), 1: string (classfile minor version) 2209 compiler.misc.invalid.static.interface=\ 2210 static method found in version {0}.{1} classfile 2211 2212 # 0: string (classfile major version), 1: string (classfile minor version) 2213 compiler.misc.anachronistic.module.info=\ 2214 module declaration found in version {0}.{1} classfile 2215 2216 # 0: name 2217 compiler.misc.file.doesnt.contain.class=\ 2218 file does not contain class {0} 2219 2220 # 0: symbol 2221 compiler.misc.file.does.not.contain.package=\ 2222 file does not contain package {0} 2223 2224 compiler.misc.file.does.not.contain.module=\ 2225 file does not contain module declaration 2226 2227 compiler.misc.illegal.start.of.class.file=\ 2228 illegal start of class file 2229 2230 compiler.misc.unable.to.access.file=\ 2231 unable to access file: {0} 2232 2233 compiler.misc.unicode.str.not.supported=\ 2234 unicode string in class file not supported 2235 2236 compiler.misc.undecl.type.var=\ 2237 undeclared type variable: {0} 2238 2239 compiler.misc.malformed.vararg.method=\ 2240 class file contains malformed variable arity method: {0} 2241 2242 compiler.misc.wrong.version=\ 2243 class file has wrong version {0}.{1}, should be {2}.{3} 2244 2245 ##### 2246 2247 # 0: type, 1: type or symbol 2248 compiler.err.not.within.bounds=\ 2249 type argument {0} is not within bounds of type-variable {1} 2250 2251 ## The following are all possible strings for the second argument ({1}) of the 2252 ## above string. 2253 2254 ## none yet... 2255 2256 ##### 2257 2258 # 0: message segment 2259 compiler.err.prob.found.req=\ 2260 incompatible types: {0} 2261 2262 # 0: message segment 2263 compiler.misc.prob.found.req=\ 2264 incompatible types: {0} 2265 2266 # 0: message segment, 1: type, 2: type 2267 compiler.warn.prob.found.req=\ 2268 {0}\n\ 2269 required: {2}\n\ 2270 found: {1} 2271 2272 # 0: type, 1: type 2273 compiler.misc.inconvertible.types=\ 2274 {0} cannot be converted to {1} 2275 2276 # 0: type, 1: type 2277 compiler.misc.possible.loss.of.precision=\ 2278 possible lossy conversion from {0} to {1} 2279 2280 compiler.misc.unchecked.assign=\ 2281 unchecked conversion 2282 2283 # compiler.misc.storecheck=\ 2284 # assignment might cause later store checks to fail 2285 # compiler.misc.unchecked=\ 2286 # assigned array cannot dynamically check its stores 2287 compiler.misc.unchecked.cast.to.type=\ 2288 unchecked cast 2289 2290 # compiler.err.star.expected=\ 2291 # ''*'' expected 2292 # compiler.err.no.elem.type=\ 2293 # \[\*\] cannot have a type 2294 2295 # 0: message segment 2296 compiler.misc.try.not.applicable.to.type=\ 2297 try-with-resources not applicable to variable type\n\ 2298 ({0}) 2299 2300 ##### 2301 2302 # 0: object, 1: message segment 2303 compiler.err.type.found.req=\ 2304 unexpected type\n\ 2305 required: {1}\n\ 2306 found: {0} 2307 2308 ## The following are all possible strings for the first argument ({0}) of the 2309 ## above string. 2310 compiler.misc.type.req.class=\ 2311 class 2312 2313 compiler.misc.type.req.class.array=\ 2314 class or array 2315 2316 compiler.misc.type.req.array.or.iterable=\ 2317 array or java.lang.Iterable 2318 2319 compiler.misc.type.req.ref=\ 2320 reference 2321 2322 compiler.misc.type.req.exact=\ 2323 class or interface without bounds 2324 2325 # 0: type 2326 compiler.misc.type.parameter=\ 2327 type parameter {0} 2328 2329 ##### 2330 2331 ## The following are all possible strings for the last argument of all those 2332 ## diagnostics whose key ends in ".1" 2333 2334 # 0: type, 1: list of type 2335 compiler.misc.no.unique.maximal.instance.exists=\ 2336 no unique maximal instance exists for type variable {0} with upper bounds {1} 2337 2338 # 0: type, 1: list of type 2339 compiler.misc.no.unique.minimal.instance.exists=\ 2340 no unique minimal instance exists for type variable {0} with lower bounds {1} 2341 2342 # 0: type, 1: list of type 2343 compiler.misc.incompatible.upper.bounds=\ 2344 inference variable {0} has incompatible upper bounds {1} 2345 2346 # 0: type, 1: list of type 2347 compiler.misc.incompatible.eq.bounds=\ 2348 inference variable {0} has incompatible equality constraints {1} 2349 2350 # 0: type, 1: fragment, 2: fragment 2351 compiler.misc.incompatible.bounds=\ 2352 inference variable {0} has incompatible bounds\n\ 2353 {1}\n\ 2354 {2} 2355 2356 # 0: list of type 2357 compiler.misc.lower.bounds=\ 2358 lower bounds: {0} 2359 2360 # 0: list of type 2361 compiler.misc.eq.bounds=\ 2362 equality constraints: {0} 2363 2364 # 0: list of type 2365 compiler.misc.upper.bounds=\ 2366 lower bounds: {0} 2367 2368 # 0: list of type, 1: type, 2: type 2369 compiler.misc.infer.no.conforming.instance.exists=\ 2370 no instance(s) of type variable(s) {0} exist so that {1} conforms to {2} 2371 2372 # 0: list of type, 1: message segment 2373 compiler.misc.infer.no.conforming.assignment.exists=\ 2374 cannot infer type-variable(s) {0}\n\ 2375 (argument mismatch; {1}) 2376 2377 # 0: list of type 2378 compiler.misc.infer.arg.length.mismatch=\ 2379 cannot infer type-variable(s) {0}\n\ 2380 (actual and formal argument lists differ in length) 2381 2382 # 0: list of type, 1: message segment 2383 compiler.misc.infer.varargs.argument.mismatch=\ 2384 cannot infer type-variable(s) {0}\n\ 2385 (varargs mismatch; {1}) 2386 2387 # 0: type, 1: list of type 2388 compiler.misc.inferred.do.not.conform.to.upper.bounds=\ 2389 inferred type does not conform to upper bound(s)\n\ 2390 inferred: {0}\n\ 2391 upper bound(s): {1} 2392 2393 # 0: type, 1: list of type 2394 compiler.misc.inferred.do.not.conform.to.lower.bounds=\ 2395 inferred type does not conform to lower bound(s)\n\ 2396 inferred: {0}\n\ 2397 lower bound(s): {1} 2398 2399 # 0: type, 1: list of type 2400 compiler.misc.inferred.do.not.conform.to.eq.bounds=\ 2401 inferred type does not conform to equality constraint(s)\n\ 2402 inferred: {0}\n\ 2403 equality constraints(s): {1} 2404 2405 # 0: symbol 2406 compiler.misc.diamond=\ 2407 {0}<> 2408 2409 # 0: type 2410 compiler.misc.diamond.non.generic=\ 2411 cannot use ''<>'' with non-generic class {0} 2412 2413 # 0: list of type, 1: message segment 2414 compiler.misc.diamond.invalid.arg=\ 2415 type argument {0} inferred for {1} is not allowed in this context\n\ 2416 inferred argument is not expressible in the Signature attribute 2417 2418 # 0: list of type, 1: message segment 2419 compiler.misc.diamond.invalid.args=\ 2420 type arguments {0} inferred for {1} are not allowed in this context\n\ 2421 inferred arguments are not expressible in the Signature attribute 2422 2423 # 0: type 2424 compiler.misc.diamond.and.explicit.params=\ 2425 cannot use ''<>'' with explicit type parameters for constructor 2426 2427 compiler.misc.mref.infer.and.explicit.params=\ 2428 cannot use raw constructor reference with explicit type parameters for constructor 2429 2430 # 0: type, 1: list of type 2431 compiler.misc.explicit.param.do.not.conform.to.bounds=\ 2432 explicit type argument {0} does not conform to declared bound(s) {1} 2433 2434 compiler.misc.arg.length.mismatch=\ 2435 actual and formal argument lists differ in length 2436 2437 # 0: string 2438 compiler.misc.wrong.number.type.args=\ 2439 wrong number of type arguments; required {0} 2440 2441 # 0: message segment 2442 compiler.misc.no.conforming.assignment.exists=\ 2443 argument mismatch; {0} 2444 2445 # 0: message segment 2446 compiler.misc.varargs.argument.mismatch=\ 2447 varargs mismatch; {0} 2448 2449 ##### 2450 2451 # 0: symbol or type, 1: file name 2452 compiler.warn.auxiliary.class.accessed.from.outside.of.its.source.file=\ 2453 auxiliary class {0} in {1} should not be accessed from outside its own source file 2454 2455 ## The first argument ({0}) is a "kindname". 2456 # 0: kind name, 1: symbol, 2: symbol 2457 compiler.err.abstract.cant.be.accessed.directly=\ 2458 abstract {0} {1} in {2} cannot be accessed directly 2459 2460 ## The first argument ({0}) is a "kindname". 2461 # 0: symbol kind, 1: symbol 2462 compiler.err.non-static.cant.be.ref=\ 2463 non-static {0} {1} cannot be referenced from a static context 2464 2465 # 0: symbol kind, 1: symbol 2466 compiler.misc.bad.static.method.in.unbound.lookup=\ 2467 unexpected static {0} {1} found in unbound lookup 2468 2469 # 0: symbol kind, 1: symbol 2470 compiler.misc.bad.instance.method.in.unbound.lookup=\ 2471 unexpected instance {0} {1} found in unbound lookup 2472 2473 # 0: symbol kind, 1: symbol 2474 compiler.misc.bad.static.method.in.bound.lookup=\ 2475 unexpected static {0} {1} found in bound lookup 2476 2477 ## Both arguments ({0}, {1}) are "kindname"s. {0} is a comma-separated list 2478 ## of kindnames (the list should be identical to that provided in source. 2479 # 0: set of kind name, 1: set of kind name 2480 compiler.err.unexpected.type=\ 2481 unexpected type\n\ 2482 required: {0}\n\ 2483 found: {1} 2484 2485 compiler.err.unexpected.lambda=\ 2486 lambda expression not expected here 2487 2488 compiler.err.unexpected.mref=\ 2489 method reference not expected here 2490 2491 ## The first argument {0} is a "kindname" (e.g. 'constructor', 'field', etc.) 2492 ## The second argument {1} is the non-resolved symbol 2493 ## The third argument {2} is a list of type parameters (non-empty if {1} is a method) 2494 ## The fourth argument {3} is a list of argument types (non-empty if {1} is a method) 2495 # 0: kind name, 1: name, 2: unused, 3: unused 2496 compiler.err.cant.resolve=\ 2497 cannot find symbol\n\ 2498 symbol: {0} {1} 2499 2500 # 0: kind name, 1: name, 2: unused, 3: list of type 2501 compiler.err.cant.resolve.args=\ 2502 cannot find symbol\n\ 2503 symbol: {0} {1}({3}) 2504 2505 # 0: kind name, 1: name, 2: unused, 3: list of type 2506 compiler.misc.cant.resolve.args=\ 2507 cannot find symbol\n\ 2508 symbol: {0} {1}({3}) 2509 2510 # 0: kind name, 1: name, 2: list of type, 3: list of type 2511 compiler.err.cant.resolve.args.params=\ 2512 cannot find symbol\n\ 2513 symbol: {0} <{2}>{1}({3}) 2514 2515 ## arguments from {0} to {3} have the same meaning as above 2516 ## The fifth argument {4} is a location subdiagnostic (see below) 2517 # 0: kind name, 1: name, 2: unused, 3: unused, 4: message segment 2518 compiler.err.cant.resolve.location=\ 2519 cannot find symbol\n\ 2520 symbol: {0} {1}\n\ 2521 location: {4} 2522 2523 # 0: kind name, 1: name, 2: unused, 3: list of type, 4: message segment 2524 compiler.err.cant.resolve.location.args=\ 2525 cannot find symbol\n\ 2526 symbol: {0} {1}({3})\n\ 2527 location: {4} 2528 2529 # 0: kind name, 1: name, 2: list of type, 3: list, 4: message segment 2530 compiler.err.cant.resolve.location.args.params=\ 2531 cannot find symbol\n\ 2532 symbol: {0} <{2}>{1}({3})\n\ 2533 location: {4} 2534 2535 ### Following are replicated/used for method reference diagnostics 2536 2537 # 0: kind name, 1: name, 2: unused, 3: list of type, 4: message segment 2538 compiler.misc.cant.resolve.location.args=\ 2539 cannot find symbol\n\ 2540 symbol: {0} {1}({3})\n\ 2541 location: {4} 2542 2543 # 0: kind name, 1: name, 2: list of type, 3: list, 4: message segment 2544 compiler.misc.cant.resolve.location.args.params=\ 2545 cannot find symbol\n\ 2546 symbol: {0} <{2}>{1}({3})\n\ 2547 location: {4} 2548 2549 ##a location subdiagnostic is composed as follows: 2550 ## The first argument {0} is the location "kindname" (e.g. 'constructor', 'field', etc.) 2551 ## The second argument {1} is the location name 2552 ## The third argument {2} is the location type (only when {1} is a variable name) 2553 2554 # 0: kind name, 1: type or symbol, 2: unused 2555 compiler.misc.location=\ 2556 {0} {1} 2557 2558 # 0: kind name, 1: symbol, 2: type 2559 compiler.misc.location.1=\ 2560 {0} {1} of type {2} 2561 2562 ## The following are all possible string for "kindname". 2563 ## They should be called whatever the JLS calls them after it been translated 2564 ## to the appropriate language. 2565 # compiler.misc.kindname.constructor=\ 2566 # static member 2567 compiler.misc.kindname.annotation=\ 2568 @interface 2569 2570 compiler.misc.kindname.constructor=\ 2571 constructor 2572 2573 compiler.misc.kindname.enum=\ 2574 enum 2575 2576 compiler.misc.kindname.interface=\ 2577 interface 2578 2579 compiler.misc.kindname.static=\ 2580 static 2581 2582 compiler.misc.kindname.type.variable=\ 2583 type variable 2584 2585 compiler.misc.kindname.type.variable.bound=\ 2586 bound of type variable 2587 2588 compiler.misc.kindname.variable=\ 2589 variable 2590 2591 compiler.misc.kindname.value=\ 2592 value 2593 2594 compiler.misc.kindname.method=\ 2595 method 2596 2597 compiler.misc.kindname.class=\ 2598 class 2599 2600 compiler.misc.kindname.package=\ 2601 package 2602 2603 compiler.misc.kindname.module=\ 2604 module 2605 2606 compiler.misc.kindname.static.init=\ 2607 static initializer 2608 2609 compiler.misc.kindname.instance.init=\ 2610 instance initializer 2611 2612 ##### 2613 2614 compiler.misc.no.args=\ 2615 no arguments 2616 2617 # 0: message segment 2618 compiler.err.override.static=\ 2619 {0}\n\ 2620 overriding method is static 2621 2622 # 0: message segment, 1: set of flag 2623 compiler.err.override.meth=\ 2624 {0}\n\ 2625 overridden method is {1} 2626 2627 # 0: message segment, 1: type 2628 compiler.err.override.meth.doesnt.throw=\ 2629 {0}\n\ 2630 overridden method does not throw {1} 2631 2632 # In the following string {1} is a space separated list of Java Keywords, as 2633 # they would have been declared in the source code 2634 # 0: message segment, 1: set of flag or string 2635 compiler.err.override.weaker.access=\ 2636 {0}\n\ 2637 attempting to assign weaker access privileges; was {1} 2638 2639 # 0: message segment, 1: type, 2: type 2640 compiler.err.override.incompatible.ret=\ 2641 {0}\n\ 2642 return type {1} is not compatible with {2} 2643 2644 # 0: message segment, 1: type, 2: type 2645 compiler.warn.override.unchecked.ret=\ 2646 {0}\n\ 2647 return type requires unchecked conversion from {1} to {2} 2648 2649 # 0: message segment, 1: type 2650 compiler.warn.override.unchecked.thrown=\ 2651 {0}\n\ 2652 overridden method does not throw {1} 2653 2654 # 0: symbol 2655 compiler.warn.override.equals.but.not.hashcode=\ 2656 Class {0} overrides equals, but neither it nor any superclass overrides hashCode method 2657 2658 ## The following are all possible strings for the first argument ({0}) of the 2659 ## above strings. 2660 # 0: symbol, 1: symbol, 2: symbol, 3: symbol 2661 compiler.misc.cant.override=\ 2662 {0} in {1} cannot override {2} in {3} 2663 2664 # 0: symbol, 1: symbol, 2: symbol, 3: symbol 2665 compiler.misc.cant.hide=\ 2666 {0} in {1} cannot hide {2} in {3} 2667 2668 # 0: symbol, 1: symbol, 2: symbol, 3: symbol 2669 compiler.misc.cant.implement=\ 2670 {0} in {1} cannot implement {2} in {3} 2671 2672 # 0: symbol, 1: symbol, 2: symbol, 3: symbol 2673 compiler.misc.clashes.with=\ 2674 {0} in {1} clashes with {2} in {3} 2675 2676 # 0: symbol, 1: symbol, 2: symbol, 3: symbol 2677 compiler.misc.unchecked.override=\ 2678 {0} in {1} overrides {2} in {3} 2679 2680 # 0: symbol, 1: symbol, 2: symbol, 3: symbol 2681 compiler.misc.unchecked.implement=\ 2682 {0} in {1} implements {2} in {3} 2683 2684 # 0: symbol, 1: symbol, 2: symbol, 3: symbol 2685 compiler.misc.unchecked.clash.with=\ 2686 {0} in {1} overrides {2} in {3} 2687 2688 # 0: symbol, 1: symbol, 2: symbol, 3: symbol 2689 compiler.misc.varargs.override=\ 2690 {0} in {1} overrides {2} in {3} 2691 2692 # 0: symbol, 1: symbol, 2: symbol, 3: symbol 2693 compiler.misc.varargs.implement=\ 2694 {0} in {1} implements {2} in {3} 2695 2696 # 0: symbol, 1: symbol, 2: symbol, 3: symbol 2697 compiler.misc.varargs.clash.with=\ 2698 {0} in {1} overrides {2} in {3} 2699 2700 # 0: kind name, 1: symbol, 2: symbol, 3: message segment 2701 compiler.misc.inapplicable.method=\ 2702 {0} {1}.{2} is not applicable\n\ 2703 ({3}) 2704 2705 ######################################## 2706 # Diagnostics for language feature changes. 2707 # Such diagnostics have a common template which can be customized by using a feature 2708 # diagnostic fragment (one of those given below). 2709 ######################################## 2710 2711 # 0: message segment (feature), 1: string (found version), 2: string (expected version) 2712 compiler.err.feature.not.supported.in.source=\ 2713 {0} is not supported in -source {1}\n\ 2714 (use -source {2} or higher to enable {0}) 2715 2716 # 0: message segment (feature), 1: string (found version), 2: string (expected version) 2717 compiler.err.feature.not.supported.in.source.plural=\ 2718 {0} are not supported in -source {1}\n\ 2719 (use -source {2} or higher to enable {0}) 2720 2721 # 0: message segment (feature), 1: string (found version), 2: string (expected version) 2722 compiler.misc.feature.not.supported.in.source=\ 2723 {0} is not supported in -source {1}\n\ 2724 (use -source {2} or higher to enable {0}) 2725 2726 # 0: message segment (feature), 1: string (found version), 2: string (expected version) 2727 compiler.misc.feature.not.supported.in.source.plural=\ 2728 {0} are not supported in -source {1}\n\ 2729 (use -source {2} or higher to enable {0}) 2730 2731 # 0: message segment (feature) 2732 compiler.err.preview.feature.disabled=\ 2733 {0} is a preview feature and is disabled by default.\n\ 2734 (use --enable-preview to enable {0}) 2735 2736 # 0: message segment (feature) 2737 compiler.err.preview.feature.disabled.plural=\ 2738 {0} are a preview feature and are disabled by default.\n\ 2739 (use --enable-preview to enable {0}) 2740 2741 # 0: file object (classfile), 1: string (expected version) 2742 compiler.err.preview.feature.disabled.classfile=\ 2743 classfile for {0} uses preview features of Java SE {1}.\n\ 2744 (use --enable-preview to allow loading of classfiles which contain preview features) 2745 2746 # 0: message segment (feature) 2747 compiler.warn.preview.feature.use=\ 2748 {0} is a preview feature and may be removed in a future release. 2749 2750 # 0: message segment (feature) 2751 compiler.warn.preview.feature.use.plural=\ 2752 {0} are a preview feature and may be removed in a future release. 2753 2754 # 0: file object (classfile), 1: string (expected version) 2755 compiler.warn.preview.feature.use.classfile=\ 2756 classfile for {0} uses preview features of Java SE {1}. 2757 2758 2759 compiler.misc.feature.modules=\ 2760 modules 2761 2762 compiler.misc.feature.diamond.and.anon.class=\ 2763 ''<>'' with anonymous inner classes 2764 2765 compiler.misc.feature.var.in.try.with.resources=\ 2766 variables in try-with-resources 2767 2768 compiler.misc.feature.type.annotations=\ 2769 type annotations 2770 2771 compiler.misc.feature.annotations.after.type.params=\ 2772 annotations after method type parameters 2773 2774 compiler.misc.feature.repeatable.annotations=\ 2775 repeated annotations 2776 2777 compiler.misc.feature.diamond=\ 2778 diamond operator 2779 2780 compiler.misc.feature.lambda=\ 2781 lambda expressions 2782 2783 compiler.misc.feature.method.references=\ 2784 method references 2785 2786 compiler.misc.feature.default.methods=\ 2787 default methods 2788 2789 compiler.misc.feature.intersection.types.in.cast=\ 2790 intersection types 2791 2792 compiler.misc.feature.static.intf.methods=\ 2793 static interface methods 2794 2795 compiler.misc.feature.static.intf.method.invoke=\ 2796 static interface method invocations 2797 2798 compiler.misc.feature.private.intf.methods=\ 2799 private interface methods 2800 2801 compiler.misc.feature.multiple.case.labels=\ 2802 multiple case labels 2803 2804 compiler.misc.feature.switch.rules=\ 2805 switch rules 2806 2807 compiler.misc.feature.switch.expressions=\ 2808 switch expressions 2809 2810 compiler.warn.underscore.as.identifier=\ 2811 as of release 9, ''_'' is a keyword, and may not be used as an identifier 2812 2813 compiler.err.underscore.as.identifier=\ 2814 as of release 9, ''_'' is a keyword, and may not be used as an identifier 2815 2816 compiler.err.underscore.as.identifier.in.lambda=\ 2817 ''_'' used as an identifier\n\ 2818 (use of ''_'' as an identifier is forbidden for lambda parameters) 2819 2820 compiler.err.enum.as.identifier=\ 2821 as of release 5, ''enum'' is a keyword, and may not be used as an identifier 2822 2823 compiler.err.assert.as.identifier=\ 2824 as of release 1.4, ''assert'' is a keyword, and may not be used as an identifier 2825 2826 # TODO 308: make a better error message 2827 compiler.err.this.as.identifier=\ 2828 as of release 8, ''this'' is allowed as the parameter name for the receiver type only\n\ 2829 which has to be the first parameter, and cannot be a lambda parameter 2830 2831 compiler.err.receiver.parameter.not.applicable.constructor.toplevel.class=\ 2832 receiver parameter not applicable for constructor of top-level class 2833 2834 # TODO 308: make a better error message 2835 # 0: annotation 2836 compiler.err.cant.type.annotate.scoping.1=\ 2837 scoping construct cannot be annotated with type-use annotation: {0} 2838 2839 # TODO 308: make a better error message 2840 # 0: list of annotation 2841 compiler.err.cant.type.annotate.scoping=\ 2842 scoping construct cannot be annotated with type-use annotations: {0} 2843 2844 # 0: type, 1: type 2845 compiler.err.incorrect.receiver.name=\ 2846 the receiver name does not match the enclosing class type\n\ 2847 required: {0}\n\ 2848 found: {1} 2849 2850 # 0: type, 1: type 2851 compiler.err.incorrect.receiver.type=\ 2852 the receiver type does not match the enclosing class type\n\ 2853 required: {0}\n\ 2854 found: {1} 2855 2856 # 0: type, 1: type 2857 compiler.err.incorrect.constructor.receiver.type=\ 2858 the receiver type does not match the enclosing outer class type\n\ 2859 required: {0}\n\ 2860 found: {1} 2861 2862 # 0: type, 1: type 2863 compiler.err.incorrect.constructor.receiver.name=\ 2864 the receiver name does not match the enclosing outer class type\n\ 2865 required: {0}\n\ 2866 found: {1} 2867 2868 compiler.err.no.annotations.on.dot.class=\ 2869 no annotations are allowed in the type of a class literal 2870 2871 ######################################## 2872 # Diagnostics for verbose resolution 2873 # used by Resolve (debug only) 2874 ######################################## 2875 2876 # 0: number, 1: symbol, 2: unused 2877 compiler.misc.applicable.method.found=\ 2878 #{0} applicable method found: {1} 2879 2880 # 0: number, 1: symbol, 2: message segment 2881 compiler.misc.applicable.method.found.1=\ 2882 #{0} applicable method found: {1}\n\ 2883 ({2}) 2884 2885 # 0: number, 1: symbol, 2: message segment 2886 compiler.misc.not.applicable.method.found=\ 2887 #{0} not applicable method found: {1}\n\ 2888 ({2}) 2889 2890 # 0: type 2891 compiler.misc.partial.inst.sig=\ 2892 partially instantiated to: {0} 2893 2894 # 0: name, 1: symbol, 2: number, 3: string (method resolution phase), 4: list of type or message segment, 5: list of type or message segment 2895 compiler.note.verbose.resolve.multi=\ 2896 resolving method {0} in type {1} to candidate {2}\n\ 2897 phase: {3}\n\ 2898 with actuals: {4}\n\ 2899 with type-args: {5}\n\ 2900 candidates: 2901 2902 # 0: name, 1: symbol, 2: unused, 3: string (method resolution phase), 4: list of type or message segment, 5: list of type or message segment 2903 compiler.note.verbose.resolve.multi.1=\ 2904 erroneous resolution for method {0} in type {1}\n\ 2905 phase: {3}\n\ 2906 with actuals: {4}\n\ 2907 with type-args: {5}\n\ 2908 candidates: 2909 2910 # 0: symbol, 1: type, 2: type 2911 compiler.note.deferred.method.inst=\ 2912 Deferred instantiation of method {0}\n\ 2913 instantiated signature: {1}\n\ 2914 target-type: {2} 2915 2916 ######################################## 2917 # Diagnostics for lambda deduplication 2918 # used by LambdaToMethod (debug only) 2919 ######################################## 2920 2921 # 0: symbol 2922 compiler.note.verbose.l2m.deduplicate=\ 2923 deduplicating lambda implementation method {0} 2924 2925 ######################################## 2926 # Diagnostics for where clause implementation 2927 # used by the RichDiagnosticFormatter. 2928 ######################################## 2929 2930 compiler.misc.type.null=\ 2931 <null> 2932 2933 # X#n (where n is an int id) is disambiguated tvar name 2934 # 0: name, 1: number 2935 compiler.misc.type.var=\ 2936 {0}#{1} 2937 2938 # CAP#n (where n is an int id) is an abbreviation for 'captured type' 2939 # 0: number 2940 compiler.misc.captured.type=\ 2941 CAP#{0} 2942 2943 # <INT#n> (where n is an int id) is an abbreviation for 'intersection type' 2944 # 0: number 2945 compiler.misc.intersection.type=\ 2946 INT#{0} 2947 2948 # where clause for captured type: contains upper ('extends {1}') and lower 2949 # ('super {2}') bound along with the wildcard that generated this captured type ({3}) 2950 # 0: type, 1: type, 2: type, 3: type 2951 compiler.misc.where.captured=\ 2952 {0} extends {1} super: {2} from capture of {3} 2953 2954 # compact where clause for captured type: contains upper ('extends {1}') along 2955 # with the wildcard that generated this captured type ({3}) 2956 # 0: type, 1: type, 2: unused, 3: type 2957 compiler.misc.where.captured.1=\ 2958 {0} extends {1} from capture of {3} 2959 2960 # where clause for type variable: contains upper bound(s) ('extends {1}') along with 2961 # the kindname ({2}) and location ({3}) in which the typevar has been declared 2962 # 0: type, 1: list of type, 2: symbol kind, 3: symbol 2963 compiler.misc.where.typevar=\ 2964 {0} extends {1} declared in {2} {3} 2965 2966 # compact where clause for type variable: contains the kindname ({2}) and location ({3}) 2967 # in which the typevar has been declared 2968 # 0: type, 1: list of type, 2: symbol kind, 3: symbol 2969 compiler.misc.where.typevar.1=\ 2970 {0} declared in {2} {3} 2971 2972 # where clause for fresh type variable: contains upper bound(s) ('extends {1}'). 2973 # Since a fresh type-variable is synthetic - there's no location/kindname here. 2974 # 0: type, 1: list of type 2975 compiler.misc.where.fresh.typevar=\ 2976 {0} extends {1} 2977 2978 # where clause for type variable: contains all the upper bound(s) ('extends {1}') 2979 # of this intersection type 2980 # 0: type, 1: list of type 2981 compiler.misc.where.intersection=\ 2982 {0} extends {1} 2983 2984 ### Where clause headers ### 2985 compiler.misc.where.description.captured=\ 2986 where {0} is a fresh type-variable: 2987 2988 # 0: set of type 2989 compiler.misc.where.description.typevar=\ 2990 where {0} is a type-variable: 2991 2992 # 0: set of type 2993 compiler.misc.where.description.intersection=\ 2994 where {0} is an intersection type: 2995 2996 # 0: set of type 2997 compiler.misc.where.description.captured.1=\ 2998 where {0} are fresh type-variables: 2999 3000 # 0: set of type 3001 compiler.misc.where.description.typevar.1=\ 3002 where {0} are type-variables: 3003 3004 # 0: set of type 3005 compiler.misc.where.description.intersection.1=\ 3006 where {0} are intersection types: 3007 3008 ### 3009 # errors related to doc comments 3010 3011 compiler.err.dc.bad.entity=\ 3012 bad HTML entity 3013 3014 compiler.err.dc.bad.gt=\ 3015 bad use of ''>'' 3016 3017 compiler.err.dc.bad.inline.tag=\ 3018 incorrect use of inline tag 3019 3020 compiler.err.dc.identifier.expected=\ 3021 identifier expected 3022 3023 compiler.err.dc.malformed.html=\ 3024 malformed HTML 3025 3026 compiler.err.dc.missing.semicolon=\ 3027 semicolon missing 3028 3029 compiler.err.dc.no.content=\ 3030 no content 3031 3032 compiler.err.dc.no.tag.name=\ 3033 no tag name after '@' 3034 3035 compiler.err.dc.gt.expected=\ 3036 ''>'' expected 3037 3038 compiler.err.dc.ref.bad.parens=\ 3039 '')'' missing in reference 3040 3041 compiler.err.dc.ref.syntax.error=\ 3042 syntax error in reference 3043 3044 compiler.err.dc.ref.unexpected.input=\ 3045 unexpected text 3046 3047 compiler.err.dc.unexpected.content=\ 3048 unexpected content 3049 3050 compiler.err.dc.unterminated.inline.tag=\ 3051 unterminated inline tag 3052 3053 compiler.err.dc.unterminated.signature=\ 3054 unterminated signature 3055 3056 compiler.err.dc.unterminated.string=\ 3057 unterminated string 3058 3059 ### 3060 # errors related to modules 3061 3062 compiler.err.expected.module=\ 3063 expected ''module'' 3064 3065 # 0: symbol 3066 compiler.err.module.not.found=\ 3067 module not found: {0} 3068 3069 # 0: symbol 3070 compiler.warn.module.not.found=\ 3071 module not found: {0} 3072 3073 compiler.err.too.many.modules=\ 3074 too many module declarations found 3075 3076 compiler.err.module.not.found.on.module.source.path=\ 3077 module not found on module source path 3078 3079 compiler.err.not.in.module.on.module.source.path=\ 3080 not in a module on the module source path 3081 3082 # 0: symbol 3083 compiler.err.duplicate.module=\ 3084 duplicate module: {0} 3085 3086 # 0: symbol 3087 compiler.err.duplicate.requires=\ 3088 duplicate requires: {0} 3089 3090 # 0: symbol 3091 compiler.err.conflicting.exports=\ 3092 duplicate or conflicting exports: {0} 3093 3094 # 0: symbol 3095 compiler.err.conflicting.opens=\ 3096 duplicate or conflicting opens: {0} 3097 3098 # 0: symbol 3099 compiler.err.conflicting.exports.to.module=\ 3100 duplicate or conflicting exports to module: {0} 3101 3102 # 0: symbol 3103 compiler.err.conflicting.opens.to.module=\ 3104 duplicate or conflicting opens to module: {0} 3105 3106 compiler.err.no.opens.unless.strong=\ 3107 ''opens'' only allowed in strong modules 3108 3109 # 0: symbol 3110 compiler.err.repeated.provides.for.service=\ 3111 multiple ''provides'' for service {0} 3112 3113 # 0: symbol, 1: symbol 3114 compiler.err.duplicate.provides=\ 3115 duplicate provides: service {0}, implementation {1} 3116 3117 # 0: symbol 3118 compiler.err.duplicate.uses=\ 3119 duplicate uses: {0} 3120 3121 # 0: symbol 3122 compiler.err.service.implementation.is.abstract=\ 3123 the service implementation is an abstract class: {0} 3124 3125 compiler.err.service.implementation.must.be.subtype.of.service.interface=\ 3126 the service implementation type must be a subtype of the service interface type, or \ 3127 have a public static no-args method named "provider" returning the service implementation 3128 3129 compiler.err.service.implementation.provider.return.must.be.subtype.of.service.interface=\ 3130 the "provider" method return type must be a subtype of the service interface type 3131 3132 # 0: symbol 3133 compiler.err.service.implementation.is.inner=\ 3134 the service implementation is an inner class: {0} 3135 3136 # 0: symbol 3137 compiler.err.service.definition.is.enum=\ 3138 the service definition is an enum: {0} 3139 3140 # 0: symbol 3141 compiler.err.service.implementation.doesnt.have.a.no.args.constructor=\ 3142 the service implementation does not have a default constructor: {0} 3143 3144 # 0: symbol 3145 compiler.err.service.implementation.no.args.constructor.not.public=\ 3146 the no arguments constructor of the service implementation is not public: {0} 3147 3148 # 0: symbol 3149 compiler.err.package.empty.or.not.found=\ 3150 package is empty or does not exist: {0} 3151 3152 # 0: symbol 3153 compiler.warn.package.empty.or.not.found=\ 3154 package is empty or does not exist: {0} 3155 3156 compiler.err.no.output.dir=\ 3157 no class output directory specified 3158 3159 compiler.err.unnamed.pkg.not.allowed.named.modules=\ 3160 unnamed package is not allowed in named modules 3161 3162 # 0: name, 1: name 3163 compiler.err.module.name.mismatch=\ 3164 module name {0} does not match expected name {1} 3165 3166 # 0: name, 1: name 3167 compiler.misc.module.name.mismatch=\ 3168 module name {0} does not match expected name {1} 3169 3170 # 0: name 3171 compiler.err.module.non.zero.opens=\ 3172 open module {0} has non-zero opens_count 3173 3174 # 0: name 3175 compiler.misc.module.non.zero.opens=\ 3176 open module {0} has non-zero opens_count 3177 3178 compiler.err.module.decl.sb.in.module-info.java=\ 3179 module declarations should be in a file named module-info.java 3180 3181 # 0: set of string 3182 compiler.err.too.many.patched.modules=\ 3183 too many patched modules ({0}), use --module-source-path 3184 3185 # 0: name, 1: name 3186 compiler.err.file.patched.and.msp=\ 3187 file accessible from both --patch-module and --module-source-path, \ 3188 but belongs to a different module on each path: {0}, {1} 3189 3190 compiler.err.processorpath.no.processormodulepath=\ 3191 illegal combination of -processorpath and --processor-module-path 3192 3193 # 0: symbol 3194 compiler.err.package.in.other.module=\ 3195 package exists in another module: {0} 3196 3197 # 0: symbol, 1: name, 2: symbol, 3: symbol 3198 compiler.err.package.clash.from.requires=\ 3199 module {0} reads package {1} from both {2} and {3} 3200 3201 # 0: name, 1: symbol, 2: symbol 3202 compiler.err.package.clash.from.requires.in.unnamed=\ 3203 the unnamed module reads package {0} from both {1} and {2} 3204 3205 # 0: string 3206 compiler.err.module.not.found.in.module.source.path=\ 3207 module {0} not found in module source path 3208 3209 compiler.err.output.dir.must.be.specified.with.dash.m.option=\ 3210 class output directory must be specified if -m option is used 3211 3212 compiler.err.modulesourcepath.must.be.specified.with.dash.m.option=\ 3213 module source path must be specified if -m option is used 3214 3215 # 0: symbol 3216 compiler.err.service.implementation.not.in.right.module=\ 3217 service implementation must be defined in the same module as the provides directive 3218 3219 # 0: symbol 3220 compiler.err.cyclic.requires=\ 3221 cyclic dependence involving {0} 3222 3223 # 0: fragment, 1: name 3224 compiler.err.duplicate.module.on.path=\ 3225 duplicate module on {0}\nmodule in {1} 3226 3227 # 0: option name, 1: string 3228 compiler.warn.bad.name.for.option=\ 3229 bad name in value for {0} option: ''{1}'' 3230 3231 # 0: option name, 1: string 3232 compiler.err.bad.name.for.option=\ 3233 bad name in value for {0} option: ''{1}'' 3234 3235 # 0: option name, 1: symbol 3236 compiler.warn.module.for.option.not.found=\ 3237 module name in {0} option not found: {1} 3238 3239 compiler.err.addmods.all.module.path.invalid=\ 3240 --add-modules ALL-MODULE-PATH can only be used when compiling the unnamed module 3241 3242 # 0: symbol 3243 compiler.err.add.exports.with.release=\ 3244 exporting a package from system module {0} is not allowed with --release 3245 3246 # 0: symbol 3247 compiler.err.add.reads.with.release=\ 3248 adding read edges for system module {0} is not allowed with --release 3249 3250 compiler.warn.addopens.ignored=\ 3251 --add-opens has no effect at compile time 3252 3253 compiler.misc.locn.module_source_path=\ 3254 module source path 3255 3256 compiler.misc.locn.upgrade_module_path=\ 3257 upgrade module path 3258 3259 compiler.misc.locn.system_modules=\ 3260 system modules 3261 3262 compiler.misc.locn.module_path=\ 3263 application module path 3264 3265 compiler.misc.cant.resolve.modules=\ 3266 cannot resolve modules 3267 3268 compiler.misc.bad.requires.flag=\ 3269 bad requires flag: {0} 3270 3271 # 0: string 3272 compiler.err.invalid.module.specifier=\ 3273 module specifier not allowed: {0} 3274 3275 # 0: symbol 3276 compiler.warn.service.provided.but.not.exported.or.used=\ 3277 service interface provided but not exported or used 3278 3279 # 0: kind name, 1: symbol, 2: symbol 3280 compiler.warn.leaks.not.accessible=\ 3281 {0} {1} in module {2} is not accessible to clients that require this module 3282 # 0: kind name, 1: symbol, 2: symbol 3283 compiler.warn.leaks.not.accessible.unexported=\ 3284 {0} {1} in module {2} is not exported 3285 # 0: kind name, 1: symbol, 2: symbol 3286 compiler.warn.leaks.not.accessible.not.required.transitive=\ 3287 {0} {1} in module {2} is not indirectly exported using 'requires transitive' 3288 # 0: kind name, 1: symbol, 2: symbol 3289 compiler.warn.leaks.not.accessible.unexported.qualified=\ 3290 {0} {1} in module {2} may not be visible to all clients that require this module 3291 3292 ### 3293 # errors related to options 3294 3295 # 0: string, 1: string 3296 compiler.err.illegal.argument.for.option=\ 3297 illegal argument for {0}: {1} 3298 3299 compiler.err.switch.null.not.allowed=\ 3300 null label in case is not allowed 3301 3302 compiler.err.switch.case.unexpected.statement=\ 3303 unexpected statement in case, expected is an expression, a block or a throw statement 3304 3305 compiler.err.switch.mixing.case.types=\ 3306 different case kinds used in the switch 3307 3308 ############################################ 3309 # messages previouly at javac.properties 3310 3311 compiler.err.empty.A.argument=\ 3312 -A requires an argument; use ''-Akey'' or ''-Akey=value'' 3313 3314 # 0: string 3315 compiler.err.invalid.A.key=\ 3316 key in annotation processor option ''{0}'' is not a dot-separated sequence of identifiers 3317 3318 # 0: string 3319 compiler.err.invalid.flag=\ 3320 invalid flag: {0} 3321 3322 compiler.err.profile.bootclasspath.conflict=\ 3323 profile and bootclasspath options cannot be used together 3324 3325 # 0: string 3326 compiler.err.invalid.profile=\ 3327 invalid profile: {0} 3328 3329 # 0: string 3330 compiler.err.invalid.target=\ 3331 invalid target release: {0} 3332 3333 # 0: option name, 1: target 3334 compiler.err.option.not.allowed.with.target=\ 3335 option {0} not allowed with target {1} 3336 3337 # 0: string 3338 compiler.err.option.too.many=\ 3339 option {0} can only be specified once 3340 3341 compiler.err.no.source.files=\ 3342 no source files 3343 3344 compiler.err.no.source.files.classes=\ 3345 no source files or class names 3346 3347 # 0: string 3348 compiler.err.req.arg=\ 3349 {0} requires an argument 3350 3351 # 0: string 3352 compiler.err.invalid.source=\ 3353 invalid source release: {0} 3354 3355 # 0: string, 1: string 3356 compiler.err.error.writing.file=\ 3357 error writing {0}; {1} 3358 3359 compiler.err.sourcepath.modulesourcepath.conflict=\ 3360 cannot specify both --source-path and --module-source-path 3361 3362 # 0: string, 1: target 3363 compiler.warn.source.target.conflict=\ 3364 source release {0} requires target release {1} 3365 3366 # 0: string, 1: target 3367 compiler.warn.target.default.source.conflict=\ 3368 target release {0} conflicts with default source release {1} 3369 3370 # 0: profile, 1: target 3371 compiler.warn.profile.target.conflict=\ 3372 profile {0} is not valid for target release {1} 3373 3374 # 0: string 3375 compiler.err.file.not.directory=\ 3376 not a directory: {0} 3377 3378 # 0: object 3379 compiler.err.file.not.file=\ 3380 not a file: {0} 3381 3382 compiler.err.two.class.loaders.1=\ 3383 javac is split between multiple class loaders: check your configuration 3384 3385 # 0: url, 1: url 3386 compiler.err.two.class.loaders.2=\ 3387 javac is split between multiple class loaders:\n\ 3388 one class comes from file: {0}\n\ 3389 while javac comes from {1} 3390 3391 # 0: string, 1: string 3392 compiler.err.bad.value.for.option=\ 3393 bad value for {0} option: ''{1}'' 3394 3395 # 0: string 3396 compiler.err.no.value.for.option=\ 3397 no value for {0} option 3398 3399 # 0: string 3400 compiler.err.repeated.value.for.patch.module=\ 3401 --patch-module specified more than once for {0} 3402 3403 # 0: string 3404 compiler.err.unmatched.quote=\ 3405 unmatched quote in environment variable {0} 3406 3407 # 0: option name 3408 compiler.err.release.bootclasspath.conflict=\ 3409 option {0} cannot be used together with --release 3410 3411 # 0: string 3412 compiler.err.unsupported.release.version=\ 3413 release version {0} not supported 3414 3415 # 0: string 3416 compiler.err.file.not.found=\ 3417 file not found: {0} 3418 3419 # 0: string, 1: source 3420 compiler.err.preview.not.latest=\ 3421 invalid source release {0} with --enable-preview\n\ 3422 (preview language features are only supported for release {1}) 3423 3424 compiler.err.preview.without.source.or.release=\ 3425 --enable-preview must be used with either -source or --release