dart2js cps: Translate synthesized mixin constructors.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.dart

 // Copyright (c) 2013, 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 dart2js.ir_builder_task;
 
 import '../closure.dart' as closurelib;
 import '../closure.dart' hide ClosureScope;
 import '../constants/expressions.dart';
 import '../dart_types.dart';
@@ skipping 2510 matching lines @@
           if (Elements.isNativeOrExtendsNative(c)) {
             // Native field is initialized elsewhere.
           } else {
             // Fields without an initializer default to null.
             // This value will be overwritten below if an initializer is found.
             fieldValues[field] = irBuilder.buildNullConstant();
           }
         }
       });
     }
+    // If this is a mixin constructor, it does not have its own parameter list
+    // or initializer list. Directly forward to the super constructor.
+    // Note that the declaration-site initializers originating from the
+    // mixed-in class were handled above.
+    if (enclosingClass.isMixinApplication) {
+      forwardSynthesizedMixinConstructor(constructor, supers, fieldValues);
+      return;
+    }
     // Evaluate initializing parameters, e.g. `Foo(this.x)`.
     constructor.functionSignature.orderedForEachParameter(
         (ParameterElement parameter) {
       if (parameter.isInitializingFormal) {
         InitializingFormalElement fieldParameter = parameter;
         fieldValues[fieldParameter.fieldElement] =
             irBuilder.buildLocalVariableGet(parameter);
       }
     });
     // Evaluate constructor initializers, e.g. `Foo() : x = 50`.
@@ skipping 46 matching lines @@
   ///
   /// Calls [loadArguments] and [evaluateConstructorFieldInitializers] in a
   /// visitor that has the proper [TreeElements] mapping.
   void evaluateConstructorCallFromInitializer(
       ConstructorElement target,
       CallStructure call,
       List<ir.Primitive> arguments,
       List<ConstructorElement> supers,
       Map<FieldElement, ir.Primitive> fieldValues) {
     JsIrBuilderVisitor visitor = makeVisitorForContext(target);
-    return visitor.withBuilder(irBuilder, () {
+    visitor.withBuilder(irBuilder, () {
       visitor.loadArguments(target, call, arguments);
       visitor.evaluateConstructorFieldInitializers(target, supers, fieldValues);
     });
   }
 
+  /// Evaluate the implicit super call in the given mixin constructor.
+  void forwardSynthesizedMixinConstructor(
+        ConstructorElement constructor,
+        List<ConstructorElement> supers,
+        Map<FieldElement, ir.Primitive> fieldValues) {
+    assert(constructor.enclosingClass.implementation.isMixinApplication);
+    assert(constructor.isSynthesized);
+    ConstructorElement target =
+        constructor.definingConstructor.implementation;
+    // The resolver gives us the exact same FunctionSignature for the two
+    // constructors. The parameters for the synthesized constructor
+    // are already in the environment, so the target constructor's parameters
+    // are also in the environment since their elements are the same.
+    assert(constructor.functionSignature == target.functionSignature);
+    JsIrBuilderVisitor visitor = makeVisitorForContext(target);
+    visitor.withBuilder(irBuilder, () {
+      visitor.evaluateConstructorFieldInitializers(target, supers, fieldValues);
+    });
+  }
+
   /// Loads the type variables for all super classes of [superClass] into the
   /// IR builder's environment with their corresponding values.
   ///
   /// The type variables for [currentClass] must already be in the IR builder's
   /// environment.
   ///
   /// Type variables are stored as [TypeVariableLocal] in the environment.
   ///
   /// This ensures that access to type variables mentioned inside the
   /// constructors and initializers will happen through the local environment
@@ skipping 639 matching lines @@
   }
 
   processSetStatic(ir.SetStatic node) {
     node.body = replacementFor(node.body);
   }
 
   processContinuation(ir.Continuation node) {
     node.body = replacementFor(node.body);
   }
 }