jdk-sandbox: comparison langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/resources/compiler.properties

equal deleted inserted replaced

-:d23ae2d67a5d
+:ea7475564d07
 # Messages in this file which use "placeholders" for values (e.g. {0}, {1})
 # are preceded by a stylized comment describing the type of the corresponding
 # values.
 # The simple types currently in use are:
 #
+# annotation        annotation compound
 # boolean           true or false
 # diagnostic        a sub-message; see compiler.misc.*
 # fragment          similar to 'message segment', but with more specific type
 # modifier          a Java modifier; e.g. public, private, protected
 # file              a file URL
 # file object       a file URL - similar to 'file' but typically used for source/class files, hence more specific
+# flag              a Flags.Flag instance
 # name              a name, typically a Java identifier
 # number            an integer
 # option name       the name of a command line option
 # source version    a source version number, such as 1.5, 1.6, 1.7
 # string            a general string
 # object            a Java object (unspecified)
 # unused            the value is not used in this message
 #
 # The following compound types are also used:
 #
+# collection of X   a comma-separated collection of items; e.g. collection of type
 # list of X         a comma-separated list of items; e.g. list of type
-# set of X          a comma-separated collection of items; e.g. set of modifier
+# set of X          a comma-separated set of items; e.g. set of modifier
 #
 # These may be composed:
 #
 # list of type or message segment
 #
 # The following type aliases are supported:
 #
 # message segment --> diagnostic or fragment
-# file name --> file or file object
+# file name --> file, path or file object
 #
 # Custom comments are supported in parenthesis i.e.
 #
 # number (classfile major version)
 #
 {0} is abstract; cannot be instantiated
 compiler.err.abstract.meth.cant.have.body=\
 abstract methods cannot have a body
+# 0: kind name, 1: symbol
 compiler.err.already.annotated=\
 {0} {1} has already been annotated
-# 0: symbol kind, 1: symbol, 2: symbol kind, 3: symbol
+# 0: kind name, 1: symbol, 2: kind name, 3: symbol
 compiler.err.already.defined=\
 {0} {1} is already defined in {2} {3}
-# 0: symbol kind, 1: symbol, 2: symbol kind, 3: symbol kind, 4: symbol
+# 0: kind name, 1: symbol, 2: kind name, 3: kind name, 4: symbol
 compiler.err.already.defined.in.clinit=\
 {0} {1} is already defined in {2} of {3} {4}
-# 0: string
+# 0: symbol
 compiler.err.already.defined.single.import=\
 a type with the same simple name is already defined by the single-type-import of {0}
-# 0: string
+# 0: symbol
 compiler.err.already.defined.static.single.import=\
 a type with the same simple name is already defined by the static single-type-import of {0}
+# 0: symbol
 compiler.err.already.defined.this.unit=\
 {0} is already defined in this compilation unit
 # 0: type, 1: list of name
 compiler.err.annotation.missing.default.value=\
 # 0: symbol kind, 1: name, 2: list of type
 compiler.misc.cant.apply.symbols=\
 no suitable {0} found for {1}({2})
-# 0: symbol kind, 1: symbol
+# 0: kind name, 1: symbol
 compiler.misc.no.abstracts=\
 no abstract method found in {0} {1}
-# 0: symbol kind, 1: symbol
+# 0: kind name, 1: symbol
 compiler.misc.incompatible.abstracts=\
 multiple non-overriding abstract methods found in {0} {1}
 compiler.err.bad.functional.intf.anno=\
 Unexpected @FunctionalInterface annotation
 # 0: symbol, 1: message segment
 compiler.misc.not.a.functional.intf.1=\
 {0} is not a functional interface\n\
 {1}
-# 0: symbol, 1: symbol kind, 2: symbol
+# 0: type, 1: kind name, 2: symbol
 compiler.misc.invalid.generic.lambda.target=\
 invalid functional descriptor for lambda expression\n\
 method {0} in {1} {2} is generic
