Remove most superfluous getter arguments from dart2js.

dart/lib/compiler/implementation/js_backend/emitter.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.
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
 class ClosureInvocationElement extends FunctionElement {
   ClosureInvocationElement(SourceString name,
@@ skipping 30 matching lines @@
       : namer = compiler.namer,
         boundClosureBuffer = new CodeBuffer(),
         mainBuffer = new CodeBuffer(),
         boundClosureCache = new Map<int, String>(),
         generateSourceMap = generateSourceMap,
         sourceMapBuilder = new SourceMapBuilder(),
         super(compiler) {
     nativeEmitter = new NativeEmitter(this);
   }
 
-  String get name() => 'CodeEmitter';
+  String get name => 'CodeEmitter';
 
-  String get defineClassName()
+  String get defineClassName
       => '${namer.ISOLATE}.\$defineClass';
-  String get finishClassesName()
+  String get finishClassesName
       => '${namer.ISOLATE}.\$finishClasses';
-  String get finishIsolateConstructorName()
+  String get finishIsolateConstructorName
       => '${namer.ISOLATE}.\$finishIsolateConstructor';
-  String get pendingClassesName()
+  String get pendingClassesName
       => '${namer.ISOLATE}.\$pendingClasses';
-  String get isolatePropertiesName()
+  String get isolatePropertiesName
       => '${namer.ISOLATE}.${namer.ISOLATE_PROPERTIES}';
-  String get supportsProtoName()
+  String get supportsProtoName
       => 'supportsProto';
 
   final String GETTER_SUFFIX = "?";
   final String SETTER_SUFFIX = "!";
   final String GETTER_SETTER_SUFFIX = "=";
 
-  String get generateGetterSetterFunction() {
+  String get generateGetterSetterFunction {
     return """
 function(field, prototype) {
   var len = field.length;
   var lastChar = field[len - 1];
   var needsGetter = lastChar == '$GETTER_SUFFIX' || lastChar == '$GETTER_SETTER_SUFFIX';
   var needsSetter = lastChar == '$SETTER_SUFFIX' || lastChar == '$GETTER_SETTER_SUFFIX';
   if (needsGetter || needsSetter) field = field.substring(0, len - 1);
   if (needsGetter) {
     var getterString = "return this." + field + ";";
 """ /* The supportsProtoCheck below depends on the getter/setter convention.
        When changing here, update the protoCheck too. */ """
     prototype["get\$" + field] = new Function(getterString);
   }
   if (needsSetter) {
     var setterString = "this." + field + " = v;";
     prototype["set\$" + field] = new Function("v", setterString);
   }
   return field;
 }""";
   }
 
-  String get defineClassFunction() {
+  String get defineClassFunction {
     // First the class name, then the super class name, followed by the fields
     // (in an array) and the members (inside an Object literal).
     // The caller can also pass in the constructor as a function if needed.
     //
     // Example:
     // defineClass("A", "B", ["x", "y"], {
     //  foo$1: function(y) {
     //   print(this.x + y);
     //  },
     //  bar$2: function(t, v) {
@@ skipping 19 matching lines @@
     str += ") {" + body + "}\\n";
     str += "return " + cls + ";";
     constructor = new Function(str)();
   }
   constructor.prototype = prototype;
   return constructor;
 }""";
   }
 
   /** Needs defineClass to be defined. */
-  String get protoSupportCheck() {
+  String get protoSupportCheck {
     // On Firefox and Webkit browsers we can manipulate the __proto__
     // directly. Opera claims to have __proto__ support, but it is buggy.
     // So we have to do more checks.
     // If the browser does not support __proto__ we need to instantiate an
     // object with the correct (internal) prototype set up correctly, and then
     // copy the members.
 
     return '''
 var $supportsProtoName = false;
 var tmp = $defineClassName('c', ['f?'], {}).prototype;
 if (tmp.__proto__) {
   tmp.__proto__ = {};
   if (typeof tmp.get\$f !== "undefined") $supportsProtoName = true;
 }
 ''';
   }
 
-  String get finishClassesFunction() {
+  String get finishClassesFunction {
     // 'defineClass' does not require the classes to be constructed in order.
     // Classes are initially just stored in the 'pendingClasses' field.
     // 'finishClasses' takes all pending classes and sets up the prototype.
     // Once set up, the constructors prototype field satisfy:
     //  - it contains all (local) members.
     //  - its internal prototype (__proto__) points to the superclass'
     //    prototype field.
     //  - the prototype's constructor field points to the JavaScript
     //    constructor.
     // For engines where we have access to the '__proto__' we can manipulate
@@ skipping 40 matching lines @@
         if (hasOwnProperty.call(prototype, member)) {
           newPrototype[member] = prototype[member];
         }
       }
     }
   }
   for (var cls in pendingClasses) finishClass(cls);
 }''';
   }
 
-  String get finishIsolateConstructorFunction() {
+  String get finishIsolateConstructorFunction {
     String isolate = namer.ISOLATE;
     // We replace the old Isolate function with a new one that initializes
     // all its field with the initial (and often final) value of all globals.
     // This has two advantages:
     //   1. the properties are in the object itself (thus avoiding to go through
     //      the prototype when looking up globals.
     //   2. a new isolate goes through a (usually well optimized) constructor
     //      function of the form: "function() { this.x = ...; this.y = ...; }".
     //
     // Example: If [isolateProperties] is an object containing: x = 3 and
@@ skipping 483 matching lines @@
 
   void emitDynamicFunctionGetter(FunctionElement member,
                                  DefineMemberFunction defineInstanceMember) {
     // For every method that has the same name as a property-get we create a
     // getter that returns a bound closure. Say we have a class 'A' with method
     // 'foo' and somewhere in the code there is a dynamic property get of
     // 'foo'. Then we generate the following code (in pseudo Dart/JavaScript):
     //
     // class A {
     //    foo(x, y, z) { ... } // Original function.
-    //    get foo() { return new BoundClosure499(this, "foo"); }
+    //    get foo { return new BoundClosure499(this, "foo"); }
     // }
     // class BoundClosure499 extends Closure {
     //   var self;
     //   BoundClosure499(this.self, this.name);
     //   $call3(x, y, z) { return self[name](x, y, z); }
     // }
 
     // TODO(floitsch): share the closure classes with other classes
     // if they share methods with the same signature. Currently we do this only
     // if there are no optional parameters. Closures with optional parameters
@@ skipping 441 matching lines @@
         sourceName = token.slowToString();
       }
       int totalOffset = bufferOffset + offset;
       sourceMapBuilder.addMapping(
           sourceFile, token.charOffset, sourceName, totalOffset);
     });
   }
 }
 
 typedef void DefineMemberFunction(String invocationName, CodeBuffer definition);