Fix some warnings.

lib/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.
 
 abstract class HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBailoutTarget(HBailoutTarget node);
   R visitBitAnd(HBitAnd node);
   R visitBitNot(HBitNot node);
   R visitBitOr(HBitOr node);
@@ skipping 723 matching lines @@
   bool dominates(HBasicBlock other) {
     do {
       if (this === other) return true;
       other = other.dominator;
     } while (other !== null && other.id >= id);
     return false;
   }
 }
 
 
-class HInstruction implements Spannable {
+abstract class HInstruction implements Spannable {
   Element sourceElement;
   SourceFileLocation sourcePosition;
 
   final int id;
   static int idCounter;
 
   final List<HInstruction> inputs;
   final List<HInstruction> usedBy;
 
   HBasicBlock block;
@@ skipping 298 matching lines @@
   bool isConstant() => false;
   bool isConstantBoolean() => false;
   bool isConstantNull() => false;
   bool isConstantNumber() => false;
   bool isConstantInteger() => false;
   bool isConstantString() => false;
   bool isConstantList() => false;
   bool isConstantMap() => false;
   bool isConstantFalse() => false;
   bool isConstantTrue() => false;
+  bool isConstantSentinel() => false;
 
   bool isValid() {
     HValidator validator = new HValidator();
     validator.currentBlock = block;
     validator.visitInstruction(this);
     return validator.isValid;
   }
 
   /**
    * The code for computing a bailout environment, and the code
@@ skipping 160 matching lines @@
       ? HType.INTEGER
       : super.computeDesiredTypeForInput(input, types);
   }
 
   accept(HVisitor visitor) => visitor.visitIntegerCheck(this);
   int typeCode() => HInstruction.INTEGER_CHECK_TYPECODE;
   bool typeEquals(other) => other is HIntegerCheck;
   bool dataEquals(HInstruction other) => true;
 }
 
-class HConditionalBranch extends HControlFlow {
+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];
   abstract toString();
 }
 
-class HControlFlow extends HInstruction {
+abstract class HControlFlow extends HInstruction {
   HControlFlow(inputs) : super(inputs);
   abstract toString();
   void prepareGvn(HTypeMap types) {
     // Control flow does not have side-effects.
   }
   bool isControlFlow() => true;
   bool isJsStatement(HTypeMap types) => true;
 }
 
-class HInvoke extends HInstruction {
+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.
   abstract accept(HVisitor visitor);
 }
 
-class HInvokeDynamic extends HInvoke {
+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];
 
   // TODO(floitsch): make class abstract instead of adding an abstract method.
   abstract accept(HVisitor visitor);
 }
 
 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);
 }
 
-class HInvokeDynamicField extends HInvokeDynamic {
+abstract class HInvokeDynamicField extends HInvokeDynamic {
   HInvokeDynamicField(Selector selector, Element element,
                       List<HInstruction> inputs)
       : super(selector, element, inputs);
   toString() => 'invoke dynamic field: $selector';
 
   // TODO(floitsch): make class abstract instead of adding an abstract method.
   abstract accept(HVisitor visitor);
 }
 
 class HInvokeDynamicGetter extends HInvokeDynamicField {
@@ skipping 252 matching lines @@
 }
 
 class HForeignNew extends HForeign {
   ClassElement element;
   HForeignNew(this.element, List<HInstruction> inputs)
       : super(const LiteralDartString("new"),
               const LiteralDartString("Object"), inputs);
   accept(HVisitor visitor) => visitor.visitForeignNew(this);
 }
 
-class HInvokeBinary extends HInvokeStatic {
+abstract class HInvokeBinary extends HInvokeStatic {
   HInvokeBinary(HStatic target, HInstruction left, HInstruction right)
       : super(<HInstruction>[target, left, right]);
 
   HInstruction get left => inputs[1];
   HInstruction get right => inputs[2];
 
   abstract BinaryOperation operation(ConstantSystem constantSystem);
   abstract isBuiltin(HTypeMap types);
 }
 
-class HBinaryArithmetic extends HInvokeBinary {
+abstract class HBinaryArithmetic extends HInvokeBinary {
   HBinaryArithmetic(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
 
   void prepareGvn(HTypeMap types) {
     // An arithmetic expression can take part in global value
     // numbering and do not have any side-effects if we know that all
     // inputs are numbers.
     if (isBuiltin(types)) {
       clearAllSideEffects();
       setUseGvn();
@@ skipping 35 matching lines @@
     // to the array case.
     if (input == right && left.isNumber(types)) return HType.NUMBER;
     return HType.UNKNOWN;
   }
 
   HType computeLikelyType(HTypeMap types) {
     if (left.isTypeUnknown(types)) return HType.NUMBER;
     return HType.UNKNOWN;
   }
 
-  // TODO(1603): The class should be marked as abstract.
   abstract BinaryOperation operation(ConstantSystem constantSystem);
 }
 
 class HAdd extends HBinaryArithmetic {
   HAdd(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitAdd(this);
 
   BinaryOperation operation(ConstantSystem constantSystem)
       => constantSystem.add;
@@ skipping 93 matching lines @@
   BinaryOperation operation(ConstantSystem constantSystem)
       => constantSystem.truncatingDivide;
   int typeCode() => HInstruction.TRUNCATING_DIVIDE_TYPECODE;
   bool typeEquals(other) => other is HTruncatingDivide;
   bool dataEquals(HInstruction other) => true;
 }
 
 
 // TODO(floitsch): Should HBinaryArithmetic really be the super class of
 // HBinaryBitOp?
-class HBinaryBitOp extends HBinaryArithmetic {
+abstract class HBinaryBitOp extends HBinaryArithmetic {
   HBinaryBitOp(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
 
   HType computeTypeFromInputTypes(HTypeMap types) {
     // All bitwise operations on primitive types either produce an
     // integer or throw an error.
     if (left.isPrimitive(types)) return HType.INTEGER;
     return HType.UNKNOWN;
   }
 
@@ skipping 84 matching lines @@
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitBitXor(this);
 
   BinaryOperation operation(ConstantSystem constantSystem)
       => constantSystem.bitXor;
   int typeCode() => HInstruction.BIT_XOR_TYPECODE;
   bool typeEquals(other) => other is HBitXor;
   bool dataEquals(HInstruction other) => true;
 }
 
-class HInvokeUnary extends HInvokeStatic {
+abstract class HInvokeUnary extends HInvokeStatic {
   HInvokeUnary(HStatic target, HInstruction input)
       : super(<HInstruction>[target, input]);
 
   HInstruction get operand => inputs[1];
 
   void prepareGvn(HTypeMap types) {
     // A unary arithmetic expression can take part in global value
     // numbering and does not have any side-effects if its input is a
     // number.
     if (isBuiltin(types)) {
@@ skipping 309 matching lines @@
     assert(isLogicalOperator());
     if (logicalOperatorType == IS_AND) return "&&";
     assert(logicalOperatorType == IS_OR);
     return "||";
   }
 
   toString() => 'phi';
   accept(HVisitor visitor) => visitor.visitPhi(this);
 }
 
-class HRelational extends HInvokeBinary {
+abstract class HRelational extends HInvokeBinary {
   bool usesBoolifiedInterceptor = false;
   HRelational(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
 
   void prepareGvn(HTypeMap types) {
     // Relational expressions can take part in global value numbering
     // and do not have any side-effects if we know all the inputs are
     // numbers. This can be improved for at least equality.
     if (isBuiltin(types)) {
       clearAllSideEffects();
@@ skipping 717 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);
 }