Remove unused API.

dart/sdk/lib/_internal/compiler/implementation/ssa/nodes.dart

 // Copyright (c) 2012, 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.
 
 part of ssa;
 
 abstract class HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBitAnd(HBitAnd node);
   R visitBitNot(HBitNot node);
@@ skipping 777 matching lines @@
       : id = idCounter++, usedBy = <HInstruction>[] {
     assert(inputs.every((e) => e != null));
   }
 
   int get hashCode => id;
 
   bool useGvn() => _useGvn;
   void setUseGvn() { _useGvn = true; }
   void clearUseGvn() { _useGvn = false; }
 
-  void updateInput(int i, HInstruction insn) {
-    assert(insn != null);
-    inputs[i] = insn;
-  }
-
   /**
    * A pure instruction is an instruction that does not have any side
    * effect, nor any dependency. They can be moved anywhere in the
    * graph.
    */
   bool isPure() {
     return !sideEffects.hasSideEffects()
         && !sideEffects.dependsOnSomething()
         && !canThrow();
   }
@@ skipping 161 matching lines @@
    * Type of the unstruction.
    */
   TypeMask instructionType;
 
   Selector get selector => null;
   HInstruction getDartReceiver(Compiler compiler) => null;
   bool onlyThrowsNSM() => false;
 
   bool isInBasicBlock() => block != null;
 
