dart2js: Smaller async error sequence when only one handler

pkg/compiler/lib/src/js/rewrite_async.dart

 // Copyright (c) 2015, 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 rewrite_async;
 
 import 'dart:collection';
 import 'dart:math' show max;
 
 import 'package:js_runtime/shared/async_await_error_codes.dart' as error_codes;
@@ skipping 109 matching lines @@
   ///
   /// To "goto" a label, the label is assigned to this variable, and break out
   /// of the switch to take another iteration in the while loop. See [addGoto]
   js.VariableUse get goto => new js.VariableUse(gotoName);
   String gotoName;
 
   /// Variable containing the label of the current error handler.
   js.VariableUse get handler => new js.VariableUse(handlerName);
   String handlerName;
 
+  /// Set to `true` if any of the switch statement labels is a handler.
+  bool hasHandlerLabels = false;
+
   /// A stack of labels of finally blocks to visit, and the label to go to after
   /// the last.
   js.VariableUse get next => new js.VariableUse(nextName);
   String nextName;
 
   /// The current returned value (a finally block may overwrite it).
   js.VariableUse get returnValue => new js.VariableUse(returnValueName);
   String returnValueName;
 
   /// Stores the current error when we are in the process of handling an error.
@@ skipping 538 matching lines @@
     }).toList();
     js.Statement rewrittenBody = new js.Switch(goto, clauses);
     if (hasJumpThoughOuterLabel) {
       rewrittenBody = new js.LabeledStatement(outerLabelName, rewrittenBody);
     }
     rewrittenBody = js.js.statement('while (true) {#}', rewrittenBody);
     List<js.VariableInitialization> variables = <js.VariableInitialization>[];
 
     variables.add(_makeVariableInitializer(goto, js.number(0)));
     variables.addAll(variableInitializations());
-    variables.add(_makeVariableInitializer(handler, js.number(rethrowLabel)));
-    variables.add(_makeVariableInitializer(currentError, null));
+    if (hasHandlerLabels) {
+      variables.add(_makeVariableInitializer(handler, js.number(rethrowLabel)));
+      variables.add(_makeVariableInitializer(currentError, null));
+    }
     if (analysis.hasFinally || (isAsyncStar && analysis.hasYield)) {
       variables.add(_makeVariableInitializer(
           next, new js.ArrayInitializer(<js.Expression>[])));
     }
     if (analysis.hasThis && !isSyncStar) {
       // Sync* functions must remember `this` on the level of the outer
       // function.
       variables.add(_makeVariableInitializer(self, js.js('this')));
     }
     variables.addAll(localVariables.map((js.VariableDeclaration declaration) {
@@ skipping 705 matching lines @@
 
   @override
   void visitThrow(js.Throw node) {
     withExpression(node.expression, (js.Expression expression) {
       addStatement(new js.Throw(expression)
           .withSourceInformation(node.sourceInformation));
     }, store: false);
   }
 
   setErrorHandler([int errorHandler]) {
+    hasHandlerLabels = true;
     js.Expression label =
         (errorHandler == null) ? currentErrorHandler : js.number(errorHandler);
     addStatement(js.js.statement('# = #;', [handler, label]));
   }
 
   List<int> _finalliesUpToAndEnclosingHandler() {
     List<int> result = <int>[];
     for (int i = jumpTargets.length - 1; i >= 0; i--) {
       js.Node node = jumpTargets[i];
       int handlerLabel = handlerLabels[node];
@@ skipping 276 matching lines @@
       String safeVariableName(String proposedName),
       js.Name bodyName})
       : super(reporter, spannable, safeVariableName, bodyName);
 
   @override
   void addYield(js.DartYield node, js.Expression expression) {
     reporter.internalError(spannable, "Yield in non-generating async function");
   }
 
   void addErrorExit() {
+    if (!hasHandlerLabels) return;
     beginLabel(rethrowLabel);
     addStatement(js.js.statement(
         "return #thenHelper(#currentError, #completer);", {
       "thenHelper": asyncRethrow,
       "currentError": currentError,
       "completer": completer
     }));
   }
 
   /// Returning from an async method calls [asyncStarHelper] with the result.
@@ skipping 49 matching lines @@
       List<js.Parameter> parameters,
       js.Statement rewrittenBody,
       js.VariableDeclarationList variableDeclarations,
       SourceInformation sourceInformation) {
     return js.js(
         """
         function (#parameters) {
           #variableDeclarations;
           var #bodyName = #wrapBody(function (#errorCode, #result) {
             if (#errorCode === #ERROR) {
-                #currentError = #result;
-                #goto = #handler;
+              if (#hasHandlerLabels) {
+                  #currentError = #result;
+                  #goto = #handler;
+              } else
+                  return #asyncRethrow(#result, #completer);
             }
             #rewrittenBody;
           });
           return #asyncStart(#bodyName, #completer);
         }""",
         {
           "parameters": parameters,
           "variableDeclarations": variableDeclarations,
           "ERROR": js.number(error_codes.ERROR),
           "rewrittenBody": rewrittenBody,
           "bodyName": bodyName,
           "currentError": currentError,
           "goto": goto,
           "handler": handler,
           "errorCode": errorCodeName,
           "result": resultName,
           "asyncStart": asyncStart,
+          "asyncRethrow": asyncRethrow,
+          "hasHandlerLabels": hasHandlerLabels,
           "completer": completer,
           "wrapBody": wrapBody,
         }).withSourceInformation(sourceInformation);
   }
 }
 
 class SyncStarRewriter extends AsyncRewriterBase {
   bool get isSyncStar => true;
 
   /// Constructor creating the Iterable for a sync* method. Called with
@@ skipping 91 matching lines @@
           "self": selfName,
           "result": resultName,
           "goto": goto,
           "handler": handler,
           "currentError": currentErrorName,
           "ERROR": js.number(error_codes.ERROR),
         }).withSourceInformation(sourceInformation);
   }
 
   void addErrorExit() {
+    hasHandlerLabels = true;

[floitsch, 2017/05/04 08:52:05]

This is too confusing, but I'm guessing this is just temporary.

Would you make a virtual function for the actual statement?

[sra1, 2017/05/05 21:52:34]

I added a field comment and a TODO comment here to help with that
The statement could be different at this point and in the no-handler case. It
takes different variables as inputs.

     beginLabel(rethrowLabel);
     addStatement(js.js
         .statement('return #(#);', [uncaughtErrorExpression, currentError]));
   }
 
   /// Returning from a sync* function returns an [endOfIteration] marker.
   void addSuccesExit() {
     if (analysis.hasExplicitReturns) {
       beginLabel(exitLabel);
     } else {
@@ skipping 164 matching lines @@
           "errorCode": errorCodeName,
           "result": resultName,
           "streamOfController": streamOfController,
           "controller": controllerName,
           "wrapBody": wrapBody,
         }).withSourceInformation(sourceInformation);
   }
 
   @override
   void addErrorExit() {
+    hasHandlerLabels = true;

[floitsch, 2017/05/04 08:52:05]

ditto.

     beginLabel(rethrowLabel);
     addStatement(js.js.statement(
         "return #asyncHelper(#currentError, #errorCode, #controller);", {
       "asyncHelper": asyncStarHelper,
       "errorCode": js.number(error_codes.ERROR),
       "currentError": currentError,
       "controller": controllerName
     }));
   }
 
@@ skipping 491 matching lines @@
     return condition || body;
   }
 
   @override
   bool visitDartYield(js.DartYield node) {
     hasYield = true;
     visit(node.expression);
     return true;
   }
 }