Remove most superfluous getter arguments from dart2js.

dart/lib/compiler/implementation/js/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 NodeVisitor<T> {
   T visitProgram(Program node);
 
   T visitBlock(Block node);
   T visitExpressionStatement(ExpressionStatement node);
   T visitEmptyStatement(EmptyStatement node);
@@ skipping 178 matching lines @@
 }
 
 class If extends Statement {
   final Expression condition;
   final Node then;
   final Node otherwise;
 
   If(this.condition, this.then, this.otherwise);
   If.then(this.condition, this.then) : this.otherwise = new EmptyStatement();
 
-  bool get hasElse() => otherwise is !EmptyStatement;
+  bool get hasElse => otherwise is !EmptyStatement;
 
   accept(NodeVisitor visitor) => visitor.visitIf(this);
 
   void visitChildren(NodeVisitor visitor) {
     condition.accept(visitor);
     then.accept(visitor);
     otherwise.accept(visitor);
   }
 }
 
@@ skipping 227 matching lines @@
   LiteralExpression.withData(this.template, this.inputs);
 
   accept(NodeVisitor visitor) => visitor.visitLiteralExpression(this);
 
   void visitChildren(NodeVisitor visitor) {
     for (Expression expr in inputs) expr.accept(visitor);
   }
 
   // Code that uses JS must take care of operator precedences, and
   // put parenthesis if needed.
