- Change "static final" to "static const" in the lib/ directory.

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.
 
 interface HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBailoutTarget(HBailoutTarget node);
   R visitBitAnd(HBitAnd node);
   R visitBitNot(HBitNot node);
   R visitBitOr(HBitOr node);
@@ skipping 414 matching lines @@
     }
     return false;
   }
 }
 
 class HBasicBlock extends HInstructionList implements Hashable {
   // The [id] must be such that any successor's id is greater than
   // 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;
+  static const int STATUS_NEW = 0;
+  static const int STATUS_OPEN = 1;
+  static const int STATUS_CLOSED = 2;
   int status = STATUS_NEW;
 
   HInstructionList phis;
 
   HLoopInformation loopInformation = null;
   HBlockFlow blockFlow = null;
   HBasicBlock parentLoopHeader = null;
   List<HBailoutTarget> bailoutTargets;
 
   final List<HBasicBlock> predecessors;
@@ skipping 295 matching lines @@
 
   final List<HInstruction> inputs;
   final List<HInstruction> usedBy;
 
   HBasicBlock block;
   HInstruction previous = null;
   HInstruction next = null;
   int flags = 0;
 
   // Changes flags.
-  static final int FLAG_CHANGES_SOMETHING    = 0;
-  static final int FLAG_CHANGES_COUNT        = FLAG_CHANGES_SOMETHING + 1;
+  static const int FLAG_CHANGES_SOMETHING    = 0;
+  static const int FLAG_CHANGES_COUNT        = FLAG_CHANGES_SOMETHING + 1;
 
   // Depends flags (one for each changes flag).
-  static final int FLAG_DEPENDS_ON_SOMETHING = FLAG_CHANGES_COUNT;
+  static const int FLAG_DEPENDS_ON_SOMETHING = FLAG_CHANGES_COUNT;
 
   // Other flags.
-  static final int FLAG_USE_GVN              = FLAG_DEPENDS_ON_SOMETHING + 1;
+  static const int FLAG_USE_GVN              = FLAG_DEPENDS_ON_SOMETHING + 1;
 
   // Type codes.
-  static final int UNDEFINED_TYPECODE = -1;
-  static final int BOOLIFY_TYPECODE = 0;
-  static final int TYPE_GUARD_TYPECODE = 1;
-  static final int BOUNDS_CHECK_TYPECODE = 2;
-  static final int INTEGER_CHECK_TYPECODE = 3;
-  static final int INVOKE_INTERCEPTOR_TYPECODE = 4;
-  static final int ADD_TYPECODE = 5;
-  static final int DIVIDE_TYPECODE = 6;
-  static final int MODULO_TYPECODE = 7;
-  static final int MULTIPLY_TYPECODE = 8;
-  static final int SUBTRACT_TYPECODE = 9;
-  static final int TRUNCATING_DIVIDE_TYPECODE = 10;
-  static final int SHIFT_LEFT_TYPECODE = 11;
-  static final int SHIFT_RIGHT_TYPECODE = 12;
-  static final int BIT_OR_TYPECODE = 13;
-  static final int BIT_AND_TYPECODE = 14;
-  static final int BIT_XOR_TYPECODE = 15;
-  static final int NEGATE_TYPECODE = 16;
-  static final int BIT_NOT_TYPECODE = 17;
-  static final int NOT_TYPECODE = 18;
-  static final int EQUALS_TYPECODE = 19;
-  static final int IDENTITY_TYPECODE = 20;
-  static final int GREATER_TYPECODE = 21;
-  static final int GREATER_EQUAL_TYPECODE = 22;
-  static final int LESS_TYPECODE = 23;
-  static final int LESS_EQUAL_TYPECODE = 24;
-  static final int STATIC_TYPECODE = 25;
-  static final int STATIC_STORE_TYPECODE = 26;
-  static final int FIELD_GET_TYPECODE = 27;
-  static final int TYPE_CONVERSION_TYPECODE = 28;
-  static final int BAILOUT_TARGET_TYPECODE = 29;
-  static final int INVOKE_STATIC_TYPECODE = 30;
+  static const int UNDEFINED_TYPECODE = -1;
+  static const int BOOLIFY_TYPECODE = 0;
+  static const int TYPE_GUARD_TYPECODE = 1;
+  static const int BOUNDS_CHECK_TYPECODE = 2;
+  static const int INTEGER_CHECK_TYPECODE = 3;
+  static const int INVOKE_INTERCEPTOR_TYPECODE = 4;
+  static const int ADD_TYPECODE = 5;
+  static const int DIVIDE_TYPECODE = 6;
+  static const int MODULO_TYPECODE = 7;
+  static const int MULTIPLY_TYPECODE = 8;
+  static const int SUBTRACT_TYPECODE = 9;
+  static const int TRUNCATING_DIVIDE_TYPECODE = 10;
+  static const int SHIFT_LEFT_TYPECODE = 11;
+  static const int SHIFT_RIGHT_TYPECODE = 12;
+  static const int BIT_OR_TYPECODE = 13;
+  static const int BIT_AND_TYPECODE = 14;
+  static const int BIT_XOR_TYPECODE = 15;
+  static const int NEGATE_TYPECODE = 16;
+  static const int BIT_NOT_TYPECODE = 17;
+  static const int NOT_TYPECODE = 18;
+  static const int EQUALS_TYPECODE = 19;
+  static const int IDENTITY_TYPECODE = 20;
+  static const int GREATER_TYPECODE = 21;
+  static const int GREATER_EQUAL_TYPECODE = 22;
+  static const int LESS_TYPECODE = 23;
+  static const int LESS_EQUAL_TYPECODE = 24;
+  static const int STATIC_TYPECODE = 25;
+  static const int STATIC_STORE_TYPECODE = 26;
+  static const int FIELD_GET_TYPECODE = 27;
+  static const int TYPE_CONVERSION_TYPECODE = 28;
+  static const int BAILOUT_TARGET_TYPECODE = 29;
+  static const int INVOKE_STATIC_TYPECODE = 30;
 
   HInstruction(this.inputs)
       : id = idCounter++,
         usedBy = <HInstruction>[];
 
   int hashCode() => id;
 
   bool getFlag(int position) => (flags & (1 << position)) != 0;
   void setFlag(int position) { flags |= (1 << position); }
   void clearFlag(int position) { flags &= ~(1 << position); }
@@ skipping 348 matching lines @@
 
   bool isStatement(HTypeMap types) => isEnabled;
 
   accept(HVisitor visitor) => visitor.visitTypeGuard(this);
   int typeCode() => HInstruction.TYPE_GUARD_TYPECODE;
   bool typeEquals(other) => other is HTypeGuard;
   bool dataEquals(HTypeGuard other) => guardedType == other.guardedType;
 }
 
 class HBoundsCheck extends HCheck {
-  static final int ALWAYS_FALSE = 0;
-  static final int FULL_CHECK = 1;
-  static final int ALWAYS_ABOVE_ZERO = 2;
-  static final int ALWAYS_TRUE = 3;
+  static const int ALWAYS_FALSE = 0;
+  static const int FULL_CHECK = 1;
+  static const int ALWAYS_ABOVE_ZERO = 2;
+  static const int ALWAYS_TRUE = 3;
   /**
    * Details which tests have been done statically during compilation.
    * Default is that all checks must be performed dynamically.
    */
   int staticChecks = FULL_CHECK;
 
   HBoundsCheck(length, index) : super(<HInstruction>[length, index]);
 
   HInstruction get length => inputs[1];
   HInstruction get index => inputs[0];
@@ skipping 49 matching lines @@
   bool isStatement(HTypeMap types) => true;
 }
 
 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 final int ARGUMENTS_OFFSET = 1;
