Convert property methods into getters.

sdk/lib/_internal/compiler/implementation/js_backend/namer.dart

 // Copyright (c) 2011, 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 js_backend;
 
 /**
  * Assigns JavaScript identifiers to Dart variables, class-names and members.
  */
 class Namer implements ClosureNamer {
@@ skipping 362 matching lines @@
     }
   }
 
   String instanceMethodName(FunctionElement element) {
     // TODO(ahe): Could this be: return invocationName(new
     // Selector.fromElement(element))?
     String elementName = element.name;
     String name = operatorNameToIdentifier(elementName);
     if (name != elementName) return getMappedOperatorName(name);
 
-    LibraryElement library = element.getLibrary();
-    if (element.isGenerativeConstructorBody()) {
+    LibraryElement library = element.library;
+    if (element.isGenerativeConstructorBody) {
       name = Elements.reconstructConstructorNameSourceString(element);
     }
     FunctionSignature signature = element.functionSignature;
     // We don't mangle the closure invoking function name because it
     // is generated by string concatenation in applyFunction from
     // js_helper.dart. To keep code size down, we potentially shorten
     // the prefix though.
     String methodName;
     if (name == closureInvocationSelectorName) {
       methodName = '$callPrefix\$${signature.parameterCount}';
@@ skipping 19 matching lines @@
     // We don't mangle the closure invoking function name because it
     // is generated by string concatenation in applyFunction from
     // js_helper.dart. To keep code size down, we potentially shorten
     // the prefix though.
     if (name == closureInvocationSelectorName) return '$callPrefix\$$arity';
 
     return getMappedInstanceName('$name\$$arity');
   }
 
   String invocationName(Selector selector) {
-    if (selector.isGetter()) {
+    if (selector.isGetter) {
       String proposedName = privateName(selector.library, selector.name);
       return '$getterPrefix${getMappedInstanceName(proposedName)}';
-    } else if (selector.isSetter()) {
+    } else if (selector.isSetter) {
       String proposedName = privateName(selector.library, selector.name);
       return '$setterPrefix${getMappedInstanceName(proposedName)}';
     } else {
       String name = selector.name;
       if (selector.kind == SelectorKind.OPERATOR
           || selector.kind == SelectorKind.INDEX) {
         name = operatorNameToIdentifier(name);
         assert(name != selector.name);
         return getMappedOperatorName(name);
       }
       assert(name == operatorNameToIdentifier(name));
       StringBuffer buffer = new StringBuffer();
       for (String argumentName in selector.getOrderedNamedArguments()) {
         buffer.write('\$${safeName(argumentName)}');
       }
       String suffix = '\$${selector.argumentCount}$buffer';
       // We don't mangle the closure invoking function name because it
       // is generated by string concatenation in applyFunction from
       // js_helper.dart. We potentially shorten the prefix though.
-      if (selector.isClosureCall()) {
+      if (selector.isClosureCall) {
         return "$callPrefix$suffix";
       } else {
         String proposedName = privateName(selector.library, name);
         return getMappedInstanceName('$proposedName$suffix');
       }
     }
   }
 
   /**
    * Returns the internal name used for an invocation mirror of this selector.
    */
   String invocationMirrorInternalName(Selector selector)
       => invocationName(selector);
 
   /**
    * Returns name of accessor (root to getter and setter) for a static or
    * instance field.
    */
   String fieldAccessorName(Element element) {
-    return element.isInstanceMember()
+    return element.isInstanceMember
         ? instanceFieldAccessorName(element)
         : getNameOfField(element);
   }
 
   /**
    * Returns name of the JavaScript property used to store a static or instance
    * field.
    */
   String fieldPropertyName(Element element) {
-    return element.isInstanceMember()
+    return element.isInstanceMember
         ? instanceFieldPropertyName(element)
         : getNameOfField(element);
   }
 
   /**
    * Returns name of accessor (root to getter and setter) for an instance field.
    */
   String instanceFieldAccessorName(Element element) {
-    String proposedName = privateName(element.getLibrary(), element.name);
+    String proposedName = privateName(element.library, element.name);
     return getMappedInstanceName(proposedName);
   }
 
   String readTypeVariableName(TypeVariableElement element) {
     return '\$tv_${instanceFieldAccessorName(element)}';
   }
 
   /**
    * Returns name of the JavaScript property used to store an instance field.
    */
   String instanceFieldPropertyName(Element element) {
-    if (element.hasFixedBackendName()) {
-      return element.fixedBackendName();
+    if (element.hasFixedBackendName) {
+      return element.fixedBackendName;
     }
     // If a class is used anywhere as a mixin, we must make the name unique so
     // that it does not accidentally shadow.  Also, the mixin name must be
     // constant over all mixins.
-    if (compiler.world.isUsedAsMixin(element.getEnclosingClass()) ||
+    if (compiler.world.isUsedAsMixin(element.enclosingClass) ||
         shadowingAnotherField(element)) {
       // Construct a new name for the element based on the library and class it
       // is in.  The name here is not important, we just need to make sure it is
       // unique.  If we are minifying, we actually construct the name from the
       // minified version of the class name, but the result is minified once
       // again, so that is not visible in the end result.
-      String libraryName = getNameOfLibrary(element.getLibrary());
-      String className = getNameOfClass(element.getEnclosingClass());
-      String instanceName = privateName(element.getLibrary(), element.name);
+      String libraryName = getNameOfLibrary(element.library);
+      String className = getNameOfClass(element.enclosingClass);
+      String instanceName = privateName(element.library, element.name);
       return getMappedInstanceName('$libraryName\$$className\$$instanceName');
     }
 
-    String proposedName = privateName(element.getLibrary(), element.name);
+    String proposedName = privateName(element.library, element.name);
     return getMappedInstanceName(proposedName);
   }
 
 
   bool shadowingAnotherField(Element element) {
-    return element.getEnclosingClass().hasFieldShadowedBy(element);
+    return element.enclosingClass.hasFieldShadowedBy(element);
   }
 
   String setterName(Element element) {
     // We dynamically create setters from the field-name. The setter name must
     // therefore be derived from the instance field-name.
-    LibraryElement library = element.getLibrary();
+    LibraryElement library = element.library;
     String name = getMappedInstanceName(privateName(library, element.name));
     return '$setterPrefix$name';
   }
 
   String setterNameFromAccessorName(String name) {
     // We dynamically create setters from the field-name. The setter name must
     // therefore be derived from the instance field-name.
     return '$setterPrefix$name';
   }
 
   String getterNameFromAccessorName(String name) {
     // We dynamically create getters from the field-name. The getter name must
     // therefore be derived from the instance field-name.
     return '$getterPrefix$name';
   }
 
   String getterName(Element element) {
     // We dynamically create getters from the field-name. The getter name must
     // therefore be derived from the instance field-name.
-    LibraryElement library = element.getLibrary();
+    LibraryElement library = element.library;
     String name = getMappedInstanceName(privateName(library, element.name));
     return '$getterPrefix$name';
   }
 
   String getMappedGlobalName(String proposedName, {bool ensureSafe: true}) {
     var newName = globalNameMap[proposedName];
     if (newName == null) {
       newName = getFreshName(proposedName, usedGlobalNames,
                              suggestedGlobalNames, ensureSafe: ensureSafe);
       globalNameMap[proposedName] = newName;
@@ skipping 47 matching lines @@
 
   String getClosureVariableName(String name, int id) {
     return "${name}_$id";
   }
 
   /**
    * Returns a preferred JS-id for the given top-level or static element.
    * The returned id is guaranteed to be a valid JS-id.
    */
   String _computeGuess(Element element) {
-    assert(!element.isInstanceMember());
+    assert(!element.isInstanceMember);
     String name;
-    if (element.isGenerativeConstructor()) {
-      name = "${element.getEnclosingClass().name}\$"
+    if (element.isGenerativeConstructor) {
+      name = "${element.enclosingClass.name}\$"
              "${element.name}";
-    } else if (element.isFactoryConstructor()) {
+    } else if (element.isFactoryConstructor) {
       // TODO(johnniwinther): Change factory name encoding as to not include
       // the class-name twice.
-      String className = element.getEnclosingClass().name;
+      String className = element.enclosingClass.name;
       name = '${className}_${Elements.reconstructConstructorName(element)}';
     } else if (Elements.isStaticOrTopLevel(element)) {
-      if (element.isMember()) {
-        ClassElement enclosingClass = element.getEnclosingClass();
+      if (element.isMember) {
+        ClassElement enclosingClass = element.enclosingClass;
         name = "${enclosingClass.name}_"
                "${element.name}";
       } else {
         name = element.name.replaceAll('+', '_');
       }
-    } else if (element.isLibrary()) {
+    } else if (element.isLibrary) {
       LibraryElement library = element;
       name = library.getLibraryOrScriptName();
       if (name.contains('.')) {
         // For libraries that have a library tag, we use the last part
         // of the fully qualified name as their base name. For all other
         // libraries, we use the first part of their filename.
         name = library.hasLibraryName()
             ? name.substring(name.lastIndexOf('.') + 1)
             : name.substring(0, name.indexOf('.'));
       }
@@ skipping 62 matching lines @@
     String root = invocationName(selector);  // Is already safe.
 
     if (classes.contains(backend.jsInterceptorClass)) {
       // If the base Interceptor class is in the set of intercepted classes,
       // this is the most general specialization which uses the generic
       // getInterceptor method.  To keep the name short, we add '$' only to
       // distinguish from global getters or setters; operators and methods can't
       // clash.
       // TODO(sra): Find a way to get the simple name when Object is not in the
       // set of classes for most general variant, e.g. "$lt$n" could be "$lt".
-      if (selector.isGetter() || selector.isSetter()) root = '$root\$';
+      if (selector.isGetter || selector.isSetter) root = '$root\$';
       return getMappedGlobalName(root, ensureSafe: false);
     } else {
       String suffix = getInterceptorSuffix(classes);
       return getMappedGlobalName("$root\$$suffix", ensureSafe: false);
     }
   }
 
   /// Returns the runtime name for [element].  The result is not safe as an id.
   String getRuntimeTypeName(Element element) {
     if (identical(element, compiler.dynamicClass)) return 'dynamic';
     return getNameForRti(element);
   }
 
   /**
    * Returns a preferred JS-id for the given element. The returned id is
    * guaranteed to be a valid JS-id. Globals and static fields are furthermore
    * guaranteed to be unique.
    *
    * For accessing statics consider calling
    * [isolateAccess] or [isolatePropertyAccess] instead.
    */
   // TODO(ahe): This is an internal method to the Namer (and its subclasses)
   // and should not be call from outside.
   String getNameX(Element element) {
-    if (element.isInstanceMember()) {
+    if (element.isInstanceMember) {
       if (element.kind == ElementKind.GENERATIVE_CONSTRUCTOR_BODY
           || element.kind == ElementKind.FUNCTION) {
         return instanceMethodName(element);
       } else if (element.kind == ElementKind.GETTER) {
         return getterName(element);
       } else if (element.kind == ElementKind.SETTER) {
         return setterName(element);
       } else if (element.kind == ElementKind.FIELD) {
         compiler.internalError(element,
             'Use instanceFieldPropertyName or instanceFieldAccessorName.');
@@ skipping 20 matching lines @@
       if (kind == ElementKind.GENERATIVE_CONSTRUCTOR ||
           kind == ElementKind.FUNCTION ||
           kind == ElementKind.CLASS ||
           kind == ElementKind.FIELD ||
           kind == ElementKind.GETTER ||
           kind == ElementKind.SETTER ||
           kind == ElementKind.TYPEDEF ||
           kind == ElementKind.LIBRARY) {
         bool fixedName = false;
         if (Elements.isInstanceField(element)) {
-          fixedName = element.hasFixedBackendName();
+          fixedName = element.hasFixedBackendName;
         }
         String result = fixedName
             ? guess
             : getFreshName(guess, usedGlobalNames, suggestedGlobalNames,
                            ensureSafe: true);
         globals[element] = result;
         return result;
       }
       compiler.internalError(element,
           'getName for unknown kind: ${element.kind}.');
@@ skipping 20 matching lines @@
   /// to store only mutable static state in [currentIsolate], constants are
   /// stored in 'C', and functions, accessors, classes, etc. are stored in one
   /// of the other objects in [reservedGlobalObjectNames].
   bool isPropertyOfCurrentIsolate(Element element) {
     // TODO(ahe): Make sure this method's documentation is always true and
     // remove the word "intend".
     return
         // TODO(ahe): Re-write these tests to be positive (so it only returns
         // true for static/top-level mutable fields). Right now, a number of
         // other elements, such as bound closures also live in [currentIsolate].
-        !element.isAccessor() &&
-        !element.isClass() &&
-        !element.isConstructor() &&
-        !element.isFunction() &&
-        !element.isLibrary();
+        !element.isAccessor &&
+        !element.isClass &&
+        !element.isConstructor &&
+        !element.isFunction &&
+        !element.isLibrary;
   }
 
   /// Returns [currentIsolate] or one of [reservedGlobalObjectNames].
   String globalObjectFor(Element element) {
     if (isPropertyOfCurrentIsolate(element)) return currentIsolate;
-    LibraryElement library = element.getLibrary();
+    LibraryElement library = element.library;
     if (library == compiler.interceptorsLibrary) return 'J';
     if (library.isInternalLibrary) return 'H';
     if (library.isPlatformLibrary) {
       if ('${library.canonicalUri}' == 'dart:html') return 'W';
       return 'P';
     }
     return userGlobalObjects[
         library.getLibraryOrScriptName().hashCode % userGlobalObjects.length];
   }
 
@@ skipping 528 matching lines @@
         if (!first) {
           sb.write('_');
         }
         sb.write('_');
         visit(link.head);
         first = true;
       }
     }
   }
 }