jdk8-mips64-public/langtools: comparison src/share/classes/com/sun/tools/javac/comp/Attr.java

-:2f2ead61db06
+:7b99f98b3035
 import com.sun.tools.javac.util.*;
 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
 import com.sun.tools.javac.util.List;
 import com.sun.tools.javac.jvm.Target;
+import com.sun.tools.javac.code.Lint.LintCategory;
 import com.sun.tools.javac.code.Symbol.*;
 import com.sun.tools.javac.tree.JCTree.*;
 import com.sun.tools.javac.code.Type.*;
 import com.sun.source.tree.IdentifierTree;
 public void visitMethodDef(JCMethodDecl tree) {
 MethodSymbol m = tree.sym;
 Lint lint = env.info.lint.augment(m.attributes_field, m.flags());
 Lint prevLint = chk.setLint(lint);
+MethodSymbol prevMethod = chk.setMethod(m);
 try {
 chk.checkDeprecatedAnnotation(tree.pos(), m);
 attribBounds(tree.typarams);
 // Attribute all value parameters.
 for (List<JCVariableDecl> l = tree.params; l.nonEmpty(); l = l.tail) {
 attribStat(l.head, localEnv);
 }
-chk.checkVarargMethodDecl(tree);
+chk.checkVarargsMethodDecl(localEnv, tree);
 // Check that type parameters are well-formed.
 chk.validate(tree.typarams, localEnv);
 // Check that result type is well-formed.
 result = tree.type = m.type;
 chk.validateAnnotations(tree.mods.annotations, m);
 }
 finally {
 chk.setLint(prevLint);
+chk.setMethod(prevMethod);
 }
 }
 public void visitVarDef(JCVariableDecl tree) {
 // Local variables have not been entered yet, so we need to do it now:
 if (sitesym != null &&
 sitesym.kind == VAR &&
 ((VarSymbol)sitesym).isResourceVariable() &&
 sym.kind == MTH &&
 sym.overrides(syms.autoCloseableClose, sitesym.type.tsym, types, true) &&
-env.info.lint.isEnabled(Lint.LintCategory.TRY)) {
+env.info.lint.isEnabled(LintCategory.TRY)) {
-log.warning(Lint.LintCategory.TRY, tree, "try.explicit.close.call");
+log.warning(LintCategory.TRY, tree, "try.explicit.close.call");
 }
 // Disallow selecting a type from an expression
 if (isType(sym) && (sitesym==null || (sitesym.kind&(TYP|PCK)) == 0)) {
 tree.type = check(tree.selected, pt,
 // Compute the identifier's instantiated type.
 // For methods, we need to compute the instance type by
 // Resolve.instantiate from the symbol's type as well as
 // any type arguments and value arguments.
-noteWarner.warned = false;
+noteWarner.clear();
 Type owntype = rs.instantiate(env,
 site,
 sym,
 argtypes,
 typeargtypes,
 true,
 useVarargs,
 noteWarner);
-boolean warned = noteWarner.warned;
+boolean warned = noteWarner.hasNonSilentLint(LintCategory.UNCHECKED);
 // If this fails, something went wrong; we should not have
 // found the identifier in the first place.
 if (owntype == null) {
 if (!pt.isErroneous())
 List<JCExpression> args = argtrees;
 while (formals.head != last) {
 JCTree arg = args.head;
 Warner warn = chk.convertWarner(arg.pos(), arg.type, formals.head);
 assertConvertible(arg, arg.type, formals.head, warn);
-warned |= warn.warned;
+warned |= warn.hasNonSilentLint(LintCategory.UNCHECKED);
 args = args.tail;
 formals = formals.tail;
 }
 if (useVarargs) {
 Type varArg = types.elemtype(last);
 while (args.tail != null) {
 JCTree arg = args.head;
 Warner warn = chk.convertWarner(arg.pos(), arg.type, varArg);
 assertConvertible(arg, arg.type, varArg, warn);
-warned |= warn.warned;
+warned |= warn.hasNonSilentLint(LintCategory.UNCHECKED);
 args = args.tail;
 }
 } else if ((sym.flags() & VARARGS) != 0 && allowVarargs) {
 // non-varargs call to varargs method
 Type varParam = owntype.getParameterTypes().last();
 }
 if (useVarargs) {
 JCTree tree = env.tree;
 Type argtype = owntype.getParameterTypes().last();
 if (owntype.getReturnType().tag != FORALL || warned) {
-chk.checkVararg(env.tree.pos(), owntype.getParameterTypes(), sym, env);
+chk.checkVararg(env.tree.pos(), owntype.getParameterTypes(), sym);
 }
 Type elemtype = types.elemtype(argtype);
 switch (tree.getTag()) {
 case JCTree.APPLY:
 ((JCMethodInvocation) tree).varargsElement = elemtype;
 // Check for cycles among annotation elements.
 chk.checkNonCyclicElements(tree);
 // Check for proper use of serialVersionUID
-if (env.info.lint.isEnabled(Lint.LintCategory.SERIAL) &&
+if (env.info.lint.isEnabled(LintCategory.SERIAL) &&
 isSerializable(c) &&
 (c.flags() & Flags.ENUM) == 0 &&
 (c.flags() & ABSTRACT) == 0) {
 checkSerialVersionUID(tree, c);
 }
 // check for presence of serialVersionUID
 Scope.Entry e = c.members().lookup(names.serialVersionUID);
 while (e.scope != null && e.sym.kind != VAR) e = e.next();
 if (e.scope == null) {
-log.warning(Lint.LintCategory.SERIAL,
+log.warning(LintCategory.SERIAL,
 tree.pos(), "missing.SVUID", c);
 return;
 }
 // check that it is static final
 VarSymbol svuid = (VarSymbol)e.sym;
 if ((svuid.flags() & (STATIC | FINAL)) !=
 (STATIC | FINAL))
-log.warning(Lint.LintCategory.SERIAL,
+log.warning(LintCategory.SERIAL,
 TreeInfo.diagnosticPositionFor(svuid, tree), "improper.SVUID", c);
 // check that it is long
 else if (svuid.type.tag != TypeTags.LONG)
-log.warning(Lint.LintCategory.SERIAL,
+log.warning(LintCategory.SERIAL,
 TreeInfo.diagnosticPositionFor(svuid, tree), "long.SVUID", c);
 // check constant
 else if (svuid.getConstValue() == null)
-log.warning(Lint.LintCategory.SERIAL,
+log.warning(LintCategory.SERIAL,
 TreeInfo.diagnosticPositionFor(svuid, tree), "constant.SVUID", c);
 }
 private Type capture(Type type) {
 return types.capture(type);

Mercurial > jdk8-mips64-public > langtools / file comparison

comparison: src/share/classes/com/sun/tools/javac/comp/Attr.java

src/share/classes/com/sun/tools/javac/comp/Attr.java