Deal with bad supertypes.

pkg/front_end/lib/src/fasta/kernel/kernel_target.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_target;
 
 import 'dart:async' show Future;
 
 import 'dart:io' show File, IOSink;
 
@@ skipping 58 matching lines @@
     show InputError, internalError, reportCrash, resetCrashReporting;
 
 import '../util/relativize.dart' show relativizeUri;
 
 import '../compiler_context.dart' show CompilerContext;
 
 import 'kernel_builder.dart'
     show
         Builder,
         ClassBuilder,
+        InvalidTypeBuilder,
         KernelClassBuilder,
         KernelLibraryBuilder,
         KernelNamedTypeBuilder,
         KernelProcedureBuilder,
         LibraryBuilder,
         MixinApplicationBuilder,
         NamedMixinApplicationBuilder,
         NamedTypeBuilder,
         TypeBuilder,
         TypeVariableBuilder;
@@ skipping 309 matching lines @@
       // We have to test if builder.cls is a mixin application. [builder] may
       // think it's a mixin application, but if its mixed-in type couldn't be
       // resolved, the target class won't be a mixin application and we need
       // to add a default constructor to complete error recovery.
       return;
     }
     if (builder.constructors.isNotEmpty) return;
 
     /// Quotes below are from [Dart Programming Language Specification, 4th
     /// Edition](
     /// http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-408.pdf):

[karlklose, 2017/03/10 05:36:46]

BTW: http://ecma-international.org/publications/files/ECMA-ST/ECMA-408.pdf (that
is, without the 'www') also points to the document and avoids the long line.

[ahe, 2017/03/10 07:38:17]

Nice. And there's even room for an "s" after http.

     if (builder is NamedMixinApplicationBuilder) {
       /// >A mixin application of the form S with M; defines a class C with
       /// >superclass S.
       /// >...
 
       /// >Let LM be the library in which M is declared. For each generative
       /// >constructor named qi(Ti1 ai1, . . . , Tiki aiki), i in 1..n of S
       /// >that is accessible to LM , C has an implicitly declared constructor
       /// >named q'i = [C/S]qi of the form q'i(ai1,...,aiki) :
       /// >super(ai1,...,aiki);.
@@ skipping 18 matching lines @@
                     builder.charOffset, dynamicType),
                 builder.parent);
         if (supertype.cls.constructors.isEmpty) {
           builder.addSyntheticConstructor(makeDefaultConstructor());
         } else {
           for (Constructor constructor in supertype.cls.constructors) {
             builder.addSyntheticConstructor(makeMixinApplicationConstructor(
                 builder.cls.mixin, constructor, substitutionMap));
           }
         }
+      } else if (supertype is InvalidTypeBuilder) {
+        builder.addSyntheticConstructor(makeDefaultConstructor());
       } else {
         internalError("Unhandled: ${supertype.runtimeType}");
       }
     } else {
       /// >Iff no constructor is specified for a class C, it implicitly has a
       /// >default constructor C() : super() {}, unless C is class Object.
       // The superinitializer is installed below in [finishConstructors].
       builder.addSyntheticConstructor(makeDefaultConstructor());
     }
   }
@@ skipping 186 matching lines @@
   }
   for (Constructor constructor in superclass.constructors) {
     if (constructor.name.name.isEmpty) {
       return constructor.function.requiredParameterCount == 0
           ? constructor
           : null;
     }
   }
   return null;
 }