Rewrite mixin application handling in Fasta.

pkg/front_end/lib/src/fasta/builder/class_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.class_builder;
 
 import '../errors.dart' show internalError;
 
 import 'builder.dart'
     show
@@ skipping 38 matching lines @@
       LibraryBuilder parent,
       int charOffset)
       : scopeBuilder = new ScopeBuilder(scope),
         constructorScopeBuilder = new ScopeBuilder(constructors),
         super(metadata, modifiers, name, parent, charOffset);
 
   /// Returns true if this class is the result of applying a mixin to its
   /// superclass.
   bool get isMixinApplication => mixedInType != null;
 
+  bool get isNamedMixinApplication {
+    return isMixinApplication && super.isNamedMixinApplication;
+  }
+
   T get mixedInType;
 
+  void set mixedInType(T mixin);
+
   List<ConstructorReferenceBuilder> get constructorReferences => null;
 
   LibraryBuilder get library {
     LibraryBuilder library = parent;
     return library.partOfLibrary ?? library;
   }
 
   @override
   int resolveConstructors(LibraryBuilder library) {
     if (constructorReferences == null) return 0;
@@ skipping 60 matching lines @@
           if (s != null) return s;
         }
       }
       return null;
     }
 
     void handleNamedTypeBuilder(NamedTypeBuilder t) {
       builder = t.builder;
       arguments = t.arguments ?? const [];
       if (builder is ClassBuilder) {
-        variables = builder.typeVariables;
-        supertype = builder.supertype;
+        ClassBuilder cls = builder;
+        variables = cls.typeVariables;
+        supertype = cls.supertype;
       }
     }
 
     while (builder != superclass) {
       variables = null;
       if (supertype is NamedTypeBuilder) {
         handleNamedTypeBuilder(supertype);
       } else if (supertype is MixinApplicationBuilder) {
         MixinApplicationBuilder t = supertype;
         NamedTypeBuilder s = findSuperclass(t);
         if (s != null) {
           handleNamedTypeBuilder(s);
         }
         supertype = t.supertype;
       } else {
-        internalError("Superclass not found.", fileUri, charOffset);
+        internalError("Superclass not found '${superclass.fullNameForErrors}'.",
+            fileUri, charOffset);
       }
       if (variables != null) {
         Map<TypeVariableBuilder, TypeBuilder> directSubstitutionMap =
             <TypeVariableBuilder, TypeBuilder>{};
         for (int i = 0; i < variables.length; i++) {
           TypeBuilder argument =
               i < arguments.length ? arguments[i] : dynamicType;
           if (substitutionMap != null) {
             argument = argument.subst(substitutionMap);
           }
@@ skipping 21 matching lines @@
   }
 
   void addWarning(int charOffset, String message) {
     library.addWarning(charOffset, message, fileUri: fileUri);
   }
 
   void addNit(int charOffset, String message) {
     library.addNit(charOffset, message, fileUri: fileUri);
   }
 }