fixes #516, nested cascade code generation

lib/src/compiler/js_metalet.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.
 
 // TODO(jmesserly): import from its own package
 import '../js_ast/js_ast.dart';
 import '../js_ast/precedence.dart';
 
 import 'js_names.dart' show TemporaryId;
 
@@ skipping 18 matching lines @@
 ///
 class MetaLet extends Expression {
   /// Creates a temporary to contain the value of [expr]. The temporary can be
   /// used multiple times in the resulting expression. For example:
   /// `expr ** 2` could be compiled as `expr * expr`. The temporary scope will
   /// ensure `expr` is only evaluated once: `(x => x * x)(expr)`.
   ///
   /// If the expression does not end up using `x` more than once, or if those
   /// expressions can be treated as [stateless] (e.g. they are non-mutated
   /// variables), then the resulting code will be simplified automatically.
-  final Map<String, Expression> variables;
+  final Map<MetaLetVariable, Expression> variables;
 
   /// A list of expressions in the body.
   /// The last value should represent the returned value.
   final List<Expression> body;
 
   /// True if the final expression in [body] can be skipped in [toStatement].
   final bool statelessResult;
 
   /// We run [toExpression] implicitly when the JS AST is visited, to get the
   /// transformation to happen before the tree is printed.
@@ skipping 114 matching lines @@
       return new Call(new ArrowFun([], block), []);
     }
     // If we have a yield, it's more tricky. We'll create a `function*`, which
     // we `yield*` to immediately invoke. We also may need to bind this:
     Expression fn = new Fun([], block, isGenerator: true);
     if (finder.hasThis) fn = js.call('#.bind(this)', fn);
     return new Yield(new Call(fn, []), star: true);
   }
 
   Block _finishStatement(List<Statement> statements) {
-    var params = <TemporaryId>[];
-    var values = <Expression>[];
-    var block = _build(params, values, new Block(statements));
-    if (params.isEmpty) return block;
-
-    var vars = [];
-    for (int i = 0; i < params.length; i++) {
-      vars.add(new VariableInitialization(params[i], values[i]));
-    }
-
-    return new Block(<Statement>[
-      new VariableDeclarationList('let', vars).toStatement(),
-      block
-    ]);
-  }
-
-  Node _build(List<TemporaryId> params, List<Expression> values, Node node) {
     // Visit the tree and count how many times each temp was used.
     var counter = new _VariableUseCounter();
+    var node = new Block(statements);
     node.accept(counter);
     // Also count the init expressions.
     for (var init in variables.values) init.accept(counter);
 
-    var substitutions = {};
-    _substitute(node) => new Template(null, node).safeCreate(substitutions);
-
-    variables.forEach((name, init) {
+    var initializers = <VariableInitialization>[];
+    var substitutions = <MetaLetVariable, Expression>{};
+    variables.forEach((variable, init) {
       // Since this is let*, subsequent variables can refer to previous ones,
       // so we need to substitute here.
-      init = _substitute(init);
-      int n = counter.counts[name];
-      if (n == null || n < 2) {
-        substitutions[name] = _substitute(init);
+      init = _substitute(init, substitutions);
+      int n = counter.counts[variable];
+      if (n == 1) {
+        // Replace interpolated exprs with their value, if it only occurs once.
+        substitutions[variable] = init;
       } else {
-        params.add(substitutions[name] = new TemporaryId(name));
-        values.add(init);
+        // Otherwise replace it with a temp, which will be assigned once.
+        var temp = new TemporaryId(variable.displayName);
+        substitutions[variable] = temp;
+        initializers.add(new VariableInitialization(temp, init));
       }
     });
 
-    // Interpolate the body:
-    // Replace interpolated exprs with their value, if it only occurs once.
-    // Otherwise replace it with a temp, which will be assigned once.
-    return _substitute(node);
+    // Interpolate the body.
+    node = _substitute(node, substitutions);
+    if (initializers.isNotEmpty) {
+      node = new Block([
+        new VariableDeclarationList('let', initializers).toStatement(),
+        node
+      ]);
+    }
+    return node;
   }
 
   /// If we finish with an assignment to an identifier, try to simplify the
   /// block. For example:
   ///
   ///     ((_) => _.add(1), _.add(2), result = _)([])
   ///
   /// Can be transformed to:
   ///
   ///     (result = [], result.add(1), result.add(2), result)
   ///
   /// However we should not simplify in this case because `result` is read:
   ///
   ///     ((_) => _.addAll(result), _.add(2), result = _)([])
   ///
   MetaLet _simplifyAssignment(Identifier left, {bool isDeclaration: false}) {
     // See if the result value is a let* temporary variable.
-    if (body.last is! InterpolatedExpression) return null;
+    if (body.last is! MetaLetVariable) return null;
 
-    InterpolatedExpression last = body.last;
-    String name = last.nameOrPosition;
-    if (!variables.containsKey(name)) return null;
+    MetaLetVariable result = body.last;
+    if (!variables.containsKey(result)) return null;
 
     // Variables declared can't be used inside their initializer, so make
     // sure we don't transform an assignment into an initializer.
     // If this already was a declaration, then we know it's legal, so we can
     // skip the check.
     if (!isDeclaration) {
       var finder = new _IdentFinder(left.name);
       for (var expr in body) {
         if (finder.found) break;
         expr.accept(finder);
       }
       // If the identifier was used elsewhere, bail, because we're going to
       // change the order of when the assignment happens.
       if (finder.found) return null;
     }
 
-    var vars = new Map<String, Expression>.from(variables);
-    var value = vars.remove(name);
+    var vars = new Map<MetaLetVariable, Expression>.from(variables);
+    var value = vars.remove(result);
     Expression assign;
     if (isDeclaration) {
       // Technically, putting one of these in a comma expression is not
       // legal. However when isDeclaration is true, toStatement will be
       // called immediately on the MetaLet, which results in legal JS.
       assign = new VariableDeclarationList(
           'let', [new VariableInitialization(left, value)]);
     } else {
       assign = value.toAssignExpression(left);
     }
 
     var newBody = new Expression.binary([assign]..addAll(body), ',');
-    Binary comma = new Template(null, newBody).safeCreate({name: left});
-    return new MetaLet(vars, comma.commaToExpressionList(),
+    newBody = _substitute(newBody, {result: left});
+    return new MetaLet(vars, newBody.commaToExpressionList(),
         statelessResult: statelessResult);
   }
 }
 
+/// Similar to [Template.instantiate] but works with free variables.
+Node _substitute(Node tree, Map<MetaLetVariable, Expression> substitutions) {
+  var generator = new InstantiatorGeneratorVisitor(/*forceCopy:*/ false);
+  var instantiator = generator.compile(tree);
+  var nodes = new List<MetaLetVariable>.from(generator
+      .analysis.containsInterpolatedNode
+      .where((n) => n is MetaLetVariable));
+  if (nodes.isEmpty) return tree;
+
+  return instantiator(new Map.fromIterable(nodes,
+      key: (v) => (v as MetaLetVariable).nameOrPosition,
+      value: (v) => substitutions[v] ?? v));
+}
+
+/// A temporary variable used in a [MetaLet].
+///
+/// Each instance of this class represents a fresh variable. The same object
+/// should be used everywhere to refer to the same variable. Different variables
+/// with the same name are different, and will be renamed later on, if needed.
+///
+/// These variables will be replaced when the `let*` is complete, depending on
+/// how often they occur and whether they can be optimized away. See [MetaLet]
+/// for more information.
+///
+/// This class should never reach our final JS code.
+class MetaLetVariable extends InterpolatedExpression {
+  /// The suggested display name of this variable.
+  ///
+  /// This name should not be used
+  final String displayName;
+
+  /// Compute fresh IDs to avoid
+  static int _uniqueId = 0;
+
+  MetaLetVariable(String displayName)
+      : displayName = displayName,
+        super(displayName + '@${++_uniqueId}');
+}
+
 class _VariableUseCounter extends BaseVisitor {
-  final counts = <String, int>{};
+  final counts = <MetaLetVariable, int>{};
   @override
   visitInterpolatedExpression(InterpolatedExpression node) {
-    int n = counts[node.nameOrPosition];
-    counts[node.nameOrPosition] = n == null ? 1 : n + 1;
+    if (node is MetaLetVariable) {
+      int n = counts[node];
+      counts[node] = n == null ? 1 : n + 1;
+    }
   }
 }
 
 class _IdentFinder extends BaseVisitor {
   final String name;
   bool found = false;
   _IdentFinder(this.name);
 
   @override
   visitIdentifier(Identifier node) {
@@ skipping 26 matching lines @@
   @override
   visitYield(Yield node) {
     if (!_nestedFunction) hasYield = true;
   }
 
   @override
   visitNode(Node node) {
     if (!hasYield) super.visitNode(node);
   }
 }