-# 0: symbol kind, 1: symbol
+# 0: kind name, 1: symbol
 compiler.misc.incompatible.descs.in.functional.intf=\
 incompatible function descriptors found in {0} {1}
 # 0: name, 1: list of type, 2: type, 3: list of type
 compiler.misc.descriptor=\
 # 0: symbol or type
 compiler.misc.not.an.intf.component=\
 component type {0} is not an interface
-# 0: symbol kind, 1: message segment
+# 0: kind name, 1: message segment
 compiler.err.invalid.mref=\
 invalid {0} reference\n\
 {1}
 # 0: symbol kind, 1: message segment
 # 0: symbol
 compiler.err.cant.inherit.from.final=\
 cannot inherit from final {0}
-# 0: symbol
+# 0: symbol or string
 compiler.err.cant.ref.before.ctor.called=\
 cannot reference {0} before supertype constructor has been called
 compiler.err.cant.select.static.class.from.param.type=\
 cannot select a static class from a parameterized type
 {0} cannot be inherited with different arguments: <{1}> and <{2}>
 compiler.err.catch.without.try=\
 ''catch'' without ''try''
-# 0: symbol kind, 1: symbol
+# 0: kind name, 1: symbol
 compiler.err.clash.with.pkg.of.same.name=\
 {0} {1} clashes with package of same name
 compiler.err.class.not.allowed=\
 class, interface or enum declaration not allowed here
 constant expression required
 compiler.err.cont.outside.loop=\
 continue outside of loop
-# 0: symbol
+# 0: symbol or type
 compiler.err.cyclic.inheritance=\
 cyclic inheritance involving {0}
 # 0: symbol
 compiler.err.cyclic.annotation.element=\
 type of element {0} is cyclic
-# 0: unused
+# 0: symbol
 compiler.err.call.to.super.not.allowed.in.enum.ctor=\
 call to super not allowed in enum constructor
 # 0: type
 compiler.err.no.superclass=\
 {0} has no superclass.
-# 0: symbol, 1: type, 2: symbol, 3: type, 4: unused
+# 0: symbol, 1: type, 2: symbol, 3: type, 4: type
 compiler.err.concrete.inheritance.conflict=\
 methods {0} from {1} and {2} from {3} are inherited with the same signature
 compiler.err.default.allowed.in.intf.annotation.member=\
 default value only allowed in an annotation type declaration
 # 0: name, 1: type
 compiler.err.duplicate.annotation.member.value=\
 duplicate element ''{0}'' in annotation @{1}.
-# 0: name, 1: unused
+# 0: type
 compiler.err.duplicate.annotation.missing.container=\
 {0} is not a repeatable annotation type
-# 0: type, 1: unused
+# 0: symbol
 compiler.err.invalid.repeatable.annotation=\
 duplicate annotation: {0} is annotated with an invalid @Repeatable annotation
 # 0: symbol or type
 compiler.err.invalid.repeatable.annotation.no.value=\
 # 0: type
 compiler.err.invalid.repeatable.annotation.invalid.value=\
 {0} is not a valid @Repeatable: invalid value element
-# 0: symbol or type, 1: unused, 2: type
+# 0: symbol or type, 1: type, 2: type
 compiler.err.invalid.repeatable.annotation.value.return=\
 containing annotation type ({0}) must declare an element named ''value'' of type {2}
 # 0: symbol or type, 1: symbol
 compiler.err.invalid.repeatable.annotation.elem.nondefault=\
 containing annotation type ({0}) does not have a default value for element {1}
-# 0: symbol, 1: unused, 2: symbol, 3: unused
+# 0: symbol, 1: string, 2: symbol, 3: string
 compiler.err.invalid.repeatable.annotation.retention=\
 retention of containing annotation type ({0}) is shorter than the retention of repeatable annotation type ({2})
 # 0: symbol, 1: symbol
 compiler.err.invalid.repeatable.annotation.not.documented=\
 # 0: string, 1: string
 compiler.err.illegal.char.for.encoding=\
 unmappable character (0x{0}) for encoding {1}
