Recover from bad supertypes.

pkg/front_end/lib/src/fasta/kernel/kernel_library_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.kernel_library_builder;
 
 import 'package:kernel/ast.dart';
 
 import 'package:kernel/clone.dart' show CloneVisitor;
 
@@ skipping 50 matching lines @@
 
   final List<KernelProcedureBuilder> nativeMethods = <KernelProcedureBuilder>[];
 
   final List<KernelTypeVariableBuilder> boundlessTypeVariables =
       <KernelTypeVariableBuilder>[];
 
   KernelLibraryBuilder(Uri uri, Uri fileUri, Loader loader)
       : library = new Library(uri, fileUri: relativizeUri(fileUri)),
         super(loader, fileUri);
 
+  Library get target => library;
+
   Uri get uri => library.importUri;
 
   KernelTypeBuilder addNamedType(
       String name, List<KernelTypeBuilder> arguments, int charOffset) {
     KernelNamedTypeBuilder type =
         new KernelNamedTypeBuilder(name, arguments, charOffset, fileUri);
     if (identical(name, "dynamic")) {
       type.builder =
           new DynamicTypeBuilder(const DynamicType(), this, charOffset);
     } else {
@@ skipping 192 matching lines @@
     var builder = new KernelTypeVariableBuilder(name, this, charOffset, bound);
     boundlessTypeVariables.add(builder);
     return builder;
   }
 
   void buildBuilder(Builder builder) {
     if (builder is SourceClassBuilder) {
       Class cls = builder.build(this);
       library.addClass(cls);
     } else if (builder is KernelFieldBuilder) {
-      library.addMember(builder.build(library)..isStatic = true);
+      library.addMember(builder.build(this)..isStatic = true);
     } else if (builder is KernelProcedureBuilder) {
-      library.addMember(builder.build(library)..isStatic = true);
+      library.addMember(builder.build(this)..isStatic = true);
     } else if (builder is FunctionTypeAliasBuilder) {
       // Kernel discard typedefs and use their corresponding function types
       // directly.
     } else if (builder is KernelEnumBuilder) {
       library.addClass(builder.build(this));
     } else if (builder is PrefixBuilder) {
       // Ignored. Kernel doesn't represent prefixes.
     } else {
       internalError("Unhandled builder: ${builder.runtimeType}");
     }
@@ skipping 91 matching lines @@
     i = 0;
     for (KernelTypeVariableBuilder variable in original) {
       copy[i++].bound = variable.bound?.subst(substitution);
     }
     return copy;
   }
 
   int finishTypeVariables(ClassBuilder object) {
     int count = boundlessTypeVariables.length;
     for (KernelTypeVariableBuilder builder in boundlessTypeVariables) {
-      builder.finish(object);
+      builder.finish(this, object);
     }
     boundlessTypeVariables.clear();
     return count;
   }
 
   @override
   void includePart(covariant KernelLibraryBuilder part) {
     super.includePart(part);
     nativeMethods.addAll(part.nativeMethods);
     boundlessTypeVariables.addAll(part.boundlessTypeVariables);
     assert(mixinApplicationClasses.isEmpty);
   }
 }
 
 bool isConstructorName(String name, String className) {
   if (name.startsWith(className)) {
     if (name.length == className.length) return true;
     if (name.startsWith(".", className.length)) return true;
   }
   return false;
 }