Recover from bad supertypes.

pkg/front_end/lib/src/fasta/kernel/kernel_procedure_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_procedure_builder;
 
 import 'package:kernel/ast.dart'
     show
         Arguments,
         AsyncMarker,
         Constructor,
         ConstructorInvocation,
         DartType,
         DynamicType,
         EmptyStatement,
         Expression,
         FunctionNode,
         Initializer,
-        Library,
         LocalInitializer,
         Member,
         Name,
         NamedExpression,
         Procedure,
         ProcedureKind,
         RedirectingInitializer,
         Statement,
         StaticInvocation,
         StringLiteral,
@@ skipping 15 matching lines @@
 import 'kernel_builder.dart'
     show
         Builder,
         ClassBuilder,
         ConstructorReferenceBuilder,
         FormalParameterBuilder,
         KernelFormalParameterBuilder,
         KernelLibraryBuilder,
         KernelTypeBuilder,
         KernelTypeVariableBuilder,
+        LibraryBuilder,
         MetadataBuilder,
         ProcedureBuilder,
         TypeVariableBuilder,
         memberError;
 
 abstract class KernelFunctionBuilder
     extends ProcedureBuilder<KernelTypeBuilder> {
   final String nativeMethodName;
 
   FunctionNode function;
@@ skipping 21 matching lines @@
     if (function != null) {
       function.body = newBody;
       newBody?.parent = function;
     }
   }
 
   Statement get body => actualBody ??= new EmptyStatement();
 
   bool get isNative => nativeMethodName != null;
 
-  FunctionNode buildFunction() {
+  FunctionNode buildFunction(LibraryBuilder library) {
     assert(function == null);
     FunctionNode result = new FunctionNode(body, asyncMarker: asyncModifier);
     if (typeVariables != null) {
       for (KernelTypeVariableBuilder t in typeVariables) {
         result.typeParameters.add(t.parameter);
       }
       setParents(result.typeParameters, result);
     }
     if (formals != null) {
       for (KernelFormalParameterBuilder formal in formals) {
-        VariableDeclaration parameter = formal.build();
+        VariableDeclaration parameter = formal.build(library);
         if (formal.isNamed) {
           result.namedParameters.add(parameter);
         } else {
           result.positionalParameters.add(parameter);
         }
         parameter.parent = result;
         if (formal.isRequired) {
           result.requiredParameterCount++;
         }
       }
     }
     if (returnType != null) {
-      result.returnType = returnType.build();
+      result.returnType = returnType.build(library);
     }
     if (!isConstructor && !isInstanceMember && parent is ClassBuilder) {
       List<TypeParameter> typeParameters = parent.target.typeParameters;
       if (typeParameters.isNotEmpty) {
         Map<TypeParameter, DartType> substitution;
         DartType removeTypeVariables(DartType type) {
           if (substitution == null) {
             substitution = <TypeParameter, DartType>{};
             for (TypeParameter parameter in typeParameters) {
               substitution[parameter] = const DynamicType();
@@ skipping 16 matching lines @@
           }
         }
         if (containsTypeVariable(result.returnType, set)) {
           result.returnType = removeTypeVariables(result.returnType);
         }
       }
     }
     return function = result;
   }
 
-  Member build(Library library);
+  Member build(LibraryBuilder library);
 
   void becomeNative(Loader loader) {
     target.isExternal = true;
     Builder constructor = loader.getNativeAnnotation();
     Arguments arguments =
         new Arguments(<Expression>[new StringLiteral(nativeMethodName)]);
     Expression annotation;
     if (constructor.isConstructor) {
       annotation = new ConstructorInvocation(constructor.target, arguments)
         ..isConst = true;
@@ skipping 45 matching lines @@
   }
 
   void set asyncModifier(AsyncMarker newModifier) {
     actualAsyncModifier = newModifier;
     if (function != null) {
       // No parent, it's an enum.
       function.asyncMarker = actualAsyncModifier;
     }
   }
 
-  Procedure build(Library library) {
+  Procedure build(LibraryBuilder library) {
     // TODO(ahe): I think we may call this twice on parts. Investigate.
     if (procedure.name == null) {
-      procedure.function = buildFunction();
+      procedure.function = buildFunction(library);
       procedure.function.parent = procedure;
       procedure.isAbstract = isAbstract;
       procedure.isStatic = isStatic;
       procedure.isExternal = isExternal;
       procedure.isConst = isConst;
-      procedure.name = new Name(name, library);
+      procedure.name = new Name(name, library.target);
     }
     return procedure;
   }
 
   Procedure get target => procedure;
 }
 
 // TODO(ahe): Move this to own file?
 class KernelConstructorBuilder extends KernelFunctionBuilder {
   final Constructor constructor = new Constructor(null);
@@ skipping 18 matching lines @@
             compilationUnit, charOffset, nativeMethodName);
 
   bool get isInstanceMember => false;
 
   bool get isConstructor => true;
 
   AsyncMarker get asyncModifier => AsyncMarker.Sync;
 
   ProcedureKind get kind => null;
 
-  Constructor build(Library library) {
+  Constructor build(LibraryBuilder library) {
     if (constructor.name == null) {
-      constructor.function = buildFunction();
+      constructor.function = buildFunction(library);
       constructor.function.parent = constructor;
       constructor.isConst = isConst;
       constructor.isExternal = isExternal;
-      constructor.name = new Name(name, library);
+      constructor.name = new Name(name, library.target);
     }
     return constructor;
   }
 
-  FunctionNode buildFunction() {
+  FunctionNode buildFunction(LibraryBuilder library) {
     // TODO(ahe): Should complain if another type is explicitly set.
-    return super.buildFunction()..returnType = const VoidType();
+    return super.buildFunction(library)..returnType = const VoidType();
   }
 
   Constructor get target => constructor;
 
   void checkSuperOrThisInitializer(Initializer initializer) {
     if (superInitializer != null || redirectingInitializer != null) {
       memberError(
           target,
           "Can't have more than one 'super' or 'this' initializer.",
           initializer.fileOffset);
@@ skipping 46 matching lines @@
         }
       }
       initializers.add(initializer..parent = constructor);
       initializers.add(superInitializer);
       return;
     }
     initializers.add(initializer);
     initializer.parent = constructor;
   }
 }