Refactoring if block-information.

lib/compiler/implementation/ssa/nodes.dart

 // Copyright (c) 2011, 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.
 
 interface HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBitAnd(HBitAnd node);
   R visitBitNot(HBitNot node);
   R visitBitOr(HBitOr node);
   R visitBitXor(HBitXor node);
@@ skipping 124 matching lines @@
   HBasicBlock addNewBlock() {
     HBasicBlock result = new HBasicBlock();
     addBlock(result);
     return result;
   }
 
   HBasicBlock addNewLoopHeaderBlock(int type,
                                     TargetElement target,
                                     List<LabelElement> labels) {
     HBasicBlock result = addNewBlock();
-    result.loopInformation = new HLoopInformation(type, result, target, labels);
+    result.blockInformation =
+        new HLoopInformation(type, result, target, labels);
     return result;
   }
 
   static HType mapConstantTypeToSsaType(Constant constant) {
     if (constant.isNull()) return HType.UNKNOWN;
     if (constant.isBool()) return HType.BOOLEAN;
     if (constant.isInt()) return HType.INTEGER;
     if (constant.isDouble()) return HType.DOUBLE;
     if (constant.isString()) return HType.STRING;
     if (constant.isList()) return HType.READABLE_ARRAY;
@@ skipping 250 matching lines @@
   // this [id]. The exception are back-edges.
   int id;
 
   static final int STATUS_NEW = 0;
   static final int STATUS_OPEN = 1;
   static final int STATUS_CLOSED = 2;
   int status = STATUS_NEW;
 
   HInstructionList phis;
 
-  HLoopInformation loopInformation = null;
-  HLabeledBlockInformation labeledBlockInformation = null;
+  HBlockInformation blockInformation = null;
   HBasicBlock parentLoopHeader = null;
   List<HTypeGuard> guards;
 
   final List<HBasicBlock> predecessors;
   List<HBasicBlock> successors;
 
   HBasicBlock dominator = null;
   final List<HBasicBlock> dominatedBlocks;
 
   HBasicBlock() : this.withId(null);
   HBasicBlock.withId(this.id)
       : phis = new HInstructionList(),
         predecessors = <HBasicBlock>[],
         successors = const <HBasicBlock>[],
         dominatedBlocks = <HBasicBlock>[],
         guards = <HTypeGuard>[];
 
   int hashCode() => id;
 
   bool isNew() => status == STATUS_NEW;
   bool isOpen() => status == STATUS_OPEN;
   bool isClosed() => status == STATUS_CLOSED;
 
-  bool isLoopHeader() => loopInformation !== null;
-  bool hasLabeledBlockInformation() => labeledBlockInformation !== null;
+  bool isLoopHeader() => blockInformation is HLoopInformation;
+  bool isLabeledBlock() => blockInformation is HLabeledBlockInformation;
 
   bool hasGuards() => !guards.isEmpty();
 
   void open() {
     assert(isNew());
     status = STATUS_OPEN;
   }
 
   void close(HControlFlow end) {
     assert(isOpen());
@@ skipping 86 matching lines @@
     } else {
       successors.add(block);
     }
     block.predecessors.add(this);
   }
 
   void postProcessLoopHeader() {
     assert(isLoopHeader());
     // Only the first entry into the loop is from outside the
     // loop. All other entries must be back edges.
+    HLoopInformation loopInformation = this.blockInformation;
     for (int i = 1, length = predecessors.length; i < length; i++) {
       loopInformation.addBackEdge(predecessors[i]);
     }
   }
 
   /**
    * Rewrites all uses of the [from] instruction to using the [to]
    * instruction instead.
    */
   void rewrite(HInstruction from, HInstruction to) {
@@ skipping 87 matching lines @@
   }
 
   bool isValid() {
     assert(isClosed());
     HValidator validator = new HValidator();
     validator.visitBasicBlock(this);
     return validator.isValid;
   }
 }
 
