jdk-sandbox: comparison langtools/src/share/classes/com/sun/tools/javac/comp/Check.java

equal deleted inserted replaced

-:9ca5d29b34f7
+:a067a0cda531
 // The set of lint options currently in effect. It is initialized
 // from the context, and then is set/reset as needed by Attr as it
 // visits all the various parts of the trees during attribution.
 private Lint lint;
+// The method being analyzed in Attr - it is set/reset as needed by
+// Attr as it visits new method declarations.
+private MethodSymbol method;
 public static Check instance(Context context) {
 Check instance = context.get(checkKey);
 if (instance == null)
 instance = new Check(context);
 return instance;
 Source source = Source.instance(context);
 allowGenerics = source.allowGenerics();
 allowAnnotations = source.allowAnnotations();
 allowCovariantReturns = source.allowCovariantReturns();
+allowSimplifiedVarargs = source.allowSimplifiedVarargs();
 complexInference = options.isSet(COMPLEXINFERENCE);
 skipAnnotations = options.isSet("skipAnnotations");
 warnOnSyntheticConflicts = options.isSet("warnOnSyntheticConflicts");
 suppressAbortOnBadClassFile = options.isSet("suppressAbortOnBadClassFile");
 /** Switch: covariant returns enabled?
 */
 boolean allowCovariantReturns;
+/** Switch: simplified varargs enabled?
+*/
+boolean allowSimplifiedVarargs;
 /** Switch: -complexinference option set?
 */
 boolean complexInference;
 /** Character for synthetic names
 Lint prev = lint;
 lint = newLint;
 return prev;
 }
+MethodSymbol setMethod(MethodSymbol newMethod) {
+MethodSymbol prev = method;
+method = newMethod;
+return prev;
+}
 /** Warn about deprecated symbol.
 *  @param pos        Position to be used for error reporting.
 *  @param sym        The deprecated symbol.
 */
 void warnDeprecated(DiagnosticPosition pos, Symbol sym) {
 /** Warn about unsafe vararg method decl.
 *  @param pos        Position to be used for error reporting.
 *  @param sym        The deprecated symbol.
 */
-void warnUnsafeVararg(DiagnosticPosition pos, Type elemType) {
+void warnUnsafeVararg(DiagnosticPosition pos, String key, Object... args) {
-if (!lint.isSuppressed(LintCategory.VARARGS))
+if (lint.isEnabled(LintCategory.VARARGS) && allowSimplifiedVarargs)
-unsafeVarargsHandler.report(pos, "varargs.non.reifiable.type", elemType);
+log.warning(LintCategory.VARARGS, pos, key, args);
 }
 /** Warn about using proprietary API.
 *  @param pos        Position to be used for error reporting.
 *  @param msg        A string describing the problem.
 * Report any deferred diagnostics.
 */
 public void reportDeferredDiagnostics() {
 deprecationHandler.reportDeferredDiagnostic();
 uncheckedHandler.reportDeferredDiagnostic();
-unsafeVarargsHandler.reportDeferredDiagnostic();
 sunApiHandler.reportDeferredDiagnostic();
 }
 /** Report a failure to complete a class.
 public Boolean visitCapturedType(CapturedType t, Void s) {
 return false;
 }
 }
-void checkVarargMethodDecl(JCMethodDecl tree) {
+void checkVarargsMethodDecl(Env<AttrContext> env, JCMethodDecl tree) {
 MethodSymbol m = tree.sym;
-//check the element type of the vararg
+if (!allowSimplifiedVarargs) return;
+boolean hasTrustMeAnno = m.attribute(syms.trustMeType.tsym) != null;
+Type varargElemType = null;
 if (m.isVarArgs()) {
-Type varargElemType = types.elemtype(tree.params.last().type);
+varargElemType = types.elemtype(tree.params.last().type);
-if (!types.isReifiable(varargElemType)) {
+}
-warnUnsafeVararg(tree.params.head.pos(), varargElemType);
+if (hasTrustMeAnno && !isTrustMeAllowedOnMethod(m)) {
-}
+if (varargElemType != null) {
-}
+log.error(tree,
-}
+"varargs.invalid.trustme.anno",
+syms.trustMeType.tsym,
+diags.fragment("varargs.trustme.on.virtual.varargs", m));
+} else {
+log.error(tree,
+"varargs.invalid.trustme.anno",
+syms.trustMeType.tsym,
+diags.fragment("varargs.trustme.on.non.varargs.meth", m));
+}
+} else if (hasTrustMeAnno && varargElemType != null &&
+types.isReifiable(varargElemType)) {
+warnUnsafeVararg(tree,
+"varargs.redundant.trustme.anno",
+syms.trustMeType.tsym,
+diags.fragment("varargs.trustme.on.reifiable.varargs", varargElemType));
+}
+else if (!hasTrustMeAnno && varargElemType != null &&
+!types.isReifiable(varargElemType)) {
+warnUnchecked(tree.params.head.pos(), "unchecked.varargs.non.reifiable.type", varargElemType);
+}
+}
+//where
+private boolean isTrustMeAllowedOnMethod(Symbol s) {
+return (s.flags() & VARARGS) != 0 &&
+(s.isConstructor() ||
+(s.flags() & (STATIC | FINAL)) != 0);
+}
 /**
 * Check that vararg method call is sound
 * @param pos Position to be used for error reporting.
 * @param argtypes Actual arguments supplied to vararg method.
 */
-void checkVararg(DiagnosticPosition pos, List<Type> argtypes, Symbol msym, Env<AttrContext> env) {
+void checkVararg(DiagnosticPosition pos, List<Type> argtypes, Symbol msym) {
-Env<AttrContext> calleeLintEnv = env;
-while (calleeLintEnv.info.lint == null)
-calleeLintEnv = calleeLintEnv.next;
-Lint calleeLint = calleeLintEnv.info.lint.augment(msym.attributes_field, msym.flags());
 Type argtype = argtypes.last();
-if (!types.isReifiable(argtype) && !calleeLint.isSuppressed(Lint.LintCategory.VARARGS)) {
+if (!types.isReifiable(argtype) &&
+(!allowSimplifiedVarargs ||
+msym.attribute(syms.trustMeType.tsym) == null ||
+!isTrustMeAllowedOnMethod(msym))) {
 warnUnchecked(pos,
 "unchecked.generic.array.creation",
 argtype);
 }
 }
 for (List<? extends JCTree> l = trees; l.nonEmpty(); l = l.tail)
 validateTree(l.head, checkRaw, isOuter);
 }
 void checkRaw(JCTree tree, Env<AttrContext> env) {
-if (lint.isEnabled(Lint.LintCategory.RAW) &&
+if (lint.isEnabled(LintCategory.RAW) &&
 tree.type.tag == CLASS &&
 !TreeInfo.isDiamond(tree) &&
 !env.enclClass.name.isEmpty() &&  //anonymous or intersection
 tree.type.isRaw()) {
-log.warning(Lint.LintCategory.RAW,
+log.warning(LintCategory.RAW,
 tree.pos(), "raw.class.use", tree.type, tree.type.tsym.type);
 }
 }
 }
 List<Type> mtvars = mt.getTypeArguments();
 List<Type> otvars = ot.getTypeArguments();
 Type mtres = mt.getReturnType();
 Type otres = types.subst(ot.getReturnType(), otvars, mtvars);
-overrideWarner.warned = false;
+overrideWarner.clear();
 boolean resultTypesOK =
 types.returnTypeSubstitutable(mt, ot, otres, overrideWarner);
 if (!resultTypesOK) {
 if (!allowCovariantReturns &&
 m.owner != origin &&
 "override.incompatible.ret",
 cannotOverride(m, other),
 mtres, otres);
 return;
 }
-} else if (overrideWarner.warned) {
+} else if (overrideWarner.hasNonSilentLint(LintCategory.UNCHECKED)) {
 warnUnchecked(TreeInfo.diagnosticPositionFor(m, tree),
 "override.unchecked.ret",
 uncheckedOverrides(m, other),
 mtres, otres);
 }
 return;
 }
 // Optional warning if varargs don't agree
 if ((((m.flags() ^ other.flags()) & Flags.VARARGS) != 0)
-&& lint.isEnabled(Lint.LintCategory.OVERRIDES)) {
+&& lint.isEnabled(LintCategory.OVERRIDES)) {
 log.warning(TreeInfo.diagnosticPositionFor(m, tree),
 ((m.flags() & Flags.VARARGS) != 0)
 ? "override.varargs.missing"
 : "override.varargs.extra",
 varargsOverrides(m, other));
 }
 }
 void checkDeprecatedAnnotation(DiagnosticPosition pos, Symbol s) {
 if (allowAnnotations &&
-lint.isEnabled(Lint.LintCategory.DEP_ANN) &&
+lint.isEnabled(LintCategory.DEP_ANN) &&
 (s.flags() & DEPRECATED) != 0 &&
 !syms.deprecatedType.isErroneous() &&
 s.attribute(syms.deprecatedType.tsym) == null) {
-log.warning(Lint.LintCategory.DEP_ANN,
+log.warning(LintCategory.DEP_ANN,
 pos, "missing.deprecated.annotation");
 }
 }
 /* *************************************************************************
 *  @param operator      The operator for the expression
 *  @param operand       The right hand operand for the expression
 */
 void checkDivZero(DiagnosticPosition pos, Symbol operator, Type operand) {
 if (operand.constValue() != null
-&& lint.isEnabled(Lint.LintCategory.DIVZERO)
+&& lint.isEnabled(LintCategory.DIVZERO)
 && operand.tag <= LONG
 && ((Number) (operand.constValue())).longValue() == 0) {
 int opc = ((OperatorSymbol)operator).opcode;
 if (opc == ByteCodes.idiv || opc == ByteCodes.imod
 || opc == ByteCodes.ldiv || opc == ByteCodes.lmod) {
-log.warning(Lint.LintCategory.DIVZERO, pos, "div.zero");
+log.warning(LintCategory.DIVZERO, pos, "div.zero");
 }
 }
 }
 /**
 * Check for empty statements after if
 */
 void checkEmptyIf(JCIf tree) {
-if (tree.thenpart.getTag() == JCTree.SKIP && tree.elsepart == null && lint.isEnabled(Lint.LintCategory.EMPTY))
+if (tree.thenpart.getTag() == JCTree.SKIP && tree.elsepart == null && lint.isEnabled(LintCategory.EMPTY))
-log.warning(Lint.LintCategory.EMPTY, tree.thenpart.pos(), "empty.if");
+log.warning(LintCategory.EMPTY, tree.thenpart.pos(), "empty.if");
 }
 /** Check that symbol is unique in given scope.
 *  @param pos           Position for error reporting.
 *  @param sym           The symbol.
 }
 return true;
 }
 private class ConversionWarner extends Warner {
-final String key;
+final String uncheckedKey;
 final Type found;
 final Type expected;
-public ConversionWarner(DiagnosticPosition pos, String key, Type found, Type expected) {
+public ConversionWarner(DiagnosticPosition pos, String uncheckedKey, Type found, Type expected) {
 super(pos);
-this.key = key;
+this.uncheckedKey = uncheckedKey;
 this.found = found;
 this.expected = expected;
 }
 @Override
-public void warnUnchecked() {
+public void warn(LintCategory lint) {
 boolean warned = this.warned;
-super.warnUnchecked();
+super.warn(lint);
 if (warned) return; // suppress redundant diagnostics
-Object problem = diags.fragment(key);
+switch (lint) {
-Check.this.warnUnchecked(pos(), "prob.found.req", problem, found, expected);
+case UNCHECKED:
+Check.this.warnUnchecked(pos(), "prob.found.req", diags.fragment(uncheckedKey), found, expected);
+break;
+case VARARGS:
+if (method != null &&
+method.attribute(syms.trustMeType.tsym) != null &&
+isTrustMeAllowedOnMethod(method) &&
+!types.isReifiable(method.type.getParameterTypes().last())) {
+Check.this.warnUnsafeVararg(pos(), "varargs.unsafe.use.varargs.param", method.params.last());
+}
+break;
+default:
+throw new AssertionError("Unexpected lint: " + lint);
+}
 }
 }
 public Warner castWarner(DiagnosticPosition pos, Type found, Type expected) {
 return new ConversionWarner(pos, "unchecked.cast.to.type", found, expected);

changeset 7643	a067a0cda531
parent 7628	e7baeb97d164
child 7681	1f0819a3341f