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

-:5a9b808557b6
+:91eea580fbe9
 /** Check kind and type of given tree against protokind and prototype.
 *  If check succeeds, store type in tree and return it.
 *  If check fails, store errType in tree and return it.
 *  No checks are performed if the prototype is a method type.
-*  Its not necessary in this case since we know that kind and type
+*  It is not necessary in this case since we know that kind and type
 *  are correct.
 *
 *  @param tree     The tree whose kind and type is checked
 *  @param owntype  The computed type of the tree
 *  @param ownkind  The computed kind of the tree
 owntype = chk.checkType(tree.pos(), owntype, pt);
 } else {
 log.error(tree.pos(), "unexpected.type",
 kindNames(pkind),
 kindName(ownkind));
-owntype = syms.errType;
+owntype = types.createErrorType(owntype);
 }
 }
 tree.type = owntype;
 return owntype;
 }
 boolean checkExtensible) {
 if (t.tag == TYPEVAR && !classExpected && !interfaceExpected) {
 // check that type variable is already visible
 if (t.getUpperBound() == null) {
 log.error(tree.pos(), "illegal.forward.ref");
-return syms.errType;
+return types.createErrorType(t);
 }
 } else {
 t = chk.checkClassType(tree.pos(), t, checkExtensible|!allowGenerics);
 }
 if (interfaceExpected && (t.tsym.flags() & INTERFACE) == 0) {
 log.error(tree.pos(), "intf.expected.here");
 // return errType is necessary since otherwise there might
 // be undetected cycles which cause attribution to loop
-return syms.errType;
+return types.createErrorType(t);
 } else if (checkExtensible &&
 classExpected &&
 (t.tsym.flags() & INTERFACE) != 0) {
 log.error(tree.pos(), "no.intf.expected.here");
-return syms.errType;
+return types.createErrorType(t);
 }
 if (checkExtensible &&
 ((t.tsym.flags() & FINAL) != 0)) {
 log.error(tree.pos(),
 "cant.inherit.from.final", t.tsym);
 if (elemtype == null) {
 // or perhaps expr implements Iterable<T>?
 Type base = types.asSuper(exprType, syms.iterableType.tsym);
 if (base == null) {
 log.error(tree.expr.pos(), "foreach.not.applicable.to.type");
-elemtype = syms.errType;
+elemtype = types.createErrorType(exprType);
 } else {
 List<Type> iterableParams = base.allparams();
 elemtype = iterableParams.isEmpty()
 ? syms.objectType
 : types.upperBound(iterableParams.head);
 // constructor is defined.
 Type site = env.enclClass.sym.type;
 if (methName == names._super) {
 if (site == syms.objectType) {
 log.error(tree.meth.pos(), "no.superclass", site);
-site = syms.errType;
+site = types.createErrorType(syms.objectType);
 } else {
 site = types.supertype(site);
 }
 }
 MethodType mt = new MethodType(argtypes, null, null, syms.methodClass);
 return (typeargtypes == null) ? mt : (Type)new ForAll(typeargtypes, mt);
 }
 public void visitNewClass(JCNewClass tree) {
-Type owntype = syms.errType;
+Type owntype = types.createErrorType(tree.type);
 // The local environment of a class creation is
 // a new environment nested in the current one.
 Env<AttrContext> localEnv = env.dup(tree, env.info.dup());
 tree.type = arg.type;
 return tree;
 }
 public void visitNewArray(JCNewArray tree) {
-Type owntype = syms.errType;
+Type owntype = types.createErrorType(tree.type);
 Type elemtype;
 if (tree.elemtype != null) {
 elemtype = attribType(tree.elemtype, env);
 chk.validate(tree.elemtype);
 owntype = elemtype;
 } else {
 if (pt.tag != ERROR) {
 log.error(tree.pos(), "illegal.initializer.for.type",
 pt);
 }
-elemtype = syms.errType;
+elemtype = types.createErrorType(pt);
 }
 }
 if (tree.elems != null) {
 attribExprs(tree.elems, env, elemtype);
 owntype = new ArrayType(elemtype, syms.arrayClass);
 // Find operator.
 Symbol operator = tree.operator =
 rs.resolveUnaryOperator(tree.pos(), tree.getTag(), env, argtype);
-Type owntype = syms.errType;
+Type owntype = types.createErrorType(tree.type);
 if (operator.kind == MTH) {
 owntype = (JCTree.PREINC <= tree.getTag() && tree.getTag() <= JCTree.POSTDEC)
 ? tree.arg.type
 : operator.type.getReturnType();
 int opc = ((OperatorSymbol)operator).opcode;
 // Find operator.
 Symbol operator = tree.operator =
 rs.resolveBinaryOperator(tree.pos(), tree.getTag(), env, left, right);
-Type owntype = syms.errType;
+Type owntype = types.createErrorType(tree.type);
 if (operator.kind == MTH) {
 owntype = operator.type.getReturnType();
 int opc = chk.checkOperator(tree.lhs.pos(),
 (OperatorSymbol)operator,
 tree.getTag(),
 chk.checkCastable(tree.expr.pos(), exprtype, clazztype);
 result = check(tree, syms.booleanType, VAL, pkind, pt);
 }
 public void visitIndexed(JCArrayAccess tree) {
-Type owntype = syms.errType;
+Type owntype = types.createErrorType(tree.type);
 Type atype = attribExpr(tree.indexed, env);
 attribExpr(tree.index, env, syms.intType);
 if (types.isArray(atype))
 owntype = types.elemtype(atype);
 else if (atype.tag != ERROR)
 Type elt = site;
 while (elt.tag == ARRAY)
 elt = ((ArrayType)elt).elemtype;
 if (elt.tag == TYPEVAR) {
 log.error(tree.pos(), "type.var.cant.be.deref");
-result = syms.errType;
+result = types.createErrorType(tree.type);
 return;
 }
 }
 // If qualifier symbol is a type or `super', assert `selectSuper'
 } else {
 return sym;
 }
 case ERROR:
 // preserve identifier names through errors
-return new ErrorType(name, site.tsym).tsym;
+return types.createErrorType(name, site.tsym, site).tsym;
 default:
 // The qualifier expression is of a primitive type -- only
 // .class is allowed for these.
 if (name == names._class) {
 // In this case, we have already made sure in Select that
 Symbol sym,
 Env<AttrContext> env,
 int pkind,
 Type pt,
 boolean useVarargs) {
-if (pt.isErroneous()) return syms.errType;
+if (pt.isErroneous()) return types.createErrorType(site);
 Type owntype; // The computed type of this identifier occurrence.
 switch (sym.kind) {
 case TYP:
 // For types, the computed type equals the symbol's type,
 // except for two situations:
 if (env.info.tvars.nonEmpty()) {
 Type owntype1 = new ForAll(env.info.tvars, owntype);
 for (List<Type> l = env.info.tvars; l.nonEmpty(); l = l.tail)
 if (!owntype.contains(l.head)) {
 log.error(tree.pos(), "undetermined.type", owntype1);
-owntype1 = syms.errType;
+owntype1 = types.createErrorType(owntype1);
 }
 owntype = owntype1;
 }
 // If the variable is a constant, record constant value in
 if (!pt.isErroneous())
 log.error(env.tree.pos(),
 "internal.error.cant.instantiate",
 sym, site,
 Type.toString(pt.getParameterTypes()));
-owntype = syms.errType;
+owntype = types.createErrorType(site);
 } else {
 // System.out.println("call   : " + env.tree);
 // System.out.println("method : " + owntype);
 // System.out.println("actuals: " + argtypes);
 List<Type> formals = owntype.getParameterTypes();
 /** Visitor method for parameterized types.
 *  Bound checking is left until later, since types are attributed
 *  before supertype structure is completely known
 */
 public void visitTypeApply(JCTypeApply tree) {
-Type owntype = syms.errType;
+Type owntype = types.createErrorType(tree.type);
 // Attribute functor part of application and make sure it's a class.
 Type clazztype = chk.checkClassType(tree.clazz.pos(), attribType(tree.clazz, env));
 // Attribute type parameters
 log.error(tree.pos(), "wrong.number.type.args",
 Integer.toString(formals.length()));
 } else {
 log.error(tree.pos(), "type.doesnt.take.params", clazztype.tsym);
 }
-owntype = syms.errType;
+owntype = types.createErrorType(tree.type);
 }
 }
 result = check(tree, owntype, TYP, pkind, pt);
 }

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