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

equal deleted inserted replaced

-:e1739a771470
+:23101f54df44
 /*
-* Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 // whose formal argument types is exactly the list of actual
 // arguments (this will also set the method symbol).
 Type mpt = newMethTemplate(argtypes, typeargtypes);
 localEnv.info.varArgs = false;
 Type mtype = attribExpr(tree.meth, localEnv, mpt);
-if (localEnv.info.varArgs)
-Assert.check(mtype.isErroneous() || tree.varargsElement != null);
 // Compute the result type.
 Type restype = mtype.getReturnType();
 if (restype.tag == WILDCARD)
 throw new AssertionError(mtype);
 chk.checkRefTypes(tree.typeargs, typeargtypes);
 // Check that value of resulting type is admissible in the
 // current context.  Also, capture the return type
 result = check(tree, capture(restype), VAL, pkind, pt);
+if (localEnv.info.varArgs)
+Assert.check(result.isErroneous() || tree.varargsElement != null);
 }
 chk.validate(tree.typeargs, localEnv);
 }
 //where
 /** Check that given application node appears as first statement
 rsEnv.info.varArgs = false;
 tree.constructor = rs.resolveConstructor(
 tree.pos(), rsEnv, clazztype, argtypes, typeargtypes);
 tree.constructorType = tree.constructor.type.isErroneous() ?
 syms.errType :
-checkMethod(clazztype,
+checkConstructor(clazztype,
 tree.constructor,
 rsEnv,
 tree.args,
 argtypes,
 typeargtypes,
 tree.constructor = sym;
 if (tree.constructor.kind > ERRONEOUS) {
 tree.constructorType =  syms.errType;
 }
 else {
-tree.constructorType = checkMethod(clazztype,
+tree.constructorType = checkConstructor(clazztype,
 tree.constructor,
 localEnv,
 tree.args,
 argtypes,
 typeargtypes,
 }
 Warner noteWarner = new Warner();
 /**
-* Check that method arguments conform to its instantation.
+* Check that method arguments conform to its instantiation.
 **/
 public Type checkMethod(Type site,
 Symbol sym,
 Env<AttrContext> env,
 final List<JCExpression> argtrees,
 argtypes,
 typeargtypes,
 true,
 useVarargs,
 noteWarner);
-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())
 log.error(env.tree.pos(),
 "internal.error.cant.instantiate",
 sym, site,
 Type.toString(pt.getParameterTypes()));
 owntype = types.createErrorType(site);
+return types.createErrorType(site);
+} else if (owntype.getReturnType().tag == FORALL) {
+return owntype;
 } else {
-// System.out.println("call   : " + env.tree);
+return chk.checkMethod(owntype, sym, env, argtrees, argtypes, useVarargs);
-// System.out.println("method : " + owntype);
+}
-// System.out.println("actuals: " + argtypes);
+}
-List<Type> formals = owntype.getParameterTypes();
-Type last = useVarargs ? formals.last() : null;
+/**
-if (sym.name==names.init &&
+* Check that constructor arguments conform to its instantiation.
-sym.owner == syms.enumSym)
+**/
-formals = formals.tail.tail;
+public Type checkConstructor(Type site,
-List<JCExpression> args = argtrees;
+Symbol sym,
-while (formals.head != last) {
+Env<AttrContext> env,
-JCTree arg = args.head;
+final List<JCExpression> argtrees,
-Warner warn = chk.convertWarner(arg.pos(), arg.type, formals.head);
+List<Type> argtypes,
-assertConvertible(arg, arg.type, formals.head, warn);
+List<Type> typeargtypes,
-warned |= warn.hasNonSilentLint(LintCategory.UNCHECKED);
+boolean useVarargs) {
-args = args.tail;
+Type owntype = checkMethod(site, sym, env, argtrees, argtypes, typeargtypes, useVarargs);
-formals = formals.tail;
+chk.checkType(env.tree.pos(), owntype.getReturnType(), syms.voidType);
-}
-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.hasNonSilentLint(LintCategory.UNCHECKED);
-args = args.tail;
-}
-} else if ((sym.flags() & VARARGS) != 0 && allowVarargs) {
-// non-varargs call to varargs method
-Type varParam = owntype.getParameterTypes().last();
-Type lastArg = argtypes.last();
-if (types.isSubtypeUnchecked(lastArg, types.elemtype(varParam)) &&
-!types.isSameType(types.erasure(varParam), types.erasure(lastArg)))
-log.warning(argtrees.last().pos(), "inexact.non-varargs.call",
-types.elemtype(varParam),
-varParam);
-}
-if (warned && sym.type.tag == FORALL) {
-chk.warnUnchecked(env.tree.pos(),
-"unchecked.meth.invocation.applied",
-kindName(sym),
-sym.name,
-rs.methodArguments(sym.type.getParameterTypes()),
-rs.methodArguments(argtypes),
-kindName(sym.location()),
-sym.location());
-owntype = new MethodType(owntype.getParameterTypes(),
-types.erasure(owntype.getReturnType()),
-types.erasure(owntype.getThrownTypes()),
-syms.methodClass);
-}
-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);
-}
-Type elemtype = types.elemtype(argtype);
-switch (tree.getTag()) {
-case APPLY:
-((JCMethodInvocation) tree).varargsElement = elemtype;
-break;
-case NEWCLASS:
-((JCNewClass) tree).varargsElement = elemtype;
-break;
-default:
-throw new AssertionError(""+tree);
-}
-}
-}
 return owntype;
-}
-private void assertConvertible(JCTree tree, Type actual, Type formal, Warner warn) {
-if (types.isConvertible(actual, formal, warn))
-return;
-if (formal.isCompound()
-&& types.isSubtype(actual, types.supertype(formal))
-&& types.isSubtypeUnchecked(actual, types.interfaces(formal), warn))
-return;
-if (false) {
-// TODO: make assertConvertible work
-chk.typeError(tree.pos(), diags.fragment("incompatible.types"), actual, formal);
-throw new AssertionError("Tree: " + tree
-+ " actual:" + actual
-+ " formal: " + formal);
-}
 }
 public void visitLiteral(JCLiteral tree) {
 result = check(
 tree, litType(tree.typetag).constType(tree.value), VAL, pkind, pt);

changeset 12080	23101f54df44
parent 12078	7470e05d486b
child 12081	42f541476d14