Remove most superfluous getter arguments from dart2js.

dart/lib/compiler/implementation/resolver.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 TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
   Type getType(TypeAnnotation annotation);
 }
 
@@ skipping 20 matching lines @@
   void setSelector(Node node, Selector selector) {
     selectors[node] = selector;
   }
 
   Selector getSelector(Node node) => selectors[node];
 }
 
 class ResolverTask extends CompilerTask {
   ResolverTask(Compiler compiler) : super(compiler);
 
-  String get name() => 'Resolver';
+  String get name => 'Resolver';
 
   TreeElements resolve(Element element) {
     return measure(() {
       ElementKind kind = element.kind;
       if (kind === ElementKind.GENERATIVE_CONSTRUCTOR ||
           kind === ElementKind.FUNCTION ||
           kind === ElementKind.GETTER ||
           kind === ElementKind.SETTER) {
         return resolveMethodElement(element);
       }
@@ skipping 625 matching lines @@
   LabelElement lookup(String labelName) {
     LabelElement result = caseLabels[labelName];
     if (result !== null) return result;
     return outer.lookup(labelName);
   }
 }
 
 class EmptyLabelScope implements LabelScope {
   const EmptyLabelScope();
   LabelElement lookup(String label) => null;
-  LabelScope get outer() {
+  LabelScope get outer {
     throw 'internal error: empty label scope has no outer';
   }
 }
 
 class StatementScope {
   LabelScope labels;
   Link<TargetElement> breakTargetStack;
   Link<TargetElement> continueTargetStack;
   // Used to provide different numbers to statements if one is inside the other.
   // Can be used to make otherwise duplicate labels unique.
@@ skipping 204 matching lines @@
           || element.isGenerativeConstructor(),
       this.currentClass = element.isMember() ?
                               element.getEnclosingClass() :
                               null,
       this.statementScope = new StatementScope(),
       typeResolver = new TypeResolver(compiler),
       scope = element.buildEnclosingScope(),
       super(compiler) {
   }
 
-  Enqueuer get world() => compiler.enqueuer.resolution;
+  Enqueuer get world => compiler.enqueuer.resolution;
 
   Element lookup(Node node, SourceString name) {
     Element result = scope.lookup(name);
     if (!inInstanceContext && result != null && result.isInstanceMember()) {
       error(node, MessageKind.NO_INSTANCE_AVAILABLE, [node]);
     }
     return result;
   }
 
   // Create, or reuse an already created, statement element for a statement.
@@ skipping 890 matching lines @@
         variableElement.bound = compiler.objectClass.computeType(compiler);
       }
       nodeLink = nodeLink.tail;
       typeLink = typeLink.tail;
     }
     assert(typeLink.isEmpty());
   }
 }
 
 class TypedefResolverVisitor extends TypeDefinitionVisitor {
-  TypedefElement get element() => super.element;
+  TypedefElement get element => super.element;
 
   TypedefResolverVisitor(Compiler compiler, TypedefElement typedefElement)
       : super(compiler, typedefElement);
 
   visitTypedef(Typedef node) {
     TypedefType type = element.computeType(compiler);
     scope = new TypeDeclarationScope(scope, element);
     resolveTypeVariableBounds(node.typeParameters);
 
     element.functionSignature = SignatureResolver.analyze(
@@ skipping 12 matching lines @@
  * This visitor has to be extra careful as it is building the basic
  * element information, and cannot safely look at other elements as
  * this may lead to cycles.
  *
  * This visitor can assume that the supertypes have already been
  * resolved, but it cannot call [ResolverTask.resolveClass] directly
  * or indirectly (through [ClassElement.ensureResolved]) for any other
  * types.
  */
 class ClassResolverVisitor extends TypeDefinitionVisitor {
-  ClassElement get element() => super.element;
+  ClassElement get element => super.element;
 
   ClassResolverVisitor(Compiler compiler, ClassElement classElement)
     : super(compiler, classElement);
 
   Type visitClassNode(ClassNode node) {
     compiler.ensure(element !== null);
     compiler.ensure(element.resolutionState == ClassElement.STATE_STARTED);
 
     InterfaceType type = element.computeType(compiler);
     scope = new TypeDeclarationScope(scope, element);
@@ skipping 438 matching lines @@
                                  returnType);
   }
 
   // TODO(ahe): This is temporary.
   void resolveExpression(Node node) {
     if (node == null) return;
     node.accept(new ResolverVisitor(compiler, enclosingElement));
   }
 
   // TODO(ahe): This is temporary.
-  ClassElement get currentClass() {
+  ClassElement get currentClass {
     return enclosingElement.isMember()
       ? enclosingElement.getEnclosingClass() : null;
   }
 }
 
 class ConstructorResolver extends CommonResolverVisitor<Element> {
   final ResolverVisitor resolver;
 
   ConstructorResolver(Compiler compiler, this.resolver) : super(compiler);
 
@@ skipping 95 matching lines @@
 }
 
 /**
  * [TypeDeclarationScope] defines the outer scope of a type declaration in
  * which the declared type variables and the entities in the enclosing scope are
  * available but where declared and inherited members are not available. This
  * scope is only used for class/interface declarations during resolution of the
  * class hierarchy. In all other cases [ClassScope] is used.
  */
 class TypeDeclarationScope extends Scope {
-  TypeDeclarationElement get element() => super.element;
+  TypeDeclarationElement get element => super.element;
 
   TypeDeclarationScope(parent, TypeDeclarationElement element)
       : super(parent, element) {
     assert(parent !== null);
   }
 
   Element add(Element newElement) {
     throw "Cannot add element to TypeDeclarationScope";
   }
 
@@ skipping 72 matching lines @@
   }
 
   Element add(Element newElement) {
     throw "Cannot add an element in a class scope";
   }
 
   String toString() => '$element > $parent';
 }
 
 class TopScope extends Scope {
-  LibraryElement get library() => element;
+  LibraryElement get library => element;
 
   TopScope(LibraryElement library) : super(null, library);
   Element lookup(SourceString name) {
     return library.find(name);
   }
 
   Element add(Element newElement) {
     throw "Cannot add an element in the top scope";
   }
   String toString() => '$element';
 }