dart2js cps: Avoid deep recursion using trampolines and basic blocks.

pkg/compiler/lib/src/js_backend/codegen/unsugar.dart

 library dart2js.unsugar_cps;
 
 import '../../cps_ir/cps_ir_nodes.dart';
 
 import '../../cps_ir/optimizers.dart' show ParentVisitor;
 import '../../constants/expressions.dart';
 import '../../constants/values.dart';
 import '../../elements/elements.dart';
 import '../../js_backend/codegen/glue.dart';
 import '../../dart2jslib.dart' show Selector, World;
@@ skipping 64 matching lines @@
     // Set all parent pointers.
     _parentVisitor.visit(function);
 
     if (inInterceptedMethod) {
       explicitReceiverParameter.substituteFor(thisParameter);
     }
 
     visit(function);
   }
 
-  @override
-  visit(Node node) {
-    Node result = node.accept(this);
-    return result != null ? result : node;
-  }
-
   Constant get trueConstant {
     return new Constant(new TrueConstantValue());
   }
 
   Constant get falseConstant {
     return new Constant(new FalseConstantValue());
   }
 
   Constant get nullConstant {
     return new Constant(new NullConstantValue());
@@ skipping 68 matching lines @@
         new InvokeStatic(function, selector, arguments, continuation, null);
     _parentVisitor.processInvokeStatic(invoke);
 
     LetCont letCont = new LetCont(continuation, invoke);
     _parentVisitor.processLetCont(letCont);
 
     parent.body = letCont;
     letCont.parent = parent;
   }
 
-  processLetHandler(LetHandler node) {
+  @override
+  Expression traverseLetHandler(LetHandler node) {
+    assert(node.handler.parameters.length == 2);
+    Parameter previousExceptionParameter = _exceptionParameter;
+
     // BEFORE: Handlers have two parameters, exception and stack trace.
     // AFTER: Handlers have a single parameter, which is unwrapped to get
     // the exception and stack trace.
     _exceptionParameter = node.handler.parameters.first;
     Parameter stackTraceParameter = node.handler.parameters.last;
     Expression body = node.handler.body;
     if (_exceptionParameter.hasAtLeastOneUse ||
         stackTraceParameter.hasAtLeastOneUse) {
       Parameter exceptionValue = new Parameter(null);
       exceptionValue.substituteFor(_exceptionParameter);
       insertStaticCall(_glue.getExceptionUnwrapper(), [_exceptionParameter],
           exceptionValue, body);
 
       if (stackTraceParameter.hasAtLeastOneUse) {
         Parameter stackTraceValue = new Parameter(null);
         stackTraceValue.substituteFor(stackTraceParameter);
         insertStaticCall(_glue.getTraceFromException(), [_exceptionParameter],
             stackTraceValue, body);
       }
     }
 
     assert(stackTraceParameter.hasNoUses);
     node.handler.parameters.removeLast();
-  }
 
-  @override
-  visitLetHandler(LetHandler node) {
-    assert(node.handler.parameters.length == 2);
-    Parameter previousExceptionParameter = _exceptionParameter;
-    _exceptionParameter = node.handler.parameters.first;
-    processLetHandler(node);
     visit(node.handler);
     _exceptionParameter = previousExceptionParameter;
 
-    visit(node.body);
+    return node.body;
   }
 
   processThrow(Throw node) {
     // The subexpression of throw is wrapped in the JavaScript output.
     Parameter value = new Parameter(null);
     insertStaticCall(_glue.getWrapExceptionHelper(), [node.value.definition],
         value, node);
     node.value.unlink();
     node.value = new Reference<Primitive>(value);
   }
@@ skipping 12 matching lines @@
   /// Returns an interceptor for the given value, capable of responding to
   /// [selector].
   /// 
   /// A single getInterceptor call will be created per primitive, bound
   /// immediately after the primitive is bound.
   /// 
   /// The type propagation pass will later narrow the set of interceptors
   /// based on the input type, and the let sinking pass will propagate the
   /// getInterceptor call closer to its use when this is profitable.
   Interceptor getInterceptorFor(Primitive prim, Selector selector) {
+    assert(prim is! Interceptor);
     Interceptor interceptor = interceptors[prim];
     if (interceptor == null) {
       interceptor = new Interceptor(prim);
       interceptors[prim] = interceptor;
       InteriorNode parent = prim.parent;
       insertLetPrim(interceptor, parent.body);
       if (prim.hint != null) {
         interceptor.hint = new InterceptorEntity(prim.hint);
       }
     }
@@ skipping 53 matching lines @@
     condition.value.unlink();
     node.trueContinuation.unlink();
     node.falseContinuation.unlink();
     parent.body = newNode;
   }
 
   processInterceptor(Interceptor node) {
     _glue.registerSpecializedGetInterceptor(node.interceptedClasses);
   }
 }