Streamline the CPS IR Visitor interface.

pkg/compiler/lib/src/tree_ir/tree_ir_builder.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_builder;
 
 import '../dart2jslib.dart' as dart2js;
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../cps_ir/cps_ir_nodes.dart' as cps_ir;
@@ skipping 25 matching lines @@
  * `LetLabel(L, v, body)`
  *
  * Block arguments are later replaced with data flow during the Tree-to-Tree
  * translation out of SSA.  Jumps are eliminated during the Tree-to-Tree
  * control-flow recognition.
  *
  * Otherwise, the output of Builder looks very much like the input.  In
  * particular, intermediate values and blocks used for local control flow are
  * still all named.
  */
-class Builder extends cps_ir.Visitor<Node> {
+class Builder implements cps_ir.Visitor<Node> {
   final dart2js.InternalErrorFunction internalError;
 
   /// Maps variable/parameter elements to the Tree variables that represent it.
   final Map<Local, List<Variable>> local2variables = <Local, List<Variable>>{};
 
   /// Like [local2variables], except for mutable variables.
   final Map<cps_ir.MutableVariable, Variable> local2mutable =
       <cps_ir.MutableVariable, Variable>{};
 
   // Continuations with more than one use are replaced with Tree labels.  This
@@ skipping 260 matching lines @@
     }
 
     if (first == null) {
       first = buildRest();
     } else {
       current.next = buildRest();
     }
     return first;
   }
 
-  visitNode(cps_ir.Node node) {
-    if (node is cps_ir.JsSpecificNode) {
-      throw "Cannot handle JS specific IR nodes in this visitor";
-    } else {
-      throw "Unhandled node: $node";
-    }
+  visit(cps_ir.Node node) => node.accept(this);
+
+  unexpectedNode(cps_ir.Node node) {
+    internalError(CURRENT_ELEMENT_SPANNABLE, 'Unexpected IR node: $node');
+  }
+
+  // JS-specific nodes are handled by a subclass.
+  visitSetField(cps_ir.SetField node) => unexpectedNode(node);
+  visitIdentical(cps_ir.Identical node) => unexpectedNode(node);
+  visitInterceptor(cps_ir.Interceptor node) => unexpectedNode(node);
+  visitCreateInstance(cps_ir.CreateInstance node) => unexpectedNode(node);
+  visitGetField(cps_ir.GetField node) => unexpectedNode(node);
+  visitCreateBox(cps_ir.CreateBox node) => unexpectedNode(node);
+
+  // Executable definitions are not visited directly.  They have 'build'
+  // functions as entry points.
+  visitFieldDefinition(cps_ir.FieldDefinition node) {
+    return unexpectedNode(node);
+  }
+  visitFunctionDefinition(cps_ir.FunctionDefinition node) {
+    return unexpectedNode(node);
+  }
+  visitConstructorDefinition(cps_ir.ConstructorDefinition node) {
+    return unexpectedNode(node);
   }
 
   Initializer visitFieldInitializer(cps_ir.FieldInitializer node) {
     returnContinuation = node.body.returnContinuation;
     return new FieldInitializer(node.element, visit(node.body.body));
   }
 
   Initializer visitSuperInitializer(cps_ir.SuperInitializer node) {
     List<Statement> arguments =
         node.arguments.map((cps_ir.RunnableBody argument) {
@@ skipping 245 matching lines @@
     bool hasReturnType = !type.returnType.treatAsDynamic;
     if (hasReturnType) {
       // This function cannot occur in expression context.
       // The successor will be filled in by visitLetPrim.
       return new FunctionDeclaration(getVariable(node), def, null);
     } else {
       return new FunctionExpression(def);
     }
   }
 
-  Expression visitParameter(cps_ir.Parameter node) {
+  visitParameter(cps_ir.Parameter node) {
     // Continuation parameters are not visited (continuations themselves are
     // not visited yet).
-    internalError(CURRENT_ELEMENT_SPANNABLE, 'Unexpected IR node: $node');
-    return null;
+    unexpectedNode(node);
   }
 
-  Expression visitContinuation(cps_ir.Continuation node) {
+  visitContinuation(cps_ir.Continuation node) {
     // Until continuations with multiple uses are supported, they are not
     // visited.
-    internalError(CURRENT_ELEMENT_SPANNABLE, 'Unexpected IR node: $node.');
-    return null;
+    unexpectedNode(node);
+  }
+
+  visitMutableVariable(cps_ir.MutableVariable node) {
+    // These occur as parameters or bound by LetMutable.  They are not visited
+    // directly.
+    unexpectedNode(node);
   }
 
   Expression visitIsTrue(cps_ir.IsTrue node) {
     return getVariableUse(node.value);
   }
 }