-# 0: set of modifier, 1: set of modifier
+# 0: set of flag, 1: set of flag
 compiler.err.illegal.combination.of.modifiers=\
 illegal combination of modifiers: {0} and {1}
 compiler.err.illegal.enum.static.ref=\
 illegal reference to static field from initializer
 illegal escape character
 compiler.err.illegal.forward.ref=\
 illegal forward reference
-# 0: symbol, 1: string
+# 0: symbol, 1: object
 compiler.err.not.in.profile=\
 {0} is not available in profile ''{1}''
 # 0: symbol
 compiler.warn.forward.ref=\
 interface expected here
 compiler.err.intf.meth.cant.have.body=\
 interface abstract methods cannot have body
-# 0: symbol
 compiler.err.invalid.annotation.member.type=\
-invalid type for element {0} of annotation type
+invalid type for annotation type element
 compiler.err.invalid.binary.number=\
 binary numbers must contain at least one binary digit
 compiler.err.invalid.hex.number=\
 code requires too much stack
 compiler.err.limit.string=\
 constant string too long
+# 0: string
 compiler.err.limit.string.overflow=\
 UTF8 representation for string \"{0}...\" is too long for the constant pool
 compiler.err.malformed.fp.lit=\
 malformed floating point literal
 missing method body, or declare abstract
 compiler.err.missing.ret.stmt=\
 missing return statement
-# 0: unused
+# 0: type
 compiler.misc.missing.ret.val=\
 missing return value
 compiler.misc.unexpected.ret.val=\
 unexpected return value
-# 0: set of modifier
+# 0: set of flag
 compiler.err.mod.not.allowed.here=\
 modifier {0} not allowed here
 compiler.err.intf.not.allowed.here=\
 interface not allowed here
 {0}
 compiler.misc.conditional.target.cant.be.void=\
 target-type for conditional expression cannot be void
-# 0: type
+# 0: message segment
 compiler.misc.incompatible.ret.type.in.lambda=\
 bad return type in lambda expression\n\
 {0}
 compiler.misc.stat.expr.expected=\
 lambda body is not compatible with a void functional interface\n\
 (consider using a block lambda body, or use a statement expression instead)
-# 0: type
+# 0: message segment
 compiler.misc.incompatible.ret.type.in.mref=\
 bad return type in method reference\n\
 {0}
 compiler.err.lambda.body.neither.value.nor.void.compatible=\
 incompatible parameter types in method reference
 compiler.err.new.not.allowed.in.annotation=\
 ''new'' not allowed in an annotation
+# 0: name, 1: type
 compiler.err.no.annotation.member=\
 no annotation member {0} in {1}
+# 0: symbol
 compiler.err.no.encl.instance.of.type.in.scope=\
 no enclosing instance of type {0} is in scope
 compiler.err.no.intf.expected.here=\
 no interface expected here
 compiler.err.no.match.entry=\
 {0} has no match in entry in {1}; required {2}
+# 0: type
 compiler.err.not.annotation.type=\
 {0} is not an annotation type
 # 0: symbol, 1: symbol, 2: message segment
 compiler.err.not.def.access.package.cant.access=\
 compiler.err.warnings.and.werror=\
 warnings found and -Werror specified
 # Errors related to annotation processing
-# 0: symbol, 1: string, 2: string (stack-trace)
+# 0: symbol, 1: message segment, 2: string (stack-trace)
 compiler.err.proc.cant.access=\
 cannot access {0}\n\
 {1}\n\
 Consult the following stack trace for details.\n\
 {2}
-# 0: symbol, 1: string
+# 0: symbol, 1: message segment
 compiler.err.proc.cant.access.1=\
 cannot access {0}\n\
 {1}
 # 0: string
 # Print a client-generated error message; assumed to be localized, no translation required
 # 0: string
 compiler.err.proc.messager=\
 {0}
