CPS implementation of throw and rethrow.

pkg/compiler/lib/src/dart_backend/backend_ast_emitter.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 backend_ast_emitter;
 
 import '../tree_ir/tree_ir_nodes.dart' as tree;
 import 'backend_ast_nodes.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart';
@@ skipping 326 matching lines @@
       }
 
       List<Statement> bodyParts = [];
       if (constants.length > 0) {
         bodyParts.add(new VariableDeclarations(constants, isConst: true));
       }
       if (context.variables.length > 0) {
         bodyParts.add(new VariableDeclarations(context.variables));
       }
       bodyParts.addAll(context.statements);
-
       body = new Block(bodyParts);
-
     }
-    FunctionType functionType = context.currentElement.type;
-
     return new ConstructorDefinition(
         parameters,
         body,
         initializers,
-        context.currentElement.name, definition.element.isConst)
-        ..element = context.currentElement;
+        context.currentElement.name,
+        definition.element.isConst)..element = context.currentElement;
   }
 
   @override
   FunctionExpression visitFunctionDefinition(
         tree.FunctionDefinition definition,
         BuilderContext<Statement> context) {
     context.currentElement = definition.element;
 
     Parameters parameters = emitRootParameters(
         definition, definition.defaultParameterValues, context);
@@ skipping 188 matching lines @@
       context.declaredVariables.add(assign.variable);
 
       visitStatement(statement.next, context);
       return;
     }
 
     Expression definition = visitExpression(assign.value, context);
     bool isFirstOccurrence = (context.variableNames[assign.variable] == null);
     bool isDeclaredHere = assign.variable.host == context.currentElement;
     bool isFirstStatement = context.firstStatement == statement;
-    String name = context.getVariableName(assign.variable);
 
     // Try to pull into initializer.
     if (isFirstStatement && isFirstOccurrence && isDeclaredHere) {
       if (isNullLiteral(definition)) definition = null;
       context.addDeclaration(assign.variable, definition);
       context.firstStatement = statement.next;
       visitStatement(statement.next, context);
       return;
     }
 
     context.addStatement(new ExpressionStatement(makeAssignment(
         context.makeVariableAccess(assign.variable),
         definition)));
     visitStatement(statement.next, context);
   }
 
   @override
-  void visitReturn(tree.Return stmt,
-                   BuilderContext<Statement> context) {
+  void visitReturn(tree.Return stmt, BuilderContext<Statement> context) {
     if (context.currentElement.isGenerativeConstructor &&
         !context.inInitializer) {
       assert(() {
         tree.Expression value = stmt.value;
         return value is tree.Constant && value.value.isNull;
       });
       context.addStatement(new Return(null));
     } else {
       Expression inner = visitExpression(stmt.value, context);
       context.addStatement(new Return(inner));
     }
   }
 
   @override
-  void visitBreak(tree.Break stmt,
-                  BuilderContext<Statement> context) {
+  void visitThrow(tree.Throw stmt, BuilderContext<Statement> context) {
+    Expression value = visitExpression(stmt.value, context);
+    context.addStatement(new ExpressionStatement(new Throw(value)));
+  }
+
+  @override
+  void visitRethrow(tree.Rethrow stmt, BuilderContext<Statement> context) {
+    context.addStatement(new Rethrow());
+  }
+
+  @override
+  void visitBreak(tree.Break stmt, BuilderContext<Statement> context) {
     tree.Statement fall = context.fallthrough;
     if (stmt.target.binding.next == fall) {
       // Fall through to break target
     } else if (fall is tree.Break && fall.target == stmt.target) {
       // Fall through to equivalent break
     } else {
       context.useLabel(stmt.target);
       context.addStatement(new Break(stmt.target.name));
     }
   }
@@ skipping 736 matching lines @@
       : super(name, ElementKind.VARIABLE, enclosingElement, variables, null);
 
   ExecutableElement get executableContext => enclosingElement;
 
   ExecutableElement get memberContext => executableContext.memberContext;
 
   bool get isLocal => true;
 
   LibraryElement get implementationLibrary => enclosingElement.library;
 }