+  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 {
   final Selector selector;
   Element element;
 
   HInvokeDynamic(this.selector, this.element, List<HInstruction> inputs)
@@ skipping 674 matching lines @@
 
   HBasicBlock get elseBlock {
     assert(block.dominatedBlocks[1] === block.successors[1]);
     return block.successors[1];
   }
 
   HBasicBlock get joinBlock => blockInformation.continuation;
 }
 
 class HLoopBranch extends HConditionalBranch {
-  static final int CONDITION_FIRST_LOOP = 0;
-  static final int DO_WHILE_LOOP = 1;
+  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 kind === DO_WHILE_LOOP;
   }
@@ skipping 76 matching lines @@
 
 class HThis extends HParameterValue {
   HThis([HType type = HType.UNKNOWN]) : super(null) {
     guaranteedType = type;
   }
   toString() => 'this';
   accept(HVisitor visitor) => visitor.visitThis(this);
 }
 
 class HPhi extends HInstruction {
-  static final IS_NOT_LOGICAL_OPERATOR = 0;
-  static final IS_AND = 1;
-  static final IS_OR = 2;
+  static const IS_NOT_LOGICAL_OPERATOR = 0;
+  static const IS_AND = 1;
+  static const IS_OR = 2;
 
   int logicalOperatorType = IS_NOT_LOGICAL_OPERATOR;
 
   // The order of the [inputs] must correspond to the order of the
   // predecessor-edges. That is if an input comes from the first predecessor
   // of the surrounding block, then the input must be the first in the [HPhi].
   HPhi(Element element, List<HInstruction> inputs) : super(inputs) {
     sourceElement = element;
   }
   HPhi.noInputs(Element element) : this(element, <HInstruction>[]);
@@ skipping 378 matching lines @@
 
   accept(HVisitor visitor) => visitor.visitIs(this);
 
   toString() => "$expression is $typeExpression";
 }
 
 class HTypeConversion extends HCheck {
   HType type;
   final int kind;
 
-  static final int NO_CHECK = 0;
-  static final int CHECKED_MODE_CHECK = 1;
-  static final int ARGUMENT_TYPE_CHECK = 2;
-  static final int CAST_TYPE_CHECK = 3;
+  static const int NO_CHECK = 0;
+  static const int CHECKED_MODE_CHECK = 1;
+  static const int ARGUMENT_TYPE_CHECK = 2;
+  static const int CAST_TYPE_CHECK = 3;
 
   HTypeConversion(this.type, HInstruction input, [this.kind = NO_CHECK])
       : super(<HInstruction>[input]) {
     sourceElement = input.sourceElement;
   }
   HTypeConversion.checkedModeCheck(HType type, HInstruction input)
       : this(type, input, CHECKED_MODE_CHECK);
   HTypeConversion.argumentTypeCheck(HType type, HInstruction input)
       : this(type, input, ARGUMENT_TYPE_CHECK);
   HTypeConversion.castCheck(HType type, HInstruction input)
@@ skipping 222 matching lines @@
 class LoopTypeVisitor extends AbstractVisitor {
   const LoopTypeVisitor();
   int visitNode(Node node) => HLoopBlockInformation.NOT_A_LOOP;
   int visitWhile(While node) => HLoopBlockInformation.WHILE_LOOP;
   int visitFor(For node) => HLoopBlockInformation.FOR_LOOP;
   int visitDoWhile(DoWhile node) => HLoopBlockInformation.DO_WHILE_LOOP;
   int visitForIn(ForIn node) => HLoopBlockInformation.FOR_IN_LOOP;
 }
 
 class HLoopBlockInformation implements HStatementInformation {
-  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;
-  static final int NOT_A_LOOP = -1;
+  static const int WHILE_LOOP = 0;
+  static const int FOR_LOOP = 1;
+  static const int DO_WHILE_LOOP = 2;
+  static const int FOR_IN_LOOP = 3;
+  static const int NOT_A_LOOP = -1;
 
   final int kind;
   final HExpressionInformation initializer;
   final HExpressionInformation condition;
   final HStatementInformation body;
   final HExpressionInformation updates;
   final TargetElement target;
   final List<LabelElement> labels;
   final Node sourcePosition;
 
@@ skipping 108 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);
 }