-# 0: list of string
+# 0: string
+compiler.misc.exception.message=\
+{0}
+compiler.misc.user.selected.completion.failure=\
+user-selected completion failure by class name
+# 0: collection of string
 compiler.err.proc.no.explicit.annotation.processing.requested=\
 Class names, ''{0}'', are only accepted if annotation processing is explicitly requested
 compiler.err.proc.no.service=\
 A ServiceLoader was not usable and is required for annotation processing.
+# 0: string, 1: string
 compiler.err.proc.processor.bad.option.name=\
 Bad option name ''{0}'' provided by processor ''{1}''
 # 0: string
 compiler.err.proc.processor.cant.instantiate=\
 Annotation processor ''{0}'' does not implement javax.annotation.processing.Processor
 compiler.err.proc.service.problem=\
 Error creating a service loader to load Processors.
+# 0: string
 compiler.err.proc.bad.config.file=\
 Bad service configuration file, or exception thrown while constructing Processor object: {0}
 compiler.err.proc.cant.create.loader=\
 Could not create class loader for annotation processors: {0}
-# 0: unused
+# 0: symbol
 compiler.err.qualified.new.of.static.class=\
 qualified new of static class
 compiler.err.recursive.ctor.invocation=\
 recursive constructor invocation
 # 0: symbol, 1: symbol, 2: symbol
 compiler.err.does.not.override.abstract=\
 {0} is not abstract and does not override abstract method {1} in {2}
+# 0: file object
 compiler.err.source.cant.overwrite.input.file=\
 error writing source; cannot overwrite input file {0}
+# 0: symbol
 compiler.err.stack.sim.error=\
 Internal error: stack sim error on {0}
 compiler.err.static.imp.only.classes.and.interfaces=\
 static import only from classes and interfaces
 # 0: type
 compiler.err.illegal.static.intf.meth.call=\
 illegal static interface method call\n\
 the receiver expression should be replaced with the type qualifier ''{0}''
-# 0: type, 1: message segment
+# 0: symbol or type, 1: message segment
 compiler.err.illegal.default.super.call=\
 bad type qualifier {0} in default super call\n\
 {1}
 # 0: symbol, 1: type
 unclosed comment
 compiler.err.unclosed.str.lit=\
 unclosed string literal
-# 0: name
+# 0: string
 compiler.err.unsupported.encoding=\
 unsupported encoding: {0}
 compiler.err.io.exception=\
 error reading source file: {0}
 # Fatal Errors
 compiler.misc.fatal.err.no.java.lang=\
 Fatal Error: Unable to find package java.lang in classpath or bootclasspath
+# 0: name
 compiler.misc.fatal.err.cant.locate.meth=\
 Fatal Error: Unable to find method {0}
+# 0: name
 compiler.misc.fatal.err.cant.locate.field=\
 Fatal Error: Unable to find field {0}
+# 0: type
 compiler.misc.fatal.err.cant.locate.ctor=\
 Fatal Error: Unable to find constructor for {0}
 compiler.misc.fatal.err.cant.close=\
 Fatal Error: Cannot close compiler resources
 # 0: symbol
 compiler.warn.constant.SVUID=\
 serialVersionUID must be constant in class {0}
-# 0: file name
+# 0: path
 compiler.warn.dir.path.element.not.found=\
 bad path element "{0}": no such directory
 # 0: file name
 compiler.warn.dir.path.element.not.directory=\
 # 0: message segment
 compiler.warn.override.varargs.extra=\
 {0}; overriding method is missing ''...''
+# 0: message segment
 compiler.warn.override.bridge=\
 {0}; overridden method is a bridge method
 # 0: symbol
 compiler.warn.pkg-info.already.seen=\
 a package-info.java file has already been seen for package {0}
-# 0: file name
+# 0: path
 compiler.warn.path.element.not.found=\
 bad path element "{0}": no such file or directory
 compiler.warn.possible.fall-through.into.case=\
 possible fall-through into case
 # Warnings related to annotation processing
 # 0: string
 compiler.warn.proc.package.does.not.exist=\
 package {0} does not exist
