CPS implementation of throw and rethrow.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.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.
 
 library dart2js.ir_builder_task;
 
 import '../closure.dart' as closurelib;
 import '../closure.dart' hide ClosureScope;
 import '../constants/expressions.dart';
 import '../dart_types.dart';
@@ skipping 348 matching lines @@
   // Build(EmptyStatement, C) = C
   ir.Primitive visitEmptyStatement(ast.EmptyStatement node) {
     assert(irBuilder.isOpen);
     return null;
   }
 
   // Build(ExpressionStatement(e), C) = C'
   //   where (C', _) = Build(e, C)
   ir.Primitive visitExpressionStatement(ast.ExpressionStatement node) {
     assert(irBuilder.isOpen);
-    visit(node.expression);
+    if (node.expression is ast.Throw) {
+      // Throw expressions that occur as statements are translated differently
+      // from ones that occur as subexpressions.  This is achieved by peeking
+      // at statement-level expressions here.
+      irBuilder.buildThrow(visit(node.expression));
+    } else {
+      visit(node.expression);
+    }
     return null;
   }
 
+  ir.Primitive visitRethrow(ast.Rethrow node) {
+    assert(irBuilder.isOpen);
+    irBuilder.buildRethrow();
+    return null;
+  }
+
   visitFor(ast.For node) {
     List<LocalElement> loopVariables = <LocalElement>[];
     if (node.initializer is ast.VariableDefinitions) {
       ast.VariableDefinitions definitions = node.initializer;
       for (ast.Node node in definitions.definitions.nodes) {
         LocalElement loopVariable = elements[node];
         loopVariables.add(loopVariable);
       }
     }
 
@@ skipping 104 matching lines @@
   ir.Primitive visitReturn(ast.Return node) {
     assert(irBuilder.isOpen);
     assert(invariant(node, node.beginToken.value != 'native'));
     irBuilder.buildReturn(build(node.expression));
     return null;
   }
 
   visitTryStatement(ast.TryStatement node) {
     // Multiple catch blocks are not yet implemented.
     if (node.catchBlocks.isEmpty ||
-        node.catchBlocks.nodes.tail == null) {
+        !node.catchBlocks.nodes.tail.isEmpty) {
       return giveup(node, 'not exactly one catch block');
     }
     // 'on T' catch blocks are not yet implemented.
     if ((node.catchBlocks.nodes.head as ast.CatchBlock).onKeyword != null) {
       return giveup(node, '"on T" catch block');
     }
     // Finally blocks are not yet implemented.
     if (node.finallyBlock != null) {
       return giveup(node, 'try/finally');
     }
@@ skipping 1246 matching lines @@
       arguments.add(visitLiteralString(part.string));
     }
     return irBuilder.buildStringConcatenation(arguments);
   }
 
   ir.Primitive translateConstant(ast.Node node) {
     assert(irBuilder.isOpen);
     return irBuilder.buildConstantLiteral(getConstantForNode(node));
   }
 
+  ir.Primitive visitThrow(ast.Throw node) {
+    assert(irBuilder.isOpen);
+    // This function is not called for throw expressions occurring as
+    // statements.
+    return irBuilder.buildNonTailThrow(visit(node.expression));
+  }
+
   ir.RootNode nullIfGiveup(ir.RootNode action()) {
     try {
       return action();
-    } catch(e, tr) {
+    } catch(e) {
       if (e == ABORT_IRNODE_BUILDER) {
         return null;
       }
       rethrow;
     }
   }
 
   void internalError(ast.Node node, String message) {
     giveup(node, message);
   }