-  String inputsToString() {
-    void addAsCommaSeparated(StringBuffer buffer, List<HInstruction> list) {
-      for (int i = 0; i < list.length; i++) {
-        if (i != 0) buffer.write(', ');
-        buffer.write("@${list[i].id}");
-      }
-    }
-
-    StringBuffer buffer = new StringBuffer();
-    buffer.write('(');
-    addAsCommaSeparated(buffer, inputs);
-    buffer.write(') - used at [');
-    addAsCommaSeparated(buffer, usedBy);
-    buffer.write(']');
-    return buffer.toString();
-  }
-
   bool gvnEquals(HInstruction other) {
     assert(useGvn() && other.useGvn());
     // Check that the type and the sideEffects match.
     bool hasSameType = typeEquals(other);
     assert(hasSameType == (typeCode() == other.typeCode()));
     if (!hasSameType) return false;
     if (sideEffects != other.sideEffects) return false;
     // Check that the inputs match.
     final int inputsLength = inputs.length;
     final List<HInstruction> otherInputs = other.inputs;
@@ skipping 368 matching lines @@
 
 class HInvokeDynamicMethod extends HInvokeDynamic {
   HInvokeDynamicMethod(Selector selector,
                        List<HInstruction> inputs,
                        TypeMask type,
                        [bool isIntercepted = false])
     : super(selector, null, inputs, type, isIntercepted);
 
   String toString() => 'invoke dynamic method: $selector';
   accept(HVisitor visitor) => visitor.visitInvokeDynamicMethod(this);
-
-  bool isIndexOperatorOnIndexablePrimitive(Compiler compiler) {
-    return isInterceptedCall
-        && selector.kind == SelectorKind.INDEX
-        && selector.name == '[]'
-        && inputs[1].isIndexablePrimitive(compiler);
-  }
 }
 
 abstract class HInvokeDynamicField extends HInvokeDynamic {
   HInvokeDynamicField(
       Selector selector, Element element, List<HInstruction> inputs,
       TypeMask type)
       : super(selector, element, inputs, type);
   toString() => 'invoke dynamic field: $selector';
 }
 
@@ skipping 491 matching lines @@
 
 class HLoopBranch extends HConditionalBranch {
   static const int CONDITION_FIRST_LOOP = 0;
   static const int DO_WHILE_LOOP = 1;
 
   final int kind;
   HLoopBranch(HInstruction condition, [this.kind = CONDITION_FIRST_LOOP])
       : super(<HInstruction>[condition]);
   toString() => 'loop-branch';
   accept(HVisitor visitor) => visitor.visitLoopBranch(this);
-
-  bool isDoWhile() {
-    return identical(kind, DO_WHILE_LOOP);
-  }
-
-  HBasicBlock computeLoopHeader() {
-    HBasicBlock result;
-    if (isDoWhile()) {
-      // In case of a do/while, the successor is a block that avoids
-      // a critical edge and branchs to the loop header.
-      result = block.successors[0].successors[0];
-    } else {
-      // For other loops, the loop header might be up the dominator
-      // tree if the loop condition has control flow.
-      result = block;
-      while (!result.isLoopHeader()) result = result.dominator;
-    }
-
-    assert(result.isLoopHeader());
-    return result;
-  }
 }
 
 class HConstant extends HInstruction {
   final Constant constant;
   HConstant.internal(this.constant, TypeMask constantType)
       : super(<HInstruction>[], constantType);
 
   toString() => 'literal: $constant';
   accept(HVisitor visitor) => visitor.visitConstant(this);
 
@@ skipping 79 matching lines @@
   HPhi.manyInputs(Element element, List<HInstruction> inputs, TypeMask type)
       : this(element, inputs, type);
 
   void addInput(HInstruction input) {
     assert(isInBasicBlock());
     inputs.add(input);
     assert(inputs.length <= block.predecessors.length);
     input.usedBy.add(this);
   }
 
-  bool isLogicalOperator() => logicalOperatorType != IS_NOT_LOGICAL_OPERATOR;
-
-  String logicalOperator() {
-    assert(isLogicalOperator());
-    if (logicalOperatorType == IS_AND) return "&&";
-    assert(logicalOperatorType == IS_OR);
-    return "||";
-  }
-
   toString() => 'phi';
   accept(HVisitor visitor) => visitor.visitPhi(this);
 }
 
 abstract class HRelational extends HInvokeBinary {
   bool usesBoolifiedInterceptor = false;
   HRelational(left, right, selector, type) : super(left, right, selector, type);
 }
 
 class HIdentity extends HRelational {
@@ skipping 497 matching lines @@
     if (identical(parentHeader, header)) {
       // Nothing to do in this case.
     } else if (parentHeader != null) {
       workQueue.add(parentHeader);
     } else {
       block.parentLoopHeader = header;
       blocks.add(block);
       workQueue.addAll(block.predecessors);
     }
   }
-
-  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;
-  }
 }
 
 
 /**
  * Embedding of a [HBlockInformation] for block-structure based traversal
  * in a dominator based flow traversal by attaching it to a basic block.
  * To go back to dominator-based traversal, a [HSubGraphBlockInformation]
  * structure can be added in the block structure.
  */
 class HBlockFlow {
@@ skipping 29 matching lines @@
   HInstruction get conditionExpression;
 }
 
 
 abstract class HStatementInformationVisitor {
   bool visitLabeledBlockInfo(HLabeledBlockInformation info);
   bool visitLoopInfo(HLoopBlockInformation info);
   bool visitIfInfo(HIfBlockInformation info);
   bool visitTryInfo(HTryBlockInformation info);
   bool visitSwitchInfo(HSwitchBlockInformation info);
-  bool visitSequenceInfo(HStatementSequenceInformation info);

[Johnni Winther, 2013/12/03 11:52:31]

Only remove this together with HStatementSequenceInformation.

[ahe, 2013/12/04 11:45:43]

Keeping these for now and I'll use it to implement a check to remove unused
classes.

   // Pseudo-structure embedding a dominator-based traversal into
   // the block-structure traversal. This will eventually go away.
   bool visitSubGraphInfo(HSubGraphBlockInformation info);
 }
 
 
 abstract class HExpressionInformationVisitor {
-  bool visitAndOrInfo(HAndOrBlockInformation info);

[Johnni Winther, 2013/12/03 11:52:31]

Only remove this together with HAndOrBlockInformation.

   bool visitSubExpressionInfo(HSubExpressionBlockInformation info);
 }
 
 
 abstract class HBlockInformationVisitor
     implements HStatementInformationVisitor, HExpressionInformationVisitor {
 }
 
 
 /**
  * Generic class wrapping a [SubGraph] as a block-information until
  * all structures are handled properly.
  */
 class HSubGraphBlockInformation implements HStatementInformation {
   final SubGraph subGraph;
   HSubGraphBlockInformation(this.subGraph);
 
   HBasicBlock get start => subGraph.start;
   HBasicBlock get end => subGraph.end;
 
   bool accept(HStatementInformationVisitor visitor) =>
     visitor.visitSubGraphInfo(this);
 }
 