-# 0: name
+# 0: string
 compiler.warn.proc.file.reopening=\
 Attempt to create a file for ''{0}'' multiple times
 # 0: name
 compiler.warn.proc.type.already.exists=\
 A file for type ''{0}'' already exists on the sourcepath or classpath
-# 0: name
+# 0: string
 compiler.warn.proc.type.recreate=\
 Attempt to create a file for type ''{0}'' multiple times
 # 0: string
 compiler.warn.proc.illegal.file.name=\
 # 0: string, 1: string
 compiler.warn.proc.suspicious.class.name=\
 Creating file for a type whose name ends in {1}: ''{0}''
-# 0: name
+# 0: string
 compiler.warn.proc.file.create.last.round=\
 File for type ''{0}'' created in the last round will not be subject to annotation processing.
 # 0: string, 1: string
 compiler.warn.proc.malformed.supported.string=\
 # Print a client-generated warning; assumed to be localized, no translation required
 # 0: string
 compiler.warn.proc.messager=\
 {0}
-# 0: set of name
+# 0: set of string
 compiler.warn.proc.unclosed.type.files=\
 Unclosed files for the types ''{0}''; these types will not undergo annotation processing
 # 0: string
 compiler.warn.proc.unmatched.processor.options=\
 Varargs method could cause heap pollution from non-reifiable varargs parameter {0}
 compiler.warn.missing.deprecated.annotation=\
 deprecated item is not annotated with @Deprecated
-# 0: symbol kind
+# 0: kind name
 compiler.warn.deprecated.annotation.has.no.effect=\
 @Deprecated annotation has no effect on this {0} declaration
+# 0: string
 compiler.warn.invalid.path=\
 Invalid filename: {0}
+# 0: path
 compiler.warn.invalid.archive.file=\
 Unexpected file on path: {0}
+# 0: path
 compiler.warn.unexpected.archive.file=\
 Unexpected extension for archive file: {0}
 # 0: path
 compiler.err.no.zipfs.for.archive=\
 division by zero
 compiler.warn.empty.if=\
 empty statement after if
+# 0: type, 1: name
 compiler.warn.annotation.method.not.found=\
 Cannot find annotation method ''{1}()'' in type ''{0}''
+# 0: type, 1: name, 2: message segment
 compiler.warn.annotation.method.not.found.reason=\
 Cannot find annotation method ''{1}()'' in type ''{0}'': {2}
-# 0: symbol, 1: name
+# 0: file object, 1: symbol, 2: name
 compiler.warn.unknown.enum.constant=\
 unknown enum constant {1}.{2}
-# 0: symbol, 1: name, 2: message segment
+# 0: file object, 1: symbol, 2: name, 3: message segment
 compiler.warn.unknown.enum.constant.reason=\
 unknown enum constant {1}.{2}\n\
 reason: {3}
 # 0: type, 1: type
 compiler.warn.raw.class.use=\
 found raw type: {0}\n\
 missing type arguments for generic class {1}
-# 0: unused, 1: unused
 compiler.warn.diamond.redundant.args=\
 Redundant type arguments in new expression (use diamond operator instead).
 compiler.warn.potential.lambda.found=\
 This anonymous inner class creation can be turned into a lambda expression.
 class file contains wrong class: {0}
 compiler.misc.module.info.invalid.super.class=\
 module-info with invalid super class
+# 0: name
 compiler.misc.class.file.not.found=\
 class file for {0} not found
 # 0: string (constant value), 1: symbol (constant field), 2: type (field type)
 compiler.misc.bad.constant.range=\
 # 0: name
 compiler.misc.file.doesnt.contain.class=\
 file does not contain class {0}
