dart2js cps: Debugging utility and fix idempotency in shrinking reducer.

pkg/compiler/lib/src/cps_ir/cps_ir_nodes.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_nodes;
 
 import 'dart:collection';
 import 'cps_fragment.dart' show CpsFragment;
+import 'cps_ir_nodes_sexpr.dart';
 import '../constants/values.dart' as values;
 import '../dart_types.dart' show DartType, InterfaceType, TypeVariableType;
 import '../elements/elements.dart';
 import '../io/source_information.dart' show SourceInformation;
 import '../types/types.dart' show TypeMask;
 import '../universe/selector.dart' show Selector;
 
 import 'builtin_operator.dart';
 export 'builtin_operator.dart';
 
@@ skipping 14 matching lines @@
   Node() {
     setParentPointers();
   }
 
   accept(Visitor visitor);
 
   /// Updates the [parent] of the immediate children to refer to this node.
   ///
   /// All constructors call this method to initialize parent pointers.
   void setParentPointers();
+
+  /// Returns the SExpression for the subtree rooted at this node.
+  ///
+  /// [annotations] maps strings to nodes and/or nodes to values that will be
+  /// converted to strings. Each binding causes the annotation to appear on the
+  /// given node.
+  ///
+  /// For example, the following could be used to diagnose a problem with nodes
+  /// not appearing in an environment map:
+  ///
+  ///     if (environment[node] == null)
+  ///       root.debugPrint({
+  ///         'currentNode': node,
+  ///         'caller': someContinuation
+  ///       });
+  ///       throw 'Node was not in environment';
+  ///     }
+  ///
+  /// If two strings map to the same node, it will be given both annotations.
+  ///
+  /// Avoid using nodes as keys if there is a chance that two keys are the
+  /// same node.
+  String debugString([Map annotations]) {
+    return new SExpressionStringifier()
+        .withAnnotations(annotations).visit(this);
+  }
+
+  /// Prints the result of [debugString].
+  void debugPrint([Map annotations]) {
+    print(debugString(annotations));
+  }
 }
 
 /// Expressions can be evaluated, and may diverge, throw, and/or have
 /// side-effects.
 ///
 /// Evaluation continues by stepping into a sub-expression, invoking a
 /// continuation, or throwing an exception.
 ///
 /// Expressions do not a return value. Expressions that produce values should
 /// invoke a [Continuation] with the result as argument. Alternatively, values
@@ skipping 136 matching lines @@
         ref = ref.next;
       } else {
         current = ref;
         next = current.next;
         return true;
       }
     }
   }
 }
 
