Convert property methods into getters.

sdk/lib/_internal/compiler/implementation/js_emitter/container_builder.dart

 // Copyright (c) 2013, 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.
 
 part of dart2js.js_emitter;
 
 /// This class should morph into something that makes it easy to build
 /// JavaScript representations of libraries, class-sides, and instance-sides.
 /// Initially, it is just a placeholder for code that is moved from
 /// [CodeEmitterTask].
@@ skipping 98 matching lines @@
               indexOfLastOptionalArgumentInParameters = count;
             }
             argumentsBuffer[count] = task.constantReference(value);
           }
         }
       }
       count++;
     });
 
     var body;  // List or jsAst.Statement.
-    if (member.hasFixedBackendName()) {
+    if (member.hasFixedBackendName) {
       body = task.nativeEmitter.generateParameterStubStatements(
           member, isInterceptedMethod, invocationName,
           parametersBuffer, argumentsBuffer,
           indexOfLastOptionalArgumentInParameters);
-    } else if (member.isInstanceMember()) {
+    } else if (member.isInstanceMember) {
       if (needsSuperGetter(member)) {
-        ClassElement superClass = member.getEnclosingClass();
+        ClassElement superClass = member.enclosingClass;
         String methodName = namer.getNameOfInstanceMember(member);
         // When redirecting, we must ensure that we don't end up in a subclass.
         // We thus can't just invoke `this.foo$1.call(filledInArguments)`.
         // Instead we need to call the statically resolved target.
         //   `<class>.prototype.bar$1.call(this, argument0, ...)`.
         body = js.statement(
             'return #.prototype.#.call(this, #);',
             [backend.namer.elementAccess(superClass), methodName,
              argumentsBuffer]);
       } else {
         body = js.statement(
             'return this.#(#);',
             [namer.getNameOfInstanceMember(member), argumentsBuffer]);
       }
     } else {
       body = js.statement('return #(#)',
           [namer.elementAccess(member), argumentsBuffer]);
     }
 
     jsAst.Fun function = js('function(#) { #; }', [parametersBuffer, body]);
 
     addStub(selector, function);
   }
 
   void addParameterStubs(FunctionElement member, AddStubFunction defineStub,
                          [bool canTearOff = false]) {
-    if (member.enclosingElement.isClosure()) {
+    if (member.enclosingElement.isClosure) {
       ClosureClassElement cls = member.enclosingElement;
       if (cls.supertype.element == compiler.boundClosureClass) {
         compiler.internalError(cls.methodElement, 'Bound closure1.');
       }
-      if (cls.methodElement.isInstanceMember()) {
+      if (cls.methodElement.isInstanceMember) {
         compiler.internalError(cls.methodElement, 'Bound closure2.');
       }
     }
 
     // We fill the lists depending on the selector. For example,
     // take method foo:
     //    foo(a, b, {c, d});
     //
     // We may have multiple ways of calling foo:
     // (1) foo(1, 2);
@@ skipping 16 matching lines @@
     // (4) No stub generated, call is direct.
     // (5) No stub generated, call is direct.
     //
     // We need to pay attention if this stub is for a function that has been
     // invoked from a subclass. Then we cannot just redirect, since that
     // would invoke the methods of the subclass. We have to compile to:
     // (1) foo$2(a, b) => MyClass.foo$4$c$d.call(this, a, b, null, null)
     // (2) foo$3$c(a, b, c) => MyClass.foo$4$c$d(this, a, b, c, null);
     // (3) foo$3$d(a, b, d) => MyClass.foo$4$c$d(this, a, b, null, d);
 
-    Set<Selector> selectors = member.isInstanceMember()
+    Set<Selector> selectors = member.isInstanceMember
         ? compiler.codegenWorld.invokedNames[member.name]
         : null; // No stubs needed for static methods.
 
     /// Returns all closure call selectors renamed to match this member.
     Set<Selector> callSelectorsAsNamed() {
       if (!canTearOff) return null;
       Set<Selector> callSelectors = compiler.codegenWorld.invokedNames[
           namer.closureInvocationSelectorName];
       if (callSelectors == null) return null;
       return callSelectors.map((Selector callSelector) {
         return new Selector.call(
-            member.name, member.getLibrary(),
+            member.name, member.library,
             callSelector.argumentCount, callSelector.namedArguments);
       }).toSet();
     }
     if (selectors == null) {
       selectors = callSelectorsAsNamed();
       if (selectors == null) return;
     } else {
       Set<Selector> callSelectors = callSelectorsAsNamed();
       if (callSelectors != null) {
         selectors = selectors.union(callSelectors);
       }
     }
     Set<Selector> untypedSelectors = new Set<Selector>();
     if (selectors != null) {
       for (Selector selector in selectors) {
         if (!selector.appliesUnnamed(member, compiler)) continue;
         if (untypedSelectors.add(selector.asUntyped)) {
           // TODO(ahe): Is the last argument to [addParameterStub] needed?
           addParameterStub(member, selector, defineStub, new Set<String>());
         }
       }
     }
     if (canTearOff) {
       selectors = compiler.codegenWorld.invokedNames[
           namer.closureInvocationSelectorName];
       if (selectors != null) {
         for (Selector selector in selectors) {
           selector = new Selector.call(
-              member.name, member.getLibrary(),
+              member.name, member.library,
               selector.argumentCount, selector.namedArguments);
           if (!selector.appliesUnnamed(member, compiler)) continue;
           if (untypedSelectors.add(selector)) {
             // TODO(ahe): Is the last argument to [addParameterStub] needed?
             addParameterStub(member, selector, defineStub, new Set<String>());
           }
         }
       }
     }
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [member] must be a declaration element.
    */
   void emitCallStubForGetter(Element member,
                              Set<Selector> selectors,
                              AddPropertyFunction addProperty) {
     assert(invariant(member, member.isDeclaration));
-    LibraryElement memberLibrary = member.getLibrary();
+    LibraryElement memberLibrary = member.library;
     // If the method is intercepted, the stub gets the
     // receiver explicitely and we need to pass it to the getter call.
     bool isInterceptedMethod = backend.isInterceptedMethod(member);
     bool isInterceptorClass =
-        backend.isInterceptorClass(member.getEnclosingClass());
+        backend.isInterceptorClass(member.enclosingClass);
 
     const String receiverArgumentName = r'$receiver';
 
     jsAst.Expression buildGetter() {
       jsAst.Expression receiver =
           js(isInterceptorClass ? receiverArgumentName : 'this');
-      if (member.isGetter()) {
+      if (member.isGetter) {
         String getterName = namer.getterName(member);
         if (isInterceptedMethod) {
           return js('this.#(#)', [getterName, receiver]);
         }
         return js('#.#()', [receiver, getterName]);
       } else {
         String fieldName = namer.instanceFieldPropertyName(member);
         return js('#.#', [receiver, fieldName]);
       }
     }
@@ skipping 33 matching lines @@
     }
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [member] must be a declaration element.
    */
   void emitExtraAccessors(Element member, ClassBuilder builder) {
     assert(invariant(member, member.isDeclaration));
-    if (member.isGetter() || member.isField()) {
+    if (member.isGetter || member.isField) {
       Set<Selector> selectors = compiler.codegenWorld.invokedNames[member.name];
       if (selectors != null && !selectors.isEmpty) {
         emitCallStubForGetter(member, selectors, builder.addProperty);
       }
     }
   }
 
   void addMember(Element member, ClassBuilder builder) {
     assert(invariant(member, member.isDeclaration));
 
-    if (member.isField()) {
+    if (member.isField) {
       addMemberField(member, builder);
-    } else if (member.isFunction() ||
-               member.isGenerativeConstructorBody() ||
-               member.isGenerativeConstructor() ||
-               member.isAccessor()) {
+    } else if (member.isFunction ||
+               member.isGenerativeConstructorBody ||
+               member.isGenerativeConstructor ||
+               member.isAccessor) {
       addMemberMethod(member, builder);
     } else {
       compiler.internalError(member,
           'Unexpected kind: "${member.kind}".');
     }
-    if (member.isInstanceMember()) emitExtraAccessors(member, builder);
+    if (member.isInstanceMember) emitExtraAccessors(member, builder);
   }
 
   void addMemberMethod(FunctionElement member, ClassBuilder builder) {
     if (member.isAbstract) return;
     jsAst.Expression code = backend.generatedCode[member];
     if (code == null) return;
     String name = namer.getNameOfMember(member);
     task.interceptorEmitter.recordMangledNameOfMemberMethod(member, name);
     FunctionSignature parameters = member.functionSignature;
     bool needsStubs = !parameters.optionalParameters.isEmpty;
     bool canTearOff = false;
     bool isClosure = false;
-    bool isNotApplyTarget = !member.isFunction() ||
-                            member.isConstructor() ||
-                            member.isAccessor();
+    bool isNotApplyTarget = !member.isFunction ||
+                            member.isConstructor ||
+                            member.isAccessor;
     String tearOffName;
     if (isNotApplyTarget) {
       canTearOff = false;
-    } else if (member.isInstanceMember()) {
-      if (member.getEnclosingClass().isClosure()) {
+    } else if (member.isInstanceMember) {
+      if (member.enclosingClass.isClosure) {
         canTearOff = false;
         isClosure = true;
       } else {
         // Careful with operators.
         canTearOff = compiler.codegenWorld.hasInvokedGetter(member, compiler);
         assert(!needsSuperGetter(member) || canTearOff);
         tearOffName = namer.getterName(member);
       }
     } else {
       canTearOff =
@@ skipping 12 matching lines @@
         addParameterStubs(
             member,
             (Selector selector, jsAst.Fun function) {
               builder.addProperty(namer.invocationName(selector), function);
             });
       }
       return;
     }
 
     if (canTearOff) {
-      assert(invariant(member, !member.isGenerativeConstructor()));
-      assert(invariant(member, !member.isGenerativeConstructorBody()));
-      assert(invariant(member, !member.isConstructor()));
+      assert(invariant(member, !member.isGenerativeConstructor));
+      assert(invariant(member, !member.isGenerativeConstructorBody));
+      assert(invariant(member, !member.isConstructor));
     }
 
     // This element is needed for reflection or needs additional stubs. So we
     // need to retain additional information.
 
     // The information is stored in an array with this format:
     //
     // 1.   The JS function for this member.
     // 2.   First stub.
     // 3.   Name of first stub.
     // ...
     // M.   Call name of this member.
     // M+1. Call name of first stub.
     // ...
     // N.   Getter name for tearOff.
-    // N+1. (Required parameter count << 1) + (member.isAccessor() ? 1 : 0).
+    // N+1. (Required parameter count << 1) + (member.isAccessor ? 1 : 0).
     // N+2. (Optional parameter count << 1) +
     //                      (parameters.optionalParametersAreNamed ? 1 : 0).
     // N+3. Index to function type in constant pool.
     // N+4. First default argument.
     // ...
     // O.   First parameter name (if needed for reflection or Function.apply).
     // ...
     // P.   Unmangled name (if reflectable).
     // P+1. First metadata (if reflectable).
     // ...
     // TODO(ahe): Consider one of the parameter counts can be replaced by the
     // length property of the JavaScript function object.
 
     List<jsAst.Expression> expressions = <jsAst.Expression>[];
 
     String callSelectorString = 'null';
-    if (member.isFunction()) {
+    if (member.isFunction) {
       Selector callSelector =
           new Selector.fromElement(member, compiler).toCallSelector();
       callSelectorString = '"${namer.invocationName(callSelector)}"';
     }
 
     // On [requiredParameterCount], the lower bit is set if this method can be
     // called reflectively.
     int requiredParameterCount = parameters.requiredParameterCount << 1;
-    if (member.isAccessor()) requiredParameterCount++;
+    if (member.isAccessor) requiredParameterCount++;
 
     int optionalParameterCount = parameters.optionalParameterCount << 1;
     if (parameters.optionalParametersAreNamed) optionalParameterCount++;
 
     expressions.add(code);
 
     // TODO(sra): Don't use LiteralString for non-strings.
     List tearOffInfo = [new jsAst.LiteralString(callSelectorString)];
 
     if (needsStubs || canTearOff) {
       addParameterStubs(member, (Selector selector, jsAst.Fun function) {
         expressions.add(function);
-        if (member.isInstanceMember()) {
+        if (member.isInstanceMember) {
           Set invokedSelectors =
               compiler.codegenWorld.invokedNames[member.name];
             expressions.add(js.string(namer.invocationName(selector)));
         } else {
           expressions.add(js('null'));
           // TOOD(ahe): Since we know when reading static data versus instance
           // data, we can eliminate this element.
         }
         Set<Selector> callSelectors = compiler.codegenWorld.invokedNames[
             namer.closureInvocationSelectorName];
         Selector callSelector = selector.toCallSelector();
         String callSelectorString = 'null';
         if (canTearOff && callSelectors != null &&
             callSelectors.contains(callSelector)) {
           callSelectorString = '"${namer.invocationName(callSelector)}"';
         }
         tearOffInfo.add(new jsAst.LiteralString(callSelectorString));
       }, canTearOff);
     }
 
     jsAst.Expression memberTypeExpression;
     if (canTearOff || canBeReflected) {
       DartType memberType;
-      if (member.isGenerativeConstructorBody()) {
+      if (member.isGenerativeConstructorBody) {
         var body = member;
         memberType = body.constructor.type;
       } else {
         memberType = member.type;
       }
       if (memberType.containsTypeVariables) {
         jsAst.Expression thisAccess = js(r'this.$receiver');
         memberTypeExpression =
             backend.rti.getSignatureEncoding(memberType, thisAccess);
       } else {
         memberTypeExpression =
             js.number(task.metadataEmitter.reifyType(memberType));
       }
     } else {
       memberTypeExpression = js('null');
     }
 
     expressions
         ..addAll(tearOffInfo)
-        ..add((tearOffName == null || member.isAccessor())
+        ..add((tearOffName == null || member.isAccessor)
               ? js("null") : js.string(tearOffName))
         ..add(js.number(requiredParameterCount))
         ..add(js.number(optionalParameterCount))
         ..add(memberTypeExpression)
         ..addAll(
             task.metadataEmitter.reifyDefaultArguments(member).map(js.number));
 
     if (canBeReflected || canBeApplied) {
       parameters.forEachParameter((Element parameter) {
         expressions.add(
             js.number(task.metadataEmitter.reifyName(parameter.name)));
         if (backend.mustRetainMetadata) {
           List<MetadataAnnotation> annotations = parameter.metadata.toList();
           Iterable<int> metadataIndices =
               annotations.map((MetadataAnnotation annotation) {
             Constant constant =
                 backend.constants.getConstantForMetadata(annotation);
             backend.constants.addCompileTimeConstantForEmission(constant);
             return task.metadataEmitter.reifyMetadata(annotation);
           });
           expressions.add(
               new jsAst.ArrayInitializer.from(metadataIndices.map(js.number)));
         }
       });
     }
     if (canBeReflected) {
       jsAst.LiteralString reflectionName;
-      if (member.isConstructor()) {
+      if (member.isConstructor) {
         String reflectionNameString = task.getReflectionName(member, name);
         reflectionName =
             new jsAst.LiteralString(
                 '"new ${Elements.reconstructConstructorName(member)}"');
       } else {
         reflectionName = js.string(member.name);
       }
       expressions
           ..add(reflectionName)
           ..addAll(task.metadataEmitter.computeMetadata(member).map(js.number));
     } else if (isClosure && canBeApplied) {
       expressions.add(js.string(member.name));
     }
     builder.addProperty(name, new jsAst.ArrayInitializer.from(expressions));
   }
 
   void addMemberField(VariableElement member, ClassBuilder builder) {
     // For now, do nothing.
   }
 }