Generative constructors in the new dart backend.

pkg/compiler/lib/src/tree_ir/tree_ir_nodes.dart

 // Copyright (c) 2014, 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 tree_ir_nodes;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' as values;
 import '../cps_ir/cps_ir_nodes.dart' as cps_ir;
 import '../dart_types.dart' show DartType, GenericType;
@@ skipping 495 matching lines @@
 
 /**
  * A return exit from the function.
  *
  * In contrast to the CPS-based IR, the return value is an arbitrary
  * expression.
  */
 class Return extends Statement {
   /// Should not be null. Use [Constant] with [NullConstantValue] for void
   /// returns.
+  /// Even in constructors this holds true. Take special care when translating
+  /// back to dart, where `return null;` in a constructor is an error.
   Expression value;
 
   Statement get next => null;
   void set next(Statement s) => throw 'UNREACHABLE';
 
   Return(this.value);
 
   accept(StatementVisitor visitor) => visitor.visitReturn(this);
   accept1(StatementVisitor1 visitor, arg) => visitor.visitReturn(this, arg);
 }
@@ skipping 72 matching lines @@
   FunctionDefinition(this.element, this.parameters, this.body,
       this.localConstants, this.defaultParameterValues);
 
   /// Returns `true` if this function is abstract.
   ///
   /// If `true` [body] is `null` and [localConstants] is empty.
   bool get isAbstract => body == null;
   applyPass(Pass pass) => pass.rewriteFunctionDefinition(this);
 }
 
+abstract class Initializer implements Expression {}
+
+class FieldInitializer extends Initializer {
+  final FieldElement element;
+  Statement body;
+  bool processed = false;
+
+  FieldInitializer(this.element, this.body);
+
+  accept(ExpressionVisitor visitor) => visitor.visitFieldInitializer(this);
+  accept1(ExpressionVisitor1 visitor, arg) {
+    return visitor.visitFieldInitializer(this, arg);
+  }
+}
+
+class SuperInitializer extends Initializer {
+  final ConstructorElement target;
+  final Selector selector;
+  final List<Statement> arguments;
+  bool processed = false;
+
+  SuperInitializer(this.target, this.selector, this.arguments);
+  accept(ExpressionVisitor visitor) => visitor.visitSuperInitializer(this);
+  accept1(ExpressionVisitor1 visitor, arg) {
+    return visitor.visitSuperInitializer(this, arg);
+  }
+}
+
+class ConstructorDefinition extends FunctionDefinition {
+  final List<Initializer> initializers;
+
+  ConstructorDefinition(ConstructorElement element,
+                        List<Variable> parameters,
+                        Statement body,
+                        this.initializers,
+                        List<ConstDeclaration> localConstants,
+                        List<ConstantExpression> defaultParameterValues)
+      : super(element, parameters, body, localConstants,
+              defaultParameterValues);
+
+  applyPass(Pass pass) => pass.rewriteConstructorDefinition(this);
+}
+
 abstract class ExpressionVisitor<E> {
   E visitExpression(Expression e) => e.accept(this);
   E visitVariable(Variable node);
   E visitInvokeStatic(InvokeStatic node);
   E visitInvokeMethod(InvokeMethod node);
   E visitInvokeSuperMethod(InvokeSuperMethod node);
   E visitInvokeConstructor(InvokeConstructor node);
   E visitConcatenateStrings(ConcatenateStrings node);
   E visitConstant(Constant node);
   E visitThis(This node);
   E visitReifyTypeVar(ReifyTypeVar node);
   E visitConditional(Conditional node);
   E visitLogicalOperator(LogicalOperator node);
   E visitNot(Not node);
   E visitLiteralList(LiteralList node);
   E visitLiteralMap(LiteralMap node);
   E visitTypeOperator(TypeOperator node);
   E visitFunctionExpression(FunctionExpression node);
+  E visitFieldInitializer(FieldInitializer node);
+  E visitSuperInitializer(SuperInitializer node);
 }
 
 abstract class ExpressionVisitor1<E, A> {
   E visitExpression(Expression e, A arg) => e.accept1(this, arg);
   E visitVariable(Variable node, A arg);
   E visitInvokeStatic(InvokeStatic node, A arg);
   E visitInvokeMethod(InvokeMethod node, A arg);
   E visitInvokeSuperMethod(InvokeSuperMethod node, A arg);
   E visitInvokeConstructor(InvokeConstructor node, A arg);
   E visitConcatenateStrings(ConcatenateStrings node, A arg);
   E visitConstant(Constant node, A arg);
   E visitThis(This node, A arg);
   E visitReifyTypeVar(ReifyTypeVar node, A arg);
   E visitConditional(Conditional node, A arg);
   E visitLogicalOperator(LogicalOperator node, A arg);
   E visitNot(Not node, A arg);
   E visitLiteralList(LiteralList node, A arg);
   E visitLiteralMap(LiteralMap node, A arg);
   E visitTypeOperator(TypeOperator node, A arg);
   E visitFunctionExpression(FunctionExpression node, A arg);
+  E visitFieldInitializer(FieldInitializer node, A arg);
+  E visitSuperInitializer(SuperInitializer node, A arg);
 }
 
 abstract class StatementVisitor<S> {
   S visitStatement(Statement s) => s.accept(this);
   S visitLabeledStatement(LabeledStatement node);
   S visitAssign(Assign node);
   S visitReturn(Return node);
   S visitBreak(Break node);
   S visitContinue(Continue node);
   S visitIf(If node);
@@ skipping 134 matching lines @@
 
   visitFunctionDeclaration(FunctionDeclaration node) {
     visitFunctionDefinition(node.definition);
     visitStatement(node.next);
   }
 
   visitExpressionStatement(ExpressionStatement node) {
     visitExpression(node.expression);
     visitStatement(node.next);
   }
+
+  visitFieldInitializer(FieldInitializer node) {
+    visitStatement(node.body);
+  }
+
+  visitSuperInitializer(SuperInitializer node) {
+    node.arguments.forEach(visitStatement);
+  }
 }