-  int get precedenceLevel() => PRIMARY;
+  int get precedenceLevel => PRIMARY;
 }
 
 /**
  * [VariableDeclarationList] is a subclass of [Expression] to simplify the
  * AST.
  */
 class VariableDeclarationList extends Expression {
   final List<VariableInitialization> declarations;
 
   VariableDeclarationList(this.declarations);
 
   accept(NodeVisitor visitor) => visitor.visitVariableDeclarationList(this);
 
   void visitChildren(NodeVisitor visitor) {
     for (VariableInitialization declaration in declarations) {
       declaration.accept(visitor);
     }
   }
 
-  int get precedenceLevel() => EXPRESSION;
+  int get precedenceLevel => EXPRESSION;
 }
 
 class Sequence extends Expression {
   final List<Expression> expressions;
 
   Sequence(this.expressions);
 
   accept(NodeVisitor visitor) => visitor.visitSequence(this);
 
   void visitChildren(NodeVisitor visitor) {
     for (Expression expr in expressions) expr.accept(visitor);
   }
 
-  int get precedenceLevel() => EXPRESSION;
+  int get precedenceLevel => EXPRESSION;
 }
 
 class Assignment extends Expression {
   final Expression leftHandSide;
   // Null, if the assignment is not compound.
   final VariableReference compoundTarget;
   final Expression value;  // May be null, for [VariableInitialization]s.
 
   Assignment(this.leftHandSide, this.value) : compoundTarget = null;
   Assignment.compound(this.leftHandSide, String op, this.value)
       : compoundTarget = new VariableUse(op);
 
-  int get precedenceLevel() => ASSIGNMENT;
+  int get precedenceLevel => ASSIGNMENT;
 
-  bool get isCompound() => compoundTarget != null;
-  String get op() => compoundTarget == null ? null : compoundTarget.name;
+  bool get isCompound => compoundTarget != null;
+  String get op => compoundTarget == null ? null : compoundTarget.name;
 
   accept(NodeVisitor visitor) => visitor.visitAssignment(this);
 
   void visitChildren(NodeVisitor visitor) {
     leftHandSide.accept(visitor);
     if (compoundTarget != null) compoundTarget.accept(visitor);
     if (value != null) value.accept(visitor);
   }
 }
 
 class VariableInitialization extends Assignment {
   /** [value] may be null. */
   VariableInitialization(VariableDeclaration declaration, Expression value)
       : super(declaration, value);
 
-  VariableDeclaration get declaration() => leftHandSide;
+  VariableDeclaration get declaration => leftHandSide;
 
   accept(NodeVisitor visitor) => visitor.visitVariableInitialization(this);
 }
 
 class Conditional extends Expression {
   final Expression condition;
   final Expression then;
   final Expression otherwise;
 
   Conditional(this.condition, this.then, this.otherwise);
 
   accept(NodeVisitor visitor) => visitor.visitConditional(this);
 
   void visitChildren(NodeVisitor visitor) {
     condition.accept(visitor);
     then.accept(visitor);
     otherwise.accept(visitor);
   }
 
-  int get precedenceLevel() => ASSIGNMENT;
+  int get precedenceLevel => ASSIGNMENT;
 }
 
 class Call extends Expression {
   Expression target;
   List<Expression> arguments;
 
   Call(this.target, this.arguments);
 
   accept(NodeVisitor visitor) => visitor.visitCall(this);
 
   void visitChildren(NodeVisitor visitor) {
     target.accept(visitor);
     for (Expression arg in arguments) arg.accept(visitor);
   }
 
-  int get precedenceLevel() => CALL;
+  int get precedenceLevel => CALL;
 }
 
 class New extends Call {
   New(Expression cls, List<Expression> arguments) : super(cls, arguments);
 
   accept(NodeVisitor visitor) => visitor.visitNew(this);
 }
 
 class Binary extends Call {
   Binary(String op, Expression left, Expression right)
       : super(new VariableUse(op), <Expression>[left, right]);
 
-  String get op() {
+  String get op {
     VariableUse use = target;
     return use.name;
   }
 
-  Expression get left() => arguments[0];
-  Expression get right() => arguments[1];
+  Expression get left => arguments[0];
+  Expression get right => arguments[1];
 
   accept(NodeVisitor visitor) => visitor.visitBinary(this);
 
-  int get precedenceLevel() {
+  int get precedenceLevel {
     // TODO(floitsch): switch to constant map.
     switch (op) {
       case "*":
       case "/":
       case "%":
         return MULTIPLICATIVE;
       case "+":
       case "-":
         return ADDITIVE;
       case "<<":
@@ skipping 26 matching lines @@
         throw new leg.CompilerCancelledException(
             "Internal Error: Unhandled binary operator: $op");
     }
   }
 }
 
 class Prefix extends Call {
   Prefix(String op, Expression arg)
       : super(new VariableUse(op), <Expression>[arg]);
 
-  String get op() => (target as VariableUse).name;
-  Expression get argument() => arguments[0];
+  String get op => (target as VariableUse).name;
+  Expression get argument => arguments[0];
 
   accept(NodeVisitor visitor) => visitor.visitPrefix(this);
 
-  int get precedenceLevel() => UNARY;
+  int get precedenceLevel => UNARY;
 }
 
 class Postfix extends Call {
   Postfix(String op, Expression arg)
       : super(new VariableUse(op), <Expression>[arg]);
 
-  String get op() => (target as VariableUse).name;
-  Expression get argument() => arguments[0];
+  String get op => (target as VariableUse).name;
+  Expression get argument => arguments[0];
 
   accept(NodeVisitor visitor) => visitor.visitPostfix(this);
 
-  int get precedenceLevel() => UNARY;
+  int get precedenceLevel => UNARY;
 }
 
 abstract class VariableReference extends Expression {
   final String name;
 
   // We treat operators as if they were special functions. They can thus be
   // referenced like other variables.
   VariableReference(this.name);
 
   abstract accept(NodeVisitor visitor);
-  int get precedenceLevel() => PRIMARY;
+  int get precedenceLevel => PRIMARY;
   void visitChildren(NodeVisitor visitor) {}
 }
 
 class VariableUse extends VariableReference {
   VariableUse(String name) : super(name);
 
   accept(NodeVisitor visitor) => visitor.visitVariableUse(this);
 }
 
 class VariableDeclaration extends VariableReference {
@@ skipping 20 matching lines @@
 
   NamedFunction(this.name, this.function);
 
   accept(NodeVisitor visitor) => visitor.visitNamedFunction(this);
 
   void visitChildren(NodeVisitor visitor) {
     name.accept(visitor);
     function.accept(visitor);
   }
 
-  int get precedenceLevel() => CALL;
+  int get precedenceLevel => CALL;
 }
 
 class Fun extends Expression {
   final List<Parameter> params;
   final Block body;
 
   Fun(this.params, this.body);
 
   accept(NodeVisitor visitor) => visitor.visitFun(this);
 
   void visitChildren(NodeVisitor visitor) {
     for (Parameter param in params) param.accept(visitor);
     body.accept(visitor);
   }
 
-  int get precedenceLevel() => CALL;
+  int get precedenceLevel => CALL;
 }
 
 class PropertyAccess extends Expression {
   final Expression receiver;
   final Expression selector;
 
   PropertyAccess(this.receiver, this.selector);
   PropertyAccess.field(this.receiver, String fieldName)
       : selector = new LiteralString("'$fieldName'");
 
   accept(NodeVisitor visitor) => visitor.visitAccess(this);
 
   void visitChildren(NodeVisitor visitor) {
     receiver.accept(visitor);
     selector.accept(visitor);
   }
 
-  int get precedenceLevel() => CALL;
+  int get precedenceLevel => CALL;
 }
 
 abstract class Literal extends Expression {
   void visitChildren(NodeVisitor visitor) {}
 
-  int get precedenceLevel() => PRIMARY;
+  int get precedenceLevel => PRIMARY;
 }
 
 class LiteralBool extends Literal {
   final bool value;
 
   LiteralBool(this.value);
 
   accept(NodeVisitor visitor) => visitor.visitLiteralBool(this);
   // [visitChildren] inherited from [Literal].
 }
@@ skipping 27 matching lines @@
   final List<ArrayElement> elements;
 
   ArrayInitializer(this.length, this.elements);
 
   accept(NodeVisitor visitor) => visitor.visitArrayInitializer(this);
 
   void visitChildren(NodeVisitor visitor) {
     for (ArrayElement element in elements) element.accept(visitor);
   }
 
-  int get precedenceLevel() => PRIMARY;
+  int get precedenceLevel => PRIMARY;
 }
 
 /**
  * An expression inside an [ArrayInitialization]. An [ArrayElement] knows
  * its position in the containing [ArrayInitialization].
  */
 class ArrayElement extends Node {
   int index;
   Expression value;
 
@@ skipping 10 matching lines @@
   List<Property> properties;
 
   ObjectInitializer(this.properties);
 
   accept(NodeVisitor visitor) => visitor.visitObjectInitializer(this);
 
   void visitChildren(NodeVisitor visitor) {
     for (Property init in properties) init.accept(visitor);
   }
 
-  int get precedenceLevel() => PRIMARY;
+  int get precedenceLevel => PRIMARY;
 }
 
 class Property extends Node {
   Literal name;
   Expression value;
 
   Property(this.name, this.value);
 
   accept(NodeVisitor visitor) => visitor.visitProperty(this);
 
@@ skipping 10 matching lines @@
  */
 class RegExpLiteral extends Expression {
   /** Contains the pattern and the flags.*/
   String pattern;
 
   RegExpLiteral(this.pattern);
 
   accept(NodeVisitor visitor) => visitor.visitRegExpLiteral(this);
   void visitChildren(NodeVisitor visitor) {}
 
-  int get precedenceLevel() => PRIMARY;
+  int get precedenceLevel => PRIMARY;
 }