Perform MixinFullResolution only for source libraries.

pkg/kernel/lib/transformations/mixin_full_resolution.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 kernel.transformations.mixin_full_resolution;
 
 import '../ast.dart';
 import '../class_hierarchy.dart';
 import '../clone.dart';
 import '../core_types.dart';
-import '../target/targets.dart' show NoneTarget, Target;
+import '../target/targets.dart' show Target;
 import '../type_algebra.dart';
 
-Program transformProgram(Program program) {
-  new MixinFullResolution(new NoneTarget(null)).transform(program);
-  return program;
+void transformLibraries(Target targetInfo, List<Library> libraries) {
+  new MixinFullResolution(targetInfo).transform(libraries);
 }
 
 /// Replaces all mixin applications with regular classes, cloning all fields
 /// and procedures from the mixed-in class, cloning all constructors from the
 /// base class.
 ///
 /// Super calls (as well as super initializer invocations) are also resolved
 /// to their targets in this pass.
 class MixinFullResolution {
   final Target targetInfo;
 
   ClassHierarchy hierarchy;
   CoreTypes coreTypes;
 
   MixinFullResolution(this.targetInfo);
 
-  void transform(Program program) {
+  /// Transform the given new [libraries].  It is expected that all other
+  /// libraries have already been transformed.
+  void transform(List<Library> libraries) {
+    if (libraries.isEmpty) return;
+
     var transformedClasses = new Set<Class>();
 
     // Desugar all mixin application classes by copying in fields/methods from
     // the mixin and constructors from the base class.
     var processedClasses = new Set<Class>();
-    for (var library in program.libraries) {
+    for (var library in libraries) {
       if (library.isExternal) continue;
 
       for (var class_ in library.classes) {
-        transformClass(processedClasses, transformedClasses, class_);
+        transformClass(libraries, processedClasses, transformedClasses, class_);
       }
     }
 
+    // TODO(scheglov) Remove "program" once we switch to creating "hierarchy"
+    // and "coreTypes" outside and passing into the transformers.
+    var program = libraries.first.enclosingProgram;
     hierarchy = new ClassHierarchy(program);
     coreTypes = new CoreTypes(program);
 
     // Resolve all super call expressions and super initializers.
-    for (var library in program.libraries) {
+    for (var library in libraries) {
       if (library.isExternal) continue;
 
       for (var class_ in library.classes) {
         final bool hasTransformedSuperclass =
             transformedClasses.contains(class_.superclass);
 
         for (var procedure in class_.procedures) {
           if (procedure.containsSuperCalls) {
             new SuperCallResolutionTransformer(
                     hierarchy, coreTypes, class_.superclass, targetInfo)
                 .visit(procedure);
           }
         }
         for (var constructor in class_.constructors) {
           if (constructor.containsSuperCalls) {
             new SuperCallResolutionTransformer(
                     hierarchy, coreTypes, class_.superclass, targetInfo)
                 .visit(constructor);
           }
           if (hasTransformedSuperclass && constructor.initializers.length > 0) {
             new SuperInitializerResolutionTransformer(class_.superclass)
                 .transformInitializers(constructor.initializers);
           }
         }
       }
     }
   }
 
-  transformClass(Set<Class> processedClasses, Set<Class> transformedClasses,
+  transformClass(
+      List<Library> librariesToBeTransformed,
+      Set<Class> processedClasses,
+      Set<Class> transformedClasses,
       Class class_) {
     // If this class was already handled then so were all classes up to the
     // [Object] class.
     if (!processedClasses.add(class_)) return;
 
     // Ensure super classes have been transformed before this class.
     if (class_.superclass != null &&
         class_.superclass.level.index >= ClassLevel.Mixin.index) {
-      transformClass(processedClasses, transformedClasses, class_.superclass);
+      transformClass(librariesToBeTransformed, processedClasses,
+          transformedClasses, class_.superclass);
     }
 
     // If this is not a mixin application we don't need to make forwarding
     // constructors in this class.
     if (!class_.isMixinApplication) return;
+    assert(librariesToBeTransformed.contains(class_.enclosingLibrary));
 
     if (class_.mixedInClass.level.index < ClassLevel.Mixin.index) {
       throw new Exception(
           'Class "${class_.name}" mixes in "${class_.mixedInClass.name}" from'
           ' an external library.  Did you forget --link?');
     }
 
     transformedClasses.add(class_);
 
     // Clone fields and methods from the mixin class.
@@ skipping 228 matching lines @@
           return null;
         }
       }
 
       throw new Exception(
           'Could not find a generative constructor named "${constructor.name}" '
           'in lookup class "${lookupClass.name}"!');
     }
   }
 }