Streamline the CPS IR Visitor interface.

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;
 import '../cps_ir/optimizers.dart';
 import '../dart_types.dart' show DartType, GenericType;
-import '../dart2jslib.dart' as dart2js show invariant;
+import '../dart2jslib.dart' as dart2js show
+    CURRENT_ELEMENT_SPANNABLE,
+    InternalErrorFunction,
+    invariant;
 import '../elements/elements.dart';
 import '../io/source_information.dart' show SourceInformation;
 import '../universe/universe.dart' show Selector, SelectorKind;
 
 abstract class Node {
   /// A pointer to the parent node. Is null until set by optimization passes.
   Node parent;
 
   accept(Visitor visitor);
 }
@@ skipping 841 matching lines @@
   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);
+  T visit(Node node);
 
   // Concrete classes.
-  T visitFieldDefinition(FieldDefinition node) => visitNode(node);
-  T visitFunctionDefinition(FunctionDefinition node) => visitNode(node);
-  T visitConstructorDefinition(ConstructorDefinition node) {
-    return visitFunctionDefinition(node);
-  }
+  T visitFieldDefinition(FieldDefinition node);
+  T visitFunctionDefinition(FunctionDefinition node);
+  T visitConstructorDefinition(ConstructorDefinition node);
+  T visitRunnableBody(RunnableBody node);
 
   // Initializers
-  T visitInitializer(Initializer node) => visitNode(node);
-  T visitFieldInitializer(FieldInitializer node) => visitInitializer(node);
-  T visitSuperInitializer(SuperInitializer node) => visitInitializer(node);
+  T visitFieldInitializer(FieldInitializer node);
+  T visitSuperInitializer(SuperInitializer node);
 
   // Expressions.
-  T visitLetPrim(LetPrim node) => visitExpression(node);
-  T visitLetCont(LetCont node) => visitExpression(node);
-  T visitLetHandler(LetHandler node) => visitExpression(node);
-  T visitLetMutable(LetMutable node) => visitExpression(node);
-  T visitInvokeStatic(InvokeStatic node) => visitExpression(node);
-  T visitInvokeContinuation(InvokeContinuation node) => visitExpression(node);
-  T visitInvokeMethod(InvokeMethod node) => visitExpression(node);
-  T visitInvokeMethodDirectly(InvokeMethodDirectly node) => visitExpression(node);
-  T visitInvokeConstructor(InvokeConstructor node) => visitExpression(node);
-  T visitConcatenateStrings(ConcatenateStrings node) => visitExpression(node);
-  T visitBranch(Branch node) => visitExpression(node);
-  T visitTypeOperator(TypeOperator node) => visitExpression(node);
-  T visitSetMutableVariable(SetMutableVariable node) => visitExpression(node);
-  T visitDeclareFunction(DeclareFunction node) => visitExpression(node);
-  T visitSetField(SetField node) => visitExpression(node);
+  T visitLetPrim(LetPrim node);
+  T visitLetCont(LetCont node);
+  T visitLetHandler(LetHandler node);
+  T visitLetMutable(LetMutable node);
+  T visitInvokeContinuation(InvokeContinuation node);
+  T visitInvokeStatic(InvokeStatic node);
+  T visitInvokeMethod(InvokeMethod node);
+  T visitInvokeMethodDirectly(InvokeMethodDirectly node);
+  T visitInvokeConstructor(InvokeConstructor node);
+  T visitConcatenateStrings(ConcatenateStrings node);
+  T visitBranch(Branch node);
+  T visitTypeOperator(TypeOperator node);
+  T visitSetMutableVariable(SetMutableVariable node);
+  T visitDeclareFunction(DeclareFunction node);
 
   // Definitions.
-  T visitLiteralList(LiteralList node) => visitPrimitive(node);
-  T visitLiteralMap(LiteralMap node) => visitPrimitive(node);
-  T visitConstant(Constant node) => visitPrimitive(node);
-  T visitThis(This node) => visitPrimitive(node);
-  T visitReifyTypeVar(ReifyTypeVar node) => visitPrimitive(node);
-  T visitCreateFunction(CreateFunction node) => visitPrimitive(node);
-  T visitGetMutableVariable(GetMutableVariable node) => visitPrimitive(node);
-  T visitParameter(Parameter node) => visitPrimitive(node);
-  T visitContinuation(Continuation node) => visitDefinition(node);
-  T visitMutableVariable(MutableVariable node) => visitDefinition(node);
-  T visitGetField(GetField node) => visitDefinition(node);
-  T visitCreateBox(CreateBox node) => visitDefinition(node);
-  T visitCreateInstance(CreateInstance node) => visitDefinition(node);
+  T visitLiteralList(LiteralList node);
+  T visitLiteralMap(LiteralMap node);
+  T visitConstant(Constant node);
+  T visitThis(This node);
+  T visitReifyTypeVar(ReifyTypeVar node);
+  T visitCreateFunction(CreateFunction node);
+  T visitGetMutableVariable(GetMutableVariable node);
+  T visitParameter(Parameter node);
+  T visitContinuation(Continuation node);
+  T visitMutableVariable(MutableVariable node);
 
   // Conditions.
-  T visitIsTrue(IsTrue node) => visitCondition(node);
+  T visitIsTrue(IsTrue node);
 
   // JavaScript specific nodes.
-  T visitIdentical(Identical node) => visitPrimitive(node);
-  T visitInterceptor(Interceptor node) => visitPrimitive(node);
+  // Expressions.
+  T visitSetField(SetField node);
+  // Definitions.
+  T visitIdentical(Identical node);
+  T visitInterceptor(Interceptor node);
+  T visitCreateInstance(CreateInstance node);
+  T visitGetField(GetField node);
+  T visitCreateBox(CreateBox node);
 }
 
 /// Recursively visits the entire CPS term, and calls abstract `process*`
 /// (i.e. `processLetPrim`) functions in pre-order.
