package com.sun.tools.javac.resources;

import com.sun.tools.javac.code.Attribute.Compound;
import com.sun.tools.javac.code.Flags.Flag;
import com.sun.tools.javac.code.Kinds.Kind;
import com.sun.tools.javac.code.Kinds.KindName;
import com.sun.tools.javac.code.Source;
import com.sun.tools.javac.code.Symbol;
import com.sun.tools.javac.code.Type;
import com.sun.tools.javac.jvm.Profile;
import com.sun.tools.javac.jvm.Target;
import com.sun.tools.javac.main.Option;
import com.sun.tools.javac.parser.Tokens.TokenKind;
import com.sun.tools.javac.util.JCDiagnostic;
import com.sun.tools.javac.util.Name;
import java.io.File;
import java.net.URL;
import java.nio.file.Path;
import java.util.Collection;
import java.util.List;
import java.util.Set;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.Modifier;
import javax.tools.JavaFileObject;
import com.sun.tools.javac.util.JCDiagnostic.Error;
import com.sun.tools.javac.util.JCDiagnostic.Warning;
import com.sun.tools.javac.util.JCDiagnostic.Note;
import com.sun.tools.javac.util.JCDiagnostic.Fragment;

public class CompilerProperties {
    public static class Errors {
        
compiler.err.abstract.cant.be.accessed.directly=\ abstract {0} {1} in {2} cannot be accessed directly
/** * compiler.err.abstract.cant.be.accessed.directly=\ * abstract {0} {1} in {2} cannot be accessed directly */
public static Error AbstractCantBeAccessedDirectly(KindName arg0, Symbol arg1, Symbol arg2) { return new Error("compiler", "abstract.cant.be.accessed.directly", arg0, arg1, arg2); }
compiler.err.abstract.cant.be.instantiated=\ {0} is abstract; cannot be instantiated
/** * compiler.err.abstract.cant.be.instantiated=\ * {0} is abstract; cannot be instantiated */
public static Error AbstractCantBeInstantiated(Symbol arg0) { return new Error("compiler", "abstract.cant.be.instantiated", arg0); }
compiler.err.abstract.meth.cant.have.body=\ abstract methods cannot have a body
/** * compiler.err.abstract.meth.cant.have.body=\ * abstract methods cannot have a body */
public static final Error AbstractMethCantHaveBody = new Error("compiler", "abstract.meth.cant.have.body");
compiler.err.add.exports.with.release=\ exporting a package from system module {0} is not allowed with --release
/** * compiler.err.add.exports.with.release=\ * exporting a package from system module {0} is not allowed with --release */
public static Error AddExportsWithRelease(Symbol arg0) { return new Error("compiler", "add.exports.with.release", arg0); }
compiler.err.add.reads.with.release=\ adding read edges for system module {0} is not allowed with --release
/** * compiler.err.add.reads.with.release=\ * adding read edges for system module {0} is not allowed with --release */
public static Error AddReadsWithRelease(Symbol arg0) { return new Error("compiler", "add.reads.with.release", arg0); }
compiler.err.addmods.all.module.path.invalid=\ --add-modules ALL-MODULE-PATH can only be used when compiling the unnamed module or \ when compiling in the context of an automatic module
/** * compiler.err.addmods.all.module.path.invalid=\ * --add-modules ALL-MODULE-PATH can only be used when compiling the unnamed module or \ * when compiling in the context of an automatic module */
public static final Error AddmodsAllModulePathInvalid = new Error("compiler", "addmods.all.module.path.invalid");
compiler.err.already.annotated=\ {0} {1} has already been annotated
/** * compiler.err.already.annotated=\ * {0} {1} has already been annotated */
public static Error AlreadyAnnotated(KindName arg0, Symbol arg1) { return new Error("compiler", "already.annotated", arg0, arg1); }
compiler.err.already.defined=\ {0} {1} is already defined in {2} {3}
/** * compiler.err.already.defined=\ * {0} {1} is already defined in {2} {3} */
public static Error AlreadyDefined(KindName arg0, Symbol arg1, KindName arg2, Symbol arg3) { return new Error("compiler", "already.defined", arg0, arg1, arg2, arg3); }
compiler.err.already.defined.in.clinit=\ {0} {1} is already defined in {2} of {3} {4}
/** * compiler.err.already.defined.in.clinit=\ * {0} {1} is already defined in {2} of {3} {4} */
public static Error AlreadyDefinedInClinit(KindName arg0, Symbol arg1, KindName arg2, KindName arg3, Symbol arg4) { return new Error("compiler", "already.defined.in.clinit", arg0, arg1, arg2, arg3, arg4); }
compiler.err.already.defined.single.import=\ a type with the same simple name is already defined by the single-type-import of {0}
/** * compiler.err.already.defined.single.import=\ * a type with the same simple name is already defined by the single-type-import of {0} */
public static Error AlreadyDefinedSingleImport(Symbol arg0) { return new Error("compiler", "already.defined.single.import", arg0); }
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}
/** * 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} */
public static Error AlreadyDefinedStaticSingleImport(Symbol arg0) { return new Error("compiler", "already.defined.static.single.import", arg0); }
compiler.err.already.defined.this.unit=\ {0} is already defined in this compilation unit
/** * compiler.err.already.defined.this.unit=\ * {0} is already defined in this compilation unit */
public static Error AlreadyDefinedThisUnit(Symbol arg0) { return new Error("compiler", "already.defined.this.unit", arg0); }
compiler.err.annotation.decl.not.allowed.here=\ annotation type declaration not allowed here
/** * compiler.err.annotation.decl.not.allowed.here=\ * annotation type declaration not allowed here */
public static final Error AnnotationDeclNotAllowedHere = new Error("compiler", "annotation.decl.not.allowed.here");
compiler.err.annotation.missing.default.value=\ annotation @{0} is missing a default value for the element ''{1}''
/** * compiler.err.annotation.missing.default.value=\ * annotation @{0} is missing a default value for the element ''{1}'' */
public static Error AnnotationMissingDefaultValue(Type arg0, List<? extends Name> arg1) { return new Error("compiler", "annotation.missing.default.value", arg0, arg1); }
compiler.err.annotation.missing.default.value.1=\ annotation @{0} is missing default values for elements {1}
/** * compiler.err.annotation.missing.default.value.1=\ * annotation @{0} is missing default values for elements {1} */
public static Error AnnotationMissingDefaultValue1(Type arg0, List<? extends Name> arg1) { return new Error("compiler", "annotation.missing.default.value.1", arg0, arg1); }
compiler.err.annotation.not.valid.for.type=\ annotation not valid for an element of type {0}
/** * compiler.err.annotation.not.valid.for.type=\ * annotation not valid for an element of type {0} */
public static Error AnnotationNotValidForType(Type arg0) { return new Error("compiler", "annotation.not.valid.for.type", arg0); }
compiler.err.annotation.type.not.applicable=\ annotation type not applicable to this kind of declaration
/** * compiler.err.annotation.type.not.applicable=\ * annotation type not applicable to this kind of declaration */
public static final Error AnnotationTypeNotApplicable = new Error("compiler", "annotation.type.not.applicable");
compiler.err.annotation.type.not.applicable.to.type=\ annotation @{0} not applicable in this type context
/** * compiler.err.annotation.type.not.applicable.to.type=\ * annotation @{0} not applicable in this type context */
public static Error AnnotationTypeNotApplicableToType(Type arg0) { return new Error("compiler", "annotation.type.not.applicable.to.type", arg0); }
compiler.err.annotation.value.must.be.annotation=\ annotation value must be an annotation
/** * compiler.err.annotation.value.must.be.annotation=\ * annotation value must be an annotation */
public static final Error AnnotationValueMustBeAnnotation = new Error("compiler", "annotation.value.must.be.annotation");
compiler.err.annotation.value.must.be.class.literal=\ annotation value must be a class literal
/** * compiler.err.annotation.value.must.be.class.literal=\ * annotation value must be a class literal */
public static final Error AnnotationValueMustBeClassLiteral = new Error("compiler", "annotation.value.must.be.class.literal");
compiler.err.annotation.value.must.be.name.value=\ annotation values must be of the form ''name=value''
/** * compiler.err.annotation.value.must.be.name.value=\ * annotation values must be of the form ''name=value'' */
public static final Error AnnotationValueMustBeNameValue = new Error("compiler", "annotation.value.must.be.name.value");
compiler.err.annotation.value.not.allowable.type=\ annotation value not of an allowable type
/** * compiler.err.annotation.value.not.allowable.type=\ * annotation value not of an allowable type */
public static final Error AnnotationValueNotAllowableType = new Error("compiler", "annotation.value.not.allowable.type");
compiler.err.anon.class.impl.intf.no.args=\ anonymous class implements interface; cannot have arguments
/** * compiler.err.anon.class.impl.intf.no.args=\ * anonymous class implements interface; cannot have arguments */
public static final Error AnonClassImplIntfNoArgs = new Error("compiler", "anon.class.impl.intf.no.args");
compiler.err.anon.class.impl.intf.no.qual.for.new=\ anonymous class implements interface; cannot have qualifier for new
/** * compiler.err.anon.class.impl.intf.no.qual.for.new=\ * anonymous class implements interface; cannot have qualifier for new */
public static final Error AnonClassImplIntfNoQualForNew = new Error("compiler", "anon.class.impl.intf.no.qual.for.new");
compiler.err.anon.class.impl.intf.no.typeargs=\ anonymous class implements interface; cannot have type arguments
/** * compiler.err.anon.class.impl.intf.no.typeargs=\ * anonymous class implements interface; cannot have type arguments */
public static final Error AnonClassImplIntfNoTypeargs = new Error("compiler", "anon.class.impl.intf.no.typeargs");
compiler.err.anonymous.diamond.method.does.not.override.superclass=\ method does not override or implement a method from a supertype\n\ {0}
/** * compiler.err.anonymous.diamond.method.does.not.override.superclass=\ * method does not override or implement a method from a supertype\n\ * {0} */
public static Error AnonymousDiamondMethodDoesNotOverrideSuperclass(JCDiagnostic arg0) { return new Error("compiler", "anonymous.diamond.method.does.not.override.superclass", arg0); }
compiler.err.anonymous.diamond.method.does.not.override.superclass=\ method does not override or implement a method from a supertype\n\ {0}
/** * compiler.err.anonymous.diamond.method.does.not.override.superclass=\ * method does not override or implement a method from a supertype\n\ * {0} */
public static Error AnonymousDiamondMethodDoesNotOverrideSuperclass(Fragment arg0) { return new Error("compiler", "anonymous.diamond.method.does.not.override.superclass", arg0); }
compiler.err.array.and.receiver =\ legacy array notation not allowed on receiver parameter
/** * compiler.err.array.and.receiver =\ * legacy array notation not allowed on receiver parameter */
public static final Error ArrayAndReceiver = new Error("compiler", "array.and.receiver");
compiler.err.array.and.varargs=\ cannot declare both {0} and {1} in {2}
/** * compiler.err.array.and.varargs=\ * cannot declare both {0} and {1} in {2} */
public static Error ArrayAndVarargs(Symbol arg0, Symbol arg1, Symbol arg2) { return new Error("compiler", "array.and.varargs", arg0, arg1, arg2); }
compiler.err.array.dimension.missing=\ array dimension missing
/** * compiler.err.array.dimension.missing=\ * array dimension missing */
public static final Error ArrayDimensionMissing = new Error("compiler", "array.dimension.missing");
compiler.err.array.req.but.found=\ array required, but {0} found
/** * compiler.err.array.req.but.found=\ * array required, but {0} found */
public static Error ArrayReqButFound(Type arg0) { return new Error("compiler", "array.req.but.found", arg0); }
compiler.err.assert.as.identifier=\ as of release 1.4, ''assert'' is a keyword, and may not be used as an identifier
/** * compiler.err.assert.as.identifier=\ * as of release 1.4, ''assert'' is a keyword, and may not be used as an identifier */
public static final Error AssertAsIdentifier = new Error("compiler", "assert.as.identifier");
compiler.err.attribute.value.must.be.constant=\ element value must be a constant expression
/** * compiler.err.attribute.value.must.be.constant=\ * element value must be a constant expression */
public static final Error AttributeValueMustBeConstant = new Error("compiler", "attribute.value.must.be.constant");
compiler.err.bad.functional.intf.anno=\ Unexpected @FunctionalInterface annotation
/** * compiler.err.bad.functional.intf.anno=\ * Unexpected @FunctionalInterface annotation */
public static final Error BadFunctionalIntfAnno = new Error("compiler", "bad.functional.intf.anno");
compiler.err.bad.functional.intf.anno.1=\ Unexpected @FunctionalInterface annotation\n\ {0}
/** * compiler.err.bad.functional.intf.anno.1=\ * Unexpected @FunctionalInterface annotation\n\ * {0} */
public static Error BadFunctionalIntfAnno1(JCDiagnostic arg0) { return new Error("compiler", "bad.functional.intf.anno.1", arg0); }
compiler.err.bad.functional.intf.anno.1=\ Unexpected @FunctionalInterface annotation\n\ {0}
/** * compiler.err.bad.functional.intf.anno.1=\ * Unexpected @FunctionalInterface annotation\n\ * {0} */
public static Error BadFunctionalIntfAnno1(Fragment arg0) { return new Error("compiler", "bad.functional.intf.anno.1", arg0); }
compiler.err.bad.initializer=\ bad initializer for {0}
/** * compiler.err.bad.initializer=\ * bad initializer for {0} */
public static Error BadInitializer(String arg0) { return new Error("compiler", "bad.initializer", arg0); }
compiler.err.bad.name.for.option=\ bad name in value for {0} option: ''{1}''
/** * compiler.err.bad.name.for.option=\ * bad name in value for {0} option: ''{1}'' */
public static Error BadNameForOption(Option arg0, String arg1) { return new Error("compiler", "bad.name.for.option", arg0, arg1); }
compiler.err.bad.value.for.option=\ bad value for {0} option: ''{1}''
/** * compiler.err.bad.value.for.option=\ * bad value for {0} option: ''{1}'' */
public static Error BadValueForOption(String arg0, String arg1) { return new Error("compiler", "bad.value.for.option", arg0, arg1); }
compiler.err.break.outside.switch.expression=\ attempt to break out of a switch expression
/** * compiler.err.break.outside.switch.expression=\ * attempt to break out of a switch expression */
public static final Error BreakOutsideSwitchExpression = new Error("compiler", "break.outside.switch.expression");
compiler.err.break.outside.switch.loop=\ break outside switch or loop
/** * compiler.err.break.outside.switch.loop=\ * break outside switch or loop */
public static final Error BreakOutsideSwitchLoop = new Error("compiler", "break.outside.switch.loop");
compiler.err.call.must.be.first.stmt.in.ctor=\ call to {0} must be first statement in constructor
/** * compiler.err.call.must.be.first.stmt.in.ctor=\ * call to {0} must be first statement in constructor */
public static Error CallMustBeFirstStmtInCtor(Name arg0) { return new Error("compiler", "call.must.be.first.stmt.in.ctor", arg0); }
compiler.err.call.to.super.not.allowed.in.enum.ctor=\ call to super not allowed in enum constructor
/** * compiler.err.call.to.super.not.allowed.in.enum.ctor=\ * call to super not allowed in enum constructor */
public static Error CallToSuperNotAllowedInEnumCtor(Symbol arg0) { return new Error("compiler", "call.to.super.not.allowed.in.enum.ctor", arg0); }
compiler.err.cannot.create.array.with.diamond=\ cannot create array with ''<>''
/** * compiler.err.cannot.create.array.with.diamond=\ * cannot create array with ''<>'' */
public static final Error CannotCreateArrayWithDiamond = new Error("compiler", "cannot.create.array.with.diamond");
compiler.err.cannot.create.array.with.type.arguments=\ cannot create array with type arguments
/** * compiler.err.cannot.create.array.with.type.arguments=\ * cannot create array with type arguments */
public static final Error CannotCreateArrayWithTypeArguments = new Error("compiler", "cannot.create.array.with.type.arguments");
compiler.err.cannot.generate.class=\ error while generating class {0}\n\ ({1})
/** * compiler.err.cannot.generate.class=\ * error while generating class {0}\n\ * ({1}) */
public static Error CannotGenerateClass(Symbol arg0, Fragment arg1) { return new Error("compiler", "cannot.generate.class", arg0, arg1); }
compiler.err.cant.access=\ cannot access {0}\n\ {1}
/** * compiler.err.cant.access=\ * cannot access {0}\n\ * {1} */
public static Error CantAccess(Symbol arg0, JCDiagnostic arg1) { return new Error("compiler", "cant.access", arg0, arg1); }
compiler.err.cant.access=\ cannot access {0}\n\ {1}
/** * compiler.err.cant.access=\ * cannot access {0}\n\ * {1} */
public static Error CantAccess(Symbol arg0, Fragment arg1) { return new Error("compiler", "cant.access", arg0, arg1); }
compiler.err.cant.apply.diamond=\ cannot infer type arguments for {0}
/** * compiler.err.cant.apply.diamond=\ * cannot infer type arguments for {0} */
public static Error CantApplyDiamond(JCDiagnostic arg0, Void arg1) { return new Error("compiler", "cant.apply.diamond", arg0, arg1); }
compiler.err.cant.apply.diamond=\ cannot infer type arguments for {0}
/** * compiler.err.cant.apply.diamond=\ * cannot infer type arguments for {0} */
public static Error CantApplyDiamond(Fragment arg0, Void arg1) { return new Error("compiler", "cant.apply.diamond", arg0, arg1); }
compiler.err.cant.apply.diamond.1=\ cannot infer type arguments for {0}\n\ reason: {1}
/** * compiler.err.cant.apply.diamond.1=\ * cannot infer type arguments for {0}\n\ * reason: {1} */
public static Error CantApplyDiamond1(JCDiagnostic arg0, JCDiagnostic arg1) { return new Error("compiler", "cant.apply.diamond.1", arg0, arg1); }
compiler.err.cant.apply.diamond.1=\ cannot infer type arguments for {0}\n\ reason: {1}
/** * compiler.err.cant.apply.diamond.1=\ * cannot infer type arguments for {0}\n\ * reason: {1} */
public static Error CantApplyDiamond1(JCDiagnostic arg0, Fragment arg1) { return new Error("compiler", "cant.apply.diamond.1", arg0, arg1); }
compiler.err.cant.apply.diamond.1=\ cannot infer type arguments for {0}\n\ reason: {1}
/** * compiler.err.cant.apply.diamond.1=\ * cannot infer type arguments for {0}\n\ * reason: {1} */
public static Error CantApplyDiamond1(Fragment arg0, JCDiagnostic arg1) { return new Error("compiler", "cant.apply.diamond.1", arg0, arg1); }
compiler.err.cant.apply.diamond.1=\ cannot infer type arguments for {0}\n\ reason: {1}
/** * compiler.err.cant.apply.diamond.1=\ * cannot infer type arguments for {0}\n\ * reason: {1} */
public static Error CantApplyDiamond1(Fragment arg0, Fragment arg1) { return new Error("compiler", "cant.apply.diamond.1", arg0, arg1); }
compiler.err.cant.apply.diamond.1=\ cannot infer type arguments for {0}\n\ reason: {1}
/** * compiler.err.cant.apply.diamond.1=\ * cannot infer type arguments for {0}\n\ * reason: {1} */
public static Error CantApplyDiamond1(Type arg0, JCDiagnostic arg1) { return new Error("compiler", "cant.apply.diamond.1", arg0, arg1); }
compiler.err.cant.apply.diamond.1=\ cannot infer type arguments for {0}\n\ reason: {1}
/** * compiler.err.cant.apply.diamond.1=\ * cannot infer type arguments for {0}\n\ * reason: {1} */
public static Error CantApplyDiamond1(Type arg0, Fragment arg1) { return new Error("compiler", "cant.apply.diamond.1", arg0, arg1); }
compiler.err.cant.apply.symbol=\ {0} {1} in {4} {5} cannot be applied to given types;\n\ required: {2}\n\ found: {3}\n\ reason: {6}
/** * compiler.err.cant.apply.symbol=\ * {0} {1} in {4} {5} cannot be applied to given types;\n\ * required: {2}\n\ * found: {3}\n\ * reason: {6} */
public static Error CantApplySymbol(Kind arg0, Name arg1, List<? extends Type> arg2, List<? extends Type> arg3, Kind arg4, Type arg5, JCDiagnostic arg6) { return new Error("compiler", "cant.apply.symbol", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.err.cant.apply.symbol=\ {0} {1} in {4} {5} cannot be applied to given types;\n\ required: {2}\n\ found: {3}\n\ reason: {6}
/** * compiler.err.cant.apply.symbol=\ * {0} {1} in {4} {5} cannot be applied to given types;\n\ * required: {2}\n\ * found: {3}\n\ * reason: {6} */
public static Error CantApplySymbol(Kind arg0, Name arg1, List<? extends Type> arg2, List<? extends Type> arg3, Kind arg4, Type arg5, Fragment arg6) { return new Error("compiler", "cant.apply.symbol", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.err.cant.apply.symbol=\ {0} {1} in {4} {5} cannot be applied to given types;\n\ required: {2}\n\ found: {3}\n\ reason: {6}
/** * compiler.err.cant.apply.symbol=\ * {0} {1} in {4} {5} cannot be applied to given types;\n\ * required: {2}\n\ * found: {3}\n\ * reason: {6} */
public static Error CantApplySymbol(Kind arg0, Name arg1, List<? extends Type> arg2, JCDiagnostic arg3, Kind arg4, Type arg5, JCDiagnostic arg6) { return new Error("compiler", "cant.apply.symbol", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.err.cant.apply.symbol=\ {0} {1} in {4} {5} cannot be applied to given types;\n\ required: {2}\n\ found: {3}\n\ reason: {6}
/** * compiler.err.cant.apply.symbol=\ * {0} {1} in {4} {5} cannot be applied to given types;\n\ * required: {2}\n\ * found: {3}\n\ * reason: {6} */
public static Error CantApplySymbol(Kind arg0, Name arg1, List<? extends Type> arg2, JCDiagnostic arg3, Kind arg4, Type arg5, Fragment arg6) { return new Error("compiler", "cant.apply.symbol", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.err.cant.apply.symbol=\ {0} {1} in {4} {5} cannot be applied to given types;\n\ required: {2}\n\ found: {3}\n\ reason: {6}
/** * compiler.err.cant.apply.symbol=\ * {0} {1} in {4} {5} cannot be applied to given types;\n\ * required: {2}\n\ * found: {3}\n\ * reason: {6} */
public static Error CantApplySymbol(Kind arg0, Name arg1, List<? extends Type> arg2, Fragment arg3, Kind arg4, Type arg5, JCDiagnostic arg6) { return new Error("compiler", "cant.apply.symbol", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.err.cant.apply.symbol=\ {0} {1} in {4} {5} cannot be applied to given types;\n\ required: {2}\n\ found: {3}\n\ reason: {6}
/** * compiler.err.cant.apply.symbol=\ * {0} {1} in {4} {5} cannot be applied to given types;\n\ * required: {2}\n\ * found: {3}\n\ * reason: {6} */
public static Error CantApplySymbol(Kind arg0, Name arg1, List<? extends Type> arg2, Fragment arg3, Kind arg4, Type arg5, Fragment arg6) { return new Error("compiler", "cant.apply.symbol", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.err.cant.apply.symbol=\ {0} {1} in {4} {5} cannot be applied to given types;\n\ required: {2}\n\ found: {3}\n\ reason: {6}
/** * compiler.err.cant.apply.symbol=\ * {0} {1} in {4} {5} cannot be applied to given types;\n\ * required: {2}\n\ * found: {3}\n\ * reason: {6} */
public static Error CantApplySymbol(Kind arg0, Name arg1, JCDiagnostic arg2, List<? extends Type> arg3, Kind arg4, Type arg5, JCDiagnostic arg6) { return new Error("compiler", "cant.apply.symbol", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.err.cant.apply.symbol=\ {0} {1} in {4} {5} cannot be applied to given types;\n\ required: {2}\n\ found: {3}\n\ reason: {6}
/** * compiler.err.cant.apply.symbol=\ * {0} {1} in {4} {5} cannot be applied to given types;\n\ * required: {2}\n\ * found: {3}\n\ * reason: {6} */
public static Error CantApplySymbol(Kind arg0, Name arg1, JCDiagnostic arg2, List<? extends Type> arg3, Kind arg4, Type arg5, Fragment arg6) { return new Error("compiler", "cant.apply.symbol", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.err.cant.apply.symbol=\ {0} {1} in {4} {5} cannot be applied to given types;\n\ required: {2}\n\ found: {3}\n\ reason: {6}
/** * compiler.err.cant.apply.symbol=\ * {0} {1} in {4} {5} cannot be applied to given types;\n\ * required: {2}\n\ * found: {3}\n\ * reason: {6} */
public static Error CantApplySymbol(Kind arg0, Name arg1, JCDiagnostic arg2, JCDiagnostic arg3, Kind arg4, Type arg5, JCDiagnostic arg6) { return new Error("compiler", "cant.apply.symbol", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.err.cant.apply.symbol=\ {0} {1} in {4} {5} cannot be applied to given types;\n\ required: {2}\n\ found: {3}\n\ reason: {6}
/** * compiler.err.cant.apply.symbol=\ * {0} {1} in {4} {5} cannot be applied to given types;\n\ * required: {2}\n\ * found: {3}\n\ * reason: {6} */
public static Error CantApplySymbol(Kind arg0, Name arg1, JCDiagnostic arg2, JCDiagnostic arg3, Kind arg4, Type arg5, Fragment arg6) { return new Error("compiler", "cant.apply.symbol", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.err.cant.apply.symbol=\ {0} {1} in {4} {5} cannot be applied to given types;\n\ required: {2}\n\ found: {3}\n\ reason: {6}
/** * compiler.err.cant.apply.symbol=\ * {0} {1} in {4} {5} cannot be applied to given types;\n\ * required: {2}\n\ * found: {3}\n\ * reason: {6} */
public static Error CantApplySymbol(Kind arg0, Name arg1, JCDiagnostic arg2, Fragment arg3, Kind arg4, Type arg5, JCDiagnostic arg6) { return new Error("compiler", "cant.apply.symbol", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.err.cant.apply.symbol=\ {0} {1} in {4} {5} cannot be applied to given types;\n\ required: {2}\n\ found: {3}\n\ reason: {6}
/** * compiler.err.cant.apply.symbol=\ * {0} {1} in {4} {5} cannot be applied to given types;\n\ * required: {2}\n\ * found: {3}\n\ * reason: {6} */
public static Error CantApplySymbol(Kind arg0, Name arg1, JCDiagnostic arg2, Fragment arg3, Kind arg4, Type arg5, Fragment arg6) { return new Error("compiler", "cant.apply.symbol", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.err.cant.apply.symbol=\ {0} {1} in {4} {5} cannot be applied to given types;\n\ required: {2}\n\ found: {3}\n\ reason: {6}
/** * compiler.err.cant.apply.symbol=\ * {0} {1} in {4} {5} cannot be applied to given types;\n\ * required: {2}\n\ * found: {3}\n\ * reason: {6} */
public static Error CantApplySymbol(Kind arg0, Name arg1, Fragment arg2, List<? extends Type> arg3, Kind arg4, Type arg5, JCDiagnostic arg6) { return new Error("compiler", "cant.apply.symbol", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.err.cant.apply.symbol=\ {0} {1} in {4} {5} cannot be applied to given types;\n\ required: {2}\n\ found: {3}\n\ reason: {6}
/** * compiler.err.cant.apply.symbol=\ * {0} {1} in {4} {5} cannot be applied to given types;\n\ * required: {2}\n\ * found: {3}\n\ * reason: {6} */
public static Error CantApplySymbol(Kind arg0, Name arg1, Fragment arg2, List<? extends Type> arg3, Kind arg4, Type arg5, Fragment arg6) { return new Error("compiler", "cant.apply.symbol", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.err.cant.apply.symbol=\ {0} {1} in {4} {5} cannot be applied to given types;\n\ required: {2}\n\ found: {3}\n\ reason: {6}
/** * compiler.err.cant.apply.symbol=\ * {0} {1} in {4} {5} cannot be applied to given types;\n\ * required: {2}\n\ * found: {3}\n\ * reason: {6} */
public static Error CantApplySymbol(Kind arg0, Name arg1, Fragment arg2, JCDiagnostic arg3, Kind arg4, Type arg5, JCDiagnostic arg6) { return new Error("compiler", "cant.apply.symbol", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.err.cant.apply.symbol=\ {0} {1} in {4} {5} cannot be applied to given types;\n\ required: {2}\n\ found: {3}\n\ reason: {6}
/** * compiler.err.cant.apply.symbol=\ * {0} {1} in {4} {5} cannot be applied to given types;\n\ * required: {2}\n\ * found: {3}\n\ * reason: {6} */
public static Error CantApplySymbol(Kind arg0, Name arg1, Fragment arg2, JCDiagnostic arg3, Kind arg4, Type arg5, Fragment arg6) { return new Error("compiler", "cant.apply.symbol", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.err.cant.apply.symbol=\ {0} {1} in {4} {5} cannot be applied to given types;\n\ required: {2}\n\ found: {3}\n\ reason: {6}
/** * compiler.err.cant.apply.symbol=\ * {0} {1} in {4} {5} cannot be applied to given types;\n\ * required: {2}\n\ * found: {3}\n\ * reason: {6} */
public static Error CantApplySymbol(Kind arg0, Name arg1, Fragment arg2, Fragment arg3, Kind arg4, Type arg5, JCDiagnostic arg6) { return new Error("compiler", "cant.apply.symbol", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.err.cant.apply.symbol=\ {0} {1} in {4} {5} cannot be applied to given types;\n\ required: {2}\n\ found: {3}\n\ reason: {6}
/** * compiler.err.cant.apply.symbol=\ * {0} {1} in {4} {5} cannot be applied to given types;\n\ * required: {2}\n\ * found: {3}\n\ * reason: {6} */
public static Error CantApplySymbol(Kind arg0, Name arg1, Fragment arg2, Fragment arg3, Kind arg4, Type arg5, Fragment arg6) { return new Error("compiler", "cant.apply.symbol", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.err.cant.apply.symbols=\ no suitable {0} found for {1}({2})
/** * compiler.err.cant.apply.symbols=\ * no suitable {0} found for {1}({2}) */
public static Error CantApplySymbols(Kind arg0, Name arg1, List<? extends Type> arg2) { return new Error("compiler", "cant.apply.symbols", arg0, arg1, arg2); }
compiler.err.cant.assign.val.to.final.var=\ cannot assign a value to final variable {0}
/** * compiler.err.cant.assign.val.to.final.var=\ * cannot assign a value to final variable {0} */
public static Error CantAssignValToFinalVar(Symbol arg0) { return new Error("compiler", "cant.assign.val.to.final.var", arg0); }
compiler.err.cant.assign.val.to.this=\ cannot assign to ''this''
/** * compiler.err.cant.assign.val.to.this=\ * cannot assign to ''this'' */
public static final Error CantAssignValToThis = new Error("compiler", "cant.assign.val.to.this");
compiler.err.cant.deref=\ {0} cannot be dereferenced
/** * compiler.err.cant.deref=\ * {0} cannot be dereferenced */
public static Error CantDeref(Type arg0) { return new Error("compiler", "cant.deref", arg0); }
compiler.err.cant.extend.intf.annotation=\ ''extends'' not allowed for @interfaces
/** * compiler.err.cant.extend.intf.annotation=\ * ''extends'' not allowed for @interfaces */
public static final Error CantExtendIntfAnnotation = new Error("compiler", "cant.extend.intf.annotation");
compiler.err.cant.infer.local.var.type=\ cannot infer type for local variable {0}\n\ ({1})
/** * compiler.err.cant.infer.local.var.type=\ * cannot infer type for local variable {0}\n\ * ({1}) */
public static Error CantInferLocalVarType(Name arg0, JCDiagnostic arg1) { return new Error("compiler", "cant.infer.local.var.type", arg0, arg1); }
compiler.err.cant.infer.local.var.type=\ cannot infer type for local variable {0}\n\ ({1})
/** * compiler.err.cant.infer.local.var.type=\ * cannot infer type for local variable {0}\n\ * ({1}) */
public static Error CantInferLocalVarType(Name arg0, Fragment arg1) { return new Error("compiler", "cant.infer.local.var.type", arg0, arg1); }
compiler.err.cant.inherit.diff.arg=\ {0} cannot be inherited with different arguments: <{1}> and <{2}>
/** * compiler.err.cant.inherit.diff.arg=\ * {0} cannot be inherited with different arguments: <{1}> and <{2}> */
public static Error CantInheritDiffArg(Symbol arg0, String arg1, String arg2) { return new Error("compiler", "cant.inherit.diff.arg", arg0, arg1, arg2); }
compiler.err.cant.inherit.from.anon=\ cannot inherit from anonymous class
/** * compiler.err.cant.inherit.from.anon=\ * cannot inherit from anonymous class */
public static final Error CantInheritFromAnon = new Error("compiler", "cant.inherit.from.anon");
compiler.err.cant.inherit.from.final=\ cannot inherit from final {0}
/** * compiler.err.cant.inherit.from.final=\ * cannot inherit from final {0} */
public static Error CantInheritFromFinal(Symbol arg0) { return new Error("compiler", "cant.inherit.from.final", arg0); }
compiler.err.cant.inherit.from.sealed=\ class is not allowed to extend sealed class: {0} \ (as it is not listed in its 'permits' clause)
/** * compiler.err.cant.inherit.from.sealed=\ * class is not allowed to extend sealed class: {0} \ * (as it is not listed in its 'permits' clause) */
public static Error CantInheritFromSealed(Symbol arg0) { return new Error("compiler", "cant.inherit.from.sealed", arg0); }
compiler.err.cant.read.file=\ cannot read: {0}
/** * compiler.err.cant.read.file=\ * cannot read: {0} */
public static final Error CantReadFile = new Error("compiler", "cant.read.file");
compiler.err.cant.ref.before.ctor.called=\ cannot reference {0} before supertype constructor has been called
/** * compiler.err.cant.ref.before.ctor.called=\ * cannot reference {0} before supertype constructor has been called */
public static Error CantRefBeforeCtorCalled(Symbol arg0) { return new Error("compiler", "cant.ref.before.ctor.called", arg0); }
compiler.err.cant.ref.before.ctor.called=\ cannot reference {0} before supertype constructor has been called
/** * compiler.err.cant.ref.before.ctor.called=\ * cannot reference {0} before supertype constructor has been called */
public static Error CantRefBeforeCtorCalled(String arg0) { return new Error("compiler", "cant.ref.before.ctor.called", arg0); }
compiler.err.cant.ref.non.effectively.final.var=\ local variables referenced from {1} must be final or effectively final
/** * compiler.err.cant.ref.non.effectively.final.var=\ * local variables referenced from {1} must be final or effectively final */
public static Error CantRefNonEffectivelyFinalVar(Symbol arg0, JCDiagnostic arg1) { return new Error("compiler", "cant.ref.non.effectively.final.var", arg0, arg1); }
compiler.err.cant.ref.non.effectively.final.var=\ local variables referenced from {1} must be final or effectively final
/** * compiler.err.cant.ref.non.effectively.final.var=\ * local variables referenced from {1} must be final or effectively final */
public static Error CantRefNonEffectivelyFinalVar(Symbol arg0, Fragment arg1) { return new Error("compiler", "cant.ref.non.effectively.final.var", arg0, arg1); }
compiler.err.cant.resolve=\ cannot find symbol\n\ symbol: {0} {1}
/** * compiler.err.cant.resolve=\ * cannot find symbol\n\ * symbol: {0} {1} */
public static Error CantResolve(KindName arg0, Name arg1, Void arg2, Void arg3) { return new Error("compiler", "cant.resolve", arg0, arg1, arg2, arg3); }
compiler.err.cant.resolve.args=\ cannot find symbol\n\ symbol: {0} {1}({3})
/** * compiler.err.cant.resolve.args=\ * cannot find symbol\n\ * symbol: {0} {1}({3}) */
public static Error CantResolveArgs(KindName arg0, Name arg1, Void arg2, List<? extends Type> arg3) { return new Error("compiler", "cant.resolve.args", arg0, arg1, arg2, arg3); }
compiler.err.cant.resolve.args.params=\ cannot find symbol\n\ symbol: {0} <{2}>{1}({3})
/** * compiler.err.cant.resolve.args.params=\ * cannot find symbol\n\ * symbol: {0} <{2}>{1}({3}) */
public static Error CantResolveArgsParams(KindName arg0, Name arg1, List<? extends Type> arg2, List<? extends Type> arg3) { return new Error("compiler", "cant.resolve.args.params", arg0, arg1, arg2, arg3); }
compiler.err.cant.resolve.location=\ cannot find symbol\n\ symbol: {0} {1}\n\ location: {4}
/** * compiler.err.cant.resolve.location=\ * cannot find symbol\n\ * symbol: {0} {1}\n\ * location: {4} */
public static Error CantResolveLocation(KindName arg0, Name arg1, Void arg2, Void arg3, JCDiagnostic arg4) { return new Error("compiler", "cant.resolve.location", arg0, arg1, arg2, arg3, arg4); }
compiler.err.cant.resolve.location=\ cannot find symbol\n\ symbol: {0} {1}\n\ location: {4}
/** * compiler.err.cant.resolve.location=\ * cannot find symbol\n\ * symbol: {0} {1}\n\ * location: {4} */
public static Error CantResolveLocation(KindName arg0, Name arg1, Void arg2, Void arg3, Fragment arg4) { return new Error("compiler", "cant.resolve.location", arg0, arg1, arg2, arg3, arg4); }
compiler.err.cant.resolve.location.args=\ cannot find symbol\n\ symbol: {0} {1}({3})\n\ location: {4}
/** * compiler.err.cant.resolve.location.args=\ * cannot find symbol\n\ * symbol: {0} {1}({3})\n\ * location: {4} */
public static Error CantResolveLocationArgs(KindName arg0, Name arg1, Void arg2, List<? extends Type> arg3, JCDiagnostic arg4) { return new Error("compiler", "cant.resolve.location.args", arg0, arg1, arg2, arg3, arg4); }
compiler.err.cant.resolve.location.args=\ cannot find symbol\n\ symbol: {0} {1}({3})\n\ location: {4}
/** * compiler.err.cant.resolve.location.args=\ * cannot find symbol\n\ * symbol: {0} {1}({3})\n\ * location: {4} */
public static Error CantResolveLocationArgs(KindName arg0, Name arg1, Void arg2, List<? extends Type> arg3, Fragment arg4) { return new Error("compiler", "cant.resolve.location.args", arg0, arg1, arg2, arg3, arg4); }
compiler.err.cant.resolve.location.args.params=\ cannot find symbol\n\ symbol: {0} <{2}>{1}({3})\n\ location: {4}
/** * compiler.err.cant.resolve.location.args.params=\ * cannot find symbol\n\ * symbol: {0} <{2}>{1}({3})\n\ * location: {4} */
@SuppressWarnings("rawtypes") public static Error CantResolveLocationArgsParams(KindName arg0, Name arg1, List<? extends Type> arg2, List arg3, JCDiagnostic arg4) { return new Error("compiler", "cant.resolve.location.args.params", arg0, arg1, arg2, arg3, arg4); }
compiler.err.cant.resolve.location.args.params=\ cannot find symbol\n\ symbol: {0} <{2}>{1}({3})\n\ location: {4}
/** * compiler.err.cant.resolve.location.args.params=\ * cannot find symbol\n\ * symbol: {0} <{2}>{1}({3})\n\ * location: {4} */
@SuppressWarnings("rawtypes") public static Error CantResolveLocationArgsParams(KindName arg0, Name arg1, List<? extends Type> arg2, List arg3, Fragment arg4) { return new Error("compiler", "cant.resolve.location.args.params", arg0, arg1, arg2, arg3, arg4); }
compiler.err.cant.select.static.class.from.param.type=\ cannot select a static class from a parameterized type
/** * compiler.err.cant.select.static.class.from.param.type=\ * cannot select a static class from a parameterized type */
public static final Error CantSelectStaticClassFromParamType = new Error("compiler", "cant.select.static.class.from.param.type");
compiler.err.cant.type.annotate.scoping=\ scoping construct cannot be annotated with type-use annotations: {0}
/** * compiler.err.cant.type.annotate.scoping=\ * scoping construct cannot be annotated with type-use annotations: {0} */
public static Error CantTypeAnnotateScoping(List<? extends Compound> arg0) { return new Error("compiler", "cant.type.annotate.scoping", arg0); }
compiler.err.cant.type.annotate.scoping.1=\ scoping construct cannot be annotated with type-use annotation: {0}
/** * compiler.err.cant.type.annotate.scoping.1=\ * scoping construct cannot be annotated with type-use annotation: {0} */
public static Error CantTypeAnnotateScoping1(Compound arg0) { return new Error("compiler", "cant.type.annotate.scoping.1", arg0); }
compiler.err.catch.without.try=\ ''catch'' without ''try''
/** * compiler.err.catch.without.try=\ * ''catch'' without ''try'' */
public static final Error CatchWithoutTry = new Error("compiler", "catch.without.try");
compiler.err.clash.with.pkg.of.same.name=\ {0} {1} clashes with package of same name
/** * compiler.err.clash.with.pkg.of.same.name=\ * {0} {1} clashes with package of same name */
public static Error ClashWithPkgOfSameName(KindName arg0, Symbol arg1) { return new Error("compiler", "clash.with.pkg.of.same.name", arg0, arg1); }
compiler.err.class.cant.write=\ error while writing {0}: {1}
/** * compiler.err.class.cant.write=\ * error while writing {0}: {1} */
public static Error ClassCantWrite(Symbol arg0, String arg1) { return new Error("compiler", "class.cant.write", arg0, arg1); }
compiler.err.class.in.module.cant.extend.sealed.in.diff.module=\ class {0} in module {1} cannot extend a sealed class in a different module
/** * compiler.err.class.in.module.cant.extend.sealed.in.diff.module=\ * class {0} in module {1} cannot extend a sealed class in a different module */
public static Error ClassInModuleCantExtendSealedInDiffModule(Symbol arg0, Symbol arg1) { return new Error("compiler", "class.in.module.cant.extend.sealed.in.diff.module", arg0, arg1); }
compiler.err.class.in.unnamed.module.cant.extend.sealed.in.diff.package=\ class {0} in unnamed module cannot extend a sealed class in a different package
/** * compiler.err.class.in.unnamed.module.cant.extend.sealed.in.diff.package=\ * class {0} in unnamed module cannot extend a sealed class in a different package */
public static Error ClassInUnnamedModuleCantExtendSealedInDiffPackage(Symbol arg0) { return new Error("compiler", "class.in.unnamed.module.cant.extend.sealed.in.diff.package", arg0); }
compiler.err.class.not.allowed=\ class, interface or enum declaration not allowed here
/** * compiler.err.class.not.allowed=\ * class, interface or enum declaration not allowed here */
public static final Error ClassNotAllowed = new Error("compiler", "class.not.allowed");
compiler.err.class.public.should.be.in.file=\ {0} {1} is public, should be declared in a file named {1}.java
/** * compiler.err.class.public.should.be.in.file=\ * {0} {1} is public, should be declared in a file named {1}.java */
public static Error ClassPublicShouldBeInFile(KindName arg0, Name arg1) { return new Error("compiler", "class.public.should.be.in.file", arg0, arg1); }
compiler.err.concrete.inheritance.conflict=\ methods {0} from {1} and {2} from {3} are inherited with the same signature
/** * compiler.err.concrete.inheritance.conflict=\ * methods {0} from {1} and {2} from {3} are inherited with the same signature */
public static Error ConcreteInheritanceConflict(Symbol arg0, Type arg1, Symbol arg2, Type arg3, Type arg4) { return new Error("compiler", "concrete.inheritance.conflict", arg0, arg1, arg2, arg3, arg4); }
compiler.err.conflicting.exports=\ duplicate or conflicting exports: {0}
/** * compiler.err.conflicting.exports=\ * duplicate or conflicting exports: {0} */
public static Error ConflictingExports(Symbol arg0) { return new Error("compiler", "conflicting.exports", arg0); }
compiler.err.conflicting.exports.to.module=\ duplicate or conflicting exports to module: {0}
/** * compiler.err.conflicting.exports.to.module=\ * duplicate or conflicting exports to module: {0} */
public static Error ConflictingExportsToModule(Symbol arg0) { return new Error("compiler", "conflicting.exports.to.module", arg0); }
compiler.err.conflicting.opens=\ duplicate or conflicting opens: {0}
/** * compiler.err.conflicting.opens=\ * duplicate or conflicting opens: {0} */
public static Error ConflictingOpens(Symbol arg0) { return new Error("compiler", "conflicting.opens", arg0); }
compiler.err.conflicting.opens.to.module=\ duplicate or conflicting opens to module: {0}
/** * compiler.err.conflicting.opens.to.module=\ * duplicate or conflicting opens to module: {0} */
public static Error ConflictingOpensToModule(Symbol arg0) { return new Error("compiler", "conflicting.opens.to.module", arg0); }
compiler.err.const.expr.req=\ constant expression required
/** * compiler.err.const.expr.req=\ * constant expression required */
public static final Error ConstExprReq = new Error("compiler", "const.expr.req");
compiler.err.cont.outside.loop=\ continue outside of loop
/** * compiler.err.cont.outside.loop=\ * continue outside of loop */
public static final Error ContOutsideLoop = new Error("compiler", "cont.outside.loop");
compiler.err.continue.outside.switch.expression=\ attempt to continue out of a switch expression
/** * compiler.err.continue.outside.switch.expression=\ * attempt to continue out of a switch expression */
public static final Error ContinueOutsideSwitchExpression = new Error("compiler", "continue.outside.switch.expression");
compiler.err.cyclic.annotation.element=\ type of element {0} is cyclic
/** * compiler.err.cyclic.annotation.element=\ * type of element {0} is cyclic */
public static Error CyclicAnnotationElement(Symbol arg0) { return new Error("compiler", "cyclic.annotation.element", arg0); }
compiler.err.cyclic.inheritance=\ cyclic inheritance involving {0}
/** * compiler.err.cyclic.inheritance=\ * cyclic inheritance involving {0} */
public static Error CyclicInheritance(Symbol arg0) { return new Error("compiler", "cyclic.inheritance", arg0); }
compiler.err.cyclic.inheritance=\ cyclic inheritance involving {0}
/** * compiler.err.cyclic.inheritance=\ * cyclic inheritance involving {0} */
public static Error CyclicInheritance(Type arg0) { return new Error("compiler", "cyclic.inheritance", arg0); }
compiler.err.cyclic.requires=\ cyclic dependence involving {0}
/** * compiler.err.cyclic.requires=\ * cyclic dependence involving {0} */
public static Error CyclicRequires(Symbol arg0) { return new Error("compiler", "cyclic.requires", arg0); }
compiler.err.dc.bad.entity=\ bad HTML entity
/** * compiler.err.dc.bad.entity=\ * bad HTML entity */
public static final Error DcBadEntity = new Error("compiler", "dc.bad.entity");
compiler.err.dc.bad.inline.tag=\ incorrect use of inline tag
/** * compiler.err.dc.bad.inline.tag=\ * incorrect use of inline tag */
public static final Error DcBadInlineTag = new Error("compiler", "dc.bad.inline.tag");
compiler.err.dc.gt.expected=\ ''>'' expected
/** * compiler.err.dc.gt.expected=\ * ''>'' expected */
public static final Error DcGtExpected = new Error("compiler", "dc.gt.expected");
compiler.err.dc.identifier.expected=\ identifier expected
/** * compiler.err.dc.identifier.expected=\ * identifier expected */
public static final Error DcIdentifierExpected = new Error("compiler", "dc.identifier.expected");
compiler.err.dc.malformed.html=\ malformed HTML
/** * compiler.err.dc.malformed.html=\ * malformed HTML */
public static final Error DcMalformedHtml = new Error("compiler", "dc.malformed.html");
compiler.err.dc.missing.semicolon=\ semicolon missing
/** * compiler.err.dc.missing.semicolon=\ * semicolon missing */
public static final Error DcMissingSemicolon = new Error("compiler", "dc.missing.semicolon");
compiler.err.dc.no.content=\ no content
/** * compiler.err.dc.no.content=\ * no content */
public static final Error DcNoContent = new Error("compiler", "dc.no.content");
compiler.err.dc.no.tag.name=\ no tag name after '@'
/** * compiler.err.dc.no.tag.name=\ * no tag name after '@' */
public static final Error DcNoTagName = new Error("compiler", "dc.no.tag.name");
compiler.err.dc.ref.bad.parens=\ '')'' missing in reference
/** * compiler.err.dc.ref.bad.parens=\ * '')'' missing in reference */
public static final Error DcRefBadParens = new Error("compiler", "dc.ref.bad.parens");
compiler.err.dc.ref.syntax.error=\ syntax error in reference
/** * compiler.err.dc.ref.syntax.error=\ * syntax error in reference */
public static final Error DcRefSyntaxError = new Error("compiler", "dc.ref.syntax.error");
compiler.err.dc.ref.unexpected.input=\ unexpected text
/** * compiler.err.dc.ref.unexpected.input=\ * unexpected text */
public static final Error DcRefUnexpectedInput = new Error("compiler", "dc.ref.unexpected.input");
compiler.err.dc.unexpected.content=\ unexpected content
/** * compiler.err.dc.unexpected.content=\ * unexpected content */
public static final Error DcUnexpectedContent = new Error("compiler", "dc.unexpected.content");
compiler.err.dc.unterminated.inline.tag=\ unterminated inline tag
/** * compiler.err.dc.unterminated.inline.tag=\ * unterminated inline tag */
public static final Error DcUnterminatedInlineTag = new Error("compiler", "dc.unterminated.inline.tag");
compiler.err.dc.unterminated.signature=\ unterminated signature
/** * compiler.err.dc.unterminated.signature=\ * unterminated signature */
public static final Error DcUnterminatedSignature = new Error("compiler", "dc.unterminated.signature");
compiler.err.dc.unterminated.string=\ unterminated string
/** * compiler.err.dc.unterminated.string=\ * unterminated string */
public static final Error DcUnterminatedString = new Error("compiler", "dc.unterminated.string");
compiler.err.default.allowed.in.intf.annotation.member=\ default value only allowed in an annotation type declaration
/** * compiler.err.default.allowed.in.intf.annotation.member=\ * default value only allowed in an annotation type declaration */
public static final Error DefaultAllowedInIntfAnnotationMember = new Error("compiler", "default.allowed.in.intf.annotation.member");
compiler.err.default.overrides.object.member=\ default method {0} in {1} {2} overrides a member of java.lang.Object
/** * compiler.err.default.overrides.object.member=\ * default method {0} in {1} {2} overrides a member of java.lang.Object */
public static Error DefaultOverridesObjectMember(Name arg0, KindName arg1, Symbol arg2) { return new Error("compiler", "default.overrides.object.member", arg0, arg1, arg2); }
compiler.err.does.not.override.abstract=\ {0} is not abstract and does not override abstract method {1} in {2}
/** * compiler.err.does.not.override.abstract=\ * {0} is not abstract and does not override abstract method {1} in {2} */
public static Error DoesNotOverrideAbstract(Symbol arg0, Symbol arg1, Symbol arg2) { return new Error("compiler", "does.not.override.abstract", arg0, arg1, arg2); }
compiler.err.doesnt.exist=\ package {0} does not exist
/** * compiler.err.doesnt.exist=\ * package {0} does not exist */
public static Error DoesntExist(Symbol arg0) { return new Error("compiler", "doesnt.exist", arg0); }
compiler.err.dot.class.expected=\ ''.class'' expected
/** * compiler.err.dot.class.expected=\ * ''.class'' expected */
public static final Error DotClassExpected = new Error("compiler", "dot.class.expected");
compiler.err.duplicate.annotation.invalid.repeated=\ annotation {0} is not a valid repeatable annotation
/** * compiler.err.duplicate.annotation.invalid.repeated=\ * annotation {0} is not a valid repeatable annotation */
public static Error DuplicateAnnotationInvalidRepeated(Type arg0) { return new Error("compiler", "duplicate.annotation.invalid.repeated", arg0); }
compiler.err.duplicate.annotation.member.value=\ duplicate element ''{0}'' in annotation @{1}.
/** * compiler.err.duplicate.annotation.member.value=\ * duplicate element ''{0}'' in annotation @{1}. */
public static Error DuplicateAnnotationMemberValue(Name arg0, Type arg1) { return new Error("compiler", "duplicate.annotation.member.value", arg0, arg1); }
compiler.err.duplicate.annotation.missing.container=\ {0} is not a repeatable annotation type
/** * compiler.err.duplicate.annotation.missing.container=\ * {0} is not a repeatable annotation type */
public static Error DuplicateAnnotationMissingContainer(Type arg0) { return new Error("compiler", "duplicate.annotation.missing.container", arg0); }
compiler.err.duplicate.case.label=\ duplicate case label
/** * compiler.err.duplicate.case.label=\ * duplicate case label */
public static final Error DuplicateCaseLabel = new Error("compiler", "duplicate.case.label");
compiler.err.duplicate.class=\ duplicate class: {0}
/** * compiler.err.duplicate.class=\ * duplicate class: {0} */
public static Error DuplicateClass(Name arg0) { return new Error("compiler", "duplicate.class", arg0); }
compiler.err.duplicate.default.label=\ duplicate default label
/** * compiler.err.duplicate.default.label=\ * duplicate default label */
public static final Error DuplicateDefaultLabel = new Error("compiler", "duplicate.default.label");
compiler.err.duplicate.module=\ duplicate module: {0}
/** * compiler.err.duplicate.module=\ * duplicate module: {0} */
public static Error DuplicateModule(Symbol arg0) { return new Error("compiler", "duplicate.module", arg0); }
compiler.err.duplicate.module.on.path=\ duplicate module on {0}\nmodule in {1}
/** * compiler.err.duplicate.module.on.path=\ * duplicate module on {0}\nmodule in {1} */
public static Error DuplicateModuleOnPath(Fragment arg0, Name arg1) { return new Error("compiler", "duplicate.module.on.path", arg0, arg1); }
compiler.err.duplicate.provides=\ duplicate provides: service {0}, implementation {1}
/** * compiler.err.duplicate.provides=\ * duplicate provides: service {0}, implementation {1} */
public static Error DuplicateProvides(Symbol arg0, Symbol arg1) { return new Error("compiler", "duplicate.provides", arg0, arg1); }
compiler.err.duplicate.requires=\ duplicate requires: {0}
/** * compiler.err.duplicate.requires=\ * duplicate requires: {0} */
public static Error DuplicateRequires(Symbol arg0) { return new Error("compiler", "duplicate.requires", arg0); }
compiler.err.duplicate.uses=\ duplicate uses: {0}
/** * compiler.err.duplicate.uses=\ * duplicate uses: {0} */
public static Error DuplicateUses(Symbol arg0) { return new Error("compiler", "duplicate.uses", arg0); }
compiler.err.else.without.if=\ ''else'' without ''if''
/** * compiler.err.else.without.if=\ * ''else'' without ''if'' */
public static final Error ElseWithoutIf = new Error("compiler", "else.without.if");
compiler.err.empty.A.argument=\ -A requires an argument; use ''-Akey'' or ''-Akey=value''
/** * compiler.err.empty.A.argument=\ * -A requires an argument; use ''-Akey'' or ''-Akey=value'' */
public static final Error EmptyAArgument = new Error("compiler", "empty.A.argument");
compiler.err.empty.char.lit=\ empty character literal
/** * compiler.err.empty.char.lit=\ * empty character literal */
public static final Error EmptyCharLit = new Error("compiler", "empty.char.lit");
compiler.err.encl.class.required=\ an enclosing instance that contains {0} is required
/** * compiler.err.encl.class.required=\ * an enclosing instance that contains {0} is required */
public static Error EnclClassRequired(Symbol arg0) { return new Error("compiler", "encl.class.required", arg0); }
compiler.err.enum.annotation.must.be.enum.constant=\ an enum annotation value must be an enum constant
/** * compiler.err.enum.annotation.must.be.enum.constant=\ * an enum annotation value must be an enum constant */
public static final Error EnumAnnotationMustBeEnumConstant = new Error("compiler", "enum.annotation.must.be.enum.constant");
compiler.err.enum.as.identifier=\ as of release 5, ''enum'' is a keyword, and may not be used as an identifier
/** * compiler.err.enum.as.identifier=\ * as of release 5, ''enum'' is a keyword, and may not be used as an identifier */
public static final Error EnumAsIdentifier = new Error("compiler", "enum.as.identifier");
compiler.err.enum.cant.be.instantiated=\ enum types may not be instantiated
/** * compiler.err.enum.cant.be.instantiated=\ * enum types may not be instantiated */
public static final Error EnumCantBeInstantiated = new Error("compiler", "enum.cant.be.instantiated");
compiler.err.enum.constant.expected=\ enum constant expected here
/** * compiler.err.enum.constant.expected=\ * enum constant expected here */
public static final Error EnumConstantExpected = new Error("compiler", "enum.constant.expected");
compiler.err.enum.constant.not.expected=\ enum constant not expected here
/** * compiler.err.enum.constant.not.expected=\ * enum constant not expected here */
public static final Error EnumConstantNotExpected = new Error("compiler", "enum.constant.not.expected");
compiler.err.enum.label.must.be.unqualified.enum=\ an enum switch case label must be the unqualified name of an enumeration constant
/** * compiler.err.enum.label.must.be.unqualified.enum=\ * an enum switch case label must be the unqualified name of an enumeration constant */
public static final Error EnumLabelMustBeUnqualifiedEnum = new Error("compiler", "enum.label.must.be.unqualified.enum");
compiler.err.enum.no.finalize=\ enums cannot have finalize methods
/** * compiler.err.enum.no.finalize=\ * enums cannot have finalize methods */
public static final Error EnumNoFinalize = new Error("compiler", "enum.no.finalize");
compiler.err.enum.no.subclassing=\ classes cannot directly extend java.lang.Enum
/** * compiler.err.enum.no.subclassing=\ * classes cannot directly extend java.lang.Enum */
public static final Error EnumNoSubclassing = new Error("compiler", "enum.no.subclassing");
compiler.err.enum.types.not.extensible=\ enum types are not extensible
/** * compiler.err.enum.types.not.extensible=\ * enum types are not extensible */
public static final Error EnumTypesNotExtensible = new Error("compiler", "enum.types.not.extensible");
compiler.err.error=\ error:\u0020
/** * compiler.err.error=\ * error:\u0020 */
public static final Error Error = new Error("compiler", "error");
compiler.err.error.reading.file=\ error reading {0}; {1}
/** * compiler.err.error.reading.file=\ * error reading {0}; {1} */
public static Error ErrorReadingFile(File arg0, String arg1) { return new Error("compiler", "error.reading.file", arg0, arg1); }
compiler.err.error.reading.file=\ error reading {0}; {1}
/** * compiler.err.error.reading.file=\ * error reading {0}; {1} */
public static Error ErrorReadingFile(JavaFileObject arg0, String arg1) { return new Error("compiler", "error.reading.file", arg0, arg1); }
compiler.err.error.reading.file=\ error reading {0}; {1}
/** * compiler.err.error.reading.file=\ * error reading {0}; {1} */
public static Error ErrorReadingFile(Path arg0, String arg1) { return new Error("compiler", "error.reading.file", arg0, arg1); }
compiler.err.error.writing.file=\ error writing {0}; {1}
/** * compiler.err.error.writing.file=\ * error writing {0}; {1} */
public static Error ErrorWritingFile(String arg0, String arg1) { return new Error("compiler", "error.writing.file", arg0, arg1); }
compiler.err.except.already.caught=\ exception {0} has already been caught
/** * compiler.err.except.already.caught=\ * exception {0} has already been caught */
public static Error ExceptAlreadyCaught(Type arg0) { return new Error("compiler", "except.already.caught", arg0); }
compiler.err.except.never.thrown.in.try=\ exception {0} is never thrown in body of corresponding try statement
/** * compiler.err.except.never.thrown.in.try=\ * exception {0} is never thrown in body of corresponding try statement */
public static Error ExceptNeverThrownInTry(Type arg0) { return new Error("compiler", "except.never.thrown.in.try", arg0); }
compiler.err.expected=\ {0} expected
/** * compiler.err.expected=\ * {0} expected */
public static Error Expected(TokenKind arg0) { return new Error("compiler", "expected", arg0); }
compiler.err.expected.module=\ expected ''module''
/** * compiler.err.expected.module=\ * expected ''module'' */
public static final Error ExpectedModule = new Error("compiler", "expected.module");
compiler.err.expected.module.or.open=\ ''module'' or ''open'' expected
/** * compiler.err.expected.module.or.open=\ * ''module'' or ''open'' expected */
public static final Error ExpectedModuleOrOpen = new Error("compiler", "expected.module.or.open");
compiler.err.expected.str=\ {0} expected
/** * compiler.err.expected.str=\ * {0} expected */
public static Error ExpectedStr(String arg0) { return new Error("compiler", "expected.str", arg0); }
compiler.err.expected2=\ {0} or {1} expected
/** * compiler.err.expected2=\ * {0} or {1} expected */
public static Error Expected2(TokenKind arg0, TokenKind arg1) { return new Error("compiler", "expected2", arg0, arg1); }
compiler.err.expected3=\ {0}, {1}, or {2} expected
/** * compiler.err.expected3=\ * {0}, {1}, or {2} expected */
public static Error Expected3(TokenKind arg0, TokenKind arg1, TokenKind arg2) { return new Error("compiler", "expected3", arg0, arg1, arg2); }
compiler.err.expected4=\ {0}, {1}, {2}, or {3} expected
/** * compiler.err.expected4=\ * {0}, {1}, {2}, or {3} expected */
public static Error Expected4(TokenKind arg0, TokenKind arg1, TokenKind arg2, String arg3) { return new Error("compiler", "expected4", arg0, arg1, arg2, arg3); }
compiler.err.expression.not.allowable.as.annotation.value=\ expression not allowed as annotation value
/** * compiler.err.expression.not.allowable.as.annotation.value=\ * expression not allowed as annotation value */
public static final Error ExpressionNotAllowableAsAnnotationValue = new Error("compiler", "expression.not.allowable.as.annotation.value");
compiler.err.feature.not.supported.in.source=\ {0} is not supported in -source {1}\n\ (use -source {2} or higher to enable {0})
/** * compiler.err.feature.not.supported.in.source=\ * {0} is not supported in -source {1}\n\ * (use -source {2} or higher to enable {0}) */
public static Error FeatureNotSupportedInSource(JCDiagnostic arg0, String arg1, String arg2) { return new Error("compiler", "feature.not.supported.in.source", arg0, arg1, arg2); }
compiler.err.feature.not.supported.in.source=\ {0} is not supported in -source {1}\n\ (use -source {2} or higher to enable {0})
/** * compiler.err.feature.not.supported.in.source=\ * {0} is not supported in -source {1}\n\ * (use -source {2} or higher to enable {0}) */
public static Error FeatureNotSupportedInSource(Fragment arg0, String arg1, String arg2) { return new Error("compiler", "feature.not.supported.in.source", arg0, arg1, arg2); }
compiler.err.feature.not.supported.in.source.plural=\ {0} are not supported in -source {1}\n\ (use -source {2} or higher to enable {0})
/** * compiler.err.feature.not.supported.in.source.plural=\ * {0} are not supported in -source {1}\n\ * (use -source {2} or higher to enable {0}) */
public static Error FeatureNotSupportedInSourcePlural(JCDiagnostic arg0, String arg1, String arg2) { return new Error("compiler", "feature.not.supported.in.source.plural", arg0, arg1, arg2); }
compiler.err.feature.not.supported.in.source.plural=\ {0} are not supported in -source {1}\n\ (use -source {2} or higher to enable {0})
/** * compiler.err.feature.not.supported.in.source.plural=\ * {0} are not supported in -source {1}\n\ * (use -source {2} or higher to enable {0}) */
public static Error FeatureNotSupportedInSourcePlural(Fragment arg0, String arg1, String arg2) { return new Error("compiler", "feature.not.supported.in.source.plural", arg0, arg1, arg2); }
compiler.err.file.not.directory=\ not a directory: {0}
/** * compiler.err.file.not.directory=\ * not a directory: {0} */
public static Error FileNotDirectory(String arg0) { return new Error("compiler", "file.not.directory", arg0); }
compiler.err.file.not.file=\ not a file: {0}
/** * compiler.err.file.not.file=\ * not a file: {0} */
public static Error FileNotFile(Object arg0) { return new Error("compiler", "file.not.file", arg0); }
compiler.err.file.not.found=\ file not found: {0}
/** * compiler.err.file.not.found=\ * file not found: {0} */
public static Error FileNotFound(String arg0) { return new Error("compiler", "file.not.found", arg0); }
compiler.err.file.patched.and.msp=\ file accessible from both --patch-module and --module-source-path, \ but belongs to a different module on each path: {0}, {1}
/** * compiler.err.file.patched.and.msp=\ * file accessible from both --patch-module and --module-source-path, \ * but belongs to a different module on each path: {0}, {1} */
public static Error FilePatchedAndMsp(Name arg0, Name arg1) { return new Error("compiler", "file.patched.and.msp", arg0, arg1); }
compiler.err.file.sb.on.source.or.patch.path.for.module=\ file should be on source path, or on patch path for module
/** * compiler.err.file.sb.on.source.or.patch.path.for.module=\ * file should be on source path, or on patch path for module */
public static final Error FileSbOnSourceOrPatchPathForModule = new Error("compiler", "file.sb.on.source.or.patch.path.for.module");
compiler.err.final.parameter.may.not.be.assigned=\ final parameter {0} may not be assigned
/** * compiler.err.final.parameter.may.not.be.assigned=\ * final parameter {0} may not be assigned */
public static Error FinalParameterMayNotBeAssigned(Symbol arg0) { return new Error("compiler", "final.parameter.may.not.be.assigned", arg0); }
compiler.err.finally.without.try=\ ''finally'' without ''try''
/** * compiler.err.finally.without.try=\ * ''finally'' without ''try'' */
public static final Error FinallyWithoutTry = new Error("compiler", "finally.without.try");
compiler.err.first.statement.must.be.call.to.another.constructor=\ constructor is not canonical, so its first statement must invoke another constructor of class {0}
/** * compiler.err.first.statement.must.be.call.to.another.constructor=\ * constructor is not canonical, so its first statement must invoke another constructor of class {0} */
public static Error FirstStatementMustBeCallToAnotherConstructor(Symbol arg0) { return new Error("compiler", "first.statement.must.be.call.to.another.constructor", arg0); }
compiler.err.foreach.not.applicable.to.type=\ for-each not applicable to expression type\n\ required: {1}\n\ found: {0}
/** * compiler.err.foreach.not.applicable.to.type=\ * for-each not applicable to expression type\n\ * required: {1}\n\ * found: {0} */
public static Error ForeachNotApplicableToType(Type arg0, JCDiagnostic arg1) { return new Error("compiler", "foreach.not.applicable.to.type", arg0, arg1); }
compiler.err.foreach.not.applicable.to.type=\ for-each not applicable to expression type\n\ required: {1}\n\ found: {0}
/** * compiler.err.foreach.not.applicable.to.type=\ * for-each not applicable to expression type\n\ * required: {1}\n\ * found: {0} */
public static Error ForeachNotApplicableToType(Type arg0, Fragment arg1) { return new Error("compiler", "foreach.not.applicable.to.type", arg0, arg1); }
compiler.err.fp.number.too.large=\ floating point number too large
/** * compiler.err.fp.number.too.large=\ * floating point number too large */
public static final Error FpNumberTooLarge = new Error("compiler", "fp.number.too.large");
compiler.err.fp.number.too.small=\ floating point number too small
/** * compiler.err.fp.number.too.small=\ * floating point number too small */
public static final Error FpNumberTooSmall = new Error("compiler", "fp.number.too.small");
compiler.err.generic.array.creation=\ generic array creation
/** * compiler.err.generic.array.creation=\ * generic array creation */
public static final Error GenericArrayCreation = new Error("compiler", "generic.array.creation");
compiler.err.generic.throwable=\ a generic class may not extend java.lang.Throwable
/** * compiler.err.generic.throwable=\ * a generic class may not extend java.lang.Throwable */
public static final Error GenericThrowable = new Error("compiler", "generic.throwable");
compiler.err.icls.cant.have.static.decl=\ Illegal static declaration in inner class {0}\n\ modifier \''static\'' is only allowed in constant variable declarations
/** * compiler.err.icls.cant.have.static.decl=\ * Illegal static declaration in inner class {0}\n\ * modifier \''static\'' is only allowed in constant variable declarations */
public static Error IclsCantHaveStaticDecl(Symbol arg0) { return new Error("compiler", "icls.cant.have.static.decl", arg0); }
compiler.err.illegal.argument.for.option=\ illegal argument for {0}: {1}
/** * compiler.err.illegal.argument.for.option=\ * illegal argument for {0}: {1} */
public static Error IllegalArgumentForOption(String arg0, String arg1) { return new Error("compiler", "illegal.argument.for.option", arg0, arg1); }
compiler.err.illegal.array.creation.both.dimension.and.initialization=\ array creation with both dimension expression and initialization is illegal
/** * compiler.err.illegal.array.creation.both.dimension.and.initialization=\ * array creation with both dimension expression and initialization is illegal */
public static final Error IllegalArrayCreationBothDimensionAndInitialization = new Error("compiler", "illegal.array.creation.both.dimension.and.initialization");
compiler.err.illegal.char=\ illegal character: ''{0}''
/** * compiler.err.illegal.char=\ * illegal character: ''{0}'' */
public static Error IllegalChar(String arg0) { return new Error("compiler", "illegal.char", arg0); }
compiler.err.illegal.char.for.encoding=\ unmappable character (0x{0}) for encoding {1}
/** * compiler.err.illegal.char.for.encoding=\ * unmappable character (0x{0}) for encoding {1} */
public static Error IllegalCharForEncoding(String arg0, String arg1) { return new Error("compiler", "illegal.char.for.encoding", arg0, arg1); }
compiler.err.illegal.combination.of.modifiers=\ illegal combination of modifiers: {0} and {1}
/** * compiler.err.illegal.combination.of.modifiers=\ * illegal combination of modifiers: {0} and {1} */
public static Error IllegalCombinationOfModifiers(Set<? extends Flag> arg0, Set<? extends Flag> arg1) { return new Error("compiler", "illegal.combination.of.modifiers", arg0, arg1); }
compiler.err.illegal.default.super.call=\ bad type qualifier {0} in default super call\n\ {1}
/** * compiler.err.illegal.default.super.call=\ * bad type qualifier {0} in default super call\n\ * {1} */
public static Error IllegalDefaultSuperCall(Symbol arg0, JCDiagnostic arg1) { return new Error("compiler", "illegal.default.super.call", arg0, arg1); }
compiler.err.illegal.default.super.call=\ bad type qualifier {0} in default super call\n\ {1}
/** * compiler.err.illegal.default.super.call=\ * bad type qualifier {0} in default super call\n\ * {1} */
public static Error IllegalDefaultSuperCall(Symbol arg0, Fragment arg1) { return new Error("compiler", "illegal.default.super.call", arg0, arg1); }
compiler.err.illegal.default.super.call=\ bad type qualifier {0} in default super call\n\ {1}
/** * compiler.err.illegal.default.super.call=\ * bad type qualifier {0} in default super call\n\ * {1} */
public static Error IllegalDefaultSuperCall(Type arg0, JCDiagnostic arg1) { return new Error("compiler", "illegal.default.super.call", arg0, arg1); }
compiler.err.illegal.default.super.call=\ bad type qualifier {0} in default super call\n\ {1}
/** * compiler.err.illegal.default.super.call=\ * bad type qualifier {0} in default super call\n\ * {1} */
public static Error IllegalDefaultSuperCall(Type arg0, Fragment arg1) { return new Error("compiler", "illegal.default.super.call", arg0, arg1); }
compiler.err.illegal.dot=\ illegal ''.''
/** * compiler.err.illegal.dot=\ * illegal ''.'' */
public static final Error IllegalDot = new Error("compiler", "illegal.dot");
compiler.err.illegal.enum.static.ref=\ illegal reference to static field from initializer
/** * compiler.err.illegal.enum.static.ref=\ * illegal reference to static field from initializer */
public static final Error IllegalEnumStaticRef = new Error("compiler", "illegal.enum.static.ref");
compiler.err.illegal.esc.char=\ illegal escape character
/** * compiler.err.illegal.esc.char=\ * illegal escape character */
public static final Error IllegalEscChar = new Error("compiler", "illegal.esc.char");
compiler.err.illegal.forward.ref=\ illegal forward reference
/** * compiler.err.illegal.forward.ref=\ * illegal forward reference */
public static final Error IllegalForwardRef = new Error("compiler", "illegal.forward.ref");
compiler.err.illegal.initializer.for.type=\ illegal initializer for {0}
/** * compiler.err.illegal.initializer.for.type=\ * illegal initializer for {0} */
public static Error IllegalInitializerForType(Type arg0) { return new Error("compiler", "illegal.initializer.for.type", arg0); }
compiler.err.illegal.line.end.in.char.lit=\ illegal line end in character literal
/** * compiler.err.illegal.line.end.in.char.lit=\ * illegal line end in character literal */
public static final Error IllegalLineEndInCharLit = new Error("compiler", "illegal.line.end.in.char.lit");
compiler.err.illegal.nonascii.digit=\ illegal non-ASCII digit
/** * compiler.err.illegal.nonascii.digit=\ * illegal non-ASCII digit */
public static final Error IllegalNonasciiDigit = new Error("compiler", "illegal.nonascii.digit");
compiler.err.illegal.parenthesized.expression=\ illegal parenthesized expression
/** * compiler.err.illegal.parenthesized.expression=\ * illegal parenthesized expression */
public static final Error IllegalParenthesizedExpression = new Error("compiler", "illegal.parenthesized.expression");
compiler.err.illegal.qual.not.icls=\ illegal qualifier; {0} is not an inner class
/** * compiler.err.illegal.qual.not.icls=\ * illegal qualifier; {0} is not an inner class */
public static Error IllegalQualNotIcls(Symbol arg0) { return new Error("compiler", "illegal.qual.not.icls", arg0); }
compiler.err.illegal.record.component.name=\ illegal record component name {0}
/** * compiler.err.illegal.record.component.name=\ * illegal record component name {0} */
public static Error IllegalRecordComponentName(Symbol arg0) { return new Error("compiler", "illegal.record.component.name", arg0); }
compiler.err.illegal.ref.to.restricted.type=\ illegal reference to restricted type ''{0}''
/** * compiler.err.illegal.ref.to.restricted.type=\ * illegal reference to restricted type ''{0}'' */
public static Error IllegalRefToRestrictedType(Name arg0) { return new Error("compiler", "illegal.ref.to.restricted.type", arg0); }
compiler.err.illegal.self.ref=\ self-reference in initializer
/** * compiler.err.illegal.self.ref=\ * self-reference in initializer */
public static final Error IllegalSelfRef = new Error("compiler", "illegal.self.ref");
compiler.err.illegal.start.of.expr=\ illegal start of expression
/** * compiler.err.illegal.start.of.expr=\ * illegal start of expression */
public static final Error IllegalStartOfExpr = new Error("compiler", "illegal.start.of.expr");
compiler.err.illegal.start.of.stmt=\ illegal start of statement
/** * compiler.err.illegal.start.of.stmt=\ * illegal start of statement */
public static final Error IllegalStartOfStmt = new Error("compiler", "illegal.start.of.stmt");
compiler.err.illegal.start.of.type=\ illegal start of type
/** * compiler.err.illegal.start.of.type=\ * illegal start of type */
public static final Error IllegalStartOfType = new Error("compiler", "illegal.start.of.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}''
/** * compiler.err.illegal.static.intf.meth.call=\ * illegal static interface method call\n\ * the receiver expression should be replaced with the type qualifier ''{0}'' */
public static Error IllegalStaticIntfMethCall(Type arg0) { return new Error("compiler", "illegal.static.intf.meth.call", arg0); }
compiler.err.illegal.text.block.open=\ illegal text block open delimiter sequence, missing line terminator
/** * compiler.err.illegal.text.block.open=\ * illegal text block open delimiter sequence, missing line terminator */
public static final Error IllegalTextBlockOpen = new Error("compiler", "illegal.text.block.open");
compiler.err.illegal.underscore=\ illegal underscore
/** * compiler.err.illegal.underscore=\ * illegal underscore */
public static final Error IllegalUnderscore = new Error("compiler", "illegal.underscore");
compiler.err.illegal.unicode.esc=\ illegal unicode escape
/** * compiler.err.illegal.unicode.esc=\ * illegal unicode escape */
public static final Error IllegalUnicodeEsc = new Error("compiler", "illegal.unicode.esc");
compiler.err.import.requires.canonical=\ import requires canonical name for {0}
/** * compiler.err.import.requires.canonical=\ * import requires canonical name for {0} */
public static Error ImportRequiresCanonical(Symbol arg0) { return new Error("compiler", "import.requires.canonical", arg0); }
compiler.err.improperly.formed.type.inner.raw.param=\ improperly formed type, type arguments given on a raw type
/** * compiler.err.improperly.formed.type.inner.raw.param=\ * improperly formed type, type arguments given on a raw type */
public static final Error ImproperlyFormedTypeInnerRawParam = new Error("compiler", "improperly.formed.type.inner.raw.param");
compiler.err.improperly.formed.type.param.missing=\ improperly formed type, some parameters are missing
/** * compiler.err.improperly.formed.type.param.missing=\ * improperly formed type, some parameters are missing */
public static final Error ImproperlyFormedTypeParamMissing = new Error("compiler", "improperly.formed.type.param.missing");
compiler.err.incomparable.types=\ incomparable types: {0} and {1}
/** * compiler.err.incomparable.types=\ * incomparable types: {0} and {1} */
public static Error IncomparableTypes(Type arg0, Type arg1) { return new Error("compiler", "incomparable.types", arg0, arg1); }
compiler.err.incompatible.thrown.types.in.mref=\ incompatible thrown types {0} in functional expression
/** * compiler.err.incompatible.thrown.types.in.mref=\ * incompatible thrown types {0} in functional expression */
public static Error IncompatibleThrownTypesInMref(List<? extends Type> arg0) { return new Error("compiler", "incompatible.thrown.types.in.mref", arg0); }
compiler.err.incorrect.constructor.receiver.name=\ the receiver name does not match the enclosing outer class type\n\ required: {0}\n\ found: {1}
/** * compiler.err.incorrect.constructor.receiver.name=\ * the receiver name does not match the enclosing outer class type\n\ * required: {0}\n\ * found: {1} */
public static Error IncorrectConstructorReceiverName(Type arg0, Type arg1) { return new Error("compiler", "incorrect.constructor.receiver.name", arg0, arg1); }
compiler.err.incorrect.constructor.receiver.type=\ the receiver type does not match the enclosing outer class type\n\ required: {0}\n\ found: {1}
/** * compiler.err.incorrect.constructor.receiver.type=\ * the receiver type does not match the enclosing outer class type\n\ * required: {0}\n\ * found: {1} */
public static Error IncorrectConstructorReceiverType(Type arg0, Type arg1) { return new Error("compiler", "incorrect.constructor.receiver.type", arg0, arg1); }
compiler.err.incorrect.receiver.name=\ the receiver name does not match the enclosing class type\n\ required: {0}\n\ found: {1}
/** * compiler.err.incorrect.receiver.name=\ * the receiver name does not match the enclosing class type\n\ * required: {0}\n\ * found: {1} */
public static Error IncorrectReceiverName(Type arg0, Type arg1) { return new Error("compiler", "incorrect.receiver.name", arg0, arg1); }
compiler.err.incorrect.receiver.type=\ the receiver type does not match the enclosing class type\n\ required: {0}\n\ found: {1}
/** * compiler.err.incorrect.receiver.type=\ * the receiver type does not match the enclosing class type\n\ * required: {0}\n\ * found: {1} */
public static Error IncorrectReceiverType(Type arg0, Type arg1) { return new Error("compiler", "incorrect.receiver.type", arg0, arg1); }
compiler.err.initializer.must.be.able.to.complete.normally=\ initializer must be able to complete normally
/** * compiler.err.initializer.must.be.able.to.complete.normally=\ * initializer must be able to complete normally */
public static final Error InitializerMustBeAbleToCompleteNormally = new Error("compiler", "initializer.must.be.able.to.complete.normally");
compiler.err.initializer.not.allowed=\ initializers not allowed in interfaces
/** * compiler.err.initializer.not.allowed=\ * initializers not allowed in interfaces */
public static final Error InitializerNotAllowed = new Error("compiler", "initializer.not.allowed");
compiler.err.instance.initializer.not.allowed.in.records=\ instance initializers not allowed in records
/** * compiler.err.instance.initializer.not.allowed.in.records=\ * instance initializers not allowed in records */
public static final Error InstanceInitializerNotAllowedInRecords = new Error("compiler", "instance.initializer.not.allowed.in.records");
compiler.err.instanceof.pattern.no.subtype=\ pattern type {0} is a subtype of expression type {1}
/** * compiler.err.instanceof.pattern.no.subtype=\ * pattern type {0} is a subtype of expression type {1} */
public static Error InstanceofPatternNoSubtype(Type arg0, Type arg1) { return new Error("compiler", "instanceof.pattern.no.subtype", arg0, arg1); }
compiler.err.instanceof.reifiable.not.safe=\ {0} cannot be safely cast to {1}
/** * compiler.err.instanceof.reifiable.not.safe=\ * {0} cannot be safely cast to {1} */
public static Error InstanceofReifiableNotSafe(Type arg0, Type arg1) { return new Error("compiler", "instanceof.reifiable.not.safe", arg0, arg1); }
compiler.err.int.number.too.large=\ integer number too large
/** * compiler.err.int.number.too.large=\ * integer number too large */
public static Error IntNumberTooLarge(String arg0) { return new Error("compiler", "int.number.too.large", arg0); }
compiler.err.intf.annotation.cant.have.type.params=\ annotation type {0} cannot be generic
/** * compiler.err.intf.annotation.cant.have.type.params=\ * annotation type {0} cannot be generic */
public static Error IntfAnnotationCantHaveTypeParams(Symbol arg0) { return new Error("compiler", "intf.annotation.cant.have.type.params", arg0); }
compiler.err.intf.annotation.member.clash=\ annotation type {1} declares an element with the same name as method {0}
/** * compiler.err.intf.annotation.member.clash=\ * annotation type {1} declares an element with the same name as method {0} */
public static Error IntfAnnotationMemberClash(Symbol arg0, Type arg1) { return new Error("compiler", "intf.annotation.member.clash", arg0, arg1); }
compiler.err.intf.annotation.members.cant.have.params=\ elements in annotation type declarations cannot declare formal parameters
/** * compiler.err.intf.annotation.members.cant.have.params=\ * elements in annotation type declarations cannot declare formal parameters */
public static final Error IntfAnnotationMembersCantHaveParams = new Error("compiler", "intf.annotation.members.cant.have.params");
compiler.err.intf.annotation.members.cant.have.type.params=\ elements in annotation type declarations cannot be generic methods
/** * compiler.err.intf.annotation.members.cant.have.type.params=\ * elements in annotation type declarations cannot be generic methods */
public static final Error IntfAnnotationMembersCantHaveTypeParams = new Error("compiler", "intf.annotation.members.cant.have.type.params");
compiler.err.intf.expected.here=\ interface expected here
/** * compiler.err.intf.expected.here=\ * interface expected here */
public static final Error IntfExpectedHere = new Error("compiler", "intf.expected.here");
compiler.err.intf.meth.cant.have.body=\ interface abstract methods cannot have body
/** * compiler.err.intf.meth.cant.have.body=\ * interface abstract methods cannot have body */
public static final Error IntfMethCantHaveBody = new Error("compiler", "intf.meth.cant.have.body");
compiler.err.intf.not.allowed.here=\ interface not allowed here
/** * compiler.err.intf.not.allowed.here=\ * interface not allowed here */
public static final Error IntfNotAllowedHere = new Error("compiler", "intf.not.allowed.here");
compiler.err.invalid.A.key=\ key in annotation processor option ''{0}'' is not a dot-separated sequence of identifiers
/** * compiler.err.invalid.A.key=\ * key in annotation processor option ''{0}'' is not a dot-separated sequence of identifiers */
public static Error InvalidAKey(String arg0) { return new Error("compiler", "invalid.A.key", arg0); }
compiler.err.invalid.accessor.method.in.record=\ invalid accessor method in record {0}\n\ ({1})
/** * compiler.err.invalid.accessor.method.in.record=\ * invalid accessor method in record {0}\n\ * ({1}) */
public static Error InvalidAccessorMethodInRecord(Symbol arg0, Fragment arg1) { return new Error("compiler", "invalid.accessor.method.in.record", arg0, arg1); }
compiler.err.invalid.annotation.member.type=\ invalid type for annotation type element
/** * compiler.err.invalid.annotation.member.type=\ * invalid type for annotation type element */
public static final Error InvalidAnnotationMemberType = new Error("compiler", "invalid.annotation.member.type");
compiler.err.invalid.binary.number=\ binary numbers must contain at least one binary digit
/** * compiler.err.invalid.binary.number=\ * binary numbers must contain at least one binary digit */
public static final Error InvalidBinaryNumber = new Error("compiler", "invalid.binary.number");
compiler.err.invalid.canonical.constructor.in.record=\ invalid {0} constructor in record {1}\n\ ({2})
/** * compiler.err.invalid.canonical.constructor.in.record=\ * invalid {0} constructor in record {1}\n\ * ({2}) */
public static Error InvalidCanonicalConstructorInRecord(Fragment arg0, Name arg1, Fragment arg2) { return new Error("compiler", "invalid.canonical.constructor.in.record", arg0, arg1, arg2); }
compiler.err.invalid.flag=\ invalid flag: {0}
/** * compiler.err.invalid.flag=\ * invalid flag: {0} */
public static Error InvalidFlag(String arg0) { return new Error("compiler", "invalid.flag", arg0); }
compiler.err.invalid.hex.number=\ hexadecimal numbers must contain at least one hexadecimal digit
/** * compiler.err.invalid.hex.number=\ * hexadecimal numbers must contain at least one hexadecimal digit */
public static final Error InvalidHexNumber = new Error("compiler", "invalid.hex.number");
compiler.err.invalid.lambda.parameter.declaration=\ invalid lambda parameter declaration\n\ ({0})
/** * compiler.err.invalid.lambda.parameter.declaration=\ * invalid lambda parameter declaration\n\ * ({0}) */
public static Error InvalidLambdaParameterDeclaration(Fragment arg0) { return new Error("compiler", "invalid.lambda.parameter.declaration", arg0); }
compiler.err.invalid.meth.decl.ret.type.req=\ invalid method declaration; return type required
/** * compiler.err.invalid.meth.decl.ret.type.req=\ * invalid method declaration; return type required */
public static final Error InvalidMethDeclRetTypeReq = new Error("compiler", "invalid.meth.decl.ret.type.req");
compiler.err.invalid.module.directive=\ module directive keyword or ''}'' expected
/** * compiler.err.invalid.module.directive=\ * module directive keyword or ''}'' expected */
public static final Error InvalidModuleDirective = new Error("compiler", "invalid.module.directive");
compiler.err.invalid.module.specifier=\ module specifier not allowed: {0}
/** * compiler.err.invalid.module.specifier=\ * module specifier not allowed: {0} */
public static Error InvalidModuleSpecifier(String arg0) { return new Error("compiler", "invalid.module.specifier", arg0); }
compiler.err.invalid.mref=\ invalid {0} reference\n\ {1}
/** * compiler.err.invalid.mref=\ * invalid {0} reference\n\ * {1} */
public static Error InvalidMref(KindName arg0, JCDiagnostic arg1) { return new Error("compiler", "invalid.mref", arg0, arg1); }
compiler.err.invalid.mref=\ invalid {0} reference\n\ {1}
/** * compiler.err.invalid.mref=\ * invalid {0} reference\n\ * {1} */
public static Error InvalidMref(KindName arg0, Fragment arg1) { return new Error("compiler", "invalid.mref", arg0, arg1); }
compiler.err.invalid.path=\ Invalid filename: {0}
/** * compiler.err.invalid.path=\ * Invalid filename: {0} */
public static Error InvalidPath(String arg0) { return new Error("compiler", "invalid.path", arg0); }
compiler.err.invalid.permits.clause=\ invalid permits clause\n\ ({0})
/** * compiler.err.invalid.permits.clause=\ * invalid permits clause\n\ * ({0}) */
public static Error InvalidPermitsClause(Fragment arg0) { return new Error("compiler", "invalid.permits.clause", arg0); }
compiler.err.invalid.profile=\ invalid profile: {0}
/** * compiler.err.invalid.profile=\ * invalid profile: {0} */
public static Error InvalidProfile(String arg0) { return new Error("compiler", "invalid.profile", arg0); }
compiler.err.invalid.repeatable.annotation=\ duplicate annotation: {0} is annotated with an invalid @Repeatable annotation
/** * compiler.err.invalid.repeatable.annotation=\ * duplicate annotation: {0} is annotated with an invalid @Repeatable annotation */
public static Error InvalidRepeatableAnnotation(Symbol arg0) { return new Error("compiler", "invalid.repeatable.annotation", arg0); }
compiler.err.invalid.repeatable.annotation.elem.nondefault=\ containing annotation type ({0}) does not have a default value for element {1}
/** * compiler.err.invalid.repeatable.annotation.elem.nondefault=\ * containing annotation type ({0}) does not have a default value for element {1} */
public static Error InvalidRepeatableAnnotationElemNondefault(Symbol arg0, Symbol arg1) { return new Error("compiler", "invalid.repeatable.annotation.elem.nondefault", arg0, arg1); }
compiler.err.invalid.repeatable.annotation.elem.nondefault=\ containing annotation type ({0}) does not have a default value for element {1}
/** * compiler.err.invalid.repeatable.annotation.elem.nondefault=\ * containing annotation type ({0}) does not have a default value for element {1} */
public static Error InvalidRepeatableAnnotationElemNondefault(Type arg0, Symbol arg1) { return new Error("compiler", "invalid.repeatable.annotation.elem.nondefault", arg0, arg1); }
compiler.err.invalid.repeatable.annotation.incompatible.target=\ containing annotation type ({0}) is applicable to more targets than repeatable annotation type ({1})
/** * compiler.err.invalid.repeatable.annotation.incompatible.target=\ * containing annotation type ({0}) is applicable to more targets than repeatable annotation type ({1}) */
public static Error InvalidRepeatableAnnotationIncompatibleTarget(Symbol arg0, Symbol arg1) { return new Error("compiler", "invalid.repeatable.annotation.incompatible.target", arg0, arg1); }
compiler.err.invalid.repeatable.annotation.invalid.value=\ {0} is not a valid @Repeatable: invalid value element
/** * compiler.err.invalid.repeatable.annotation.invalid.value=\ * {0} is not a valid @Repeatable: invalid value element */
public static Error InvalidRepeatableAnnotationInvalidValue(Type arg0) { return new Error("compiler", "invalid.repeatable.annotation.invalid.value", arg0); }
compiler.err.invalid.repeatable.annotation.multiple.values=\ {0} is not a valid @Repeatable, {1} element methods named ''value'' declared
/** * compiler.err.invalid.repeatable.annotation.multiple.values=\ * {0} is not a valid @Repeatable, {1} element methods named ''value'' declared */
public static Error InvalidRepeatableAnnotationMultipleValues(Type arg0, int arg1) { return new Error("compiler", "invalid.repeatable.annotation.multiple.values", arg0, arg1); }
compiler.err.invalid.repeatable.annotation.no.value=\ {0} is not a valid @Repeatable, no value element method declared
/** * compiler.err.invalid.repeatable.annotation.no.value=\ * {0} is not a valid @Repeatable, no value element method declared */
public static Error InvalidRepeatableAnnotationNoValue(Symbol arg0) { return new Error("compiler", "invalid.repeatable.annotation.no.value", arg0); }
compiler.err.invalid.repeatable.annotation.no.value=\ {0} is not a valid @Repeatable, no value element method declared
/** * compiler.err.invalid.repeatable.annotation.no.value=\ * {0} is not a valid @Repeatable, no value element method declared */
public static Error InvalidRepeatableAnnotationNoValue(Type arg0) { return new Error("compiler", "invalid.repeatable.annotation.no.value", arg0); }
compiler.err.invalid.repeatable.annotation.not.applicable=\ container {0} is not applicable to element {1}
/** * compiler.err.invalid.repeatable.annotation.not.applicable=\ * container {0} is not applicable to element {1} */
public static Error InvalidRepeatableAnnotationNotApplicable(Type arg0, Symbol arg1) { return new Error("compiler", "invalid.repeatable.annotation.not.applicable", arg0, arg1); }
compiler.err.invalid.repeatable.annotation.not.applicable.in.context=\ container {0} is not applicable in this type context
/** * compiler.err.invalid.repeatable.annotation.not.applicable.in.context=\ * container {0} is not applicable in this type context */
public static Error InvalidRepeatableAnnotationNotApplicableInContext(Type arg0) { return new Error("compiler", "invalid.repeatable.annotation.not.applicable.in.context", arg0); }
compiler.err.invalid.repeatable.annotation.not.documented=\ repeatable annotation type ({1}) is @Documented while containing annotation type ({0}) is not
/** * compiler.err.invalid.repeatable.annotation.not.documented=\ * repeatable annotation type ({1}) is @Documented while containing annotation type ({0}) is not */
public static Error InvalidRepeatableAnnotationNotDocumented(Symbol arg0, Symbol arg1) { return new Error("compiler", "invalid.repeatable.annotation.not.documented", arg0, arg1); }
compiler.err.invalid.repeatable.annotation.not.inherited=\ repeatable annotation type ({1}) is @Inherited while containing annotation type ({0}) is not
/** * compiler.err.invalid.repeatable.annotation.not.inherited=\ * repeatable annotation type ({1}) is @Inherited while containing annotation type ({0}) is not */
public static Error InvalidRepeatableAnnotationNotInherited(Symbol arg0, Symbol arg1) { return new Error("compiler", "invalid.repeatable.annotation.not.inherited", arg0, arg1); }
compiler.err.invalid.repeatable.annotation.repeated.and.container.present=\ container {0} must not be present at the same time as the element it contains
/** * compiler.err.invalid.repeatable.annotation.repeated.and.container.present=\ * container {0} must not be present at the same time as the element it contains */
public static Error InvalidRepeatableAnnotationRepeatedAndContainerPresent(Symbol arg0) { return new Error("compiler", "invalid.repeatable.annotation.repeated.and.container.present", arg0); }
compiler.err.invalid.repeatable.annotation.retention=\ retention of containing annotation type ({0}) is shorter than the retention of repeatable annotation type ({2})
/** * compiler.err.invalid.repeatable.annotation.retention=\ * retention of containing annotation type ({0}) is shorter than the retention of repeatable annotation type ({2}) */
public static Error InvalidRepeatableAnnotationRetention(Symbol arg0, String arg1, Symbol arg2, String arg3) { return new Error("compiler", "invalid.repeatable.annotation.retention", arg0, arg1, arg2, arg3); }
compiler.err.invalid.repeatable.annotation.value.return=\ containing annotation type ({0}) must declare an element named ''value'' of type {2}
/** * compiler.err.invalid.repeatable.annotation.value.return=\ * containing annotation type ({0}) must declare an element named ''value'' of type {2} */
public static Error InvalidRepeatableAnnotationValueReturn(Symbol arg0, Type arg1, Type arg2) { return new Error("compiler", "invalid.repeatable.annotation.value.return", arg0, arg1, arg2); }
compiler.err.invalid.repeatable.annotation.value.return=\ containing annotation type ({0}) must declare an element named ''value'' of type {2}
/** * compiler.err.invalid.repeatable.annotation.value.return=\ * containing annotation type ({0}) must declare an element named ''value'' of type {2} */
public static Error InvalidRepeatableAnnotationValueReturn(Type arg0, Type arg1, Type arg2) { return new Error("compiler", "invalid.repeatable.annotation.value.return", arg0, arg1, arg2); }
compiler.err.invalid.source=\ invalid source release: {0}
/** * compiler.err.invalid.source=\ * invalid source release: {0} */
public static Error InvalidSource(String arg0) { return new Error("compiler", "invalid.source", arg0); }
compiler.err.invalid.supertype.record=\ classes cannot directly extend {0}
/** * compiler.err.invalid.supertype.record=\ * classes cannot directly extend {0} */
public static Error InvalidSupertypeRecord(Symbol arg0) { return new Error("compiler", "invalid.supertype.record", arg0); }
compiler.err.invalid.target=\ invalid target release: {0}
/** * compiler.err.invalid.target=\ * invalid target release: {0} */
public static Error InvalidTarget(String arg0) { return new Error("compiler", "invalid.target", arg0); }
compiler.err.invalid.yield=\ invalid use of a restricted identifier ''yield''\n\ (to invoke a method called yield, qualify the yield with a receiver or type name)
/** * compiler.err.invalid.yield=\ * invalid use of a restricted identifier ''yield''\n\ * (to invoke a method called yield, qualify the yield with a receiver or type name) */
public static final Error InvalidYield = new Error("compiler", "invalid.yield");
compiler.err.io.exception=\ error reading source file: {0}
/** * compiler.err.io.exception=\ * error reading source file: {0} */
public static final Error IoException = new Error("compiler", "io.exception");
compiler.err.is.preview=\ {0} is an API that is part of a preview feature
/** * compiler.err.is.preview=\ * {0} is an API that is part of a preview feature */
public static Error IsPreview(Symbol arg0) { return new Error("compiler", "is.preview", arg0); }
compiler.err.label.already.in.use=\ label {0} already in use
/** * compiler.err.label.already.in.use=\ * label {0} already in use */
public static Error LabelAlreadyInUse(Name arg0) { return new Error("compiler", "label.already.in.use", arg0); }
compiler.err.lambda.body.neither.value.nor.void.compatible=\ lambda body is neither value nor void compatible
/** * compiler.err.lambda.body.neither.value.nor.void.compatible=\ * lambda body is neither value nor void compatible */
public static final Error LambdaBodyNeitherValueNorVoidCompatible = new Error("compiler", "lambda.body.neither.value.nor.void.compatible");
compiler.err.limit.code=\ code too large
/** * compiler.err.limit.code=\ * code too large */
public static final Error LimitCode = new Error("compiler", "limit.code");
compiler.err.limit.code.too.large.for.try.stmt=\ code too large for try statement
/** * compiler.err.limit.code.too.large.for.try.stmt=\ * code too large for try statement */
public static final Error LimitCodeTooLargeForTryStmt = new Error("compiler", "limit.code.too.large.for.try.stmt");
compiler.err.limit.dimensions=\ array type has too many dimensions
/** * compiler.err.limit.dimensions=\ * array type has too many dimensions */
public static final Error LimitDimensions = new Error("compiler", "limit.dimensions");
compiler.err.limit.locals=\ too many local variables
/** * compiler.err.limit.locals=\ * too many local variables */
public static final Error LimitLocals = new Error("compiler", "limit.locals");
compiler.err.limit.parameters=\ too many parameters
/** * compiler.err.limit.parameters=\ * too many parameters */
public static final Error LimitParameters = new Error("compiler", "limit.parameters");
compiler.err.limit.pool=\ too many constants
/** * compiler.err.limit.pool=\ * too many constants */
public static final Error LimitPool = new Error("compiler", "limit.pool");
compiler.err.limit.pool.in.class=\ too many constants in class {0}
/** * compiler.err.limit.pool.in.class=\ * too many constants in class {0} */
public static final Error LimitPoolInClass = new Error("compiler", "limit.pool.in.class");
compiler.err.limit.stack=\ code requires too much stack
/** * compiler.err.limit.stack=\ * code requires too much stack */
public static final Error LimitStack = new Error("compiler", "limit.stack");
compiler.err.limit.string=\ constant string too long
/** * compiler.err.limit.string=\ * constant string too long */
public static final Error LimitString = new Error("compiler", "limit.string");
compiler.err.limit.string.overflow=\ UTF8 representation for string \"{0}...\" is too long for the constant pool
/** * compiler.err.limit.string.overflow=\ * UTF8 representation for string \"{0}...\" is too long for the constant pool */
public static Error LimitStringOverflow(String arg0) { return new Error("compiler", "limit.string.overflow", arg0); }
compiler.err.local.classes.cant.extend.sealed=\ {0} classes must not extend sealed classes\
/** * compiler.err.local.classes.cant.extend.sealed=\ * {0} classes must not extend sealed classes\ */
public static Error LocalClassesCantExtendSealed(Fragment arg0) { return new Error("compiler", "local.classes.cant.extend.sealed", arg0); }
compiler.err.local.enum=\ enum types must not be local
/** * compiler.err.local.enum=\ * enum types must not be local */
public static final Error LocalEnum = new Error("compiler", "local.enum");
compiler.err.local.var.accessed.from.icls.needs.final=\ local variable {0} is accessed from within inner class; needs to be declared final
/** * compiler.err.local.var.accessed.from.icls.needs.final=\ * local variable {0} is accessed from within inner class; needs to be declared final */
public static Error LocalVarAccessedFromIclsNeedsFinal(Symbol arg0) { return new Error("compiler", "local.var.accessed.from.icls.needs.final", arg0); }
compiler.err.locn.bad.module-info=\ problem reading module-info.class in {0}
/** * compiler.err.locn.bad.module-info=\ * problem reading module-info.class in {0} */
public static Error LocnBadModuleInfo(Path arg0) { return new Error("compiler", "locn.bad.module-info", arg0); }
compiler.err.locn.cant.get.module.name.for.jar=\ cannot determine module name for {0}
/** * compiler.err.locn.cant.get.module.name.for.jar=\ * cannot determine module name for {0} */
public static Error LocnCantGetModuleNameForJar(Path arg0) { return new Error("compiler", "locn.cant.get.module.name.for.jar", arg0); }
compiler.err.locn.cant.read.directory=\ cannot read directory {0}
/** * compiler.err.locn.cant.read.directory=\ * cannot read directory {0} */
public static Error LocnCantReadDirectory(Path arg0) { return new Error("compiler", "locn.cant.read.directory", arg0); }
compiler.err.locn.cant.read.file=\ cannot read file {0}
/** * compiler.err.locn.cant.read.file=\ * cannot read file {0} */
public static Error LocnCantReadFile(Path arg0) { return new Error("compiler", "locn.cant.read.file", arg0); }
compiler.err.locn.invalid.arg.for.xpatch=\ invalid argument for --patch-module option: {0}
/** * compiler.err.locn.invalid.arg.for.xpatch=\ * invalid argument for --patch-module option: {0} */
public static Error LocnInvalidArgForXpatch(String arg0) { return new Error("compiler", "locn.invalid.arg.for.xpatch", arg0); }
compiler.err.locn.module-info.not.allowed.on.patch.path=\ module-info.class not allowed on patch path: {0}
/** * compiler.err.locn.module-info.not.allowed.on.patch.path=\ * module-info.class not allowed on patch path: {0} */
public static Error LocnModuleInfoNotAllowedOnPatchPath(JavaFileObject arg0) { return new Error("compiler", "locn.module-info.not.allowed.on.patch.path", arg0); }
compiler.err.malformed.fp.lit=\ malformed floating point literal
/** * compiler.err.malformed.fp.lit=\ * malformed floating point literal */
public static final Error MalformedFpLit = new Error("compiler", "malformed.fp.lit");
compiler.err.match.binding.exists=\ illegal attempt to redefine an existing match binding
/** * compiler.err.match.binding.exists=\ * illegal attempt to redefine an existing match binding */
public static final Error MatchBindingExists = new Error("compiler", "match.binding.exists");
compiler.err.method.does.not.override.superclass=\ method does not override or implement a method from a supertype
/** * compiler.err.method.does.not.override.superclass=\ * method does not override or implement a method from a supertype */
public static final Error MethodDoesNotOverrideSuperclass = new Error("compiler", "method.does.not.override.superclass");
compiler.err.missing.meth.body.or.decl.abstract=\ missing method body, or declare abstract
/** * compiler.err.missing.meth.body.or.decl.abstract=\ * missing method body, or declare abstract */
public static final Error MissingMethBodyOrDeclAbstract = new Error("compiler", "missing.meth.body.or.decl.abstract");
compiler.err.missing.ret.stmt=\ missing return statement
/** * compiler.err.missing.ret.stmt=\ * missing return statement */
public static final Error MissingRetStmt = new Error("compiler", "missing.ret.stmt");
compiler.err.mod.not.allowed.here=\ modifier {0} not allowed here
/** * compiler.err.mod.not.allowed.here=\ * modifier {0} not allowed here */
public static Error ModNotAllowedHere(Set<? extends Flag> arg0) { return new Error("compiler", "mod.not.allowed.here", arg0); }
compiler.err.modifier.not.allowed.here=\ modifier {0} not allowed here
/** * compiler.err.modifier.not.allowed.here=\ * modifier {0} not allowed here */
public static Error ModifierNotAllowedHere(Name arg0) { return new Error("compiler", "modifier.not.allowed.here", arg0); }
compiler.err.module.decl.sb.in.module-info.java=\ module declarations should be in a file named module-info.java
/** * compiler.err.module.decl.sb.in.module-info.java=\ * module declarations should be in a file named module-info.java */
public static final Error ModuleDeclSbInModuleInfoJava = new Error("compiler", "module.decl.sb.in.module-info.java");
compiler.err.module.name.mismatch=\ module name {0} does not match expected name {1}
/** * compiler.err.module.name.mismatch=\ * module name {0} does not match expected name {1} */
public static Error ModuleNameMismatch(Name arg0, Name arg1) { return new Error("compiler", "module.name.mismatch", arg0, arg1); }
compiler.err.module.non.zero.opens=\ open module {0} has non-zero opens_count
/** * compiler.err.module.non.zero.opens=\ * open module {0} has non-zero opens_count */
public static Error ModuleNonZeroOpens(Name arg0) { return new Error("compiler", "module.non.zero.opens", arg0); }
compiler.err.module.not.found=\ module not found: {0}
/** * compiler.err.module.not.found=\ * module not found: {0} */
public static Error ModuleNotFound(Symbol arg0) { return new Error("compiler", "module.not.found", arg0); }
compiler.err.module.not.found.in.module.source.path=\ module {0} not found in module source path
/** * compiler.err.module.not.found.in.module.source.path=\ * module {0} not found in module source path */
public static Error ModuleNotFoundInModuleSourcePath(String arg0) { return new Error("compiler", "module.not.found.in.module.source.path", arg0); }
compiler.err.module.not.found.on.module.source.path=\ module not found on module source path
/** * compiler.err.module.not.found.on.module.source.path=\ * module not found on module source path */
public static final Error ModuleNotFoundOnModuleSourcePath = new Error("compiler", "module.not.found.on.module.source.path");
compiler.err.modulesourcepath.must.be.specified.with.dash.m.option=\ module source path must be specified if -m option is used
/** * compiler.err.modulesourcepath.must.be.specified.with.dash.m.option=\ * module source path must be specified if -m option is used */
public static final Error ModulesourcepathMustBeSpecifiedWithDashMOption = new Error("compiler", "modulesourcepath.must.be.specified.with.dash.m.option");
compiler.err.multi-module.outdir.cannot.be.exploded.module=\ in multi-module mode, the output directory cannot be an exploded module: {0}
/** * compiler.err.multi-module.outdir.cannot.be.exploded.module=\ * in multi-module mode, the output directory cannot be an exploded module: {0} */
public static Error MultiModuleOutdirCannotBeExplodedModule(Path arg0) { return new Error("compiler", "multi-module.outdir.cannot.be.exploded.module", arg0); }
compiler.err.multicatch.parameter.may.not.be.assigned=\ multi-catch parameter {0} may not be assigned
/** * compiler.err.multicatch.parameter.may.not.be.assigned=\ * multi-catch parameter {0} may not be assigned */
public static Error MulticatchParameterMayNotBeAssigned(Symbol arg0) { return new Error("compiler", "multicatch.parameter.may.not.be.assigned", arg0); }
compiler.err.multicatch.types.must.be.disjoint=\ Alternatives in a multi-catch statement cannot be related by subclassing\n\ Alternative {0} is a subclass of alternative {1}
/** * compiler.err.multicatch.types.must.be.disjoint=\ * Alternatives in a multi-catch statement cannot be related by subclassing\n\ * Alternative {0} is a subclass of alternative {1} */
public static Error MulticatchTypesMustBeDisjoint(Type arg0, Type arg1) { return new Error("compiler", "multicatch.types.must.be.disjoint", arg0, arg1); }
compiler.err.multiple.values.for.module.source.path=\ --module-source-path specified more than once with a pattern argument
/** * compiler.err.multiple.values.for.module.source.path=\ * --module-source-path specified more than once with a pattern argument */
public static final Error MultipleValuesForModuleSourcePath = new Error("compiler", "multiple.values.for.module.source.path");
compiler.err.name.clash.same.erasure=\ name clash: {0} and {1} have the same erasure
/** * compiler.err.name.clash.same.erasure=\ * name clash: {0} and {1} have the same erasure */
public static Error NameClashSameErasure(Symbol arg0, Symbol arg1) { return new Error("compiler", "name.clash.same.erasure", arg0, arg1); }
compiler.err.name.clash.same.erasure.no.hide=\ name clash: {0} in {1} and {2} in {3} have the same erasure, yet neither hides the other
/** * compiler.err.name.clash.same.erasure.no.hide=\ * name clash: {0} in {1} and {2} in {3} have the same erasure, yet neither hides the other */
public static Error NameClashSameErasureNoHide(Symbol arg0, Symbol arg1, Symbol arg2, Symbol arg3) { return new Error("compiler", "name.clash.same.erasure.no.hide", arg0, arg1, arg2, arg3); }
compiler.err.name.clash.same.erasure.no.override=\ name clash: {0}({1}) in {2} and {3}({4}) in {5} have the same erasure, yet neither overrides the other
/** * compiler.err.name.clash.same.erasure.no.override=\ * name clash: {0}({1}) in {2} and {3}({4}) in {5} have the same erasure, yet neither overrides the other */
public static Error NameClashSameErasureNoOverride(Name arg0, List<? extends Type> arg1, Symbol arg2, Name arg3, List<? extends Type> arg4, Symbol arg5) { return new Error("compiler", "name.clash.same.erasure.no.override", arg0, arg1, arg2, arg3, arg4, arg5); }
compiler.err.name.clash.same.erasure.no.override.1=\ name clash: {0} {1} has two methods with the same erasure, yet neither overrides the other\n\ first method: {2}({3}) in {4}\n\ second method: {5}({6}) in {7}
/** * compiler.err.name.clash.same.erasure.no.override.1=\ * name clash: {0} {1} has two methods with the same erasure, yet neither overrides the other\n\ * first method: {2}({3}) in {4}\n\ * second method: {5}({6}) in {7} */
public static Error NameClashSameErasureNoOverride1(String arg0, Name arg1, Name arg2, List<? extends Type> arg3, Symbol arg4, Name arg5, List<? extends Type> arg6, Symbol arg7) { return new Error("compiler", "name.clash.same.erasure.no.override.1", arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7); }
compiler.err.name.reserved.for.internal.use=\ {0} is reserved for internal use
/** * compiler.err.name.reserved.for.internal.use=\ * {0} is reserved for internal use */
public static final Error NameReservedForInternalUse = new Error("compiler", "name.reserved.for.internal.use");
compiler.err.native.meth.cant.have.body=\ native methods cannot have a body
/** * compiler.err.native.meth.cant.have.body=\ * native methods cannot have a body */
public static final Error NativeMethCantHaveBody = new Error("compiler", "native.meth.cant.have.body");
compiler.err.new.not.allowed.in.annotation=\ ''new'' not allowed in an annotation
/** * compiler.err.new.not.allowed.in.annotation=\ * ''new'' not allowed in an annotation */
public static final Error NewNotAllowedInAnnotation = new Error("compiler", "new.not.allowed.in.annotation");
compiler.err.no.annotation.member=\ no annotation member {0} in {1}
/** * compiler.err.no.annotation.member=\ * no annotation member {0} in {1} */
public static Error NoAnnotationMember(Name arg0, Type arg1) { return new Error("compiler", "no.annotation.member", arg0, arg1); }
compiler.err.no.annotations.on.dot.class=\ no annotations are allowed in the type of a class literal
/** * compiler.err.no.annotations.on.dot.class=\ * no annotations are allowed in the type of a class literal */
public static final Error NoAnnotationsOnDotClass = new Error("compiler", "no.annotations.on.dot.class");
compiler.err.no.encl.instance.of.type.in.scope=\ no enclosing instance of type {0} is in scope
/** * compiler.err.no.encl.instance.of.type.in.scope=\ * no enclosing instance of type {0} is in scope */
public static Error NoEnclInstanceOfTypeInScope(Symbol arg0) { return new Error("compiler", "no.encl.instance.of.type.in.scope", arg0); }
compiler.err.no.intf.expected.here=\ no interface expected here
/** * compiler.err.no.intf.expected.here=\ * no interface expected here */
public static final Error NoIntfExpectedHere = new Error("compiler", "no.intf.expected.here");
compiler.err.no.match.entry=\ {0} has no match in entry in {1}; required {2}
/** * compiler.err.no.match.entry=\ * {0} has no match in entry in {1}; required {2} */
public static final Error NoMatchEntry = new Error("compiler", "no.match.entry");
compiler.err.no.opens.unless.strong=\ ''opens'' only allowed in strong modules
/** * compiler.err.no.opens.unless.strong=\ * ''opens'' only allowed in strong modules */
public static final Error NoOpensUnlessStrong = new Error("compiler", "no.opens.unless.strong");
compiler.err.no.output.dir=\ no class output directory specified
/** * compiler.err.no.output.dir=\ * no class output directory specified */
public static final Error NoOutputDir = new Error("compiler", "no.output.dir");
compiler.err.no.pkg.in.module-info.java=\ package declarations not allowed in file module-info.java
/** * compiler.err.no.pkg.in.module-info.java=\ * package declarations not allowed in file module-info.java */
public static final Error NoPkgInModuleInfoJava = new Error("compiler", "no.pkg.in.module-info.java");
compiler.err.no.source.files=\ no source files
/** * compiler.err.no.source.files=\ * no source files */
public static final Error NoSourceFiles = new Error("compiler", "no.source.files");
compiler.err.no.source.files.classes=\ no source files or class names
/** * compiler.err.no.source.files.classes=\ * no source files or class names */
public static final Error NoSourceFilesClasses = new Error("compiler", "no.source.files.classes");
compiler.err.no.superclass=\ {0} has no superclass.
/** * compiler.err.no.superclass=\ * {0} has no superclass. */
public static Error NoSuperclass(Type arg0) { return new Error("compiler", "no.superclass", arg0); }
compiler.err.no.switch.expression =\ yield outside of switch expression
/** * compiler.err.no.switch.expression =\ * yield outside of switch expression */
public static final Error NoSwitchExpression = new Error("compiler", "no.switch.expression");
compiler.err.no.switch.expression.qualify=\ yield outside of switch expression\n\ (to invoke a method called yield, qualify the yield with a receiver or type name)
/** * compiler.err.no.switch.expression.qualify=\ * yield outside of switch expression\n\ * (to invoke a method called yield, qualify the yield with a receiver or type name) */
public static final Error NoSwitchExpressionQualify = new Error("compiler", "no.switch.expression.qualify");
compiler.err.no.value.for.option=\ no value for {0} option
/** * compiler.err.no.value.for.option=\ * no value for {0} option */
public static Error NoValueForOption(String arg0) { return new Error("compiler", "no.value.for.option", arg0); }
compiler.err.no.zipfs.for.archive=\ No file system provider is available to handle this file: {0}
/** * compiler.err.no.zipfs.for.archive=\ * No file system provider is available to handle this file: {0} */
public static Error NoZipfsForArchive(Path arg0) { return new Error("compiler", "no.zipfs.for.archive", arg0); }
compiler.err.non-static.cant.be.ref=\ non-static {0} {1} cannot be referenced from a static context
/** * compiler.err.non-static.cant.be.ref=\ * non-static {0} {1} cannot be referenced from a static context */
public static Error NonStaticCantBeRef(Kind arg0, Symbol arg1) { return new Error("compiler", "non-static.cant.be.ref", arg0, arg1); }
compiler.err.non.sealed.or.sealed.expected=\ sealed or non-sealed modifiers expected
/** * compiler.err.non.sealed.or.sealed.expected=\ * sealed or non-sealed modifiers expected */
public static final Error NonSealedOrSealedExpected = new Error("compiler", "non.sealed.or.sealed.expected");
compiler.err.non.sealed.sealed.or.final.expected=\ sealed, non-sealed or final modifiers expected
/** * compiler.err.non.sealed.sealed.or.final.expected=\ * sealed, non-sealed or final modifiers expected */
public static final Error NonSealedSealedOrFinalExpected = new Error("compiler", "non.sealed.sealed.or.final.expected");
compiler.err.non.sealed.with.no.sealed.supertype=\ non-sealed modifier not allowed here\n\ (class {0} does not have any sealed supertypes)
/** * compiler.err.non.sealed.with.no.sealed.supertype=\ * non-sealed modifier not allowed here\n\ * (class {0} does not have any sealed supertypes) */
public static Error NonSealedWithNoSealedSupertype(Symbol arg0) { return new Error("compiler", "non.sealed.with.no.sealed.supertype", arg0); }
compiler.err.not.annotation.type=\ {0} is not an annotation type
/** * compiler.err.not.annotation.type=\ * {0} is not an annotation type */
public static Error NotAnnotationType(Type arg0) { return new Error("compiler", "not.annotation.type", arg0); }
compiler.err.not.def.access.class.intf.cant.access=\ {1}.{0} is defined in an inaccessible class or interface
/** * compiler.err.not.def.access.class.intf.cant.access=\ * {1}.{0} is defined in an inaccessible class or interface */
public static Error NotDefAccessClassIntfCantAccess(Symbol arg0, Symbol arg1) { return new Error("compiler", "not.def.access.class.intf.cant.access", arg0, arg1); }
compiler.err.not.def.access.class.intf.cant.access.reason=\ {1}.{0} in package {2} is not accessible\n\ ({3})
/** * compiler.err.not.def.access.class.intf.cant.access.reason=\ * {1}.{0} in package {2} is not accessible\n\ * ({3}) */
public static Error NotDefAccessClassIntfCantAccessReason(Symbol arg0, Symbol arg1, Symbol arg2, JCDiagnostic arg3) { return new Error("compiler", "not.def.access.class.intf.cant.access.reason", arg0, arg1, arg2, arg3); }
compiler.err.not.def.access.class.intf.cant.access.reason=\ {1}.{0} in package {2} is not accessible\n\ ({3})
/** * compiler.err.not.def.access.class.intf.cant.access.reason=\ * {1}.{0} in package {2} is not accessible\n\ * ({3}) */
public static Error NotDefAccessClassIntfCantAccessReason(Symbol arg0, Symbol arg1, Symbol arg2, Fragment arg3) { return new Error("compiler", "not.def.access.class.intf.cant.access.reason", arg0, arg1, arg2, arg3); }
compiler.err.not.def.access.package.cant.access=\ {0} is not visible\n\ ({2})
/** * compiler.err.not.def.access.package.cant.access=\ * {0} is not visible\n\ * ({2}) */
public static Error NotDefAccessPackageCantAccess(Symbol arg0, Symbol arg1, JCDiagnostic arg2) { return new Error("compiler", "not.def.access.package.cant.access", arg0, arg1, arg2); }
compiler.err.not.def.access.package.cant.access=\ {0} is not visible\n\ ({2})
/** * compiler.err.not.def.access.package.cant.access=\ * {0} is not visible\n\ * ({2}) */
public static Error NotDefAccessPackageCantAccess(Symbol arg0, Symbol arg1, Fragment arg2) { return new Error("compiler", "not.def.access.package.cant.access", arg0, arg1, arg2); }
compiler.err.not.def.public=\ {0} is not public in {1}
/** * compiler.err.not.def.public=\ * {0} is not public in {1} */
public static Error NotDefPublic(Symbol arg0, Symbol arg1) { return new Error("compiler", "not.def.public", arg0, arg1); }
compiler.err.not.def.public.cant.access=\ {0} is not public in {1}; cannot be accessed from outside package
/** * compiler.err.not.def.public.cant.access=\ * {0} is not public in {1}; cannot be accessed from outside package */
public static Error NotDefPublicCantAccess(Symbol arg0, Symbol arg1) { return new Error("compiler", "not.def.public.cant.access", arg0, arg1); }
compiler.err.not.encl.class=\ not an enclosing class: {0}
/** * compiler.err.not.encl.class=\ * not an enclosing class: {0} */
public static Error NotEnclClass(Symbol arg0) { return new Error("compiler", "not.encl.class", arg0); }
compiler.err.not.exhaustive=\ the switch expression does not cover all possible input values
/** * compiler.err.not.exhaustive=\ * the switch expression does not cover all possible input values */
public static final Error NotExhaustive = new Error("compiler", "not.exhaustive");
compiler.err.not.in.module.on.module.source.path=\ not in a module on the module source path
/** * compiler.err.not.in.module.on.module.source.path=\ * not in a module on the module source path */
public static final Error NotInModuleOnModuleSourcePath = new Error("compiler", "not.in.module.on.module.source.path");
compiler.err.not.in.profile=\ {0} is not available in profile ''{1}''
/** * compiler.err.not.in.profile=\ * {0} is not available in profile ''{1}'' */
public static Error NotInProfile(Symbol arg0, Object arg1) { return new Error("compiler", "not.in.profile", arg0, arg1); }
compiler.err.not.loop.label=\ not a loop label: {0}
/** * compiler.err.not.loop.label=\ * not a loop label: {0} */
public static Error NotLoopLabel(Name arg0) { return new Error("compiler", "not.loop.label", arg0); }
compiler.err.not.stmt=\ not a statement
/** * compiler.err.not.stmt=\ * not a statement */
public static final Error NotStmt = new Error("compiler", "not.stmt");
compiler.err.not.within.bounds=\ type argument {0} is not within bounds of type-variable {1}
/** * compiler.err.not.within.bounds=\ * type argument {0} is not within bounds of type-variable {1} */
public static Error NotWithinBounds(Type arg0, Type arg1) { return new Error("compiler", "not.within.bounds", arg0, arg1); }
compiler.err.not.within.bounds=\ type argument {0} is not within bounds of type-variable {1}
/** * compiler.err.not.within.bounds=\ * type argument {0} is not within bounds of type-variable {1} */
public static Error NotWithinBounds(Type arg0, Symbol arg1) { return new Error("compiler", "not.within.bounds", arg0, arg1); }
compiler.err.operator.cant.be.applied=\ bad operand type {1} for unary operator ''{0}''
/** * compiler.err.operator.cant.be.applied=\ * bad operand type {1} for unary operator ''{0}'' */
public static Error OperatorCantBeApplied(Name arg0, Type arg1) { return new Error("compiler", "operator.cant.be.applied", arg0, arg1); }
compiler.err.operator.cant.be.applied.1=\ bad operand types for binary operator ''{0}''\n\ first type: {1}\n\ second type: {2}
/** * compiler.err.operator.cant.be.applied.1=\ * bad operand types for binary operator ''{0}''\n\ * first type: {1}\n\ * second type: {2} */
public static Error OperatorCantBeApplied1(Name arg0, Type arg1, Type arg2) { return new Error("compiler", "operator.cant.be.applied.1", arg0, arg1, arg2); }
compiler.err.option.not.allowed.with.target=\ option {0} not allowed with target {1}
/** * compiler.err.option.not.allowed.with.target=\ * option {0} not allowed with target {1} */
public static Error OptionNotAllowedWithTarget(Option arg0, Target arg1) { return new Error("compiler", "option.not.allowed.with.target", arg0, arg1); }
compiler.err.option.removed.source=\ Source option {0} is no longer supported. Use {1} or later.
/** * compiler.err.option.removed.source=\ * Source option {0} is no longer supported. Use {1} or later. */
public static Error OptionRemovedSource(String arg0, String arg1) { return new Error("compiler", "option.removed.source", arg0, arg1); }
compiler.err.option.removed.target=\ Target option {0} is no longer supported. Use {1} or later.
/** * compiler.err.option.removed.target=\ * Target option {0} is no longer supported. Use {1} or later. */
public static Error OptionRemovedTarget(Target arg0, Target arg1) { return new Error("compiler", "option.removed.target", arg0, arg1); }
compiler.err.option.too.many=\ option {0} can only be specified once
/** * compiler.err.option.too.many=\ * option {0} can only be specified once */
public static Error OptionTooMany(String arg0) { return new Error("compiler", "option.too.many", arg0); }
compiler.err.orphaned=\ orphaned {0}
/** * compiler.err.orphaned=\ * orphaned {0} */
public static Error Orphaned(TokenKind arg0) { return new Error("compiler", "orphaned", arg0); }
compiler.err.output.dir.must.be.specified.with.dash.m.option=\ class output directory must be specified if -m option is used
/** * compiler.err.output.dir.must.be.specified.with.dash.m.option=\ * class output directory must be specified if -m option is used */
public static final Error OutputDirMustBeSpecifiedWithDashMOption = new Error("compiler", "output.dir.must.be.specified.with.dash.m.option");
compiler.err.override.incompatible.ret=\ {0}\n\ return type {1} is not compatible with {2}
/** * compiler.err.override.incompatible.ret=\ * {0}\n\ * return type {1} is not compatible with {2} */
public static Error OverrideIncompatibleRet(JCDiagnostic arg0, Type arg1, Type arg2) { return new Error("compiler", "override.incompatible.ret", arg0, arg1, arg2); }
compiler.err.override.incompatible.ret=\ {0}\n\ return type {1} is not compatible with {2}
/** * compiler.err.override.incompatible.ret=\ * {0}\n\ * return type {1} is not compatible with {2} */
public static Error OverrideIncompatibleRet(Fragment arg0, Type arg1, Type arg2) { return new Error("compiler", "override.incompatible.ret", arg0, arg1, arg2); }
compiler.err.override.meth=\ {0}\n\ overridden method is {1}
/** * compiler.err.override.meth=\ * {0}\n\ * overridden method is {1} */
public static Error OverrideMeth(JCDiagnostic arg0, Set<? extends Flag> arg1) { return new Error("compiler", "override.meth", arg0, arg1); }
compiler.err.override.meth=\ {0}\n\ overridden method is {1}
/** * compiler.err.override.meth=\ * {0}\n\ * overridden method is {1} */
public static Error OverrideMeth(Fragment arg0, Set<? extends Flag> arg1) { return new Error("compiler", "override.meth", arg0, arg1); }
compiler.err.override.meth.doesnt.throw=\ {0}\n\ overridden method does not throw {1}
/** * compiler.err.override.meth.doesnt.throw=\ * {0}\n\ * overridden method does not throw {1} */
public static Error OverrideMethDoesntThrow(JCDiagnostic arg0, Type arg1) { return new Error("compiler", "override.meth.doesnt.throw", arg0, arg1); }
compiler.err.override.meth.doesnt.throw=\ {0}\n\ overridden method does not throw {1}
/** * compiler.err.override.meth.doesnt.throw=\ * {0}\n\ * overridden method does not throw {1} */
public static Error OverrideMethDoesntThrow(Fragment arg0, Type arg1) { return new Error("compiler", "override.meth.doesnt.throw", arg0, arg1); }
compiler.err.override.static=\ {0}\n\ overriding method is static
/** * compiler.err.override.static=\ * {0}\n\ * overriding method is static */
public static Error OverrideStatic(JCDiagnostic arg0) { return new Error("compiler", "override.static", arg0); }
compiler.err.override.static=\ {0}\n\ overriding method is static
/** * compiler.err.override.static=\ * {0}\n\ * overriding method is static */
public static Error OverrideStatic(Fragment arg0) { return new Error("compiler", "override.static", arg0); }
compiler.err.override.weaker.access=\ {0}\n\ attempting to assign weaker access privileges; was {1}
/** * compiler.err.override.weaker.access=\ * {0}\n\ * attempting to assign weaker access privileges; was {1} */
public static Error OverrideWeakerAccess(JCDiagnostic arg0, Set<? extends Flag> arg1) { return new Error("compiler", "override.weaker.access", arg0, arg1); }
compiler.err.override.weaker.access=\ {0}\n\ attempting to assign weaker access privileges; was {1}
/** * compiler.err.override.weaker.access=\ * {0}\n\ * attempting to assign weaker access privileges; was {1} */
public static Error OverrideWeakerAccess(JCDiagnostic arg0, String arg1) { return new Error("compiler", "override.weaker.access", arg0, arg1); }
compiler.err.override.weaker.access=\ {0}\n\ attempting to assign weaker access privileges; was {1}
/** * compiler.err.override.weaker.access=\ * {0}\n\ * attempting to assign weaker access privileges; was {1} */
public static Error OverrideWeakerAccess(Fragment arg0, Set<? extends Flag> arg1) { return new Error("compiler", "override.weaker.access", arg0, arg1); }
compiler.err.override.weaker.access=\ {0}\n\ attempting to assign weaker access privileges; was {1}
/** * compiler.err.override.weaker.access=\ * {0}\n\ * attempting to assign weaker access privileges; was {1} */
public static Error OverrideWeakerAccess(Fragment arg0, String arg1) { return new Error("compiler", "override.weaker.access", arg0, arg1); }
compiler.err.package.clash.from.requires=\ module {0} reads package {1} from both {2} and {3}
/** * compiler.err.package.clash.from.requires=\ * module {0} reads package {1} from both {2} and {3} */
public static Error PackageClashFromRequires(Symbol arg0, Name arg1, Symbol arg2, Symbol arg3) { return new Error("compiler", "package.clash.from.requires", arg0, arg1, arg2, arg3); }
compiler.err.package.clash.from.requires.in.unnamed=\ the unnamed module reads package {0} from both {1} and {2}
/** * compiler.err.package.clash.from.requires.in.unnamed=\ * the unnamed module reads package {0} from both {1} and {2} */
public static Error PackageClashFromRequiresInUnnamed(Name arg0, Symbol arg1, Symbol arg2) { return new Error("compiler", "package.clash.from.requires.in.unnamed", arg0, arg1, arg2); }
compiler.err.package.empty.or.not.found=\ package is empty or does not exist: {0}
/** * compiler.err.package.empty.or.not.found=\ * package is empty or does not exist: {0} */
public static Error PackageEmptyOrNotFound(Symbol arg0) { return new Error("compiler", "package.empty.or.not.found", arg0); }
compiler.err.package.in.other.module=\ package exists in another module: {0}
/** * compiler.err.package.in.other.module=\ * package exists in another module: {0} */
public static Error PackageInOtherModule(Symbol arg0) { return new Error("compiler", "package.in.other.module", arg0); }
compiler.err.package.not.visible=\ package {0} is not visible\n\ ({1})
/** * compiler.err.package.not.visible=\ * package {0} is not visible\n\ * ({1}) */
public static Error PackageNotVisible(Symbol arg0, JCDiagnostic arg1) { return new Error("compiler", "package.not.visible", arg0, arg1); }
compiler.err.package.not.visible=\ package {0} is not visible\n\ ({1})
/** * compiler.err.package.not.visible=\ * package {0} is not visible\n\ * ({1}) */
public static Error PackageNotVisible(Symbol arg0, Fragment arg1) { return new Error("compiler", "package.not.visible", arg0, arg1); }
compiler.err.pkg.annotations.sb.in.package-info.java=\ package annotations should be in file package-info.java
/** * compiler.err.pkg.annotations.sb.in.package-info.java=\ * package annotations should be in file package-info.java */
public static final Error PkgAnnotationsSbInPackageInfoJava = new Error("compiler", "pkg.annotations.sb.in.package-info.java");
compiler.err.pkg.clashes.with.class.of.same.name=\ package {0} clashes with class of same name
/** * compiler.err.pkg.clashes.with.class.of.same.name=\ * package {0} clashes with class of same name */
public static Error PkgClashesWithClassOfSameName(Symbol arg0) { return new Error("compiler", "pkg.clashes.with.class.of.same.name", arg0); }
compiler.err.plugin.not.found=\ plug-in not found: {0}
/** * compiler.err.plugin.not.found=\ * plug-in not found: {0} */
public static Error PluginNotFound(String arg0) { return new Error("compiler", "plugin.not.found", arg0); }
compiler.err.premature.eof=\ reached end of file while parsing
/** * compiler.err.premature.eof=\ * reached end of file while parsing */
public static final Error PrematureEof = new Error("compiler", "premature.eof");
compiler.err.preview.feature.disabled=\ {0} is a preview feature and is disabled by default.\n\ (use --enable-preview to enable {0})
/** * compiler.err.preview.feature.disabled=\ * {0} is a preview feature and is disabled by default.\n\ * (use --enable-preview to enable {0}) */
public static Error PreviewFeatureDisabled(JCDiagnostic arg0) { return new Error("compiler", "preview.feature.disabled", arg0); }
compiler.err.preview.feature.disabled=\ {0} is a preview feature and is disabled by default.\n\ (use --enable-preview to enable {0})
/** * compiler.err.preview.feature.disabled=\ * {0} is a preview feature and is disabled by default.\n\ * (use --enable-preview to enable {0}) */
public static Error PreviewFeatureDisabled(Fragment arg0) { return new Error("compiler", "preview.feature.disabled", arg0); }
compiler.err.preview.feature.disabled.classfile=\ classfile for {0} uses preview features of Java SE {1}.\n\ (use --enable-preview to allow loading of classfiles which contain preview features)
/** * compiler.err.preview.feature.disabled.classfile=\ * classfile for {0} uses preview features of Java SE {1}.\n\ * (use --enable-preview to allow loading of classfiles which contain preview features) */
public static Error PreviewFeatureDisabledClassfile(JavaFileObject arg0, String arg1) { return new Error("compiler", "preview.feature.disabled.classfile", arg0, arg1); }
compiler.err.preview.feature.disabled.plural=\ {0} are a preview feature and are disabled by default.\n\ (use --enable-preview to enable {0})
/** * compiler.err.preview.feature.disabled.plural=\ * {0} are a preview feature and are disabled by default.\n\ * (use --enable-preview to enable {0}) */
public static Error PreviewFeatureDisabledPlural(JCDiagnostic arg0) { return new Error("compiler", "preview.feature.disabled.plural", arg0); }
compiler.err.preview.feature.disabled.plural=\ {0} are a preview feature and are disabled by default.\n\ (use --enable-preview to enable {0})
/** * compiler.err.preview.feature.disabled.plural=\ * {0} are a preview feature and are disabled by default.\n\ * (use --enable-preview to enable {0}) */
public static Error PreviewFeatureDisabledPlural(Fragment arg0) { return new Error("compiler", "preview.feature.disabled.plural", arg0); }
compiler.err.preview.not.latest=\ invalid source release {0} with --enable-preview\n\ (preview language features are only supported for release {1})
/** * compiler.err.preview.not.latest=\ * invalid source release {0} with --enable-preview\n\ * (preview language features are only supported for release {1}) */
public static Error PreviewNotLatest(String arg0, Source arg1) { return new Error("compiler", "preview.not.latest", arg0, arg1); }
compiler.err.preview.without.source.or.release=\ --enable-preview must be used with either -source or --release
/** * compiler.err.preview.without.source.or.release=\ * --enable-preview must be used with either -source or --release */
public static final Error PreviewWithoutSourceOrRelease = new Error("compiler", "preview.without.source.or.release");
compiler.err.prob.found.req=\ incompatible types: {0}
/** * compiler.err.prob.found.req=\ * incompatible types: {0} */
public static Error ProbFoundReq(JCDiagnostic arg0) { return new Error("compiler", "prob.found.req", arg0); }
compiler.err.prob.found.req=\ incompatible types: {0}
/** * compiler.err.prob.found.req=\ * incompatible types: {0} */
public static Error ProbFoundReq(Fragment arg0) { return new Error("compiler", "prob.found.req", arg0); }
compiler.err.proc.bad.config.file=\ Bad service configuration file, or exception thrown while constructing Processor object: {0}
/** * compiler.err.proc.bad.config.file=\ * Bad service configuration file, or exception thrown while constructing Processor object: {0} */
public static Error ProcBadConfigFile(String arg0) { return new Error("compiler", "proc.bad.config.file", arg0); }
compiler.err.proc.cant.access=\ cannot access {0}\n\ {1}\n\ Consult the following stack trace for details.\n\ {2}
/** * compiler.err.proc.cant.access=\ * cannot access {0}\n\ * {1}\n\ * Consult the following stack trace for details.\n\ * {2} */
public static Error ProcCantAccess(Symbol arg0, JCDiagnostic arg1, String arg2) { return new Error("compiler", "proc.cant.access", arg0, arg1, arg2); }
compiler.err.proc.cant.access=\ cannot access {0}\n\ {1}\n\ Consult the following stack trace for details.\n\ {2}
/** * compiler.err.proc.cant.access=\ * cannot access {0}\n\ * {1}\n\ * Consult the following stack trace for details.\n\ * {2} */
public static Error ProcCantAccess(Symbol arg0, Fragment arg1, String arg2) { return new Error("compiler", "proc.cant.access", arg0, arg1, arg2); }
compiler.err.proc.cant.access.1=\ cannot access {0}\n\ {1}
/** * compiler.err.proc.cant.access.1=\ * cannot access {0}\n\ * {1} */
public static Error ProcCantAccess1(Symbol arg0, JCDiagnostic arg1) { return new Error("compiler", "proc.cant.access.1", arg0, arg1); }
compiler.err.proc.cant.access.1=\ cannot access {0}\n\ {1}
/** * compiler.err.proc.cant.access.1=\ * cannot access {0}\n\ * {1} */
public static Error ProcCantAccess1(Symbol arg0, Fragment arg1) { return new Error("compiler", "proc.cant.access.1", arg0, arg1); }
compiler.err.proc.cant.create.loader=\ Could not create class loader for annotation processors: {0}
/** * compiler.err.proc.cant.create.loader=\ * Could not create class loader for annotation processors: {0} */
public static final Error ProcCantCreateLoader = new Error("compiler", "proc.cant.create.loader");
compiler.err.proc.cant.find.class=\ Could not find class file for ''{0}''.
/** * compiler.err.proc.cant.find.class=\ * Could not find class file for ''{0}''. */
public static Error ProcCantFindClass(String arg0) { return new Error("compiler", "proc.cant.find.class", arg0); }
compiler.err.proc.cant.load.class=\ Could not load processor class file due to ''{0}''.
/** * compiler.err.proc.cant.load.class=\ * Could not load processor class file due to ''{0}''. */
public static Error ProcCantLoadClass(String arg0) { return new Error("compiler", "proc.cant.load.class", arg0); }
compiler.err.proc.messager=\ {0}
/** * compiler.err.proc.messager=\ * {0} */
public static Error ProcMessager(String arg0) { return new Error("compiler", "proc.messager", arg0); }
compiler.err.proc.no.explicit.annotation.processing.requested=\ Class names, ''{0}'', are only accepted if annotation processing is explicitly requested
/** * compiler.err.proc.no.explicit.annotation.processing.requested=\ * Class names, ''{0}'', are only accepted if annotation processing is explicitly requested */
public static Error ProcNoExplicitAnnotationProcessingRequested(Collection<? extends String> arg0) { return new Error("compiler", "proc.no.explicit.annotation.processing.requested", arg0); }
compiler.err.proc.no.service=\ A ServiceLoader was not usable and is required for annotation processing.
/** * compiler.err.proc.no.service=\ * A ServiceLoader was not usable and is required for annotation processing. */
public static final Error ProcNoService = new Error("compiler", "proc.no.service");
compiler.err.proc.processor.bad.option.name=\ Bad option name ''{0}'' provided by processor ''{1}''
/** * compiler.err.proc.processor.bad.option.name=\ * Bad option name ''{0}'' provided by processor ''{1}'' */
public static Error ProcProcessorBadOptionName(String arg0, String arg1) { return new Error("compiler", "proc.processor.bad.option.name", arg0, arg1); }
compiler.err.proc.processor.cant.instantiate=\ Could not instantiate an instance of processor ''{0}''
/** * compiler.err.proc.processor.cant.instantiate=\ * Could not instantiate an instance of processor ''{0}'' */
public static Error ProcProcessorCantInstantiate(String arg0) { return new Error("compiler", "proc.processor.cant.instantiate", arg0); }
compiler.err.proc.processor.not.found=\ Annotation processor ''{0}'' not found
/** * compiler.err.proc.processor.not.found=\ * Annotation processor ''{0}'' not found */
public static Error ProcProcessorNotFound(String arg0) { return new Error("compiler", "proc.processor.not.found", arg0); }
compiler.err.proc.processor.wrong.type=\ Annotation processor ''{0}'' does not implement javax.annotation.processing.Processor
/** * compiler.err.proc.processor.wrong.type=\ * Annotation processor ''{0}'' does not implement javax.annotation.processing.Processor */
public static Error ProcProcessorWrongType(String arg0) { return new Error("compiler", "proc.processor.wrong.type", arg0); }
compiler.err.proc.service.problem=\ Error creating a service loader to load Processors.
/** * compiler.err.proc.service.problem=\ * Error creating a service loader to load Processors. */
public static final Error ProcServiceProblem = new Error("compiler", "proc.service.problem");
compiler.err.processorpath.no.processormodulepath=\ illegal combination of -processorpath and --processor-module-path
/** * compiler.err.processorpath.no.processormodulepath=\ * illegal combination of -processorpath and --processor-module-path */
public static final Error ProcessorpathNoProcessormodulepath = new Error("compiler", "processorpath.no.processormodulepath");
compiler.err.profile.bootclasspath.conflict=\ profile and bootclasspath options cannot be used together
/** * compiler.err.profile.bootclasspath.conflict=\ * profile and bootclasspath options cannot be used together */
public static final Error ProfileBootclasspathConflict = new Error("compiler", "profile.bootclasspath.conflict");
compiler.err.qualified.new.of.static.class=\ qualified new of static class
/** * compiler.err.qualified.new.of.static.class=\ * qualified new of static class */
public static Error QualifiedNewOfStaticClass(Symbol arg0) { return new Error("compiler", "qualified.new.of.static.class", arg0); }
compiler.err.receiver.parameter.not.applicable.constructor.toplevel.class=\ receiver parameter not applicable for constructor of top-level class
/** * compiler.err.receiver.parameter.not.applicable.constructor.toplevel.class=\ * receiver parameter not applicable for constructor of top-level class */
public static final Error ReceiverParameterNotApplicableConstructorToplevelClass = new Error("compiler", "receiver.parameter.not.applicable.constructor.toplevel.class");
compiler.err.record.cannot.declare.instance.fields=\ field declaration must be static\n\ (consider replacing field with record component)
/** * compiler.err.record.cannot.declare.instance.fields=\ * field declaration must be static\n\ * (consider replacing field with record component) */
public static final Error RecordCannotDeclareInstanceFields = new Error("compiler", "record.cannot.declare.instance.fields");
compiler.err.record.cant.declare.field.modifiers=\ record components cannot have modifiers
/** * compiler.err.record.cant.declare.field.modifiers=\ * record components cannot have modifiers */
public static final Error RecordCantDeclareFieldModifiers = new Error("compiler", "record.cant.declare.field.modifiers");
compiler.err.record.component.and.old.array.syntax=\ legacy array notation not allowed on record components
/** * compiler.err.record.component.and.old.array.syntax=\ * legacy array notation not allowed on record components */
public static final Error RecordComponentAndOldArraySyntax = new Error("compiler", "record.component.and.old.array.syntax");
compiler.err.record.header.expected=\ record header expected
/** * compiler.err.record.header.expected=\ * record header expected */
public static final Error RecordHeaderExpected = new Error("compiler", "record.header.expected");
compiler.err.recursive.ctor.invocation=\ recursive constructor invocation
/** * compiler.err.recursive.ctor.invocation=\ * recursive constructor invocation */
public static final Error RecursiveCtorInvocation = new Error("compiler", "recursive.ctor.invocation");
compiler.err.ref.ambiguous=\ reference to {0} is ambiguous\n\ both {1} {2} in {3} and {4} {5} in {6} match
/** * compiler.err.ref.ambiguous=\ * reference to {0} is ambiguous\n\ * both {1} {2} in {3} and {4} {5} in {6} match */
public static Error RefAmbiguous(Name arg0, Kind arg1, Symbol arg2, Symbol arg3, Kind arg4, Symbol arg5, Symbol arg6) { return new Error("compiler", "ref.ambiguous", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.err.release.bootclasspath.conflict=\ option {0} cannot be used together with --release
/** * compiler.err.release.bootclasspath.conflict=\ * option {0} cannot be used together with --release */
public static Error ReleaseBootclasspathConflict(Option arg0) { return new Error("compiler", "release.bootclasspath.conflict", arg0); }
compiler.err.repeated.annotation.target=\ repeated annotation target
/** * compiler.err.repeated.annotation.target=\ * repeated annotation target */
public static final Error RepeatedAnnotationTarget = new Error("compiler", "repeated.annotation.target");
compiler.err.repeated.interface=\ repeated interface
/** * compiler.err.repeated.interface=\ * repeated interface */
public static final Error RepeatedInterface = new Error("compiler", "repeated.interface");
compiler.err.repeated.modifier=\ repeated modifier
/** * compiler.err.repeated.modifier=\ * repeated modifier */
public static final Error RepeatedModifier = new Error("compiler", "repeated.modifier");
compiler.err.repeated.provides.for.service=\ multiple ''provides'' for service {0}
/** * compiler.err.repeated.provides.for.service=\ * multiple ''provides'' for service {0} */
public static Error RepeatedProvidesForService(Symbol arg0) { return new Error("compiler", "repeated.provides.for.service", arg0); }
compiler.err.repeated.value.for.module.source.path=\ --module-source-path specified more than once for module {0}
/** * compiler.err.repeated.value.for.module.source.path=\ * --module-source-path specified more than once for module {0} */
public static Error RepeatedValueForModuleSourcePath(String arg0) { return new Error("compiler", "repeated.value.for.module.source.path", arg0); }
compiler.err.repeated.value.for.patch.module=\ --patch-module specified more than once for module {0}
/** * compiler.err.repeated.value.for.patch.module=\ * --patch-module specified more than once for module {0} */
public static Error RepeatedValueForPatchModule(String arg0) { return new Error("compiler", "repeated.value.for.patch.module", arg0); }
compiler.err.report.access=\ {0} has {1} access in {2}
/** * compiler.err.report.access=\ * {0} has {1} access in {2} */
public static Error ReportAccess(Symbol arg0, Set<? extends Modifier> arg1, Symbol arg2) { return new Error("compiler", "report.access", arg0, arg1, arg2); }
compiler.err.req.arg=\ {0} requires an argument
/** * compiler.err.req.arg=\ * {0} requires an argument */
public static Error ReqArg(String arg0) { return new Error("compiler", "req.arg", arg0); }
compiler.err.restricted.type.not.allowed=\ ''{0}'' not allowed here\n\ as of release {1}, ''{0}'' is a restricted type name and cannot be used for type declarations
/** * compiler.err.restricted.type.not.allowed=\ * ''{0}'' not allowed here\n\ * as of release {1}, ''{0}'' is a restricted type name and cannot be used for type declarations */
public static Error RestrictedTypeNotAllowed(Name arg0, Source arg1) { return new Error("compiler", "restricted.type.not.allowed", arg0, arg1); }
compiler.err.restricted.type.not.allowed.array=\ ''{0}'' is not allowed as an element type of an array
/** * compiler.err.restricted.type.not.allowed.array=\ * ''{0}'' is not allowed as an element type of an array */
public static Error RestrictedTypeNotAllowedArray(Name arg0) { return new Error("compiler", "restricted.type.not.allowed.array", arg0); }
compiler.err.restricted.type.not.allowed.compound=\ ''{0}'' is not allowed in a compound declaration
/** * compiler.err.restricted.type.not.allowed.compound=\ * ''{0}'' is not allowed in a compound declaration */
public static Error RestrictedTypeNotAllowedCompound(Name arg0) { return new Error("compiler", "restricted.type.not.allowed.compound", arg0); }
compiler.err.restricted.type.not.allowed.here=\ ''{0}'' is not allowed here
/** * compiler.err.restricted.type.not.allowed.here=\ * ''{0}'' is not allowed here */
public static Error RestrictedTypeNotAllowedHere(Name arg0) { return new Error("compiler", "restricted.type.not.allowed.here", arg0); }
compiler.err.ret.outside.meth=\ return outside method
/** * compiler.err.ret.outside.meth=\ * return outside method */
public static final Error RetOutsideMeth = new Error("compiler", "ret.outside.meth");
compiler.err.return.outside.switch.expression=\ attempt to return out of a switch expression
/** * compiler.err.return.outside.switch.expression=\ * attempt to return out of a switch expression */
public static final Error ReturnOutsideSwitchExpression = new Error("compiler", "return.outside.switch.expression");
compiler.err.rule.completes.normally=\ switch rule completes without providing a value\n\ (switch rules in switch expressions must either provide a value or throw)
/** * compiler.err.rule.completes.normally=\ * switch rule completes without providing a value\n\ * (switch rules in switch expressions must either provide a value or throw) */
public static final Error RuleCompletesNormally = new Error("compiler", "rule.completes.normally");
compiler.err.same.binary.name=\ classes: {0} and {1} have the same binary name
/** * compiler.err.same.binary.name=\ * classes: {0} and {1} have the same binary name */
public static Error SameBinaryName(Name arg0, Name arg1) { return new Error("compiler", "same.binary.name", arg0, arg1); }
compiler.err.sealed.class.must.have.subclasses=\ sealed class must have subclasses
/** * compiler.err.sealed.class.must.have.subclasses=\ * sealed class must have subclasses */
public static final Error SealedClassMustHaveSubclasses = new Error("compiler", "sealed.class.must.have.subclasses");
compiler.err.sealed.or.non.sealed.local.classes.not.allowed=\ sealed or non-sealed local classes are not allowed
/** * compiler.err.sealed.or.non.sealed.local.classes.not.allowed=\ * sealed or non-sealed local classes are not allowed */
public static final Error SealedOrNonSealedLocalClassesNotAllowed = new Error("compiler", "sealed.or.non.sealed.local.classes.not.allowed");
compiler.err.service.definition.is.enum=\ the service definition is an enum: {0}
/** * compiler.err.service.definition.is.enum=\ * the service definition is an enum: {0} */
public static Error ServiceDefinitionIsEnum(Symbol arg0) { return new Error("compiler", "service.definition.is.enum", arg0); }
compiler.err.service.implementation.doesnt.have.a.no.args.constructor=\ the service implementation does not have a default constructor: {0}
/** * compiler.err.service.implementation.doesnt.have.a.no.args.constructor=\ * the service implementation does not have a default constructor: {0} */
public static Error ServiceImplementationDoesntHaveANoArgsConstructor(Symbol arg0) { return new Error("compiler", "service.implementation.doesnt.have.a.no.args.constructor", arg0); }
compiler.err.service.implementation.is.abstract=\ the service implementation is an abstract class: {0}
/** * compiler.err.service.implementation.is.abstract=\ * the service implementation is an abstract class: {0} */
public static Error ServiceImplementationIsAbstract(Symbol arg0) { return new Error("compiler", "service.implementation.is.abstract", arg0); }
compiler.err.service.implementation.is.inner=\ the service implementation is an inner class: {0}
/** * compiler.err.service.implementation.is.inner=\ * the service implementation is an inner class: {0} */
public static Error ServiceImplementationIsInner(Symbol arg0) { return new Error("compiler", "service.implementation.is.inner", arg0); }
compiler.err.service.implementation.must.be.subtype.of.service.interface=\ the service implementation type must be a subtype of the service interface type, or \ have a public static no-args method named "provider" returning the service implementation
/** * compiler.err.service.implementation.must.be.subtype.of.service.interface=\ * the service implementation type must be a subtype of the service interface type, or \ * have a public static no-args method named "provider" returning the service implementation */
public static final Error ServiceImplementationMustBeSubtypeOfServiceInterface = new Error("compiler", "service.implementation.must.be.subtype.of.service.interface");
compiler.err.service.implementation.no.args.constructor.not.public=\ the no arguments constructor of the service implementation is not public: {0}
/** * compiler.err.service.implementation.no.args.constructor.not.public=\ * the no arguments constructor of the service implementation is not public: {0} */
public static Error ServiceImplementationNoArgsConstructorNotPublic(Symbol arg0) { return new Error("compiler", "service.implementation.no.args.constructor.not.public", arg0); }
compiler.err.service.implementation.not.in.right.module=\ service implementation must be defined in the same module as the provides directive
/** * compiler.err.service.implementation.not.in.right.module=\ * service implementation must be defined in the same module as the provides directive */
public static Error ServiceImplementationNotInRightModule(Symbol arg0) { return new Error("compiler", "service.implementation.not.in.right.module", arg0); }
compiler.err.service.implementation.provider.return.must.be.subtype.of.service.interface=\ the "provider" method return type must be a subtype of the service interface type
/** * compiler.err.service.implementation.provider.return.must.be.subtype.of.service.interface=\ * the "provider" method return type must be a subtype of the service interface type */
public static final Error ServiceImplementationProviderReturnMustBeSubtypeOfServiceInterface = new Error("compiler", "service.implementation.provider.return.must.be.subtype.of.service.interface");
compiler.err.signature.doesnt.match.intf=\ signature does not match {0}; incompatible interfaces
/** * compiler.err.signature.doesnt.match.intf=\ * signature does not match {0}; incompatible interfaces */
public static final Error SignatureDoesntMatchIntf = new Error("compiler", "signature.doesnt.match.intf");
compiler.err.signature.doesnt.match.supertype=\ signature does not match {0}; incompatible supertype
/** * compiler.err.signature.doesnt.match.supertype=\ * signature does not match {0}; incompatible supertype */
public static final Error SignatureDoesntMatchSupertype = new Error("compiler", "signature.doesnt.match.supertype");
compiler.err.source.cant.overwrite.input.file=\ error writing source; cannot overwrite input file {0}
/** * compiler.err.source.cant.overwrite.input.file=\ * error writing source; cannot overwrite input file {0} */
public static Error SourceCantOverwriteInputFile(JavaFileObject arg0) { return new Error("compiler", "source.cant.overwrite.input.file", arg0); }
compiler.err.sourcepath.modulesourcepath.conflict=\ cannot specify both --source-path and --module-source-path
/** * compiler.err.sourcepath.modulesourcepath.conflict=\ * cannot specify both --source-path and --module-source-path */
public static final Error SourcepathModulesourcepathConflict = new Error("compiler", "sourcepath.modulesourcepath.conflict");
compiler.err.stack.sim.error=\ Internal error: stack sim error on {0}
/** * compiler.err.stack.sim.error=\ * Internal error: stack sim error on {0} */
public static Error StackSimError(Symbol arg0) { return new Error("compiler", "stack.sim.error", arg0); }
compiler.err.static.declaration.not.allowed.in.inner.classes=\ static declarations not allowed in inner classes
/** * compiler.err.static.declaration.not.allowed.in.inner.classes=\ * static declarations not allowed in inner classes */
public static final Error StaticDeclarationNotAllowedInInnerClasses = new Error("compiler", "static.declaration.not.allowed.in.inner.classes");
compiler.err.static.imp.only.classes.and.interfaces=\ static import only from classes and interfaces
/** * compiler.err.static.imp.only.classes.and.interfaces=\ * static import only from classes and interfaces */
public static final Error StaticImpOnlyClassesAndInterfaces = new Error("compiler", "static.imp.only.classes.and.interfaces");
compiler.err.static.methods.cannot.be.annotated.with.override=\ static methods cannot be annotated with @Override
/** * compiler.err.static.methods.cannot.be.annotated.with.override=\ * static methods cannot be annotated with @Override */
public static final Error StaticMethodsCannotBeAnnotatedWithOverride = new Error("compiler", "static.methods.cannot.be.annotated.with.override");
compiler.err.string.const.req=\ constant string expression required
/** * compiler.err.string.const.req=\ * constant string expression required */
public static final Error StringConstReq = new Error("compiler", "string.const.req");
compiler.err.switch.case.unexpected.statement=\ unexpected statement in case, expected is an expression, a block or a throw statement
/** * compiler.err.switch.case.unexpected.statement=\ * unexpected statement in case, expected is an expression, a block or a throw statement */
public static final Error SwitchCaseUnexpectedStatement = new Error("compiler", "switch.case.unexpected.statement");
compiler.err.switch.expression.completes.normally=\ switch expression completes without providing a value\n\ (switch expressions must either provide a value or throw for all possible input values)
/** * compiler.err.switch.expression.completes.normally=\ * switch expression completes without providing a value\n\ * (switch expressions must either provide a value or throw for all possible input values) */
public static final Error SwitchExpressionCompletesNormally = new Error("compiler", "switch.expression.completes.normally");
compiler.err.switch.expression.empty=\ switch expression does not have any case clauses
/** * compiler.err.switch.expression.empty=\ * switch expression does not have any case clauses */
public static final Error SwitchExpressionEmpty = new Error("compiler", "switch.expression.empty");
compiler.err.switch.expression.no.result.expressions=\ switch expression does not have any result expressions
/** * compiler.err.switch.expression.no.result.expressions=\ * switch expression does not have any result expressions */
public static final Error SwitchExpressionNoResultExpressions = new Error("compiler", "switch.expression.no.result.expressions");
compiler.err.switch.mixing.case.types=\ different case kinds used in the switch
/** * compiler.err.switch.mixing.case.types=\ * different case kinds used in the switch */
public static final Error SwitchMixingCaseTypes = new Error("compiler", "switch.mixing.case.types");
compiler.err.switch.null.not.allowed=\ null label in case is not allowed
/** * compiler.err.switch.null.not.allowed=\ * null label in case is not allowed */
public static final Error SwitchNullNotAllowed = new Error("compiler", "switch.null.not.allowed");
compiler.err.this.as.identifier=\ as of release 8, ''this'' is allowed as the parameter name for the receiver type only\n\ which has to be the first parameter, and cannot be a lambda parameter
/** * compiler.err.this.as.identifier=\ * as of release 8, ''this'' is allowed as the parameter name for the receiver type only\n\ * which has to be the first parameter, and cannot be a lambda parameter */
public static final Error ThisAsIdentifier = new Error("compiler", "this.as.identifier");
compiler.err.throws.not.allowed.in.intf.annotation=\ throws clause not allowed in @interface members
/** * compiler.err.throws.not.allowed.in.intf.annotation=\ * throws clause not allowed in @interface members */
public static final Error ThrowsNotAllowedInIntfAnnotation = new Error("compiler", "throws.not.allowed.in.intf.annotation");
compiler.err.too.many.modules=\ too many module declarations found
/** * compiler.err.too.many.modules=\ * too many module declarations found */
public static final Error TooManyModules = new Error("compiler", "too.many.modules");
compiler.err.too.many.patched.modules=\ too many patched modules ({0}), use --module-source-path
/** * compiler.err.too.many.patched.modules=\ * too many patched modules ({0}), use --module-source-path */
public static Error TooManyPatchedModules(Set<? extends String> arg0) { return new Error("compiler", "too.many.patched.modules", arg0); }
compiler.err.try.resource.may.not.be.assigned=\ auto-closeable resource {0} may not be assigned
/** * compiler.err.try.resource.may.not.be.assigned=\ * auto-closeable resource {0} may not be assigned */
public static Error TryResourceMayNotBeAssigned(Symbol arg0) { return new Error("compiler", "try.resource.may.not.be.assigned", arg0); }
compiler.err.try.with.resources.expr.effectively.final.var=\ variable {0} used as a try-with-resources resource neither final nor effectively final
/** * compiler.err.try.with.resources.expr.effectively.final.var=\ * variable {0} used as a try-with-resources resource neither final nor effectively final */
public static Error TryWithResourcesExprEffectivelyFinalVar(Symbol arg0) { return new Error("compiler", "try.with.resources.expr.effectively.final.var", arg0); }
compiler.err.try.with.resources.expr.needs.var=\ the try-with-resources resource must either be a variable declaration or an expression denoting \ a reference to a final or effectively final variable
/** * compiler.err.try.with.resources.expr.needs.var=\ * the try-with-resources resource must either be a variable declaration or an expression denoting \ *a reference to a final or effectively final variable */
public static final Error TryWithResourcesExprNeedsVar = new Error("compiler", "try.with.resources.expr.needs.var");
compiler.err.try.without.catch.finally.or.resource.decls=\ ''try'' without ''catch'', ''finally'' or resource declarations
/** * compiler.err.try.without.catch.finally.or.resource.decls=\ * ''try'' without ''catch'', ''finally'' or resource declarations */
public static final Error TryWithoutCatchFinallyOrResourceDecls = new Error("compiler", "try.without.catch.finally.or.resource.decls");
compiler.err.two.class.loaders.1=\ javac is split between multiple class loaders: check your configuration
/** * compiler.err.two.class.loaders.1=\ * javac is split between multiple class loaders: check your configuration */
public static final Error TwoClassLoaders1 = new Error("compiler", "two.class.loaders.1");
compiler.err.two.class.loaders.2=\ javac is split between multiple class loaders:\n\ one class comes from file: {0}\n\ while javac comes from {1}
/** * compiler.err.two.class.loaders.2=\ * javac is split between multiple class loaders:\n\ * one class comes from file: {0}\n\ * while javac comes from {1} */
public static Error TwoClassLoaders2(URL arg0, URL arg1) { return new Error("compiler", "two.class.loaders.2", arg0, arg1); }
compiler.err.type.doesnt.take.params=\ type {0} does not take parameters
/** * compiler.err.type.doesnt.take.params=\ * type {0} does not take parameters */
public static Error TypeDoesntTakeParams(Symbol arg0) { return new Error("compiler", "type.doesnt.take.params", arg0); }
compiler.err.type.found.req=\ unexpected type\n\ required: {1}\n\ found: {0}
/** * compiler.err.type.found.req=\ * unexpected type\n\ * required: {1}\n\ * found: {0} */
public static Error TypeFoundReq(Object arg0, JCDiagnostic arg1) { return new Error("compiler", "type.found.req", arg0, arg1); }
compiler.err.type.found.req=\ unexpected type\n\ required: {1}\n\ found: {0}
/** * compiler.err.type.found.req=\ * unexpected type\n\ * required: {1}\n\ * found: {0} */
public static Error TypeFoundReq(Object arg0, Fragment arg1) { return new Error("compiler", "type.found.req", arg0, arg1); }
compiler.err.type.var.cant.be.deref=\ cannot select from a type variable
/** * compiler.err.type.var.cant.be.deref=\ * cannot select from a type variable */
public static final Error TypeVarCantBeDeref = new Error("compiler", "type.var.cant.be.deref");
compiler.err.type.var.may.not.be.followed.by.other.bounds=\ a type variable may not be followed by other bounds
/** * compiler.err.type.var.may.not.be.followed.by.other.bounds=\ * a type variable may not be followed by other bounds */
public static final Error TypeVarMayNotBeFollowedByOtherBounds = new Error("compiler", "type.var.may.not.be.followed.by.other.bounds");
compiler.err.type.var.more.than.once=\ type variable {0} occurs more than once in result type of {1}; cannot be left uninstantiated
/** * compiler.err.type.var.more.than.once=\ * type variable {0} occurs more than once in result type of {1}; cannot be left uninstantiated */
public static final Error TypeVarMoreThanOnce = new Error("compiler", "type.var.more.than.once");
compiler.err.type.var.more.than.once.in.result=\ type variable {0} occurs more than once in type of {1}; cannot be left uninstantiated
/** * compiler.err.type.var.more.than.once.in.result=\ * type variable {0} occurs more than once in type of {1}; cannot be left uninstantiated */
public static final Error TypeVarMoreThanOnceInResult = new Error("compiler", "type.var.more.than.once.in.result");
compiler.err.types.incompatible=\ types {0} and {1} are incompatible;\n\ {2}
/** * compiler.err.types.incompatible=\ * types {0} and {1} are incompatible;\n\ * {2} */
public static Error TypesIncompatible(Type arg0, Type arg1, Fragment arg2) { return new Error("compiler", "types.incompatible", arg0, arg1, arg2); }
compiler.err.unclosed.char.lit=\ unclosed character literal
/** * compiler.err.unclosed.char.lit=\ * unclosed character literal */
public static final Error UnclosedCharLit = new Error("compiler", "unclosed.char.lit");
compiler.err.unclosed.comment=\ unclosed comment
/** * compiler.err.unclosed.comment=\ * unclosed comment */
public static final Error UnclosedComment = new Error("compiler", "unclosed.comment");
compiler.err.unclosed.str.lit=\ unclosed string literal
/** * compiler.err.unclosed.str.lit=\ * unclosed string literal */
public static final Error UnclosedStrLit = new Error("compiler", "unclosed.str.lit");
compiler.err.unclosed.text.block=\ unclosed text block
/** * compiler.err.unclosed.text.block=\ * unclosed text block */
public static final Error UnclosedTextBlock = new Error("compiler", "unclosed.text.block");
compiler.err.undef.label=\ undefined label: {0}
/** * compiler.err.undef.label=\ * undefined label: {0} */
public static Error UndefLabel(Name arg0) { return new Error("compiler", "undef.label", arg0); }
compiler.err.underscore.as.identifier=\ as of release 9, ''_'' is a keyword, and may not be used as an identifier
/** * compiler.err.underscore.as.identifier=\ * as of release 9, ''_'' is a keyword, and may not be used as an identifier */
public static final Error UnderscoreAsIdentifier = new Error("compiler", "underscore.as.identifier");
compiler.err.underscore.as.identifier.in.lambda=\ ''_'' used as an identifier\n\ (use of ''_'' as an identifier is forbidden for lambda parameters)
/** * compiler.err.underscore.as.identifier.in.lambda=\ * ''_'' used as an identifier\n\ * (use of ''_'' as an identifier is forbidden for lambda parameters) */
public static final Error UnderscoreAsIdentifierInLambda = new Error("compiler", "underscore.as.identifier.in.lambda");
compiler.err.unexpected.lambda=\ lambda expression not expected here
/** * compiler.err.unexpected.lambda=\ * lambda expression not expected here */
public static final Error UnexpectedLambda = new Error("compiler", "unexpected.lambda");
compiler.err.unexpected.mref=\ method reference not expected here
/** * compiler.err.unexpected.mref=\ * method reference not expected here */
public static final Error UnexpectedMref = new Error("compiler", "unexpected.mref");
compiler.err.unexpected.type=\ unexpected type\n\ required: {0}\n\ found: {1}
/** * compiler.err.unexpected.type=\ * unexpected type\n\ * required: {0}\n\ * found: {1} */
public static Error UnexpectedType(Set<? extends KindName> arg0, Set<? extends KindName> arg1) { return new Error("compiler", "unexpected.type", arg0, arg1); }
compiler.err.unmatched.quote=\ unmatched quote in environment variable {0}
/** * compiler.err.unmatched.quote=\ * unmatched quote in environment variable {0} */
public static Error UnmatchedQuote(String arg0) { return new Error("compiler", "unmatched.quote", arg0); }
compiler.err.unnamed.pkg.not.allowed.named.modules=\ unnamed package is not allowed in named modules
/** * compiler.err.unnamed.pkg.not.allowed.named.modules=\ * unnamed package is not allowed in named modules */
public static final Error UnnamedPkgNotAllowedNamedModules = new Error("compiler", "unnamed.pkg.not.allowed.named.modules");
compiler.err.unreachable.stmt=\ unreachable statement
/** * compiler.err.unreachable.stmt=\ * unreachable statement */
public static final Error UnreachableStmt = new Error("compiler", "unreachable.stmt");
compiler.err.unreported.exception.default.constructor=\ unreported exception {0} in default constructor
/** * compiler.err.unreported.exception.default.constructor=\ * unreported exception {0} in default constructor */
public static Error UnreportedExceptionDefaultConstructor(Type arg0) { return new Error("compiler", "unreported.exception.default.constructor", arg0); }
compiler.err.unreported.exception.implicit.close=\ unreported exception {0}; must be caught or declared to be thrown\n\ exception thrown from implicit call to close() on resource variable ''{1}''
/** * compiler.err.unreported.exception.implicit.close=\ * unreported exception {0}; must be caught or declared to be thrown\n\ * exception thrown from implicit call to close() on resource variable ''{1}'' */
public static Error UnreportedExceptionImplicitClose(Type arg0, Name arg1) { return new Error("compiler", "unreported.exception.implicit.close", arg0, arg1); }
compiler.err.unreported.exception.need.to.catch.or.throw=\ unreported exception {0}; must be caught or declared to be thrown
/** * compiler.err.unreported.exception.need.to.catch.or.throw=\ * unreported exception {0}; must be caught or declared to be thrown */
public static Error UnreportedExceptionNeedToCatchOrThrow(Type arg0) { return new Error("compiler", "unreported.exception.need.to.catch.or.throw", arg0); }
compiler.err.unsupported.encoding=\ unsupported encoding: {0}
/** * compiler.err.unsupported.encoding=\ * unsupported encoding: {0} */
public static Error UnsupportedEncoding(String arg0) { return new Error("compiler", "unsupported.encoding", arg0); }
compiler.err.unsupported.release.version=\ release version {0} not supported
/** * compiler.err.unsupported.release.version=\ * release version {0} not supported */
public static Error UnsupportedReleaseVersion(String arg0) { return new Error("compiler", "unsupported.release.version", arg0); }
compiler.err.var.might.already.be.assigned=\ variable {0} might already have been assigned
/** * compiler.err.var.might.already.be.assigned=\ * variable {0} might already have been assigned */
public static Error VarMightAlreadyBeAssigned(Symbol arg0) { return new Error("compiler", "var.might.already.be.assigned", arg0); }
compiler.err.var.might.be.assigned.in.loop=\ variable {0} might be assigned in loop
/** * compiler.err.var.might.be.assigned.in.loop=\ * variable {0} might be assigned in loop */
public static Error VarMightBeAssignedInLoop(Symbol arg0) { return new Error("compiler", "var.might.be.assigned.in.loop", arg0); }
compiler.err.var.might.not.have.been.initialized=\ variable {0} might not have been initialized
/** * compiler.err.var.might.not.have.been.initialized=\ * variable {0} might not have been initialized */
public static Error VarMightNotHaveBeenInitialized(Symbol arg0) { return new Error("compiler", "var.might.not.have.been.initialized", arg0); }
compiler.err.var.not.initialized.in.default.constructor=\ variable {0} not initialized in the default constructor
/** * compiler.err.var.not.initialized.in.default.constructor=\ * variable {0} not initialized in the default constructor */
public static Error VarNotInitializedInDefaultConstructor(Symbol arg0) { return new Error("compiler", "var.not.initialized.in.default.constructor", arg0); }
compiler.err.varargs.and.old.array.syntax=\ legacy array notation not allowed on variable-arity parameter
/** * compiler.err.varargs.and.old.array.syntax=\ * legacy array notation not allowed on variable-arity parameter */
public static final Error VarargsAndOldArraySyntax = new Error("compiler", "varargs.and.old.array.syntax");
compiler.err.varargs.and.receiver =\ varargs notation not allowed on receiver parameter
/** * compiler.err.varargs.and.receiver =\ * varargs notation not allowed on receiver parameter */
public static final Error VarargsAndReceiver = new Error("compiler", "varargs.and.receiver");
compiler.err.varargs.invalid.trustme.anno=\ Invalid {0} annotation. {1}
/** * compiler.err.varargs.invalid.trustme.anno=\ * Invalid {0} annotation. {1} */
public static Error VarargsInvalidTrustmeAnno(Symbol arg0, JCDiagnostic arg1) { return new Error("compiler", "varargs.invalid.trustme.anno", arg0, arg1); }
compiler.err.varargs.invalid.trustme.anno=\ Invalid {0} annotation. {1}
/** * compiler.err.varargs.invalid.trustme.anno=\ * Invalid {0} annotation. {1} */
public static Error VarargsInvalidTrustmeAnno(Symbol arg0, Fragment arg1) { return new Error("compiler", "varargs.invalid.trustme.anno", arg0, arg1); }
compiler.err.varargs.must.be.last =\ varargs parameter must be the last parameter
/** * compiler.err.varargs.must.be.last =\ * varargs parameter must be the last parameter */
public static final Error VarargsMustBeLast = new Error("compiler", "varargs.must.be.last");
compiler.err.variable.not.allowed=\ variable declaration not allowed here
/** * compiler.err.variable.not.allowed=\ * variable declaration not allowed here */
public static final Error VariableNotAllowed = new Error("compiler", "variable.not.allowed");
compiler.err.void.not.allowed.here=\ ''void'' type not allowed here
/** * compiler.err.void.not.allowed.here=\ * ''void'' type not allowed here */
public static final Error VoidNotAllowedHere = new Error("compiler", "void.not.allowed.here");
compiler.err.warnings.and.werror=\ warnings found and -Werror specified
/** * compiler.err.warnings.and.werror=\ * warnings found and -Werror specified */
public static final Error WarningsAndWerror = new Error("compiler", "warnings.and.werror");
compiler.err.wrong.number.type.args=\ wrong number of type arguments; required {0}
/** * compiler.err.wrong.number.type.args=\ * wrong number of type arguments; required {0} */
public static Error WrongNumberTypeArgs(String arg0) { return new Error("compiler", "wrong.number.type.args", arg0); }
compiler.err.wrong.receiver =\ wrong receiver parameter name
/** * compiler.err.wrong.receiver =\ * wrong receiver parameter name */
public static final Error WrongReceiver = new Error("compiler", "wrong.receiver"); } public static class Warnings {
compiler.warn.access.to.member.from.serializable.element=\ access to member {0} from serializable element can be publicly accessible to untrusted code
/** * compiler.warn.access.to.member.from.serializable.element=\ * access to member {0} from serializable element can be publicly accessible to untrusted code */
public static Warning AccessToMemberFromSerializableElement(Symbol arg0) { return new Warning("compiler", "access.to.member.from.serializable.element", arg0); }
compiler.warn.access.to.member.from.serializable.lambda=\ access to member {0} from serializable lambda can be publicly accessible to untrusted code
/** * compiler.warn.access.to.member.from.serializable.lambda=\ * access to member {0} from serializable lambda can be publicly accessible to untrusted code */
public static Warning AccessToMemberFromSerializableLambda(Symbol arg0) { return new Warning("compiler", "access.to.member.from.serializable.lambda", arg0); }
compiler.warn.addopens.ignored=\ --add-opens has no effect at compile time
/** * compiler.warn.addopens.ignored=\ * --add-opens has no effect at compile time */
public static final Warning AddopensIgnored = new Warning("compiler", "addopens.ignored");
compiler.warn.annotation.method.not.found=\ Cannot find annotation method ''{1}()'' in type ''{0}''
/** * compiler.warn.annotation.method.not.found=\ * Cannot find annotation method ''{1}()'' in type ''{0}'' */
public static Warning AnnotationMethodNotFound(Type arg0, Name arg1) { return new Warning("compiler", "annotation.method.not.found", arg0, arg1); }
compiler.warn.annotation.method.not.found.reason=\ Cannot find annotation method ''{1}()'' in type ''{0}'': {2}
/** * compiler.warn.annotation.method.not.found.reason=\ * Cannot find annotation method ''{1}()'' in type ''{0}'': {2} */
public static Warning AnnotationMethodNotFoundReason(Type arg0, Name arg1, JCDiagnostic arg2) { return new Warning("compiler", "annotation.method.not.found.reason", arg0, arg1, arg2); }
compiler.warn.annotation.method.not.found.reason=\ Cannot find annotation method ''{1}()'' in type ''{0}'': {2}
/** * compiler.warn.annotation.method.not.found.reason=\ * Cannot find annotation method ''{1}()'' in type ''{0}'': {2} */
public static Warning AnnotationMethodNotFoundReason(Type arg0, Name arg1, Fragment arg2) { return new Warning("compiler", "annotation.method.not.found.reason", arg0, arg1, arg2); }
compiler.warn.attempt.to.synchronize.on.instance.of.value.based.class=\ attempt to synchronize on an instance of a value-based class
/** * compiler.warn.attempt.to.synchronize.on.instance.of.value.based.class=\ * attempt to synchronize on an instance of a value-based class */
public static final Warning AttemptToSynchronizeOnInstanceOfValueBasedClass = new Warning("compiler", "attempt.to.synchronize.on.instance.of.value.based.class");
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
/** * 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 */
public static Warning AuxiliaryClassAccessedFromOutsideOfItsSourceFile(Symbol arg0, File arg1) { return new Warning("compiler", "auxiliary.class.accessed.from.outside.of.its.source.file", arg0, arg1); }
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
/** * 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 */
public static Warning AuxiliaryClassAccessedFromOutsideOfItsSourceFile(Symbol arg0, JavaFileObject arg1) { return new Warning("compiler", "auxiliary.class.accessed.from.outside.of.its.source.file", arg0, arg1); }
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
/** * 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 */
public static Warning AuxiliaryClassAccessedFromOutsideOfItsSourceFile(Symbol arg0, Path arg1) { return new Warning("compiler", "auxiliary.class.accessed.from.outside.of.its.source.file", arg0, arg1); }
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
/** * 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 */
public static Warning AuxiliaryClassAccessedFromOutsideOfItsSourceFile(Type arg0, File arg1) { return new Warning("compiler", "auxiliary.class.accessed.from.outside.of.its.source.file", arg0, arg1); }
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
/** * 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 */
public static Warning AuxiliaryClassAccessedFromOutsideOfItsSourceFile(Type arg0, JavaFileObject arg1) { return new Warning("compiler", "auxiliary.class.accessed.from.outside.of.its.source.file", arg0, arg1); }
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
/** * 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 */
public static Warning AuxiliaryClassAccessedFromOutsideOfItsSourceFile(Type arg0, Path arg1) { return new Warning("compiler", "auxiliary.class.accessed.from.outside.of.its.source.file", arg0, arg1); }
compiler.warn.bad.name.for.option=\ bad name in value for {0} option: ''{1}''
/** * compiler.warn.bad.name.for.option=\ * bad name in value for {0} option: ''{1}'' */
public static Warning BadNameForOption(Option arg0, String arg1) { return new Warning("compiler", "bad.name.for.option", arg0, arg1); }
compiler.warn.big.major.version=\ {0}: major version {1} is newer than {2}, the highest major version supported by this compiler.\n\ It is recommended that the compiler be upgraded.
/** * compiler.warn.big.major.version=\ * {0}: major version {1} is newer than {2}, the highest major version supported by this compiler.\n\ * It is recommended that the compiler be upgraded. */
public static Warning BigMajorVersion(File arg0, int arg1, int arg2) { return new Warning("compiler", "big.major.version", arg0, arg1, arg2); }
compiler.warn.big.major.version=\ {0}: major version {1} is newer than {2}, the highest major version supported by this compiler.\n\ It is recommended that the compiler be upgraded.
/** * compiler.warn.big.major.version=\ * {0}: major version {1} is newer than {2}, the highest major version supported by this compiler.\n\ * It is recommended that the compiler be upgraded. */
public static Warning BigMajorVersion(JavaFileObject arg0, int arg1, int arg2) { return new Warning("compiler", "big.major.version", arg0, arg1, arg2); }
compiler.warn.big.major.version=\ {0}: major version {1} is newer than {2}, the highest major version supported by this compiler.\n\ It is recommended that the compiler be upgraded.
/** * compiler.warn.big.major.version=\ * {0}: major version {1} is newer than {2}, the highest major version supported by this compiler.\n\ * It is recommended that the compiler be upgraded. */
public static Warning BigMajorVersion(Path arg0, int arg1, int arg2) { return new Warning("compiler", "big.major.version", arg0, arg1, arg2); }
compiler.warn.constant.SVUID=\ serialVersionUID must be constant in class {0}
/** * compiler.warn.constant.SVUID=\ * serialVersionUID must be constant in class {0} */
public static Warning ConstantSVUID(Symbol arg0) { return new Warning("compiler", "constant.SVUID", arg0); }
compiler.warn.deprecated.annotation.has.no.effect=\ @Deprecated annotation has no effect on this {0} declaration
/** * compiler.warn.deprecated.annotation.has.no.effect=\ * @Deprecated annotation has no effect on this {0} declaration */
public static Warning DeprecatedAnnotationHasNoEffect(KindName arg0) { return new Warning("compiler", "deprecated.annotation.has.no.effect", arg0); }
compiler.warn.diamond.redundant.args=\ Redundant type arguments in new expression (use diamond operator instead).
/** * compiler.warn.diamond.redundant.args=\ * Redundant type arguments in new expression (use diamond operator instead). */
public static final Warning DiamondRedundantArgs = new Warning("compiler", "diamond.redundant.args");
compiler.warn.dir.path.element.not.directory=\ bad path element "{0}": not a directory
/** * compiler.warn.dir.path.element.not.directory=\ * bad path element "{0}": not a directory */
public static Warning DirPathElementNotDirectory(File arg0) { return new Warning("compiler", "dir.path.element.not.directory", arg0); }
compiler.warn.dir.path.element.not.directory=\ bad path element "{0}": not a directory
/** * compiler.warn.dir.path.element.not.directory=\ * bad path element "{0}": not a directory */
public static Warning DirPathElementNotDirectory(JavaFileObject arg0) { return new Warning("compiler", "dir.path.element.not.directory", arg0); }
compiler.warn.dir.path.element.not.directory=\ bad path element "{0}": not a directory
/** * compiler.warn.dir.path.element.not.directory=\ * bad path element "{0}": not a directory */
public static Warning DirPathElementNotDirectory(Path arg0) { return new Warning("compiler", "dir.path.element.not.directory", arg0); }
compiler.warn.dir.path.element.not.found=\ bad path element "{0}": no such directory
/** * compiler.warn.dir.path.element.not.found=\ * bad path element "{0}": no such directory */
public static Warning DirPathElementNotFound(Path arg0) { return new Warning("compiler", "dir.path.element.not.found", arg0); }
compiler.warn.div.zero=\ division by zero
/** * compiler.warn.div.zero=\ * division by zero */
public static final Warning DivZero = new Warning("compiler", "div.zero");
compiler.warn.doclint.not.available=\ No service provider for doclint is available
/** * compiler.warn.doclint.not.available=\ * No service provider for doclint is available */
public static final Warning DoclintNotAvailable = new Warning("compiler", "doclint.not.available");
compiler.warn.empty.if=\ empty statement after if
/** * compiler.warn.empty.if=\ * empty statement after if */
public static final Warning EmptyIf = new Warning("compiler", "empty.if");
compiler.warn.file.from.future=\ Modification date is in the future for file {0}
/** * compiler.warn.file.from.future=\ * Modification date is in the future for file {0} */
public static Warning FileFromFuture(File arg0) { return new Warning("compiler", "file.from.future", arg0); }
compiler.warn.file.from.future=\ Modification date is in the future for file {0}
/** * compiler.warn.file.from.future=\ * Modification date is in the future for file {0} */
public static Warning FileFromFuture(JavaFileObject arg0) { return new Warning("compiler", "file.from.future", arg0); }
compiler.warn.file.from.future=\ Modification date is in the future for file {0}
/** * compiler.warn.file.from.future=\ * Modification date is in the future for file {0} */
public static Warning FileFromFuture(Path arg0) { return new Warning("compiler", "file.from.future", arg0); }
compiler.warn.finally.cannot.complete=\ finally clause cannot complete normally
/** * compiler.warn.finally.cannot.complete=\ * finally clause cannot complete normally */
public static final Warning FinallyCannotComplete = new Warning("compiler", "finally.cannot.complete");
compiler.warn.forward.ref=\ reference to variable ''{0}'' before it has been initialized
/** * compiler.warn.forward.ref=\ * reference to variable ''{0}'' before it has been initialized */
public static Warning ForwardRef(Symbol arg0) { return new Warning("compiler", "forward.ref", arg0); }
compiler.warn.future.attr=\ {0} attribute introduced in version {1}.{2} class files is ignored in version {3}.{4} class files
/** * compiler.warn.future.attr=\ * {0} attribute introduced in version {1}.{2} class files is ignored in version {3}.{4} class files */
public static Warning FutureAttr(Name arg0, int arg1, int arg2, int arg3, int arg4) { return new Warning("compiler", "future.attr", arg0, arg1, arg2, arg3, arg4); }
compiler.warn.has.been.deprecated=\ {0} in {1} has been deprecated
/** * compiler.warn.has.been.deprecated=\ * {0} in {1} has been deprecated */
public static Warning HasBeenDeprecated(Symbol arg0, Symbol arg1) { return new Warning("compiler", "has.been.deprecated", arg0, arg1); }
compiler.warn.has.been.deprecated.for.removal=\ {0} in {1} has been deprecated and marked for removal
/** * compiler.warn.has.been.deprecated.for.removal=\ * {0} in {1} has been deprecated and marked for removal */
public static Warning HasBeenDeprecatedForRemoval(Symbol arg0, Symbol arg1) { return new Warning("compiler", "has.been.deprecated.for.removal", arg0, arg1); }
compiler.warn.has.been.deprecated.for.removal.module=\ module {0} has been deprecated and marked for removal
/** * compiler.warn.has.been.deprecated.for.removal.module=\ * module {0} has been deprecated and marked for removal */
public static Warning HasBeenDeprecatedForRemovalModule(Symbol arg0) { return new Warning("compiler", "has.been.deprecated.for.removal.module", arg0); }
compiler.warn.has.been.deprecated.module=\ module {0} has been deprecated
/** * compiler.warn.has.been.deprecated.module=\ * module {0} has been deprecated */
public static Warning HasBeenDeprecatedModule(Symbol arg0) { return new Warning("compiler", "has.been.deprecated.module", arg0); }
compiler.warn.illegal.char.for.encoding=\ unmappable character for encoding {0}
/** * compiler.warn.illegal.char.for.encoding=\ * unmappable character for encoding {0} */
public static final Warning IllegalCharForEncoding = new Warning("compiler", "illegal.char.for.encoding");
compiler.warn.illegal.ref.to.restricted.type=\ illegal reference to restricted type ''{0}''
/** * compiler.warn.illegal.ref.to.restricted.type=\ * illegal reference to restricted type ''{0}'' */
public static Warning IllegalRefToRestrictedType(Name arg0) { return new Warning("compiler", "illegal.ref.to.restricted.type", arg0); }
compiler.warn.improper.SVUID=\ serialVersionUID must be declared static final in class {0}
/** * compiler.warn.improper.SVUID=\ * serialVersionUID must be declared static final in class {0} */
public static Warning ImproperSVUID(Symbol arg0) { return new Warning("compiler", "improper.SVUID", arg0); }
compiler.warn.inconsistent.white.space.indentation=\ inconsistent white space indentation
/** * compiler.warn.inconsistent.white.space.indentation=\ * inconsistent white space indentation */
public static final Warning InconsistentWhiteSpaceIndentation = new Warning("compiler", "inconsistent.white.space.indentation");
compiler.warn.incubating.modules=\ using incubating module(s): {0}
/** * compiler.warn.incubating.modules=\ * using incubating module(s): {0} */
public static Warning IncubatingModules(String arg0) { return new Warning("compiler", "incubating.modules", arg0); }
compiler.warn.inexact.non-varargs.call=\ non-varargs call of varargs method with inexact argument type for last parameter;\n\ cast to {0} for a varargs call\n\ cast to {1} for a non-varargs call and to suppress this warning
/** * compiler.warn.inexact.non-varargs.call=\ * non-varargs call of varargs method with inexact argument type for last parameter;\n\ * cast to {0} for a varargs call\n\ * cast to {1} for a non-varargs call and to suppress this warning */
public static Warning InexactNonVarargsCall(Type arg0, Type arg1) { return new Warning("compiler", "inexact.non-varargs.call", arg0, arg1); }
compiler.warn.invalid.archive.file=\ Unexpected file on path: {0}
/** * compiler.warn.invalid.archive.file=\ * Unexpected file on path: {0} */
public static Warning InvalidArchiveFile(Path arg0) { return new Warning("compiler", "invalid.archive.file", arg0); }
compiler.warn.invalid.path=\ Invalid filename: {0}
/** * compiler.warn.invalid.path=\ * Invalid filename: {0} */
public static Warning InvalidPath(String arg0) { return new Warning("compiler", "invalid.path", arg0); }
compiler.warn.invalid.yield=\ ''yield'' may become a restricted identifier in a future release\n\ (to invoke a method called yield, qualify the yield with a receiver or type name)
/** * compiler.warn.invalid.yield=\ * ''yield'' may become a restricted identifier in a future release\n\ * (to invoke a method called yield, qualify the yield with a receiver or type name) */
public static final Warning InvalidYield = new Warning("compiler", "invalid.yield");
compiler.warn.is.preview=\ {0} is an API that is part of a preview feature
/** * compiler.warn.is.preview=\ * {0} is an API that is part of a preview feature */
public static Warning IsPreview(Symbol arg0) { return new Warning("compiler", "is.preview", arg0); }
compiler.warn.leaks.not.accessible=\ {0} {1} in module {2} is not accessible to clients that require this module
/** * compiler.warn.leaks.not.accessible=\ * {0} {1} in module {2} is not accessible to clients that require this module */
public static Warning LeaksNotAccessible(KindName arg0, Symbol arg1, Symbol arg2) { return new Warning("compiler", "leaks.not.accessible", arg0, arg1, arg2); }
compiler.warn.leaks.not.accessible.not.required.transitive=\ {0} {1} in module {2} is not indirectly exported using 'requires transitive'
/** * compiler.warn.leaks.not.accessible.not.required.transitive=\ * {0} {1} in module {2} is not indirectly exported using 'requires transitive' */
public static Warning LeaksNotAccessibleNotRequiredTransitive(KindName arg0, Symbol arg1, Symbol arg2) { return new Warning("compiler", "leaks.not.accessible.not.required.transitive", arg0, arg1, arg2); }
compiler.warn.leaks.not.accessible.unexported=\ {0} {1} in module {2} is not exported
/** * compiler.warn.leaks.not.accessible.unexported=\ * {0} {1} in module {2} is not exported */
public static Warning LeaksNotAccessibleUnexported(KindName arg0, Symbol arg1, Symbol arg2) { return new Warning("compiler", "leaks.not.accessible.unexported", arg0, arg1, arg2); }
compiler.warn.leaks.not.accessible.unexported.qualified=\ {0} {1} in module {2} may not be visible to all clients that require this module
/** * compiler.warn.leaks.not.accessible.unexported.qualified=\ * {0} {1} in module {2} may not be visible to all clients that require this module */
public static Warning LeaksNotAccessibleUnexportedQualified(KindName arg0, Symbol arg1, Symbol arg2) { return new Warning("compiler", "leaks.not.accessible.unexported.qualified", arg0, arg1, arg2); }
compiler.warn.lintOption=\ [{0}]\u0020
/** * compiler.warn.lintOption=\ * [{0}]\u0020 */
public static Warning LintOption(Option arg0) { return new Warning("compiler", "lintOption", arg0); }
compiler.warn.local.redundant.type=\ Redundant type for local variable (replace explicit type with ''var'').
/** * compiler.warn.local.redundant.type=\ * Redundant type for local variable (replace explicit type with ''var''). */
public static final Warning LocalRedundantType = new Warning("compiler", "local.redundant.type");
compiler.warn.locn.unknown.file.on.module.path=\ unknown file on module path: {0}
/** * compiler.warn.locn.unknown.file.on.module.path=\ * unknown file on module path: {0} */
public static Warning LocnUnknownFileOnModulePath(Path arg0) { return new Warning("compiler", "locn.unknown.file.on.module.path", arg0); }
compiler.warn.long.SVUID=\ serialVersionUID must be of type long in class {0}
/** * compiler.warn.long.SVUID=\ * serialVersionUID must be of type long in class {0} */
public static Warning LongSVUID(Symbol arg0) { return new Warning("compiler", "long.SVUID", arg0); }
compiler.warn.method.redundant.typeargs=\ Redundant type arguments in method call.
/** * compiler.warn.method.redundant.typeargs=\ * Redundant type arguments in method call. */
public static final Warning MethodRedundantTypeargs = new Warning("compiler", "method.redundant.typeargs");
compiler.warn.missing-explicit-ctor=\ class {0} in exported package {1} declares no explicit constructors, thereby exposing a default constructor to clients of module {2}
/** * compiler.warn.missing-explicit-ctor=\ * class {0} in exported package {1} declares no explicit constructors, thereby exposing a default constructor to clients of module {2} */
public static Warning MissingExplicitCtor(Symbol arg0, Symbol arg1, Symbol arg2) { return new Warning("compiler", "missing-explicit-ctor", arg0, arg1, arg2); }
compiler.warn.missing.SVUID=\ serializable class {0} has no definition of serialVersionUID
/** * compiler.warn.missing.SVUID=\ * serializable class {0} has no definition of serialVersionUID */
public static Warning MissingSVUID(Symbol arg0) { return new Warning("compiler", "missing.SVUID", arg0); }
compiler.warn.missing.deprecated.annotation=\ deprecated item is not annotated with @Deprecated
/** * compiler.warn.missing.deprecated.annotation=\ * deprecated item is not annotated with @Deprecated */
public static final Warning MissingDeprecatedAnnotation = new Warning("compiler", "missing.deprecated.annotation");
compiler.warn.module.for.option.not.found=\ module name in {0} option not found: {1}
/** * compiler.warn.module.for.option.not.found=\ * module name in {0} option not found: {1} */
public static Warning ModuleForOptionNotFound(Option arg0, Symbol arg1) { return new Warning("compiler", "module.for.option.not.found", arg0, arg1); }
compiler.warn.module.not.found=\ module not found: {0}
/** * compiler.warn.module.not.found=\ * module not found: {0} */
public static Warning ModuleNotFound(Symbol arg0) { return new Warning("compiler", "module.not.found", arg0); }
compiler.warn.option.obsolete.source=\ source value {0} is obsolete and will be removed in a future release
/** * compiler.warn.option.obsolete.source=\ * source value {0} is obsolete and will be removed in a future release */
public static Warning OptionObsoleteSource(String arg0) { return new Warning("compiler", "option.obsolete.source", arg0); }
compiler.warn.option.obsolete.suppression=\ To suppress warnings about obsolete options, use -Xlint:-options.
/** * compiler.warn.option.obsolete.suppression=\ * To suppress warnings about obsolete options, use -Xlint:-options. */
public static final Warning OptionObsoleteSuppression = new Warning("compiler", "option.obsolete.suppression");
compiler.warn.option.obsolete.target=\ target value {0} is obsolete and will be removed in a future release
/** * compiler.warn.option.obsolete.target=\ * target value {0} is obsolete and will be removed in a future release */
public static Warning OptionObsoleteTarget(Target arg0) { return new Warning("compiler", "option.obsolete.target", arg0); }
compiler.warn.option.parameters.unsupported=\ -parameters is not supported for target value {0}. Use {1} or later.
/** * compiler.warn.option.parameters.unsupported=\ * -parameters is not supported for target value {0}. Use {1} or later. */
public static Warning OptionParametersUnsupported(Target arg0, Target arg1) { return new Warning("compiler", "option.parameters.unsupported", arg0, arg1); }
compiler.warn.outdir.is.in.exploded.module=\ the output directory is within an exploded module: {0}
/** * compiler.warn.outdir.is.in.exploded.module=\ * the output directory is within an exploded module: {0} */
public static Warning OutdirIsInExplodedModule(Path arg0) { return new Warning("compiler", "outdir.is.in.exploded.module", arg0); }
compiler.warn.override.bridge=\ {0}; overridden method is a bridge method
/** * compiler.warn.override.bridge=\ * {0}; overridden method is a bridge method */
public static Warning OverrideBridge(JCDiagnostic arg0) { return new Warning("compiler", "override.bridge", arg0); }
compiler.warn.override.bridge=\ {0}; overridden method is a bridge method
/** * compiler.warn.override.bridge=\ * {0}; overridden method is a bridge method */
public static Warning OverrideBridge(Fragment arg0) { return new Warning("compiler", "override.bridge", arg0); }
compiler.warn.override.equals.but.not.hashcode=\ Class {0} overrides equals, but neither it nor any superclass overrides hashCode method
/** * compiler.warn.override.equals.but.not.hashcode=\ * Class {0} overrides equals, but neither it nor any superclass overrides hashCode method */
public static Warning OverrideEqualsButNotHashcode(Symbol arg0) { return new Warning("compiler", "override.equals.but.not.hashcode", arg0); }
compiler.warn.override.unchecked.ret=\ {0}\n\ return type requires unchecked conversion from {1} to {2}
/** * compiler.warn.override.unchecked.ret=\ * {0}\n\ * return type requires unchecked conversion from {1} to {2} */
public static Warning OverrideUncheckedRet(JCDiagnostic arg0, Type arg1, Type arg2) { return new Warning("compiler", "override.unchecked.ret", arg0, arg1, arg2); }
compiler.warn.override.unchecked.ret=\ {0}\n\ return type requires unchecked conversion from {1} to {2}
/** * compiler.warn.override.unchecked.ret=\ * {0}\n\ * return type requires unchecked conversion from {1} to {2} */
public static Warning OverrideUncheckedRet(Fragment arg0, Type arg1, Type arg2) { return new Warning("compiler", "override.unchecked.ret", arg0, arg1, arg2); }
compiler.warn.override.unchecked.thrown=\ {0}\n\ overridden method does not throw {1}
/** * compiler.warn.override.unchecked.thrown=\ * {0}\n\ * overridden method does not throw {1} */
public static Warning OverrideUncheckedThrown(JCDiagnostic arg0, Type arg1) { return new Warning("compiler", "override.unchecked.thrown", arg0, arg1); }
compiler.warn.override.unchecked.thrown=\ {0}\n\ overridden method does not throw {1}
/** * compiler.warn.override.unchecked.thrown=\ * {0}\n\ * overridden method does not throw {1} */
public static Warning OverrideUncheckedThrown(Fragment arg0, Type arg1) { return new Warning("compiler", "override.unchecked.thrown", arg0, arg1); }
compiler.warn.override.varargs.extra=\ {0}; overriding method is missing ''...''
/** * compiler.warn.override.varargs.extra=\ * {0}; overriding method is missing ''...'' */
public static Warning OverrideVarargsExtra(JCDiagnostic arg0) { return new Warning("compiler", "override.varargs.extra", arg0); }
compiler.warn.override.varargs.extra=\ {0}; overriding method is missing ''...''
/** * compiler.warn.override.varargs.extra=\ * {0}; overriding method is missing ''...'' */
public static Warning OverrideVarargsExtra(Fragment arg0) { return new Warning("compiler", "override.varargs.extra", arg0); }
compiler.warn.override.varargs.missing=\ {0}; overridden method has no ''...''
/** * compiler.warn.override.varargs.missing=\ * {0}; overridden method has no ''...'' */
public static Warning OverrideVarargsMissing(JCDiagnostic arg0) { return new Warning("compiler", "override.varargs.missing", arg0); }
compiler.warn.override.varargs.missing=\ {0}; overridden method has no ''...''
/** * compiler.warn.override.varargs.missing=\ * {0}; overridden method has no ''...'' */
public static Warning OverrideVarargsMissing(Fragment arg0) { return new Warning("compiler", "override.varargs.missing", arg0); }
compiler.warn.package.empty.or.not.found=\ package is empty or does not exist: {0}
/** * compiler.warn.package.empty.or.not.found=\ * package is empty or does not exist: {0} */
public static Warning PackageEmptyOrNotFound(Symbol arg0) { return new Warning("compiler", "package.empty.or.not.found", arg0); }
compiler.warn.path.element.not.found=\ bad path element "{0}": no such file or directory
/** * compiler.warn.path.element.not.found=\ * bad path element "{0}": no such file or directory */
public static Warning PathElementNotFound(Path arg0) { return new Warning("compiler", "path.element.not.found", arg0); }
compiler.warn.pkg-info.already.seen=\ a package-info.java file has already been seen for package {0}
/** * compiler.warn.pkg-info.already.seen=\ * a package-info.java file has already been seen for package {0} */
public static Warning PkgInfoAlreadySeen(Symbol arg0) { return new Warning("compiler", "pkg-info.already.seen", arg0); }
compiler.warn.poor.choice.for.module.name=\ module name component {0} should avoid terminal digits
/** * compiler.warn.poor.choice.for.module.name=\ * module name component {0} should avoid terminal digits */
public static Warning PoorChoiceForModuleName(Name arg0) { return new Warning("compiler", "poor.choice.for.module.name", arg0); }
compiler.warn.position.overflow=\ Position encoding overflows at line {0}
/** * compiler.warn.position.overflow=\ * Position encoding overflows at line {0} */
public static Warning PositionOverflow(int arg0) { return new Warning("compiler", "position.overflow", arg0); }
compiler.warn.possible.fall-through.into.case=\ possible fall-through into case
/** * compiler.warn.possible.fall-through.into.case=\ * possible fall-through into case */
public static final Warning PossibleFallThroughIntoCase = new Warning("compiler", "possible.fall-through.into.case");
compiler.warn.potential.lambda.found=\ This anonymous inner class creation can be turned into a lambda expression.
/** * compiler.warn.potential.lambda.found=\ * This anonymous inner class creation can be turned into a lambda expression. */
public static final Warning PotentialLambdaFound = new Warning("compiler", "potential.lambda.found");
compiler.warn.potentially.ambiguous.overload=\ {0} in {1} is potentially ambiguous with {2} in {3}
/** * compiler.warn.potentially.ambiguous.overload=\ * {0} in {1} is potentially ambiguous with {2} in {3} */
public static Warning PotentiallyAmbiguousOverload(Symbol arg0, Symbol arg1, Symbol arg2, Symbol arg3) { return new Warning("compiler", "potentially.ambiguous.overload", arg0, arg1, arg2, arg3); }
compiler.warn.preview.feature.use=\ {0} is a preview feature and may be removed in a future release.
/** * compiler.warn.preview.feature.use=\ * {0} is a preview feature and may be removed in a future release. */
public static Warning PreviewFeatureUse(JCDiagnostic arg0) { return new Warning("compiler", "preview.feature.use", arg0); }
compiler.warn.preview.feature.use=\ {0} is a preview feature and may be removed in a future release.
/** * compiler.warn.preview.feature.use=\ * {0} is a preview feature and may be removed in a future release. */
public static Warning PreviewFeatureUse(Fragment arg0) { return new Warning("compiler", "preview.feature.use", arg0); }
compiler.warn.preview.feature.use.classfile=\ classfile for {0} uses preview features of Java SE {1}.
/** * compiler.warn.preview.feature.use.classfile=\ * classfile for {0} uses preview features of Java SE {1}. */
public static Warning PreviewFeatureUseClassfile(JavaFileObject arg0, String arg1) { return new Warning("compiler", "preview.feature.use.classfile", arg0, arg1); }
compiler.warn.preview.feature.use.plural=\ {0} are a preview feature and may be removed in a future release.
/** * compiler.warn.preview.feature.use.plural=\ * {0} are a preview feature and may be removed in a future release. */
public static Warning PreviewFeatureUsePlural(JCDiagnostic arg0) { return new Warning("compiler", "preview.feature.use.plural", arg0); }
compiler.warn.preview.feature.use.plural=\ {0} are a preview feature and may be removed in a future release.
/** * compiler.warn.preview.feature.use.plural=\ * {0} are a preview feature and may be removed in a future release. */
public static Warning PreviewFeatureUsePlural(Fragment arg0) { return new Warning("compiler", "preview.feature.use.plural", arg0); }
compiler.warn.prob.found.req=\ {0}\n\ required: {2}\n\ found: {1}
/** * compiler.warn.prob.found.req=\ * {0}\n\ * required: {2}\n\ * found: {1} */
public static Warning ProbFoundReq(JCDiagnostic arg0, Type arg1, Type arg2) { return new Warning("compiler", "prob.found.req", arg0, arg1, arg2); }
compiler.warn.prob.found.req=\ {0}\n\ required: {2}\n\ found: {1}
/** * compiler.warn.prob.found.req=\ * {0}\n\ * required: {2}\n\ * found: {1} */
public static Warning ProbFoundReq(Fragment arg0, Type arg1, Type arg2) { return new Warning("compiler", "prob.found.req", arg0, arg1, arg2); }
compiler.warn.proc.annotations.without.processors=\ No processor claimed any of these annotations: {0}
/** * compiler.warn.proc.annotations.without.processors=\ * No processor claimed any of these annotations: {0} */
public static Warning ProcAnnotationsWithoutProcessors(Set<? extends String> arg0) { return new Warning("compiler", "proc.annotations.without.processors", arg0); }
compiler.warn.proc.duplicate.option.name=\ Duplicate supported option ''{0}'' returned by annotation processor ''{1}''
/** * compiler.warn.proc.duplicate.option.name=\ * Duplicate supported option ''{0}'' returned by annotation processor ''{1}'' */
public static Warning ProcDuplicateOptionName(String arg0, String arg1) { return new Warning("compiler", "proc.duplicate.option.name", arg0, arg1); }
compiler.warn.proc.duplicate.supported.annotation=\ Duplicate supported annotation type ''{0}'' returned by annotation processor ''{1}''
/** * compiler.warn.proc.duplicate.supported.annotation=\ * Duplicate supported annotation type ''{0}'' returned by annotation processor ''{1}'' */
public static Warning ProcDuplicateSupportedAnnotation(String arg0, String arg1) { return new Warning("compiler", "proc.duplicate.supported.annotation", arg0, arg1); }
compiler.warn.proc.file.create.last.round=\ File for type ''{0}'' created in the last round will not be subject to annotation processing.
/** * compiler.warn.proc.file.create.last.round=\ * File for type ''{0}'' created in the last round will not be subject to annotation processing. */
public static Warning ProcFileCreateLastRound(String arg0) { return new Warning("compiler", "proc.file.create.last.round", arg0); }
compiler.warn.proc.file.reopening=\ Attempt to create a file for ''{0}'' multiple times
/** * compiler.warn.proc.file.reopening=\ * Attempt to create a file for ''{0}'' multiple times */
public static Warning ProcFileReopening(String arg0) { return new Warning("compiler", "proc.file.reopening", arg0); }
compiler.warn.proc.illegal.file.name=\ Cannot create file for illegal name ''{0}''.
/** * compiler.warn.proc.illegal.file.name=\ * Cannot create file for illegal name ''{0}''. */
public static Warning ProcIllegalFileName(String arg0) { return new Warning("compiler", "proc.illegal.file.name", arg0); }
compiler.warn.proc.malformed.supported.string=\ Malformed string ''{0}'' for a supported annotation type returned by processor ''{1}''
/** * compiler.warn.proc.malformed.supported.string=\ * Malformed string ''{0}'' for a supported annotation type returned by processor ''{1}'' */
public static Warning ProcMalformedSupportedString(String arg0, String arg1) { return new Warning("compiler", "proc.malformed.supported.string", arg0, arg1); }
compiler.warn.proc.messager=\ {0}
/** * compiler.warn.proc.messager=\ * {0} */
public static Warning ProcMessager(String arg0) { return new Warning("compiler", "proc.messager", arg0); }
compiler.warn.proc.package.does.not.exist=\ package {0} does not exist
/** * compiler.warn.proc.package.does.not.exist=\ * package {0} does not exist */
public static Warning ProcPackageDoesNotExist(String arg0) { return new Warning("compiler", "proc.package.does.not.exist", arg0); }
compiler.warn.proc.proc-only.requested.no.procs=\ Annotation processing without compilation requested but no processors were found.
/** * compiler.warn.proc.proc-only.requested.no.procs=\ * Annotation processing without compilation requested but no processors were found. */
public static final Warning ProcProcOnlyRequestedNoProcs = new Warning("compiler", "proc.proc-only.requested.no.procs");
compiler.warn.proc.processor.incompatible.source.version=\ Supported source version ''{0}'' from annotation processor ''{1}'' less than -source ''{2}''
/** * compiler.warn.proc.processor.incompatible.source.version=\ * Supported source version ''{0}'' from annotation processor ''{1}'' less than -source ''{2}'' */
public static Warning ProcProcessorIncompatibleSourceVersion(SourceVersion arg0, String arg1, String arg2) { return new Warning("compiler", "proc.processor.incompatible.source.version", arg0, arg1, arg2); }
compiler.warn.proc.redundant.types.with.wildcard=\ Annotation processor ''{0}'' redundantly supports both ''*'' and other annotation types
/** * compiler.warn.proc.redundant.types.with.wildcard=\ * Annotation processor ''{0}'' redundantly supports both ''*'' and other annotation types */
public static Warning ProcRedundantTypesWithWildcard(String arg0) { return new Warning("compiler", "proc.redundant.types.with.wildcard", arg0); }
compiler.warn.proc.suspicious.class.name=\ Creating file for a type whose name ends in {1}: ''{0}''
/** * compiler.warn.proc.suspicious.class.name=\ * Creating file for a type whose name ends in {1}: ''{0}'' */
public static Warning ProcSuspiciousClassName(String arg0, String arg1) { return new Warning("compiler", "proc.suspicious.class.name", arg0, arg1); }
compiler.warn.proc.type.already.exists=\ A file for type ''{0}'' already exists on the sourcepath or classpath
/** * compiler.warn.proc.type.already.exists=\ * A file for type ''{0}'' already exists on the sourcepath or classpath */
public static Warning ProcTypeAlreadyExists(String arg0) { return new Warning("compiler", "proc.type.already.exists", arg0); }
compiler.warn.proc.type.recreate=\ Attempt to create a file for type ''{0}'' multiple times
/** * compiler.warn.proc.type.recreate=\ * Attempt to create a file for type ''{0}'' multiple times */
public static Warning ProcTypeRecreate(String arg0) { return new Warning("compiler", "proc.type.recreate", arg0); }
compiler.warn.proc.unclosed.type.files=\ Unclosed files for the types ''{0}''; these types will not undergo annotation processing
/** * compiler.warn.proc.unclosed.type.files=\ * Unclosed files for the types ''{0}''; these types will not undergo annotation processing */
public static Warning ProcUnclosedTypeFiles(Set<? extends String> arg0) { return new Warning("compiler", "proc.unclosed.type.files", arg0); }
compiler.warn.proc.unmatched.processor.options=\ The following options were not recognized by any processor: ''{0}''
/** * compiler.warn.proc.unmatched.processor.options=\ * The following options were not recognized by any processor: ''{0}'' */
public static Warning ProcUnmatchedProcessorOptions(String arg0) { return new Warning("compiler", "proc.unmatched.processor.options", arg0); }
compiler.warn.proc.use.implicit=\ Implicitly compiled files were not subject to annotation processing.\n\ Use -implicit to specify a policy for implicit compilation.
/** * compiler.warn.proc.use.implicit=\ * Implicitly compiled files were not subject to annotation processing.\n\ * Use -implicit to specify a policy for implicit compilation. */
public static final Warning ProcUseImplicit = new Warning("compiler", "proc.use.implicit");
compiler.warn.proc.use.proc.or.implicit=\ Implicitly compiled files were not subject to annotation processing.\n\ Use -proc:none to disable annotation processing or -implicit to specify a policy for implicit compilation.
/** * compiler.warn.proc.use.proc.or.implicit=\ * Implicitly compiled files were not subject to annotation processing.\n\ * Use -proc:none to disable annotation processing or -implicit to specify a policy for implicit compilation. */
public static final Warning ProcUseProcOrImplicit = new Warning("compiler", "proc.use.proc.or.implicit");
compiler.warn.profile.target.conflict=\ profile {0} is not valid for target release {1}
/** * compiler.warn.profile.target.conflict=\ * profile {0} is not valid for target release {1} */
public static Warning ProfileTargetConflict(Profile arg0, Target arg1) { return new Warning("compiler", "profile.target.conflict", arg0, arg1); }
compiler.warn.raw.class.use=\ found raw type: {0}\n\ missing type arguments for generic class {1}
/** * compiler.warn.raw.class.use=\ * found raw type: {0}\n\ * missing type arguments for generic class {1} */
public static Warning RawClassUse(Type arg0, Type arg1) { return new Warning("compiler", "raw.class.use", arg0, arg1); }
compiler.warn.redundant.cast=\ redundant cast to {0}
/** * compiler.warn.redundant.cast=\ * redundant cast to {0} */
public static Warning RedundantCast(Type arg0) { return new Warning("compiler", "redundant.cast", arg0); }
compiler.warn.requires.automatic=\ requires directive for an automatic module
/** * compiler.warn.requires.automatic=\ * requires directive for an automatic module */
public static final Warning RequiresAutomatic = new Warning("compiler", "requires.automatic");
compiler.warn.requires.transitive.automatic=\ requires transitive directive for an automatic module
/** * compiler.warn.requires.transitive.automatic=\ * requires transitive directive for an automatic module */
public static final Warning RequiresTransitiveAutomatic = new Warning("compiler", "requires.transitive.automatic");
compiler.warn.restricted.type.not.allowed=\ as of release {1}, ''{0}'' is a restricted type name and cannot be used for type declarations or as the element type of an array
/** * compiler.warn.restricted.type.not.allowed=\ * as of release {1}, ''{0}'' is a restricted type name and cannot be used for type declarations or as the element type of an array */
public static Warning RestrictedTypeNotAllowed(Name arg0, Source arg1) { return new Warning("compiler", "restricted.type.not.allowed", arg0, arg1); }
compiler.warn.restricted.type.not.allowed.preview=\ ''{0}'' may become a restricted type name in a future release and may be unusable for type declarations or as the element type of an array
/** * compiler.warn.restricted.type.not.allowed.preview=\ * ''{0}'' may become a restricted type name in a future release and may be unusable for type declarations or as the element type of an array */
public static Warning RestrictedTypeNotAllowedPreview(Name arg0, Source arg1) { return new Warning("compiler", "restricted.type.not.allowed.preview", arg0, arg1); }
compiler.warn.self.ref=\ self-reference in initializer of variable ''{0}''
/** * compiler.warn.self.ref=\ * self-reference in initializer of variable ''{0}'' */
public static Warning SelfRef(Symbol arg0) { return new Warning("compiler", "self.ref", arg0); }
compiler.warn.service.provided.but.not.exported.or.used=\ service interface provided but not exported or used
/** * compiler.warn.service.provided.but.not.exported.or.used=\ * service interface provided but not exported or used */
public static Warning ServiceProvidedButNotExportedOrUsed(Symbol arg0) { return new Warning("compiler", "service.provided.but.not.exported.or.used", arg0); }
compiler.warn.source.no.bootclasspath=\ bootstrap class path not set in conjunction with -source {0}
/** * compiler.warn.source.no.bootclasspath=\ * bootstrap class path not set in conjunction with -source {0} */
public static Warning SourceNoBootclasspath(String arg0) { return new Warning("compiler", "source.no.bootclasspath", arg0); }
compiler.warn.source.no.system.modules.path=\ system modules path not set in conjunction with -source {0}
/** * compiler.warn.source.no.system.modules.path=\ * system modules path not set in conjunction with -source {0} */
public static Warning SourceNoSystemModulesPath(String arg0) { return new Warning("compiler", "source.no.system.modules.path", arg0); }
compiler.warn.source.target.conflict=\ source release {0} requires target release {1}
/** * compiler.warn.source.target.conflict=\ * source release {0} requires target release {1} */
public static Warning SourceTargetConflict(String arg0, Target arg1) { return new Warning("compiler", "source.target.conflict", arg0, arg1); }
compiler.warn.static.not.qualified.by.type=\ static {0} should be qualified by type name, {1}, instead of by an expression
/** * compiler.warn.static.not.qualified.by.type=\ * static {0} should be qualified by type name, {1}, instead of by an expression */
public static Warning StaticNotQualifiedByType(KindName arg0, Symbol arg1) { return new Warning("compiler", "static.not.qualified.by.type", arg0, arg1); }
compiler.warn.sun.proprietary=\ {0} is internal proprietary API and may be removed in a future release
/** * compiler.warn.sun.proprietary=\ * {0} is internal proprietary API and may be removed in a future release */
public static Warning SunProprietary(Symbol arg0) { return new Warning("compiler", "sun.proprietary", arg0); }
compiler.warn.target.default.source.conflict=\ target release {0} conflicts with default source release {1}
/** * compiler.warn.target.default.source.conflict=\ * target release {0} conflicts with default source release {1} */
public static Warning TargetDefaultSourceConflict(String arg0, Target arg1) { return new Warning("compiler", "target.default.source.conflict", arg0, arg1); }
compiler.warn.trailing.white.space.will.be.removed=\ trailing white space will be removed
/** * compiler.warn.trailing.white.space.will.be.removed=\ * trailing white space will be removed */
public static final Warning TrailingWhiteSpaceWillBeRemoved = new Warning("compiler", "trailing.white.space.will.be.removed");
compiler.warn.try.explicit.close.call=\ explicit call to close() on an auto-closeable resource
/** * compiler.warn.try.explicit.close.call=\ * explicit call to close() on an auto-closeable resource */
public static final Warning TryExplicitCloseCall = new Warning("compiler", "try.explicit.close.call");
compiler.warn.try.resource.not.referenced=\ auto-closeable resource {0} is never referenced in body of corresponding try statement
/** * compiler.warn.try.resource.not.referenced=\ * auto-closeable resource {0} is never referenced in body of corresponding try statement */
public static Warning TryResourceNotReferenced(Symbol arg0) { return new Warning("compiler", "try.resource.not.referenced", arg0); }
compiler.warn.try.resource.throws.interrupted.exc=\ auto-closeable resource {0} has a member method close() that could throw InterruptedException
/** * compiler.warn.try.resource.throws.interrupted.exc=\ * auto-closeable resource {0} has a member method close() that could throw InterruptedException */
public static Warning TryResourceThrowsInterruptedExc(Type arg0) { return new Warning("compiler", "try.resource.throws.interrupted.exc", arg0); }
compiler.warn.unchecked.assign=\ unchecked assignment: {0} to {1}
/** * compiler.warn.unchecked.assign=\ * unchecked assignment: {0} to {1} */
public static final Warning UncheckedAssign = new Warning("compiler", "unchecked.assign");
compiler.warn.unchecked.assign.to.var=\ unchecked assignment to variable {0} as member of raw type {1}
/** * compiler.warn.unchecked.assign.to.var=\ * unchecked assignment to variable {0} as member of raw type {1} */
public static Warning UncheckedAssignToVar(Symbol arg0, Type arg1) { return new Warning("compiler", "unchecked.assign.to.var", arg0, arg1); }
compiler.warn.unchecked.call.mbr.of.raw.type=\ unchecked call to {0} as a member of the raw type {1}
/** * compiler.warn.unchecked.call.mbr.of.raw.type=\ * unchecked call to {0} as a member of the raw type {1} */
public static Warning UncheckedCallMbrOfRawType(Symbol arg0, Type arg1) { return new Warning("compiler", "unchecked.call.mbr.of.raw.type", arg0, arg1); }
compiler.warn.unchecked.cast.to.type=\ unchecked cast to type {0}
/** * compiler.warn.unchecked.cast.to.type=\ * unchecked cast to type {0} */
public static final Warning UncheckedCastToType = new Warning("compiler", "unchecked.cast.to.type");
compiler.warn.unchecked.generic.array.creation=\ unchecked generic array creation for varargs parameter of type {0}
/** * compiler.warn.unchecked.generic.array.creation=\ * unchecked generic array creation for varargs parameter of type {0} */
public static Warning UncheckedGenericArrayCreation(Type arg0) { return new Warning("compiler", "unchecked.generic.array.creation", arg0); }
compiler.warn.unchecked.meth.invocation.applied=\ unchecked method invocation: {0} {1} in {4} {5} is applied to given types\n\ required: {2}\n\ found: {3}
/** * compiler.warn.unchecked.meth.invocation.applied=\ * unchecked method invocation: {0} {1} in {4} {5} is applied to given types\n\ * required: {2}\n\ * found: {3} */
public static Warning UncheckedMethInvocationApplied(KindName arg0, Name arg1, Object arg2, Object arg3, KindName arg4, Symbol arg5) { return new Warning("compiler", "unchecked.meth.invocation.applied", arg0, arg1, arg2, arg3, arg4, arg5); }
compiler.warn.unchecked.varargs.non.reifiable.type=\ Possible heap pollution from parameterized vararg type {0}
/** * compiler.warn.unchecked.varargs.non.reifiable.type=\ * Possible heap pollution from parameterized vararg type {0} */
public static Warning UncheckedVarargsNonReifiableType(Type arg0) { return new Warning("compiler", "unchecked.varargs.non.reifiable.type", arg0); }
compiler.warn.underscore.as.identifier=\ as of release 9, ''_'' is a keyword, and may not be used as an identifier
/** * compiler.warn.underscore.as.identifier=\ * as of release 9, ''_'' is a keyword, and may not be used as an identifier */
public static final Warning UnderscoreAsIdentifier = new Warning("compiler", "underscore.as.identifier");
compiler.warn.unexpected.archive.file=\ Unexpected extension for archive file: {0}
/** * compiler.warn.unexpected.archive.file=\ * Unexpected extension for archive file: {0} */
public static Warning UnexpectedArchiveFile(Path arg0) { return new Warning("compiler", "unexpected.archive.file", arg0); }
compiler.warn.unknown.enum.constant=\ unknown enum constant {1}.{2}
/** * compiler.warn.unknown.enum.constant=\ * unknown enum constant {1}.{2} */
public static Warning UnknownEnumConstant(JavaFileObject arg0, Symbol arg1, Name arg2) { return new Warning("compiler", "unknown.enum.constant", arg0, arg1, arg2); }
compiler.warn.unknown.enum.constant.reason=\ unknown enum constant {1}.{2}\n\ reason: {3}
/** * compiler.warn.unknown.enum.constant.reason=\ * unknown enum constant {1}.{2}\n\ * reason: {3} */
public static Warning UnknownEnumConstantReason(JavaFileObject arg0, Symbol arg1, Name arg2, JCDiagnostic arg3) { return new Warning("compiler", "unknown.enum.constant.reason", arg0, arg1, arg2, arg3); }
compiler.warn.unknown.enum.constant.reason=\ unknown enum constant {1}.{2}\n\ reason: {3}
/** * compiler.warn.unknown.enum.constant.reason=\ * unknown enum constant {1}.{2}\n\ * reason: {3} */
public static Warning UnknownEnumConstantReason(JavaFileObject arg0, Symbol arg1, Name arg2, Fragment arg3) { return new Warning("compiler", "unknown.enum.constant.reason", arg0, arg1, arg2, arg3); }
compiler.warn.unreachable.catch=\ unreachable catch clause\n\ thrown type {0} has already been caught
/** * compiler.warn.unreachable.catch=\ * unreachable catch clause\n\ * thrown type {0} has already been caught */
public static Warning UnreachableCatch(List<? extends Type> arg0) { return new Warning("compiler", "unreachable.catch", arg0); }
compiler.warn.unreachable.catch.1=\ unreachable catch clause\n\ thrown types {0} have already been caught
/** * compiler.warn.unreachable.catch.1=\ * unreachable catch clause\n\ * thrown types {0} have already been caught */
public static Warning UnreachableCatch1(List<? extends Type> arg0) { return new Warning("compiler", "unreachable.catch.1", arg0); }
compiler.warn.varargs.redundant.trustme.anno=\ Redundant {0} annotation. {1}
/** * compiler.warn.varargs.redundant.trustme.anno=\ * Redundant {0} annotation. {1} */
public static Warning VarargsRedundantTrustmeAnno(Symbol arg0, JCDiagnostic arg1) { return new Warning("compiler", "varargs.redundant.trustme.anno", arg0, arg1); }
compiler.warn.varargs.redundant.trustme.anno=\ Redundant {0} annotation. {1}
/** * compiler.warn.varargs.redundant.trustme.anno=\ * Redundant {0} annotation. {1} */
public static Warning VarargsRedundantTrustmeAnno(Symbol arg0, Fragment arg1) { return new Warning("compiler", "varargs.redundant.trustme.anno", arg0, arg1); }
compiler.warn.varargs.unsafe.use.varargs.param=\ Varargs method could cause heap pollution from non-reifiable varargs parameter {0}
/** * compiler.warn.varargs.unsafe.use.varargs.param=\ * Varargs method could cause heap pollution from non-reifiable varargs parameter {0} */
public static Warning VarargsUnsafeUseVarargsParam(Symbol arg0) { return new Warning("compiler", "varargs.unsafe.use.varargs.param", arg0); }
compiler.warn.warning=\ warning:\u0020
/** * compiler.warn.warning=\ * warning:\u0020 */
public static final Warning Warning = new Warning("compiler", "warning"); } public static class Notes {
compiler.note.compressed.diags=\ Some messages have been simplified; recompile with -Xdiags:verbose to get full output
/** * compiler.note.compressed.diags=\ * Some messages have been simplified; recompile with -Xdiags:verbose to get full output */
public static final Note CompressedDiags = new Note("compiler", "compressed.diags");
compiler.note.deferred.method.inst=\ Deferred instantiation of method {0}\n\ instantiated signature: {1}\n\ target-type: {2}
/** * compiler.note.deferred.method.inst=\ * Deferred instantiation of method {0}\n\ * instantiated signature: {1}\n\ * target-type: {2} */
public static Note DeferredMethodInst(Symbol arg0, Type arg1, Type arg2) { return new Note("compiler", "deferred.method.inst", arg0, arg1, arg2); }
compiler.note.deprecated.filename=\ {0} uses or overrides a deprecated API.
/** * compiler.note.deprecated.filename=\ * {0} uses or overrides a deprecated API. */
public static Note DeprecatedFilename(File arg0) { return new Note("compiler", "deprecated.filename", arg0); }
compiler.note.deprecated.filename=\ {0} uses or overrides a deprecated API.
/** * compiler.note.deprecated.filename=\ * {0} uses or overrides a deprecated API. */
public static Note DeprecatedFilename(JavaFileObject arg0) { return new Note("compiler", "deprecated.filename", arg0); }
compiler.note.deprecated.filename=\ {0} uses or overrides a deprecated API.
/** * compiler.note.deprecated.filename=\ * {0} uses or overrides a deprecated API. */
public static Note DeprecatedFilename(Path arg0) { return new Note("compiler", "deprecated.filename", arg0); }
compiler.note.deprecated.filename.additional=\ {0} has additional uses or overrides of a deprecated API.
/** * compiler.note.deprecated.filename.additional=\ * {0} has additional uses or overrides of a deprecated API. */
public static Note DeprecatedFilenameAdditional(File arg0) { return new Note("compiler", "deprecated.filename.additional", arg0); }
compiler.note.deprecated.filename.additional=\ {0} has additional uses or overrides of a deprecated API.
/** * compiler.note.deprecated.filename.additional=\ * {0} has additional uses or overrides of a deprecated API. */
public static Note DeprecatedFilenameAdditional(JavaFileObject arg0) { return new Note("compiler", "deprecated.filename.additional", arg0); }
compiler.note.deprecated.filename.additional=\ {0} has additional uses or overrides of a deprecated API.
/** * compiler.note.deprecated.filename.additional=\ * {0} has additional uses or overrides of a deprecated API. */
public static Note DeprecatedFilenameAdditional(Path arg0) { return new Note("compiler", "deprecated.filename.additional", arg0); }
compiler.note.deprecated.plural=\ Some input files use or override a deprecated API.
/** * compiler.note.deprecated.plural=\ * Some input files use or override a deprecated API. */
public static final Note DeprecatedPlural = new Note("compiler", "deprecated.plural");
compiler.note.deprecated.plural.additional=\ Some input files additionally use or override a deprecated API.
/** * compiler.note.deprecated.plural.additional=\ * Some input files additionally use or override a deprecated API. */
public static final Note DeprecatedPluralAdditional = new Note("compiler", "deprecated.plural.additional");
compiler.note.deprecated.recompile=\ Recompile with -Xlint:deprecation for details.
/** * compiler.note.deprecated.recompile=\ * Recompile with -Xlint:deprecation for details. */
public static final Note DeprecatedRecompile = new Note("compiler", "deprecated.recompile");
compiler.note.lambda.stat=\ Translating lambda expression\n\ alternate metafactory = {0}\n\ synthetic method = {1}
/** * compiler.note.lambda.stat=\ * Translating lambda expression\n\ * alternate metafactory = {0}\n\ * synthetic method = {1} */
public static Note LambdaStat(boolean arg0, Symbol arg1) { return new Note("compiler", "lambda.stat", arg0, arg1); }
compiler.note.method.ref.search.results.multi=\ {0} search results for {1}, with most specific {2}\n\ applicable candidates:
/** * compiler.note.method.ref.search.results.multi=\ * {0} search results for {1}, with most specific {2}\n\ * applicable candidates: */
public static Note MethodRefSearchResultsMulti(Fragment arg0, String arg1, int arg2) { return new Note("compiler", "method.ref.search.results.multi", arg0, arg1, arg2); }
compiler.note.mref.stat=\ Translating method reference\n\ alternate metafactory = {0}\n\
/** * compiler.note.mref.stat=\ * Translating method reference\n\ * alternate metafactory = {0}\n\ */
public static Note MrefStat(boolean arg0, Void arg1) { return new Note("compiler", "mref.stat", arg0, arg1); }
compiler.note.mref.stat.1=\ Translating method reference\n\ alternate metafactory = {0}\n\ bridge method = {1}
/** * compiler.note.mref.stat.1=\ * Translating method reference\n\ * alternate metafactory = {0}\n\ * bridge method = {1} */
public static Note MrefStat1(boolean arg0, Symbol arg1) { return new Note("compiler", "mref.stat.1", arg0, arg1); }
compiler.note.multiple.elements=\ Multiple elements named ''{1}'' in modules ''{2}'' were found by javax.lang.model.util.Elements.{0}.
/** * compiler.note.multiple.elements=\ * Multiple elements named ''{1}'' in modules ''{2}'' were found by javax.lang.model.util.Elements.{0}. */
public static Note MultipleElements(String arg0, String arg1, String arg2) { return new Note("compiler", "multiple.elements", arg0, arg1, arg2); }
compiler.note.note=\ Note:\u0020
/** * compiler.note.note=\ * Note:\u0020 */
public static final Note Note = new Note("compiler", "note");
compiler.note.preview.filename=\ {0} uses preview language features.
/** * compiler.note.preview.filename=\ * {0} uses preview language features. */
public static Note PreviewFilename(File arg0) { return new Note("compiler", "preview.filename", arg0); }
compiler.note.preview.filename=\ {0} uses preview language features.
/** * compiler.note.preview.filename=\ * {0} uses preview language features. */
public static Note PreviewFilename(JavaFileObject arg0) { return new Note("compiler", "preview.filename", arg0); }
compiler.note.preview.filename=\ {0} uses preview language features.
/** * compiler.note.preview.filename=\ * {0} uses preview language features. */
public static Note PreviewFilename(Path arg0) { return new Note("compiler", "preview.filename", arg0); }
compiler.note.preview.filename.additional=\ {0} has additional uses of preview language features.
/** * compiler.note.preview.filename.additional=\ * {0} has additional uses of preview language features. */
public static Note PreviewFilenameAdditional(File arg0) { return new Note("compiler", "preview.filename.additional", arg0); }
compiler.note.preview.filename.additional=\ {0} has additional uses of preview language features.
/** * compiler.note.preview.filename.additional=\ * {0} has additional uses of preview language features. */
public static Note PreviewFilenameAdditional(JavaFileObject arg0) { return new Note("compiler", "preview.filename.additional", arg0); }
compiler.note.preview.filename.additional=\ {0} has additional uses of preview language features.
/** * compiler.note.preview.filename.additional=\ * {0} has additional uses of preview language features. */
public static Note PreviewFilenameAdditional(Path arg0) { return new Note("compiler", "preview.filename.additional", arg0); }
compiler.note.preview.plural=\ Some input files use preview language features.
/** * compiler.note.preview.plural=\ * Some input files use preview language features. */
public static final Note PreviewPlural = new Note("compiler", "preview.plural");
compiler.note.preview.plural.additional=\ Some input files additionally use preview language features.
/** * compiler.note.preview.plural.additional=\ * Some input files additionally use preview language features. */
public static final Note PreviewPluralAdditional = new Note("compiler", "preview.plural.additional");
compiler.note.preview.recompile=\ Recompile with -Xlint:preview for details.
/** * compiler.note.preview.recompile=\ * Recompile with -Xlint:preview for details. */
public static final Note PreviewRecompile = new Note("compiler", "preview.recompile");
compiler.note.proc.messager=\ {0}
/** * compiler.note.proc.messager=\ * {0} */
public static Note ProcMessager(String arg0) { return new Note("compiler", "proc.messager", arg0); }
compiler.note.removal.filename=\ {0} uses or overrides a deprecated API that is marked for removal.
/** * compiler.note.removal.filename=\ * {0} uses or overrides a deprecated API that is marked for removal. */
public static Note RemovalFilename(File arg0) { return new Note("compiler", "removal.filename", arg0); }
compiler.note.removal.filename=\ {0} uses or overrides a deprecated API that is marked for removal.
/** * compiler.note.removal.filename=\ * {0} uses or overrides a deprecated API that is marked for removal. */
public static Note RemovalFilename(JavaFileObject arg0) { return new Note("compiler", "removal.filename", arg0); }
compiler.note.removal.filename=\ {0} uses or overrides a deprecated API that is marked for removal.
/** * compiler.note.removal.filename=\ * {0} uses or overrides a deprecated API that is marked for removal. */
public static Note RemovalFilename(Path arg0) { return new Note("compiler", "removal.filename", arg0); }
compiler.note.removal.filename.additional=\ {0} has additional uses or overrides of a deprecated API that is marked for removal.
/** * compiler.note.removal.filename.additional=\ * {0} has additional uses or overrides of a deprecated API that is marked for removal. */
public static Note RemovalFilenameAdditional(File arg0) { return new Note("compiler", "removal.filename.additional", arg0); }
compiler.note.removal.filename.additional=\ {0} has additional uses or overrides of a deprecated API that is marked for removal.
/** * compiler.note.removal.filename.additional=\ * {0} has additional uses or overrides of a deprecated API that is marked for removal. */
public static Note RemovalFilenameAdditional(JavaFileObject arg0) { return new Note("compiler", "removal.filename.additional", arg0); }
compiler.note.removal.filename.additional=\ {0} has additional uses or overrides of a deprecated API that is marked for removal.
/** * compiler.note.removal.filename.additional=\ * {0} has additional uses or overrides of a deprecated API that is marked for removal. */
public static Note RemovalFilenameAdditional(Path arg0) { return new Note("compiler", "removal.filename.additional", arg0); }
compiler.note.removal.plural=\ Some input files use or override a deprecated API that is marked for removal.
/** * compiler.note.removal.plural=\ * Some input files use or override a deprecated API that is marked for removal. */
public static final Note RemovalPlural = new Note("compiler", "removal.plural");
compiler.note.removal.plural.additional=\ Some input files additionally use or override a deprecated API that is marked for removal.
/** * compiler.note.removal.plural.additional=\ * Some input files additionally use or override a deprecated API that is marked for removal. */
public static final Note RemovalPluralAdditional = new Note("compiler", "removal.plural.additional");
compiler.note.removal.recompile=\ Recompile with -Xlint:removal for details.
/** * compiler.note.removal.recompile=\ * Recompile with -Xlint:removal for details. */
public static final Note RemovalRecompile = new Note("compiler", "removal.recompile");
compiler.note.unchecked.filename=\ {0} uses unchecked or unsafe operations.
/** * compiler.note.unchecked.filename=\ * {0} uses unchecked or unsafe operations. */
public static Note UncheckedFilename(File arg0) { return new Note("compiler", "unchecked.filename", arg0); }
compiler.note.unchecked.filename=\ {0} uses unchecked or unsafe operations.
/** * compiler.note.unchecked.filename=\ * {0} uses unchecked or unsafe operations. */
public static Note UncheckedFilename(JavaFileObject arg0) { return new Note("compiler", "unchecked.filename", arg0); }
compiler.note.unchecked.filename=\ {0} uses unchecked or unsafe operations.
/** * compiler.note.unchecked.filename=\ * {0} uses unchecked or unsafe operations. */
public static Note UncheckedFilename(Path arg0) { return new Note("compiler", "unchecked.filename", arg0); }
compiler.note.unchecked.filename.additional=\ {0} has additional unchecked or unsafe operations.
/** * compiler.note.unchecked.filename.additional=\ * {0} has additional unchecked or unsafe operations. */
public static Note UncheckedFilenameAdditional(File arg0) { return new Note("compiler", "unchecked.filename.additional", arg0); }
compiler.note.unchecked.filename.additional=\ {0} has additional unchecked or unsafe operations.
/** * compiler.note.unchecked.filename.additional=\ * {0} has additional unchecked or unsafe operations. */
public static Note UncheckedFilenameAdditional(JavaFileObject arg0) { return new Note("compiler", "unchecked.filename.additional", arg0); }
compiler.note.unchecked.filename.additional=\ {0} has additional unchecked or unsafe operations.
/** * compiler.note.unchecked.filename.additional=\ * {0} has additional unchecked or unsafe operations. */
public static Note UncheckedFilenameAdditional(Path arg0) { return new Note("compiler", "unchecked.filename.additional", arg0); }
compiler.note.unchecked.plural=\ Some input files use unchecked or unsafe operations.
/** * compiler.note.unchecked.plural=\ * Some input files use unchecked or unsafe operations. */
public static final Note UncheckedPlural = new Note("compiler", "unchecked.plural");
compiler.note.unchecked.plural.additional=\ Some input files additionally use unchecked or unsafe operations.
/** * compiler.note.unchecked.plural.additional=\ * Some input files additionally use unchecked or unsafe operations. */
public static final Note UncheckedPluralAdditional = new Note("compiler", "unchecked.plural.additional");
compiler.note.unchecked.recompile=\ Recompile with -Xlint:unchecked for details.
/** * compiler.note.unchecked.recompile=\ * Recompile with -Xlint:unchecked for details. */
public static final Note UncheckedRecompile = new Note("compiler", "unchecked.recompile");
compiler.note.verbose.l2m.deduplicate=\ deduplicating lambda implementation method {0}
/** * compiler.note.verbose.l2m.deduplicate=\ * deduplicating lambda implementation method {0} */
public static Note VerboseL2mDeduplicate(Symbol arg0) { return new Note("compiler", "verbose.l2m.deduplicate", arg0); }
compiler.note.verbose.resolve.multi=\ resolving method {0} in type {1} to candidate {2}\n\ phase: {3}\n\ with actuals: {4}\n\ with type-args: {5}\n\ candidates:
/** * compiler.note.verbose.resolve.multi=\ * resolving method {0} in type {1} to candidate {2}\n\ * phase: {3}\n\ * with actuals: {4}\n\ * with type-args: {5}\n\ * candidates: */
public static Note VerboseResolveMulti(Name arg0, Symbol arg1, int arg2, String arg3, List<? extends Type> arg4, List<? extends Type> arg5) { return new Note("compiler", "verbose.resolve.multi", arg0, arg1, arg2, arg3, arg4, arg5); }
compiler.note.verbose.resolve.multi=\ resolving method {0} in type {1} to candidate {2}\n\ phase: {3}\n\ with actuals: {4}\n\ with type-args: {5}\n\ candidates:
/** * compiler.note.verbose.resolve.multi=\ * resolving method {0} in type {1} to candidate {2}\n\ * phase: {3}\n\ * with actuals: {4}\n\ * with type-args: {5}\n\ * candidates: */
public static Note VerboseResolveMulti(Name arg0, Symbol arg1, int arg2, String arg3, List<? extends Type> arg4, JCDiagnostic arg5) { return new Note("compiler", "verbose.resolve.multi", arg0, arg1, arg2, arg3, arg4, arg5); }
compiler.note.verbose.resolve.multi=\ resolving method {0} in type {1} to candidate {2}\n\ phase: {3}\n\ with actuals: {4}\n\ with type-args: {5}\n\ candidates:
/** * compiler.note.verbose.resolve.multi=\ * resolving method {0} in type {1} to candidate {2}\n\ * phase: {3}\n\ * with actuals: {4}\n\ * with type-args: {5}\n\ * candidates: */
public static Note VerboseResolveMulti(Name arg0, Symbol arg1, int arg2, String arg3, List<? extends Type> arg4, Fragment arg5) { return new Note("compiler", "verbose.resolve.multi", arg0, arg1, arg2, arg3, arg4, arg5); }
compiler.note.verbose.resolve.multi=\ resolving method {0} in type {1} to candidate {2}\n\ phase: {3}\n\ with actuals: {4}\n\ with type-args: {5}\n\ candidates:
/** * compiler.note.verbose.resolve.multi=\ * resolving method {0} in type {1} to candidate {2}\n\ * phase: {3}\n\ * with actuals: {4}\n\ * with type-args: {5}\n\ * candidates: */
public static Note VerboseResolveMulti(Name arg0, Symbol arg1, int arg2, String arg3, JCDiagnostic arg4, List<? extends Type> arg5) { return new Note("compiler", "verbose.resolve.multi", arg0, arg1, arg2, arg3, arg4, arg5); }
compiler.note.verbose.resolve.multi=\ resolving method {0} in type {1} to candidate {2}\n\ phase: {3}\n\ with actuals: {4}\n\ with type-args: {5}\n\ candidates:
/** * compiler.note.verbose.resolve.multi=\ * resolving method {0} in type {1} to candidate {2}\n\ * phase: {3}\n\ * with actuals: {4}\n\ * with type-args: {5}\n\ * candidates: */
public static Note VerboseResolveMulti(Name arg0, Symbol arg1, int arg2, String arg3, JCDiagnostic arg4, JCDiagnostic arg5) { return new Note("compiler", "verbose.resolve.multi", arg0, arg1, arg2, arg3, arg4, arg5); }
compiler.note.verbose.resolve.multi=\ resolving method {0} in type {1} to candidate {2}\n\ phase: {3}\n\ with actuals: {4}\n\ with type-args: {5}\n\ candidates:
/** * compiler.note.verbose.resolve.multi=\ * resolving method {0} in type {1} to candidate {2}\n\ * phase: {3}\n\ * with actuals: {4}\n\ * with type-args: {5}\n\ * candidates: */
public static Note VerboseResolveMulti(Name arg0, Symbol arg1, int arg2, String arg3, JCDiagnostic arg4, Fragment arg5) { return new Note("compiler", "verbose.resolve.multi", arg0, arg1, arg2, arg3, arg4, arg5); }
compiler.note.verbose.resolve.multi=\ resolving method {0} in type {1} to candidate {2}\n\ phase: {3}\n\ with actuals: {4}\n\ with type-args: {5}\n\ candidates:
/** * compiler.note.verbose.resolve.multi=\ * resolving method {0} in type {1} to candidate {2}\n\ * phase: {3}\n\ * with actuals: {4}\n\ * with type-args: {5}\n\ * candidates: */
public static Note VerboseResolveMulti(Name arg0, Symbol arg1, int arg2, String arg3, Fragment arg4, List<? extends Type> arg5) { return new Note("compiler", "verbose.resolve.multi", arg0, arg1, arg2, arg3, arg4, arg5); }
compiler.note.verbose.resolve.multi=\ resolving method {0} in type {1} to candidate {2}\n\ phase: {3}\n\ with actuals: {4}\n\ with type-args: {5}\n\ candidates:
/** * compiler.note.verbose.resolve.multi=\ * resolving method {0} in type {1} to candidate {2}\n\ * phase: {3}\n\ * with actuals: {4}\n\ * with type-args: {5}\n\ * candidates: */
public static Note VerboseResolveMulti(Name arg0, Symbol arg1, int arg2, String arg3, Fragment arg4, JCDiagnostic arg5) { return new Note("compiler", "verbose.resolve.multi", arg0, arg1, arg2, arg3, arg4, arg5); }
compiler.note.verbose.resolve.multi=\ resolving method {0} in type {1} to candidate {2}\n\ phase: {3}\n\ with actuals: {4}\n\ with type-args: {5}\n\ candidates:
/** * compiler.note.verbose.resolve.multi=\ * resolving method {0} in type {1} to candidate {2}\n\ * phase: {3}\n\ * with actuals: {4}\n\ * with type-args: {5}\n\ * candidates: */
public static Note VerboseResolveMulti(Name arg0, Symbol arg1, int arg2, String arg3, Fragment arg4, Fragment arg5) { return new Note("compiler", "verbose.resolve.multi", arg0, arg1, arg2, arg3, arg4, arg5); }
compiler.note.verbose.resolve.multi.1=\ erroneous resolution for method {0} in type {1}\n\ phase: {3}\n\ with actuals: {4}\n\ with type-args: {5}\n\ candidates:
/** * compiler.note.verbose.resolve.multi.1=\ * erroneous resolution for method {0} in type {1}\n\ * phase: {3}\n\ * with actuals: {4}\n\ * with type-args: {5}\n\ * candidates: */
public static Note VerboseResolveMulti1(Name arg0, Symbol arg1, Void arg2, String arg3, List<? extends Type> arg4, List<? extends Type> arg5) { return new Note("compiler", "verbose.resolve.multi.1", arg0, arg1, arg2, arg3, arg4, arg5); }
compiler.note.verbose.resolve.multi.1=\ erroneous resolution for method {0} in type {1}\n\ phase: {3}\n\ with actuals: {4}\n\ with type-args: {5}\n\ candidates:
/** * compiler.note.verbose.resolve.multi.1=\ * erroneous resolution for method {0} in type {1}\n\ * phase: {3}\n\ * with actuals: {4}\n\ * with type-args: {5}\n\ * candidates: */
public static Note VerboseResolveMulti1(Name arg0, Symbol arg1, Void arg2, String arg3, List<? extends Type> arg4, JCDiagnostic arg5) { return new Note("compiler", "verbose.resolve.multi.1", arg0, arg1, arg2, arg3, arg4, arg5); }
compiler.note.verbose.resolve.multi.1=\ erroneous resolution for method {0} in type {1}\n\ phase: {3}\n\ with actuals: {4}\n\ with type-args: {5}\n\ candidates:
/** * compiler.note.verbose.resolve.multi.1=\ * erroneous resolution for method {0} in type {1}\n\ * phase: {3}\n\ * with actuals: {4}\n\ * with type-args: {5}\n\ * candidates: */
public static Note VerboseResolveMulti1(Name arg0, Symbol arg1, Void arg2, String arg3, List<? extends Type> arg4, Fragment arg5) { return new Note("compiler", "verbose.resolve.multi.1", arg0, arg1, arg2, arg3, arg4, arg5); }
compiler.note.verbose.resolve.multi.1=\ erroneous resolution for method {0} in type {1}\n\ phase: {3}\n\ with actuals: {4}\n\ with type-args: {5}\n\ candidates:
/** * compiler.note.verbose.resolve.multi.1=\ * erroneous resolution for method {0} in type {1}\n\ * phase: {3}\n\ * with actuals: {4}\n\ * with type-args: {5}\n\ * candidates: */
public static Note VerboseResolveMulti1(Name arg0, Symbol arg1, Void arg2, String arg3, JCDiagnostic arg4, List<? extends Type> arg5) { return new Note("compiler", "verbose.resolve.multi.1", arg0, arg1, arg2, arg3, arg4, arg5); }
compiler.note.verbose.resolve.multi.1=\ erroneous resolution for method {0} in type {1}\n\ phase: {3}\n\ with actuals: {4}\n\ with type-args: {5}\n\ candidates:
/** * compiler.note.verbose.resolve.multi.1=\ * erroneous resolution for method {0} in type {1}\n\ * phase: {3}\n\ * with actuals: {4}\n\ * with type-args: {5}\n\ * candidates: */
public static Note VerboseResolveMulti1(Name arg0, Symbol arg1, Void arg2, String arg3, JCDiagnostic arg4, JCDiagnostic arg5) { return new Note("compiler", "verbose.resolve.multi.1", arg0, arg1, arg2, arg3, arg4, arg5); }
compiler.note.verbose.resolve.multi.1=\ erroneous resolution for method {0} in type {1}\n\ phase: {3}\n\ with actuals: {4}\n\ with type-args: {5}\n\ candidates:
/** * compiler.note.verbose.resolve.multi.1=\ * erroneous resolution for method {0} in type {1}\n\ * phase: {3}\n\ * with actuals: {4}\n\ * with type-args: {5}\n\ * candidates: */
public static Note VerboseResolveMulti1(Name arg0, Symbol arg1, Void arg2, String arg3, JCDiagnostic arg4, Fragment arg5) { return new Note("compiler", "verbose.resolve.multi.1", arg0, arg1, arg2, arg3, arg4, arg5); }
compiler.note.verbose.resolve.multi.1=\ erroneous resolution for method {0} in type {1}\n\ phase: {3}\n\ with actuals: {4}\n\ with type-args: {5}\n\ candidates:
/** * compiler.note.verbose.resolve.multi.1=\ * erroneous resolution for method {0} in type {1}\n\ * phase: {3}\n\ * with actuals: {4}\n\ * with type-args: {5}\n\ * candidates: */
public static Note VerboseResolveMulti1(Name arg0, Symbol arg1, Void arg2, String arg3, Fragment arg4, List<? extends Type> arg5) { return new Note("compiler", "verbose.resolve.multi.1", arg0, arg1, arg2, arg3, arg4, arg5); }
compiler.note.verbose.resolve.multi.1=\ erroneous resolution for method {0} in type {1}\n\ phase: {3}\n\ with actuals: {4}\n\ with type-args: {5}\n\ candidates:
/** * compiler.note.verbose.resolve.multi.1=\ * erroneous resolution for method {0} in type {1}\n\ * phase: {3}\n\ * with actuals: {4}\n\ * with type-args: {5}\n\ * candidates: */
public static Note VerboseResolveMulti1(Name arg0, Symbol arg1, Void arg2, String arg3, Fragment arg4, JCDiagnostic arg5) { return new Note("compiler", "verbose.resolve.multi.1", arg0, arg1, arg2, arg3, arg4, arg5); }
compiler.note.verbose.resolve.multi.1=\ erroneous resolution for method {0} in type {1}\n\ phase: {3}\n\ with actuals: {4}\n\ with type-args: {5}\n\ candidates:
/** * compiler.note.verbose.resolve.multi.1=\ * erroneous resolution for method {0} in type {1}\n\ * phase: {3}\n\ * with actuals: {4}\n\ * with type-args: {5}\n\ * candidates: */
public static Note VerboseResolveMulti1(Name arg0, Symbol arg1, Void arg2, String arg3, Fragment arg4, Fragment arg5) { return new Note("compiler", "verbose.resolve.multi.1", arg0, arg1, arg2, arg3, arg4, arg5); } } public static class Fragments {
compiler.misc.accessor.method.cant.throw.exception=\ throws clause not allowed for accessor method
/** * compiler.misc.accessor.method.cant.throw.exception=\ * throws clause not allowed for accessor method */
public static final Fragment AccessorMethodCantThrowException = new Fragment("compiler", "accessor.method.cant.throw.exception");
compiler.misc.accessor.method.must.not.be.generic=\ accessor method must not be generic
/** * compiler.misc.accessor.method.must.not.be.generic=\ * accessor method must not be generic */
public static final Fragment AccessorMethodMustNotBeGeneric = new Fragment("compiler", "accessor.method.must.not.be.generic");
compiler.misc.accessor.method.must.not.be.static=\ accessor method must not be static
/** * compiler.misc.accessor.method.must.not.be.static=\ * accessor method must not be static */
public static final Fragment AccessorMethodMustNotBeStatic = new Fragment("compiler", "accessor.method.must.not.be.static");
compiler.misc.accessor.return.type.doesnt.match=\ return type of accessor method {0} must match the type of record component {1}
/** * compiler.misc.accessor.return.type.doesnt.match=\ * return type of accessor method {0} must match the type of record component {1} */
public static Fragment AccessorReturnTypeDoesntMatch(Symbol arg0, Symbol arg1) { return new Fragment("compiler", "accessor.return.type.doesnt.match", arg0, arg1); }
compiler.misc.anachronistic.module.info=\ module declaration found in version {0}.{1} classfile
/** * compiler.misc.anachronistic.module.info=\ * module declaration found in version {0}.{1} classfile */
public static Fragment AnachronisticModuleInfo(String arg0, String arg1) { return new Fragment("compiler", "anachronistic.module.info", arg0, arg1); }
compiler.misc.anonymous=\ anonymous
/** * compiler.misc.anonymous=\ * anonymous */
public static final Fragment Anonymous = new Fragment("compiler", "anonymous");
compiler.misc.anonymous.class=\
/** * compiler.misc.anonymous.class=\ * <anonymous {0}> */
public static Fragment AnonymousClass(Name arg0) { return new Fragment("compiler", "anonymous.class", arg0); }
compiler.misc.applicable.method.found=\
/** * compiler.misc.applicable.method.found=\ */
public static Fragment ApplicableMethodFound(int arg0, Symbol arg1, Void arg2) { return new Fragment("compiler", "applicable.method.found", arg0, arg1, arg2); }
compiler.misc.applicable.method.found.1=\ ({2})
/** * compiler.misc.applicable.method.found.1=\ * ({2}) */
public static Fragment ApplicableMethodFound1(int arg0, Symbol arg1, JCDiagnostic arg2) { return new Fragment("compiler", "applicable.method.found.1", arg0, arg1, arg2); }
compiler.misc.applicable.method.found.1=\ ({2})
/** * compiler.misc.applicable.method.found.1=\ * ({2}) */
public static Fragment ApplicableMethodFound1(int arg0, Symbol arg1, Fragment arg2) { return new Fragment("compiler", "applicable.method.found.1", arg0, arg1, arg2); }
compiler.misc.applicable.method.found.2=\
/** * compiler.misc.applicable.method.found.2=\ */
public static Fragment ApplicableMethodFound2(int arg0, Fragment arg1, Symbol arg2) { return new Fragment("compiler", "applicable.method.found.2", arg0, arg1, arg2); }
compiler.misc.applicable.method.found.3=\ ({3})
/** * compiler.misc.applicable.method.found.3=\ * ({3}) */
public static Fragment ApplicableMethodFound3(int arg0, Fragment arg1, Symbol arg2, JCDiagnostic arg3) { return new Fragment("compiler", "applicable.method.found.3", arg0, arg1, arg2, arg3); }
compiler.misc.applicable.method.found.3=\ ({3})
/** * compiler.misc.applicable.method.found.3=\ * ({3}) */
public static Fragment ApplicableMethodFound3(int arg0, Fragment arg1, Symbol arg2, Fragment arg3) { return new Fragment("compiler", "applicable.method.found.3", arg0, arg1, arg2, arg3); }
compiler.misc.arg.length.mismatch=\ actual and formal argument lists differ in length
/** * compiler.misc.arg.length.mismatch=\ * actual and formal argument lists differ in length */
public static final Fragment ArgLengthMismatch = new Fragment("compiler", "arg.length.mismatch");
compiler.misc.bad.class.file=\ class file is invalid for class {0}
/** * compiler.misc.bad.class.file=\ * class file is invalid for class {0} */
public static Fragment BadClassFile(Name arg0) { return new Fragment("compiler", "bad.class.file", arg0); }
compiler.misc.bad.class.file.header=\ bad class file: {0}\n\ {1}\n\ Please remove or make sure it appears in the correct subdirectory of the classpath.
/** * compiler.misc.bad.class.file.header=\ * bad class file: {0}\n\ * {1}\n\ * Please remove or make sure it appears in the correct subdirectory of the classpath. */
public static Fragment BadClassFileHeader(File arg0, JCDiagnostic arg1) { return new Fragment("compiler", "bad.class.file.header", arg0, arg1); }
compiler.misc.bad.class.file.header=\ bad class file: {0}\n\ {1}\n\ Please remove or make sure it appears in the correct subdirectory of the classpath.
/** * compiler.misc.bad.class.file.header=\ * bad class file: {0}\n\ * {1}\n\ * Please remove or make sure it appears in the correct subdirectory of the classpath. */
public static Fragment BadClassFileHeader(File arg0, Fragment arg1) { return new Fragment("compiler", "bad.class.file.header", arg0, arg1); }
compiler.misc.bad.class.file.header=\ bad class file: {0}\n\ {1}\n\ Please remove or make sure it appears in the correct subdirectory of the classpath.
/** * compiler.misc.bad.class.file.header=\ * bad class file: {0}\n\ * {1}\n\ * Please remove or make sure it appears in the correct subdirectory of the classpath. */
public static Fragment BadClassFileHeader(JavaFileObject arg0, JCDiagnostic arg1) { return new Fragment("compiler", "bad.class.file.header", arg0, arg1); }
compiler.misc.bad.class.file.header=\ bad class file: {0}\n\ {1}\n\ Please remove or make sure it appears in the correct subdirectory of the classpath.
/** * compiler.misc.bad.class.file.header=\ * bad class file: {0}\n\ * {1}\n\ * Please remove or make sure it appears in the correct subdirectory of the classpath. */
public static Fragment BadClassFileHeader(JavaFileObject arg0, Fragment arg1) { return new Fragment("compiler", "bad.class.file.header", arg0, arg1); }
compiler.misc.bad.class.file.header=\ bad class file: {0}\n\ {1}\n\ Please remove or make sure it appears in the correct subdirectory of the classpath.
/** * compiler.misc.bad.class.file.header=\ * bad class file: {0}\n\ * {1}\n\ * Please remove or make sure it appears in the correct subdirectory of the classpath. */
public static Fragment BadClassFileHeader(Path arg0, JCDiagnostic arg1) { return new Fragment("compiler", "bad.class.file.header", arg0, arg1); }
compiler.misc.bad.class.file.header=\ bad class file: {0}\n\ {1}\n\ Please remove or make sure it appears in the correct subdirectory of the classpath.
/** * compiler.misc.bad.class.file.header=\ * bad class file: {0}\n\ * {1}\n\ * Please remove or make sure it appears in the correct subdirectory of the classpath. */
public static Fragment BadClassFileHeader(Path arg0, Fragment arg1) { return new Fragment("compiler", "bad.class.file.header", arg0, arg1); }
compiler.misc.bad.class.signature=\ bad class signature: {0}
/** * compiler.misc.bad.class.signature=\ * bad class signature: {0} */
public static final Fragment BadClassSignature = new Fragment("compiler", "bad.class.signature");
compiler.misc.bad.const.pool.entry=\ bad constant pool entry in {0}\n\ expected {1} at index {2}
/** * compiler.misc.bad.const.pool.entry=\ * bad constant pool entry in {0}\n\ * expected {1} at index {2} */
public static Fragment BadConstPoolEntry(File arg0, String arg1, int arg2) { return new Fragment("compiler", "bad.const.pool.entry", arg0, arg1, arg2); }
compiler.misc.bad.const.pool.entry=\ bad constant pool entry in {0}\n\ expected {1} at index {2}
/** * compiler.misc.bad.const.pool.entry=\ * bad constant pool entry in {0}\n\ * expected {1} at index {2} */
public static Fragment BadConstPoolEntry(JavaFileObject arg0, String arg1, int arg2) { return new Fragment("compiler", "bad.const.pool.entry", arg0, arg1, arg2); }
compiler.misc.bad.const.pool.entry=\ bad constant pool entry in {0}\n\ expected {1} at index {2}
/** * compiler.misc.bad.const.pool.entry=\ * bad constant pool entry in {0}\n\ * expected {1} at index {2} */
public static Fragment BadConstPoolEntry(Path arg0, String arg1, int arg2) { return new Fragment("compiler", "bad.const.pool.entry", arg0, arg1, arg2); }
compiler.misc.bad.const.pool.index=\ bad constant pool index in {0}\n\ index {1} is not within pool size {2}.
/** * compiler.misc.bad.const.pool.index=\ * bad constant pool index in {0}\n\ * index {1} is not within pool size {2}. */
public static Fragment BadConstPoolIndex(File arg0, int arg1, int arg2) { return new Fragment("compiler", "bad.const.pool.index", arg0, arg1, arg2); }
compiler.misc.bad.const.pool.index=\ bad constant pool index in {0}\n\ index {1} is not within pool size {2}.
/** * compiler.misc.bad.const.pool.index=\ * bad constant pool index in {0}\n\ * index {1} is not within pool size {2}. */
public static Fragment BadConstPoolIndex(JavaFileObject arg0, int arg1, int arg2) { return new Fragment("compiler", "bad.const.pool.index", arg0, arg1, arg2); }
compiler.misc.bad.const.pool.index=\ bad constant pool index in {0}\n\ index {1} is not within pool size {2}.
/** * compiler.misc.bad.const.pool.index=\ * bad constant pool index in {0}\n\ * index {1} is not within pool size {2}. */
public static Fragment BadConstPoolIndex(Path arg0, int arg1, int arg2) { return new Fragment("compiler", "bad.const.pool.index", arg0, arg1, arg2); }
compiler.misc.bad.const.pool.tag=\ bad constant pool tag: {0}
/** * compiler.misc.bad.const.pool.tag=\ * bad constant pool tag: {0} */
public static final Fragment BadConstPoolTag = new Fragment("compiler", "bad.const.pool.tag");
compiler.misc.bad.const.pool.tag.at=\ bad constant pool tag: {0} at {1}
/** * compiler.misc.bad.const.pool.tag.at=\ * bad constant pool tag: {0} at {1} */
public static final Fragment BadConstPoolTagAt = new Fragment("compiler", "bad.const.pool.tag.at");
compiler.misc.bad.constant.range=\ constant value ''{0}'' for {1} is outside the expected range for {2}
/** * compiler.misc.bad.constant.range=\ * constant value ''{0}'' for {1} is outside the expected range for {2} */
public static Fragment BadConstantRange(String arg0, Symbol arg1, Type arg2) { return new Fragment("compiler", "bad.constant.range", arg0, arg1, arg2); }
compiler.misc.bad.constant.value=\ bad constant value ''{0}'' for {1}, expected {2}
/** * compiler.misc.bad.constant.value=\ * bad constant value ''{0}'' for {1}, expected {2} */
public static Fragment BadConstantValue(String arg0, Symbol arg1, String arg2) { return new Fragment("compiler", "bad.constant.value", arg0, arg1, arg2); }
compiler.misc.bad.constant.value.type=\ variable of type ''{0}'' cannot have a constant value, but has one specified
/** * compiler.misc.bad.constant.value.type=\ * variable of type ''{0}'' cannot have a constant value, but has one specified */
public static Fragment BadConstantValueType(Type arg0) { return new Fragment("compiler", "bad.constant.value.type", arg0); }
compiler.misc.bad.enclosing.class=\ bad enclosing class for {0}: {1}
/** * compiler.misc.bad.enclosing.class=\ * bad enclosing class for {0}: {1} */
public static final Fragment BadEnclosingClass = new Fragment("compiler", "bad.enclosing.class");
compiler.misc.bad.enclosing.method=\ bad enclosing method attribute for class {0}
/** * compiler.misc.bad.enclosing.method=\ * bad enclosing method attribute for class {0} */
public static Fragment BadEnclosingMethod(Symbol arg0) { return new Fragment("compiler", "bad.enclosing.method", arg0); }
compiler.misc.bad.instance.method.in.unbound.lookup=\ unexpected instance {0} {1} found in unbound lookup
/** * compiler.misc.bad.instance.method.in.unbound.lookup=\ * unexpected instance {0} {1} found in unbound lookup */
public static Fragment BadInstanceMethodInUnboundLookup(Kind arg0, Symbol arg1) { return new Fragment("compiler", "bad.instance.method.in.unbound.lookup", arg0, arg1); }
compiler.misc.bad.intersection.target.for.functional.expr=\ bad intersection type target for lambda or method reference\n\ {0}
/** * compiler.misc.bad.intersection.target.for.functional.expr=\ * bad intersection type target for lambda or method reference\n\ * {0} */
public static Fragment BadIntersectionTargetForFunctionalExpr(JCDiagnostic arg0) { return new Fragment("compiler", "bad.intersection.target.for.functional.expr", arg0); }
compiler.misc.bad.intersection.target.for.functional.expr=\ bad intersection type target for lambda or method reference\n\ {0}
/** * compiler.misc.bad.intersection.target.for.functional.expr=\ * bad intersection type target for lambda or method reference\n\ * {0} */
public static Fragment BadIntersectionTargetForFunctionalExpr(Fragment arg0) { return new Fragment("compiler", "bad.intersection.target.for.functional.expr", arg0); }
compiler.misc.bad.module-info.name=\ bad class name
/** * compiler.misc.bad.module-info.name=\ * bad class name */
public static final Fragment BadModuleInfoName = new Fragment("compiler", "bad.module-info.name");
compiler.misc.bad.requires.flag=\ bad requires flag: {0}
/** * compiler.misc.bad.requires.flag=\ * bad requires flag: {0} */
public static final Fragment BadRequiresFlag = new Fragment("compiler", "bad.requires.flag");
compiler.misc.bad.runtime.invisible.param.annotations=\ bad RuntimeInvisibleParameterAnnotations attribute: {0}
/** * compiler.misc.bad.runtime.invisible.param.annotations=\ * bad RuntimeInvisibleParameterAnnotations attribute: {0} */
public static final Fragment BadRuntimeInvisibleParamAnnotations = new Fragment("compiler", "bad.runtime.invisible.param.annotations");
compiler.misc.bad.signature=\ bad signature: {0}
/** * compiler.misc.bad.signature=\ * bad signature: {0} */
public static final Fragment BadSignature = new Fragment("compiler", "bad.signature");
compiler.misc.bad.source.file.header=\ bad source file: {0}\n\ {1}\n\ Please remove or make sure it appears in the correct subdirectory of the sourcepath.
/** * compiler.misc.bad.source.file.header=\ * bad source file: {0}\n\ * {1}\n\ * Please remove or make sure it appears in the correct subdirectory of the sourcepath. */
public static Fragment BadSourceFileHeader(File arg0, JCDiagnostic arg1) { return new Fragment("compiler", "bad.source.file.header", arg0, arg1); }
compiler.misc.bad.source.file.header=\ bad source file: {0}\n\ {1}\n\ Please remove or make sure it appears in the correct subdirectory of the sourcepath.
/** * compiler.misc.bad.source.file.header=\ * bad source file: {0}\n\ * {1}\n\ * Please remove or make sure it appears in the correct subdirectory of the sourcepath. */
public static Fragment BadSourceFileHeader(File arg0, Fragment arg1) { return new Fragment("compiler", "bad.source.file.header", arg0, arg1); }
compiler.misc.bad.source.file.header=\ bad source file: {0}\n\ {1}\n\ Please remove or make sure it appears in the correct subdirectory of the sourcepath.
/** * compiler.misc.bad.source.file.header=\ * bad source file: {0}\n\ * {1}\n\ * Please remove or make sure it appears in the correct subdirectory of the sourcepath. */
public static Fragment BadSourceFileHeader(JavaFileObject arg0, JCDiagnostic arg1) { return new Fragment("compiler", "bad.source.file.header", arg0, arg1); }
compiler.misc.bad.source.file.header=\ bad source file: {0}\n\ {1}\n\ Please remove or make sure it appears in the correct subdirectory of the sourcepath.
/** * compiler.misc.bad.source.file.header=\ * bad source file: {0}\n\ * {1}\n\ * Please remove or make sure it appears in the correct subdirectory of the sourcepath. */
public static Fragment BadSourceFileHeader(JavaFileObject arg0, Fragment arg1) { return new Fragment("compiler", "bad.source.file.header", arg0, arg1); }
compiler.misc.bad.source.file.header=\ bad source file: {0}\n\ {1}\n\ Please remove or make sure it appears in the correct subdirectory of the sourcepath.
/** * compiler.misc.bad.source.file.header=\ * bad source file: {0}\n\ * {1}\n\ * Please remove or make sure it appears in the correct subdirectory of the sourcepath. */
public static Fragment BadSourceFileHeader(Path arg0, JCDiagnostic arg1) { return new Fragment("compiler", "bad.source.file.header", arg0, arg1); }
compiler.misc.bad.source.file.header=\ bad source file: {0}\n\ {1}\n\ Please remove or make sure it appears in the correct subdirectory of the sourcepath.
/** * compiler.misc.bad.source.file.header=\ * bad source file: {0}\n\ * {1}\n\ * Please remove or make sure it appears in the correct subdirectory of the sourcepath. */
public static Fragment BadSourceFileHeader(Path arg0, Fragment arg1) { return new Fragment("compiler", "bad.source.file.header", arg0, arg1); }
compiler.misc.bad.static.method.in.bound.lookup=\ unexpected static {0} {1} found in bound lookup
/** * compiler.misc.bad.static.method.in.bound.lookup=\ * unexpected static {0} {1} found in bound lookup */
public static Fragment BadStaticMethodInBoundLookup(Kind arg0, Symbol arg1) { return new Fragment("compiler", "bad.static.method.in.bound.lookup", arg0, arg1); }
compiler.misc.bad.static.method.in.unbound.lookup=\ unexpected static {0} {1} found in unbound lookup
/** * compiler.misc.bad.static.method.in.unbound.lookup=\ * unexpected static {0} {1} found in unbound lookup */
public static Fragment BadStaticMethodInUnboundLookup(Kind arg0, Symbol arg1) { return new Fragment("compiler", "bad.static.method.in.unbound.lookup", arg0, arg1); }
compiler.misc.bad.type.annotation.value=\ bad type annotation target type value: {0}
/** * compiler.misc.bad.type.annotation.value=\ * bad type annotation target type value: {0} */
public static final Fragment BadTypeAnnotationValue = new Fragment("compiler", "bad.type.annotation.value");
compiler.misc.base.membership=\ all your base class are belong to us
/** * compiler.misc.base.membership=\ * all your base class are belong to us */
public static final Fragment BaseMembership = new Fragment("compiler", "base.membership");
compiler.misc.bound=\ bound
/** * compiler.misc.bound=\ * bound */
public static final Fragment Bound = new Fragment("compiler", "bound");
compiler.misc.canonical=\ canonical
/** * compiler.misc.canonical=\ * canonical */
public static final Fragment Canonical = new Fragment("compiler", "canonical");
compiler.misc.canonical.cant.have.return.statement=\ compact constructor must not have return statements
/** * compiler.misc.canonical.cant.have.return.statement=\ * compact constructor must not have return statements */
public static final Fragment CanonicalCantHaveReturnStatement = new Fragment("compiler", "canonical.cant.have.return.statement");
compiler.misc.canonical.must.not.contain.explicit.constructor.invocation=\ canonical constructor must not contain explicit constructor invocation
/** * compiler.misc.canonical.must.not.contain.explicit.constructor.invocation=\ * canonical constructor must not contain explicit constructor invocation */
public static final Fragment CanonicalMustNotContainExplicitConstructorInvocation = new Fragment("compiler", "canonical.must.not.contain.explicit.constructor.invocation");
compiler.misc.canonical.must.not.declare.type.variables=\ canonical constructor must not declare type variables
/** * compiler.misc.canonical.must.not.declare.type.variables=\ * canonical constructor must not declare type variables */
public static final Fragment CanonicalMustNotDeclareTypeVariables = new Fragment("compiler", "canonical.must.not.declare.type.variables");
compiler.misc.canonical.must.not.have.stronger.access=\ attempting to assign stronger access privileges; was {0}
/** * compiler.misc.canonical.must.not.have.stronger.access=\ * attempting to assign stronger access privileges; was {0} */
public static Fragment CanonicalMustNotHaveStrongerAccess(Set<? extends Flag> arg0) { return new Fragment("compiler", "canonical.must.not.have.stronger.access", arg0); }
compiler.misc.canonical.must.not.have.stronger.access=\ attempting to assign stronger access privileges; was {0}
/** * compiler.misc.canonical.must.not.have.stronger.access=\ * attempting to assign stronger access privileges; was {0} */
public static Fragment CanonicalMustNotHaveStrongerAccess(String arg0) { return new Fragment("compiler", "canonical.must.not.have.stronger.access", arg0); }
compiler.misc.canonical.with.name.mismatch=\ invalid parameter names in canonical constructor
/** * compiler.misc.canonical.with.name.mismatch=\ * invalid parameter names in canonical constructor */
public static final Fragment CanonicalWithNameMismatch = new Fragment("compiler", "canonical.with.name.mismatch");
compiler.misc.cant.access.inner.cls.constr=\ cannot access constructor {0}({1})\n\ an enclosing instance of type {2} is not in scope
/** * compiler.misc.cant.access.inner.cls.constr=\ * cannot access constructor {0}({1})\n\ * an enclosing instance of type {2} is not in scope */
public static Fragment CantAccessInnerClsConstr(Symbol arg0, List<? extends Type> arg1, Type arg2) { return new Fragment("compiler", "cant.access.inner.cls.constr", arg0, arg1, arg2); }
compiler.misc.cant.apply.diamond.1=\ cannot infer type arguments for {0}\n\ reason: {1}
/** * compiler.misc.cant.apply.diamond.1=\ * cannot infer type arguments for {0}\n\ * reason: {1} */
public static Fragment CantApplyDiamond1(JCDiagnostic arg0, JCDiagnostic arg1) { return new Fragment("compiler", "cant.apply.diamond.1", arg0, arg1); }
compiler.misc.cant.apply.diamond.1=\ cannot infer type arguments for {0}\n\ reason: {1}
/** * compiler.misc.cant.apply.diamond.1=\ * cannot infer type arguments for {0}\n\ * reason: {1} */
public static Fragment CantApplyDiamond1(JCDiagnostic arg0, Fragment arg1) { return new Fragment("compiler", "cant.apply.diamond.1", arg0, arg1); }
compiler.misc.cant.apply.diamond.1=\ cannot infer type arguments for {0}\n\ reason: {1}
/** * compiler.misc.cant.apply.diamond.1=\ * cannot infer type arguments for {0}\n\ * reason: {1} */
public static Fragment CantApplyDiamond1(Fragment arg0, JCDiagnostic arg1) { return new Fragment("compiler", "cant.apply.diamond.1", arg0, arg1); }
compiler.misc.cant.apply.diamond.1=\ cannot infer type arguments for {0}\n\ reason: {1}
/** * compiler.misc.cant.apply.diamond.1=\ * cannot infer type arguments for {0}\n\ * reason: {1} */
public static Fragment CantApplyDiamond1(Fragment arg0, Fragment arg1) { return new Fragment("compiler", "cant.apply.diamond.1", arg0, arg1); }
compiler.misc.cant.apply.diamond.1=\ cannot infer type arguments for {0}\n\ reason: {1}
/** * compiler.misc.cant.apply.diamond.1=\ * cannot infer type arguments for {0}\n\ * reason: {1} */
public static Fragment CantApplyDiamond1(Type arg0, JCDiagnostic arg1) { return new Fragment("compiler", "cant.apply.diamond.1", arg0, arg1); }
compiler.misc.cant.apply.diamond.1=\ cannot infer type arguments for {0}\n\ reason: {1}
/** * compiler.misc.cant.apply.diamond.1=\ * cannot infer type arguments for {0}\n\ * reason: {1} */
public static Fragment CantApplyDiamond1(Type arg0, Fragment arg1) { return new Fragment("compiler", "cant.apply.diamond.1", arg0, arg1); }
compiler.misc.cant.apply.symbol=\ {0} {1} in {4} {5} cannot be applied to given types\n\ required: {2}\n\ found: {3}\n\ reason: {6}
/** * compiler.misc.cant.apply.symbol=\ * {0} {1} in {4} {5} cannot be applied to given types\n\ * required: {2}\n\ * found: {3}\n\ * reason: {6} */
public static Fragment CantApplySymbol(Kind arg0, Name arg1, List<? extends Type> arg2, List<? extends Type> arg3, Kind arg4, Type arg5, JCDiagnostic arg6) { return new Fragment("compiler", "cant.apply.symbol", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.misc.cant.apply.symbol=\ {0} {1} in {4} {5} cannot be applied to given types\n\ required: {2}\n\ found: {3}\n\ reason: {6}
/** * compiler.misc.cant.apply.symbol=\ * {0} {1} in {4} {5} cannot be applied to given types\n\ * required: {2}\n\ * found: {3}\n\ * reason: {6} */
public static Fragment CantApplySymbol(Kind arg0, Name arg1, List<? extends Type> arg2, List<? extends Type> arg3, Kind arg4, Type arg5, Fragment arg6) { return new Fragment("compiler", "cant.apply.symbol", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.misc.cant.apply.symbol=\ {0} {1} in {4} {5} cannot be applied to given types\n\ required: {2}\n\ found: {3}\n\ reason: {6}
/** * compiler.misc.cant.apply.symbol=\ * {0} {1} in {4} {5} cannot be applied to given types\n\ * required: {2}\n\ * found: {3}\n\ * reason: {6} */
public static Fragment CantApplySymbol(Kind arg0, Name arg1, List<? extends Type> arg2, JCDiagnostic arg3, Kind arg4, Type arg5, JCDiagnostic arg6) { return new Fragment("compiler", "cant.apply.symbol", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.misc.cant.apply.symbol=\ {0} {1} in {4} {5} cannot be applied to given types\n\ required: {2}\n\ found: {3}\n\ reason: {6}
/** * compiler.misc.cant.apply.symbol=\ * {0} {1} in {4} {5} cannot be applied to given types\n\ * required: {2}\n\ * found: {3}\n\ * reason: {6} */
public static Fragment CantApplySymbol(Kind arg0, Name arg1, List<? extends Type> arg2, JCDiagnostic arg3, Kind arg4, Type arg5, Fragment arg6) { return new Fragment("compiler", "cant.apply.symbol", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.misc.cant.apply.symbol=\ {0} {1} in {4} {5} cannot be applied to given types\n\ required: {2}\n\ found: {3}\n\ reason: {6}
/** * compiler.misc.cant.apply.symbol=\ * {0} {1} in {4} {5} cannot be applied to given types\n\ * required: {2}\n\ * found: {3}\n\ * reason: {6} */
public static Fragment CantApplySymbol(Kind arg0, Name arg1, List<? extends Type> arg2, Fragment arg3, Kind arg4, Type arg5, JCDiagnostic arg6) { return new Fragment("compiler", "cant.apply.symbol", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.misc.cant.apply.symbol=\ {0} {1} in {4} {5} cannot be applied to given types\n\ required: {2}\n\ found: {3}\n\ reason: {6}
/** * compiler.misc.cant.apply.symbol=\ * {0} {1} in {4} {5} cannot be applied to given types\n\ * required: {2}\n\ * found: {3}\n\ * reason: {6} */
public static Fragment CantApplySymbol(Kind arg0, Name arg1, List<? extends Type> arg2, Fragment arg3, Kind arg4, Type arg5, Fragment arg6) { return new Fragment("compiler", "cant.apply.symbol", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.misc.cant.apply.symbol=\ {0} {1} in {4} {5} cannot be applied to given types\n\ required: {2}\n\ found: {3}\n\ reason: {6}
/** * compiler.misc.cant.apply.symbol=\ * {0} {1} in {4} {5} cannot be applied to given types\n\ * required: {2}\n\ * found: {3}\n\ * reason: {6} */
public static Fragment CantApplySymbol(Kind arg0, Name arg1, JCDiagnostic arg2, List<? extends Type> arg3, Kind arg4, Type arg5, JCDiagnostic arg6) { return new Fragment("compiler", "cant.apply.symbol", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.misc.cant.apply.symbol=\ {0} {1} in {4} {5} cannot be applied to given types\n\ required: {2}\n\ found: {3}\n\ reason: {6}
/** * compiler.misc.cant.apply.symbol=\ * {0} {1} in {4} {5} cannot be applied to given types\n\ * required: {2}\n\ * found: {3}\n\ * reason: {6} */
public static Fragment CantApplySymbol(Kind arg0, Name arg1, JCDiagnostic arg2, List<? extends Type> arg3, Kind arg4, Type arg5, Fragment arg6) { return new Fragment("compiler", "cant.apply.symbol", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.misc.cant.apply.symbol=\ {0} {1} in {4} {5} cannot be applied to given types\n\ required: {2}\n\ found: {3}\n\ reason: {6}
/** * compiler.misc.cant.apply.symbol=\ * {0} {1} in {4} {5} cannot be applied to given types\n\ * required: {2}\n\ * found: {3}\n\ * reason: {6} */
public static Fragment CantApplySymbol(Kind arg0, Name arg1, JCDiagnostic arg2, JCDiagnostic arg3, Kind arg4, Type arg5, JCDiagnostic arg6) { return new Fragment("compiler", "cant.apply.symbol", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.misc.cant.apply.symbol=\ {0} {1} in {4} {5} cannot be applied to given types\n\ required: {2}\n\ found: {3}\n\ reason: {6}
/** * compiler.misc.cant.apply.symbol=\ * {0} {1} in {4} {5} cannot be applied to given types\n\ * required: {2}\n\ * found: {3}\n\ * reason: {6} */
public static Fragment CantApplySymbol(Kind arg0, Name arg1, JCDiagnostic arg2, JCDiagnostic arg3, Kind arg4, Type arg5, Fragment arg6) { return new Fragment("compiler", "cant.apply.symbol", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.misc.cant.apply.symbol=\ {0} {1} in {4} {5} cannot be applied to given types\n\ required: {2}\n\ found: {3}\n\ reason: {6}
/** * compiler.misc.cant.apply.symbol=\ * {0} {1} in {4} {5} cannot be applied to given types\n\ * required: {2}\n\ * found: {3}\n\ * reason: {6} */
public static Fragment CantApplySymbol(Kind arg0, Name arg1, JCDiagnostic arg2, Fragment arg3, Kind arg4, Type arg5, JCDiagnostic arg6) { return new Fragment("compiler", "cant.apply.symbol", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.misc.cant.apply.symbol=\ {0} {1} in {4} {5} cannot be applied to given types\n\ required: {2}\n\ found: {3}\n\ reason: {6}
/** * compiler.misc.cant.apply.symbol=\ * {0} {1} in {4} {5} cannot be applied to given types\n\ * required: {2}\n\ * found: {3}\n\ * reason: {6} */
public static Fragment CantApplySymbol(Kind arg0, Name arg1, JCDiagnostic arg2, Fragment arg3, Kind arg4, Type arg5, Fragment arg6) { return new Fragment("compiler", "cant.apply.symbol", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.misc.cant.apply.symbol=\ {0} {1} in {4} {5} cannot be applied to given types\n\ required: {2}\n\ found: {3}\n\ reason: {6}
/** * compiler.misc.cant.apply.symbol=\ * {0} {1} in {4} {5} cannot be applied to given types\n\ * required: {2}\n\ * found: {3}\n\ * reason: {6} */
public static Fragment CantApplySymbol(Kind arg0, Name arg1, Fragment arg2, List<? extends Type> arg3, Kind arg4, Type arg5, JCDiagnostic arg6) { return new Fragment("compiler", "cant.apply.symbol", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.misc.cant.apply.symbol=\ {0} {1} in {4} {5} cannot be applied to given types\n\ required: {2}\n\ found: {3}\n\ reason: {6}
/** * compiler.misc.cant.apply.symbol=\ * {0} {1} in {4} {5} cannot be applied to given types\n\ * required: {2}\n\ * found: {3}\n\ * reason: {6} */
public static Fragment CantApplySymbol(Kind arg0, Name arg1, Fragment arg2, List<? extends Type> arg3, Kind arg4, Type arg5, Fragment arg6) { return new Fragment("compiler", "cant.apply.symbol", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.misc.cant.apply.symbol=\ {0} {1} in {4} {5} cannot be applied to given types\n\ required: {2}\n\ found: {3}\n\ reason: {6}
/** * compiler.misc.cant.apply.symbol=\ * {0} {1} in {4} {5} cannot be applied to given types\n\ * required: {2}\n\ * found: {3}\n\ * reason: {6} */
public static Fragment CantApplySymbol(Kind arg0, Name arg1, Fragment arg2, JCDiagnostic arg3, Kind arg4, Type arg5, JCDiagnostic arg6) { return new Fragment("compiler", "cant.apply.symbol", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.misc.cant.apply.symbol=\ {0} {1} in {4} {5} cannot be applied to given types\n\ required: {2}\n\ found: {3}\n\ reason: {6}
/** * compiler.misc.cant.apply.symbol=\ * {0} {1} in {4} {5} cannot be applied to given types\n\ * required: {2}\n\ * found: {3}\n\ * reason: {6} */
public static Fragment CantApplySymbol(Kind arg0, Name arg1, Fragment arg2, JCDiagnostic arg3, Kind arg4, Type arg5, Fragment arg6) { return new Fragment("compiler", "cant.apply.symbol", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.misc.cant.apply.symbol=\ {0} {1} in {4} {5} cannot be applied to given types\n\ required: {2}\n\ found: {3}\n\ reason: {6}
/** * compiler.misc.cant.apply.symbol=\ * {0} {1} in {4} {5} cannot be applied to given types\n\ * required: {2}\n\ * found: {3}\n\ * reason: {6} */
public static Fragment CantApplySymbol(Kind arg0, Name arg1, Fragment arg2, Fragment arg3, Kind arg4, Type arg5, JCDiagnostic arg6) { return new Fragment("compiler", "cant.apply.symbol", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.misc.cant.apply.symbol=\ {0} {1} in {4} {5} cannot be applied to given types\n\ required: {2}\n\ found: {3}\n\ reason: {6}
/** * compiler.misc.cant.apply.symbol=\ * {0} {1} in {4} {5} cannot be applied to given types\n\ * required: {2}\n\ * found: {3}\n\ * reason: {6} */
public static Fragment CantApplySymbol(Kind arg0, Name arg1, Fragment arg2, Fragment arg3, Kind arg4, Type arg5, Fragment arg6) { return new Fragment("compiler", "cant.apply.symbol", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.misc.cant.apply.symbols=\ no suitable {0} found for {1}({2})
/** * compiler.misc.cant.apply.symbols=\ * no suitable {0} found for {1}({2}) */
public static Fragment CantApplySymbols(Kind arg0, Name arg1, List<? extends Type> arg2) { return new Fragment("compiler", "cant.apply.symbols", arg0, arg1, arg2); }
compiler.misc.cant.hide=\ {0} in {1} cannot hide {2} in {3}
/** * compiler.misc.cant.hide=\ * {0} in {1} cannot hide {2} in {3} */
public static Fragment CantHide(Symbol arg0, Symbol arg1, Symbol arg2, Symbol arg3) { return new Fragment("compiler", "cant.hide", arg0, arg1, arg2, arg3); }
compiler.misc.cant.implement=\ {0} in {1} cannot implement {2} in {3}
/** * compiler.misc.cant.implement=\ * {0} in {1} cannot implement {2} in {3} */
public static Fragment CantImplement(Symbol arg0, Symbol arg1, Symbol arg2, Symbol arg3) { return new Fragment("compiler", "cant.implement", arg0, arg1, arg2, arg3); }
compiler.misc.cant.override=\ {0} in {1} cannot override {2} in {3}
/** * compiler.misc.cant.override=\ * {0} in {1} cannot override {2} in {3} */
public static Fragment CantOverride(Symbol arg0, Symbol arg1, Symbol arg2, Symbol arg3) { return new Fragment("compiler", "cant.override", arg0, arg1, arg2, arg3); }
compiler.misc.cant.resolve.args=\ cannot find symbol\n\ symbol: {0} {1}({3})
/** * compiler.misc.cant.resolve.args=\ * cannot find symbol\n\ * symbol: {0} {1}({3}) */
public static Fragment CantResolveArgs(KindName arg0, Name arg1, Void arg2, List<? extends Type> arg3) { return new Fragment("compiler", "cant.resolve.args", arg0, arg1, arg2, arg3); }
compiler.misc.cant.resolve.location.args=\ cannot find symbol\n\ symbol: {0} {1}({3})\n\ location: {4}
/** * compiler.misc.cant.resolve.location.args=\ * cannot find symbol\n\ * symbol: {0} {1}({3})\n\ * location: {4} */
public static Fragment CantResolveLocationArgs(KindName arg0, Name arg1, Void arg2, List<? extends Type> arg3, JCDiagnostic arg4) { return new Fragment("compiler", "cant.resolve.location.args", arg0, arg1, arg2, arg3, arg4); }
compiler.misc.cant.resolve.location.args=\ cannot find symbol\n\ symbol: {0} {1}({3})\n\ location: {4}
/** * compiler.misc.cant.resolve.location.args=\ * cannot find symbol\n\ * symbol: {0} {1}({3})\n\ * location: {4} */
public static Fragment CantResolveLocationArgs(KindName arg0, Name arg1, Void arg2, List<? extends Type> arg3, Fragment arg4) { return new Fragment("compiler", "cant.resolve.location.args", arg0, arg1, arg2, arg3, arg4); }
compiler.misc.cant.resolve.location.args.params=\ cannot find symbol\n\ symbol: {0} <{2}>{1}({3})\n\ location: {4}
/** * compiler.misc.cant.resolve.location.args.params=\ * cannot find symbol\n\ * symbol: {0} <{2}>{1}({3})\n\ * location: {4} */
@SuppressWarnings("rawtypes") public static Fragment CantResolveLocationArgsParams(KindName arg0, Name arg1, List<? extends Type> arg2, List arg3, JCDiagnostic arg4) { return new Fragment("compiler", "cant.resolve.location.args.params", arg0, arg1, arg2, arg3, arg4); }
compiler.misc.cant.resolve.location.args.params=\ cannot find symbol\n\ symbol: {0} <{2}>{1}({3})\n\ location: {4}
/** * compiler.misc.cant.resolve.location.args.params=\ * cannot find symbol\n\ * symbol: {0} <{2}>{1}({3})\n\ * location: {4} */
@SuppressWarnings("rawtypes") public static Fragment CantResolveLocationArgsParams(KindName arg0, Name arg1, List<? extends Type> arg2, List arg3, Fragment arg4) { return new Fragment("compiler", "cant.resolve.location.args.params", arg0, arg1, arg2, arg3, arg4); }
compiler.misc.cant.resolve.modules=\ cannot resolve modules
/** * compiler.misc.cant.resolve.modules=\ * cannot resolve modules */
public static final Fragment CantResolveModules = new Fragment("compiler", "cant.resolve.modules");
compiler.misc.captured.type=\ CAP#{0}
/** * compiler.misc.captured.type=\ * CAP#{0} */
public static Fragment CapturedType(int arg0) { return new Fragment("compiler", "captured.type", arg0); }
compiler.misc.clashes.with=\ {0} in {1} clashes with {2} in {3}
/** * compiler.misc.clashes.with=\ * {0} in {1} clashes with {2} in {3} */
public static Fragment ClashesWith(Symbol arg0, Symbol arg1, Symbol arg2, Symbol arg3) { return new Fragment("compiler", "clashes.with", arg0, arg1, arg2, arg3); }
compiler.misc.class.file.not.found=\ class file for {0} not found
/** * compiler.misc.class.file.not.found=\ * class file for {0} not found */
public static Fragment ClassFileNotFound(Name arg0) { return new Fragment("compiler", "class.file.not.found", arg0); }
compiler.misc.class.file.wrong.class=\ class file contains wrong class: {0}
/** * compiler.misc.class.file.wrong.class=\ * class file contains wrong class: {0} */
public static final Fragment ClassFileWrongClass = new Fragment("compiler", "class.file.wrong.class");
compiler.misc.class.is.not.sealed=\ {0} must be sealed
/** * compiler.misc.class.is.not.sealed=\ * {0} must be sealed */
public static Fragment ClassIsNotSealed(String arg0) { return new Fragment("compiler", "class.is.not.sealed", arg0); }
compiler.misc.compact=\ compact
/** * compiler.misc.compact=\ * compact */
public static final Fragment Compact = new Fragment("compiler", "compact");
compiler.misc.conditional.target.cant.be.void=\ target-type for conditional expression cannot be void
/** * compiler.misc.conditional.target.cant.be.void=\ * target-type for conditional expression cannot be void */
public static final Fragment ConditionalTargetCantBeVoid = new Fragment("compiler", "conditional.target.cant.be.void");
compiler.misc.count.error=\ {0} error
/** * compiler.misc.count.error=\ * {0} error */
public static Fragment CountError(int arg0) { return new Fragment("compiler", "count.error", arg0); }
compiler.misc.count.error.plural=\ {0} errors
/** * compiler.misc.count.error.plural=\ * {0} errors */
public static Fragment CountErrorPlural(int arg0) { return new Fragment("compiler", "count.error.plural", arg0); }
compiler.misc.count.error.recompile=\ only showing the first {0} errors, of {1} total; use -Xmaxerrs if you would like to see more
/** * compiler.misc.count.error.recompile=\ * only showing the first {0} errors, of {1} total; use -Xmaxerrs if you would like to see more */
public static Fragment CountErrorRecompile(int arg0, int arg1) { return new Fragment("compiler", "count.error.recompile", arg0, arg1); }
compiler.misc.count.warn=\ {0} warning
/** * compiler.misc.count.warn=\ * {0} warning */
public static Fragment CountWarn(int arg0) { return new Fragment("compiler", "count.warn", arg0); }
compiler.misc.count.warn.plural=\ {0} warnings
/** * compiler.misc.count.warn.plural=\ * {0} warnings */
public static Fragment CountWarnPlural(int arg0) { return new Fragment("compiler", "count.warn.plural", arg0); }
compiler.misc.count.warn.recompile=\ only showing the first {0} warnings, of {1} total; use -Xmaxwarns if you would like to see more
/** * compiler.misc.count.warn.recompile=\ * only showing the first {0} warnings, of {1} total; use -Xmaxwarns if you would like to see more */
public static Fragment CountWarnRecompile(int arg0, int arg1) { return new Fragment("compiler", "count.warn.recompile", arg0, arg1); }
compiler.misc.descriptor=\ descriptor: {2} {0}({1})
/** * compiler.misc.descriptor=\ * descriptor: {2} {0}({1}) */
public static Fragment Descriptor(Name arg0, List<? extends Type> arg1, Type arg2, List<? extends Type> arg3) { return new Fragment("compiler", "descriptor", arg0, arg1, arg2, arg3); }
compiler.misc.descriptor.throws=\ descriptor: {2} {0}({1}) throws {3}
/** * compiler.misc.descriptor.throws=\ * descriptor: {2} {0}({1}) throws {3} */
public static Fragment DescriptorThrows(Name arg0, List<? extends Type> arg1, Type arg2, List<? extends Type> arg3) { return new Fragment("compiler", "descriptor.throws", arg0, arg1, arg2, arg3); }
compiler.misc.diamond=\ {0}<>
/** * compiler.misc.diamond=\ * {0}<> */
public static Fragment Diamond(Symbol arg0) { return new Fragment("compiler", "diamond", arg0); }
compiler.misc.diamond.and.explicit.params=\ cannot use ''<>'' with explicit type parameters for constructor
/** * compiler.misc.diamond.and.explicit.params=\ * cannot use ''<>'' with explicit type parameters for constructor */
public static Fragment DiamondAndExplicitParams(Type arg0) { return new Fragment("compiler", "diamond.and.explicit.params", arg0); }
compiler.misc.diamond.anonymous.methods.implicitly.override=\ (due to <>, every non-private method declared in this anonymous class must override or implement a method from a supertype)
/** * compiler.misc.diamond.anonymous.methods.implicitly.override=\ * (due to <>, every non-private method declared in this anonymous class must override or implement a method from a supertype) */
public static final Fragment DiamondAnonymousMethodsImplicitlyOverride = new Fragment("compiler", "diamond.anonymous.methods.implicitly.override");
compiler.misc.diamond.invalid.arg=\ type argument {0} inferred for {1} is not allowed in this context\n\ inferred argument is not expressible in the Signature attribute
/** * compiler.misc.diamond.invalid.arg=\ * type argument {0} inferred for {1} is not allowed in this context\n\ * inferred argument is not expressible in the Signature attribute */
public static Fragment DiamondInvalidArg(List<? extends Type> arg0, JCDiagnostic arg1) { return new Fragment("compiler", "diamond.invalid.arg", arg0, arg1); }
compiler.misc.diamond.invalid.arg=\ type argument {0} inferred for {1} is not allowed in this context\n\ inferred argument is not expressible in the Signature attribute
/** * compiler.misc.diamond.invalid.arg=\ * type argument {0} inferred for {1} is not allowed in this context\n\ * inferred argument is not expressible in the Signature attribute */
public static Fragment DiamondInvalidArg(List<? extends Type> arg0, Fragment arg1) { return new Fragment("compiler", "diamond.invalid.arg", arg0, arg1); }
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
/** * 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 */
public static Fragment DiamondInvalidArgs(List<? extends Type> arg0, JCDiagnostic arg1) { return new Fragment("compiler", "diamond.invalid.args", arg0, arg1); }
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
/** * 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 */
public static Fragment DiamondInvalidArgs(List<? extends Type> arg0, Fragment arg1) { return new Fragment("compiler", "diamond.invalid.args", arg0, arg1); }
compiler.misc.diamond.non.generic=\ cannot use ''<>'' with non-generic class {0}
/** * compiler.misc.diamond.non.generic=\ * cannot use ''<>'' with non-generic class {0} */
public static Fragment DiamondNonGeneric(Type arg0) { return new Fragment("compiler", "diamond.non.generic", arg0); }
compiler.misc.doesnt.extend.sealed=\ subclass {0} must extend sealed class
/** * compiler.misc.doesnt.extend.sealed=\ * subclass {0} must extend sealed class */
public static Fragment DoesntExtendSealed(Type arg0) { return new Fragment("compiler", "doesnt.extend.sealed", arg0); }
compiler.misc.eq.bounds=\ equality constraints: {0}
/** * compiler.misc.eq.bounds=\ * equality constraints: {0} */
public static Fragment EqBounds(List<? extends Type> arg0) { return new Fragment("compiler", "eq.bounds", arg0); }
compiler.misc.exception.message=\ {0}
/** * compiler.misc.exception.message=\ * {0} */
public static Fragment ExceptionMessage(String arg0) { return new Fragment("compiler", "exception.message", arg0); }
compiler.misc.explicit.param.do.not.conform.to.bounds=\ explicit type argument {0} does not conform to declared bound(s) {1}
/** * compiler.misc.explicit.param.do.not.conform.to.bounds=\ * explicit type argument {0} does not conform to declared bound(s) {1} */
public static Fragment ExplicitParamDoNotConformToBounds(Type arg0, List<? extends Type> arg1) { return new Fragment("compiler", "explicit.param.do.not.conform.to.bounds", arg0, arg1); }
compiler.misc.fatal.err.cant.close=\ Fatal Error: Cannot close compiler resources
/** * compiler.misc.fatal.err.cant.close=\ * Fatal Error: Cannot close compiler resources */
public static final Fragment FatalErrCantClose = new Fragment("compiler", "fatal.err.cant.close");
compiler.misc.fatal.err.cant.locate.ctor=\ Fatal Error: Unable to find constructor for {0}
/** * compiler.misc.fatal.err.cant.locate.ctor=\ * Fatal Error: Unable to find constructor for {0} */
public static Fragment FatalErrCantLocateCtor(Type arg0) { return new Fragment("compiler", "fatal.err.cant.locate.ctor", arg0); }
compiler.misc.fatal.err.cant.locate.field=\ Fatal Error: Unable to find field {0}
/** * compiler.misc.fatal.err.cant.locate.field=\ * Fatal Error: Unable to find field {0} */
public static Fragment FatalErrCantLocateField(Name arg0) { return new Fragment("compiler", "fatal.err.cant.locate.field", arg0); }
compiler.misc.fatal.err.cant.locate.meth=\ Fatal Error: Unable to find method {0}
/** * compiler.misc.fatal.err.cant.locate.meth=\ * Fatal Error: Unable to find method {0} */
public static Fragment FatalErrCantLocateMeth(Name arg0) { return new Fragment("compiler", "fatal.err.cant.locate.meth", arg0); }
compiler.misc.fatal.err.no.java.lang=\ Fatal Error: Unable to find package java.lang in classpath or bootclasspath
/** * compiler.misc.fatal.err.no.java.lang=\ * Fatal Error: Unable to find package java.lang in classpath or bootclasspath */
public static final Fragment FatalErrNoJavaLang = new Fragment("compiler", "fatal.err.no.java.lang");
compiler.misc.feature.annotations.after.type.params=\ annotations after method type parameters
/** * compiler.misc.feature.annotations.after.type.params=\ * annotations after method type parameters */
public static final Fragment FeatureAnnotationsAfterTypeParams = new Fragment("compiler", "feature.annotations.after.type.params");
compiler.misc.feature.default.methods=\ default methods
/** * compiler.misc.feature.default.methods=\ * default methods */
public static final Fragment FeatureDefaultMethods = new Fragment("compiler", "feature.default.methods");
compiler.misc.feature.diamond=\ diamond operator
/** * compiler.misc.feature.diamond=\ * diamond operator */
public static final Fragment FeatureDiamond = new Fragment("compiler", "feature.diamond");
compiler.misc.feature.diamond.and.anon.class=\ ''<>'' with anonymous inner classes
/** * compiler.misc.feature.diamond.and.anon.class=\ * ''<>'' with anonymous inner classes */
public static final Fragment FeatureDiamondAndAnonClass = new Fragment("compiler", "feature.diamond.and.anon.class");
compiler.misc.feature.intersection.types.in.cast=\ intersection types
/** * compiler.misc.feature.intersection.types.in.cast=\ * intersection types */
public static final Fragment FeatureIntersectionTypesInCast = new Fragment("compiler", "feature.intersection.types.in.cast");
compiler.misc.feature.lambda=\ lambda expressions
/** * compiler.misc.feature.lambda=\ * lambda expressions */
public static final Fragment FeatureLambda = new Fragment("compiler", "feature.lambda");
compiler.misc.feature.method.references=\ method references
/** * compiler.misc.feature.method.references=\ * method references */
public static final Fragment FeatureMethodReferences = new Fragment("compiler", "feature.method.references");
compiler.misc.feature.modules=\ modules
/** * compiler.misc.feature.modules=\ * modules */
public static final Fragment FeatureModules = new Fragment("compiler", "feature.modules");
compiler.misc.feature.multiple.case.labels=\ multiple case labels
/** * compiler.misc.feature.multiple.case.labels=\ * multiple case labels */
public static final Fragment FeatureMultipleCaseLabels = new Fragment("compiler", "feature.multiple.case.labels");
compiler.misc.feature.not.supported.in.source=\ {0} is not supported in -source {1}\n\ (use -source {2} or higher to enable {0})
/** * compiler.misc.feature.not.supported.in.source=\ * {0} is not supported in -source {1}\n\ * (use -source {2} or higher to enable {0}) */
public static Fragment FeatureNotSupportedInSource(JCDiagnostic arg0, String arg1, String arg2) { return new Fragment("compiler", "feature.not.supported.in.source", arg0, arg1, arg2); }
compiler.misc.feature.not.supported.in.source=\ {0} is not supported in -source {1}\n\ (use -source {2} or higher to enable {0})
/** * compiler.misc.feature.not.supported.in.source=\ * {0} is not supported in -source {1}\n\ * (use -source {2} or higher to enable {0}) */
public static Fragment FeatureNotSupportedInSource(Fragment arg0, String arg1, String arg2) { return new Fragment("compiler", "feature.not.supported.in.source", arg0, arg1, arg2); }
compiler.misc.feature.not.supported.in.source.plural=\ {0} are not supported in -source {1}\n\ (use -source {2} or higher to enable {0})
/** * compiler.misc.feature.not.supported.in.source.plural=\ * {0} are not supported in -source {1}\n\ * (use -source {2} or higher to enable {0}) */
public static Fragment FeatureNotSupportedInSourcePlural(JCDiagnostic arg0, String arg1, String arg2) { return new Fragment("compiler", "feature.not.supported.in.source.plural", arg0, arg1, arg2); }
compiler.misc.feature.not.supported.in.source.plural=\ {0} are not supported in -source {1}\n\ (use -source {2} or higher to enable {0})
/** * compiler.misc.feature.not.supported.in.source.plural=\ * {0} are not supported in -source {1}\n\ * (use -source {2} or higher to enable {0}) */
public static Fragment FeatureNotSupportedInSourcePlural(Fragment arg0, String arg1, String arg2) { return new Fragment("compiler", "feature.not.supported.in.source.plural", arg0, arg1, arg2); }
compiler.misc.feature.pattern.matching.instanceof=\ pattern matching in instanceof
/** * compiler.misc.feature.pattern.matching.instanceof=\ * pattern matching in instanceof */
public static final Fragment FeaturePatternMatchingInstanceof = new Fragment("compiler", "feature.pattern.matching.instanceof");
compiler.misc.feature.private.intf.methods=\ private interface methods
/** * compiler.misc.feature.private.intf.methods=\ * private interface methods */
public static final Fragment FeaturePrivateIntfMethods = new Fragment("compiler", "feature.private.intf.methods");
compiler.misc.feature.records=\ records
/** * compiler.misc.feature.records=\ * records */
public static final Fragment FeatureRecords = new Fragment("compiler", "feature.records");
compiler.misc.feature.reifiable.types.instanceof=\ reifiable types in instanceof
/** * compiler.misc.feature.reifiable.types.instanceof=\ * reifiable types in instanceof */
public static final Fragment FeatureReifiableTypesInstanceof = new Fragment("compiler", "feature.reifiable.types.instanceof");
compiler.misc.feature.repeatable.annotations=\ repeated annotations
/** * compiler.misc.feature.repeatable.annotations=\ * repeated annotations */
public static final Fragment FeatureRepeatableAnnotations = new Fragment("compiler", "feature.repeatable.annotations");
compiler.misc.feature.sealed.classes=\ sealed classes
/** * compiler.misc.feature.sealed.classes=\ * sealed classes */
public static final Fragment FeatureSealedClasses = new Fragment("compiler", "feature.sealed.classes");
compiler.misc.feature.static.intf.method.invoke=\ static interface method invocations
/** * compiler.misc.feature.static.intf.method.invoke=\ * static interface method invocations */
public static final Fragment FeatureStaticIntfMethodInvoke = new Fragment("compiler", "feature.static.intf.method.invoke");
compiler.misc.feature.static.intf.methods=\ static interface methods
/** * compiler.misc.feature.static.intf.methods=\ * static interface methods */
public static final Fragment FeatureStaticIntfMethods = new Fragment("compiler", "feature.static.intf.methods");
compiler.misc.feature.switch.expressions=\ switch expressions
/** * compiler.misc.feature.switch.expressions=\ * switch expressions */
public static final Fragment FeatureSwitchExpressions = new Fragment("compiler", "feature.switch.expressions");
compiler.misc.feature.switch.rules=\ switch rules
/** * compiler.misc.feature.switch.rules=\ * switch rules */
public static final Fragment FeatureSwitchRules = new Fragment("compiler", "feature.switch.rules");
compiler.misc.feature.text.blocks=\ text blocks
/** * compiler.misc.feature.text.blocks=\ * text blocks */
public static final Fragment FeatureTextBlocks = new Fragment("compiler", "feature.text.blocks");
compiler.misc.feature.type.annotations=\ type annotations
/** * compiler.misc.feature.type.annotations=\ * type annotations */
public static final Fragment FeatureTypeAnnotations = new Fragment("compiler", "feature.type.annotations");
compiler.misc.feature.var.in.try.with.resources=\ variables in try-with-resources
/** * compiler.misc.feature.var.in.try.with.resources=\ * variables in try-with-resources */
public static final Fragment FeatureVarInTryWithResources = new Fragment("compiler", "feature.var.in.try.with.resources");
compiler.misc.feature.var.syntax.in.implicit.lambda=\ var syntax in implicit lambdas
/** * compiler.misc.feature.var.syntax.in.implicit.lambda=\ * var syntax in implicit lambdas */
public static final Fragment FeatureVarSyntaxInImplicitLambda = new Fragment("compiler", "feature.var.syntax.in.implicit.lambda");
compiler.misc.file.does.not.contain.module=\ file does not contain module declaration
/** * compiler.misc.file.does.not.contain.module=\ * file does not contain module declaration */
public static final Fragment FileDoesNotContainModule = new Fragment("compiler", "file.does.not.contain.module");
compiler.misc.file.does.not.contain.package=\ file does not contain package {0}
/** * compiler.misc.file.does.not.contain.package=\ * file does not contain package {0} */
public static Fragment FileDoesNotContainPackage(Symbol arg0) { return new Fragment("compiler", "file.does.not.contain.package", arg0); }
compiler.misc.file.doesnt.contain.class=\ file does not contain class {0}
/** * compiler.misc.file.doesnt.contain.class=\ * file does not contain class {0} */
public static Fragment FileDoesntContainClass(Name arg0) { return new Fragment("compiler", "file.doesnt.contain.class", arg0); }
compiler.misc.illegal.signature=\ illegal signature attribute for type {1}
/** * compiler.misc.illegal.signature=\ * illegal signature attribute for type {1} */
public static Fragment IllegalSignature(Symbol arg0, Type arg1) { return new Fragment("compiler", "illegal.signature", arg0, arg1); }
compiler.misc.illegal.start.of.class.file=\ illegal start of class file
/** * compiler.misc.illegal.start.of.class.file=\ * illegal start of class file */
public static final Fragment IllegalStartOfClassFile = new Fragment("compiler", "illegal.start.of.class.file");
compiler.misc.implicit.and.explicit.not.allowed=\ cannot mix implicitly-typed and explicitly-typed parameters
/** * compiler.misc.implicit.and.explicit.not.allowed=\ * cannot mix implicitly-typed and explicitly-typed parameters */
public static final Fragment ImplicitAndExplicitNotAllowed = new Fragment("compiler", "implicit.and.explicit.not.allowed");
compiler.misc.inaccessible.varargs.type=\ formal varargs element type {0} is not accessible from {1} {2}
/** * compiler.misc.inaccessible.varargs.type=\ * formal varargs element type {0} is not accessible from {1} {2} */
public static Fragment InaccessibleVarargsType(Type arg0, Kind arg1, Symbol arg2) { return new Fragment("compiler", "inaccessible.varargs.type", arg0, arg1, arg2); }
compiler.misc.inapplicable.method=\ {0} {1}.{2} is not applicable\n\ ({3})
/** * compiler.misc.inapplicable.method=\ * {0} {1}.{2} is not applicable\n\ * ({3}) */
public static Fragment InapplicableMethod(KindName arg0, Symbol arg1, Symbol arg2, JCDiagnostic arg3) { return new Fragment("compiler", "inapplicable.method", arg0, arg1, arg2, arg3); }
compiler.misc.inapplicable.method=\ {0} {1}.{2} is not applicable\n\ ({3})
/** * compiler.misc.inapplicable.method=\ * {0} {1}.{2} is not applicable\n\ * ({3}) */
public static Fragment InapplicableMethod(KindName arg0, Symbol arg1, Symbol arg2, Fragment arg3) { return new Fragment("compiler", "inapplicable.method", arg0, arg1, arg2, arg3); }
compiler.misc.incompatible.abstract.default=\ {0} {1} inherits abstract and default for {2}({3}) from types {4} and {5}
/** * compiler.misc.incompatible.abstract.default=\ * {0} {1} inherits abstract and default for {2}({3}) from types {4} and {5} */
public static Fragment IncompatibleAbstractDefault(KindName arg0, Type arg1, Name arg2, List<? extends Type> arg3, Symbol arg4, Symbol arg5) { return new Fragment("compiler", "incompatible.abstract.default", arg0, arg1, arg2, arg3, arg4, arg5); }
compiler.misc.incompatible.abstracts=\ multiple non-overriding abstract methods found in {0} {1}
/** * compiler.misc.incompatible.abstracts=\ * multiple non-overriding abstract methods found in {0} {1} */
public static Fragment IncompatibleAbstracts(KindName arg0, Symbol arg1) { return new Fragment("compiler", "incompatible.abstracts", arg0, arg1); }
compiler.misc.incompatible.arg.types.in.lambda=\ incompatible parameter types in lambda expression
/** * compiler.misc.incompatible.arg.types.in.lambda=\ * incompatible parameter types in lambda expression */
public static final Fragment IncompatibleArgTypesInLambda = new Fragment("compiler", "incompatible.arg.types.in.lambda");
compiler.misc.incompatible.arg.types.in.mref=\ incompatible parameter types in method reference
/** * compiler.misc.incompatible.arg.types.in.mref=\ * incompatible parameter types in method reference */
public static final Fragment IncompatibleArgTypesInMref = new Fragment("compiler", "incompatible.arg.types.in.mref");
compiler.misc.incompatible.bounds=\ inference variable {0} has incompatible bounds\n\ {1}\n\ {2}
/** * compiler.misc.incompatible.bounds=\ * inference variable {0} has incompatible bounds\n\ * {1}\n\ * {2} */
public static Fragment IncompatibleBounds(Type arg0, Fragment arg1, Fragment arg2) { return new Fragment("compiler", "incompatible.bounds", arg0, arg1, arg2); }
compiler.misc.incompatible.descs.in.functional.intf=\ incompatible function descriptors found in {0} {1}
/** * compiler.misc.incompatible.descs.in.functional.intf=\ * incompatible function descriptors found in {0} {1} */
public static Fragment IncompatibleDescsInFunctionalIntf(KindName arg0, Symbol arg1) { return new Fragment("compiler", "incompatible.descs.in.functional.intf", arg0, arg1); }
compiler.misc.incompatible.diff.ret=\ both define {0}({1}), but with unrelated return types
/** * compiler.misc.incompatible.diff.ret=\ * both define {0}({1}), but with unrelated return types */
public static Fragment IncompatibleDiffRet(Name arg0, List<? extends Type> arg1) { return new Fragment("compiler", "incompatible.diff.ret", arg0, arg1); }
compiler.misc.incompatible.eq.bounds=\ inference variable {0} has incompatible equality constraints {1}
/** * compiler.misc.incompatible.eq.bounds=\ * inference variable {0} has incompatible equality constraints {1} */
public static Fragment IncompatibleEqBounds(Type arg0, List<? extends Type> arg1) { return new Fragment("compiler", "incompatible.eq.bounds", arg0, arg1); }
compiler.misc.incompatible.ret.type.in.lambda=\ bad return type in lambda expression\n\ {0}
/** * compiler.misc.incompatible.ret.type.in.lambda=\ * bad return type in lambda expression\n\ * {0} */
public static Fragment IncompatibleRetTypeInLambda(JCDiagnostic arg0) { return new Fragment("compiler", "incompatible.ret.type.in.lambda", arg0); }
compiler.misc.incompatible.ret.type.in.lambda=\ bad return type in lambda expression\n\ {0}
/** * compiler.misc.incompatible.ret.type.in.lambda=\ * bad return type in lambda expression\n\ * {0} */
public static Fragment IncompatibleRetTypeInLambda(Fragment arg0) { return new Fragment("compiler", "incompatible.ret.type.in.lambda", arg0); }
compiler.misc.incompatible.ret.type.in.mref=\ bad return type in method reference\n\ {0}
/** * compiler.misc.incompatible.ret.type.in.mref=\ * bad return type in method reference\n\ * {0} */
public static Fragment IncompatibleRetTypeInMref(JCDiagnostic arg0) { return new Fragment("compiler", "incompatible.ret.type.in.mref", arg0); }
compiler.misc.incompatible.ret.type.in.mref=\ bad return type in method reference\n\ {0}
/** * compiler.misc.incompatible.ret.type.in.mref=\ * bad return type in method reference\n\ * {0} */
public static Fragment IncompatibleRetTypeInMref(Fragment arg0) { return new Fragment("compiler", "incompatible.ret.type.in.mref", arg0); }
compiler.misc.incompatible.type.in.conditional=\ bad type in conditional expression\n\ {0}
/** * compiler.misc.incompatible.type.in.conditional=\ * bad type in conditional expression\n\ * {0} */
public static Fragment IncompatibleTypeInConditional(JCDiagnostic arg0) { return new Fragment("compiler", "incompatible.type.in.conditional", arg0); }
compiler.misc.incompatible.type.in.conditional=\ bad type in conditional expression\n\ {0}
/** * compiler.misc.incompatible.type.in.conditional=\ * bad type in conditional expression\n\ * {0} */
public static Fragment IncompatibleTypeInConditional(Fragment arg0) { return new Fragment("compiler", "incompatible.type.in.conditional", arg0); }
compiler.misc.incompatible.type.in.switch.expression=\ bad type in switch expression\n\ {0}
/** * compiler.misc.incompatible.type.in.switch.expression=\ * bad type in switch expression\n\ * {0} */
public static Fragment IncompatibleTypeInSwitchExpression(JCDiagnostic arg0) { return new Fragment("compiler", "incompatible.type.in.switch.expression", arg0); }
compiler.misc.incompatible.type.in.switch.expression=\ bad type in switch expression\n\ {0}
/** * compiler.misc.incompatible.type.in.switch.expression=\ * bad type in switch expression\n\ * {0} */
public static Fragment IncompatibleTypeInSwitchExpression(Fragment arg0) { return new Fragment("compiler", "incompatible.type.in.switch.expression", arg0); }
compiler.misc.incompatible.unrelated.defaults=\ {0} {1} inherits unrelated defaults for {2}({3}) from types {4} and {5}
/** * compiler.misc.incompatible.unrelated.defaults=\ * {0} {1} inherits unrelated defaults for {2}({3}) from types {4} and {5} */
public static Fragment IncompatibleUnrelatedDefaults(KindName arg0, Type arg1, Name arg2, List<? extends Type> arg3, Symbol arg4, Symbol arg5) { return new Fragment("compiler", "incompatible.unrelated.defaults", arg0, arg1, arg2, arg3, arg4, arg5); }
compiler.misc.incompatible.upper.bounds=\ inference variable {0} has incompatible upper bounds {1}
/** * compiler.misc.incompatible.upper.bounds=\ * inference variable {0} has incompatible upper bounds {1} */
public static Fragment IncompatibleUpperBounds(Type arg0, List<? extends Type> arg1) { return new Fragment("compiler", "incompatible.upper.bounds", arg0, arg1); }
compiler.misc.inconvertible.types=\ {0} cannot be converted to {1}
/** * compiler.misc.inconvertible.types=\ * {0} cannot be converted to {1} */
public static Fragment InconvertibleTypes(Type arg0, Type arg1) { return new Fragment("compiler", "inconvertible.types", arg0, arg1); }
compiler.misc.infer.arg.length.mismatch=\ cannot infer type-variable(s) {0}\n\ (actual and formal argument lists differ in length)
/** * compiler.misc.infer.arg.length.mismatch=\ * cannot infer type-variable(s) {0}\n\ * (actual and formal argument lists differ in length) */
public static Fragment InferArgLengthMismatch(List<? extends Type> arg0) { return new Fragment("compiler", "infer.arg.length.mismatch", arg0); }
compiler.misc.infer.no.conforming.assignment.exists=\ cannot infer type-variable(s) {0}\n\ (argument mismatch; {1})
/** * compiler.misc.infer.no.conforming.assignment.exists=\ * cannot infer type-variable(s) {0}\n\ * (argument mismatch; {1}) */
public static Fragment InferNoConformingAssignmentExists(List<? extends Type> arg0, JCDiagnostic arg1) { return new Fragment("compiler", "infer.no.conforming.assignment.exists", arg0, arg1); }
compiler.misc.infer.no.conforming.assignment.exists=\ cannot infer type-variable(s) {0}\n\ (argument mismatch; {1})
/** * compiler.misc.infer.no.conforming.assignment.exists=\ * cannot infer type-variable(s) {0}\n\ * (argument mismatch; {1}) */
public static Fragment InferNoConformingAssignmentExists(List<? extends Type> arg0, Fragment arg1) { return new Fragment("compiler", "infer.no.conforming.assignment.exists", arg0, arg1); }
compiler.misc.infer.no.conforming.instance.exists=\ no instance(s) of type variable(s) {0} exist so that {1} conforms to {2}
/** * compiler.misc.infer.no.conforming.instance.exists=\ * no instance(s) of type variable(s) {0} exist so that {1} conforms to {2} */
public static Fragment InferNoConformingInstanceExists(List<? extends Type> arg0, Type arg1, Type arg2) { return new Fragment("compiler", "infer.no.conforming.instance.exists", arg0, arg1, arg2); }
compiler.misc.infer.varargs.argument.mismatch=\ cannot infer type-variable(s) {0}\n\ (varargs mismatch; {1})
/** * compiler.misc.infer.varargs.argument.mismatch=\ * cannot infer type-variable(s) {0}\n\ * (varargs mismatch; {1}) */
public static Fragment InferVarargsArgumentMismatch(List<? extends Type> arg0, JCDiagnostic arg1) { return new Fragment("compiler", "infer.varargs.argument.mismatch", arg0, arg1); }
compiler.misc.infer.varargs.argument.mismatch=\ cannot infer type-variable(s) {0}\n\ (varargs mismatch; {1})
/** * compiler.misc.infer.varargs.argument.mismatch=\ * cannot infer type-variable(s) {0}\n\ * (varargs mismatch; {1}) */
public static Fragment InferVarargsArgumentMismatch(List<? extends Type> arg0, Fragment arg1) { return new Fragment("compiler", "infer.varargs.argument.mismatch", arg0, arg1); }
compiler.misc.inferred.do.not.conform.to.eq.bounds=\ inferred type does not conform to equality constraint(s)\n\ inferred: {0}\n\ equality constraints(s): {1}
/** * compiler.misc.inferred.do.not.conform.to.eq.bounds=\ * inferred type does not conform to equality constraint(s)\n\ * inferred: {0}\n\ * equality constraints(s): {1} */
public static Fragment InferredDoNotConformToEqBounds(Type arg0, List<? extends Type> arg1) { return new Fragment("compiler", "inferred.do.not.conform.to.eq.bounds", arg0, arg1); }
compiler.misc.inferred.do.not.conform.to.lower.bounds=\ inferred type does not conform to lower bound(s)\n\ inferred: {0}\n\ lower bound(s): {1}
/** * compiler.misc.inferred.do.not.conform.to.lower.bounds=\ * inferred type does not conform to lower bound(s)\n\ * inferred: {0}\n\ * lower bound(s): {1} */
public static Fragment InferredDoNotConformToLowerBounds(Type arg0, List<? extends Type> arg1) { return new Fragment("compiler", "inferred.do.not.conform.to.lower.bounds", arg0, arg1); }
compiler.misc.inferred.do.not.conform.to.upper.bounds=\ inferred type does not conform to upper bound(s)\n\ inferred: {0}\n\ upper bound(s): {1}
/** * compiler.misc.inferred.do.not.conform.to.upper.bounds=\ * inferred type does not conform to upper bound(s)\n\ * inferred: {0}\n\ * upper bound(s): {1} */
public static Fragment InferredDoNotConformToUpperBounds(Type arg0, List<? extends Type> arg1) { return new Fragment("compiler", "inferred.do.not.conform.to.upper.bounds", arg0, arg1); }
compiler.misc.inner.cls=\ an inner class
/** * compiler.misc.inner.cls=\ * an inner class */
public static final Fragment InnerCls = new Fragment("compiler", "inner.cls");
compiler.misc.intersection.type=\ INT#{0}
/** * compiler.misc.intersection.type=\ * INT#{0} */
public static Fragment IntersectionType(int arg0) { return new Fragment("compiler", "intersection.type", arg0); }
compiler.misc.invalid.default.interface=\ default method found in version {0}.{1} classfile
/** * compiler.misc.invalid.default.interface=\ * default method found in version {0}.{1} classfile */
public static Fragment InvalidDefaultInterface(String arg0, String arg1) { return new Fragment("compiler", "invalid.default.interface", arg0, arg1); }
compiler.misc.invalid.generic.lambda.target=\ invalid functional descriptor for lambda expression\n\ method {0} in {1} {2} is generic
/** * compiler.misc.invalid.generic.lambda.target=\ * invalid functional descriptor for lambda expression\n\ * method {0} in {1} {2} is generic */
public static Fragment InvalidGenericLambdaTarget(Type arg0, KindName arg1, Symbol arg2) { return new Fragment("compiler", "invalid.generic.lambda.target", arg0, arg1, arg2); }
compiler.misc.invalid.mref=\ invalid {0} reference\n\ {1}
/** * compiler.misc.invalid.mref=\ * invalid {0} reference\n\ * {1} */
public static Fragment InvalidMref(KindName arg0, JCDiagnostic arg1) { return new Fragment("compiler", "invalid.mref", arg0, arg1); }
compiler.misc.invalid.mref=\ invalid {0} reference\n\ {1}
/** * compiler.misc.invalid.mref=\ * invalid {0} reference\n\ * {1} */
public static Fragment InvalidMref(KindName arg0, Fragment arg1) { return new Fragment("compiler", "invalid.mref", arg0, arg1); }
compiler.misc.invalid.static.interface=\ static method found in version {0}.{1} classfile
/** * compiler.misc.invalid.static.interface=\ * static method found in version {0}.{1} classfile */
public static Fragment InvalidStaticInterface(String arg0, String arg1) { return new Fragment("compiler", "invalid.static.interface", arg0, arg1); }
compiler.misc.is.a.type.variable=\ must not include type variables: {0}
/** * compiler.misc.is.a.type.variable=\ * must not include type variables: {0} */
public static Fragment IsATypeVariable(Type arg0) { return new Fragment("compiler", "is.a.type.variable", arg0); }
compiler.misc.is.duplicated=\ must not contain duplicates: {0}
/** * compiler.misc.is.duplicated=\ * must not contain duplicates: {0} */
public static Fragment IsDuplicated(Type arg0) { return new Fragment("compiler", "is.duplicated", arg0); }
compiler.misc.kindname.annotation=\ @interface
/** * compiler.misc.kindname.annotation=\ * @interface */
public static final Fragment KindnameAnnotation = new Fragment("compiler", "kindname.annotation");
compiler.misc.kindname.class=\ class
/** * compiler.misc.kindname.class=\ * class */
public static final Fragment KindnameClass = new Fragment("compiler", "kindname.class");
compiler.misc.kindname.constructor=\ constructor
/** * compiler.misc.kindname.constructor=\ * constructor */
public static final Fragment KindnameConstructor = new Fragment("compiler", "kindname.constructor");
compiler.misc.kindname.enum=\ enum
/** * compiler.misc.kindname.enum=\ * enum */
public static final Fragment KindnameEnum = new Fragment("compiler", "kindname.enum");
compiler.misc.kindname.instance.init=\ instance initializer
/** * compiler.misc.kindname.instance.init=\ * instance initializer */
public static final Fragment KindnameInstanceInit = new Fragment("compiler", "kindname.instance.init");
compiler.misc.kindname.interface=\ interface
/** * compiler.misc.kindname.interface=\ * interface */
public static final Fragment KindnameInterface = new Fragment("compiler", "kindname.interface");
compiler.misc.kindname.method=\ method
/** * compiler.misc.kindname.method=\ * method */
public static final Fragment KindnameMethod = new Fragment("compiler", "kindname.method");
compiler.misc.kindname.module=\ module
/** * compiler.misc.kindname.module=\ * module */
public static final Fragment KindnameModule = new Fragment("compiler", "kindname.module");
compiler.misc.kindname.package=\ package
/** * compiler.misc.kindname.package=\ * package */
public static final Fragment KindnamePackage = new Fragment("compiler", "kindname.package");
compiler.misc.kindname.record=\ record
/** * compiler.misc.kindname.record=\ * record */
public static final Fragment KindnameRecord = new Fragment("compiler", "kindname.record");
compiler.misc.kindname.record.component=\ record component
/** * compiler.misc.kindname.record.component=\ * record component */
public static final Fragment KindnameRecordComponent = new Fragment("compiler", "kindname.record.component");
compiler.misc.kindname.static=\ static
/** * compiler.misc.kindname.static=\ * static */
public static final Fragment KindnameStatic = new Fragment("compiler", "kindname.static");
compiler.misc.kindname.static.init=\ static initializer
/** * compiler.misc.kindname.static.init=\ * static initializer */
public static final Fragment KindnameStaticInit = new Fragment("compiler", "kindname.static.init");
compiler.misc.kindname.type.variable=\ type variable
/** * compiler.misc.kindname.type.variable=\ * type variable */
public static final Fragment KindnameTypeVariable = new Fragment("compiler", "kindname.type.variable");
compiler.misc.kindname.type.variable.bound=\ bound of type variable
/** * compiler.misc.kindname.type.variable.bound=\ * bound of type variable */
public static final Fragment KindnameTypeVariableBound = new Fragment("compiler", "kindname.type.variable.bound");
compiler.misc.kindname.value=\ value
/** * compiler.misc.kindname.value=\ * value */
public static final Fragment KindnameValue = new Fragment("compiler", "kindname.value");
compiler.misc.kindname.variable=\ variable
/** * compiler.misc.kindname.variable=\ * variable */
public static final Fragment KindnameVariable = new Fragment("compiler", "kindname.variable");
compiler.misc.lambda=\ a lambda expression
/** * compiler.misc.lambda=\ * a lambda expression */
public static final Fragment Lambda = new Fragment("compiler", "lambda");
compiler.misc.local=\ local
/** * compiler.misc.local=\ * local */
public static final Fragment Local = new Fragment("compiler", "local");
compiler.misc.local.array.missing.target=\ array initializer needs an explicit target-type
/** * compiler.misc.local.array.missing.target=\ * array initializer needs an explicit target-type */
public static final Fragment LocalArrayMissingTarget = new Fragment("compiler", "local.array.missing.target");
compiler.misc.local.cant.infer.null=\ variable initializer is ''null''
/** * compiler.misc.local.cant.infer.null=\ * variable initializer is ''null'' */
public static final Fragment LocalCantInferNull = new Fragment("compiler", "local.cant.infer.null");
compiler.misc.local.cant.infer.void=\ variable initializer is ''void''
/** * compiler.misc.local.cant.infer.void=\ * variable initializer is ''void'' */
public static final Fragment LocalCantInferVoid = new Fragment("compiler", "local.cant.infer.void");
compiler.misc.local.lambda.missing.target=\ lambda expression needs an explicit target-type
/** * compiler.misc.local.lambda.missing.target=\ * lambda expression needs an explicit target-type */
public static final Fragment LocalLambdaMissingTarget = new Fragment("compiler", "local.lambda.missing.target");
compiler.misc.local.missing.init=\ cannot use ''var'' on variable without initializer
/** * compiler.misc.local.missing.init=\ * cannot use ''var'' on variable without initializer */
public static final Fragment LocalMissingInit = new Fragment("compiler", "local.missing.init");
compiler.misc.local.mref.missing.target=\ method reference needs an explicit target-type
/** * compiler.misc.local.mref.missing.target=\ * method reference needs an explicit target-type */
public static final Fragment LocalMrefMissingTarget = new Fragment("compiler", "local.mref.missing.target");
compiler.misc.local.self.ref=\ cannot use ''var'' on self-referencing variable
/** * compiler.misc.local.self.ref=\ * cannot use ''var'' on self-referencing variable */
public static final Fragment LocalSelfRef = new Fragment("compiler", "local.self.ref");
compiler.misc.location=\ {0} {1}
/** * compiler.misc.location=\ * {0} {1} */
public static Fragment Location(KindName arg0, Type arg1, Void arg2) { return new Fragment("compiler", "location", arg0, arg1, arg2); }
compiler.misc.location=\ {0} {1}
/** * compiler.misc.location=\ * {0} {1} */
public static Fragment Location(KindName arg0, Symbol arg1, Void arg2) { return new Fragment("compiler", "location", arg0, arg1, arg2); }
compiler.misc.location.1=\ {0} {1} of type {2}
/** * compiler.misc.location.1=\ * {0} {1} of type {2} */
public static Fragment Location1(KindName arg0, Symbol arg1, Type arg2) { return new Fragment("compiler", "location.1", arg0, arg1, arg2); }
compiler.misc.locn.module_path=\ application module path
/** * compiler.misc.locn.module_path=\ * application module path */
public static final Fragment LocnModule_path = new Fragment("compiler", "locn.module_path");
compiler.misc.locn.module_source_path=\ module source path
/** * compiler.misc.locn.module_source_path=\ * module source path */
public static final Fragment LocnModule_source_path = new Fragment("compiler", "locn.module_source_path");
compiler.misc.locn.system_modules=\ system modules
/** * compiler.misc.locn.system_modules=\ * system modules */
public static final Fragment LocnSystem_modules = new Fragment("compiler", "locn.system_modules");
compiler.misc.locn.upgrade_module_path=\ upgrade module path
/** * compiler.misc.locn.upgrade_module_path=\ * upgrade module path */
public static final Fragment LocnUpgrade_module_path = new Fragment("compiler", "locn.upgrade_module_path");
compiler.misc.lower.bounds=\ lower bounds: {0}
/** * compiler.misc.lower.bounds=\ * lower bounds: {0} */
public static Fragment LowerBounds(List<? extends Type> arg0) { return new Fragment("compiler", "lower.bounds", arg0); }
compiler.misc.malformed.vararg.method=\ class file contains malformed variable arity method: {0}
/** * compiler.misc.malformed.vararg.method=\ * class file contains malformed variable arity method: {0} */
public static final Fragment MalformedVarargMethod = new Fragment("compiler", "malformed.vararg.method");
compiler.misc.method.descriptor.invalid=\ method descriptor invalid for {0}
/** * compiler.misc.method.descriptor.invalid=\ * method descriptor invalid for {0} */
public static Fragment MethodDescriptorInvalid(Name arg0) { return new Fragment("compiler", "method.descriptor.invalid", arg0); }
compiler.misc.method.must.be.public=\ accessor method must be public
/** * compiler.misc.method.must.be.public=\ * accessor method must be public */
public static final Fragment MethodMustBePublic = new Fragment("compiler", "method.must.be.public");
compiler.misc.missing.ret.val=\ missing return value
/** * compiler.misc.missing.ret.val=\ * missing return value */
public static Fragment MissingRetVal(Type arg0) { return new Fragment("compiler", "missing.ret.val", arg0); }
compiler.misc.module.info.definition.expected=\ module-info definition expected
/** * compiler.misc.module.info.definition.expected=\ * module-info definition expected */
public static final Fragment ModuleInfoDefinitionExpected = new Fragment("compiler", "module.info.definition.expected");
compiler.misc.module.info.invalid.super.class=\ module-info with invalid super class
/** * compiler.misc.module.info.invalid.super.class=\ * module-info with invalid super class */
public static final Fragment ModuleInfoInvalidSuperClass = new Fragment("compiler", "module.info.invalid.super.class");
compiler.misc.module.name.mismatch=\ module name {0} does not match expected name {1}
/** * compiler.misc.module.name.mismatch=\ * module name {0} does not match expected name {1} */
public static Fragment ModuleNameMismatch(Name arg0, Name arg1) { return new Fragment("compiler", "module.name.mismatch", arg0, arg1); }
compiler.misc.module.non.zero.opens=\ open module {0} has non-zero opens_count
/** * compiler.misc.module.non.zero.opens=\ * open module {0} has non-zero opens_count */
public static Fragment ModuleNonZeroOpens(Name arg0) { return new Fragment("compiler", "module.non.zero.opens", arg0); }
compiler.misc.mref.infer.and.explicit.params=\ cannot use raw constructor reference with explicit type parameters for constructor
/** * compiler.misc.mref.infer.and.explicit.params=\ * cannot use raw constructor reference with explicit type parameters for constructor */
public static final Fragment MrefInferAndExplicitParams = new Fragment("compiler", "mref.infer.and.explicit.params");
compiler.misc.must.not.be.same.class=\ illegal self-reference in permits clause
/** * compiler.misc.must.not.be.same.class=\ * illegal self-reference in permits clause */
public static final Fragment MustNotBeSameClass = new Fragment("compiler", "must.not.be.same.class");
compiler.misc.must.not.be.supertype=\ illegal reference to supertype {0}
/** * compiler.misc.must.not.be.supertype=\ * illegal reference to supertype {0} */
public static Fragment MustNotBeSupertype(Type arg0) { return new Fragment("compiler", "must.not.be.supertype", arg0); }
compiler.misc.no.abstracts=\ no abstract method found in {0} {1}
/** * compiler.misc.no.abstracts=\ * no abstract method found in {0} {1} */
public static Fragment NoAbstracts(KindName arg0, Symbol arg1) { return new Fragment("compiler", "no.abstracts", arg0, arg1); }
compiler.misc.no.args=\ no arguments
/** * compiler.misc.no.args=\ * no arguments */
public static final Fragment NoArgs = new Fragment("compiler", "no.args");
compiler.misc.no.conforming.assignment.exists=\ argument mismatch; {0}
/** * compiler.misc.no.conforming.assignment.exists=\ * argument mismatch; {0} */
public static Fragment NoConformingAssignmentExists(JCDiagnostic arg0) { return new Fragment("compiler", "no.conforming.assignment.exists", arg0); }
compiler.misc.no.conforming.assignment.exists=\ argument mismatch; {0}
/** * compiler.misc.no.conforming.assignment.exists=\ * argument mismatch; {0} */
public static Fragment NoConformingAssignmentExists(Fragment arg0) { return new Fragment("compiler", "no.conforming.assignment.exists", arg0); }
compiler.misc.no.suitable.functional.intf.inst=\ cannot infer functional interface descriptor for {0}
/** * compiler.misc.no.suitable.functional.intf.inst=\ * cannot infer functional interface descriptor for {0} */
public static Fragment NoSuitableFunctionalIntfInst(Type arg0) { return new Fragment("compiler", "no.suitable.functional.intf.inst", arg0); }
compiler.misc.no.unique.maximal.instance.exists=\ no unique maximal instance exists for type variable {0} with upper bounds {1}
/** * compiler.misc.no.unique.maximal.instance.exists=\ * no unique maximal instance exists for type variable {0} with upper bounds {1} */
public static Fragment NoUniqueMaximalInstanceExists(Type arg0, List<? extends Type> arg1) { return new Fragment("compiler", "no.unique.maximal.instance.exists", arg0, arg1); }
compiler.misc.no.unique.minimal.instance.exists=\ no unique minimal instance exists for type variable {0} with lower bounds {1}
/** * compiler.misc.no.unique.minimal.instance.exists=\ * no unique minimal instance exists for type variable {0} with lower bounds {1} */
public static Fragment NoUniqueMinimalInstanceExists(Type arg0, List<? extends Type> arg1) { return new Fragment("compiler", "no.unique.minimal.instance.exists", arg0, arg1); }
compiler.misc.non.static=\ non-static
/** * compiler.misc.non.static=\ * non-static */
public static final Fragment NonStatic = new Fragment("compiler", "non.static");
compiler.misc.not.a.functional.intf=\ {0} is not a functional interface
/** * compiler.misc.not.a.functional.intf=\ * {0} is not a functional interface */
public static Fragment NotAFunctionalIntf(Symbol arg0) { return new Fragment("compiler", "not.a.functional.intf", arg0); }
compiler.misc.not.a.functional.intf.1=\ {0} is not a functional interface\n\ {1}
/** * compiler.misc.not.a.functional.intf.1=\ * {0} is not a functional interface\n\ * {1} */
public static Fragment NotAFunctionalIntf1(Symbol arg0, JCDiagnostic arg1) { return new Fragment("compiler", "not.a.functional.intf.1", arg0, arg1); }
compiler.misc.not.a.functional.intf.1=\ {0} is not a functional interface\n\ {1}
/** * compiler.misc.not.a.functional.intf.1=\ * {0} is not a functional interface\n\ * {1} */
public static Fragment NotAFunctionalIntf1(Symbol arg0, Fragment arg1) { return new Fragment("compiler", "not.a.functional.intf.1", arg0, arg1); }
compiler.misc.not.an.intf.component=\ component type {0} is not an interface
/** * compiler.misc.not.an.intf.component=\ * component type {0} is not an interface */
public static Fragment NotAnIntfComponent(Symbol arg0) { return new Fragment("compiler", "not.an.intf.component", arg0); }
compiler.misc.not.an.intf.component=\ component type {0} is not an interface
/** * compiler.misc.not.an.intf.component=\ * component type {0} is not an interface */
public static Fragment NotAnIntfComponent(Type arg0) { return new Fragment("compiler", "not.an.intf.component", arg0); }
compiler.misc.not.applicable.method.found=\ ({2})
/** * compiler.misc.not.applicable.method.found=\ * ({2}) */
public static Fragment NotApplicableMethodFound(int arg0, Symbol arg1, JCDiagnostic arg2) { return new Fragment("compiler", "not.applicable.method.found", arg0, arg1, arg2); }
compiler.misc.not.applicable.method.found=\ ({2})
/** * compiler.misc.not.applicable.method.found=\ * ({2}) */
public static Fragment NotApplicableMethodFound(int arg0, Symbol arg1, Fragment arg2) { return new Fragment("compiler", "not.applicable.method.found", arg0, arg1, arg2); }
compiler.misc.not.def.access.class.intf.cant.access=\ {1}.{0} is defined in an inaccessible class or interface
/** * compiler.misc.not.def.access.class.intf.cant.access=\ * {1}.{0} is defined in an inaccessible class or interface */
public static Fragment NotDefAccessClassIntfCantAccess(Symbol arg0, Symbol arg1) { return new Fragment("compiler", "not.def.access.class.intf.cant.access", arg0, arg1); }
compiler.misc.not.def.access.class.intf.cant.access.reason=\ {1}.{0} in package {2} is not accessible\n\ ({3})
/** * compiler.misc.not.def.access.class.intf.cant.access.reason=\ * {1}.{0} in package {2} is not accessible\n\ * ({3}) */
public static Fragment NotDefAccessClassIntfCantAccessReason(Symbol arg0, Symbol arg1, Symbol arg2, JCDiagnostic arg3) { return new Fragment("compiler", "not.def.access.class.intf.cant.access.reason", arg0, arg1, arg2, arg3); }
compiler.misc.not.def.access.class.intf.cant.access.reason=\ {1}.{0} in package {2} is not accessible\n\ ({3})
/** * compiler.misc.not.def.access.class.intf.cant.access.reason=\ * {1}.{0} in package {2} is not accessible\n\ * ({3}) */
public static Fragment NotDefAccessClassIntfCantAccessReason(Symbol arg0, Symbol arg1, Symbol arg2, Fragment arg3) { return new Fragment("compiler", "not.def.access.class.intf.cant.access.reason", arg0, arg1, arg2, arg3); }
compiler.misc.not.def.access.does.not.read=\ package {1} is declared in module {2}, but module {0} does not read it
/** * compiler.misc.not.def.access.does.not.read=\ * package {1} is declared in module {2}, but module {0} does not read it */
public static Fragment NotDefAccessDoesNotRead(Symbol arg0, Symbol arg1, Symbol arg2) { return new Fragment("compiler", "not.def.access.does.not.read", arg0, arg1, arg2); }
compiler.misc.not.def.access.does.not.read.from.unnamed=\ package {0} is declared in module {1}, which is not in the module graph
/** * compiler.misc.not.def.access.does.not.read.from.unnamed=\ * package {0} is declared in module {1}, which is not in the module graph */
public static Fragment NotDefAccessDoesNotReadFromUnnamed(Symbol arg0, Symbol arg1) { return new Fragment("compiler", "not.def.access.does.not.read.from.unnamed", arg0, arg1); }
compiler.misc.not.def.access.does.not.read.unnamed=\ package {0} is declared in the unnamed module, but module {1} does not read it
/** * compiler.misc.not.def.access.does.not.read.unnamed=\ * package {0} is declared in the unnamed module, but module {1} does not read it */
public static Fragment NotDefAccessDoesNotReadUnnamed(Symbol arg0, Symbol arg1) { return new Fragment("compiler", "not.def.access.does.not.read.unnamed", arg0, arg1); }
compiler.misc.not.def.access.not.exported=\ package {0} is declared in module {1}, which does not export it
/** * compiler.misc.not.def.access.not.exported=\ * package {0} is declared in module {1}, which does not export it */
public static Fragment NotDefAccessNotExported(Symbol arg0, Symbol arg1) { return new Fragment("compiler", "not.def.access.not.exported", arg0, arg1); }
compiler.misc.not.def.access.not.exported.from.unnamed=\ package {0} is declared in module {1}, which does not export it
/** * compiler.misc.not.def.access.not.exported.from.unnamed=\ * package {0} is declared in module {1}, which does not export it */
public static Fragment NotDefAccessNotExportedFromUnnamed(Symbol arg0, Symbol arg1) { return new Fragment("compiler", "not.def.access.not.exported.from.unnamed", arg0, arg1); }
compiler.misc.not.def.access.not.exported.to.module=\ package {0} is declared in module {1}, which does not export it to module {2}
/** * compiler.misc.not.def.access.not.exported.to.module=\ * package {0} is declared in module {1}, which does not export it to module {2} */
public static Fragment NotDefAccessNotExportedToModule(Symbol arg0, Symbol arg1, Symbol arg2) { return new Fragment("compiler", "not.def.access.not.exported.to.module", arg0, arg1, arg2); }
compiler.misc.not.def.access.not.exported.to.module.from.unnamed=\ package {0} is declared in module {1}, which does not export it to the unnamed module
/** * compiler.misc.not.def.access.not.exported.to.module.from.unnamed=\ * package {0} is declared in module {1}, which does not export it to the unnamed module */
public static Fragment NotDefAccessNotExportedToModuleFromUnnamed(Symbol arg0, Symbol arg1) { return new Fragment("compiler", "not.def.access.not.exported.to.module.from.unnamed", arg0, arg1); }
compiler.misc.not.def.access.package.cant.access=\ {0} is not visible\n\ ({2})
/** * compiler.misc.not.def.access.package.cant.access=\ * {0} is not visible\n\ * ({2}) */
public static Fragment NotDefAccessPackageCantAccess(Symbol arg0, Symbol arg1, JCDiagnostic arg2) { return new Fragment("compiler", "not.def.access.package.cant.access", arg0, arg1, arg2); }
compiler.misc.not.def.access.package.cant.access=\ {0} is not visible\n\ ({2})
/** * compiler.misc.not.def.access.package.cant.access=\ * {0} is not visible\n\ * ({2}) */
public static Fragment NotDefAccessPackageCantAccess(Symbol arg0, Symbol arg1, Fragment arg2) { return new Fragment("compiler", "not.def.access.package.cant.access", arg0, arg1, arg2); }
compiler.misc.not.def.public.cant.access=\ {0} is not public in {1}; cannot be accessed from outside package
/** * compiler.misc.not.def.public.cant.access=\ * {0} is not public in {1}; cannot be accessed from outside package */
public static Fragment NotDefPublicCantAccess(Symbol arg0, Symbol arg1) { return new Fragment("compiler", "not.def.public.cant.access", arg0, arg1); }
compiler.misc.overridden.default=\ method {0} is overridden in {1}
/** * compiler.misc.overridden.default=\ * method {0} is overridden in {1} */
public static Fragment OverriddenDefault(Symbol arg0, Type arg1) { return new Fragment("compiler", "overridden.default", arg0, arg1); }
compiler.misc.package.not.visible=\ package {0} is not visible\n\ ({1})
/** * compiler.misc.package.not.visible=\ * package {0} is not visible\n\ * ({1}) */
public static Fragment PackageNotVisible(Symbol arg0, JCDiagnostic arg1) { return new Fragment("compiler", "package.not.visible", arg0, arg1); }
compiler.misc.package.not.visible=\ package {0} is not visible\n\ ({1})
/** * compiler.misc.package.not.visible=\ * package {0} is not visible\n\ * ({1}) */
public static Fragment PackageNotVisible(Symbol arg0, Fragment arg1) { return new Fragment("compiler", "package.not.visible", arg0, arg1); }
compiler.misc.partial.inst.sig=\ partially instantiated to: {0}
/** * compiler.misc.partial.inst.sig=\ * partially instantiated to: {0} */
public static Fragment PartialInstSig(Type arg0) { return new Fragment("compiler", "partial.inst.sig", arg0); }
compiler.misc.possible.loss.of.precision=\ possible lossy conversion from {0} to {1}
/** * compiler.misc.possible.loss.of.precision=\ * possible lossy conversion from {0} to {1} */
public static Fragment PossibleLossOfPrecision(Type arg0, Type arg1) { return new Fragment("compiler", "possible.loss.of.precision", arg0, arg1); }
compiler.misc.prob.found.req=\ incompatible types: {0}
/** * compiler.misc.prob.found.req=\ * incompatible types: {0} */
public static Fragment ProbFoundReq(JCDiagnostic arg0) { return new Fragment("compiler", "prob.found.req", arg0); }
compiler.misc.prob.found.req=\ incompatible types: {0}
/** * compiler.misc.prob.found.req=\ * incompatible types: {0} */
public static Fragment ProbFoundReq(Fragment arg0) { return new Fragment("compiler", "prob.found.req", arg0); }
compiler.misc.redundant.supertype=\ redundant interface {0} is extended by {1}
/** * compiler.misc.redundant.supertype=\ * redundant interface {0} is extended by {1} */
public static Fragment RedundantSupertype(Symbol arg0, Type arg1) { return new Fragment("compiler", "redundant.supertype", arg0, arg1); }
compiler.misc.redundant.supertype=\ redundant interface {0} is extended by {1}
/** * compiler.misc.redundant.supertype=\ * redundant interface {0} is extended by {1} */
public static Fragment RedundantSupertype(Symbol arg0, Symbol arg1) { return new Fragment("compiler", "redundant.supertype", arg0, arg1); }
compiler.misc.ref.ambiguous=\ reference to {0} is ambiguous\n\ both {1} {2} in {3} and {4} {5} in {6} match
/** * compiler.misc.ref.ambiguous=\ * reference to {0} is ambiguous\n\ * both {1} {2} in {3} and {4} {5} in {6} match */
public static Fragment RefAmbiguous(Name arg0, Kind arg1, Symbol arg2, Symbol arg3, Kind arg4, Symbol arg5, Symbol arg6) { return new Fragment("compiler", "ref.ambiguous", arg0, arg1, arg2, arg3, arg4, arg5, arg6); }
compiler.misc.report.access=\ {0} has {1} access in {2}
/** * compiler.misc.report.access=\ * {0} has {1} access in {2} */
public static Fragment ReportAccess(Symbol arg0, Set<? extends Modifier> arg1, Symbol arg2) { return new Fragment("compiler", "report.access", arg0, arg1, arg2); }
compiler.misc.resume.abort=\ R)esume, A)bort>
/** * compiler.misc.resume.abort=\ * R)esume, A)bort> */
public static final Fragment ResumeAbort = new Fragment("compiler", "resume.abort");
compiler.misc.source.unavailable=\ (source unavailable)
/** * compiler.misc.source.unavailable=\ * (source unavailable) */
public static final Fragment SourceUnavailable = new Fragment("compiler", "source.unavailable");
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)
/** * 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) */
public static final Fragment StatExprExpected = new Fragment("compiler", "stat.expr.expected");
compiler.misc.static=\ static
/** * compiler.misc.static=\ * static */
public static final Fragment Static = new Fragment("compiler", "static");
compiler.misc.static.mref.with.targs=\ parameterized qualifier on static method reference
/** * compiler.misc.static.mref.with.targs=\ * parameterized qualifier on static method reference */
public static final Fragment StaticMrefWithTargs = new Fragment("compiler", "static.mref.with.targs");
compiler.misc.switch.expression.target.cant.be.void=\ target-type for switch expression cannot be void
/** * compiler.misc.switch.expression.target.cant.be.void=\ * target-type for switch expression cannot be void */
public static final Fragment SwitchExpressionTargetCantBeVoid = new Fragment("compiler", "switch.expression.target.cant.be.void");
compiler.misc.synthetic.name.conflict=\ the symbol {0} conflicts with a compiler-synthesized symbol in {1}
/** * compiler.misc.synthetic.name.conflict=\ * the symbol {0} conflicts with a compiler-synthesized symbol in {1} */
public static Fragment SyntheticNameConflict(Symbol arg0, Symbol arg1) { return new Fragment("compiler", "synthetic.name.conflict", arg0, arg1); }
compiler.misc.throws.clause.not.allowed.for.canonical.constructor=\ throws clause not allowed for {0} constructor
/** * compiler.misc.throws.clause.not.allowed.for.canonical.constructor=\ * throws clause not allowed for {0} constructor */
public static Fragment ThrowsClauseNotAllowedForCanonicalConstructor(Fragment arg0) { return new Fragment("compiler", "throws.clause.not.allowed.for.canonical.constructor", arg0); }
compiler.misc.token.bad-symbol=\
/** * compiler.misc.token.bad-symbol=\ * <bad symbol> */
public static final Fragment TokenBadSymbol = new Fragment("compiler", "token.bad-symbol");
compiler.misc.token.character=\
/** * compiler.misc.token.character=\ * <character> */
public static final Fragment TokenCharacter = new Fragment("compiler", "token.character");
compiler.misc.token.double=\
/** * compiler.misc.token.double=\ * <double> */
public static final Fragment TokenDouble = new Fragment("compiler", "token.double");
compiler.misc.token.end-of-input=\
/** * compiler.misc.token.end-of-input=\ * <end of input> */
public static final Fragment TokenEndOfInput = new Fragment("compiler", "token.end-of-input");
compiler.misc.token.float=\
/** * compiler.misc.token.float=\ * <float> */
public static final Fragment TokenFloat = new Fragment("compiler", "token.float");
compiler.misc.token.identifier=\
/** * compiler.misc.token.identifier=\ * <identifier> */
public static final Fragment TokenIdentifier = new Fragment("compiler", "token.identifier");
compiler.misc.token.integer=\
/** * compiler.misc.token.integer=\ * <integer> */
public static final Fragment TokenInteger = new Fragment("compiler", "token.integer");
compiler.misc.token.long-integer=\
/** * compiler.misc.token.long-integer=\ * <long integer> */
public static final Fragment TokenLongInteger = new Fragment("compiler", "token.long-integer");
compiler.misc.token.string=\
/** * compiler.misc.token.string=\ * <string> */
public static final Fragment TokenString = new Fragment("compiler", "token.string");
compiler.misc.try.not.applicable.to.type=\ try-with-resources not applicable to variable type\n\ ({0})
/** * compiler.misc.try.not.applicable.to.type=\ * try-with-resources not applicable to variable type\n\ * ({0}) */
public static Fragment TryNotApplicableToType(JCDiagnostic arg0) { return new Fragment("compiler", "try.not.applicable.to.type", arg0); }
compiler.misc.try.not.applicable.to.type=\ try-with-resources not applicable to variable type\n\ ({0})
/** * compiler.misc.try.not.applicable.to.type=\ * try-with-resources not applicable to variable type\n\ * ({0}) */
public static Fragment TryNotApplicableToType(Fragment arg0) { return new Fragment("compiler", "try.not.applicable.to.type", arg0); }
compiler.misc.type.captureof=\ capture#{0} of {1}
/** * compiler.misc.type.captureof=\ * capture#{0} of {1} */
public static Fragment TypeCaptureof(Name arg0, Type arg1) { return new Fragment("compiler", "type.captureof", arg0, arg1); }
compiler.misc.type.captureof.1=\ capture#{0}
/** * compiler.misc.type.captureof.1=\ * capture#{0} */
public static final Fragment TypeCaptureof1 = new Fragment("compiler", "type.captureof.1");
compiler.misc.type.must.be.identical.to.corresponding.record.component.type=\ type and arity must match that of the corresponding record component\
/** * compiler.misc.type.must.be.identical.to.corresponding.record.component.type=\ * type and arity must match that of the corresponding record component\ */
public static final Fragment TypeMustBeIdenticalToCorrespondingRecordComponentType = new Fragment("compiler", "type.must.be.identical.to.corresponding.record.component.type");
compiler.misc.type.none=\
/** * compiler.misc.type.none=\ * <none> */
public static final Fragment TypeNone = new Fragment("compiler", "type.none");
compiler.misc.type.null=\
/** * compiler.misc.type.null=\ * <null> */
public static final Fragment TypeNull = new Fragment("compiler", "type.null");
compiler.misc.type.parameter=\ type parameter {0}
/** * compiler.misc.type.parameter=\ * type parameter {0} */
public static Fragment TypeParameter(Type arg0) { return new Fragment("compiler", "type.parameter", arg0); }
compiler.misc.type.req.array.or.iterable=\ array or java.lang.Iterable
/** * compiler.misc.type.req.array.or.iterable=\ * array or java.lang.Iterable */
public static final Fragment TypeReqArrayOrIterable = new Fragment("compiler", "type.req.array.or.iterable");
compiler.misc.type.req.class=\ class
/** * compiler.misc.type.req.class=\ * class */
public static final Fragment TypeReqClass = new Fragment("compiler", "type.req.class");
compiler.misc.type.req.class.array=\ class or array
/** * compiler.misc.type.req.class.array=\ * class or array */
public static final Fragment TypeReqClassArray = new Fragment("compiler", "type.req.class.array");
compiler.misc.type.req.exact=\ class or interface without bounds
/** * compiler.misc.type.req.exact=\ * class or interface without bounds */
public static final Fragment TypeReqExact = new Fragment("compiler", "type.req.exact");
compiler.misc.type.req.ref=\ reference
/** * compiler.misc.type.req.ref=\ * reference */
public static final Fragment TypeReqRef = new Fragment("compiler", "type.req.ref");
compiler.misc.type.var=\ {0}#{1}
/** * compiler.misc.type.var=\ * {0}#{1} */
public static Fragment TypeVar(Name arg0, int arg1) { return new Fragment("compiler", "type.var", arg0, arg1); }
compiler.misc.unable.to.access.file=\ unable to access file: {0}
/** * compiler.misc.unable.to.access.file=\ * unable to access file: {0} */
public static final Fragment UnableToAccessFile = new Fragment("compiler", "unable.to.access.file");
compiler.misc.unbound=\ unbound
/** * compiler.misc.unbound=\ * unbound */
public static final Fragment Unbound = new Fragment("compiler", "unbound");
compiler.misc.unchecked.assign=\ unchecked conversion
/** * compiler.misc.unchecked.assign=\ * unchecked conversion */
public static final Fragment UncheckedAssign = new Fragment("compiler", "unchecked.assign");
compiler.misc.unchecked.cast.to.type=\ unchecked cast
/** * compiler.misc.unchecked.cast.to.type=\ * unchecked cast */
public static final Fragment UncheckedCastToType = new Fragment("compiler", "unchecked.cast.to.type");
compiler.misc.unchecked.clash.with=\ {0} in {1} overrides {2} in {3}
/** * compiler.misc.unchecked.clash.with=\ * {0} in {1} overrides {2} in {3} */
public static Fragment UncheckedClashWith(Symbol arg0, Symbol arg1, Symbol arg2, Symbol arg3) { return new Fragment("compiler", "unchecked.clash.with", arg0, arg1, arg2, arg3); }
compiler.misc.unchecked.implement=\ {0} in {1} implements {2} in {3}
/** * compiler.misc.unchecked.implement=\ * {0} in {1} implements {2} in {3} */
public static Fragment UncheckedImplement(Symbol arg0, Symbol arg1, Symbol arg2, Symbol arg3) { return new Fragment("compiler", "unchecked.implement", arg0, arg1, arg2, arg3); }
compiler.misc.unchecked.override=\ {0} in {1} overrides {2} in {3}
/** * compiler.misc.unchecked.override=\ * {0} in {1} overrides {2} in {3} */
public static Fragment UncheckedOverride(Symbol arg0, Symbol arg1, Symbol arg2, Symbol arg3) { return new Fragment("compiler", "unchecked.override", arg0, arg1, arg2, arg3); }
compiler.misc.undecl.type.var=\ undeclared type variable: {0}
/** * compiler.misc.undecl.type.var=\ * undeclared type variable: {0} */
public static final Fragment UndeclTypeVar = new Fragment("compiler", "undecl.type.var");
compiler.misc.unexpected.const.pool.tag.at=\ unexpected constant pool tag: {0} at {1}
/** * compiler.misc.unexpected.const.pool.tag.at=\ * unexpected constant pool tag: {0} at {1} */
public static final Fragment UnexpectedConstPoolTagAt = new Fragment("compiler", "unexpected.const.pool.tag.at");
compiler.misc.unexpected.ret.val=\ unexpected return value
/** * compiler.misc.unexpected.ret.val=\ * unexpected return value */
public static final Fragment UnexpectedRetVal = new Fragment("compiler", "unexpected.ret.val");
compiler.misc.unicode.str.not.supported=\ unicode string in class file not supported
/** * compiler.misc.unicode.str.not.supported=\ * unicode string in class file not supported */
public static final Fragment UnicodeStrNotSupported = new Fragment("compiler", "unicode.str.not.supported");
compiler.misc.unnamed.module=\ unnamed module
/** * compiler.misc.unnamed.module=\ * unnamed module */
public static final Fragment UnnamedModule = new Fragment("compiler", "unnamed.module");
compiler.misc.unnamed.package=\ unnamed package
/** * compiler.misc.unnamed.package=\ * unnamed package */
public static final Fragment UnnamedPackage = new Fragment("compiler", "unnamed.package");
compiler.misc.upper.bounds=\ lower bounds: {0}
/** * compiler.misc.upper.bounds=\ * lower bounds: {0} */
public static Fragment UpperBounds(List<? extends Type> arg0) { return new Fragment("compiler", "upper.bounds", arg0); }
compiler.misc.user.selected.completion.failure=\ user-selected completion failure by class name
/** * compiler.misc.user.selected.completion.failure=\ * user-selected completion failure by class name */
public static final Fragment UserSelectedCompletionFailure = new Fragment("compiler", "user.selected.completion.failure");
compiler.misc.var.and.explicit.not.allowed=\ cannot mix ''var'' and explicitly-typed parameters
/** * compiler.misc.var.and.explicit.not.allowed=\ * cannot mix ''var'' and explicitly-typed parameters */
public static final Fragment VarAndExplicitNotAllowed = new Fragment("compiler", "var.and.explicit.not.allowed");
compiler.misc.var.and.implicit.not.allowed=\ cannot mix ''var'' and implicitly-typed parameters
/** * compiler.misc.var.and.implicit.not.allowed=\ * cannot mix ''var'' and implicitly-typed parameters */
public static final Fragment VarAndImplicitNotAllowed = new Fragment("compiler", "var.and.implicit.not.allowed");
compiler.misc.varargs.argument.mismatch=\ varargs mismatch; {0}
/** * compiler.misc.varargs.argument.mismatch=\ * varargs mismatch; {0} */
public static Fragment VarargsArgumentMismatch(JCDiagnostic arg0) { return new Fragment("compiler", "varargs.argument.mismatch", arg0); }
compiler.misc.varargs.argument.mismatch=\ varargs mismatch; {0}
/** * compiler.misc.varargs.argument.mismatch=\ * varargs mismatch; {0} */
public static Fragment VarargsArgumentMismatch(Fragment arg0) { return new Fragment("compiler", "varargs.argument.mismatch", arg0); }
compiler.misc.varargs.clash.with=\ {0} in {1} overrides {2} in {3}
/** * compiler.misc.varargs.clash.with=\ * {0} in {1} overrides {2} in {3} */
public static Fragment VarargsClashWith(Symbol arg0, Symbol arg1, Symbol arg2, Symbol arg3) { return new Fragment("compiler", "varargs.clash.with", arg0, arg1, arg2, arg3); }
compiler.misc.varargs.implement=\ {0} in {1} implements {2} in {3}
/** * compiler.misc.varargs.implement=\ * {0} in {1} implements {2} in {3} */
public static Fragment VarargsImplement(Symbol arg0, Symbol arg1, Symbol arg2, Symbol arg3) { return new Fragment("compiler", "varargs.implement", arg0, arg1, arg2, arg3); }
compiler.misc.varargs.override=\ {0} in {1} overrides {2} in {3}
/** * compiler.misc.varargs.override=\ * {0} in {1} overrides {2} in {3} */
public static Fragment VarargsOverride(Symbol arg0, Symbol arg1, Symbol arg2, Symbol arg3) { return new Fragment("compiler", "varargs.override", arg0, arg1, arg2, arg3); }
compiler.misc.varargs.trustme.on.non.varargs.accessor=\ Accessor {0} is not a varargs method.
/** * compiler.misc.varargs.trustme.on.non.varargs.accessor=\ * Accessor {0} is not a varargs method. */
public static Fragment VarargsTrustmeOnNonVarargsAccessor(Symbol arg0) { return new Fragment("compiler", "varargs.trustme.on.non.varargs.accessor", arg0); }
compiler.misc.varargs.trustme.on.non.varargs.meth=\ Method {0} is not a varargs method.
/** * compiler.misc.varargs.trustme.on.non.varargs.meth=\ * Method {0} is not a varargs method. */
public static Fragment VarargsTrustmeOnNonVarargsMeth(Symbol arg0) { return new Fragment("compiler", "varargs.trustme.on.non.varargs.meth", arg0); }
compiler.misc.varargs.trustme.on.reifiable.varargs=\ Varargs element type {0} is reifiable.
/** * compiler.misc.varargs.trustme.on.reifiable.varargs=\ * Varargs element type {0} is reifiable. */
public static Fragment VarargsTrustmeOnReifiableVarargs(Type arg0) { return new Fragment("compiler", "varargs.trustme.on.reifiable.varargs", arg0); }
compiler.misc.varargs.trustme.on.virtual.varargs=\ Instance method {0} is neither final nor private.
/** * compiler.misc.varargs.trustme.on.virtual.varargs=\ * Instance method {0} is neither final nor private. */
public static Fragment VarargsTrustmeOnVirtualVarargs(Symbol arg0) { return new Fragment("compiler", "varargs.trustme.on.virtual.varargs", arg0); }
compiler.misc.varargs.trustme.on.virtual.varargs.final.only=\ Instance method {0} is not final.
/** * compiler.misc.varargs.trustme.on.virtual.varargs.final.only=\ * Instance method {0} is not final. */
public static Fragment VarargsTrustmeOnVirtualVarargsFinalOnly(Symbol arg0) { return new Fragment("compiler", "varargs.trustme.on.virtual.varargs.final.only", arg0); }
compiler.misc.verbose.checking.attribution=\ [checking {0}]
/** * compiler.misc.verbose.checking.attribution=\ * [checking {0}] */
public static Fragment VerboseCheckingAttribution(Symbol arg0) { return new Fragment("compiler", "verbose.checking.attribution", arg0); }
compiler.misc.verbose.classpath=\ [search path for class files: {0}]
/** * compiler.misc.verbose.classpath=\ * [search path for class files: {0}] */
public static Fragment VerboseClasspath(String arg0) { return new Fragment("compiler", "verbose.classpath", arg0); }
compiler.misc.verbose.loading=\ [loading {0}]
/** * compiler.misc.verbose.loading=\ * [loading {0}] */
public static Fragment VerboseLoading(String arg0) { return new Fragment("compiler", "verbose.loading", arg0); }
compiler.misc.verbose.parsing.done=\ [parsing completed {0}ms]
/** * compiler.misc.verbose.parsing.done=\ * [parsing completed {0}ms] */
public static Fragment VerboseParsingDone(String arg0) { return new Fragment("compiler", "verbose.parsing.done", arg0); }
compiler.misc.verbose.parsing.started=\ [parsing started {0}]
/** * compiler.misc.verbose.parsing.started=\ * [parsing started {0}] */
public static Fragment VerboseParsingStarted(File arg0) { return new Fragment("compiler", "verbose.parsing.started", arg0); }
compiler.misc.verbose.parsing.started=\ [parsing started {0}]
/** * compiler.misc.verbose.parsing.started=\ * [parsing started {0}] */
public static Fragment VerboseParsingStarted(JavaFileObject arg0) { return new Fragment("compiler", "verbose.parsing.started", arg0); }
compiler.misc.verbose.parsing.started=\ [parsing started {0}]
/** * compiler.misc.verbose.parsing.started=\ * [parsing started {0}] */
public static Fragment VerboseParsingStarted(Path arg0) { return new Fragment("compiler", "verbose.parsing.started", arg0); }
compiler.misc.verbose.sourcepath=\ [search path for source files: {0}]
/** * compiler.misc.verbose.sourcepath=\ * [search path for source files: {0}] */
public static Fragment VerboseSourcepath(String arg0) { return new Fragment("compiler", "verbose.sourcepath", arg0); }
compiler.misc.verbose.total=\ [total {0}ms]
/** * compiler.misc.verbose.total=\ * [total {0}ms] */
public static Fragment VerboseTotal(String arg0) { return new Fragment("compiler", "verbose.total", arg0); }
compiler.misc.verbose.wrote.file=\ [wrote {0}]
/** * compiler.misc.verbose.wrote.file=\ * [wrote {0}] */
public static Fragment VerboseWroteFile(File arg0) { return new Fragment("compiler", "verbose.wrote.file", arg0); }
compiler.misc.verbose.wrote.file=\ [wrote {0}]
/** * compiler.misc.verbose.wrote.file=\ * [wrote {0}] */
public static Fragment VerboseWroteFile(JavaFileObject arg0) { return new Fragment("compiler", "verbose.wrote.file", arg0); }
compiler.misc.verbose.wrote.file=\ [wrote {0}]
/** * compiler.misc.verbose.wrote.file=\ * [wrote {0}] */
public static Fragment VerboseWroteFile(Path arg0) { return new Fragment("compiler", "verbose.wrote.file", arg0); }
compiler.misc.version.not.available=\ (version info not available)
/** * compiler.misc.version.not.available=\ * (version info not available) */
public static final Fragment VersionNotAvailable = new Fragment("compiler", "version.not.available");
compiler.misc.where.captured=\ {0} extends {1} super: {2} from capture of {3}
/** * compiler.misc.where.captured=\ * {0} extends {1} super: {2} from capture of {3} */
public static Fragment WhereCaptured(Type arg0, Type arg1, Type arg2, Type arg3) { return new Fragment("compiler", "where.captured", arg0, arg1, arg2, arg3); }
compiler.misc.where.captured.1=\ {0} extends {1} from capture of {3}
/** * compiler.misc.where.captured.1=\ * {0} extends {1} from capture of {3} */
public static Fragment WhereCaptured1(Type arg0, Type arg1, Void arg2, Type arg3) { return new Fragment("compiler", "where.captured.1", arg0, arg1, arg2, arg3); }
compiler.misc.where.description.captured=\ where {0} is a fresh type-variable:
/** * compiler.misc.where.description.captured=\ * where {0} is a fresh type-variable: */
public static final Fragment WhereDescriptionCaptured = new Fragment("compiler", "where.description.captured");
compiler.misc.where.description.captured.1=\ where {0} are fresh type-variables:
/** * compiler.misc.where.description.captured.1=\ * where {0} are fresh type-variables: */
public static Fragment WhereDescriptionCaptured1(Set<? extends Type> arg0) { return new Fragment("compiler", "where.description.captured.1", arg0); }
compiler.misc.where.description.intersection=\ where {0} is an intersection type:
/** * compiler.misc.where.description.intersection=\ * where {0} is an intersection type: */
public static Fragment WhereDescriptionIntersection(Set<? extends Type> arg0) { return new Fragment("compiler", "where.description.intersection", arg0); }
compiler.misc.where.description.intersection.1=\ where {0} are intersection types:
/** * compiler.misc.where.description.intersection.1=\ * where {0} are intersection types: */
public static Fragment WhereDescriptionIntersection1(Set<? extends Type> arg0) { return new Fragment("compiler", "where.description.intersection.1", arg0); }
compiler.misc.where.description.typevar=\ where {0} is a type-variable:
/** * compiler.misc.where.description.typevar=\ * where {0} is a type-variable: */
public static Fragment WhereDescriptionTypevar(Set<? extends Type> arg0) { return new Fragment("compiler", "where.description.typevar", arg0); }
compiler.misc.where.description.typevar.1=\ where {0} are type-variables:
/** * compiler.misc.where.description.typevar.1=\ * where {0} are type-variables: */
public static Fragment WhereDescriptionTypevar1(Set<? extends Type> arg0) { return new Fragment("compiler", "where.description.typevar.1", arg0); }
compiler.misc.where.fresh.typevar=\ {0} extends {1}
/** * compiler.misc.where.fresh.typevar=\ * {0} extends {1} */
public static Fragment WhereFreshTypevar(Type arg0, List<? extends Type> arg1) { return new Fragment("compiler", "where.fresh.typevar", arg0, arg1); }
compiler.misc.where.intersection=\ {0} extends {1}
/** * compiler.misc.where.intersection=\ * {0} extends {1} */
public static Fragment WhereIntersection(Type arg0, List<? extends Type> arg1) { return new Fragment("compiler", "where.intersection", arg0, arg1); }
compiler.misc.where.typevar=\ {0} extends {1} declared in {2} {3}
/** * compiler.misc.where.typevar=\ * {0} extends {1} declared in {2} {3} */
public static Fragment WhereTypevar(Type arg0, List<? extends Type> arg1, Kind arg2, Symbol arg3) { return new Fragment("compiler", "where.typevar", arg0, arg1, arg2, arg3); }
compiler.misc.where.typevar.1=\ {0} declared in {2} {3}
/** * compiler.misc.where.typevar.1=\ * {0} declared in {2} {3} */
public static Fragment WhereTypevar1(Type arg0, List<? extends Type> arg1, Kind arg2, Symbol arg3) { return new Fragment("compiler", "where.typevar.1", arg0, arg1, arg2, arg3); }
compiler.misc.wrong.number.type.args=\ wrong number of type arguments; required {0}
/** * compiler.misc.wrong.number.type.args=\ * wrong number of type arguments; required {0} */
public static Fragment WrongNumberTypeArgs(String arg0) { return new Fragment("compiler", "wrong.number.type.args", arg0); }
compiler.misc.wrong.version=\ class file has wrong version {0}.{1}, should be {2}.{3}
/** * compiler.misc.wrong.version=\ * class file has wrong version {0}.{1}, should be {2}.{3} */
public static final Fragment WrongVersion = new Fragment("compiler", "wrong.version");
compiler.misc.x.print.processor.info=\ Processor {0} matches {1} and returns {2}.
/** * compiler.misc.x.print.processor.info=\ * Processor {0} matches {1} and returns {2}. */
public static Fragment XPrintProcessorInfo(String arg0, String arg1, boolean arg2) { return new Fragment("compiler", "x.print.processor.info", arg0, arg1, arg2); }
compiler.misc.x.print.rounds=\ Round {0}:\n\tinput files: {1}\n\tannotations: {2}\n\tlast round: {3}
/** * compiler.misc.x.print.rounds=\ * Round {0}:\n\tinput files: {1}\n\tannotations: {2}\n\tlast round: {3} */
public static Fragment XPrintRounds(int arg0, String arg1, Set<? extends Symbol> arg2, boolean arg3) { return new Fragment("compiler", "x.print.rounds", arg0, arg1, arg2, arg3); } } }