Support synthetic default constructors.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_visitor.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.
 
 part of dart2js.ir_builder;
 
 /**
  * This task iterates through all resolved elements and builds [ir.Node]s. The
  * nodes are stored in the [nodes] map and accessible through [hasIr] and
  * [getIr].
@@ skipping 53 matching lines @@
     if (element is FunctionElement) {
       // TODO(sigurdm): Support native functions for dart2js.
       assert(invariant(element, !element.isNative));
 
       // TODO(kmillikin,sigurdm): Support constructors.
       if (element is ConstructorElement && !element.isGenerativeConstructor) {
         return false;
       }
 
     } else if (element is! FieldElement) {
-      compiler.internalError(element, "Unexpected elementtype $element");
+      compiler.internalError(element, "Unexpected element type $element");
     }
     return compiler.backend.shouldOutput(element);
   }
 
   bool get inCheckedMode {
     bool result = false;
     assert((result = true));
     return result;
   }
 
@@ skipping 98 matching lines @@
     signature.orderedForEachParameter((ParameterElement parameterElement) {
       irBuilder.createFunctionParameter(parameterElement);
     });
 
     List<ConstantExpression> defaults = new List<ConstantExpression>();
     signature.orderedOptionalParameters.forEach((ParameterElement element) {
       defaults.add(getConstantForVariable(element));
     });
 
     List<ir.Initializer> initializers;
-    if (element.isGenerativeConstructor) {
+    if (element.isSynthesized) {
+      assert(element is ConstructorElement);
+      return irBuilder.makeConstructorDefinition(const <ConstantExpression>[],
+          const <ir.Initializer>[]);
+    } else if (element.isGenerativeConstructor) {
       initializers = buildConstructorInitializers(node, element);
       visit(node.body);
       return irBuilder.makeConstructorDefinition(defaults, initializers);
     } else {
       visit(node.body);
       return irBuilder.makeFunctionDefinition(defaults);
     }
   }
 
   List<ir.Initializer> buildConstructorInitializers(
@@ skipping 68 matching lines @@
                                                   <ir.RunnableBody>[],
                                                   selector));
       }
     }
     return result;
   }
 
   ir.FunctionDefinition buildFunction(FunctionElement element) {
     assert(invariant(element, element.isImplementation));
     ast.FunctionExpression node = element.node;
-    assert(node != null);
-    assert(elements[node] != null);
 
-    DetectClosureVariables closureLocals = new DetectClosureVariables(elements);
-    closureLocals.visit(node);
+    Iterable<Entity> usedFromClosure;
+    if (!element.isSynthesized) {
+      assert(node != null);
+      assert(elements[node] != null);
+
+      // TODO(karlklose): this information should be provided by resolution.
+      DetectClosureVariables closureLocals =
+          new DetectClosureVariables(elements);
+      closureLocals.visit(node);
+      usedFromClosure = closureLocals.usedFromClosure;
+    } else {
+      SynthesizedConstructorElementX constructor = element;
+      if (!constructor.isDefaultConstructor) {
+        giveup(null, 'cannot handle synthetic forwarding constructors');
+      }
+
+      usedFromClosure = <Entity>[];
+    }
 
     IrBuilder builder = new IrBuilder(compiler.backend.constantSystem,
                                       element,
-                                      closureLocals.usedFromClosure);
+                                      usedFromClosure);
 
     return withBuilder(builder, () => _makeFunctionBody(element, node));
   }
 
   ir.Primitive visit(ast.Node node) => node.accept(this);
 
   // ==== Statements ====
   visitBlock(ast.Block node) {
     irBuilder.buildBlock(node.statements.nodes, build);
   }
@@ skipping 735 matching lines @@
     currentFunction = elements[node];
     if (node.initializers != null) {
       insideInitializer = true;
       visit(node.initializers);
       insideInitializer = false;
     }
     visit(node.body);
     currentFunction = oldFunction;
   }
 }