dart2dart: Implementation of simple try/catch.

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/expressions.dart';
 import '../constants/values.dart' show PrimitiveConstantValue;
 import '../dart_types.dart';
 import '../dart2jslib.dart';
@@ skipping 190 matching lines @@
   IrBuilderDelimitedState(this.constantSystem, this.currentElement);
 }
 
 /// A factory for building the cps IR.
 ///
 /// [DartIrBuilder] and [JsIrBuilder] implement nested functions and captured
 /// variables in different ways.
 abstract class IrBuilder {
   IrBuilder _makeInstance();
 
+  /// A map from TryStatements in the AST to their analysis information.
+  ///
+  /// This include which variables should be copied into [ir.MutableVariable]s

[floitsch, 2015/02/16 14:54:07]

includes

[Kevin Millikin (Google), 2015/02/24 11:59:24]

Done.

+  /// on entry to the try and copied out on exit.
+  Map<ast.TryStatement, TryStatementInfo> get tryStatements;

[asgerf, 2015/02/20 10:10:07]

I thought the IR builder was supposed to be independent of the AST so
analyzer2dart could reuse it.

I suspect this will be moved to the IR builder visitor when analyzer2dart wants
to support try.

Just an FYI.

[Kevin Millikin (Google), 2015/02/24 11:59:24]

Acknowledged.

+
+  /// The set of local variables that will spend their lifetime as
+  /// [ir.MutableVariable]s due to being captured by a nested function.
+  Set<Local> get mutableCapturedVariables;
+
+  /// True if [local] should currently be accessed from a [ir.MutableVariable].
+  bool isInMutableVariable(Local local);
+
+  /// Creates a [ir.MutableVariable] for the given local.
+  void makeMutableVariable(Local local);
+
+  /// Remove an [ir.MutableVariable] for a local.
+  ///
+  /// Subsequent access to the local will be direct rather than through the
+  /// mutable variable.  This is used for variables that do not spend their
+  /// entire lifetime as mutable variables (e.g., variables that are boxed
+  /// in mutable variables for a try block).
+  void removeMutableVariable(Local local);
+
   void declareLocalVariable(LocalVariableElement element,
                             {ir.Primitive initialValue});
   ir.Primitive buildLocalGet(LocalElement element);
   ir.Primitive buildLocalSet(LocalElement element, ir.Primitive value);
 
   /// Called when entering a nested function with free variables.
   ///
   /// The free variables must subsequently be accessible using [buildLocalGet]
   /// and [buildLocalSet].
   void _enterClosureEnvironment(ClosureEnvironment env);
@@ skipping 1290 matching lines @@
     return join;
   }
 }
 
 /// Shared state between DartIrBuilders within the same method.
 class DartIrBuilderSharedState {
   /// Maps local variables to their corresponding [MutableVariable] object.
   final Map<Local, ir.MutableVariable> local2mutable =
       <Local, ir.MutableVariable>{};
 
-  final DartCapturedVariableInfo capturedVariables;
+  final DartCapturedVariables capturedVariables;
 
   /// Creates a [MutableVariable] for the given local.
   void makeMutableVariable(Local local) {
     ir.MutableVariable variable =
         new ir.MutableVariable(local.executableContext, local);
     local2mutable[local] = variable;
   }
 
   /// [MutableVariable]s that should temporarily be treated as registers.
   final Set<Local> registerizedMutableVariables = new Set<Local>();
@@ skipping 11 matching lines @@
 /// Captured variables are translated to ref cells (see [MutableVariable])
 /// using [GetMutableVariable] and [SetMutableVariable].
 class DartIrBuilder extends IrBuilder {
   final DartIrBuilderSharedState dartState;
 
   IrBuilder _makeInstance() => new DartIrBuilder._blank(dartState);
   DartIrBuilder._blank(this.dartState);
 
   DartIrBuilder(ConstantSystem constantSystem,
                 ExecutableElement currentElement,
-                DartCapturedVariableInfo capturedVariables)
+                DartCapturedVariables capturedVariables)
       : dartState = new DartIrBuilderSharedState(capturedVariables) {
     _init(constantSystem, currentElement);
   }
 
-  /// True if [local] should currently be accessed from a [MutableVariable].
+  Map<ast.TryStatement, TryStatementInfo> get tryStatements {
+    return dartState.capturedVariables.tryStatements;
+  }
+
+  Set<Local> get mutableCapturedVariables {
+    return dartState.capturedVariables.capturedVariables;
+  }
+
   bool isInMutableVariable(Local local) {
     return dartState.local2mutable.containsKey(local) &&
            !dartState.registerizedMutableVariables.contains(local);
   }
 
+  void makeMutableVariable(Local local) {
+    dartState.makeMutableVariable(local);
+  }
+
+  void removeMutableVariable(Local local) {
+    dartState.local2mutable.remove(local);
+  }
+
   /// Gets the [MutableVariable] containing the value of [local].
   ir.MutableVariable getMutableVariable(Local local) {
     return dartState.local2mutable[local];
   }
 
   void _enterScope(ClosureScope scope) {
     assert(scope == null);
   }
 
   void _enterClosureEnvironment(ClosureEnvironment env) {
@@ skipping 153 matching lines @@
   final JsIrBuilderSharedState jsState;
 
   IrBuilder _makeInstance() => new JsIrBuilder._blank(jsState);
   JsIrBuilder._blank(this.jsState);
 
   JsIrBuilder(ConstantSystem constantSystem, ExecutableElement currentElement)
       : jsState = new JsIrBuilderSharedState() {
     _init(constantSystem, currentElement);
   }
 
+  Map<ast.TryStatement, TryStatementInfo> get tryStatements => null;
+  Set<Local> get mutableCapturedVariables => null;
+  bool isInMutableVariable(Local local) => false;
+  void makeMutableVariable(Local local) {}
+  void removeMutableVariable(Local local) {}
+
   void _enterClosureEnvironment(ClosureEnvironment env) {
     if (env == null) return;
 
     // Obtain a reference to the function object (this).
     ir.Primitive thisPrim = new ir.This();
     add(new ir.LetPrim(thisPrim));
 
     // Obtain access to the free variables.
     env.freeVariables.forEach((Local local, ClosureLocation location) {
       if (location.isBox) {
@@ skipping 253 matching lines @@
   /// If non-null, [thisLocal] has an entry in [freeVariables] describing where
   /// to find the captured value of `this`.
   final ThisLocal thisLocal;
 
   /// Maps [LocalElement]s, [BoxLocal]s and [ThisLocal] to their location.
   final Map<Local, ClosureLocation> freeVariables;
 
   ClosureEnvironment(this.selfReference, this.thisLocal, this.freeVariables);
 }
 
-/// Information about which variables are captured by a nested function.
-///
-/// This is used by the [DartIrBuilder] instead of [ClosureScope] and
-/// [ClosureEnvironment].
-abstract class DartCapturedVariableInfo {
-  Iterable<Local> get capturedVariables;
+class TryStatementInfo {
+  final TryStatementInfo parent;
+  final List<TryStatementInfo> children = <TryStatementInfo>[];
+  final Set<LocalVariableElement> declared = new Set<LocalVariableElement>();
+  final Set<LocalVariableElement> boxedOnEntry =
+      new Set<LocalVariableElement>();
+
+  TryStatementInfo(this.parent) {
+    if (parent != null) parent.children.add(this);
+  }
+
+  void computeVariablesBoxedOnEntry(Set<LocalVariableElement> boxedInParent) {

[floitsch, 2015/02/16 14:54:07]

Comments.
At the very least mention that the argument is going to be modified (when?).

[Kevin Millikin (Google), 2015/02/24 11:59:24]

This whole approach is overly complicated.  I've changed it so instead of
building a nesting tree and traversing it afterward, we just maintain a nesting
stack during the analysis.

+    Set<LocalVariableElement> boxed =
+        new Set<LocalVariableElement>.from(boxedOnEntry);
+    if (boxedInParent != null) {
+      // Initially, variables are marked as boxed on entry if they are assigned
+      // in this try but not including variables assigned only in some nested

[floitsch, 2015/02/16 14:54:07]

I don't understand this comment.

+      // try.  However, these do not have to be boxed if they are boxed in the
+      // immediately enclosing try.

[asgerf, 2015/02/20 10:10:07]

I would remove the word "However" here.

+      boxedOnEntry.removeAll(boxedInParent);
+      // Variables are boxed in this try if they are boxed in the immediately
+      // enclosing try or boxed on entry to this try.

[floitsch, 2015/02/16 14:54:07]

The boxed-on-entry happens earlier. It's slightly confusing if you mention it
here.

+      boxed.addAll(boxedInParent);
+    }
+    for (TryStatementInfo child in children) {
+      child.computeVariablesBoxedOnEntry(boxed);
+    }
+  }
 }