Support 'on T' catch clauses and multiple clauses.

pkg/compiler/lib/src/cps_ir/cps_ir_builder.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;
 
 import '../constants/constant_system.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart' show PrimitiveConstantValue;
 import '../dart_types.dart';
@@ skipping 1768 matching lines @@
     IrBuilder catchBuilder = tryCatchBuilder.makeDelimitedBuilder();
     for (LocalVariableElement variable in tryStatementInfo.boxedOnEntry) {
       assert(catchBuilder.isInMutableVariable(variable));
       ir.Primitive value = catchBuilder.buildLocalVariableGet(variable);
       // After this point, the variables that were boxed on entry to the try
       // are no longer treated as mutable.
       catchBuilder.removeMutableVariable(variable);
       catchBuilder.environment.update(variable, value);
     }
 
-    // TODO(kmillikin): Handle multiple catch clauses.
-    assert(catchClauseInfos.length == 1);
-    for (CatchClauseInfo catchClauseInfo in catchClauseInfos) {
-      LocalVariableElement exceptionVariable =
-          catchClauseInfo.exceptionVariable;
-      ir.Parameter exceptionParameter = new ir.Parameter(exceptionVariable);
-      catchBuilder.declareLocalVariable(exceptionVariable,
-                                        initialValue: exceptionParameter);
-      ir.Parameter traceParameter;
-      LocalVariableElement stackTraceVariable =
-          catchClauseInfo.stackTraceVariable;
-      if (stackTraceVariable != null) {
-        traceParameter = new ir.Parameter(stackTraceVariable);
-        catchBuilder.declareLocalVariable(stackTraceVariable,
-                                          initialValue: traceParameter);
-      } else {
-        // Use a dummy continuation parameter for the stack trace parameter.
-        // This will ensure that all handlers have two parameters and so they
-        // can be treated uniformly.
-        traceParameter = new ir.Parameter(null);
+    // Handlers are always translated as having both exception and stack trace
+    // parameters.  Multiple clauses do not have to use the same names for
+    // them.  Choose the first of each as the name hint for the respective
+    // handler parameter.
+    ir.Parameter exceptionParameter =
+        new ir.Parameter(catchClauseInfos.first.exceptionVariable);
+    LocalVariableElement traceVariable;
+    CatchClauseInfo catchAll;
+    for (int i = 0; i < catchClauseInfos.length; ++i) {
+      CatchClauseInfo info = catchClauseInfos[i];
+      if (info.type == null) {
+        catchAll = info;
+        catchClauseInfos.length = i;
+        break;
       }
-      catchClauseInfo.buildCatchBlock(catchBuilder);
-      if (catchBuilder.isOpen) catchBuilder.jumpTo(join);
-      List<ir.Parameter> catchParameters =
-          <ir.Parameter>[exceptionParameter, traceParameter];
-      ir.Continuation catchContinuation = new ir.Continuation(catchParameters);
-      catchContinuation.body = catchBuilder._root;
+      if (traceVariable == null) {
+        traceVariable = info.stackTraceVariable;
+      }
+    }
+    ir.Parameter traceParameter = new ir.Parameter(traceVariable);
+    // Expand multiple catch clauses into an explicit if/then/else.  Iterate
+    // them in reverse so the current block becomes the next else block.
+    ir.Expression catchBody;
+    if (catchAll == null) {
+      catchBody = new ir.Rethrow();
+    } else {
+      IrBuilder clauseBuilder = catchBuilder.makeDelimitedBuilder();

[Kevin Millikin (Google), 2015/05/05 10:29:12]

I'm going to move the next seven or eight lines into a named helper, because
they're duplicated inside the loop too.

+      clauseBuilder.declareLocalVariable(catchAll.exceptionVariable,
+                                         initialValue: exceptionParameter);
+      if (catchAll.stackTraceVariable != null) {
+        clauseBuilder.declareLocalVariable(catchAll.stackTraceVariable,
+                                           initialValue: traceParameter);
+      }
+      catchAll.buildCatchBlock(clauseBuilder);
+      if (clauseBuilder.isOpen) clauseBuilder.jumpTo(join);
+      catchBody = clauseBuilder._root;
+    }
+    for (CatchClauseInfo clause in catchClauseInfos.reversed) {
+      IrBuilder clauseBuilder = catchBuilder.makeDelimitedBuilder();
+      clauseBuilder.declareLocalVariable(clause.exceptionVariable,
+                                         initialValue: exceptionParameter);
+      if (clause.stackTraceVariable != null) {
+        clauseBuilder.declareLocalVariable(clause.stackTraceVariable,
+                                           initialValue: traceParameter);
+      }
+      clause.buildCatchBlock(clauseBuilder);
+      if (clauseBuilder.isOpen) clauseBuilder.jumpTo(join);
+      ir.Continuation thenContinuation = new ir.Continuation([]);
+      thenContinuation.body = clauseBuilder._root;
+      ir.Continuation elseContinuation = new ir.Continuation([]);
+      elseContinuation.body = catchBody;
 
-      tryCatchBuilder.add(
-          new ir.LetHandler(catchContinuation, tryBuilder._root));
-      tryCatchBuilder._current = null;
+      ir.Parameter typeMatches = new ir.Parameter(null);
+      ir.Continuation checkType = new ir.Continuation([typeMatches]);
+      checkType.body =
+          new ir.LetCont.many([thenContinuation, elseContinuation],
+              new ir.Branch(new ir.IsTrue(typeMatches),
+                            thenContinuation,
+                            elseContinuation));
+      catchBody =
+          new ir.LetCont(checkType,
+              new ir.TypeOperator(exceptionParameter, clause.type, checkType,
+                                  isTypeTest: true));
     }
 
+    List<ir.Parameter> catchParameters =
+        <ir.Parameter>[exceptionParameter, traceParameter];
+    ir.Continuation catchContinuation = new ir.Continuation(catchParameters);
+    catchContinuation.body = catchBody;
+
+    tryCatchBuilder.add(
+        new ir.LetHandler(catchContinuation, tryBuilder._root));
     add(new ir.LetCont(join.continuation, tryCatchBuilder._root));
     environment = join.environment;
   }
 
   /// Create a return statement `return value;` or `return;` if [value] is
   /// null.
   void buildReturn([ir.Primitive value]) {
     // Build(Return(e), C) = C'[InvokeContinuation(return, x)]
     //   where (C', x) = Build(e, C)
     //
@@ skipping 809 matching lines @@
 
   ClosureEnvironment(this.selfReference, this.thisLocal, this.freeVariables);
 }
 
 class TryStatementInfo {
   final Set<LocalVariableElement> declared = new Set<LocalVariableElement>();
   final Set<LocalVariableElement> boxedOnEntry =
       new Set<LocalVariableElement>();
 }
 
-// TODO(johnniwinther): Support passing of [DartType] for the exception.
 class CatchClauseInfo {
+  final DartType type;
   final LocalVariableElement exceptionVariable;
   final LocalVariableElement stackTraceVariable;
   final SubbuildFunction buildCatchBlock;
 
-  CatchClauseInfo({this.exceptionVariable,
+  CatchClauseInfo({this.type,
+                   this.exceptionVariable,
                    this.stackTraceVariable,
                    this.buildCatchBlock});
 }
 
 /// Synthetic parameter to a JavaScript factory method that takes the type
 /// argument given for the type variable [variable].
 class TypeInformationParameter implements Local {
   final TypeVariableElement variable;
   final ExecutableElement executableContext;
   TypeInformationParameter(this.variable, this.executableContext);
   String get name => variable.name;
 }