-interface HBlockInformation {}
-
-class HLabeledBlockInformation implements HBlockInformation {
-  final SubGraph body;
-  final HBasicBlock joinBlock;
-  final List<LabelElement> labels;
-  final TargetElement target;
-  final bool isContinue;
-
-  HLabeledBlockInformation(this.body, this.joinBlock,
-                           List<LabelElement> labels,
-                           [this.isContinue = false]) :
-      this.labels = labels, this.target = labels[0].target;
-
-  HLabeledBlockInformation.implicit(this.body,
-                                    this.joinBlock,
-                                    this.target,
-                                    [this.isContinue = false])
-      : this.labels = const<LabelElement>[];
-}
-
-class LoopTypeVisitor extends AbstractVisitor {
-  const LoopTypeVisitor();
-  int visitNode(Node node) {
-    unreachable();
-  }
-  int visitWhile(While node) => HLoopInformation.WHILE_LOOP;
-  int visitFor(For node) => HLoopInformation.FOR_LOOP;
-  int visitDoWhile(DoWhile node) => HLoopInformation.DO_WHILE_LOOP;
-  int visitForIn(ForIn node) => HLoopInformation.FOR_IN_LOOP;
-}
-
-class HLoopInformation implements HBlockInformation {
-  static final int WHILE_LOOP = 0;
-  static final int FOR_LOOP = 1;
-  static final int DO_WHILE_LOOP = 2;
-  static final int FOR_IN_LOOP = 3;
-
-  final int type;
-  final HBasicBlock header;
-  final List<HBasicBlock> blocks;
-  final List<HBasicBlock> backEdges;
-  final List<LabelElement> labels;
-  final TargetElement target;
-  SubGraph initializer = null;
-  SubExpression condition = null;
-  SubGraph body = null;
-  SubGraph updates = null;
-  HBasicBlock joinBlock;
-
-  HLoopInformation(this.type, this.header, this.target, this.labels)
-      : blocks = new List<HBasicBlock>(),
-        backEdges = new List<HBasicBlock>();
-
-  static int loopType(Node node) {
-    return node.accept(const LoopTypeVisitor());
-  }
-
-  void addBackEdge(HBasicBlock predecessor) {
-    backEdges.add(predecessor);
-    addBlock(predecessor);
-  }
-
-  // Adds a block and transitively all its predecessors in the loop as
-  // loop blocks.
-  void addBlock(HBasicBlock block) {
-    if (block === header) return;
-    HBasicBlock parentHeader = block.parentLoopHeader;
-    if (parentHeader === header) {
-      // Nothing to do in this case.
-    } else if (parentHeader !== null) {
-      addBlock(parentHeader);
-    } else {
-      block.parentLoopHeader = header;
-      blocks.add(block);
-      for (int i = 0, length = block.predecessors.length; i < length; i++) {
-        addBlock(block.predecessors[i]);
-      }
-    }
-  }
-
-  HBasicBlock getLastBackEdge() {
-    int maxId = -1;
-    HBasicBlock result = null;
-    for (int i = 0, length = backEdges.length; i < length; i++) {
-      HBasicBlock current = backEdges[i];
-      if (current.id > maxId) {
-        maxId = current.id;
-        result = current;
-      }
-    }
-    return result;
-  }
-}
 
 class HType {
   final int flag;
   const HType(int this.flag);
 
   static final int FLAG_CONFLICTING = 0;
   static final int FLAG_UNKNOWN = 1;
   static final int FLAG_BOOLEAN = FLAG_UNKNOWN << 1;
   static final int FLAG_INTEGER = FLAG_BOOLEAN << 1;
   static final int FLAG_STRING = FLAG_INTEGER << 1;
@@ skipping 1329 matching lines @@
   HInstruction get expression() => inputs[0];
 
   HType computeType() => HType.BOOLEAN;
   bool hasExpectedType() => true;
 
   accept(HVisitor visitor) => visitor.visitIs(this);
 
   toString() => "$expression is $typeExpression";
 }
 
