Rewrite mixin application handling in Fasta.

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 63 matching lines @@
     show
         Builder,
         ClassBuilder,
         InvalidTypeBuilder,
         KernelClassBuilder,
         KernelLibraryBuilder,
         KernelNamedTypeBuilder,
         KernelProcedureBuilder,
         LibraryBuilder,
         MemberBuilder,
-        MixinApplicationBuilder,
-        NamedMixinApplicationBuilder,
         NamedTypeBuilder,
         TypeBuilder,
+        TypeDeclarationBuilder,
         TypeVariableBuilder;
 
 import 'verifier.dart' show verifyProgram;
 
 class KernelTarget extends TargetImplementation {
   /// The [FileSystem] which should be used to access files.
   final FileSystem fileSystem;
 
   final bool strongMode;
 
@@ skipping 43 matching lines @@
   LibraryBuilder createLibraryBuilder(Uri uri, Uri fileUri) {
     if (dillTarget.isLoaded) {
       var builder = dillTarget.loader.builders[uri];
       if (builder != null) {
         return builder;
       }
     }
     return new KernelLibraryBuilder(uri, fileUri, loader);
   }
 
+  void forEachDirectSupertype(ClassBuilder cls, void f(NamedTypeBuilder type)) {
+    TypeBuilder supertype = cls.supertype;
+    if (supertype is NamedTypeBuilder) {
+      f(supertype);
+    } else if (supertype != null) {
+      internalError("Unhandled: ${supertype.runtimeType}");
+    }
+    if (cls.interfaces != null) {
+      for (NamedTypeBuilder t in cls.interfaces) {
+        f(t);
+      }
+    }
+    if (cls.library.loader == loader &&
+        // TODO(ahe): Implement DillClassBuilder.mixedInType and remove the
+        // above check.
+        cls.mixedInType != null) {
+      f(cls.mixedInType);
+    }
+  }
+
   void addDirectSupertype(ClassBuilder cls, Set<ClassBuilder> set) {
     if (cls == null) return;
-    TypeBuilder supertype = cls.supertype;
-    add(NamedTypeBuilder type) {
+    forEachDirectSupertype(cls, (NamedTypeBuilder type) {
       Builder builder = type.builder;
       if (builder is ClassBuilder) {
         set.add(builder);
       }
-    }
-
-    if (supertype == null) {
-      // OK.
-    } else if (supertype is MixinApplicationBuilder) {
-      add(supertype.supertype);
-      for (NamedTypeBuilder t in supertype.mixins) {
-        add(t);
-      }
-    } else if (supertype is NamedTypeBuilder) {
-      add(supertype);
-    } else {
-      internalError("Unhandled: ${supertype.runtimeType}");
-    }
-    if (cls.interfaces != null) {
-      for (NamedTypeBuilder t in cls.interfaces) {
-        add(t);
-      }
-    }
+    });
   }
 
   List<ClassBuilder> collectAllClasses() {
     List<ClassBuilder> result = <ClassBuilder>[];
     loader.builders.forEach((Uri uri, LibraryBuilder library) {
       library.forEach((String name, Builder member) {
         if (member is KernelClassBuilder) {
           result.add(member);
         }
       });
@@ skipping 19 matching lines @@
 
   void breakCycle(ClassBuilder builder) {
     Class cls = builder.target;
     cls.implementedTypes.clear();
     cls.supertype = null;
     cls.mixedInType = null;
     builder.supertype = new KernelNamedTypeBuilder("Object", null,
         builder.charOffset, builder.fileUri ?? Uri.parse(cls.fileUri))
       ..builder = objectClassBuilder;
     builder.interfaces = null;
+    builder.mixedInType = null;
   }
 
   Future<Program> handleInputError(Uri uri, InputError error,
       {bool isFullProgram}) {
     if (error != null) {
       String message = error.format();
       print(message);
       errors.add(message);
     }
     program = erroneousProgram(isFullProgram);
     return uri == null
         ? new Future<Program>.value(program)
         : writeLinkedProgram(uri, program, isFullProgram: isFullProgram);
   }
 
   Future<Program> writeOutline(Uri uri) async {
     if (loader.first == null) return null;
     try {
       loader.createTypeInferenceEngine();
       await loader.buildOutlines();
       loader.coreLibrary
           .becomeCoreLibrary(const DynamicType(), const VoidType());
       dynamicType.bind(loader.coreLibrary["dynamic"]);
       loader.resolveParts();
       loader.computeLibraryScopes();
       loader.resolveTypes();
+      loader.checkSemantics();
       loader.buildProgram();
-      loader.checkSemantics();
       List<SourceClassBuilder> sourceClasses = collectAllSourceClasses();
       installDefaultSupertypes();
       installDefaultConstructors(sourceClasses);
       loader.resolveConstructors();
       loader.finishTypeVariables(objectClassBuilder);
       program = link(new List<Library>.from(loader.libraries));
       loader.computeHierarchy(program);
       loader.checkOverrides(sourceClasses);
       loader.prepareInitializerInference();
       loader.performInitializerInference();
@@ skipping 185 matching lines @@
     }
     ticker.logMs("Installed default constructors");
   }
 
   KernelClassBuilder get objectClassBuilder => loader.coreLibrary["Object"];
 
   Class get objectClass => objectClassBuilder.cls;
 
   /// If [builder] doesn't have a constructors, install the defaults.
   void installDefaultConstructor(SourceClassBuilder builder) {
-    if (builder.cls.isMixinApplication) {
-      // 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.isMixinApplication && !builder.isNamedMixinApplication) return;
     if (builder.constructors.local.isNotEmpty) return;
 
     /// Quotes below are from [Dart Programming Language Specification, 4th
     /// Edition](
     /// https://ecma-international.org/publications/files/ECMA-ST/ECMA-408.pdf):
-    if (builder is NamedMixinApplicationBuilder) {
+    if (builder.isNamedMixinApplication) {
       /// >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);.
-      Builder supertype = builder;
-      while (supertype is NamedMixinApplicationBuilder) {
-        NamedMixinApplicationBuilder named = supertype;
-        TypeBuilder type = named.mixinApplication;
-        if (type is MixinApplicationBuilder) {
-          MixinApplicationBuilder t = type;
-          type = t.supertype;
-        }
+      TypeDeclarationBuilder supertype = builder;
+      while (supertype.isMixinApplication) {
+        SourceClassBuilder named = supertype;
+        TypeBuilder type = named.supertype;
         if (type is NamedTypeBuilder) {
           supertype = type.builder;
         } else {
           internalError("Unhandled: ${type.runtimeType}");
         }
       }
       if (supertype is KernelClassBuilder) {
         Map<TypeParameter, DartType> substitutionMap =
             computeKernelSubstitutionMap(
                 builder.getSubstitutionMap(supertype, builder.fileUri,
@@ skipping 237 matching lines @@
   }
   for (Constructor constructor in superclass.constructors) {
     if (constructor.name.name.isEmpty) {
       return constructor.function.requiredParameterCount == 0
           ? constructor
           : null;
     }
   }
   return null;
 }