Remove most superfluous getter arguments from dart2js.

dart/lib/compiler/implementation/tree/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 Visitor<R> {
   R visitBlock(Block node);
   R visitBreakStatement(BreakStatement node);
   R visitCascade(Cascade node);
   R visitCascadeReceiver(CascadeReceiver node);
   R visitCaseMatch(CaseMatch node);
@@ skipping 193 matching lines @@
   accept(Visitor visitor) => visitor.visitClassNode(this);
 
   visitChildren(Visitor visitor) {
     if (name !== null) name.accept(visitor);
     if (typeParameters !== null) typeParameters.accept(visitor);
     if (superclass !== null) superclass.accept(visitor);
     if (interfaces !== null) interfaces.accept(visitor);
     if (body !== null) body.accept(visitor);
   }
 
-  bool get isInterface() => beginToken.stringValue === 'interface';
+  bool get isInterface => beginToken.stringValue === 'interface';
 
-  bool get isClass() => !isInterface;
+  bool get isClass => !isInterface;
 
   Token getBeginToken() => beginToken;
 
   Token getEndToken() => endToken;
 }
 
 class Expression extends Node {
   Expression();
 
   Expression asExpression() => this;
@@ skipping 17 matching lines @@
  * A message send aka method invocation. In Dart, most operations can
  * (and should) be considered as message sends. Getters and setters
  * are just methods with a special syntax. Consequently, we model
  * property access, assignment, operators, and method calls with this
  * one node.
  */
 class Send extends Expression {
   final Node receiver;
   final Node selector;
   final NodeList argumentsNode;
-  Link<Node> get arguments() => argumentsNode.nodes;
+  Link<Node> get arguments => argumentsNode.nodes;
 
   Send([this.receiver, this.selector, this.argumentsNode]);
   Send.postfix(this.receiver, this.selector, [Node argument = null])
       : argumentsNode = (argument === null)
         ? new Postfix()
         : new Postfix.singleton(argument);
   Send.prefix(this.receiver, this.selector, [Node argument = null])
       : argumentsNode = (argument === null)
         ? new Prefix()
         : new Prefix.singleton(argument);
 
   Send asSend() => this;
 
   accept(Visitor visitor) => visitor.visitSend(this);
 
   visitChildren(Visitor visitor) {
     if (receiver !== null) receiver.accept(visitor);
     if (selector !== null) selector.accept(visitor);
     if (argumentsNode !== null) argumentsNode.accept(visitor);
   }
 
   int argumentCount() => (argumentsNode === null) ? -1 : argumentsNode.length();
 
-  bool get isSuperCall() {
+  bool get isSuperCall {
     return receiver !== null &&
            receiver.asIdentifier() !== null &&
            receiver.asIdentifier().isSuper();
   }
-  bool get isOperator() => selector is Operator;
-  bool get isPropertyAccess() => argumentsNode === null;
-  bool get isFunctionObjectInvocation() => selector === null;
-  bool get isPrefix() => argumentsNode is Prefix;
-  bool get isPostfix() => argumentsNode is Postfix;
-  bool get isCall() => !isOperator && !isPropertyAccess;
-  bool get isIndex() =>
+  bool get isOperator => selector is Operator;
+  bool get isPropertyAccess => argumentsNode === null;
+  bool get isFunctionObjectInvocation => selector === null;
+  bool get isPrefix => argumentsNode is Prefix;
+  bool get isPostfix => argumentsNode is Postfix;
+  bool get isCall => !isOperator && !isPropertyAccess;
+  bool get isIndex =>
       isOperator && selector.asOperator().source.stringValue === '[]';
-  bool get isLogicalAnd() =>
+  bool get isLogicalAnd =>
       isOperator && selector.asOperator().source.stringValue === '&&';
-  bool get isLogicalOr() =>
+  bool get isLogicalOr =>
       isOperator && selector.asOperator().source.stringValue === '||';
 
   Token getBeginToken() {
     if (isPrefix && !isIndex) return selector.getBeginToken();
     return firstBeginToken(receiver, selector);
   }
 
   Token getEndToken() {
     if (isPrefix) {
       if (receiver !== null) return receiver.getEndToken();
@@ skipping 171 matching lines @@
   final Statement elsePart;
 
   final Token ifToken;
   final Token elseToken;
 
   If(this.condition, this.thenPart, this.elsePart,
      this.ifToken, this.elseToken);
 
   If asIf() => this;
 
-  bool get hasElsePart() => elsePart !== null;
+  bool get hasElsePart => elsePart !== null;
 
   void validate() {
     // TODO(ahe): Check that condition has size one.
   }
 
   accept(Visitor visitor) => visitor.visitIf(this);
 
   visitChildren(Visitor visitor) {
     if (condition !== null) condition.accept(visitor);
     if (thenPart !== null) thenPart.accept(visitor);
@@ skipping 41 matching lines @@
   final Statement conditionStatement;
   final NodeList update;
 
   final Token forToken;
 
   For(this.initializer, this.conditionStatement, this.update, body,
       this.forToken) : super(body);
 
   For asFor() => this;
 
-  Expression get condition() {
+  Expression get condition {
     if (conditionStatement is ExpressionStatement) {
       return conditionStatement.asExpressionStatement().expression;
     } else {
       return null;
     }
   }
 
   accept(Visitor visitor) => visitor.visitFor(this);
 
   visitChildren(Visitor visitor) {
@@ skipping 95 matching lines @@
   Token getBeginToken() => token;
 
   Token getEndToken() => token;
 }
 
 class LiteralInt extends Literal<int> {
   LiteralInt(Token token, DecodeErrorHandler handler) : super(token, handler);
 
   LiteralInt asLiteralInt() => this;
 
-  int get value() {
+  int get value {
     try {
       Token valueToken = token;
       if (valueToken.kind === PLUS_TOKEN) valueToken = valueToken.next;
       return Math.parseInt(valueToken.value.slowToString());
     } catch (FormatException ex) {
       (this.handler)(token, ex);
     }
   }
 
   accept(Visitor visitor) => visitor.visitLiteralInt(this);
 }
 
 class LiteralDouble extends Literal<double> {
   LiteralDouble(Token token, DecodeErrorHandler handler)
     : super(token, handler);
 
   LiteralDouble asLiteralDouble() => this;
 
-  double get value() {
+  double get value {
     try {
       Token valueToken = token;
       if (valueToken.kind === PLUS_TOKEN) valueToken = valueToken.next;
       return Math.parseDouble(valueToken.value.slowToString());
     } catch (FormatException ex) {
       (this.handler)(token, ex);
     }
   }
 
   accept(Visitor visitor) => visitor.visitLiteralDouble(this);
 }
 
 class LiteralBool extends Literal<bool> {
   LiteralBool(Token token, DecodeErrorHandler handler) : super(token, handler);
 
   LiteralBool asLiteralBool() => this;
 
-  bool get value() {
+  bool get value {
     if (token.value == Keyword.TRUE) return true;
     if (token.value == Keyword.FALSE) return false;
     (this.handler)(token, "not a bool ${token.value}");
   }
 
   accept(Visitor visitor) => visitor.visitLiteralBool(this);
 }
 
 
 class StringQuoting {
@@ skipping 47 matching lines @@
     MULTILINE_NL_SQ,
     RAW_MULTILINE_NL_SQ,
     MULTILINE_NL2_SQ,
     RAW_MULTILINE_NL2_SQ
   ];
   final bool raw;
   final int leftQuoteCharCount;
   final int quote;
   const StringQuoting(this.quote, [bool raw, int leftQuoteLength])
       : this.raw = raw, this.leftQuoteCharCount = leftQuoteLength;
-  String get quoteChar() => quote === $DQ ? '"' : "'";
+  String get quoteChar => quote === $DQ ? '"' : "'";
 
-  int get leftQuoteLength() => (raw ? 1 : 0) + leftQuoteCharCount;
-  int get rightQuoteLength() => (leftQuoteCharCount > 2) ? 3 : 1;
+  int get leftQuoteLength => (raw ? 1 : 0) + leftQuoteCharCount;
+  int get rightQuoteLength => (leftQuoteCharCount > 2) ? 3 : 1;
   static StringQuoting getQuoting(int quote, bool raw, int quoteLength) {
     int index = quoteLength - 1;
     if (quoteLength > 2) index -= 1;
     return mapping[(raw ? 1 : 0) + index * 2 + (quote === $SQ ? 8 : 0)];
   }
 }
 
 /**
   * Superclass for classes representing string literals.
   */
 class StringNode extends Expression {
   abstract DartString get dartString();
   abstract bool get isInterpolation();
 
   StringNode asStringNode() => this;
 }
 
 class LiteralString extends StringNode {
   final Token token;
   /** Non-null on validated string literals. */
   final DartString dartString;
 
   LiteralString(this.token, this.dartString);
 
   LiteralString asLiteralString() => this;
 
   void visitChildren(Visitor visitor) {}
 
-  bool get isInterpolation() => false;
+  bool get isInterpolation => false;
   bool isValidated() => dartString !== null;
 
   Token getBeginToken() => token;
   Token getEndToken() => token;
 
   accept(Visitor visitor) => visitor.visitLiteralString(this);
 }
 
 class LiteralNull extends Literal<SourceString> {
   LiteralNull(Token token) : super(token, null);
 
   LiteralNull asLiteralNull() => this;
 
-  SourceString get value() => null;
+  SourceString get value => null;
 
   accept(Visitor visitor) => visitor.visitLiteralNull(this);
 }
 
 class LiteralList extends Expression {
   final TypeAnnotation type;
   final NodeList elements;
 
   final Token constKeyword;
 
@@ skipping 13 matching lines @@
     if (constKeyword !== null) return constKeyword;
     return firstBeginToken(type, elements);
   }
 
   Token getEndToken() => elements.getEndToken();
 }
 
 class Identifier extends Expression {
   final Token token;
 
-  SourceString get source() => token.value;
+  SourceString get source => token.value;
 
   Identifier(Token this.token);
 
   bool isThis() => source.stringValue === 'this';
 
   bool isSuper() => source.stringValue === 'super';
 
   Identifier asIdentifier() => this;
 
   accept(Visitor visitor) => visitor.visitIdentifier(this);
@@ skipping 15 matching lines @@
 
 class Return extends Statement {
   final Expression expression;
   final Token beginToken;
   final Token endToken;
 
   Return(this.beginToken, this.endToken, this.expression);
 
   Return asReturn() => this;
 
-  bool get hasExpression() => expression !== null;
+  bool get hasExpression => expression !== null;
 
   accept(Visitor visitor) => visitor.visitReturn(this);
 
   visitChildren(Visitor visitor) {
     if (expression !== null) expression.accept(visitor);
   }
 
   Token getBeginToken() => beginToken;
 
   Token getEndToken() {
@@ skipping 261 matching lines @@
 }
 
 class StringInterpolation extends StringNode {
   final LiteralString string;
   final NodeList parts;
 
   StringInterpolation(this.string, this.parts);
 
   StringInterpolation asStringInterpolation() => this;
 
-  DartString get dartString() => null;
-  bool get isInterpolation() => true;
+  DartString get dartString => null;
+  bool get isInterpolation => true;
 
   accept(Visitor visitor) => visitor.visitStringInterpolation(this);
 
   visitChildren(Visitor visitor) {
     string.accept(visitor);
     parts.accept(visitor);
   }
 
   Token getBeginToken() => string.getBeginToken();
   Token getEndToken() => parts.getEndToken();
@@ skipping 37 matching lines @@
    * Caches a Dart string representation of the entire juxtaposition's
    * content. Only juxtapositions that don't (transitively) contains
    * interpolations have a static representation.
    */
   DartString dartStringCache = null;
 
   StringJuxtaposition(this.first, this.second);
 
   StringJuxtaposition asStringJuxtaposition() => this;
 
-  bool get isInterpolation() {
+  bool get isInterpolation {
     if (isInterpolationCache === null) {
       isInterpolationCache = (first.accept(const IsInterpolationVisitor()) ||
                           second.accept(const IsInterpolationVisitor()));
     }
     return isInterpolationCache;
   }
 
   /**
    * Retrieve a single DartString that represents this entire juxtaposition
    * of string literals.
    * Should only be called if [isInterpolation] returns false.
    */
-  DartString get dartString() {
+  DartString get dartString {
     if (isInterpolation) {
       throw new NodeAssertionFailure(this,
                                      "Getting dartString on interpolation;");
     }
     if (dartStringCache === null) {
       DartString firstString = first.accept(const GetDartStringVisitor());
       DartString secondString = second.accept(const GetDartStringVisitor());
       if (firstString === null || secondString === null) {
         return null;
       }
@@ skipping 105 matching lines @@
   final ParenthesizedExpression parenthesizedExpression;
   final NodeList cases;
 
   final Token switchKeyword;
 
   SwitchStatement(this.parenthesizedExpression, this.cases,
                   this.switchKeyword);
 
   SwitchStatement asSwitchStatement() => this;
 
-  Expression get expression() => parenthesizedExpression.expression;
+  Expression get expression => parenthesizedExpression.expression;
 
   accept(Visitor visitor) => visitor.visitSwitchStatement(this);
 
   visitChildren(Visitor visitor) {
     parenthesizedExpression.accept(visitor);
     cases.accept(visitor);
   }
 
   Token getBeginToken() => switchKeyword;
 
@@ skipping 29 matching lines @@
   /** List of statements, the body of the case. */
   final NodeList statements;
 
   final Token startToken;
 
   SwitchCase(this.labelsAndCases, this.defaultKeyword,
              this.statements, this.startToken);
 
   SwitchCase asSwitchCase() => this;
 
-  bool get isDefaultCase() => defaultKeyword !== null;
+  bool get isDefaultCase => defaultKeyword !== null;
 
   bool isValidContinueTarget() => true;
 
   accept(Visitor visitor) => visitor.visitSwitchCase(this);
 
   visitChildren(Visitor visitor) {
     labelsAndCases.accept(visitor);
     statements.accept(visitor);
   }
 
@@ skipping 56 matching lines @@
 class ForIn extends Loop {
   final Node declaredIdentifier;
   final Expression expression;
 
   final Token forToken;
   final Token inToken;
 
   ForIn(this.declaredIdentifier, this.expression,
         Statement body, this.forToken, this.inToken) : super(body);
 
-  Expression get condition() => null;
+  Expression get condition => null;
 
   ForIn asForIn() => this;
 
   accept(Visitor visitor) => visitor.visitForIn(this);
 
   visitChildren(Visitor visitor) {
     declaredIdentifier.accept(visitor);
     expression.accept(visitor);
     body.accept(visitor);
   }
@@ skipping 179 matching lines @@
   final Token onKeyword;
   final Token catchKeyword;
 
   CatchBlock(this.type, this.formals, this.block,
              this.onKeyword, this.catchKeyword);
 
   CatchBlock asCatchBlock() => this;
 
   accept(Visitor visitor) => visitor.visitCatchBlock(this);
 
-  Node get exception() {
+  Node get exception {
     if (formals.nodes.isEmpty()) return null;
     VariableDefinitions declarations = formals.nodes.head;
     return declarations.definitions.nodes.head;
   }
 
-  Node get trace() {
+  Node get trace {
     if (formals.nodes.isEmpty()) return null;
     Link<Node> declarations = formals.nodes.tail;
     if (declarations.isEmpty()) return null;
     VariableDefinitions head = declarations.head;
     return head.definitions.nodes.head;
   }
 
   visitChildren(Visitor visitor) {
     if (type != null) type.accept(visitor);
     formals.accept(visitor);
@@ skipping 48 matching lines @@
  * argument).
  *
  * TODO(ahe): This method is controversial, the team needs to discuss
  * if top-level methods are acceptable and what naming conventions to
  * use.
  */
 initializerDo(Node node, f(Node node)) {
   SendSet send = node.asSendSet();
   if (send !== null) return f(send.arguments.head);
 }