Recover from bad supertypes.

pkg/front_end/lib/src/fasta/kernel/body_builder.dart

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library fasta.body_builder;
 
 import '../parser/parser.dart' show FormalParameterType, optional;
 
 import '../parser/error_kind.dart' show ErrorKind;
 
@@ skipping 157 matching lines @@
 
   @override
   Expression toValue(Object node) {
     if (node is UnresolvedIdentifier) {
       return throwNoSuchMethodError(
           node.name.name, new Arguments.empty(), node.fileOffset,
           isGetter: true);
     } else if (node is BuilderAccessor) {
       return node.buildSimpleRead();
     } else if (node is TypeVariableBuilder) {
-      TypeParameterType type = node.buildTypesWithBuiltArguments(null);
+      TypeParameterType type = node.buildTypesWithBuiltArguments(library, null);
       if (!isInstanceContext && type.parameter.parent is Class) {
         return buildCompileTimeError(
             "Type variables can only be used in instance methods.");
       } else {
         return new TypeLiteral(type);
       }
     } else if (node is TypeDeclarationBuilder) {
-      return new TypeLiteral(node.buildTypesWithBuiltArguments(null));
+      return new TypeLiteral(node.buildTypesWithBuiltArguments(library, null));
     } else if (node is KernelTypeBuilder) {
-      return new TypeLiteral(node.build());
+      return new TypeLiteral(node.build(library));
     } else if (node is Expression) {
       return node;
     } else if (node is PrefixBuilder) {
       return buildCompileTimeError("A library can't be used as an expression.");
     } else {
       return internalError("Unhandled: ${node.runtimeType}");
     }
   }
 
   Expression toEffect(Object node) {
@@ skipping 743 matching lines @@
     exitLocalScope();
     push(block);
   }
 
   @override
   void handleAssignmentExpression(Token token) {
     debugEvent("AssignmentExpression");
     Expression value = popForValue();
     var accessor = pop();
     if (accessor is TypeDeclarationBuilder) {
-      push(wrapInvalid(
-          new TypeLiteral(accessor.buildTypesWithBuiltArguments(null))));
+      push(wrapInvalid(new TypeLiteral(
+          accessor.buildTypesWithBuiltArguments(library, null))));
     } else if (accessor is! BuilderAccessor) {
       push(buildCompileTimeError("Can't assign to this.", token.charOffset));
     } else {
       push(new DelayedAssignment(
           this, token.charOffset, accessor, value, token.stringValue));
     }
   }
 
   @override
   void enterLoop(int charOffset) {
@@ skipping 177 matching lines @@
       }
     }
     push(new SymbolLiteral(value));
   }
 
   DartType toKernelType(String name, List<DartType> arguments, int charOffset) {
     if (identical(name, "void")) return const VoidType();
     if (identical(name, "dynamic")) return const DynamicType();
     Builder builder = scope.lookup(name, charOffset, uri);
     if (builder is TypeDeclarationBuilder) {
-      return builder.buildTypesWithBuiltArguments(arguments);
+      return builder.buildTypesWithBuiltArguments(library, arguments);
     }
     if (builder == null) {
       warning("Type not found: '$name'.", charOffset);
     } else {
       warning("Not a type: '$name'.", charOffset);
     }
     // TODO(ahe): Create an error somehow.
     return const DynamicType();
   }
 
@@ skipping 33 matching lines @@
     if (name is Identifier) {
       name = name.name;
     }
     if (name is BuilderAccessor) {
       warning("'${beginToken.value}' isn't a type.", beginToken.charOffset);
       push(const DynamicType());
     } else if (name is UnresolvedIdentifier) {
       warning("'${name.name}' isn't a type.", beginToken.charOffset);
       push(const DynamicType());
     } else if (name is TypeVariableBuilder) {
-      push(name.buildTypesWithBuiltArguments(arguments));
+      push(name.buildTypesWithBuiltArguments(library, arguments));
     } else if (name is TypeDeclarationBuilder) {
-      push(name.buildTypesWithBuiltArguments(arguments));
+      push(name.buildTypesWithBuiltArguments(library, arguments));
     } else if (name is TypeBuilder) {
-      push(name.build());
+      push(name.build(library));
     } else {
       push(toKernelType(name, arguments, beginToken.charOffset));
     }
     if (peek() is TypeParameterType) {
       TypeParameterType type = peek();
       if (!isInstanceContext && type.parameter.parent is Class) {
         pop();
         warning("Type variables can only be used in instance methods.",
             beginToken.charOffset);
         push(const DynamicType());
@@ skipping 66 matching lines @@
       dynamic builder = formalParameterScope.lookup(name.name, charOffset, uri);
       if (builder == null) {
         if (thisKeyword == null) {
           internalError("Internal error: formal missing for '${name.name}'");
         } else {
           addCompileTimeError(thisKeyword.charOffset,
               "'${name.name}' isn't a field in this class.");
           thisKeyword = null;
         }
       } else if (thisKeyword == null) {
-        variable = builder.build();
+        variable = builder.build(library);
         variable.initializer = name.initializer;
       } else if (builder.isField && builder.parent == classBuilder) {
         FieldBuilder field = builder;
         if (type != null) {
           nit("Ignoring type on 'this' parameter '${name.name}'.",
               thisKeyword.charOffset);
         }
         type = field.target.type ?? const DynamicType();
         variable = new VariableDeclaration(name.name,
             type: type, initializer: name.initializer);
@@ skipping 1375 matching lines @@
   } else if (node is TypeDeclarationBuilder) {
     return node.name;
   } else if (node is PrefixBuilder) {
     return node.name;
   } else if (node is ThisPropertyAccessor) {
     return node.name.name;
   } else {
     return internalError("Unhandled: ${node.runtimeType}");
   }
 }