-
 /**
  * Generic class wrapping a [SubExpression] as a block-information until
  * expressions structures are handled properly.
  */
 class HSubExpressionBlockInformation implements HExpressionInformation {
   final SubExpression subExpression;
   HSubExpressionBlockInformation(this.subExpression);
 
   HBasicBlock get start => subExpression.start;
   HBasicBlock get end => subExpression.end;
 
   HInstruction get conditionExpression => subExpression.conditionExpression;
 
   bool accept(HExpressionInformationVisitor visitor) =>
     visitor.visitSubExpressionInfo(this);
 }
 
-
 /** A sequence of separate statements. */
 class HStatementSequenceInformation implements HStatementInformation {
   final List<HStatementInformation> statements;
   HStatementSequenceInformation(this.statements);
 
   HBasicBlock get start => statements[0].start;
   HBasicBlock get end => statements.last.end;
-
-  bool accept(HStatementInformationVisitor visitor) =>

[Johnni Winther, 2013/12/03 11:52:31]

Needed if HStatementSequenceInformation is needed.

-    visitor.visitSequenceInfo(this);
 }
 
-
 class HLabeledBlockInformation implements HStatementInformation {
   final HStatementInformation body;
   final List<LabelElement> labels;
   final TargetElement target;
   final bool isContinue;
 
   HLabeledBlockInformation(this.body,
                            List<LabelElement> labels,
                            {this.isContinue: false}) :
       this.labels = labels, this.target = labels[0].target;
@@ skipping 69 matching lines @@
     if (kind == DO_WHILE_LOOP && condition != null) {
       return condition.end;
     }
     return body.end;
   }
 
   static int loopType(Node node) {
     return node.accept(const LoopTypeVisitor());
   }
 
-  bool isDoWhile() => kind == DO_WHILE_LOOP;
-
   bool accept(HStatementInformationVisitor visitor) =>
     visitor.visitLoopInfo(this);
 }
 
 class HIfBlockInformation implements HStatementInformation {
   final HExpressionInformation condition;
   final HStatementInformation thenGraph;
   final HStatementInformation elseGraph;
   HIfBlockInformation(this.condition,
                       this.thenGraph,
@@ skipping 14 matching lines @@
                          this.left,
                          this.right);
 
   HBasicBlock get start => left.start;
   HBasicBlock get end => right.end;
 
   // We don't currently use HAndOrBlockInformation.
   HInstruction get conditionExpression {
     return null;
   }
-  bool accept(HExpressionInformationVisitor visitor) =>

[Johnni Winther, 2013/12/03 11:52:31]

Needed if HAndOrBlockInformation is needed.

-    visitor.visitAndOrInfo(this);
 }
 
 class HTryBlockInformation implements HStatementInformation {
   final HStatementInformation body;
   final HLocalValue catchVariable;
   final HStatementInformation catchBlock;
   final HStatementInformation finallyBlock;
   HTryBlockInformation(this.body,
                        this.catchVariable,
                        this.catchBlock,
@@ skipping 23 matching lines @@
   HBasicBlock get start => expression.start;
   HBasicBlock get end {
     // We don't create a switch block if there are no cases.
     assert(!statements.isEmpty);
     return statements.last.end;
   }
 
   bool accept(HStatementInformationVisitor visitor) =>
       visitor.visitSwitchInfo(this);
 }