Remove dart2jslib.dart

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 '../diagnostics/invariant.dart' show
+    InternalErrorFunction;
+import '../diagnostics/spannable.dart' show
+    CURRENT_ELEMENT_SPANNABLE;
 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';
 
 typedef Statement NodeCallback(Statement next);
 
 /**
  * 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:
@@ skipping 17 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 implements cps_ir.Visitor/*<NodeCallback|Node>*/ {
-  final dart2js.InternalErrorFunction internalError;
+  final InternalErrorFunction internalError;
 
   final Map<cps_ir.Primitive, Variable> primitive2variable =
       <cps_ir.Primitive, Variable>{};
   final Map<cps_ir.MutableVariable, Variable> mutable2variable =
       <cps_ir.MutableVariable, 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>{};
 
@@ skipping 182 matching lines @@
       first = buildRest();
     } else {
       current.next = buildRest();
     }
     return first;
   }
 
   visit(cps_ir.Node node) => throw 'Use translateXXX instead of visit';
 
   /// Translates a CPS expression into a tree statement.
-  /// 
+  ///
   /// To avoid deep recursion, we traverse each basic blocks without
   /// recursion.
-  /// 
+  ///
   /// Non-tail expressions evaluate to a callback to be invoked once the
   /// successor statement has been constructed. These callbacks are stored
   /// in a stack until the block's tail expression has been translated.
   Statement translateExpression(cps_ir.Expression node) {
     List<NodeCallback> stack = <NodeCallback>[];
     while (node is! cps_ir.TailExpression) {
       stack.add(node.accept(this));
       node = node.next;
     }
     Statement result = node.accept(this); // Translate the tail expression.
     for (NodeCallback fun in stack.reversed) {
       result = fun(result);
     }
     return result;
   }
 
   /// Translates a CPS primitive to a tree expression.
-  /// 
+  ///
   /// This simply calls the visit method for the primitive.
   Expression translatePrimitive(cps_ir.Primitive prim) {
     return prim.accept(this);
   }
 
   /// Translates a condition to a tree expression.
   Expression translateCondition(cps_ir.Condition condition) {
     cps_ir.IsTrue isTrue = condition;
     return getVariableUse(isTrue.value);
   }
@@ skipping 31 matching lines @@
     for (cps_ir.Continuation continuation in node.continuations) {
       // This happens after the body of the LetCont has been translated.
       // Labels are created on-demand if the continuation could not be inlined,
       // so the existence of the label indicates if a labeled statement should
       // be emitted.
       Label label = labels[continuation];
       if (label != null && !continuation.isRecursive) {
         // Recursively build the body. We only do this for join continuations,
         // so we should not risk overly deep recursion.
         next = new LabeledStatement(
-            label, 
-            next, 
+            label,
+            next,
             translateExpression(continuation.body));
       }
     }
     return next;
   };
 
   NodeCallback visitLetHandler(cps_ir.LetHandler node) => (Statement next) {
     List<Variable> catchParameters =
         node.handler.parameters.map(getVariable).toList();
     Statement catchBody = translateExpression(node.handler.body);
@@ skipping 144 matching lines @@
             //       inline at the invocation site.
             //     - If there are multiple uses, translate to Break.
             //   * Recursive continuations
             //     - There is a single non-recursive invocation.  Translate
             //       the continuation body inline as a labeled loop at the
             //       invocation site.
             //     - Translate the recursive invocations to Continue.
             if (cont.isRecursive) {
               return node.isRecursive
                   ? new Continue(getLabel(cont))
-                  : new WhileTrue(getLabel(cont), 
+                  : new WhileTrue(getLabel(cont),
                                   translateExpression(cont.body));
             } else {
               return cont.hasExactlyOneUse && !node.isEscapingTry
                   ? translateExpression(cont.body)
                   : new Break(getLabel(cont));
             }
           });
     }
   }
 
   Statement visitBranch(cps_ir.Branch node) {
     Expression condition = translateCondition(node.condition);
     Statement thenStatement, elseStatement;
     cps_ir.Continuation cont = node.trueContinuation.definition;
     assert(cont.parameters.isEmpty);
-    thenStatement = cont.hasExactlyOneUse 
-        ? translateExpression(cont.body) 
+    thenStatement = cont.hasExactlyOneUse
+        ? translateExpression(cont.body)
         : new Break(labels[cont]);
     cont = node.falseContinuation.definition;
     assert(cont.parameters.isEmpty);
-    elseStatement = cont.hasExactlyOneUse 
-        ? translateExpression(cont.body) 
+    elseStatement = cont.hasExactlyOneUse
+        ? translateExpression(cont.body)
         : new Break(labels[cont]);
     return new If(condition, thenStatement, elseStatement);
   }
 
 
   /************************** PRIMITIVES  **************************/
-  // 
+  //
   // Visit methods for primitives must return an expression.
   //
 
   Expression visitSetField(cps_ir.SetField node) {
     return new SetField(getVariableUse(node.object),
                         node.field,
                         getVariableUse(node.value));
   }
-  
+
   Expression visitInterceptor(cps_ir.Interceptor node) {
-    return new Interceptor(getVariableUse(node.input), 
+    return new Interceptor(getVariableUse(node.input),
                            node.interceptedClasses,
                            node.sourceInformation);
   }
 
   Expression visitCreateInstance(cps_ir.CreateInstance node) {
     return new CreateInstance(
         node.classElement,
         translateArguments(node.arguments),
         translateArguments(node.typeInformation),
         node.sourceInformation);
@@ skipping 126 matching lines @@
 
   visitFunctionDefinition(cps_ir.FunctionDefinition node) {
     unexpectedNode(node);
   }
   visitParameter(cps_ir.Parameter node) => unexpectedNode(node);
   visitContinuation(cps_ir.Continuation node) => unexpectedNode(node);
   visitMutableVariable(cps_ir.MutableVariable node) => unexpectedNode(node);
   visitIsTrue(cps_ir.IsTrue node) => unexpectedNode(node);
 }