-class HIfBlockInformation {
-  final HIf branch;
+
+interface HBlockInformation {
+  bool accept(HBlockInformationVisitor visitor);
+}
+
+interface HBlockInformationVisitor {
+  bool visitLabeledBlockInfo(HLabeledBlockInformation info);
+  bool visitLoopInfo(HLoopInformation info);
+  bool visitIfInfo(HIfBlockInformation info);
+  bool visitAndOrInfo(HAndOrBlockInformation info);
+}
+
+class HLabeledBlockInformation implements HBlockInformation {
+  final SubGraph body;
+  final HBasicBlock joinBlock;
+  final List<LabelElement> labels;
+  final TargetElement target;
+  final bool isContinue;
+
+  HLabeledBlockInformation(this.body, this.joinBlock,
+                           List<LabelElement> labels,
+                           [this.isContinue = false]) :
+      this.labels = labels, this.target = labels[0].target;
+
+  HLabeledBlockInformation.implicit(this.body,
+                                    this.joinBlock,
+                                    this.target,
+                                    [this.isContinue = false])
+      : this.labels = const<LabelElement>[];
+
+  bool accept(HBlockInformationVisitor visitor) =>
+    visitor.visitLabeledBlockInfo(this);
+}
+
+class LoopTypeVisitor extends AbstractVisitor {
+  const LoopTypeVisitor();
+  int visitNode(Node node) {
+    unreachable();
+  }
+  int visitWhile(While node) => HLoopInformation.WHILE_LOOP;
+  int visitFor(For node) => HLoopInformation.FOR_LOOP;
+  int visitDoWhile(DoWhile node) => HLoopInformation.DO_WHILE_LOOP;
+  int visitForIn(ForIn node) => HLoopInformation.FOR_IN_LOOP;
+}
+
+class HLoopInformation implements HBlockInformation {
+  static final int WHILE_LOOP = 0;
+  static final int FOR_LOOP = 1;
+  static final int DO_WHILE_LOOP = 2;
+  static final int FOR_IN_LOOP = 3;
+
+  final int type;
+  final HBasicBlock header;
+  final List<HBasicBlock> blocks;
+  final List<HBasicBlock> backEdges;
+  final List<LabelElement> labels;
+  final TargetElement target;
+  SubGraph initializer = null;
+  SubExpression condition = null;
+  SubGraph body = null;
+  SubGraph updates = null;
+  HBasicBlock joinBlock;
+
+  HLoopInformation(this.type, this.header, this.target, this.labels)
+      : blocks = new List<HBasicBlock>(),
+        backEdges = new List<HBasicBlock>();
+
+  static int loopType(Node node) {
+    return node.accept(const LoopTypeVisitor());
+  }
+
+  void addBackEdge(HBasicBlock predecessor) {
+    backEdges.add(predecessor);
+    addBlock(predecessor);
+  }
+
+  // Adds a block and transitively all its predecessors in the loop as
+  // loop blocks.
+  void addBlock(HBasicBlock block) {
+    if (block === header) return;
+    HBasicBlock parentHeader = block.parentLoopHeader;
+    if (parentHeader === header) {
+      // Nothing to do in this case.
+    } else if (parentHeader !== null) {
+      addBlock(parentHeader);
+    } else {
+      block.parentLoopHeader = header;
+      blocks.add(block);
+      for (int i = 0, length = block.predecessors.length; i < length; i++) {
+        addBlock(block.predecessors[i]);
+      }
+    }
+  }
+
+  HBasicBlock getLastBackEdge() {
+    int maxId = -1;
+    HBasicBlock result = null;
+    for (int i = 0, length = backEdges.length; i < length; i++) {
+      HBasicBlock current = backEdges[i];
+      if (current.id > maxId) {
+        maxId = current.id;
+        result = current;
+      }
+    }
+    return result;
+  }
+
+  bool accept(HBlockInformationVisitor visitor) => visitor.visitLoopInfo(this);
+}
+
+class HIfBlockInformation implements HBlockInformation {
+  final SubExpression condition;
   final SubGraph thenGraph;
   final SubGraph elseGraph;
   final HBasicBlock joinBlock;
-  HIfBlockInformation(this.branch,
+  HIfBlockInformation(this.condition,
                       this.thenGraph,
                       this.elseGraph,
                       this.joinBlock);
+  bool accept(HBlockInformationVisitor visitor) => visitor.visitIfInfo(this);
 }
+
+class HAndOrBlockInformation implements HBlockInformation {
+  final bool isAnd;
+  final SubExpression left;
+  final SubExpression right;
+  final HBasicBlock joinBlock;
+  HAndOrBlockInformation(this.isAnd,
+                         this.left,
+                         this.right,
+                         this.joinBlock);
+  bool accept(HBlockInformationVisitor visitor) => visitor.visitAndOrInfo(this);
+}