Create a Tree IR builder for JavaScript specific nodes.

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;
 import '../util/util.dart' show CURRENT_ELEMENT_SPANNABLE;
 import 'tree_ir_nodes.dart';
-import '../js_backend/codegen/glue.dart';
 
 /**
  * Builder translates from CPS-based IR to direct-style Tree.
  *
  * A call `Invoke(fun, cont, args)`, where cont is a singly-referenced
  * non-exit continuation `Cont(v, body)` is translated into a direct-style call
  * whose value is bound in the continuation body:
  *
  * `LetVal(v, Invoke(fun, args), body)`
  *
@@ skipping 15 matching lines @@
  * 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> {
   final dart2js.InternalErrorFunction internalError;
-  final Element identicalFunction;
-  final Glue glue;
 
   /// Maps variable/parameter elements to the Tree variables that represent it.
   final Map<Element, List<Variable>> element2variables =
       <Element,List<Variable>>{};
 
   /// Like [element2variables], except for closure variables.
   final Map<cps_ir.ClosureVariable, Variable> local2closure =
       <cps_ir.ClosureVariable, Variable>{};
 
   // Continuations with more than one use are replaced with Tree labels.  This
   // is the mapping from continuations to labels.
   final Map<cps_ir.Continuation, Label> labels = <cps_ir.Continuation, Label>{};
 
   ExecutableElement currentElement;
   cps_ir.Continuation returnContinuation;
 
   Builder parent;
 
-  Builder(this.glue, this.internalError, this.identicalFunction);
+  Builder(this.internalError, [this.parent]);
 
-  Builder.inner(Builder parent)
-      : this.parent = parent,
-        this.glue = parent.glue,
-        this.internalError = parent.internalError,
-            this.identicalFunction = parent.identicalFunction;
+  Builder createInnerBuilder() {
+    return new Builder(internalError, this);
+  }
 
   /// Variable used in [buildPhiAssignments] as a temporary when swapping
   /// variables.
   Variable phiTempVar;
 
   Variable getClosureVariable(cps_ir.ClosureVariable irVariable) {
     if (irVariable.host != currentElement) {
       return parent.getClosureVariable(irVariable);
     }
     return local2closure.putIfAbsent(irVariable,
@@ skipping 25 matching lines @@
           CURRENT_ELEMENT_SPANNABLE,
           "Reference to ${reference.definition} has no register");
     }
     ++variable.readCount;
     return variable;
   }
 
   ExecutableDefinition build(cps_ir.ExecutableDefinition node) {
     if (node is cps_ir.FieldDefinition) {
       return buildField(node);
-    } else if (node is cps_ir.FunctionDefinition) {
+    } else {
+      assert(dart2js.invariant(
+          currentElement,
+          node is cps_ir.FunctionDefinition,
+          message: 'expected FunctionDefinition or FieldDefinition, '
+            ' found $node'));
       return buildFunction(node);
     }
-    assert(false);
   }
 
   FieldDefinition buildField(cps_ir.FieldDefinition node) {
     Statement body;
     if (node.hasInitializer) {
       currentElement = node.element;
       returnContinuation = node.returnContinuation;
 
       phiTempVar = new Variable(node.element, null);
 
@@ skipping 134 matching lines @@
     }
 
     if (first == null) {
       first = buildRest();
     } else {
       current.next = buildRest();
     }
     return first;
   }
 
-  visitNode(cps_ir.Node node) => throw "Unhandled node: $node";
+  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";
+    }
+  }
 
   Statement visitLetPrim(cps_ir.LetPrim node) {
     Variable variable = getVariable(node.primitive);
 
     // Don't translate unused primitives.
     if (variable == null) return visit(node.body);
 
     Node definition = visit(node.primitive);
 
     // visitPrimitive returns a Statement without successor if it cannot occur
@@ skipping 171 matching lines @@
         node.type,
         new List<LiteralMapEntry>.generate(node.entries.length, (int index) {
           return new LiteralMapEntry(
               getVariableReference(node.entries[index].key),
               getVariableReference(node.entries[index].value));
         })
     );
   }
 
   FunctionDefinition makeSubFunction(cps_ir.FunctionDefinition function) {
-    return new Builder.inner(this).buildFunction(function);
+    return createInnerBuilder().buildFunction(function);
   }
 
   Node visitCreateFunction(cps_ir.CreateFunction node) {
     FunctionDefinition def = makeSubFunction(node.definition);
     FunctionType type = node.definition.element.type;
     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);
@@ skipping 12 matching lines @@
   Expression 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;
   }
 
   Expression visitIsTrue(cps_ir.IsTrue node) {
     return getVariableReference(node.value);
   }
-
-  dart2js.Selector get identicalSelector {
-    return new dart2js.Selector.call('identical', null, 2);
-  }
-
-  Expression visitIdentical(cps_ir.Identical node) {
-    return new InvokeStatic(
-        identicalFunction,
-        identicalSelector,
-        <Expression>[getVariableReference(node.left),
-                     getVariableReference(node.right)]);
-  }
-
-  Expression visitInterceptor(cps_ir.Interceptor node) {
-    Element getInterceptor = glue.getInterceptorMethod;
-    glue.registerUseInterceptorInCodegen();
-    return new InvokeStatic(
-        getInterceptor,
-        new dart2js.Selector.fromElement(getInterceptor),
-        <Expression>[getVariableReference(node.input)]);
-  }
 }