+# 0: symbol
 compiler.misc.file.does.not.contain.package=\
 file does not contain package {0}
 compiler.misc.file.does.not.contain.module=\
 file does not contain module declaration
 # compiler.err.star.expected=\
 #     ''*'' expected
 # compiler.err.no.elem.type=\
 #     \[\*\] cannot have a type
-# 0: type
+# 0: message segment
 compiler.misc.try.not.applicable.to.type=\
 try-with-resources not applicable to variable type\n\
 ({0})
 #####
-# 0: message segment or type, 1: message segment
+# 0: object, 1: message segment
 compiler.err.type.found.req=\
 unexpected type\n\
 required: {1}\n\
 found:    {0}
 # 0: list of type, 1: message segment
 compiler.misc.diamond.invalid.args=\
 type arguments {0} inferred for {1} are not allowed in this context\n\
 inferred arguments are not expressible in the Signature attribute
-# 0: unused
+# 0: type
 compiler.misc.diamond.and.explicit.params=\
 cannot use ''<>'' with explicit type parameters for constructor
-# 0: unused
 compiler.misc.mref.infer.and.explicit.params=\
 cannot use raw constructor reference with explicit type parameters for constructor
 # 0: type, 1: list of type
 compiler.misc.explicit.param.do.not.conform.to.bounds=\
 # 0: symbol or type, 1: file name
 compiler.warn.auxiliary.class.accessed.from.outside.of.its.source.file=\
 auxiliary class {0} in {1} should not be accessed from outside its own source file
 ## The first argument ({0}) is a "kindname".
-# 0: symbol kind, 1: symbol, 2: symbol
+# 0: kind name, 1: symbol, 2: symbol
 compiler.err.abstract.cant.be.accessed.directly=\
 abstract {0} {1} in {2} cannot be accessed directly
 ## The first argument ({0}) is a "kindname".
 # 0: symbol kind, 1: symbol
 compiler.misc.bad.static.method.in.bound.lookup=\
 unexpected static {0} {1} found in bound lookup
 ## Both arguments ({0}, {1}) are "kindname"s.  {0} is a comma-separated list
 ## of kindnames (the list should be identical to that provided in source.
+# 0: set of kind name, 1: set of kind name
 compiler.err.unexpected.type=\
 unexpected type\n\
 required: {0}\n\
 found:    {1}
 ## The first argument {0} is a "kindname" (e.g. 'constructor', 'field', etc.)
 ## The second argument {1} is the non-resolved symbol
 ## The third argument {2} is a list of type parameters (non-empty if {1} is a method)
 ## The fourth argument {3} is a list of argument types (non-empty if {1} is a method)
-# 0: symbol kind, 1: name, 2: unused, 3: unused
+# 0: kind name, 1: name, 2: unused, 3: unused
 compiler.err.cant.resolve=\
 cannot find symbol\n\
 symbol: {0} {1}
-# 0: symbol kind, 1: name, 2: unused, 3: list of type
+# 0: kind name, 1: name, 2: unused, 3: list of type
 compiler.err.cant.resolve.args=\
 cannot find symbol\n\
 symbol: {0} {1}({3})
-# 0: symbol kind, 1: name, 2: list of type, 3: list of type
+# 0: kind name, 1: name, 2: list of type, 3: list of type
 compiler.err.cant.resolve.args.params=\
 cannot find symbol\n\
 symbol: {0} <{2}>{1}({3})
 ## arguments from {0} to {3} have the same meaning as above
 ## The fifth argument {4} is a location subdiagnostic (see below)
-# 0: symbol kind, 1: name, 2: unused, 3: unused, 4: message segment
+# 0: kind name, 1: name, 2: unused, 3: unused, 4: message segment
 compiler.err.cant.resolve.location=\
 cannot find symbol\n\
 symbol:   {0} {1}\n\
 location: {4}
-# 0: symbol kind, 1: name, 2: unused, 3: list of type, 4: message segment
+# 0: kind name, 1: name, 2: unused, 3: list of type, 4: message segment
 compiler.err.cant.resolve.location.args=\
 cannot find symbol\n\
 symbol:   {0} {1}({3})\n\
 location: {4}
