Generate throw statements at statement level

pkg/compiler/lib/src/ssa/builder_kernel.dart

 // Copyright (c) 2016, 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.
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../closure.dart';
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/names.dart';
@@ skipping 39 matching lines @@
   SsaKernelBuilderTask(JavaScriptBackend backend, this.sourceInformationFactory)
       : backend = backend,
         super(backend.compiler.measurer);
 
   HGraph build(CodegenWorkItem work) {
     return measure(() {
       AstElement element = work.element.implementation;
       Kernel kernel = backend.kernelTask.kernel;
       KernelSsaBuilder builder = new KernelSsaBuilder(element, work.resolvedAst,
           backend.compiler, work.registry, sourceInformationFactory, kernel);
-      return builder.build();
+      HGraph graph = builder.build();
+
+      if (backend.compiler.tracer.isEnabled) {
+        String name;
+        if (element.isClassMember) {
+          String className = element.enclosingClass.name;
+          String memberName = element.name;
+          name = "$className.$memberName";
+          if (element.isGenerativeConstructorBody) {
+            name = "$name (body)";
+          }
+        } else {
+          name = "${element.name}";
+        }
+        backend.compiler.tracer.traceCompilation(name);
+        backend.compiler.tracer.traceGraph('builder', graph);
+      }
+
+      return graph;
     });
   }
 }
 
 class KernelSsaBuilder extends ir.Visitor with GraphBuilder {
   ir.Node target;
   final AstElement targetElement;
   final ResolvedAst resolvedAst;
   final CodegenRegistry registry;
 
@@ skipping 10 matching lines @@
   // TODO(karlklose): consider removing this and keeping the (substituted) types
   // of the type variables in an environment (like the [LocalsHandler]).
   final List<DartType> currentImplicitInstantiations = <DartType>[];
 
   @override
   JavaScriptBackend get backend => compiler.backend;
 
   @override
   TreeElements get elements => resolvedAst.elements;
 
-
   SourceInformationBuilder sourceInformationBuilder;
   KernelAstAdapter astAdapter;
   LoopHandler<ir.Node> loopHandler;
   TypeBuilder typeBuilder;
 
   final Map<ir.VariableDeclaration, HInstruction> letBindings =
       <ir.VariableDeclaration, HInstruction>{};
 
+  /// True if we are visiting the expression of a throw statement; we assume
+  /// this is a slow path.
+  bool _inExpressionOfThrow = false;
+
   KernelSsaBuilder(
       this.targetElement,
       this.resolvedAst,
       Compiler compiler,
       this.registry,
       SourceInformationStrategy sourceInformationFactory,
       Kernel kernel) {
     this.compiler = compiler;
     this.loopHandler = new KernelLoopHandler(this);
     typeBuilder = new TypeBuilder(this);
@@ skipping 336 matching lines @@
     }
     assert(!current.isClosed());
     if (stack.isNotEmpty) {
       compiler.reporter
           .internalError(NO_LOCATION_SPANNABLE, 'Non-empty instruction stack');
     }
   }
 
   @override
   void visitExpressionStatement(ir.ExpressionStatement exprStatement) {
-    exprStatement.expression.accept(this);
-    pop();
+    if (!isReachable) return;
+    ir.Expression expression = exprStatement.expression;
+    if (expression is ir.Throw) {
+      // TODO(sra): Prevent generating a statement when inlining.
+      _visitThrowExpression(expression.expression);
+      closeAndGotoExit(new HThrow(pop(), null));
+    } else {
+      expression.accept(this);
+      pop();
+    }
   }
 
   @override
   void visitReturnStatement(ir.ReturnStatement returnStatement) {
     HInstruction value;
     if (returnStatement.expression == null) {
       value = graph.addConstantNull(compiler);
     } else {
       assert(_targetFunction != null && _targetFunction is ir.FunctionNode);
       returnStatement.expression.accept(this);
-      value = typeBuilder.potentiallyCheckOrTrustType(pop(),
-          astAdapter.getFunctionReturnType(_targetFunction));
+      value = typeBuilder.potentiallyCheckOrTrustType(
+          pop(), astAdapter.getFunctionReturnType(_targetFunction));
     }
     // TODO(het): Add source information
     // TODO(het): Set a return value instead of closing the function when we
     // support inlining.
     closeAndGotoExit(new HReturn(value, null));
   }
 
   @override
   void visitForStatement(ir.ForStatement forStatement) {
     assert(isReachable);
@@ skipping 1209 matching lines @@
     // TODO(efortuna): Add source information here.
     push(new HCreate(closureClassElement, capturedVariables, type));
 
     registry?.registerInstantiatedClosure(methodElement);
   }
 
   @override
   visitFunctionDeclaration(ir.FunctionDeclaration declaration) {
     assert(isReachable);
     declaration.function.accept(this);
-    LocalFunctionElement localFunction = astAdapter.getElement(
-        declaration.function);
+    LocalFunctionElement localFunction =
+        astAdapter.getElement(declaration.function);
     localsHandler.updateLocal(localFunction, pop());
   }
 
   @override
   void visitFunctionExpression(ir.FunctionExpression funcExpression) {
     funcExpression.function.accept(this);
   }
 
   // TODO(het): Decide when to inline
   @override
@@ skipping 136 matching lines @@
     }
 
     // The interceptor is not always needed.  It is removed by optimization
     // when the receiver type or tested type permit.
     HInterceptor interceptor = _interceptorFor(expression);
     push(new HIs.raw(type, expression, interceptor, backend.boolType));
   }
 
   @override
   void visitThrow(ir.Throw throwNode) {
-    throwNode.expression.accept(this);
-    HInstruction expression = pop();
+    _visitThrowExpression(throwNode.expression);
     if (isReachable) {
-      push(new HThrowExpression(expression, null));
+      push(new HThrowExpression(pop(), null));
       isReachable = false;
     }
   }
 
+  void _visitThrowExpression(ir.Expression expression) {
+    bool old = _inExpressionOfThrow;
+    try {
+      _inExpressionOfThrow = true;
+      expression.accept(this);
+    } finally {
+      _inExpressionOfThrow = old;
+    }
+  }
+
   @override
   void visitThisExpression(ir.ThisExpression thisExpression) {
     stack.add(localsHandler.readThis());
   }
 
   @override
   void visitNot(ir.Not not) {
     not.operand.accept(this);
     push(new HNot(popBoolified(), backend.boolType));
   }
 
   @override
   void visitStringConcatenation(ir.StringConcatenation stringConcat) {
     KernelStringBuilder stringBuilder = new KernelStringBuilder(this);
     stringConcat.accept(stringBuilder);
     stack.add(stringBuilder.result);
   }
 }