@@ skipping 219 matching lines @@
     LocalFunctionElement element = elements[node.function];
     Object inner = makeSubFunction(node.function);
     irBuilder.declareLocalFunction(element, inner);
   }
 
   ClosureScope getClosureScopeForNode(ast.Node node) => null;
   ClosureEnvironment getClosureEnvironment() => null;
 
   ir.RootNode buildExecutable(ExecutableElement element) {
     return nullIfGiveup(() {
+      ir.RootNode root;
       if (element is FieldElement) {
-        return buildField(element);
+        root = buildField(element);
       } else if (element is FunctionElement || element is ConstructorElement) {
-        return buildFunction(element);
+        root = buildFunction(element);
       } else {
         compiler.internalError(element, "Unexpected element type $element");
       }
+      new CleanupPass().visit(root);
+      return root;
     });
   }
 
   /// Returns a [ir.FieldDefinition] describing the initializer of [element].
   ir.FieldDefinition buildField(FieldElement element) {
     assert(invariant(element, element.isImplementation));
     ast.VariableDefinitions definitions = element.node;
     ast.Node fieldDefinition = definitions.definitions.nodes.first;
     if (definitions.modifiers.isConst) {
       // TODO(sigurdm): Just return const value.
@@ skipping 193 matching lines @@
             elements);
     closurelib.ClosureScope scope = map.capturingScopes[function.node];
     if (scope == null) return null;
     return new ClosureScope(scope.boxElement,
                             mapValues(scope.capturedVariables, getLocation),
                             scope.boxedLoopVariables);
   }
 
   ir.RootNode buildExecutable(ExecutableElement element) {
     return nullIfGiveup(() {
+      ir.RootNode root;
       switch (element.kind) {
         case ElementKind.GENERATIVE_CONSTRUCTOR:
-          return buildConstructor(element);
+          root = buildConstructor(element);
+          break;
 
         case ElementKind.GENERATIVE_CONSTRUCTOR_BODY:
-          return buildConstructorBody(element);
+          root = buildConstructorBody(element);
+          break;
 
         case ElementKind.FUNCTION:
         case ElementKind.GETTER:
         case ElementKind.SETTER:
-          return buildFunction(element);
+          root = buildFunction(element);
+          break;
 
         default:
           compiler.internalError(element, "Unexpected element type $element");
       }
+      new CleanupPass().visit(root);
+      return root;
     });
   }
 
   /// Builds the IR for an [expression] taken from a different [context].
   ///
   /// Such expressions need to be compiled with a different [sourceFile] and
   /// [elements] mapping.
   ir.Primitive inlineExpression(AstElement context, ast.Expression expression) {
     JsIrBuilderVisitor visitor = new JsIrBuilderVisitor(
         context.resolvedAst.elements,
@@ skipping 513 matching lines @@
   SourceInformation buildCall(ast.Node node) {
     return new PositionSourceInformation(
         new TokenSourceLocation(sourceFile, node.getBeginToken(), name));
   }
 
   @override
   SourceInformationBuilder forContext(AstElement element) {
     return new PositionSourceInformationBuilder(element);
   }
 }
+
+/// Perform simple post-processing on the initial CPS-translated root term.
+///
+/// This pass performs backend-independent post-processing on the translated
+/// term.  It is implemented separately from the optimization passes because
+/// it is required for correctness of the implementation.
+///
+/// It performs the following translations:
+///   - Replace [ir.LetPrim] binding a [ir.NonTailThrow] with a [ir.Throw]
+///     expression.
+class CleanupPass extends ir.RecursiveVisitor {
+  RemovalVisitor _remover = new RemovalVisitor();
+
+  ir.Expression replacementFor(ir.Expression expression) {
+    if (expression != null && expression is ir.LetPrim) {
+      ir.Primitive primitive = expression.primitive;
+      if (primitive is ir.NonTailThrow) {
+        _remover.visit(expression);
+        return new ir.Throw(primitive.value.definition);
+      }
+    }
+    return expression;
+  }
+
+  processLetPrim(ir.LetPrim node) {
+    node.body = replacementFor(node.body);
+  }
+
+  processLetCont(ir.LetCont node) {
+    node.body = replacementFor(node.body);
+  }
+
+  processLetHandler(ir.LetHandler node) {
+    node.body = replacementFor(node.body);
+  }
+
+  processLetMutable(ir.LetMutable node) {
+    node.body = replacementFor(node.body);
+  }
+
+  processSetMutableVariable(ir.SetMutableVariable node) {
+    node.body = replacementFor(node.body);
+  }
+
+  processDeclareFunction(ir.DeclareFunction node) {
+    node.body = replacementFor(node.body);
+  }
+
+  processSetField(ir.SetField node) {
+    node.body = replacementFor(node.body);
+  }
+
+  processContinuation(ir.Continuation node) {
+    node.body = replacementFor(node.body);
+  }
+
+  processBody(ir.Body node) {
+    node.body = replacementFor(node.body);
+  }
+}
+
+/// Visit a just-deleted subterm and unlink all [Reference]s in it.
+class RemovalVisitor extends ir.RecursiveVisitor {
+  processReference(ir.Reference reference) {
+    reference.unlink();
+  }
+}
+