-# 0: symbol kind, 1: name, 2: list of type, 3: list, 4: message segment
+# 0: kind name, 1: name, 2: list of type, 3: list, 4: message segment
 compiler.err.cant.resolve.location.args.params=\
 cannot find symbol\n\
 symbol:   {0} <{2}>{1}({3})\n\
 location: {4}
 ### Following are replicated/used for method reference diagnostics
-# 0: symbol kind, 1: name, 2: unused, 3: list of type, 4: message segment
+# 0: kind name, 1: name, 2: unused, 3: list of type, 4: message segment
 compiler.misc.cant.resolve.location.args=\
 cannot find symbol\n\
 symbol:   {0} {1}({3})\n\
 location: {4}
-# 0: symbol kind, 1: name, 2: list of type, 3: list, 4: message segment
+# 0: kind name, 1: name, 2: list of type, 3: list, 4: message segment
 compiler.misc.cant.resolve.location.args.params=\
 cannot find symbol\n\
 symbol:   {0} <{2}>{1}({3})\n\
 location: {4}
 ##a location subdiagnostic is composed as follows:
 ## The first argument {0} is the location "kindname" (e.g. 'constructor', 'field', etc.)
 ## The second argument {1} is the location name
 ## The third argument {2} is the location type (only when {1} is a variable name)
-# 0: symbol kind, 1: type or symbol, 2: unused
+# 0: kind name, 1: type or symbol, 2: unused
 compiler.misc.location=\
 {0} {1}
-# 0: symbol kind, 1: symbol, 2: type
+# 0: kind name, 1: symbol, 2: type
 compiler.misc.location.1=\
 {0} {1} of type {2}
 ## The following are all possible string for "kindname".
 ## They should be called whatever the JLS calls them after it been translated
 # 0: message segment
 compiler.err.override.static=\
 {0}\n\
 overriding method is static
-# 0: message segment, 1: set of modifier
+# 0: message segment, 1: set of flag
 compiler.err.override.meth=\
 {0}\n\
 overridden method is {1}
 # 0: message segment, 1: type
 {0}\n\
 overridden method does not throw {1}
 # In the following string {1} is a space separated list of Java Keywords, as
 # they would have been declared in the source code
-# 0: message segment, 1: set of modifier
+# 0: message segment, 1: set of flag or string
 compiler.err.override.weaker.access=\
 {0}\n\
 attempting to assign weaker access privileges; was {1}
 # 0: message segment, 1: type, 2: type
 # 0: symbol, 1: symbol, 2: symbol, 3: symbol
 compiler.misc.varargs.clash.with=\
 {0} in {1} overrides {2} in {3}
-# 0: symbol kind, 1: symbol, 2: symbol, 3: message segment
+# 0: kind name, 1: symbol, 2: symbol, 3: message segment
 compiler.misc.inapplicable.method=\
 {0} {1}.{2} is not applicable\n\
 ({3})
 ########################################
 # TODO 308: make a better error message
 compiler.err.this.as.identifier=\
 as of release 8, ''this'' is allowed as the parameter name for the receiver type only, which has to be the first parameter
-# 0: symbol
 compiler.err.receiver.parameter.not.applicable.constructor.toplevel.class=\
 receiver parameter not applicable for constructor of top-level class
 # TODO 308: make a better error message
-# 0: symbol
+# 0: annotation
 compiler.err.cant.type.annotate.scoping.1=\
 scoping construct cannot be annotated with type-use annotation: {0}
 # TODO 308: make a better error message
-# 0: list of symbol
+# 0: list of annotation
 compiler.err.cant.type.annotate.scoping=\
 scoping construct cannot be annotated with type-use annotations: {0}
 # 0: type, 1: type
 compiler.err.incorrect.receiver.name=\

changeset 45504	ea7475564d07
parent 45500	365640343c55
child 45744	db6aedca2c8c