Address review comments on issue 11412105.

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 visitBailoutTarget(HBailoutTarget node);
   R visitBitAnd(HBitAnd node);
@@ skipping 485 matching lines @@
     assert(isNew());
     status = STATUS_OPEN;
   }
 
   void close(HControlFlow end) {
     assert(isOpen());
     addAfter(last, end);
     status = STATUS_CLOSED;
   }
 
-  // TODO(kasperl): I really don't want to pass the compiler into this
-  // method. Maybe we need a better logging framework.
-  void printToCompiler(Compiler compiler) {
-    HInstruction instruction = first;
-    while (instruction != null) {
-      int instructionId = instruction.id;
-      String inputsAsString = instruction.inputsToString();
-      compiler.log('$instructionId: $instruction $inputsAsString');
-      instruction = instruction.next;
-    }
-  }
-
   void addAtEntry(HInstruction instruction) {
     assert(instruction is !HPhi);
     super.addBefore(first, instruction);
     instruction.notifyAddedToBlock(this);
   }
 
   void addAtExit(HInstruction instruction) {
     assert(isClosed());
     assert(last is HControlFlow);
     assert(instruction is !HPhi);
@@ skipping 750 matching lines @@
   int typeCode() => HInstruction.INTEGER_CHECK_TYPECODE;
   bool typeEquals(other) => other is HIntegerCheck;
   bool dataEquals(HInstruction other) => true;
 }
 
 abstract class HConditionalBranch extends HControlFlow {
   HConditionalBranch(inputs) : super(inputs);
   HInstruction get condition => inputs[0];
   HBasicBlock get trueBranch => block.successors[0];
   HBasicBlock get falseBranch => block.successors[1];
-  toString();
 }
 
 abstract class HControlFlow extends HInstruction {
   HControlFlow(inputs) : super(inputs);
-  toString();
   void prepareGvn(HTypeMap types) {
     // Control flow does not have side-effects.
   }
   bool isControlFlow() => true;
   bool isJsStatement(HTypeMap types) => true;
 }
 
 abstract class HInvoke extends HInstruction {
   /**
     * The first argument must be the target: either an [HStatic] node, or
     * the receiver of a method-call. The remaining inputs are the arguments
     * to the invocation.
     */
   HInvoke(List<HInstruction> inputs) : super(inputs);
   static const int ARGUMENTS_OFFSET = 1;
-
-  // TODO(floitsch): make class abstract instead of adding an abstract method.
-  accept(HVisitor visitor);
 }
 
 abstract class HInvokeDynamic extends HInvoke {
   final Selector selector;
   Element element;
 
   HInvokeDynamic(this.selector, this.element, List<HInstruction> inputs)
     : super(inputs);
   toString() => 'invoke dynamic: $selector';
   HInstruction get receiver => inputs[0];
 
-  accept(HVisitor visitor);
-
   bool get isInterceptorCall {
     // We know it's a selector call if it follows the interceptor
     // calling convention, which adds the actual receiver as a
     // parameter to the call.
     return inputs.length - 2 == selector.argumentCount;
   }
 }
 
 class HInvokeClosure extends HInvokeDynamic {
   HInvokeClosure(Selector selector, List<HInstruction> inputs)
     : super(selector, null, inputs);
   accept(HVisitor visitor) => visitor.visitInvokeClosure(this);
 }
 
 class HInvokeDynamicMethod extends HInvokeDynamic {
   HInvokeDynamicMethod(Selector selector, List<HInstruction> inputs)
     : super(selector, null, inputs);
   toString() => 'invoke dynamic method: $selector';
   accept(HVisitor visitor) => visitor.visitInvokeDynamicMethod(this);
 }
 
 abstract class HInvokeDynamicField extends HInvokeDynamic {
   final bool isSideEffectFree;
   HInvokeDynamicField(
       Selector selector, Element element, List<HInstruction> inputs,
       this.isSideEffectFree)
       : super(selector, element, inputs);
   toString() => 'invoke dynamic field: $selector';
-
-  accept(HVisitor visitor);
 }
 
 class HInvokeDynamicGetter extends HInvokeDynamicField {
   HInvokeDynamicGetter(
       selector, element, receiver, isSideEffectFree)
     : super(selector, element, [receiver], isSideEffectFree);
   toString() => 'invoke dynamic getter: $selector';
   accept(HVisitor visitor) => visitor.visitInvokeDynamicGetter(this);
 
   void prepareGvn(HTypeMap types) {
@@ skipping 384 matching lines @@
     if (propagatedType.isUnknown() || propagatedType.isNumber()) {
       return HType.INTEGER;
     }
     return HType.UNKNOWN;
   }
 
   HType computeLikelyType(HTypeMap types, Compiler compiler) {
     if (left.isTypeUnknown(types)) return HType.INTEGER;
     return HType.UNKNOWN;
   }
-
-  // TODO(floitsch): make class abstract instead of adding an abstract method.
-  accept(HVisitor visitor);
 }
 
 class HShiftLeft extends HBinaryBitOp {
   HShiftLeft(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitShiftLeft(this);
 
   // Shift left cannot be mapped to the native operator unless the
   // shift count is guaranteed to be an integer in the [0,31] range.
   bool isBuiltin(HTypeMap types) {
@@ skipping 451 matching lines @@
         return HType.NUMBER;
       }
     }
     return HType.UNKNOWN;
   }
 
   HType computeLikelyType(HTypeMap types, Compiler compiler) => HType.BOOLEAN;
 
   bool isBuiltin(HTypeMap types)
       => left.isNumber(types) && right.isNumber(types);
-  // TODO(1603): the class should be marked as abstract.
-  BinaryOperation operation(ConstantSystem constantSystem);
 }
 
 class HEquals extends HRelational {
   HEquals(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitEquals(this);
 
   bool isBuiltin(HTypeMap types) {
     // All primitive types have 'identical' semantics.
     // Note that this includes all constants except the user-constructed
@@ skipping 713 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);
 }