dart2js: Adds support for custom elements in CPS.

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 closure;
 import '../common.dart';
 import '../common/names.dart' show
     Identifiers,
@@ skipping 41 matching lines @@
 import '../util/util.dart';
 
 import 'package:js_runtime/shared/embedded_names.dart'
     show JsBuiltin, JsGetName;
 import '../constants/values.dart';
 import 'type_mask_system.dart' show
     TypeMaskSystem;
 
 typedef void IrBuilderCallback(Element element, ir.FunctionDefinition irNode);
 
+class ExplicitReceiverParameter implements Local {
+  final ExecutableElement executableContext;
+
+  ExplicitReceiverParameter(this.executableContext);
+
+  String get name => 'receiver';
+  String toString() => 'ExplicitReceiverParameter($executableContext)';
+}
+
 /// This task provides the interface to build IR nodes from [ast.Node]s, which
 /// is used from the [CpsFunctionCompiler] to generate code.
 ///
 /// This class is mainly there to correctly measure how long building the IR
 /// takes.
 class IrBuilderTask extends CompilerTask {
   final SourceInformationStrategy sourceInformationStrategy;
 
   String bailoutMessage = null;
 
@@ skipping 309 matching lines @@
     ClassElement classElement = constructor.enclosingClass.implementation;
 
     IrBuilder builder = getBuilderFor(constructor);
 
     final bool requiresTypeInformation =
         builder.program.requiresRuntimeTypesFor(classElement);
 
     return withBuilder(builder, () {
       // Setup parameters and create a box if anything is captured.
       List<Local> parameters = <Local>[];
+      if (constructor.isGenerativeConstructor &&
+          backend.isNativeOrExtendsNative(classElement)) {
+        parameters.add(new ExplicitReceiverParameter(constructor));
+      }
       constructor.functionSignature.orderedForEachParameter(
           (ParameterElement p) => parameters.add(p));
 
       int firstTypeArgumentParameterIndex;
 
       // If instances of the class may need runtime type information, we add a
       // synthetic parameter for each type parameter.
       if (requiresTypeInformation) {
         firstTypeArgumentParameterIndex = parameters.length;
         classElement.typeVariables.forEach((TypeVariableType variable) {
@@ skipping 38 matching lines @@
       evaluateConstructorFieldInitializers(
           constructor, constructorList, fieldValues);
 
       // All parameters in all constructors are now bound in the environment.
       // BoxLocals for captured parameters are also in the environment.
       // The initial value of all fields are now bound in [fieldValues].
 
       // --- Create the object ---
       // Get the initial field values in the canonical order.
       List<ir.Primitive> instanceArguments = <ir.Primitive>[];
+      List<FieldElement> fields = <FieldElement>[];
       classElement.forEachInstanceField((ClassElement c, FieldElement field) {
         ir.Primitive value = fieldValues[field];
         if (value != null) {
+          fields.add(field);
           instanceArguments.add(value);
         } else {
           assert(backend.isNativeOrExtendsNative(c));
           // Native fields are initialized elsewhere.
         }
       }, includeSuperAndInjectedMembers: true);
 
-      ir.Primitive instance = new ir.CreateInstance(
+      ir.Primitive instance;
+      if (constructor.isGenerativeConstructor &&
+          backend.isNativeOrExtendsNative(classElement)) {
+        instance = irParameters.first;
+        instance.type =
+            new TypeMask.exact(classElement, typeMaskSystem.classWorld);
+        irBuilder.addPrimitive(new ir.ReceiverCheck.nullCheck(
+            instance, Selectors.toString_, null));
+        for (int i = 0; i < fields.length; i++) {
+          irBuilder.addPrimitive(
+              new ir.SetField(instance, fields[i], instanceArguments[i]));
+        }
+      } else {
+        instance = new ir.CreateInstance(
           classElement,
           instanceArguments,
           typeInformation,
           constructor.hasNode
               ? sourceInformationBuilder.buildCreate(constructor.node)
-          // TODO(johnniwinther): Provide source information for creation
-          // through synthetic constructors.
+              // TODO(johnniwinther): Provide source information for creation
+              // through synthetic constructors.
               : null);
-      irBuilder.add(new ir.LetPrim(instance));
+        irBuilder.add(new ir.LetPrim(instance));
+      }
 
       // --- Call constructor bodies ---
       for (ConstructorElement target in constructorList) {
         ConstructorBodyElement bodyElement = getConstructorBody(target);
         if (bodyElement == null) continue; // Skip if constructor has no body.
         List<ir.Primitive> bodyArguments = <ir.Primitive>[];
         for (Local param in getConstructorBodyParameters(bodyElement)) {
           bodyArguments.add(irBuilder.environment.lookup(param));
         }
         Selector selector = new Selector.call(target.memberName,
@@ skipping 1883 matching lines @@
     if (constructor.isRedirectingFactory && !constructor.isCyclicRedirection) {
       ConstructorElement current = constructor;
       while (current.isRedirectingFactory) {
         var prefix = current.redirectionDeferredPrefix;
         if (prefix != null) buildCheckDeferredIsLoaded(prefix, send);
         current = current.immediateRedirectionTarget;
       }
     }
 
     List<ir.Primitive> arguments = argumentsNode.nodes.mapToList(visit);
+    if (constructor.isGenerativeConstructor &&
+        backend.isNativeOrExtendsNative(constructor.enclosingClass)) {
+      arguments.insert(0, irBuilder.buildNullConstant());
+    }
     // Use default values from the effective target, not the immediate target.
     ConstructorElement target;
     if (constructor == compiler.symbolConstructor) {
       // The Symbol constructor should perform validation of its argument
       // which is not expressible as a Dart const constructor.  Instead, the
       // libraries contain a dummy const constructor implementation that
       // doesn't perform validation and the compiler compiles a call to
       // (non-const) Symbol.validated when it sees new Symbol(...).
       target = compiler.symbolValidatedConstructor;
     } else {
@@ skipping 1842 matching lines @@
     _backend.jsInteropAnalysis.hasAnonymousAnnotation(element.contextClass);
 
   String getJsInteropTargetPath(FunctionElement element) {
     return '${_backend.namer.fixedBackendPath(element)}.'
       '${_backend.getFixedBackendName(element)}';
   }
 
   DartType get jsJavascriptObjectType =>
     _backend.helpers.jsJavaScriptObjectClass.thisType;
 }