-
-
Save bowbahdoe/3f6270a96260daa841329d7ef4a998d7 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
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; | |
import com.sun.tools.javac.util.JCDiagnostic.InfoFragment; | |
import com.sun.tools.javac.util.JCDiagnostic.HelpFragment; | |
public class CompilerProperties { | |
public static class Errors { | |
/** | |
* 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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
public static final Error AddmodsAllModulePathInvalid = new Error("compiler", "addmods.all.module.path.invalid"); | |
/** | |
* 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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
public static Error AlreadyDefinedThisUnit(Symbol arg0) { | |
return new Error("compiler", "already.defined.this.unit", arg0); | |
} | |
/** | |
* compiler.err.annotation.decl.not.allowed.here=\ | |
* annotation interface 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}'' | |
*/ | |
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} | |
*/ | |
public static Error AnnotationMissingDefaultValue1(Type arg0, List<? extends Name> arg1) { | |
return new Error("compiler", "annotation.missing.default.value.1", arg0, arg1); | |
} | |
/** | |
* compiler.err.annotation.missing.element.value=\ | |
* annotation is missing element value | |
*/ | |
public static final Error AnnotationMissingElementValue = new Error("compiler", "annotation.missing.element.value"); | |
/** | |
* 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 interface 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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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'' | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
public static final Error ArrayAndReceiver = new Error("compiler", "array.and.receiver"); | |
/** | |
* 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 | |
*/ | |
public static final Error ArrayDimensionMissing = new Error("compiler", "array.dimension.missing"); | |
/** | |
* 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 | |
*/ | |
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 | |
*/ | |
public static final Error AttributeValueMustBeConstant = new Error("compiler", "attribute.value.must.be.constant"); | |
/** | |
* 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} | |
*/ | |
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} | |
*/ | |
public static Error BadFunctionalIntfAnno1(Fragment arg0) { | |
return new Error("compiler", "bad.functional.intf.anno.1", arg0); | |
} | |
/** | |
* 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}'' | |
*/ | |
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}'' | |
*/ | |
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 | |
*/ | |
public static final Error BreakOutsideSwitchExpression = new Error("compiler", "break.outside.switch.expression"); | |
/** | |
* 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 | |
*/ | |
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 | |
*/ | |
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 ''<>'' | |
*/ | |
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 | |
*/ | |
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}) | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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}) | |
*/ | |
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} | |
*/ | |
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'' | |
*/ | |
public static final Error CantAssignValToThis = new Error("compiler", "cant.assign.val.to.this"); | |
/** | |
* 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 | |
*/ | |
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}) | |
*/ | |
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}) | |
*/ | |
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}> | |
*/ | |
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 | |
*/ | |
public static final Error CantInheritFromAnon = new Error("compiler", "cant.inherit.from.anon"); | |
/** | |
* 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) | |
*/ | |
public static Error CantInheritFromSealed(Symbol arg0) { | |
return new Error("compiler", "cant.inherit.from.sealed", arg0); | |
} | |
/** | |
* 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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
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}) | |
*/ | |
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}) | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
@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} | |
*/ | |
@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 | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
public static Error CantTypeAnnotateScoping1(Compound arg0) { | |
return new Error("compiler", "cant.type.annotate.scoping.1", arg0); | |
} | |
/** | |
* 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 | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
public static Error ConflictingExportsToModule(Symbol arg0) { | |
return new Error("compiler", "conflicting.exports.to.module", arg0); | |
} | |
/** | |
* 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} | |
*/ | |
public static Error ConflictingOpensToModule(Symbol arg0) { | |
return new Error("compiler", "conflicting.opens.to.module", arg0); | |
} | |
/** | |
* compiler.err.const.expr.req=\ | |
* constant expression required | |
*/ | |
public static final Error ConstExprReq = new Error("compiler", "const.expr.req"); | |
/** | |
* compiler.err.constant.label.not.compatible=\ | |
* constant label of type {0} is not compatible with switch selector type {1} | |
*/ | |
public static Error ConstantLabelNotCompatible(Type arg0, Type arg1) { | |
return new Error("compiler", "constant.label.not.compatible", arg0, arg1); | |
} | |
/** | |
* 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 | |
*/ | |
public static final Error ContinueOutsideSwitchExpression = new Error("compiler", "continue.outside.switch.expression"); | |
/** | |
* 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} | |
*/ | |
public static Error CyclicInheritance(Symbol arg0) { | |
return new Error("compiler", "cyclic.inheritance", arg0); | |
} | |
/** | |
* 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} | |
*/ | |
public static Error CyclicRequires(Symbol arg0) { | |
return new Error("compiler", "cyclic.requires", arg0); | |
} | |
/** | |
* 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 | |
*/ | |
public static final Error DcBadInlineTag = new Error("compiler", "dc.bad.inline.tag"); | |
/** | |
* compiler.err.dc.gt.expected=\ | |
* ''>'' expected | |
*/ | |
public static final Error DcGtExpected = new Error("compiler", "dc.gt.expected"); | |
/** | |
* compiler.err.dc.identifier.expected=\ | |
* identifier expected | |
*/ | |
public static final Error DcIdentifierExpected = new Error("compiler", "dc.identifier.expected"); | |
/** | |
* compiler.err.dc.invalid.html=\ | |
* invalid HTML | |
*/ | |
public static final Error DcInvalidHtml = new Error("compiler", "dc.invalid.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 | |
*/ | |
public static final Error DcMissingSemicolon = new Error("compiler", "dc.missing.semicolon"); | |
/** | |
* 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 '@' | |
*/ | |
public static final Error DcNoTagName = new Error("compiler", "dc.no.tag.name"); | |
/** | |
* compiler.err.dc.no.title=\ | |
* no title | |
*/ | |
public static final Error DcNoTitle = new Error("compiler", "dc.no.title"); | |
/** | |
* compiler.err.dc.no.url=\ | |
* no URL | |
*/ | |
public static final Error DcNoUrl = new Error("compiler", "dc.no.url"); | |
/** | |
* compiler.err.dc.ref.annotations.not.allowed=\ | |
* annotations not allowed | |
*/ | |
public static final Error DcRefAnnotationsNotAllowed = new Error("compiler", "dc.ref.annotations.not.allowed"); | |
/** | |
* compiler.err.dc.ref.bad.parens=\ | |
* unexpected text after parenthesis | |
*/ | |
public static final Error DcRefBadParens = new Error("compiler", "dc.ref.bad.parens"); | |
/** | |
* 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 | |
*/ | |
public static final Error DcRefUnexpectedInput = new Error("compiler", "dc.ref.unexpected.input"); | |
/** | |
* 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 | |
*/ | |
public static final Error DcUnterminatedInlineTag = new Error("compiler", "dc.unterminated.inline.tag"); | |
/** | |
* 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 | |
*/ | |
public static final Error DcUnterminatedString = new Error("compiler", "dc.unterminated.string"); | |
/** | |
* compiler.err.deconstruction.pattern.only.records=\ | |
* deconstruction patterns can only be applied to records, {0} is not a record | |
*/ | |
public static Error DeconstructionPatternOnlyRecords(Symbol arg0) { | |
return new Error("compiler", "deconstruction.pattern.only.records", arg0); | |
} | |
/** | |
* compiler.err.default.allowed.in.intf.annotation.member=\ | |
* default value only allowed in an annotation interface declaration | |
*/ | |
public static final Error DefaultAllowedInIntfAnnotationMember = new Error("compiler", "default.allowed.in.intf.annotation.member"); | |
/** | |
* compiler.err.default.label.not.allowed=\ | |
* default label not allowed here | |
*/ | |
public static final Error DefaultLabelNotAllowed = new Error("compiler", "default.label.not.allowed"); | |
/** | |
* 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} | |
*/ | |
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 | |
*/ | |
public static Error DoesntExist(Symbol arg0) { | |
return new Error("compiler", "doesnt.exist", arg0); | |
} | |
/** | |
* 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 | |
*/ | |
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}. | |
*/ | |
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 interface | |
*/ | |
public static Error DuplicateAnnotationMissingContainer(Type arg0) { | |
return new Error("compiler", "duplicate.annotation.missing.container", arg0); | |
} | |
/** | |
* 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} | |
*/ | |
public static Error DuplicateClass(Name arg0) { | |
return new Error("compiler", "duplicate.class", arg0); | |
} | |
/** | |
* 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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
public static Error DuplicateProvides(Symbol arg0, Symbol arg1) { | |
return new Error("compiler", "duplicate.provides", arg0, arg1); | |
} | |
/** | |
* compiler.err.duplicate.requires=\ | |
* duplicate requires: {0} | |
*/ | |
public static Error DuplicateRequires(Symbol arg0) { | |
return new Error("compiler", "duplicate.requires", arg0); | |
} | |
/** | |
* compiler.err.duplicate.unconditional.pattern=\ | |
* duplicate unconditional pattern | |
*/ | |
public static final Error DuplicateUnconditionalPattern = new Error("compiler", "duplicate.unconditional.pattern"); | |
/** | |
* 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'' | |
*/ | |
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'' | |
*/ | |
public static final Error EmptyAArgument = new Error("compiler", "empty.A.argument"); | |
/** | |
* 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 | |
*/ | |
public static Error EnclClassRequired(Symbol arg0) { | |
return new Error("compiler", "encl.class.required", arg0); | |
} | |
/** | |
* compiler.err.enclosing.class.type.non.denotable=\ | |
* enclosing class type: {0}\n\ | |
* is non-denotable, try casting to a denotable type | |
*/ | |
public static Error EnclosingClassTypeNonDenotable(Type arg0) { | |
return new Error("compiler", "enclosing.class.type.non.denotable", arg0); | |
} | |
/** | |
* 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 | |
*/ | |
public static final Error EnumAsIdentifier = new Error("compiler", "enum.as.identifier"); | |
/** | |
* compiler.err.enum.cant.be.generic=\ | |
* enums cannot be generic | |
*/ | |
public static final Error EnumCantBeGeneric = new Error("compiler", "enum.cant.be.generic"); | |
/** | |
* compiler.err.enum.cant.be.instantiated=\ | |
* enum classes 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 | |
*/ | |
public static final Error EnumConstantExpected = new Error("compiler", "enum.constant.expected"); | |
/** | |
* 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 | |
*/ | |
public static final Error EnumLabelMustBeUnqualifiedEnum = new Error("compiler", "enum.label.must.be.unqualified.enum"); | |
/** | |
* 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 | |
*/ | |
public static final Error EnumNoSubclassing = new Error("compiler", "enum.no.subclassing"); | |
/** | |
* compiler.err.enum.types.not.extensible=\ | |
* enum classes are not extensible | |
*/ | |
public static final Error EnumTypesNotExtensible = new Error("compiler", "enum.types.not.extensible"); | |
/** | |
* compiler.err.error=\ | |
* error:\u0020 | |
*/ | |
public static final Error Error = new Error("compiler", "error"); | |
/** | |
* 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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
public static Error ExceptNeverThrownInTry(Type arg0) { | |
return new Error("compiler", "except.never.thrown.in.try", arg0); | |
} | |
/** | |
* compiler.err.expected=\ | |
* {0} expected | |
*/ | |
public static Error Expected(TokenKind arg0) { | |
return new Error("compiler", "expected", arg0); | |
} | |
/** | |
* 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 | |
*/ | |
public static final Error ExpectedModuleOrOpen = new Error("compiler", "expected.module.or.open"); | |
/** | |
* 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 | |
*/ | |
public static Error Expected2(TokenKind arg0, TokenKind arg1) { | |
return new Error("compiler", "expected2", arg0, arg1); | |
} | |
/** | |
* 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 | |
*/ | |
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 | |
*/ | |
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}) | |
*/ | |
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}) | |
*/ | |
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}) | |
*/ | |
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}) | |
*/ | |
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} | |
*/ | |
public static Error FileNotDirectory(String arg0) { | |
return new Error("compiler", "file.not.directory", arg0); | |
} | |
/** | |
* 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} | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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'' | |
*/ | |
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} | |
*/ | |
public static Error FirstStatementMustBeCallToAnotherConstructor(Symbol arg0) { | |
return new Error("compiler", "first.statement.must.be.call.to.another.constructor", arg0); | |
} | |
/** | |
* compiler.err.flows.through.from.pattern=\ | |
* illegal fall-through from a pattern | |
*/ | |
public static final Error FlowsThroughFromPattern = new Error("compiler", "flows.through.from.pattern"); | |
/** | |
* compiler.err.flows.through.to.pattern=\ | |
* illegal fall-through to a pattern | |
*/ | |
public static final Error FlowsThroughToPattern = new Error("compiler", "flows.through.to.pattern"); | |
/** | |
* 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} | |
*/ | |
public static Error ForeachNotApplicableToType(Type arg0, Fragment arg1) { | |
return new Error("compiler", "foreach.not.applicable.to.type", arg0, arg1); | |
} | |
/** | |
* compiler.err.foreach.not.exhaustive.on.type=\ | |
* Pattern {0} is not exhaustive on {1} | |
*/ | |
public static Error ForeachNotExhaustiveOnType(Type arg0, Type arg1) { | |
return new Error("compiler", "foreach.not.exhaustive.on.type", arg0, arg1); | |
} | |
/** | |
* 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 | |
*/ | |
public static final Error FpNumberTooSmall = new Error("compiler", "fp.number.too.small"); | |
/** | |
* 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 | |
*/ | |
public static final Error GenericThrowable = new Error("compiler", "generic.throwable"); | |
/** | |
* compiler.err.guard.has.constant.expression.false=\ | |
* this case label has a guard that is a constant expression with value ''false'' | |
*/ | |
public static final Error GuardHasConstantExpressionFalse = new Error("compiler", "guard.has.constant.expression.false"); | |
/** | |
* 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} | |
*/ | |
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 | |
*/ | |
public static final Error IllegalArrayCreationBothDimensionAndInitialization = new Error("compiler", "illegal.array.creation.both.dimension.and.initialization"); | |
/** | |
* 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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
public static Error IllegalDefaultSuperCall(Type arg0, Fragment arg1) { | |
return new Error("compiler", "illegal.default.super.call", arg0, arg1); | |
} | |
/** | |
* 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 | |
*/ | |
public static final Error IllegalEnumStaticRef = new Error("compiler", "illegal.enum.static.ref"); | |
/** | |
* 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 | |
*/ | |
public static final Error IllegalForwardRef = new Error("compiler", "illegal.forward.ref"); | |
/** | |
* 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 | |
*/ | |
public static final Error IllegalLineEndInCharLit = new Error("compiler", "illegal.line.end.in.char.lit"); | |
/** | |
* 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 | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
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}'' | |
*/ | |
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 | |
*/ | |
public static final Error IllegalSelfRef = new Error("compiler", "illegal.self.ref"); | |
/** | |
* 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 | |
*/ | |
public static final Error IllegalStartOfStmt = new Error("compiler", "illegal.start.of.stmt"); | |
/** | |
* 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}'' | |
*/ | |
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 | |
*/ | |
public static final Error IllegalTextBlockOpen = new Error("compiler", "illegal.text.block.open"); | |
/** | |
* compiler.err.illegal.underscore=\ | |
* illegal underscore | |
*/ | |
public static final Error IllegalUnderscore = new Error("compiler", "illegal.underscore"); | |
/** | |
* 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} | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
public static final Error ImproperlyFormedTypeParamMissing = new Error("compiler", "improperly.formed.type.param.missing"); | |
/** | |
* 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.diff.ret.same.type=\ | |
* type {0} defines {1}({2}) more than once with unrelated return types | |
*/ | |
public static Error IncompatibleDiffRetSameType(Type arg0, Name arg1, List<? extends Type> arg2) { | |
return new Error("compiler", "incompatible.diff.ret.same.type", arg0, arg1, arg2); | |
} | |
/** | |
* 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} | |
*/ | |
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} | |
*/ | |
public static Error IncorrectConstructorReceiverType(Type arg0, Type arg1) { | |
return new Error("compiler", "incorrect.constructor.receiver.type", arg0, arg1); | |
} | |
/** | |
* compiler.err.incorrect.number.of.nested.patterns=\ | |
* incorrect number of nested patterns\n\ | |
* required: {0}\n\ | |
* found: {1} | |
*/ | |
public static Error IncorrectNumberOfNestedPatterns(List<? extends Type> arg0, List<? extends Type> arg1) { | |
return new Error("compiler", "incorrect.number.of.nested.patterns", arg0, arg1); | |
} | |
/** | |
* 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} | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
public static final Error InstanceInitializerNotAllowedInRecords = new Error("compiler", "instance.initializer.not.allowed.in.records"); | |
/** | |
* compiler.err.instanceof.pattern.no.subtype=\ | |
* expression type {0} is a subtype of pattern 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} | |
*/ | |
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 | |
*/ | |
public static Error IntNumberTooLarge(String arg0) { | |
return new Error("compiler", "int.number.too.large", arg0); | |
} | |
/** | |
* compiler.err.intf.annotation.cant.have.type.params=\ | |
* annotation interface {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 interface {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 interface 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 interface 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 | |
*/ | |
public static final Error IntfExpectedHere = new Error("compiler", "intf.expected.here"); | |
/** | |
* 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 | |
*/ | |
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 | |
*/ | |
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}) | |
*/ | |
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 interface 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 | |
*/ | |
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}) | |
*/ | |
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.case.label.combination=\ | |
* invalid case label combination | |
*/ | |
public static final Error InvalidCaseLabelCombination = new Error("compiler", "invalid.case.label.combination"); | |
/** | |
* 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 | |
*/ | |
public static final Error InvalidHexNumber = new Error("compiler", "invalid.hex.number"); | |
/** | |
* 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 | |
*/ | |
public static final Error InvalidMethDeclRetTypeReq = new Error("compiler", "invalid.meth.decl.ret.type.req"); | |
/** | |
* 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} | |
*/ | |
public static Error InvalidModuleSpecifier(String arg0) { | |
return new Error("compiler", "invalid.module.specifier", arg0); | |
} | |
/** | |
* 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} | |
*/ | |
public static Error InvalidMref(KindName arg0, Fragment arg1) { | |
return new Error("compiler", "invalid.mref", arg0, arg1); | |
} | |
/** | |
* 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}) | |
*/ | |
public static Error InvalidPermitsClause(Fragment arg0) { | |
return new Error("compiler", "invalid.permits.clause", arg0); | |
} | |
/** | |
* 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 | |
*/ | |
public static Error InvalidRepeatableAnnotation(Symbol arg0) { | |
return new Error("compiler", "invalid.repeatable.annotation", arg0); | |
} | |
/** | |
* compiler.err.invalid.repeatable.annotation.elem.nondefault=\ | |
* containing annotation interface ({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 interface ({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 interface ({0}) is applicable to more targets than repeatable annotation interface ({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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
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 interface ({1}) is @Documented while containing annotation interface ({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 interface ({1}) is @Inherited while containing annotation interface ({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 | |
*/ | |
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 interface ({0}) is shorter than the retention of repeatable annotation interface ({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 interface ({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 interface ({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} | |
*/ | |
public static Error InvalidSource(String arg0) { | |
return new Error("compiler", "invalid.source", arg0); | |
} | |
/** | |
* 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} | |
*/ | |
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) | |
*/ | |
public static final Error InvalidYield = new Error("compiler", "invalid.yield"); | |
/** | |
* 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 a preview API and is disabled by default.\n\ | |
* (use --enable-preview to enable preview APIs) | |
*/ | |
public static Error IsPreview(Symbol arg0) { | |
return new Error("compiler", "is.preview", arg0); | |
} | |
/** | |
* 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 | |
*/ | |
public static final Error LambdaBodyNeitherValueNorVoidCompatible = new Error("compiler", "lambda.body.neither.value.nor.void.compatible"); | |
/** | |
* 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 | |
*/ | |
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 | |
*/ | |
public static final Error LimitDimensions = new Error("compiler", "limit.dimensions"); | |
/** | |
* 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 | |
*/ | |
public static final Error LimitParameters = new Error("compiler", "limit.parameters"); | |
/** | |
* 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} | |
*/ | |
public static final Error LimitPoolInClass = new Error("compiler", "limit.pool.in.class"); | |
/** | |
* 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 | |
*/ | |
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 | |
*/ | |
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\ | |
*/ | |
public static Error LocalClassesCantExtendSealed(Fragment arg0) { | |
return new Error("compiler", "local.classes.cant.extend.sealed", arg0); | |
} | |
/** | |
* compiler.err.local.enum=\ | |
* enum classes must not be local | |
*/ | |
public static final Error LocalEnum = new Error("compiler", "local.enum"); | |
/** | |
* 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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
public static final Error MalformedFpLit = new Error("compiler", "malformed.fp.lit"); | |
/** | |
* 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 | |
*/ | |
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 | |
*/ | |
public static final Error MissingMethBodyOrDeclAbstract = new Error("compiler", "missing.meth.body.or.decl.abstract"); | |
/** | |
* 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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
public static Error ModuleNonZeroOpens(Name arg0) { | |
return new Error("compiler", "module.non.zero.opens", arg0); | |
} | |
/** | |
* 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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
public static final Error NewNotAllowedInAnnotation = new Error("compiler", "new.not.allowed.in.annotation"); | |
/** | |
* 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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
public static final Error NoIntfExpectedHere = new Error("compiler", "no.intf.expected.here"); | |
/** | |
* compiler.err.no.java.lang=\ | |
* Unable to find package java.lang in platform classes | |
*/ | |
public static final Error NoJavaLang = new Error("compiler", "no.java.lang"); | |
/** | |
* 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 | |
*/ | |
public static final Error NoOpensUnlessStrong = new Error("compiler", "no.opens.unless.strong"); | |
/** | |
* 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 | |
*/ | |
public static final Error NoPkgInModuleInfoJava = new Error("compiler", "no.pkg.in.module-info.java"); | |
/** | |
* 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 | |
*/ | |
public static final Error NoSourceFilesClasses = new Error("compiler", "no.source.files.classes"); | |
/** | |
* 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 | |
*/ | |
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) | |
*/ | |
public static final Error NoSwitchExpressionQualify = new Error("compiler", "no.switch.expression.qualify"); | |
/** | |
* 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} | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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) | |
*/ | |
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 interface | |
*/ | |
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 | |
*/ | |
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}) | |
*/ | |
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}) | |
*/ | |
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}) | |
*/ | |
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}) | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
public static final Error NotExhaustive = new Error("compiler", "not.exhaustive"); | |
/** | |
* compiler.err.not.exhaustive.statement=\ | |
* the switch statement does not cover all possible input values | |
*/ | |
public static final Error NotExhaustiveStatement = new Error("compiler", "not.exhaustive.statement"); | |
/** | |
* 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}'' | |
*/ | |
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} | |
*/ | |
public static Error NotLoopLabel(Name arg0) { | |
return new Error("compiler", "not.loop.label", arg0); | |
} | |
/** | |
* 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} | |
*/ | |
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} | |
*/ | |
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}'' | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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. | |
*/ | |
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. | |
*/ | |
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 | |
*/ | |
public static Error OptionTooMany(String arg0) { | |
return new Error("compiler", "option.too.many", arg0); | |
} | |
/** | |
* 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 | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
public static Error OverrideStatic(JCDiagnostic arg0) { | |
return new Error("compiler", "override.static", arg0); | |
} | |
/** | |
* 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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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}) | |
*/ | |
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}) | |
*/ | |
public static Error PackageNotVisible(Symbol arg0, Fragment arg1) { | |
return new Error("compiler", "package.not.visible", arg0, arg1); | |
} | |
/** | |
* compiler.err.pattern.dominated=\ | |
* this case label is dominated by a preceding case label | |
*/ | |
public static final Error PatternDominated = new Error("compiler", "pattern.dominated"); | |
/** | |
* compiler.err.pattern.expected=\ | |
* type pattern expected | |
*/ | |
public static final Error PatternExpected = new Error("compiler", "pattern.expected"); | |
/** | |
* compiler.err.pattern.type.cannot.infer=\ | |
* cannot infer pattern type | |
*/ | |
public static final Error PatternTypeCannotInfer = new Error("compiler", "pattern.type.cannot.infer"); | |
/** | |
* 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 | |
*/ | |
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} | |
*/ | |
public static Error PluginNotFound(String arg0) { | |
return new Error("compiler", "plugin.not.found", arg0); | |
} | |
/** | |
* 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}) | |
*/ | |
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}) | |
*/ | |
public static Error PreviewFeatureDisabled(Fragment arg0) { | |
return new Error("compiler", "preview.feature.disabled", arg0); | |
} | |
/** | |
* compiler.err.preview.feature.disabled.classfile=\ | |
* class file for {0} uses preview features of Java SE {1}.\n\ | |
* (use --enable-preview to allow loading of class files 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}) | |
*/ | |
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}) | |
*/ | |
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}) | |
*/ | |
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 | |
*/ | |
public static final Error PreviewWithoutSourceOrRelease = new Error("compiler", "preview.without.source.or.release"); | |
/** | |
* 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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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}''. | |
*/ | |
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}''. | |
*/ | |
public static Error ProcCantLoadClass(String arg0) { | |
return new Error("compiler", "proc.cant.load.class", arg0); | |
} | |
/** | |
* 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 | |
*/ | |
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. | |
*/ | |
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}'' | |
*/ | |
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}'' | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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. | |
*/ | |
public static final Error ProcServiceProblem = new Error("compiler", "proc.service.problem"); | |
/** | |
* 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 | |
*/ | |
public static final Error ProfileBootclasspathConflict = new Error("compiler", "profile.bootclasspath.conflict"); | |
/** | |
* 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 | |
*/ | |
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) | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
public static final Error RecordComponentAndOldArraySyntax = new Error("compiler", "record.component.and.old.array.syntax"); | |
/** | |
* 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 | |
*/ | |
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 | |
*/ | |
public static Error ReleaseBootclasspathConflict(Option arg0) { | |
return new Error("compiler", "release.bootclasspath.conflict", arg0); | |
} | |
/** | |
* 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 | |
*/ | |
public static final Error RepeatedInterface = new Error("compiler", "repeated.interface"); | |
/** | |
* 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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
public static Error RestrictedTypeNotAllowedHere(Name arg0) { | |
return new Error("compiler", "restricted.type.not.allowed.here", arg0); | |
} | |
/** | |
* 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 | |
*/ | |
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) | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
public static final Error SourcepathModulesourcepathConflict = new Error("compiler", "sourcepath.modulesourcepath.conflict"); | |
/** | |
* 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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
public static final Error StaticMethodsCannotBeAnnotatedWithOverride = new Error("compiler", "static.methods.cannot.be.annotated.with.override"); | |
/** | |
* 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 | |
*/ | |
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) | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
public static final Error SwitchMixingCaseTypes = new Error("compiler", "switch.mixing.case.types"); | |
/** | |
* 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 | |
*/ | |
public static final Error ThrowsNotAllowedInIntfAnnotation = new Error("compiler", "throws.not.allowed.in.intf.annotation"); | |
/** | |
* 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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
public static final Error UnclosedCharLit = new Error("compiler", "unclosed.char.lit"); | |
/** | |
* compiler.err.unclosed.comment=\ | |
* unclosed comment | |
*/ | |
public static final Error UnclosedComment = new Error("compiler", "unclosed.comment"); | |
/** | |
* 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 | |
*/ | |
public static final Error UnclosedTextBlock = new Error("compiler", "unclosed.text.block"); | |
/** | |
* compiler.err.unconditional.pattern.and.default=\ | |
* switch has both an unconditional pattern and a default label | |
*/ | |
public static final Error UnconditionalPatternAndDefault = new Error("compiler", "unconditional.pattern.and.default"); | |
/** | |
* 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 | |
*/ | |
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) | |
*/ | |
public static final Error UnderscoreAsIdentifierInLambda = new Error("compiler", "underscore.as.identifier.in.lambda"); | |
/** | |
* 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 | |
*/ | |
public static final Error UnexpectedMref = new Error("compiler", "unexpected.mref"); | |
/** | |
* 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} | |
*/ | |
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 | |
*/ | |
public static final Error UnnamedPkgNotAllowedNamedModules = new Error("compiler", "unnamed.pkg.not.allowed.named.modules"); | |
/** | |
* 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 | |
*/ | |
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}'' | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
public static Error UnsupportedEncoding(String arg0) { | |
return new Error("compiler", "unsupported.encoding", arg0); | |
} | |
/** | |
* 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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
public static final Error VarargsAndReceiver = new Error("compiler", "varargs.and.receiver"); | |
/** | |
* 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} | |
*/ | |
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 | |
*/ | |
public static final Error VarargsMustBeLast = new Error("compiler", "varargs.must.be.last"); | |
/** | |
* 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 | |
*/ | |
public static final Error VoidNotAllowedHere = new Error("compiler", "void.not.allowed.here"); | |
/** | |
* 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} | |
*/ | |
public static Error WrongNumberTypeArgs(String arg0) { | |
return new Error("compiler", "wrong.number.type.args", arg0); | |
} | |
/** | |
* compiler.err.wrong.receiver =\ | |
* wrong receiver parameter name | |
*/ | |
public static final Error WrongReceiver = new Error("compiler", "wrong.receiver"); | |
} | |
public static class Warnings { | |
/** | |
* compiler.warn.OSF.array.SPF=\ | |
* serialPersistentFields must be of type java.io.ObjectStreamField[] to be effective | |
*/ | |
public static final Warning OSFArraySPF = new Warning("compiler", "OSF.array.SPF"); | |
/** | |
* compiler.warn.SPF.null.init=\ | |
* serialPersistentFields ineffective if initialized to null.\n\ | |
* Initialize to an empty array to indicate no fields | |
*/ | |
public static final Warning SPFNullInit = new Warning("compiler", "SPF.null.init"); | |
/** | |
* 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 | |
*/ | |
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 | |
*/ | |
public static final Warning AddopensIgnored = new Warning("compiler", "addopens.ignored"); | |
/** | |
* 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} | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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}'' | |
*/ | |
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. | |
*/ | |
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. | |
*/ | |
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. | |
*/ | |
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} | |
*/ | |
public static Warning ConstantSVUID(Symbol arg0) { | |
return new Warning("compiler", "constant.SVUID", arg0); | |
} | |
/** | |
* compiler.warn.declared.using.preview=\ | |
* {0} {1} is declared using a preview feature, which may be removed in a future release. | |
*/ | |
public static Warning DeclaredUsingPreview(KindName arg0, Symbol arg1) { | |
return new Warning("compiler", "declared.using.preview", arg0, arg1); | |
} | |
/** | |
* compiler.warn.default.ineffective=\ | |
* serialization-related default method from an interface will not be run by serialization for an implementing class | |
*/ | |
public static final Warning DefaultIneffective = new Warning("compiler", "default.ineffective"); | |
/** | |
* 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). | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
public static Warning DirPathElementNotFound(Path arg0) { | |
return new Warning("compiler", "dir.path.element.not.found", arg0); | |
} | |
/** | |
* 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 | |
*/ | |
public static final Warning DoclintNotAvailable = new Warning("compiler", "doclint.not.available"); | |
/** | |
* compiler.warn.empty.if=\ | |
* empty statement after if | |
*/ | |
public static final Warning EmptyIf = new Warning("compiler", "empty.if"); | |
/** | |
* compiler.warn.externalizable.missing.public.no.arg.ctor=\ | |
* an Externalizable class needs a public no-arg constructor | |
*/ | |
public static final Warning ExternalizableMissingPublicNoArgCtor = new Warning("compiler", "externalizable.missing.public.no.arg.ctor"); | |
/** | |
* 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} | |
*/ | |
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} | |
*/ | |
public static Warning FileFromFuture(Path arg0) { | |
return new Warning("compiler", "file.from.future", arg0); | |
} | |
/** | |
* 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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
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}'' | |
*/ | |
public static Warning IllegalRefToRestrictedType(Name arg0) { | |
return new Warning("compiler", "illegal.ref.to.restricted.type", arg0); | |
} | |
/** | |
* compiler.warn.improper.SPF=\ | |
* serialPersistentFields must be declared private static final to be effective | |
*/ | |
public static final Warning ImproperSPF = new Warning("compiler", "improper.SPF"); | |
/** | |
* 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 | |
*/ | |
public static final Warning InconsistentWhiteSpaceIndentation = new Warning("compiler", "inconsistent.white.space.indentation"); | |
/** | |
* compiler.warn.incubating.modules=\ | |
* using incubating module(s): {0} | |
*/ | |
public static Warning IncubatingModules(String arg0) { | |
return new Warning("compiler", "incubating.modules", arg0); | |
} | |
/** | |
* compiler.warn.ineffectual.serial.field.enum=\ | |
* serialization-related field {0} is not effective in an enum class | |
*/ | |
public static Warning IneffectualSerialFieldEnum(String arg0) { | |
return new Warning("compiler", "ineffectual.serial.field.enum", arg0); | |
} | |
/** | |
* compiler.warn.ineffectual.serial.field.externalizable=\ | |
* serialPersistentFields is not effective in an Externalizable class | |
*/ | |
public static final Warning IneffectualSerialFieldExternalizable = new Warning("compiler", "ineffectual.serial.field.externalizable"); | |
/** | |
* compiler.warn.ineffectual.serial.field.interface=\ | |
* serialPersistentFields is not effective in an interface | |
*/ | |
public static final Warning IneffectualSerialFieldInterface = new Warning("compiler", "ineffectual.serial.field.interface"); | |
/** | |
* compiler.warn.ineffectual.serial.field.record=\ | |
* serialPersistentFields is not effective in a record class | |
*/ | |
public static final Warning IneffectualSerialFieldRecord = new Warning("compiler", "ineffectual.serial.field.record"); | |
/** | |
* compiler.warn.ineffectual.serial.method.enum=\ | |
* serialization-related method {0} is not effective in an enum class | |
*/ | |
public static Warning IneffectualSerialMethodEnum(String arg0) { | |
return new Warning("compiler", "ineffectual.serial.method.enum", arg0); | |
} | |
/** | |
* compiler.warn.ineffectual.serial.method.externalizable=\ | |
* serialization-related method {0} is not effective in an Externalizable class | |
*/ | |
public static Warning IneffectualSerialMethodExternalizable(Name arg0) { | |
return new Warning("compiler", "ineffectual.serial.method.externalizable", arg0); | |
} | |
/** | |
* compiler.warn.ineffectual.serial.method.record=\ | |
* serialization-related method {0} is not effective in a record class | |
*/ | |
public static Warning IneffectualSerialMethodRecord(String arg0) { | |
return new Warning("compiler", "ineffectual.serial.method.record", 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 | |
*/ | |
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} | |
*/ | |
public static Warning InvalidArchiveFile(Path arg0) { | |
return new Warning("compiler", "invalid.archive.file", arg0); | |
} | |
/** | |
* 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) | |
*/ | |
public static final Warning InvalidYield = new Warning("compiler", "invalid.yield"); | |
/** | |
* compiler.warn.is.preview=\ | |
* {0} is a preview API and may be removed in a future release. | |
*/ | |
public static Warning IsPreview(Symbol arg0) { | |
return new Warning("compiler", "is.preview", arg0); | |
} | |
/** | |
* compiler.warn.is.preview.reflective=\ | |
* {0} is a reflective preview API and may be removed in a future release. | |
*/ | |
public static Warning IsPreviewReflective(Symbol arg0) { | |
return new Warning("compiler", "is.preview.reflective", arg0); | |
} | |
/** | |
* 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' | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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''). | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
public static Warning LongSVUID(Symbol arg0) { | |
return new Warning("compiler", "long.SVUID", arg0); | |
} | |
/** | |
* 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} | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
public static Warning ModuleNotFound(Symbol arg0) { | |
return new Warning("compiler", "module.not.found", arg0); | |
} | |
/** | |
* compiler.warn.non.private.method.weaker.access=\ | |
* serialization-related method declared non-private in an interface will prevent\n\ | |
* classes implementing the interface from declaring the method as private | |
*/ | |
public static final Warning NonPrivateMethodWeakerAccess = new Warning("compiler", "non.private.method.weaker.access"); | |
/** | |
* compiler.warn.non.serializable.instance.field=\ | |
* non-transient instance field of a serializable class declared with a non-serializable type | |
*/ | |
public static final Warning NonSerializableInstanceField = new Warning("compiler", "non.serializable.instance.field"); | |
/** | |
* compiler.warn.non.serializable.instance.field.array=\ | |
* non-transient instance field of a serializable class declared with an array having a non-serializable base component type {0} | |
*/ | |
public static Warning NonSerializableInstanceFieldArray(Type arg0) { | |
return new Warning("compiler", "non.serializable.instance.field.array", arg0); | |
} | |
/** | |
* 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. | |
*/ | |
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 | |
*/ | |
public static Warning OptionObsoleteTarget(Target arg0) { | |
return new Warning("compiler", "option.obsolete.target", arg0); | |
} | |
/** | |
* 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 | |
*/ | |
public static Warning OverrideBridge(JCDiagnostic arg0) { | |
return new Warning("compiler", "override.bridge", arg0); | |
} | |
/** | |
* 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 | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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 ''...'' | |
*/ | |
public static Warning OverrideVarargsExtra(JCDiagnostic arg0) { | |
return new Warning("compiler", "override.varargs.extra", arg0); | |
} | |
/** | |
* 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 ''...'' | |
*/ | |
public static Warning OverrideVarargsMissing(JCDiagnostic arg0) { | |
return new Warning("compiler", "override.varargs.missing", arg0); | |
} | |
/** | |
* 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} | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
public static final Warning PossibleFallThroughIntoCase = new Warning("compiler", "possible.fall-through.into.case"); | |
/** | |
* compiler.warn.possible.loss.of.precision=\ | |
* implicit cast from {0} to {1} in compound assignment is possibly lossy | |
*/ | |
public static Warning PossibleLossOfPrecision(Type arg0, Type arg1) { | |
return new Warning("compiler", "possible.loss.of.precision", arg0, arg1); | |
} | |
/** | |
* 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} | |
*/ | |
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. | |
*/ | |
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. | |
*/ | |
public static Warning PreviewFeatureUse(Fragment arg0) { | |
return new Warning("compiler", "preview.feature.use", arg0); | |
} | |
/** | |
* compiler.warn.preview.feature.use.classfile=\ | |
* class file 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. | |
*/ | |
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. | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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}'' | |
*/ | |
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 interface ''{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. | |
*/ | |
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 | |
*/ | |
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}''. | |
*/ | |
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 interface 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} | |
*/ | |
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 | |
*/ | |
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. | |
*/ | |
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}'' | |
*/ | |
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 interfaces | |
*/ | |
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}'' | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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}'' | |
*/ | |
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. | |
*/ | |
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. | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
public static Warning RedundantCast(Type arg0) { | |
return new Warning("compiler", "redundant.cast", arg0); | |
} | |
/** | |
* 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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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}'' | |
*/ | |
public static Warning SelfRef(Symbol arg0) { | |
return new Warning("compiler", "self.ref", arg0); | |
} | |
/** | |
* compiler.warn.serial.concrete.instance.method=\ | |
* serialization-related method {0} must be a concrete instance method to be effective, neither abstract nor static | |
*/ | |
public static Warning SerialConcreteInstanceMethod(Name arg0) { | |
return new Warning("compiler", "serial.concrete.instance.method", arg0); | |
} | |
/** | |
* compiler.warn.serial.method.no.args=\ | |
* to be effective serialization-related method {0} must have no parameters | |
*/ | |
public static Warning SerialMethodNoArgs(Name arg0) { | |
return new Warning("compiler", "serial.method.no.args", arg0); | |
} | |
/** | |
* compiler.warn.serial.method.not.private=\ | |
* serialization-related method {0} not declared private | |
*/ | |
public static Warning SerialMethodNotPrivate(Name arg0) { | |
return new Warning("compiler", "serial.method.not.private", arg0); | |
} | |
/** | |
* compiler.warn.serial.method.one.arg=\ | |
* to be effective serialization-related method {0} must have exactly one parameter rather than {1} parameters | |
*/ | |
public static Warning SerialMethodOneArg(Name arg0, int arg1) { | |
return new Warning("compiler", "serial.method.one.arg", arg0, arg1); | |
} | |
/** | |
* compiler.warn.serial.method.parameter.type=\ | |
* sole parameter of serialization-related method {0} must have type {1} to be effective rather than type {2} | |
*/ | |
public static Warning SerialMethodParameterType(Name arg0, Type arg1, Type arg2) { | |
return new Warning("compiler", "serial.method.parameter.type", arg0, arg1, arg2); | |
} | |
/** | |
* compiler.warn.serial.method.static=\ | |
* serialization-related method {0} declared static; must instead be an instance method to be effective | |
*/ | |
public static Warning SerialMethodStatic(Name arg0) { | |
return new Warning("compiler", "serial.method.static", arg0); | |
} | |
/** | |
* compiler.warn.serial.method.unexpected.exception=\ | |
* serialization-related method {0} declared to throw an unexpected type {1} | |
*/ | |
public static Warning SerialMethodUnexpectedException(Name arg0, Type arg1) { | |
return new Warning("compiler", "serial.method.unexpected.exception", arg0, arg1); | |
} | |
/** | |
* compiler.warn.serial.method.unexpected.return.type=\ | |
* serialization-related method {0} declared with a return type of {1} rather than expected type {2}.\n\ | |
* As declared, the method will be ineffective for serialization | |
*/ | |
public static Warning SerialMethodUnexpectedReturnType(Name arg0, Type arg1, Type arg2) { | |
return new Warning("compiler", "serial.method.unexpected.return.type", arg0, arg1, arg2); | |
} | |
/** | |
* compiler.warn.serializable.missing.access.no.arg.ctor=\ | |
* cannot access a no-arg constructor in first non-serializable superclass {0} | |
*/ | |
public static Warning SerializableMissingAccessNoArgCtor(Name arg0) { | |
return new Warning("compiler", "serializable.missing.access.no.arg.ctor", arg0); | |
} | |
/** | |
* 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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
public static Warning StaticNotQualifiedByType(KindName arg0, Symbol arg1) { | |
return new Warning("compiler", "static.not.qualified.by.type", arg0, arg1); | |
} | |
/** | |
* compiler.warn.static.not.qualified.by.type2=\ | |
* static {0} should not be used as a member of an anonymous class | |
*/ | |
public static Warning StaticNotQualifiedByType2(KindName arg0) { | |
return new Warning("compiler", "static.not.qualified.by.type2", arg0); | |
} | |
/** | |
* compiler.warn.strictfp=\ | |
* as of release 17, all floating-point expressions are evaluated strictly and ''strictfp'' is not required | |
*/ | |
public static final Warning Strictfp = new Warning("compiler", "strictfp"); | |
/** | |
* 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} | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
public static final Warning UnderscoreAsIdentifier = new Warning("compiler", "underscore.as.identifier"); | |
/** | |
* 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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
public static Warning VarargsUnsafeUseVarargsParam(Symbol arg0) { | |
return new Warning("compiler", "varargs.unsafe.use.varargs.param", arg0); | |
} | |
/** | |
* 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 | |
*/ | |
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} | |
*/ | |
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. | |
*/ | |
public static Note DeprecatedFilename(File arg0) { | |
return new Note("compiler", "deprecated.filename", arg0); | |
} | |
/** | |
* 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. | |
*/ | |
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. | |
*/ | |
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. | |
*/ | |
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. | |
*/ | |
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. | |
*/ | |
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. | |
*/ | |
public static final Note DeprecatedPluralAdditional = new Note("compiler", "deprecated.plural.additional"); | |
/** | |
* 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} | |
*/ | |
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: | |
*/ | |
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\ | |
*/ | |
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} | |
*/ | |
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}. | |
*/ | |
public static Note MultipleElements(String arg0, String arg1, String arg2) { | |
return new Note("compiler", "multiple.elements", arg0, arg1, arg2); | |
} | |
/** | |
* compiler.note.note=\ | |
* Note:\u0020 | |
*/ | |
public static final Note Note = new Note("compiler", "note"); | |
/** | |
* compiler.note.preview.filename=\ | |
* {0} uses preview features of Java SE {1}. | |
*/ | |
public static Note PreviewFilename(File arg0, Source arg1) { | |
return new Note("compiler", "preview.filename", arg0, arg1); | |
} | |
/** | |
* compiler.note.preview.filename=\ | |
* {0} uses preview features of Java SE {1}. | |
*/ | |
public static Note PreviewFilename(JavaFileObject arg0, Source arg1) { | |
return new Note("compiler", "preview.filename", arg0, arg1); | |
} | |
/** | |
* compiler.note.preview.filename=\ | |
* {0} uses preview features of Java SE {1}. | |
*/ | |
public static Note PreviewFilename(Path arg0, Source arg1) { | |
return new Note("compiler", "preview.filename", arg0, arg1); | |
} | |
/** | |
* compiler.note.preview.filename.additional=\ | |
* {0} has additional uses of preview features of Java SE {1}. | |
*/ | |
public static Note PreviewFilenameAdditional(File arg0, Source arg1) { | |
return new Note("compiler", "preview.filename.additional", arg0, arg1); | |
} | |
/** | |
* compiler.note.preview.filename.additional=\ | |
* {0} has additional uses of preview features of Java SE {1}. | |
*/ | |
public static Note PreviewFilenameAdditional(JavaFileObject arg0, Source arg1) { | |
return new Note("compiler", "preview.filename.additional", arg0, arg1); | |
} | |
/** | |
* compiler.note.preview.filename.additional=\ | |
* {0} has additional uses of preview features of Java SE {1}. | |
*/ | |
public static Note PreviewFilenameAdditional(Path arg0, Source arg1) { | |
return new Note("compiler", "preview.filename.additional", arg0, arg1); | |
} | |
/** | |
* compiler.note.preview.plural=\ | |
* Some input files use preview features of Java SE {0}. | |
*/ | |
public static Note PreviewPlural(Source arg0) { | |
return new Note("compiler", "preview.plural", arg0); | |
} | |
/** | |
* compiler.note.preview.plural.additional=\ | |
* Some input files additionally use preview features of Java SE {0}. | |
*/ | |
public static Note PreviewPluralAdditional(Source arg0) { | |
return new Note("compiler", "preview.plural.additional", arg0); | |
} | |
/** | |
* 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} | |
*/ | |
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. | |
*/ | |
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. | |
*/ | |
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. | |
*/ | |
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. | |
*/ | |
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. | |
*/ | |
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. | |
*/ | |
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. | |
*/ | |
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. | |
*/ | |
public static final Note RemovalPluralAdditional = new Note("compiler", "removal.plural.additional"); | |
/** | |
* 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. | |
*/ | |
public static Note UncheckedFilename(File arg0) { | |
return new Note("compiler", "unchecked.filename", arg0); | |
} | |
/** | |
* 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. | |
*/ | |
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. | |
*/ | |
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. | |
*/ | |
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. | |
*/ | |
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. | |
*/ | |
public static final Note UncheckedPlural = new Note("compiler", "unchecked.plural"); | |
/** | |
* 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. | |
*/ | |
public static final Note UncheckedRecompile = new Note("compiler", "unchecked.recompile"); | |
/** | |
* 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: | |
*/ | |
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: | |
*/ | |
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: | |
*/ | |
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: | |
*/ | |
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: | |
*/ | |
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: | |
*/ | |
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: | |
*/ | |
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: | |
*/ | |
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: | |
*/ | |
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: | |
*/ | |
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: | |
*/ | |
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: | |
*/ | |
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: | |
*/ | |
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: | |
*/ | |
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: | |
*/ | |
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: | |
*/ | |
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: | |
*/ | |
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: | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
public static Fragment AnachronisticModuleInfo(String arg0, String arg1) { | |
return new Fragment("compiler", "anachronistic.module.info", arg0, arg1); | |
} | |
/** | |
* compiler.misc.anonymous=\ | |
* anonymous | |
*/ | |
public static final Fragment Anonymous = new Fragment("compiler", "anonymous"); | |
/** | |
* compiler.misc.anonymous.class=\ | |
* <anonymous {0}> | |
*/ | |
public static Fragment AnonymousClass(Name arg0) { | |
return new Fragment("compiler", "anonymous.class", arg0); | |
} | |
/** | |
* 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}) | |
*/ | |
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}) | |
*/ | |
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=\ | |
*/ | |
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}) | |
*/ | |
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}) | |
*/ | |
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 | |
*/ | |
public static final Fragment ArgLengthMismatch = new Fragment("compiler", "arg.length.mismatch"); | |
/** | |
* 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. | |
*/ | |
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. | |
*/ | |
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. | |
*/ | |
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. | |
*/ | |
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. | |
*/ | |
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. | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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}. | |
*/ | |
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}. | |
*/ | |
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}. | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
public static final Fragment BadEnclosingClass = new Fragment("compiler", "bad.enclosing.class"); | |
/** | |
* 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 | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
public static final Fragment BadModuleInfoName = new Fragment("compiler", "bad.module-info.name"); | |
/** | |
* 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} | |
*/ | |
public static final Fragment BadRuntimeInvisibleParamAnnotations = new Fragment("compiler", "bad.runtime.invisible.param.annotations"); | |
/** | |
* 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. | |
*/ | |
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. | |
*/ | |
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. | |
*/ | |
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. | |
*/ | |
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. | |
*/ | |
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. | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
public static final Fragment BadTypeAnnotationValue = new Fragment("compiler", "bad.type.annotation.value"); | |
/** | |
* compiler.misc.bound=\ | |
* bound | |
*/ | |
public static final Fragment Bound = new Fragment("compiler", "bound"); | |
/** | |
* 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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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}) | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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}) | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
@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} | |
*/ | |
@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 | |
*/ | |
public static final Fragment CantResolveModules = new Fragment("compiler", "cant.resolve.modules"); | |
/** | |
* 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} | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
public static final Fragment ClassFileWrongClass = new Fragment("compiler", "class.file.wrong.class"); | |
/** | |
* 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 | |
*/ | |
public static final Fragment Compact = new Fragment("compiler", "compact"); | |
/** | |
* 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 | |
*/ | |
public static Fragment CountError(int arg0) { | |
return new Fragment("compiler", "count.error", arg0); | |
} | |
/** | |
* 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 | |
*/ | |
public static Fragment CountErrorRecompile(int arg0, int arg1) { | |
return new Fragment("compiler", "count.error.recompile", arg0, arg1); | |
} | |
/** | |
* 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 | |
*/ | |
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 | |
*/ | |
public static Fragment CountWarnRecompile(int arg0, int arg1) { | |
return new Fragment("compiler", "count.warn.recompile", arg0, arg1); | |
} | |
/** | |
* 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} | |
*/ | |
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}<> | |
*/ | |
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 | |
*/ | |
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) | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
public static Fragment DoesntExtendSealed(Type arg0) { | |
return new Fragment("compiler", "doesnt.extend.sealed", arg0); | |
} | |
/** | |
* 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} | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
public static Fragment FatalErrCantLocateMeth(Name arg0) { | |
return new Fragment("compiler", "fatal.err.cant.locate.meth", arg0); | |
} | |
/** | |
* compiler.misc.feature.case.null=\ | |
* null in switch cases | |
*/ | |
public static final Fragment FeatureCaseNull = new Fragment("compiler", "feature.case.null"); | |
/** | |
* compiler.misc.feature.deconstruction.patterns=\ | |
* deconstruction patterns | |
*/ | |
public static final Fragment FeatureDeconstructionPatterns = new Fragment("compiler", "feature.deconstruction.patterns"); | |
/** | |
* 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.modules=\ | |
* modules | |
*/ | |
public static final Fragment FeatureModules = new Fragment("compiler", "feature.modules"); | |
/** | |
* 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}) | |
*/ | |
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}) | |
*/ | |
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}) | |
*/ | |
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}) | |
*/ | |
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 | |
*/ | |
public static final Fragment FeaturePatternMatchingInstanceof = new Fragment("compiler", "feature.pattern.matching.instanceof"); | |
/** | |
* compiler.misc.feature.pattern.switch=\ | |
* patterns in switch statements | |
*/ | |
public static final Fragment FeaturePatternSwitch = new Fragment("compiler", "feature.pattern.switch"); | |
/** | |
* 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 | |
*/ | |
public static final Fragment FeatureRecords = new Fragment("compiler", "feature.records"); | |
/** | |
* 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.sealed.classes=\ | |
* sealed classes | |
*/ | |
public static final Fragment FeatureSealedClasses = new Fragment("compiler", "feature.sealed.classes"); | |
/** | |
* 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 | |
*/ | |
public static final Fragment FeatureSwitchRules = new Fragment("compiler", "feature.switch.rules"); | |
/** | |
* compiler.misc.feature.text.blocks=\ | |
* text blocks | |
*/ | |
public static final Fragment FeatureTextBlocks = new Fragment("compiler", "feature.text.blocks"); | |
/** | |
* compiler.misc.feature.unconditional.patterns.in.instanceof=\ | |
* unconditional patterns in instanceof | |
*/ | |
public static final Fragment FeatureUnconditionalPatternsInInstanceof = new Fragment("compiler", "feature.unconditional.patterns.in.instanceof"); | |
/** | |
* 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 | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
public static Fragment FileDoesntContainClass(Name arg0) { | |
return new Fragment("compiler", "file.doesnt.contain.class", arg0); | |
} | |
/** | |
* compiler.misc.guard=\ | |
* a guard | |
*/ | |
public static final Fragment Guard = new Fragment("compiler", "guard"); | |
/** | |
* 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 | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
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}) | |
*/ | |
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}) | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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) | |
*/ | |
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}) | |
*/ | |
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}) | |
*/ | |
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} | |
*/ | |
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}) | |
*/ | |
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}) | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
public static final Fragment InnerCls = new Fragment("compiler", "inner.cls"); | |
/** | |
* 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 | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
public static Fragment IsATypeVariable(Type arg0) { | |
return new Fragment("compiler", "is.a.type.variable", arg0); | |
} | |
/** | |
* 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 | |
*/ | |
public static final Fragment KindnameAnnotation = new Fragment("compiler", "kindname.annotation"); | |
/** | |
* compiler.misc.kindname.class=\ | |
* class | |
*/ | |
public static final Fragment KindnameClass = new Fragment("compiler", "kindname.class"); | |
/** | |
* compiler.misc.kindname.constructor=\ | |
* constructor | |
*/ | |
public static final Fragment KindnameConstructor = new Fragment("compiler", "kindname.constructor"); | |
/** | |
* compiler.misc.kindname.enum=\ | |
* enum | |
*/ | |
public static final Fragment KindnameEnum = new Fragment("compiler", "kindname.enum"); | |
/** | |
* compiler.misc.kindname.instance.init=\ | |
* instance initializer | |
*/ | |
public static final Fragment KindnameInstanceInit = new Fragment("compiler", "kindname.instance.init"); | |
/** | |
* compiler.misc.kindname.interface=\ | |
* interface | |
*/ | |
public static final Fragment KindnameInterface = new Fragment("compiler", "kindname.interface"); | |
/** | |
* compiler.misc.kindname.method=\ | |
* method | |
*/ | |
public static final Fragment KindnameMethod = new Fragment("compiler", "kindname.method"); | |
/** | |
* compiler.misc.kindname.module=\ | |
* module | |
*/ | |
public static final Fragment KindnameModule = new Fragment("compiler", "kindname.module"); | |
/** | |
* compiler.misc.kindname.package=\ | |
* package | |
*/ | |
public static final Fragment KindnamePackage = new Fragment("compiler", "kindname.package"); | |
/** | |
* compiler.misc.kindname.record=\ | |
* record | |
*/ | |
public static final Fragment KindnameRecord = new Fragment("compiler", "kindname.record"); | |
/** | |
* compiler.misc.kindname.record.component=\ | |
* record component | |
*/ | |
public static final Fragment KindnameRecordComponent = new Fragment("compiler", "kindname.record.component"); | |
/** | |
* compiler.misc.kindname.static=\ | |
* static | |
*/ | |
public static final Fragment KindnameStatic = new Fragment("compiler", "kindname.static"); | |
/** | |
* 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 | |
*/ | |
public static final Fragment KindnameTypeVariable = new Fragment("compiler", "kindname.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 | |
*/ | |
public static final Fragment KindnameValue = new Fragment("compiler", "kindname.value"); | |
/** | |
* compiler.misc.kindname.variable=\ | |
* variable | |
*/ | |
public static final Fragment KindnameVariable = new Fragment("compiler", "kindname.variable"); | |
/** | |
* compiler.misc.lambda=\ | |
* a lambda expression | |
*/ | |
public static final Fragment Lambda = new Fragment("compiler", "lambda"); | |
/** | |
* 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 | |
*/ | |
public static final Fragment LocalArrayMissingTarget = new Fragment("compiler", "local.array.missing.target"); | |
/** | |
* 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'' | |
*/ | |
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 | |
*/ | |
public static final Fragment LocalLambdaMissingTarget = new Fragment("compiler", "local.lambda.missing.target"); | |
/** | |
* 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 | |
*/ | |
public static final Fragment LocalMrefMissingTarget = new Fragment("compiler", "local.mref.missing.target"); | |
/** | |
* 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} | |
*/ | |
public static Fragment Location(KindName arg0, Type arg1, Void arg2) { | |
return new Fragment("compiler", "location", arg0, arg1, arg2); | |
} | |
/** | |
* 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} | |
*/ | |
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 | |
*/ | |
public static final Fragment LocnModule_path = new Fragment("compiler", "locn.module_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 | |
*/ | |
public static final Fragment LocnSystem_modules = new Fragment("compiler", "locn.system_modules"); | |
/** | |
* 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} | |
*/ | |
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} | |
*/ | |
public static final Fragment MalformedVarargMethod = new Fragment("compiler", "malformed.vararg.method"); | |
/** | |
* 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 | |
*/ | |
public static final Fragment MethodMustBePublic = new Fragment("compiler", "method.must.be.public"); | |
/** | |
* 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 | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
public static final Fragment MustNotBeSameClass = new Fragment("compiler", "must.not.be.same.class"); | |
/** | |
* 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} | |
*/ | |
public static Fragment NoAbstracts(KindName arg0, Symbol arg1) { | |
return new Fragment("compiler", "no.abstracts", arg0, arg1); | |
} | |
/** | |
* 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} | |
*/ | |
public static Fragment NoConformingAssignmentExists(JCDiagnostic arg0) { | |
return new Fragment("compiler", "no.conforming.assignment.exists", arg0); | |
} | |
/** | |
* 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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
public static final Fragment NonStatic = new Fragment("compiler", "non.static"); | |
/** | |
* 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} | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
public static Fragment NotAnIntfComponent(Type arg0) { | |
return new Fragment("compiler", "not.an.intf.component", arg0); | |
} | |
/** | |
* 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}) | |
*/ | |
public static Fragment NotApplicableMethodFound(int arg0, Symbol arg1, Fragment arg2) { | |
return new Fragment("compiler", "not.applicable.method.found", arg0, arg1, arg2); | |
} | |
/** | |
* compiler.misc.not.applicable.types=\ | |
* pattern of type {1} is not applicable at {0} | |
*/ | |
public static Fragment NotApplicableTypes(Type arg0, Type arg1) { | |
return new Fragment("compiler", "not.applicable.types", arg0, arg1); | |
} | |
/** | |
* 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}) | |
*/ | |
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}) | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
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}) | |
*/ | |
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}) | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
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}) | |
*/ | |
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}) | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
public static Fragment ProbFoundReq(JCDiagnostic arg0) { | |
return new Fragment("compiler", "prob.found.req", arg0); | |
} | |
/** | |
* 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} | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
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> | |
*/ | |
public static final Fragment ResumeAbort = new Fragment("compiler", "resume.abort"); | |
/** | |
* 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) | |
*/ | |
public static final Fragment StatExprExpected = new Fragment("compiler", "stat.expr.expected"); | |
/** | |
* 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 | |
*/ | |
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 | |
*/ | |
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} | |
*/ | |
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 | |
*/ | |
public static Fragment ThrowsClauseNotAllowedForCanonicalConstructor(Fragment arg0) { | |
return new Fragment("compiler", "throws.clause.not.allowed.for.canonical.constructor", arg0); | |
} | |
/** | |
* compiler.misc.token.bad-symbol=\ | |
* <bad symbol> | |
*/ | |
public static final Fragment TokenBadSymbol = new Fragment("compiler", "token.bad-symbol"); | |
/** | |
* compiler.misc.token.character=\ | |
* <character> | |
*/ | |
public static final Fragment TokenCharacter = new Fragment("compiler", "token.character"); | |
/** | |
* compiler.misc.token.double=\ | |
* <double> | |
*/ | |
public static final Fragment TokenDouble = new Fragment("compiler", "token.double"); | |
/** | |
* 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=\ | |
* <float> | |
*/ | |
public static final Fragment TokenFloat = new Fragment("compiler", "token.float"); | |
/** | |
* compiler.misc.token.identifier=\ | |
* <identifier> | |
*/ | |
public static final Fragment TokenIdentifier = new Fragment("compiler", "token.identifier"); | |
/** | |
* compiler.misc.token.integer=\ | |
* <integer> | |
*/ | |
public static final Fragment TokenInteger = new Fragment("compiler", "token.integer"); | |
/** | |
* compiler.misc.token.long-integer=\ | |
* <long integer> | |
*/ | |
public static final Fragment TokenLongInteger = new Fragment("compiler", "token.long-integer"); | |
/** | |
* 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}) | |
*/ | |
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}) | |
*/ | |
public static Fragment TryNotApplicableToType(Fragment arg0) { | |
return new Fragment("compiler", "try.not.applicable.to.type", arg0); | |
} | |
/** | |
* 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} | |
*/ | |
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\ | |
*/ | |
public static final Fragment TypeMustBeIdenticalToCorrespondingRecordComponentType = new Fragment("compiler", "type.must.be.identical.to.corresponding.record.component.type"); | |
/** | |
* compiler.misc.type.none=\ | |
* <none> | |
*/ | |
public static final Fragment TypeNone = new Fragment("compiler", "type.none"); | |
/** | |
* compiler.misc.type.null=\ | |
* <null> | |
*/ | |
public static final Fragment TypeNull = new Fragment("compiler", "type.null"); | |
/** | |
* 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 | |
*/ | |
public static final Fragment TypeReqArrayOrIterable = new Fragment("compiler", "type.req.array.or.iterable"); | |
/** | |
* 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 | |
*/ | |
public static final Fragment TypeReqClassArray = new Fragment("compiler", "type.req.class.array"); | |
/** | |
* 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 | |
*/ | |
public static final Fragment TypeReqRef = new Fragment("compiler", "type.req.ref"); | |
/** | |
* 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} | |
*/ | |
public static final Fragment UnableToAccessFile = new Fragment("compiler", "unable.to.access.file"); | |
/** | |
* compiler.misc.unbound=\ | |
* unbound | |
*/ | |
public static final Fragment Unbound = new Fragment("compiler", "unbound"); | |
/** | |
* compiler.misc.unchecked.assign=\ | |
* unchecked conversion | |
*/ | |
public static final Fragment UncheckedAssign = new Fragment("compiler", "unchecked.assign"); | |
/** | |
* 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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
public static final Fragment UnexpectedConstPoolTagAt = new Fragment("compiler", "unexpected.const.pool.tag.at"); | |
/** | |
* 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 | |
*/ | |
public static final Fragment UnicodeStrNotSupported = new Fragment("compiler", "unicode.str.not.supported"); | |
/** | |
* compiler.misc.unnamed.module=\ | |
* unnamed module | |
*/ | |
public static final Fragment UnnamedModule = new Fragment("compiler", "unnamed.module"); | |
/** | |
* compiler.misc.unnamed.package=\ | |
* unnamed package | |
*/ | |
public static final Fragment UnnamedPackage = new Fragment("compiler", "unnamed.package"); | |
/** | |
* compiler.misc.upper.bounds=\ | |
* upper 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 | |
*/ | |
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 | |
*/ | |
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 | |
*/ | |
public static final Fragment VarAndImplicitNotAllowed = new Fragment("compiler", "var.and.implicit.not.allowed"); | |
/** | |
* 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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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. | |
*/ | |
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. | |
*/ | |
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. | |
*/ | |
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. | |
*/ | |
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. | |
*/ | |
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}] | |
*/ | |
public static Fragment VerboseCheckingAttribution(Symbol arg0) { | |
return new Fragment("compiler", "verbose.checking.attribution", arg0); | |
} | |
/** | |
* 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}] | |
*/ | |
public static Fragment VerboseLoading(String arg0) { | |
return new Fragment("compiler", "verbose.loading", arg0); | |
} | |
/** | |
* 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}] | |
*/ | |
public static Fragment VerboseParsingStarted(File arg0) { | |
return new Fragment("compiler", "verbose.parsing.started", arg0); | |
} | |
/** | |
* 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}] | |
*/ | |
public static Fragment VerboseParsingStarted(Path arg0) { | |
return new Fragment("compiler", "verbose.parsing.started", arg0); | |
} | |
/** | |
* 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] | |
*/ | |
public static Fragment VerboseTotal(String arg0) { | |
return new Fragment("compiler", "verbose.total", arg0); | |
} | |
/** | |
* 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}] | |
*/ | |
public static Fragment VerboseWroteFile(JavaFileObject arg0) { | |
return new Fragment("compiler", "verbose.wrote.file", arg0); | |
} | |
/** | |
* 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) | |
*/ | |
public static final Fragment VersionNotAvailable = new Fragment("compiler", "version.not.available"); | |
/** | |
* 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} | |
*/ | |
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: | |
*/ | |
public static final Fragment WhereDescriptionCaptured = new Fragment("compiler", "where.description.captured"); | |
/** | |
* 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: | |
*/ | |
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: | |
*/ | |
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: | |
*/ | |
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: | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
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} | |
*/ | |
public static final Fragment WrongVersion = new Fragment("compiler", "wrong.version"); | |
/** | |
* 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} | |
*/ | |
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); | |
} | |
} | |
public static class Infos { | |
/** | |
* compiler.info.class.already.defined=\ | |
* class already defined in {0} | |
*/ | |
public static InfoFragment ClassAlreadyDefined(String arg0) { | |
return new InfoFragment("compiler", "class.already.defined", arg0); | |
} | |
/** | |
* compiler.info.function.declared.here=\ | |
* function declared here | |
*/ | |
public static final InfoFragment FunctionDeclaredHere = new InfoFragment("compiler", "function.declared.here"); | |
/** | |
* compiler.info.int.number.range=\ | |
* int literals can store values from -2147483648 through 2147483647, inclusive. | |
*/ | |
public static final InfoFragment IntNumberRange = new InfoFragment("compiler", "int.number.range"); | |
/** | |
* compiler.info.long.number.range=\ | |
* long literals can store values from -9223372036854775808 through 9223372036854775807, inclusive. | |
*/ | |
public static final InfoFragment LongNumberRange = new InfoFragment("compiler", "long.number.range"); | |
} | |
public static class Helps { | |
/** | |
* compiler.help.rename.the.identifier=\ | |
* rename the identifier | |
*/ | |
public static final HelpFragment RenameTheIdentifier = new HelpFragment("compiler", "rename.the.identifier"); | |
/** | |
* compiler.help.similar.symbol=\ | |
* a similarly named {0} exists: {1} | |
*/ | |
public static HelpFragment SimilarSymbol(KindName arg0, Symbol arg1) { | |
return new HelpFragment("compiler", "similar.symbol", arg0, arg1); | |
} | |
/** | |
* compiler.help.use.long.integer.literal=\ | |
* use a long instead | |
*/ | |
public static final HelpFragment UseLongIntegerLiteral = new HelpFragment("compiler", "use.long.integer.literal"); | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment