Remove most superfluous getter arguments from dart2js.

dart/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 328 matching lines @@
     assert(block !== null);
     return start.id <= block.id && block.id <= end.id;
   }
 }
 
 class SubExpression extends SubGraph {
   const SubExpression(HBasicBlock start, HBasicBlock end)
       : super(start, end);
 
   /** Find the condition expression if this sub-expression is a condition. */
-  HInstruction get conditionExpression() {
+  HInstruction get conditionExpression {
     HInstruction last = end.last;
     if (last is HConditionalBranch || last is HSwitch) return last.inputs[0];
     return null;
   }
 }
 
 class HInstructionList {
   HInstruction first = null;
   HInstruction last = null;
 
@@ skipping 108 matching lines @@
   }
 
   void setBlockFlow(HBlockInformation blockInfo, HBasicBlock continuation) {
     blockFlow = new HBlockFlow(blockInfo, continuation);
   }
 
   bool isLabeledBlock() =>
     blockFlow !== null &&
     blockFlow.body is HLabeledBlockInformation;
 
-  HBasicBlock get enclosingLoopHeader() {
+  HBasicBlock get enclosingLoopHeader {
     if (isLoopHeader()) return this;
     return parentLoopHeader;
   }
 
   bool hasBailoutTargets() => !bailoutTargets.isEmpty();
 
   void open() {
     assert(isNew());
     status = STATUS_OPEN;
   }
@@ skipping 557 matching lines @@
   }
 }
 
 class HBoolify extends HInstruction {
   HBoolify(HInstruction value) : super(<HInstruction>[value]);
   void prepareGvn(HTypeMap types) {
     assert(!hasSideEffects(types));
     setUseGvn();
   }
 
-  HType get guaranteedType() => HType.BOOLEAN;
+  HType get guaranteedType => HType.BOOLEAN;
 
   accept(HVisitor visitor) => visitor.visitBoolify(this);
   int typeCode() => 0;
   bool typeEquals(other) => other is HBoolify;
   bool dataEquals(HInstruction other) => true;
 }
 
 /**
  * A [HCheck] instruction is an instruction that might do a dynamic
  * check at runtime on another instruction. To have proper instruction
  * dependencies in the graph, instructions that depend on the check
  * being done reference the [HCheck] instruction instead of the
  * instruction itself.
  */
 abstract class HCheck extends HInstruction {
   HCheck(inputs) : super(inputs);
-  HInstruction get checkedInput() => inputs[0];
+  HInstruction get checkedInput => inputs[0];
   bool isStatement(HTypeMap types) => true;
   void prepareGvn(HTypeMap types) {
     assert(!hasSideEffects(types));
     setUseGvn();
   }
 }
 
 class HBailoutTarget extends HInstruction {
   final int state;
   bool isEnabled = false;
@@ skipping 12 matching lines @@
   bool dataEquals(HBailoutTarget other) => other.state == state;
 }
 
 class HTypeGuard extends HCheck {
   final HType guardedType;
   bool isEnabled = false;
 
   HTypeGuard(this.guardedType, HInstruction guarded, HInstruction bailoutTarget)
       : super(<HInstruction>[guarded, bailoutTarget]);
 
-  HInstruction get guarded() => inputs[0];
-  HInstruction get checkedInput() => guarded;
-  HBailoutTarget get bailoutTarget() => inputs[1];
-  int get state() => bailoutTarget.state;
+  HInstruction get guarded => inputs[0];
+  HInstruction get checkedInput => guarded;
+  HBailoutTarget get bailoutTarget => inputs[1];
+  int get state => bailoutTarget.state;
 
   HType computeTypeFromInputTypes(HTypeMap types) {
     return isEnabled ? guardedType : types[guarded];
   }
 
-  HType get guaranteedType() => isEnabled ? guardedType : HType.UNKNOWN;
+  HType get guaranteedType => isEnabled ? guardedType : HType.UNKNOWN;
 
   bool isControlFlow() => true;
 
   bool isStatement(HTypeMap types) => isEnabled;
 
   accept(HVisitor visitor) => visitor.visitTypeGuard(this);
   int typeCode() => 1;
   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;
   /**
    * 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];
+  HInstruction get length => inputs[1];
+  HInstruction get index => inputs[0];
   bool isControlFlow() => true;
 
-  HType get guaranteedType() => HType.INTEGER;
+  HType get guaranteedType => HType.INTEGER;
 
   accept(HVisitor visitor) => visitor.visitBoundsCheck(this);
   int typeCode() => 2;
   bool typeEquals(other) => other is HBoundsCheck;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HIntegerCheck extends HCheck {
   bool alwaysFalse = false;
 
   HIntegerCheck(value) : super(<HInstruction>[value]);
 
-  HInstruction get value() => inputs[0];
+  HInstruction get value => inputs[0];
   bool isControlFlow() => true;
 
-  HType get guaranteedType() => HType.INTEGER;
+  HType get guaranteedType => HType.INTEGER;
 
   HType computeDesiredTypeForInput(HInstruction input, HTypeMap types) {
     // If the desired type of the input is already a number, we want
     // to specialize it to an integer.
     return input.isNumber(types)
       ? HType.INTEGER
       : super.computeDesiredTypeForInput(input, types);
   }
 
   accept(HVisitor visitor) => visitor.visitIntegerCheck(this);
   int typeCode() => 3;
   bool typeEquals(other) => other is HIntegerCheck;
   bool dataEquals(HInstruction other) => true;
 }
 
 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];
+  HInstruction get condition => inputs[0];
+  HBasicBlock get trueBranch => block.successors[0];
+  HBasicBlock get falseBranch => block.successors[1];
   abstract toString();
 }
 
 class HControlFlow extends HInstruction {
   HControlFlow(inputs) : super(inputs);
   abstract toString();
   void prepareGvn(HTypeMap types) {
     // Control flow does not have side-effects.
   }
   bool isControlFlow() => true;
@@ skipping 13 matching lines @@
   abstract accept(HVisitor visitor);
 }
 
 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];
+  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);
 }
@@ skipping 33 matching lines @@
   static final int INVOKE_STATIC_TYPECODE = 30;
 
   /** The first input must be the target. */
   HInvokeStatic(inputs, [HType knownType = HType.UNKNOWN]) : super(inputs) {
     guaranteedType = knownType;
   }
 
   toString() => 'invoke static: ${element.name}';
   accept(HVisitor visitor) => visitor.visitInvokeStatic(this);
   int typeCode() => INVOKE_STATIC_TYPECODE;
-  Element get element() => target.element;
-  HStatic get target() => inputs[0];
+  Element get element => target.element;
+  HStatic get target => inputs[0];
 
   HType computeDesiredTypeForInput(HInstruction input, HTypeMap types) {
     // TODO(floitsch): we want the target to be a function.
     if (input == target) return HType.UNKNOWN;
     return computeDesiredTypeForNonTargetInput(input, types);
   }
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input,
                                             HTypeMap types) {
     return HType.UNKNOWN;
   }
 }
 
 class HInvokeSuper extends HInvokeStatic {
   final bool isSetter;
   HInvokeSuper(inputs, [this.isSetter = false]) : super(inputs);
   toString() => 'invoke super: ${element.name}';
   accept(HVisitor visitor) => visitor.visitInvokeSuper(this);
 
-  HInstruction get value() {
+  HInstruction get value {
     assert(isSetter);
     // Index 0: the element, index 1: 'this'.
     return inputs[2];
   }
 }
 
 class HInvokeInterceptor extends HInvokeStatic {
   final Selector selector;
   final SourceString name;
   final bool getter;
@@ skipping 79 matching lines @@
   final bool isFinalOrConst;
 
   HFieldGet(SourceString name, LibraryElement library, HInstruction receiver,
             [this.isFinalOrConst = false])
       : super(name, library, <HInstruction>[receiver]);
 
   HFieldGet.withElement(Element element, HInstruction receiver,
                         [this.isFinalOrConst = false])
       : super.withElement(element, <HInstruction>[receiver]);
 
-  HInstruction get receiver() => inputs[0];
+  HInstruction get receiver => inputs[0];
 
   accept(HVisitor visitor) => visitor.visitFieldGet(this);
 
   void prepareGvn(HTypeMap types) {
     setUseGvn();
     clearAllSideEffects();
     if (!isFinalOrConst) setDependsOnSomething();
   }
 
   int typeCode() => 27;
   bool typeEquals(other) => other is HFieldGet;
   bool dataEquals(HFieldGet other) => element == other.element;
   String toString() => "FieldGet ${element == null ? fieldName : element}";
 }
 
 class HFieldSet extends HFieldAccess {
   HFieldSet(SourceString name,
             LibraryElement library,
             HInstruction receiver,
             HInstruction value)
       : super(name, library, <HInstruction>[receiver, value]);
 
   HFieldSet.withElement(Element element,
                         HInstruction receiver,
                         HInstruction value)
       : super.withElement(element, <HInstruction>[receiver, value]);
 
-  HInstruction get receiver() => inputs[0];
-  HInstruction get value() => inputs[1];
+  HInstruction get receiver => inputs[0];
+  HInstruction get value => inputs[1];
   accept(HVisitor visitor) => visitor.visitFieldSet(this);
 
   void prepareGvn(HTypeMap types) {
     // TODO(ngeoffray): implement more fine grained side effects.
     setAllSideEffects();
   }
 
   bool isStatement(HTypeMap types) => true;
   String toString() => "FieldSet ${element == null ? fieldName : element}";
 }
 
 class HLocalGet extends HFieldGet {
   HLocalGet(Element element, HLocalValue local)
       : super.withElement(element, local);
 
   accept(HVisitor visitor) => visitor.visitLocalGet(this);
 
-  HLocalValue get local() => inputs[0];
+  HLocalValue get local => inputs[0];
 
   void prepareGvn(HTypeMap types) {
     setUseGvn();
     // TODO(floitsch): if the variable is not captured then it only depends
     // on assignments to the same variable. Otherwise we need to see if the
     // variable is mutated inside closures.
     setDependsOnSomething();
   }
 }
 
 class HLocalSet extends HFieldSet {
   HLocalSet(Element element, HLocalValue local, HInstruction value)
       : super.withElement(element, local, value);
 
   accept(HVisitor visitor) => visitor.visitLocalSet(this);
 
-  HLocalValue get local() => inputs[0];
+  HLocalValue get local => inputs[0];
 
   void prepareGvn(HTypeMap types) {
     // TODO(floitsch): implement more fine grained side effects.
     setAllSideEffects();
   }
 }
 
 class HForeign extends HInstruction {
   final DartString code;
   final HType foreignType;
@@ skipping 11 matching lines @@
 
   static HType computeTypeFromDeclaredType(DartString declaredType) {
     if (declaredType.slowToString() == 'bool') return HType.BOOLEAN;
     if (declaredType.slowToString() == 'int') return HType.INTEGER;
     if (declaredType.slowToString() == 'double') return HType.DOUBLE;
     if (declaredType.slowToString() == 'num') return HType.NUMBER;
     if (declaredType.slowToString() == 'String') return HType.STRING;
     return HType.UNKNOWN;
   }
 
-  HType get guaranteedType() => foreignType;
+  HType get guaranteedType => foreignType;
 
   bool isStatement(HTypeMap types) => _isStatement;
 }
 
 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 {
   HInvokeBinary(HStatic target, HInstruction left, HInstruction right)
       : super(<HInstruction>[target, left, right]);
 
-  HInstruction get left() => inputs[1];
-  HInstruction get right() => inputs[2];
+  HInstruction get left => inputs[1];
+  HInstruction get right => inputs[2];
 
   abstract BinaryOperation get operation();
   abstract isBuiltin(HTypeMap types);
 }
 
 class HBinaryArithmetic extends HInvokeBinary {
   HBinaryArithmetic(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
 
   void prepareGvn(HTypeMap types) {
@@ skipping 50 matching lines @@
 
   // TODO(1603): The class should be marked as abstract.
   abstract BinaryOperation get operation();
 }
 
 class HAdd extends HBinaryArithmetic {
   HAdd(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitAdd(this);
 
-  AddOperation get operation() => const AddOperation();
+  AddOperation get operation => const AddOperation();
   int typeCode() => 5;
   bool typeEquals(other) => other is HAdd;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HDivide extends HBinaryArithmetic {
   HDivide(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitDivide(this);
 
   HType computeTypeFromInputTypes(HTypeMap types) {
     if (left.isNumber(types)) return HType.DOUBLE;
     return HType.UNKNOWN;
   }
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input,
                                             HTypeMap types) {
     // A division can never return an integer. So don't ask for integer inputs.
     if (isInteger(types)) return HType.UNKNOWN;
     return super.computeDesiredTypeForNonTargetInput(input, types);
   }
 
-  DivideOperation get operation() => const DivideOperation();
+  DivideOperation get operation => const DivideOperation();
   int typeCode() => 6;
   bool typeEquals(other) => other is HDivide;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HModulo extends HBinaryArithmetic {
   HModulo(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitModulo(this);
 
-  ModuloOperation get operation() => const ModuloOperation();
+  ModuloOperation get operation => const ModuloOperation();
   int typeCode() => 7;
   bool typeEquals(other) => other is HModulo;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HMultiply extends HBinaryArithmetic {
   HMultiply(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitMultiply(this);
 
-  MultiplyOperation get operation() => const MultiplyOperation();
+  MultiplyOperation get operation => const MultiplyOperation();
   int typeCode() => 8;
   bool typeEquals(other) => other is HMultiply;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HSubtract extends HBinaryArithmetic {
   HSubtract(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitSubtract(this);
 
-  SubtractOperation get operation() => const SubtractOperation();
+  SubtractOperation get operation => const SubtractOperation();
   int typeCode() => 9;
   bool typeEquals(other) => other is HSubtract;
   bool dataEquals(HInstruction other) => true;
 }
 
 /**
  * An [HSwitch] instruction has one input for the incoming
  * value, and one input per constant that it can switch on.
  * Its block has one successor per constant, and one for the default.
  */
 class HSwitch extends HControlFlow {
   HSwitch(List<HInstruction> inputs) : super(inputs);
 
   HConstant constant(int index) => inputs[index + 1];
-  HInstruction get expression() => inputs[0];
+  HInstruction get expression => inputs[0];
 
   /**
    * Provides the target to jump to if none of the constants match
    * the expression. If the switch had no default case, this is the
    * following join-block.
    */
-  HBasicBlock get defaultTarget() => block.successors.last();
+  HBasicBlock get defaultTarget => block.successors.last();
 
   accept(HVisitor visitor) => visitor.visitSwitch(this);
 
   String toString() => "HSwitch cases = $inputs";
 }
 
 class HTruncatingDivide extends HBinaryArithmetic {
   HTruncatingDivide(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitTruncatingDivide(this);
 
-  TruncatingDivideOperation get operation()
+  TruncatingDivideOperation get operation
       => const TruncatingDivideOperation();
   int typeCode() => 10;
   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 {
@@ skipping 36 matching lines @@
   // 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) {
     if (!left.isNumber(types) || !right.isConstantInteger()) return false;
     HConstant rightConstant = right;
     IntConstant intConstant = rightConstant.constant;
     int count = intConstant.value;
     return count >= 0 && count <= 31;
   }
 
-  ShiftLeftOperation get operation() => const ShiftLeftOperation();
+  ShiftLeftOperation get operation => const ShiftLeftOperation();
   int typeCode() => 11;
   bool typeEquals(other) => other is HShiftLeft;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HShiftRight extends HBinaryBitOp {
   HShiftRight(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitShiftRight(this);
 
   // Shift right cannot be mapped to the native operator easily.
   bool isBuiltin(HTypeMap types) => false;
 
-  ShiftRightOperation get operation() => const ShiftRightOperation();
+  ShiftRightOperation get operation => const ShiftRightOperation();
   int typeCode() => 12;
   bool typeEquals(other) => other is HShiftRight;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HBitOr extends HBinaryBitOp {
   HBitOr(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitBitOr(this);
 
-  BitOrOperation get operation() => const BitOrOperation();
+  BitOrOperation get operation => const BitOrOperation();
   int typeCode() => 13;
   bool typeEquals(other) => other is HBitOr;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HBitAnd extends HBinaryBitOp {
   HBitAnd(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitBitAnd(this);
 
-  BitAndOperation get operation() => const BitAndOperation();
+  BitAndOperation get operation => const BitAndOperation();
   int typeCode() => 14;
   bool typeEquals(other) => other is HBitAnd;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HBitXor extends HBinaryBitOp {
   HBitXor(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitBitXor(this);
 
-  BitXorOperation get operation() => const BitXorOperation();
+  BitXorOperation get operation => const BitXorOperation();
   int typeCode() => 15;
   bool typeEquals(other) => other is HBitXor;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HInvokeUnary extends HInvokeStatic {
   HInvokeUnary(HStatic target, HInstruction input)
       : super(<HInstruction>[target, input]);
 
-  HInstruction get operand() => inputs[1];
+  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)) {
       clearAllSideEffects();
       setUseGvn();
     } else {
       setAllSideEffects();
@@ skipping 21 matching lines @@
 
   HType computeLikelyType(HTypeMap types) => HType.NUMBER;
 
   abstract UnaryOperation get operation();
 }
 
 class HNegate extends HInvokeUnary {
   HNegate(HStatic target, HInstruction input) : super(target, input);
   accept(HVisitor visitor) => visitor.visitNegate(this);
 
-  NegateOperation get operation() => const NegateOperation();
+  NegateOperation get operation => const NegateOperation();
   int typeCode() => 16;
   bool typeEquals(other) => other is HNegate;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HBitNot extends HInvokeUnary {
   HBitNot(HStatic target, HInstruction input) : super(target, input);
   accept(HVisitor visitor) => visitor.visitBitNot(this);
 
   HType computeTypeFromInputTypes(HTypeMap types) {
     // All bitwise operations on primitive types either produce an
     // integer or throw an error.
     if (operand.isPrimitive(types)) return HType.INTEGER;
     return HType.UNKNOWN;
   }
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input,
                                             HTypeMap types) {
     HType propagatedType = types[this];
     // Bit operations only work on integers. If there is no desired output
     // type or if it as a number we want to get an integer as input.
     if (propagatedType.isUnknown() || propagatedType.isNumber()) {
       return HType.INTEGER;
     }
     return HType.UNKNOWN;
   }
 
-  BitNotOperation get operation() => const BitNotOperation();
+  BitNotOperation get operation => const BitNotOperation();
   int typeCode() => 17;
   bool typeEquals(other) => other is HBitNot;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HExit extends HControlFlow {
   HExit() : super(const <HInstruction>[]);
   toString() => 'exit';
   accept(HVisitor visitor) => visitor.visitExit(this);
 }
@@ skipping 26 matching lines @@
   accept(HVisitor visitor) => visitor.visitContinue(this);
 }
 
 class HTry extends HControlFlow {
   HParameterValue exception;
   HBasicBlock catchBlock;
   HBasicBlock finallyBlock;
   HTry() : super(const <HInstruction>[]);
   toString() => 'try';
   accept(HVisitor visitor) => visitor.visitTry(this);
-  HBasicBlock get joinBlock() => this.block.successors.last();
+  HBasicBlock get joinBlock => this.block.successors.last();
 }
 
 class HIf extends HConditionalBranch {
   HBlockFlow blockInformation = null;
   HIf(HInstruction condition) : super(<HInstruction>[condition]);
   toString() => 'if';
   accept(HVisitor visitor) => visitor.visitIf(this);
 
-  HBasicBlock get thenBlock() {
+  HBasicBlock get thenBlock {
     assert(block.dominatedBlocks[0] === block.successors[0]);
     return block.successors[0];
   }
 
-  HBasicBlock get elseBlock() {
+  HBasicBlock get elseBlock {
     assert(block.dominatedBlocks[1] === block.successors[1]);
     return block.successors[1];
   }
 
-  HBasicBlock get joinBlock() => blockInformation.continuation;
+  HBasicBlock get joinBlock => blockInformation.continuation;
 }
 
 class HLoopBranch extends HConditionalBranch {
   static final int CONDITION_FIRST_LOOP = 0;
   static final int DO_WHILE_LOOP = 1;
 
   final int kind;
   HLoopBranch(HInstruction condition, [this.kind = CONDITION_FIRST_LOOP])
       : super(<HInstruction>[condition]);
   toString() => 'loop-branch';
@@ skipping 10 matching lines @@
   HConstant.internal(this.constant, HType this.constantType)
       : super(<HInstruction>[]);
 
   void prepareGvn(HTypeMap types) {
     assert(!hasSideEffects(types));
   }
 
   toString() => 'literal: $constant';
   accept(HVisitor visitor) => visitor.visitConstant(this);
 
-  HType get guaranteedType() => constantType;
+  HType get guaranteedType => constantType;
 
   bool isConstant() => true;
   bool isConstantBoolean() => constant.isBool();
   bool isConstantNull() => constant.isNull();
   bool isConstantNumber() => constant.isNum();
   bool isConstantInteger() => constant.isInt();
   bool isConstantString() => constant.isString();
   bool isConstantList() => constant.isList();
   bool isConstantMap() => constant.isMap();
   bool isConstantFalse() => constant.isFalse();
   bool isConstantTrue() => constant.isTrue();
 
   // Maybe avoid this if the literal is big?
   bool isCodeMotionInvariant() => true;
 }
 
 class HNot extends HInstruction {
   HNot(HInstruction value) : super(<HInstruction>[value]);
   void prepareGvn(HTypeMap types) {
     assert(!hasSideEffects(types));
     setUseGvn();
   }
 
-  HType get guaranteedType() => HType.BOOLEAN;
+  HType get guaranteedType => HType.BOOLEAN;
 
   // 'Not' only works on booleans. That's what we want as input.
   HType computeDesiredTypeForInput(HInstruction input, HTypeMap types) {
     return HType.BOOLEAN;
   }
 
   accept(HVisitor visitor) => visitor.visitNot(this);
   int typeCode() => 18;
   bool typeEquals(other) => other is HNot;
   bool dataEquals(HInstruction other) => true;
@@ skipping 133 matching lines @@
     } else {
       setAllSideEffects();
     }
   }
 
   HType computeTypeFromInputTypes(HTypeMap types) {
     if (left.isNumber(types) || usesBoolifiedInterceptor) return HType.BOOLEAN;
     return HType.UNKNOWN;
   }
 
-  HType get guaranteedType() {
+  HType get guaranteedType {
     if (usesBoolifiedInterceptor) return HType.BOOLEAN;
     return HType.UNKNOWN;
   }
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input,
                                             HTypeMap types) {
     HType propagatedType = types[this];
     // For all relational operations exept HEquals, we expect to get numbers
     // only. With numbers the outgoing type is a boolean. If something else
     // is desired, then numbers are incorrect, though.
@@ skipping 52 matching lines @@
     if (input == left && left.isIndexablePrimitive(types)) {
       return HType.READABLE_ARRAY;
     }
     // String equality testing is much more common than array equality testing.
     if (input == right && right.isIndexablePrimitive(types)) {
       return HType.STRING;
     }
     return HType.UNKNOWN;
   }
 
-  EqualsOperation get operation() => const EqualsOperation();
+  EqualsOperation get operation => const EqualsOperation();
   int typeCode() => 19;
   bool typeEquals(other) => other is HEquals;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HIdentity extends HRelational {
   HIdentity(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitIdentity(this);
 
   bool isBuiltin(HTypeMap types) => true;
 
-  HType get guaranteedType() => HType.BOOLEAN;
+  HType get guaranteedType => HType.BOOLEAN;
   HType computeTypeFromInputTypes(HTypeMap types)
       => HType.BOOLEAN;
   // Note that the identity operator really does not care for its input types.
   HType computeDesiredTypeForInput(HInstruction input, HTypeMap types)
       => HType.UNKNOWN;
 
-  IdentityOperation get operation() => const IdentityOperation();
+  IdentityOperation get operation => const IdentityOperation();
   int typeCode() => 20;
   bool typeEquals(other) => other is HIdentity;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HGreater extends HRelational {
   HGreater(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitGreater(this);
 
-  GreaterOperation get operation() => const GreaterOperation();
+  GreaterOperation get operation => const GreaterOperation();
   int typeCode() => 21;
   bool typeEquals(other) => other is HGreater;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HGreaterEqual extends HRelational {
   HGreaterEqual(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitGreaterEqual(this);
 
-  GreaterEqualOperation get operation() => const GreaterEqualOperation();
+  GreaterEqualOperation get operation => const GreaterEqualOperation();
   int typeCode() => 22;
   bool typeEquals(other) => other is HGreaterEqual;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HLess extends HRelational {
   HLess(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitLess(this);
 
-  LessOperation get operation() => const LessOperation();
+  LessOperation get operation => const LessOperation();
   int typeCode() => 23;
   bool typeEquals(other) => other is HLess;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HLessEqual extends HRelational {
   HLessEqual(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitLessEqual(this);
 
-  LessEqualOperation get operation() => const LessEqualOperation();
+  LessEqualOperation get operation => const LessEqualOperation();
   int typeCode() => 24;
   bool typeEquals(other) => other is HLessEqual;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HReturn extends HControlFlow {
   HReturn(value) : super(<HInstruction>[value]);
   toString() => 'return';
   accept(HVisitor visitor) => visitor.visitReturn(this);
 }
@@ skipping 35 matching lines @@
   bool typeEquals(other) => other is HStaticStore;
   bool dataEquals(HStaticStore other) => element == other.element;
   bool isStatement(HTypeMap types) => true;
 }
 
 class HLiteralList extends HInstruction {
   HLiteralList(inputs) : super(inputs);
   toString() => 'literal list';
   accept(HVisitor visitor) => visitor.visitLiteralList(this);
 
-  HType get guaranteedType() => HType.MUTABLE_ARRAY;
+  HType get guaranteedType => HType.MUTABLE_ARRAY;
 
   void prepareGvn(HTypeMap types) {
     assert(!hasSideEffects(types));
   }
 }
 
 class HIndex extends HInvokeStatic {
   HIndex(HStatic target, HInstruction receiver, HInstruction index)
       : super(<HInstruction>[target, receiver, index]);
   toString() => 'index operator';
   accept(HVisitor visitor) => visitor.visitIndex(this);
 
   void prepareGvn(HTypeMap types) {
     if (isBuiltin(types)) {
       clearAllSideEffects();
     } else {
       setAllSideEffects();
     }
   }
 
-  HInstruction get receiver() => inputs[1];
-  HInstruction get index() => inputs[2];
+  HInstruction get receiver => inputs[1];
+  HInstruction get index => inputs[2];
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input,
                                             HTypeMap types) {
     if (input == receiver &&
         (index.isTypeUnknown(types) || index.isNumber(types))) {
       return HType.INDEXABLE_PRIMITIVE;
     }
     // The index should be an int when the receiver is a string or array.
     // However it turns out that inserting an integer check in the optimized
     // version is cheaper than having another bailout case. This is true,
     // because the integer check will simply throw if it fails.
     return HType.UNKNOWN;
   }
 
   bool isBuiltin(HTypeMap types)
       => receiver.isIndexablePrimitive(types) && index.isInteger(types);
 }
 
 class HIndexAssign extends HInvokeStatic {
   HIndexAssign(HStatic target,
                HInstruction receiver,
                HInstruction index,
                HInstruction value)
       : super(<HInstruction>[target, receiver, index, value]);
   toString() => 'index assign operator';
   accept(HVisitor visitor) => visitor.visitIndexAssign(this);
 
-  HInstruction get receiver() => inputs[1];
-  HInstruction get index() => inputs[2];
-  HInstruction get value() => inputs[3];
+  HInstruction get receiver => inputs[1];
+  HInstruction get index => inputs[2];
+  HInstruction get value => inputs[3];
 
   // Note, that we don't have a computeTypeFromInputTypes, since [HIndexAssign]
   // is never used as input.
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input,
                                             HTypeMap types) {
     if (input == receiver &&
         (index.isTypeUnknown(types) || index.isNumber(types))) {
       return HType.MUTABLE_ARRAY;
     }
@@ skipping 13 matching lines @@
   final Type typeExpression;
   final bool nullOk;
 
   HIs.withTypeInfoCall(this.typeExpression, HInstruction expression,
                        HInstruction typeInfo, [this.nullOk = false])
     : super(<HInstruction>[expression, typeInfo]);
 
   HIs(this.typeExpression, HInstruction expression, [this.nullOk = false])
      : super(<HInstruction>[expression]);
 
-  HInstruction get expression() => inputs[0];
+  HInstruction get expression => inputs[0];
 
-  HInstruction get typeInfoCall() => inputs[1];
+  HInstruction get typeInfoCall => inputs[1];
 
-  HType get guaranteedType() => HType.BOOLEAN;
+  HType get guaranteedType => HType.BOOLEAN;
 
   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;
 
   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)
       : this(type, input, CAST_TYPE_CHECK);
 
 
-  bool get isChecked() => kind != NO_CHECK;
-  bool get isCheckedModeCheck() => kind == CHECKED_MODE_CHECK;
-  bool get isArgumentTypeCheck() => kind == ARGUMENT_TYPE_CHECK;
-  bool get isCastTypeCheck() => kind == CAST_TYPE_CHECK;
+  bool get isChecked => kind != NO_CHECK;
+  bool get isCheckedModeCheck => kind == CHECKED_MODE_CHECK;
+  bool get isArgumentTypeCheck => kind == ARGUMENT_TYPE_CHECK;
+  bool get isCastTypeCheck => kind == CAST_TYPE_CHECK;
 
-  HType get guaranteedType() => type;
+  HType get guaranteedType => type;
 
   accept(HVisitor visitor) => visitor.visitTypeConversion(this);
 
   bool isStatement(HTypeMap types) => kind == ARGUMENT_TYPE_CHECK;
   bool isControlFlow() => kind == ARGUMENT_TYPE_CHECK;
 
   int typeCode() => 28;
   bool typeEquals(HInstruction other) => other is HTypeConversion;
   bool dataEquals(HTypeConversion other) {
     return type == other.type && kind == other.kind;
   }
 }
 
 class HStringConcat extends HInstruction {
   final Node node;
   HStringConcat(HInstruction left, HInstruction right, this.node)
       : super(<HInstruction>[left, right]);
-  HType get guaranteedType() => HType.STRING;
+  HType get guaranteedType => HType.STRING;
 
-  HInstruction get left() => inputs[0];
-  HInstruction get right() => inputs[1];
+  HInstruction get left => inputs[0];
+  HInstruction get right => inputs[1];
 
   accept(HVisitor visitor) => visitor.visitStringConcat(this);
   toString() => "string concat";
 }
 
 /** Non-block-based (aka. traditional) loop information. */
 class HLoopInformation {
   final HBasicBlock header;
   final List<HBasicBlock> blocks;
   final List<HBasicBlock> backEdges;
@@ skipping 110 matching lines @@
 
 
 /**
  * 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;
+  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;
+  HBasicBlock get start => subExpression.start;
+  HBasicBlock get end => subExpression.end;
 
-  HInstruction get conditionExpression() => subExpression.conditionExpression;
+  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;
+  HBasicBlock get start => statements[0].start;
+  HBasicBlock get end => statements.last().end;
 
   bool accept(HStatementInformationVisitor visitor) =>
     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;
 
   HLabeledBlockInformation.implicit(this.body,
                                     this.target,
                                     [this.isContinue = false])
       : this.labels = const<LabelElement>[];
 
-  HBasicBlock get start() => body.start;
-  HBasicBlock get end() => body.end;
+  HBasicBlock get start => body.start;
+  HBasicBlock get end => body.end;
 
   bool accept(HStatementInformationVisitor visitor) =>
     visitor.visitLabeledBlockInfo(this);
 }
 
 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;
@@ skipping 19 matching lines @@
 
   HLoopBlockInformation(this.kind,
                         this.initializer,
                         this.condition,
                         this.body,
                         this.updates,
                         this.target,
                         this.labels,
                         this.sourcePosition);
 
-  HBasicBlock get start() {
+  HBasicBlock get start {
     if (initializer !== null) return initializer.start;
     if (kind == DO_WHILE_LOOP) {
       return body.start;
     }
     return condition.start;
   }
 
-  HBasicBlock get loopHeader() {
+  HBasicBlock get loopHeader {
     return kind == DO_WHILE_LOOP ? body.start : condition.start;
   }
 
-  HBasicBlock get end() {
+  HBasicBlock get end {
     if (updates !== null) return updates.end;
     if (kind == DO_WHILE_LOOP) {
       return condition.end;
     }
     return body.end;
   }
 
   static int loopType(Node node) {
     return node.accept(const LoopTypeVisitor());
   }
 
   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,
                       this.elseGraph);
 
-  HBasicBlock get start() => condition.start;
-  HBasicBlock get end() => elseGraph === null ? thenGraph.end : elseGraph.end;
+  HBasicBlock get start => condition.start;
+  HBasicBlock get end => elseGraph === null ? thenGraph.end : elseGraph.end;
 
   bool accept(HStatementInformationVisitor visitor) =>
     visitor.visitIfInfo(this);
 }
 
 class HAndOrBlockInformation implements HExpressionInformation {
   final bool isAnd;
   final HExpressionInformation left;
   final HExpressionInformation right;
   HAndOrBlockInformation(this.isAnd,
                          this.left,
                          this.right);
 
-  HBasicBlock get start() => left.start;
-  HBasicBlock get end() => right.end;
+  HBasicBlock get start => left.start;
+  HBasicBlock get end => right.end;
 
   // We don't currently use HAndOrBlockInformation.
-  HInstruction get conditionExpression() {
+  HInstruction get conditionExpression {
     return null;
   }
   bool accept(HExpressionInformationVisitor visitor) =>
     visitor.visitAndOrInfo(this);
 }
 
 class HTryBlockInformation implements HStatementInformation {
   final HStatementInformation body;
   final HParameterValue catchVariable;
   final HStatementInformation catchBlock;
   final HStatementInformation finallyBlock;
   HTryBlockInformation(this.body,
                        this.catchVariable,
                        this.catchBlock,
                        this.finallyBlock);
 
-  HBasicBlock get start() => body.start;
-  HBasicBlock get end() =>
+  HBasicBlock get start => body.start;
+  HBasicBlock get end =>
       finallyBlock === null ? catchBlock.end : finallyBlock.end;
 
   bool accept(HStatementInformationVisitor visitor) =>
     visitor.visitTryInfo(this);
 }
 
 
 
 class HSwitchBlockInformation implements HStatementInformation {
   final HExpressionInformation expression;
   final List<List<Constant>> matchExpressions;
   final List<HStatementInformation> statements;
   // If the switch has a default, it's the last statement block, which
   // may or may not have other expresions.
   final bool hasDefault;
   final TargetElement target;
   final List<LabelElement> labels;
 
   HSwitchBlockInformation(this.expression,
                           this.matchExpressions,
                           this.statements,
                           this.hasDefault,
                           this.target,
                           this.labels);
 
-  HBasicBlock get start() => expression.start;
-  HBasicBlock get end() {
+  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);
 }