dart2js cps: Name labels uniquely within each method, not globally.

pkg/compiler/lib/src/js_backend/codegen/codegen.dart

 // Copyright (c) 2014, 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 code_generator;
 
 import 'glue.dart';
 
 import '../../closure.dart' show
     ClosureClassElement;
@@ skipping 63 matching lines @@
   /// followed by the end of the method.
   ///
   /// Note on why the [fallthrough] stack should not be used for this:
   /// Ordinary statements may choose whether to use the [fallthrough] target,
   /// and the choice to do so may disable an optimization in [visitIf].
   /// But omitting an unreachable 'return' should have lower priority than
   /// the optimizations in [visitIf], so [visitIf] will instead tell the
   /// [Unreachable] statements whether they may use fallthrough or not.
   List<bool> emitUnreachableAsReturn = <bool>[false];
 
-  Set<tree_ir.Label> usedLabels = new Set<tree_ir.Label>();
+  final Map<tree_ir.Label, String> labelNames = <tree_ir.Label, String>{};
 
   List<js.Statement> accumulator = new List<js.Statement>();
 
   CodeGenerator(this.glue, this.registry);
 
   /// Generates JavaScript code for the body of [function].
   js.Fun buildFunction(tree_ir.FunctionDefinition function) {
     registerDefaultParameterValues(function.element);
     currentFunction = function.element;
     visitStatement(function.body);
@@ skipping 479 matching lines @@
     tree_ir.Statement next = fallthrough.target;
     if (node.target.binding == next ||
         next is tree_ir.Continue && node.target == next.target) {
       // Fall through to continue target or to equivalent continue.
       fallthrough.use();
     } else if (node.target.binding == shortContinue.target) {
       // The target is the immediately enclosing loop.
       shortContinue.use();
       accumulator.add(new js.Continue(null));
     } else {
-      usedLabels.add(node.target);
-      accumulator.add(new js.Continue(node.target.name));
+      accumulator.add(new js.Continue(makeLabel(node.target)));
     }
   }
 
   /// True if [other] is the target of [node] or is a [Break] with the same
   /// target. This means jumping to [other] is equivalent to executing [node].
   bool isEffectiveBreakTarget(tree_ir.Break node, tree_ir.Statement other) {
     return node.target.binding.next == other ||
            other is tree_ir.Break && node.target == other.target;
   }
 
@@ skipping 11 matching lines @@
       fallthrough.use();
     } else if (isEffectiveBreakTarget(node, shortBreak.target)) {
       // Unlabeled break to the break target or to an equivalent break.
       shortBreak.use();
       accumulator.add(new js.Break(null));
     } else if (isShortContinue(node)) {
       // An unlabeled continue is better than a labeled break.
       shortContinue.use();
       accumulator.add(new js.Continue(null));
     } else {
-      usedLabels.add(node.target);
-      accumulator.add(new js.Break(node.target.name));
+      accumulator.add(new js.Break(makeLabel(node.target)));
     }
   }
 
   @override
   void visitExpressionStatement(tree_ir.ExpressionStatement node) {
     js.Expression exp = visitExpression(node.expression);
     if (node.next is tree_ir.Unreachable && emitUnreachableAsReturn.last) {
       // Emit as 'return exp' to assist local analysis in the VM.
       accumulator.add(new js.Return(exp));
     } else {
@@ skipping 34 matching lines @@
 
   @override
   void visitLabeledStatement(tree_ir.LabeledStatement node) {
     fallthrough.push(node.next);
     js.Statement body = buildBodyStatement(node.body);
     fallthrough.pop();
     accumulator.add(insertLabel(node.label, body));
     visitStatement(node.next);
   }
 
+  /// Creates a name for [label] if it does not already have one.
+  ///
+  /// This also marks the label as being used.
+  String makeLabel(tree_ir.Label label) {
+    return labelNames.putIfAbsent(label, () => 'L${labelNames.length}');
+  }
+
   /// Wraps a node in a labeled statement unless the label is unused.
   js.Statement insertLabel(tree_ir.Label label, js.Statement node) {
-    if (usedLabels.remove(label)) {
-      return new js.LabeledStatement(label.name, node);
-    } else {
-      return node;
-    }
+    String name = labelNames[label];
+    if (name == null) return node; // Label is unused.
+    return new js.LabeledStatement(name, node);
   }
 
   /// Returns the current [accumulator] wrapped in a block if neccessary.
   js.Statement _bodyAsStatement() {
     if (accumulator.length == 0) {
       return new js.EmptyStatement();
     }
     if (accumulator.length == 1) {
       return accumulator.single;
     }
@@ skipping 537 matching lines @@
   void registerDefaultParameterValues(ExecutableElement element) {
     if (element is! FunctionElement) return;
     FunctionElement function = element;
     if (function.isStatic) return; // Defaults are inlined at call sites.
     function.functionSignature.forEachOptionalParameter((param) {
       ConstantValue constant = glue.getDefaultParameterValue(param);
       registry.registerCompileTimeConstant(constant);
     });
   }
 }