-class EffectiveUseIterable extends IterableBase<Reference<Primitive>> {
+class RefinedUseIterable extends IterableBase<Reference<Primitive>> {
   Primitive primitive;
-  EffectiveUseIterable(this.primitive);
+  RefinedUseIterable(this.primitive);
   EffectiveUseIterator get iterator => new EffectiveUseIterator(primitive);
 }
 
 /// A named value.
 ///
 /// The identity of the [Primitive] object is the name of the value.
 /// The subclass describes how to compute the value.
 ///
 /// All primitives except [Parameter] must be bound by a [LetPrim].
 abstract class Primitive extends Variable<Primitive> {
@@ skipping 20 matching lines @@
   /// If this is a [Refinement], [BoundsCheck] or [NullCheck] node, returns the
   /// value being refined, the indexable object being checked, or the value
   /// that was checked to be non-null, respectively.
   ///
   /// Those instructions all return the corresponding operand directly, and
   /// this getter can be used to get (closer to) where the value came from.
   //
   // TODO(asgerf): Also do this for [TypeCast]?
   Primitive get effectiveDefinition => this;
 
+  /// Like [effectiveDefinition] but only unfolds [Refinement] nodes.
+  Primitive get unrefined => this;
+
   /// True if the two primitives are (refinements of) the same value.
   bool sameValue(Primitive other) {
     return effectiveDefinition == other.effectiveDefinition;
   }
 
   /// Iterates all non-refinement uses of the primitive and all uses of
   /// a [Refinement] of this primitive (transitively).
   ///
   /// Notes regarding concurrent modification:
   /// - The current reference may safely be unlinked.
   /// - Yet unvisited references may not be unlinked.
   /// - References to this primitive created during iteration will not be seen.
   /// - References to a refinement of this primitive may not be created during
   ///   iteration.
-  EffectiveUseIterable get effectiveUses => new EffectiveUseIterable(this);
+  RefinedUseIterable get refinedUses => new RefinedUseIterable(this);
 
-  bool get hasMultipleEffectiveUses {
-    Iterator it = effectiveUses.iterator;
+  bool get hasMultipleRefinedUses {
+    Iterator it = refinedUses.iterator;
     return it.moveNext() && it.moveNext();
   }
 
-  bool get hasNoEffectiveUses {
-    return effectiveUses.isEmpty;
+  bool get hasNoRefinedUses {
+    return refinedUses.isEmpty;
   }
 
   /// Unlinks all references contained in this node.
   void destroy() {
     assert(hasNoUses);
     RemovalVisitor.remove(this);
   }
 
   /// Replaces this definition, both at the binding site and at all uses sites.
   ///
@@ skipping 453 matching lines @@
     : value = new Reference<Primitive>(value);
 
   bool get hasValue => true;
   bool get isSafeForElimination => false;
   bool get isSafeForReordering => false;
 
   accept(Visitor visitor) => visitor.visitRefinement(this);
 
   Primitive get effectiveDefinition => value.definition.effectiveDefinition;
 
+  Primitive get unrefined => value.definition.unrefined;
+
   void setParentPointers() {
     value.parent = this;
   }
 }
 
 /// Checks that [index] is a valid index on a given indexable [object].
 ///
 /// Compiles to the following, with a subset of the conditions in the `if`:
 ///
 ///     if (index < 0 || index >= object.length || object.length === 0)
@@ skipping 868 matching lines @@
 /// Continuations are normally bound by 'let cont'.  A continuation with one
 /// parameter and no body is used to represent a function's return continuation.
 /// The return continuation is bound by the function, not by 'let cont'.
 class Continuation extends Definition<Continuation> implements InteriorNode {
   final List<Parameter> parameters;
   Expression body = null;
 
   // A continuation is recursive if it has any recursive invocations.
   bool isRecursive;
 
+  /// True if this is the return continuation.  The return continuation is bound
+  /// by [FunctionDefinition].
   bool get isReturnContinuation => body == null;
 
+  /// True if this is a branch continuation.  Branch continuations are bound
+  /// by [LetCont] and can only have one use.
+  bool get isBranchContinuation => firstRef?.parent is Branch;
+
+  /// True if this is the exception handler bound by a [LetHandler].
+  bool get isHandlerContinuation => parent is LetHandler;
+
+  /// True if this is a non-return continuation that can be targeted by
+  /// [InvokeContinuation].
+  bool get isJoinContinuation {
+    return body != null &&
+           parent is! LetHandler &&
+           (firstRef == null || firstRef.parent is InvokeContinuation);
+  }
+
   Continuation(this.parameters, {this.isRecursive: false});
 
   Continuation.retrn()
     : parameters = <Parameter>[new Parameter(null)],
       isRecursive = false;
 
   accept(BlockVisitor visitor) => visitor.visitContinuation(this);
 
   void setParentPointers() {
     _setParentsOnNodes(parameters, this);
@@ skipping 1150 matching lines @@
     plug(new Branch.loose(_definitions.getCopy(node.condition),
         _copies[node.trueContinuation.definition],
         _copies[node.falseContinuation.definition])
       ..isStrictCheck = node.isStrictCheck);
   }
 
   visitUnreachable(Unreachable node) {
     plug(new Unreachable());
   }
 }