Remove most superfluous getter arguments from dart2js.

dart/lib/compiler/implementation/elements/elements.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.
 
 #library('elements');
 
 #import('dart:uri');
 
 #import('../tree/tree.dart');
 #import('../scanner/scannerlib.dart');
@@ skipping 94 matching lines @@
 class Element implements Hashable {
   final SourceString name;
   final ElementKind kind;
   final Element enclosingElement;
   Link<Node> metadata = const EmptyLink<Node>();
 
   Element(this.name, this.kind, this.enclosingElement) {
     assert(getLibrary() !== null);
   }
 
-  Modifiers get modifiers() => null;
+  Modifiers get modifiers => null;
 
   Node parseNode(DiagnosticListener listener) {
     listener.cancel("Internal Error: $this.parseNode", token: position());
   }
 
   Type computeType(Compiler compiler) {
     compiler.internalError("$this.computeType.", token: position());
   }
 
   void addMetadata(Node node) {
@@ skipping 187 matching lines @@
 
   ErroneousElement(this.errorMessage, Element enclosing)
       : super(const SourceString('erroneous element'), null, enclosing);
 
   isErroneous() => true;
 
   unsupported() {
     throw 'unsupported operation on erroneous element';
   }
 
-  SourceString get name() => unsupported();
-  ElementKind get kind() => unsupported();
-  Link<Node> get metadata() => unsupported();
+  SourceString get name => unsupported();
+  ElementKind get kind => unsupported();
+  Link<Node> get metadata => unsupported();
 }
 
 class ErroneousFunctionElement extends ErroneousElement
                                implements FunctionElement {
   ErroneousFunctionElement(errorMessage, Element enclosing)
       : super(errorMessage, enclosing);
 
-  get type() => unsupported();
-  get cachedNode() => unsupported();
-  get functionSignature() => unsupported();
-  get patch() => unsupported();
-  get defaultImplementation() => unsupported();
-  bool get isPatched() => unsupported();
+  get type => unsupported();
+  get cachedNode => unsupported();
+  get functionSignature => unsupported();
+  get patch => unsupported();
+  get defaultImplementation => unsupported();
+  bool get isPatched => unsupported();
   setPatch(patch) => unsupported();
   computeSignature(compiler) => unsupported();
   requiredParameterCount(compiler) => unsupported();
   optionalParameterCount(compiler) => unsupported();
   parameterCount(copmiler) => unsupported();
 
   getLibrary() => enclosingElement.getLibrary();
 }
 
 class ContainerElement extends Element {
@@ skipping 115 matching lines @@
   bool canUseNative = false;
   LibraryElement patch = null;
 
   LibraryElement(Script script, [Uri uri])
     : this.uri = ((uri === null) ? script.uri : uri),
       super(new SourceString(script.name), ElementKind.LIBRARY, null) {
     entryCompilationUnit = new CompilationUnitElement(script, this);
   }
 
 
-  bool get isPatched() => patch !== null;
+  bool get isPatched => patch !== null;
 
   void addCompilationUnit(CompilationUnitElement element) {
     compilationUnits = compilationUnits.prepend(element);
   }
 
   void addTag(ScriptTag tag, DiagnosticListener listener) {
     tags = tags.prepend(tag);
   }
 
   /** Look up a top-level element in this library. The element could
@@ skipping 87 matching lines @@
   TypedefType computeType(Compiler compiler) {
     if (cachedType !== null) return cachedType;
     Typedef node = parseNode(compiler);
     Link<Type> parameters =
         TypeDeclarationElement.createTypeVariables(this, node.typeParameters);
     cachedType = new TypedefType(this, parameters);
     compiler.resolveTypedef(this);
     return cachedType;
   }
 
-  Link<Type> get typeVariables() => cachedType.typeArguments;
+  Link<Type> get typeVariables => cachedType.typeArguments;
 
   Scope buildScope() =>
       new TypeDeclarationScope(enclosingElement.buildScope(), this);
 
   TypedefElement cloneTo(Element enclosing, DiagnosticListener listener) {
     TypedefElement result = new TypedefElement(name, enclosing);
     return result;
   }
 }
 
 class VariableElement extends Element {
   final VariableListElement variables;
   Expression cachedNode; // The send or the identifier in the variables list.
 
-  Modifiers get modifiers() => variables.modifiers;
+  Modifiers get modifiers => variables.modifiers;
 
   VariableElement(SourceString name,
                   VariableListElement this.variables,
                   ElementKind kind,
                   Element enclosing,
                   [Node node])
     : super(name, kind, enclosing), cachedNode = node;
 
   Node parseNode(DiagnosticListener listener) {
     if (cachedNode !== null) return cachedNode;
@@ skipping 10 matching lines @@
         return cachedNode;
       }
     }
     listener.cancel('internal error: could not find $name', node: variables);
   }
 
   Type computeType(Compiler compiler) {
     return variables.computeType(compiler);
   }
 
-  Type get type() => variables.type;
+  Type get type => variables.type;
 
   bool isInstanceMember() {
     return isMember() && !modifiers.isStatic();
   }
 
   // Note: cachedNode.getBeginToken() will not be correct in all
   // cases, for example, for function typed parameters.
   Token position() => findMyName(variables.position());
 
   VariableElement cloneTo(Element enclosing, DiagnosticListener listener) {
@@ skipping 145 matching lines @@
     // We need to make sure that the position returned is relative to
     // the compilation unit of the abstract element.
     if (getter !== null
         && getter.getCompilationUnit() === getCompilationUnit()) {
       return getter.position();
     } else {
       return setter.position();
     }
   }
 
-  Modifiers get modifiers() {
+  Modifiers get modifiers {
     // The resolver ensures that the flags match (ignoring abstract).
     if (getter !== null) {
       return new Modifiers.withFlags(
           getter.modifiers.nodes,
           getter.modifiers.flags | Modifiers.FLAG_ABSTRACT);
     } else {
       return new Modifiers.withFlags(
           setter.modifiers.nodes,
           setter.modifiers.flags | Modifiers.FLAG_ABSTRACT);
     }
@@ skipping 25 matching lines @@
          link = link.tail) {
       function(link.head);
     }
     for (Link<Element> link = optionalParameters;
          !link.isEmpty();
          link = link.tail) {
       function(link.head);
     }
   }
 
-  int get parameterCount() => requiredParameterCount + optionalParameterCount;
+  int get parameterCount => requiredParameterCount + optionalParameterCount;
 }
 
 class FunctionElement extends Element {
   FunctionExpression cachedNode;
   Type type;
   final Modifiers modifiers;
 
   FunctionSignature functionSignature;
 
   /**
@@ skipping 34 matching lines @@
   FunctionElement.tooMuchOverloading(SourceString name,
                                      FunctionExpression this.cachedNode,
                                      ElementKind kind,
                                      Modifiers this.modifiers,
                                      Element enclosing,
                                      FunctionSignature this.functionSignature)
       : super(name, kind, enclosing) {
     defaultImplementation = this;
   }
 
-  bool get isPatched() => patch !== null;
+  bool get isPatched => patch !== null;
 
   /**
    * Applies a patch function to this function. The patch function's body
    * is used as replacement when parsing this function's body.
    * This method must not be called after the function has been parsed,
    * and it must be called at most once.
    */
   void setPatch(FunctionElement patchElement) {
     // Sanity checks. The caller must check these things before calling.
     assert(patch === null);
@@ skipping 191 matching lines @@
   InterfaceType computeType(compiler) {
     if (type == null) {
       ClassNode node = parseNode(compiler);
       Link<Type> parameters =
           TypeDeclarationElement.createTypeVariables(this, node.typeParameters);
       type = new InterfaceType(this, parameters);
     }
     return type;
   }
 
-  bool get isPatched() => patch != null;
+  bool get isPatched => patch != null;
 
-  Link<Type> get typeVariables() => type.arguments;
+  Link<Type> get typeVariables => type.arguments;
 
   ClassElement ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveClass(this);
     }
     return this;
   }
 
   /**
    * Lookup local members in the class. This will ignore constructors.
@@ skipping 119 matching lines @@
     } else {
       normalizedName = className;
     }
     Element result = localLookup(normalizedName);
     if (result === null || !result.isConstructor()) {
       result = noMatch !== null ? noMatch(result) : null;
     }
     return result;
   }
 
-  bool get hasConstructor() {
+  bool get hasConstructor {
     // Search in scope to be sure we search patched constructors.
     for (var element in localScope.getValues()) {
       if (element.isConstructor()) return true;
     }
     return false;
   }
 
-  Link<Element> get constructors() {
+  Link<Element> get constructors {
     // TODO(ajohnsen): See if we can avoid this method at some point.
     Link<Element> result = const EmptyLink<Element>();
     for (Element member in localMembers) {
       if (member.isConstructor()) result = result.prepend(member);
     }
     return result;
   }
 
   /**
    * Returns the super class, if any.
    *
    * The returned element may not be resolved yet.
    */
-  ClassElement get superclass() {
+  ClassElement get superclass {
     assert(supertypeLoadState == STATE_DONE);
     return supertype === null ? null : supertype.element;
   }
 
   /**
    * Runs through all members of this class.
    *
    * The enclosing class is passed to the callback. This is useful when
    * [includeSuperMembers] is [:true:].
    */
@@ skipping 68 matching lines @@
   bool isNative() => nativeName != null;
   int hashCode() => id;
 
   Scope buildScope() =>
       new ClassScope(enclosingElement.buildScope(), this);
 
   ClassElement cloneTo(Element enclosing, DiagnosticListener listener) {
     listener.internalErrorOnElement(this, 'unsupported operation');
   }
 
-  Link<Type> get allSupertypesAndSelf() {
+  Link<Type> get allSupertypesAndSelf {
     return allSupertypes.prepend(new InterfaceType(this));
   }
 }
 
 class Elements {
   static bool isLocal(Element element) {
     return !Element.isInvalid(element)
             && !element.isInstanceMember()
             && !isStaticOrTopLevelField(element)
             && !isStaticOrTopLevelFunction(element)
@@ skipping 130 matching lines @@
 
   void setBreakTarget() {
     isBreakTarget = true;
     target.isBreakTarget = true;
   }
   void setContinueTarget() {
     isContinueTarget = true;
     target.isContinueTarget = true;
   }
 
-  bool get isTarget() => isBreakTarget || isContinueTarget;
+  bool get isTarget => isBreakTarget || isContinueTarget;
   Node parseNode(DiagnosticListener l) => label;
 
   Token position() => label.getBeginToken();
   String toString() => "${labelName}:";
 }
 
 // Represents a reference to a statement or switch-case, either by label or the
 // default target of a break or continue.
 class TargetElement extends Element {
   final Node statement;
   final int nestingLevel;
   Link<LabelElement> labels = const EmptyLink<LabelElement>();
   bool isBreakTarget = false;
   bool isContinueTarget = false;
 
   TargetElement(this.statement, this.nestingLevel, Element enclosingElement)
       : super(const SourceString(""), ElementKind.STATEMENT, enclosingElement);
-  bool get isTarget() => isBreakTarget || isContinueTarget;
+  bool get isTarget => isBreakTarget || isContinueTarget;
 
   LabelElement addLabel(Label label, String labelName) {
     LabelElement result = new LabelElement(label, labelName, this,
                                            enclosingElement);
     labels = labels.prepend(result);
     return result;
   }
 
   Node parseNode(DiagnosticListener l) => statement;
 
-  bool get isSwitch() => statement is SwitchStatement;
+  bool get isSwitch => statement is SwitchStatement;
 
   Token position() => statement.getBeginToken();
   String toString() => statement.toString();
 }
 
 class TypeVariableElement extends Element {
   final Node cachedNode;
   TypeVariableType type;
   Type bound;
 
   TypeVariableElement(name, Element enclosing, this.cachedNode,
                       [this.type, this.bound])
     : super(name, ElementKind.TYPE_VARIABLE, enclosing);
 
   TypeVariableType computeType(compiler) => type;
 
   Node parseNode(compiler) => cachedNode;
 
   String toString() => "${enclosingElement.toString()}.${name.slowToString()}";
 
   Token position() => cachedNode.getBeginToken();
 
   TypeVariableElement cloneTo(Element enclosing, DiagnosticListener listener) {
     TypeVariableElement result =
         new TypeVariableElement(name, enclosing, cachedNode, type, bound);
     return result;
   }
 }