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

equal deleted inserted replaced

-:add7eef3ce4a
+:873b053bf757
 *  @param req        The type that was required.
 */
 Type typeError(DiagnosticPosition pos, Object problem, Type found, Type req) {
 log.error(pos, "prob.found.req",
 problem, found, req);
-return syms.errType;
+return types.createErrorType(found);
 }
 Type typeError(DiagnosticPosition pos, String problem, Type found, Type req, Object explanation) {
 log.error(pos, "prob.found.req.1", problem, found, req, explanation);
-return syms.errType;
+return types.createErrorType(found);
 }
 /** Report an error that wrong type tag was found.
 *  @param pos        Position to be used for error reporting.
 *  @param required   An internationalized string describing the type tag
 *                    required.
 *  @param found      The type that was found.
 */
 Type typeTagError(DiagnosticPosition pos, Object required, Object found) {
 log.error(pos, "type.found.req", found, required);
-return syms.errType;
+return types.createErrorType(found instanceof Type ? (Type)found : syms.errType);
 }
 /** Report an error that symbol cannot be referenced before super
 *  has been called.
 *  @param pos        Position to be used for error reporting.
 return found;
 if (found.tag <= DOUBLE && req.tag <= DOUBLE)
 return typeError(pos, diags.fragment("possible.loss.of.precision"), found, req);
 if (found.isSuperBound()) {
 log.error(pos, "assignment.from.super-bound", found);
-return syms.errType;
+return types.createErrorType(found);
 }
 if (req.isExtendsBound()) {
 log.error(pos, "assignment.to.extends-bound", req);
-return syms.errType;
+return types.createErrorType(found);
 }
 return typeError(pos, diags.fragment("incompatible.types"), found, req);
 }
 /** Instantiate polymorphic type to some prototype, unless
 if (ex.isAmbiguous) {
 JCDiagnostic d = ex.getDiagnostic();
 log.error(pos,
 "undetermined.type" + (d!=null ? ".1" : ""),
 t, d);
-return syms.errType;
+return types.createErrorType(pt);
 } else {
 JCDiagnostic d = ex.getDiagnostic();
 return typeError(pos,
 diags.fragment("incompatible.types" + (d!=null ? ".1" : ""), d),
 t, pt);
 *  @param t             The type to be checked.
 */
 Type checkNonVoid(DiagnosticPosition pos, Type t) {
 if (t.tag == VOID) {
 log.error(pos, "void.not.allowed.here");
-return syms.errType;
+return types.createErrorType(t);
 } else {
 return t;
 }
 }
 return typeTagError(pos,
 diags.fragment("type.req.class.array"),
 t);
 } else if (!types.isReifiable(t)) {
 log.error(pos, "illegal.generic.type.for.instof");
-return syms.errType;
+return types.createErrorType(t);
 } else {
 return t;
 }
 }
 final TypeVar tv;
 if  (t.tag == TYPEVAR && (t.tsym.flags() & UNATTRIBUTED) != 0)
 return;
 if (seen.contains(t)) {
 tv = (TypeVar)t;
-tv.bound = new ErrorType();
+tv.bound = types.createErrorType(t);
 log.error(pos, "cyclic.inheritance", t);
 } else if (t.tag == TYPEVAR) {
 tv = (TypeVar)t;
 seen.add(tv);
 for (Type b : types.getBounds(tv))
 /** Note that we found an inheritance cycle. */
 private void noteCyclic(DiagnosticPosition pos, ClassSymbol c) {
 log.error(pos, "cyclic.inheritance", c);
 for (List<Type> l=types.interfaces(c.type); l.nonEmpty(); l=l.tail)
-l.head = new ErrorType((ClassSymbol)l.head.tsym);
+l.head = types.createErrorType((ClassSymbol)l.head.tsym, Type.noType);
 Type st = types.supertype(c.type);
 if (st.tag == CLASS)
-((ClassType)c.type).supertype_field = new ErrorType((ClassSymbol)st.tsym);
+((ClassType)c.type).supertype_field = types.createErrorType((ClassSymbol)st.tsym, Type.noType);
-c.type = new ErrorType(c);
+c.type = types.createErrorType(c, c.type);
 c.flags_field |= ACYCLIC;
 }
 /** Check that all methods which implement some
 *  method conform to the method they implement.

changeset 1257	873b053bf757
parent 1040	c0f5acfd9d15
child 1260	a772ba9ba43d