-abstract class RecursiveVisitor extends Visitor {
+class RecursiveVisitor implements 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 "$this is stale, add missing visit override for $node";
-  }
+  visit(Node node) => node.accept(this);
 
   processReference(Reference ref) {}
 
   processRunnableBody(RunnableBody node) {}
   visitRunnableBody(RunnableBody node) {
     processRunnableBody(node);
     visit(node.returnContinuation);
     visit(node.body);
   }
 
@@ skipping 18 matching lines @@
   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);
+    visit(node.body);
   }
 
   processSuperInitializer(SuperInitializer node) {}
   visitSuperInitializer(SuperInitializer node) {
     processSuperInitializer(node);
-    node.arguments.forEach(
-        (RunnableBody argument) => visit(argument.body));
+    node.arguments.forEach(visit);
   }
 
   // Expressions.
 
   processLetPrim(LetPrim node) {}
   visitLetPrim(LetPrim node) {
     processLetPrim(node);
     visit(node.primitive);
     visit(node.body);
   }
@@ skipping 128 matching lines @@
   }
 
   processMutableVariable(node) {}
   visitMutableVariable(MutableVariable node) {
     processMutableVariable(node);
   }
 
   processGetMutableVariable(GetMutableVariable node) {}
   visitGetMutableVariable(GetMutableVariable node) {
     processGetMutableVariable(node);
+    processReference(node.variable);
   }
 
   processParameter(Parameter node) {}
   visitParameter(Parameter node) => processParameter(node);
 
   processContinuation(Continuation node) {}
   visitContinuation(Continuation node) {
     processContinuation(node);
     node.parameters.forEach(visitParameter);
     if (node.body != null) visit(node.body);
@@ skipping 65 matching lines @@
     freeStack.add(index);
   }
 }
 
 /// Assigns indices to each primitive in the IR such that primitives that are
 /// live simultaneously never get assigned the same index.
 /// This information is used by the dart tree builder to generate fewer
 /// redundant variables.
 /// Currently, the liveness analysis is very simple and is often inadequate
 /// for removing all of the redundant variables.
-class RegisterAllocator extends Visitor {
+class RegisterAllocator implements Visitor {
+  final dart2js.InternalErrorFunction internalError;
+
   /// Separate register spaces for each source-level variable/parameter.
   /// Note that null is used as key for primitives without hints.
   final Map<Local, RegisterArray> elementRegisters = <Local, RegisterArray>{};
 
+  RegisterAllocator(this.internalError);
+
   RegisterArray getRegisterArray(Local local) {
     RegisterArray registers = elementRegisters[local];
     if (registers == null) {
       registers = new RegisterArray();
       elementRegisters[local] = registers;
     }
     return registers;
   }
 
   void allocate(Primitive primitive) {
     if (primitive.registerIndex == null) {
       primitive.registerIndex = getRegisterArray(primitive.hint).makeIndex();
     }
   }
 
   void release(Primitive primitive) {
     // Do not share indices for temporaries as this may obstruct inlining.
     if (primitive.hint == null) return;
     if (primitive.registerIndex != null) {
       getRegisterArray(primitive.hint).releaseIndex(primitive.registerIndex);
     }
   }
 
+  void visit(Node node) => node.accept(this);
+
   void visitReference(Reference reference) {
     allocate(reference.definition);
   }
 
   void visitFieldDefinition(FieldDefinition node) {
     if (node.hasInitializer) {
       visit(node.body);
     }
   }
 
@@ skipping 114 matching lines @@
   void visitConstant(Constant node) {
   }
 
   void visitThis(This node) {
   }
 
   void visitReifyTypeVar(ReifyTypeVar node) {
   }
 
   void visitCreateFunction(CreateFunction node) {
-    new RegisterAllocator().visit(node.definition);
+    new RegisterAllocator(internalError).visit(node.definition);
   }
 
   void visitGetMutableVariable(GetMutableVariable node) {
   }
 
   void visitSetMutableVariable(SetMutableVariable node) {
     visit(node.body);
     visitReference(node.value);
   }
 
   void visitDeclareFunction(DeclareFunction node) {
-    new RegisterAllocator().visit(node.definition);
+    new RegisterAllocator(internalError).visit(node.definition);
     visit(node.body);
   }
 
   void visitParameter(Parameter node) {
-    throw "Parameters should not be visited by RegisterAllocator";
+    // Parameters are handled differently depending on whether they are
+    // function parameters, continuation parameters, exception handler
+    // parameters, etc.  Thus we do not call visitParameter directly and
+    // handle them explicitly in their parent IR node.
+    internalError(dart2js.CURRENT_ELEMENT_SPANNABLE,
+                  'tried to allocate a parameter');
   }
 
+  void visitMutableVariable(MutableVariable node) {}
+
   void visitContinuation(Continuation node) {
     visit(node.body);
 
     // Arguments get allocated left-to-right, so we release parameters
     // right-to-left. This increases the likelihood that arguments can be
     // transferred without intermediate assignments.
     for (int i = node.parameters.length - 1; i >= 0; --i) {
       release(node.parameters[i]);
     }
   }
@@ skipping 23 matching lines @@
 
   void visitIdentical(Identical node) {
     visitReference(node.left);
     visitReference(node.right);
   }
 
   void visitInterceptor(Interceptor node) {
     visitReference(node.input);
   }
 }