Generative constructors in the new dart backend.

pkg/compiler/lib/src/cps_ir/cps_ir_nodes.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.
 
 // IrNodes are kept in a separate library to have precise control over their
 // dependencies on other parts of the system.
 library dart2js.ir_nodes;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' as values show ConstantValue;
@@ skipping 531 matching lines @@
   bool get isReturnContinuation => body == null;
 
   Continuation(this.parameters);
 
   Continuation.retrn() : parameters = <Parameter>[new Parameter(null)];
 
   accept(Visitor visitor) => visitor.visitContinuation(this);
 }
 
 abstract class ExecutableDefinition implements Node {
-  Expression get body;
+  RunnableBody get body;
 
   applyPass(Pass pass);
 }
 
 // This is basically a function definition with an empty parameter list and a
 // field element instead of a function element and no const declarations, and
 // never a getter or setter, though that's less important.
-class FieldDefinition extends Node
-    implements InteriorNode, ExecutableDefinition {
+class FieldDefinition extends Node implements ExecutableDefinition {
   final FieldElement element;
-  final Continuation returnContinuation;
-  Expression body;
+  RunnableBody body;
 
-  FieldDefinition(this.element, this.returnContinuation, this.body);
+  FieldDefinition(this.element, this.body);
 
   FieldDefinition.withoutInitializer(this.element)
-      : this.returnContinuation = null;
+      : this.body = null;
 
   accept(Visitor visitor) => visitor.visitFieldDefinition(this);
   applyPass(Pass pass) => pass.rewriteFieldDefinition(this);
 
   /// `true` if this field has no initializer.
   ///
   /// If `true` [body] and [returnContinuation] are `null`.
   ///
   /// This is different from a initializer that is `null`. Consider this class:
   ///
@@ skipping 15 matching lines @@
 class ClosureVariable extends Definition {
   /// Body of code that declares this closure variable.
   ExecutableElement host;
   Entity hint;
 
   ClosureVariable(this.host, this.hint);
 
   accept(Visitor v) => v.visitClosureVariable(this);
 }
 
+class RunnableBody implements InteriorNode {
+  Expression body;
+  final Continuation returnContinuation;
+  Node parent;
+  RunnableBody(this.body, this.returnContinuation);
+  accept(Visitor visitor) => visitor.visitRunnableBody(this);
+}
+
 /// A function definition, consisting of parameters and a body.  The parameters
 /// include a distinguished continuation parameter.
 class FunctionDefinition extends Node
-    implements InteriorNode, ExecutableDefinition {
+    implements ExecutableDefinition {
   final FunctionElement element;
-  final Continuation returnContinuation;
   /// Mixed list of [Parameter]s and [ClosureVariable]s.
   final List<Definition> parameters;
-  Expression body;
+  final RunnableBody body;
   final List<ConstDeclaration> localConstants;
 
   /// Values for optional parameters.
   final List<ConstantExpression> defaultParameterValues;
 
   /// Closure variables declared by this function.
   final List<ClosureVariable> closureVariables;
 
-  FunctionDefinition(this.element, this.returnContinuation,
-      this.parameters, this.body, this.localConstants,
-      this.defaultParameterValues, this.closureVariables);
+  FunctionDefinition(this.element,
+      this.parameters,
+      this.body,
+      this.localConstants,
+      this.defaultParameterValues,
+      this.closureVariables);
 
   FunctionDefinition.abstract(this.element,
                               this.parameters,
                               this.defaultParameterValues)
-      : this.returnContinuation = null,
-        this.localConstants = const <ConstDeclaration>[],
-        this.closureVariables = const <ClosureVariable>[];
+      : body = null,
+        localConstants = const <ConstDeclaration>[],
+        closureVariables = const <ClosureVariable>[];
 
   accept(Visitor visitor) => visitor.visitFunctionDefinition(this);
   applyPass(Pass pass) => pass.rewriteFunctionDefinition(this);
 
   /// Returns `true` if this function is abstract or external.
   ///
   /// If `true`, [body] and [returnContinuation] are `null` and [localConstants]
   /// is empty.
   bool get isAbstract => body == null;
 }
 
+abstract class Initializer extends Node {}
+
+class FieldInitializer implements Initializer {
+  final FieldElement element;
+  final RunnableBody body;
+  Node parent;
+
+  FieldInitializer(this.element, this.body);
+  accept(Visitor visitor) => visitor.visitFieldInitializer(this);
+}
+
+class SuperInitializer implements Initializer {
+  final ConstructorElement target;
+  final List<RunnableBody> arguments;
+  final Selector selector;
+  Node parent;
+  SuperInitializer(this.target, this.arguments, this.selector);
+  accept(Visitor visitor) => visitor.visitSuperInitializer(this);
+}
+
+class ConstructorDefinition extends FunctionDefinition {
+  final List<Initializer> initializers;
+
+  ConstructorDefinition(ConstructorElement element,
+                        List<Definition> parameters,
+                        RunnableBody body,
+                        this.initializers,
+                        List<ConstDeclaration> localConstants,
+                        List<ConstantExpression> defaultParameterValues,
+                        List<ClosureVariable> closureVariables)
+      : super(element, parameters, body, localConstants,
+              defaultParameterValues, closureVariables);
+
+  // 'Abstract' here means "has no body" and is used to represent external
+  // constructors.
+  ConstructorDefinition.abstract(
+      ConstructorElement element,
+      List<Parameter> parameters,
+      List<ConstantExpression> defaultParameterValues)
+      : initializers = null,
+        super.abstract(element, parameters, defaultParameterValues);
+
+  accept(Visitor visitor) => visitor.visitConstructorDefinition(this);
+  applyPass(Pass pass) => pass.rewriteConstructorDefinition(this);
+}
+
 List<Reference<Primitive>> _referenceList(Iterable<Primitive> definitions) {
   return definitions.map((e) => new Reference<Primitive>(e)).toList();
 }
 
 abstract class Visitor<T> {
   const Visitor();
 
   T visit(Node node) => node.accept(this);
   // Abstract classes.
   T visitNode(Node node) => null;
   T visitExpression(Expression node) => visitNode(node);
   T visitDefinition(Definition node) => visitNode(node);
   T visitPrimitive(Primitive node) => visitDefinition(node);
   T visitCondition(Condition node) => visitNode(node);
+  T visitRunnableBody(RunnableBody node) => visitNode(node);
 
   // Concrete classes.
   T visitFieldDefinition(FieldDefinition node) => visitNode(node);
   T visitFunctionDefinition(FunctionDefinition node) => visitNode(node);
+  T visitConstructorDefinition(ConstructorDefinition node) {
+    return visitFunctionDefinition(node);
+  }
+
+  // Initializers
+  T visitInitializer(Initializer node) => visitNode(node);
+  T visitFieldInitializer(FieldInitializer node) => visitInitializer(node);
+  T visitSuperInitializer(SuperInitializer node) => visitInitializer(node);
 
   // Expressions.
   T visitLetPrim(LetPrim node) => visitExpression(node);
   T visitLetCont(LetCont node) => visitExpression(node);
   T visitInvokeStatic(InvokeStatic node) => visitExpression(node);
   T visitInvokeContinuation(InvokeContinuation node) => visitExpression(node);
   T visitInvokeMethod(InvokeMethod node) => visitExpression(node);
   T visitInvokeSuperMethod(InvokeSuperMethod node) => visitExpression(node);
   T visitInvokeConstructor(InvokeConstructor node) => visitExpression(node);
   T visitConcatenateStrings(ConcatenateStrings node) => visitExpression(node);
@@ skipping 24 matching lines @@
 /// Recursively visits the entire CPS term, and calls abstract `process*`
 /// (i.e. `processLetPrim`) functions in pre-order.
 abstract class RecursiveVisitor extends Visitor {
   const RecursiveVisitor();
 
   // Ensures that RecursiveVisitor contains overrides for all relevant nodes.
   // As a rule of thumb, nodes with structure to traverse should be overridden
   // with the appropriate visits in this class (for example, visitLetCont),
   // while leaving other nodes for subclasses (i.e., visitLiteralList).
   visitNode(Node node) {
-    throw "RecursiveVisitor is stale, add missing visit overrides";
+    throw "$this is stale, add missing visit override for $node";
   }
 
   processReference(Reference ref) {}
 
+  processRunnableBody(RunnableBody node) {}
+  visitRunnableBody(RunnableBody node) {
+    processRunnableBody(node);
+    visit(node.body);
+  }
+
   processFieldDefinition(FieldDefinition node) {}
   visitFieldDefinition(FieldDefinition node) {
     processFieldDefinition(node);
     if (node.hasInitializer) {
       visit(node.body);
     }
   }
 
   processFunctionDefinition(FunctionDefinition node) {}
   visitFunctionDefinition(FunctionDefinition node) {
     processFunctionDefinition(node);
     node.parameters.forEach(visit);
     if (!node.isAbstract) {
       visit(node.body);
     }
   }
 
+  processConstructorDefinition(ConstructorDefinition node) {}
+  visitConstructorDefinition(ConstructorDefinition node) {
+    processConstructorDefinition(node);
+    node.parameters.forEach(visit);
+    node.initializers.forEach(visit);
+    visit(node.body);
+  }
+
+  processFieldInitializer(FieldInitializer node) {}
+  visitFieldInitializer(FieldInitializer node) {
+    processFieldInitializer(node);
+    visit(node.body.body);
+  }
+
+  processSuperInitializer(SuperInitializer node) {}
+  visitSuperInitializer(SuperInitializer node) {
+    processSuperInitializer(node);
+    node.arguments.forEach(
+        (RunnableBody argument) => visit(argument.body));
+  }
+
   // Expressions.
 
   processLetPrim(LetPrim node) {}
   visitLetPrim(LetPrim node) {
     processLetPrim(node);
     visit(node.primitive);
     visit(node.body);
   }
 
   processLetCont(LetCont node) {}
@@ skipping 201 matching lines @@
   void visitReference(Reference reference) {
     allocate(reference.definition);
   }
 
   void visitFieldDefinition(FieldDefinition node) {
     if (node.hasInitializer) {
       visit(node.body);
     }
   }
 
+  void visitRunnableBody(RunnableBody node) {
+    visit(node.body);
+  }
+
   void visitFunctionDefinition(FunctionDefinition node) {
     if (!node.isAbstract) {
       visit(node.body);
     }
     // Assign indices to unused parameters.
     for (Definition param in node.parameters) {
       if (param is Primitive) {
         allocate(param);
       }
     }
   }
 
+  void visitConstructorDefinition(ConstructorDefinition node) {
+    if (!node.isAbstract) {
+      node.initializers.forEach(visit);
+      visit(node.body);
+    }
+    // Assign indices to unused parameters.
+    for (Definition param in node.parameters) {
+      if (param is Primitive) {
+        allocate(param);
+      }
+    }
+  }
+
+  void visitFieldInitializer(FieldInitializer node) {
+    visit(node.body.body);
+  }
+
+  void visitSuperInitializer(SuperInitializer node) {
+    node.arguments.forEach((RunnableBody argument) => visit(argument.body));
+  }
+
   void visitLetPrim(LetPrim node) {
     visit(node.body);
     release(node.primitive);
     visit(node.primitive);
   }
 
   void visitLetCont(LetCont node) {
     visit(node.continuation);
     visit(node.body);
   }
@@ skipping 88 matching lines @@
   }
 
   // JavaScript specific nodes.
 
   void visitIdentical(Identical node) {
     visitReference(node.left);
     visitReference(node.right);
   }
 }