Convert property methods into getters.

sdk/lib/_internal/compiler/implementation/js_backend/backend.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.
 
 part of js_backend;
 
 const VERBOSE_OPTIMIZER_HINTS = false;
 
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked = new Set<HInstruction>();
@@ skipping 304 matching lines @@
     return constantCompilerTask.jsConstantCompiler;
   }
 
   static Namer determineNamer(Compiler compiler) {
     return compiler.enableMinification ?
         new MinifyNamer(compiler) :
         new Namer(compiler);
   }
 
   bool usedByBackend(Element element) {
-    if (element.isParameter()
-        || element.isFieldParameter()
-        || element.isField()) {
+    if (element.isParameter
+        || element.isFieldParameter
+        || element.isField) {
       if (usedByBackend(element.enclosingElement)) return true;
     }
     return helpersUsed.contains(element.declaration);
   }
 
   bool invokedReflectively(Element element) {
-    if (element.isParameter() || element.isFieldParameter()) {
+    if (element.isParameter || element.isFieldParameter) {
       if (invokedReflectively(element.enclosingElement)) return true;
     }
 
-    if (element.isField()) {
+    if (element.isField) {
       if (Elements.isStaticOrTopLevel(element)
-          && (element.modifiers.isFinal() || element.modifiers.isConst())) {
+          && (element.modifiers.isFinal || element.modifiers.isConst)) {
         return false;
       }
     }
 
     return isNeededForReflection(element.declaration);
   }
 
   bool canBeUsedForGlobalOptimizations(Element element) {
     return !usedByBackend(element) && !invokedReflectively(element);
   }
@@ skipping 10 matching lines @@
     Set<ClassElement> classes = getInterceptedClassesOn(selector.name);
     String name = namer.getOneShotInterceptorName(selector, classes);
     if (!oneShotInterceptors.containsKey(name)) {
       registerSpecializedGetInterceptor(classes);
       oneShotInterceptors[name] = selector;
     }
     return name;
   }
 
   bool isInterceptedMethod(Element element) {
-    if (!element.isInstanceMember()) return false;
-    if (element.isGenerativeConstructorBody()) {
-      return Elements.isNativeOrExtendsNative(element.getEnclosingClass());
+    if (!element.isInstanceMember) return false;
+    if (element.isGenerativeConstructorBody) {
+      return Elements.isNativeOrExtendsNative(element.enclosingClass);
     }
     return interceptedElements[element.name] != null;
   }
 
   bool fieldHasInterceptedGetter(Element element) {
-    assert(element.isField());
+    assert(element.isField);
     return interceptedElements[element.name] != null;
   }
 
   bool fieldHasInterceptedSetter(Element element) {
-    assert(element.isField());
+    assert(element.isField);
     return interceptedElements[element.name] != null;
   }
 
   bool isInterceptedName(String name) {
     return interceptedElements[name] != null;
   }
 
   bool isInterceptedSelector(Selector selector) {
     return interceptedElements[selector.name] != null;
   }
 
   /**
    * Returns `true` iff [selector] matches an element defined in a class mixed
    * into an intercepted class.  These selectors are not eligible for the 'dummy
    * explicit receiver' optimization.
    */
   bool isInterceptedMixinSelector(Selector selector) {
     Set<Element> elements = interceptedMixinElements.putIfAbsent(
         selector.name,
         () {
           Set<Element> elements = interceptedElements[selector.name];
           if (elements == null) return null;
           return elements
               .where((element) =>
                   classesMixedIntoInterceptedClasses.contains(
-                      element.getEnclosingClass()))
+                      element.enclosingClass))
               .toSet();
         });
 
     if (elements == null) return false;
     if (elements.isEmpty) return false;
     return elements.any((element) => selector.applies(element, compiler));
   }
 
   final Map<String, Set<ClassElement>> interceptedClassesCache =
       new Map<String, Set<ClassElement>>();
 
   /**
    * Returns a set of interceptor classes that contain a member named
    * [name]. Returns [:null:] if there is no class.
    */
   Set<ClassElement> getInterceptedClassesOn(String name) {
     Set<Element> intercepted = interceptedElements[name];
     if (intercepted == null) return null;
     return interceptedClassesCache.putIfAbsent(name, () {
       // Populate the cache by running through all the elements and
       // determine if the given selector applies to them.
       Set<ClassElement> result = new Set<ClassElement>();
       for (Element element in intercepted) {
-        ClassElement classElement = element.getEnclosingClass();
+        ClassElement classElement = element.enclosingClass;
         if (Elements.isNativeOrExtendsNative(classElement)
             || interceptedClasses.contains(classElement)) {
           result.add(classElement);
         }
         if (classesMixedIntoInterceptedClasses.contains(classElement)) {
           Set<ClassElement> nativeSubclasses =
               nativeSubclassesOfMixin(classElement);
           if (nativeSubclasses != null) result.addAll(nativeSubclasses);
         }
       }
@@ skipping 14 matching lines @@
             result.add(subclass);
           }
         }
       }
     }
     return result;
   }
 
   bool operatorEqHandlesNullArgument(FunctionElement operatorEqfunction) {
     return specialOperatorEqClasses.contains(
-        operatorEqfunction.getEnclosingClass());
+        operatorEqfunction.enclosingClass);
   }
 
   void initializeHelperClasses() {
     getInterceptorMethod = compiler.findInterceptor('getInterceptor');
     interceptedNames = compiler.findInterceptor('interceptedNames');
     mapTypeToInterceptor = compiler.findInterceptor('mapTypeToInterceptor');
     getNativeInterceptorMethod =
         compiler.findInterceptor('getNativeInterceptor');
 
     // These methods are overwritten with generated versions.
@@ skipping 41 matching lines @@
     if (jsFixedArrayClass != null) {
       jsFixedArrayClass.ensureResolved(compiler);
     }
     if (jsExtendableArrayClass != null) {
       jsExtendableArrayClass.ensureResolved(compiler);
     }
 
     jsIndexableClass.ensureResolved(compiler);
     jsIndexableLength = compiler.lookupElementIn(
         jsIndexableClass, 'length');
-    if (jsIndexableLength != null && jsIndexableLength.isAbstractField()) {
+    if (jsIndexableLength != null && jsIndexableLength.isAbstractField) {
       AbstractFieldElement element = jsIndexableLength;
       jsIndexableLength = element.getter;
     }
 
     jsArrayClass.ensureResolved(compiler);
     jsArrayTypedConstructor = compiler.lookupElementIn(jsArrayClass, 'typed');
     jsArrayRemoveLast = compiler.lookupElementIn(jsArrayClass, 'removeLast');
     jsArrayAdd = compiler.lookupElementIn(jsArrayClass, 'add');
 
     jsStringClass.ensureResolved(compiler);
@@ skipping 32 matching lines @@
     noThrowsClass = compiler.findHelper('NoThrows');
     noInlineClass = compiler.findHelper('NoInline');
     irRepresentationClass = compiler.findHelper('IrRepresentation');
   }
 
   void validateInterceptorImplementsAllObjectMethods(
       ClassElement interceptorClass) {
     if (interceptorClass == null) return;
     interceptorClass.ensureResolved(compiler);
     compiler.objectClass.forEachMember((_, Element member) {
-      if (member.isGenerativeConstructor()) return;
+      if (member.isGenerativeConstructor) return;
       Element interceptorMember = interceptorClass.lookupMember(member.name);
       // Interceptors must override all Object methods due to calling convention
       // differences.
-      assert(interceptorMember.getEnclosingClass() == interceptorClass);
+      assert(interceptorMember.enclosingClass == interceptorClass);
     });
   }
 
   void addInterceptorsForNativeClassMembers(
       ClassElement cls, Enqueuer enqueuer) {
     if (enqueuer.isResolutionQueue) {
       cls.ensureResolved(compiler);
       cls.forEachMember((ClassElement classElement, Element member) {
         if (member.name == Compiler.CALL_OPERATOR_NAME) {
           compiler.reportError(
@@ skipping 153 matching lines @@
         enqueueClass(enqueuer, jsPlainJavaScriptObjectClass, elements);
       } else if (cls == mapLiteralClass) {
         // For map literals, the dependency between the implementation class
         // and [Map] is not visible, so we have to add it manually.
         Element getFactory(String name, int arity) {
           // The constructor is on the patch class, but dart2js unit tests don't
           // have a patch class.
           ClassElement implementation = cls.patch != null ? cls.patch : cls;
           return implementation.lookupConstructor(
             new Selector.callConstructor(
-                name, mapLiteralClass.getLibrary(), arity),
+                name, mapLiteralClass.library, arity),
             (element) {
               compiler.internalError(mapLiteralClass,
                   "Map literal class $mapLiteralClass missing "
                   "'$name' constructor"
                   "  ${mapLiteralClass.constructors}");
             });
         }
         mapLiteralConstructor = getFactory('_literal', 1);
         mapLiteralConstructorEmpty = getFactory('_empty', 0);
         enqueueInResolution(mapLiteralConstructor, elements);
@@ skipping 120 matching lines @@
   }
 
   void registerTypeLiteral(Element element,
                            Enqueuer enqueuer,
                            TreeElements elements) {
     enqueuer.registerInstantiatedClass(typeImplementation, elements);
     enqueueInResolution(getCreateRuntimeType(), elements);
     // TODO(ahe): Might want to register [element] as an instantiated class
     // when reflection is used.  However, as long as we disable tree-shaking
     // eagerly it doesn't matter.
-    if (element.isTypedef()) {
+    if (element.isTypedef) {
       typedefTypeLiterals.add(element);
     }
     customElementsAnalysis.registerTypeLiteral(element, enqueuer);
   }
 
   void registerStackTraceInCatch(TreeElements elements) {
     enqueueInResolution(getTraceFromException(), elements);
   }
 
   void registerGetRuntimeTypeArgument(TreeElements elements) {
@@ skipping 85 matching lines @@
         if (inCheckedMode) {
           enqueueInResolution(getAssertSubtypeOfRuntimeType(), elements);
         }
       }
       enqueueClass(world, compiler.listClass, elements);
     }
     if (type is FunctionType) {
       enqueueInResolution(
           compiler.findHelper('functionTypeTestMetaHelper'), elements);
     }
-    if (type.element.isNative()) {
+    if (type.element.isNative) {
       // We will neeed to add the "$is" and "$as" properties on the
       // JavaScript object prototype, so we make sure
       // [:defineProperty:] is compiled.
       enqueue(world,
               compiler.findHelper('defineProperty'),
               elements);
     }
   }
 
   void registerAsCheck(DartType type, Enqueuer world, TreeElements elements) {
@@ skipping 67 matching lines @@
   }
 
   void registerRequiredType(DartType type, Element enclosingElement) {
     // If [argument] has type variables or is a type variable, this method
     // registers a RTI dependency between the class where the type variable is
     // defined (that is the enclosing class of the current element being
     // resolved) and the class of [type]. If the class of [type] requires RTI,
     // then the class of the type variable does too.
     ClassElement contextClass = Types.getClassContext(type);
     if (contextClass != null) {
-      assert(contextClass == enclosingElement.getEnclosingClass().declaration);
+      assert(contextClass == enclosingElement.enclosingClass.declaration);
       rti.registerRtiDependency(type.element, contextClass);
     }
   }
 
   void registerClassUsingVariableExpression(ClassElement cls) {
     rti.classesUsingTypeVariableExpression.add(cls);
   }
 
   bool classNeedsRti(ClassElement cls) {
     return rti.classesNeedingRti.contains(cls.declaration) ||
         compiler.enabledRuntimeType;
   }
 
   bool isDefaultNoSuchMethodImplementation(Element element) {
     assert(element.name == Compiler.NO_SUCH_METHOD);
-    ClassElement classElement = element.getEnclosingClass();
+    ClassElement classElement = element.enclosingClass;
     return classElement == compiler.objectClass
         || classElement == jsInterceptorClass
         || classElement == jsNullClass;
   }
 
   bool isDefaultEqualityImplementation(Element element) {
     assert(element.name == '==');
-    ClassElement classElement = element.getEnclosingClass();
+    ClassElement classElement = element.enclosingClass;
     return classElement == compiler.objectClass
         || classElement == jsInterceptorClass
         || classElement == jsNullClass;
   }
 
   bool methodNeedsRti(FunctionElement function) {
     return rti.methodsNeedingRti.contains(function) ||
            compiler.enabledRuntimeType;
   }
 
@@ skipping 39 matching lines @@
     enqueue(MapConstant.DART_CLASS);
     enqueue(MapConstant.DART_PROTO_CLASS);
     enqueue(MapConstant.DART_STRING_CLASS);
     enqueue(MapConstant.DART_GENERAL_CLASS);
   }
 
   void codegen(CodegenWorkItem work) {
     Element element = work.element;
     var kind = element.kind;
     if (kind == ElementKind.TYPEDEF) return;
-    if (element.isConstructor() && element.getEnclosingClass() == jsNullClass) {
+    if (element.isConstructor && element.enclosingClass == jsNullClass) {
       // Work around a problem compiling JSNull's constructor.
       return;
     }
     if (kind.category == ElementCategory.VARIABLE) {
       Constant initialValue = constants.getConstantForVariable(element);
       if (initialValue != null) {
         registerCompileTimeConstant(initialValue, work.resolutionTree);
         constants.addCompileTimeConstantForEmission(initialValue);
         // We don't need to generate code for static or top-level
         // variables. For instance variables, we may need to generate
@@ skipping 16 matching lines @@
   native.NativeEnqueuer nativeResolutionEnqueuer(Enqueuer world) {
     return new native.NativeResolutionEnqueuer(world, compiler);
   }
 
   native.NativeEnqueuer nativeCodegenEnqueuer(Enqueuer world) {
     return new native.NativeCodegenEnqueuer(world, compiler, emitter);
   }
 
   ClassElement defaultSuperclass(ClassElement element) {
     // Native classes inherit from Interceptor.
-    return element.isNative() ? jsInterceptorClass : compiler.objectClass;
+    return element.isNative ? jsInterceptorClass : compiler.objectClass;
   }
 
   /**
    * Unit test hook that returns code of an element as a String.
    *
    * Invariant: [element] must be a declaration element.
    */
   String assembleCode(Element element) {
     assert(invariant(element, element.isDeclaration));
     return jsAst.prettyPrint(generatedCode[element], compiler).getText();
@@ skipping 350 matching lines @@
     if (element == disableTreeShakingMarker) {
       compiler.disableTypeInferenceForMirrors = true;
       isTreeShakingDisabled = true;
       typeVariableHandler.onTreeShakingDisabled(enqueuer);
     } else if (element == preserveNamesMarker) {
       mustPreserveNames = true;
     } else if (element == preserveMetadataMarker) {
       mustRetainMetadata = true;
     } else if (element == getIsolateAffinityTagMarker) {
       needToInitializeIsolateAffinityTag = true;
-    } else if (element.isDeferredLoaderGetter()) {
+    } else if (element.isDeferredLoaderGetter) {
       // TODO(sigurdm): Create a function registerLoadLibraryAccess.
       if (compiler.loadLibraryFunction == null) {
         compiler.loadLibraryFunction =
             compiler.findHelper("_loadLibraryWrapper");
         enqueueInResolution(compiler.loadLibraryFunction,
                             compiler.globalDependencies);
       }
     }
     customElementsAnalysis.registerStaticUse(element, enqueuer);
   }
@@ skipping 66 matching lines @@
                            Set<Element> metaTargets) {
     if (symbols == null && targets == null && metaTargets == null) {
       // The user didn't specify anything, or there are imports of
       // 'dart:mirrors' without @MirrorsUsed.
       hasInsufficientMirrorsUsed = true;
       return;
     }
     if (symbols != null) symbolsUsed.addAll(symbols);
     if (targets != null) {
       for (Element target in targets) {
-        if (target.isAbstractField()) {
+        if (target.isAbstractField) {
           AbstractFieldElement field = target;
           targetsUsed.add(field.getter);
           targetsUsed.add(field.setter);
         } else {
           targetsUsed.add(target);
         }
       }
     }
     if (metaTargets != null) metaTargetsUsed.addAll(metaTargets);
   }
@@ skipping 19 matching lines @@
    * is no direct use in the program, but because the reflective system may
    * need to access it.
    */
   bool isNeededForReflection(Element element) {
     element = getDartClass(element);
     if (hasInsufficientMirrorsUsed) return isTreeShakingDisabled;
     /// Record the name of [element] in [symbolsUsed]. Return true for
     /// convenience.
     bool registerNameOf(Element element) {
       symbolsUsed.add(element.name);
-      if (element.isConstructor()) {
-        symbolsUsed.add(element.getEnclosingClass().name);
+      if (element.isConstructor) {
+        symbolsUsed.add(element.enclosingClass.name);
       }
       return true;
     }
 
     Element enclosing = element.enclosingElement;
     if (enclosing != null && isNeededForReflection(enclosing)) {
       return registerNameOf(element);
     }
 
     if (isNeededThroughMetaTarget(element)) {
@@ skipping 64 matching lines @@
   }
 
   /// Returns all static fields that are referenced through [targetsUsed].
   /// If the target is a library or class all nested static fields are
   /// included too.
   Iterable<Element> _findStaticFieldTargets() {
     List staticFields = [];
 
     void addFieldsInContainer(ScopeContainerElement container) {
       container.forEachLocalMember((Element member) {
-        if (!member.isInstanceMember() && member.isField()) {
+        if (!member.isInstanceMember && member.isField) {
           staticFields.add(member);
-        } else if (member.isClass()) {
+        } else if (member.isClass) {
           addFieldsInContainer(member);
         }
       });
     }
 
     for (Element target in targetsUsed) {
       if (target == null) continue;
-      if (target.isField()) {
+      if (target.isField) {
         staticFields.add(target);
-      } else if (target.isLibrary() || target.isClass()) {
+      } else if (target.isLibrary || target.isClass) {
         addFieldsInContainer(target);
       }
     }
     return staticFields;
   }
 
   /// Called when [enqueuer] is empty, but before it is closed.
   void onQueueEmpty(Enqueuer enqueuer) {
     if (!enqueuer.isResolutionQueue && preMirrorsMethodCount == 0) {
       preMirrorsMethodCount = generatedCode.length;
@@ skipping 18 matching lines @@
         registerCompileTimeConstant(
             dependency.constant, dependency.user);
       }
       metadataConstants.clear();
     }
 
     customElementsAnalysis.onQueueEmpty(enqueuer);
   }
 
   void onElementResolved(Element element, TreeElements elements) {
-    LibraryElement library = element.getLibrary();
+    LibraryElement library = element.library;
     if (!library.isPlatformLibrary && !library.canUseNative) return;
     bool hasNoInline = false;
     bool hasNoThrows = false;
     bool hasNoSideEffects = false;
     for (MetadataAnnotation metadata in element.metadata) {
       metadata.ensureResolved(compiler);
       if (!metadata.value.isConstructedObject) continue;
       ObjectConstant value = metadata.value;
       ClassElement cls = value.type.element;
       if (cls == noInlineClass) {
@@ skipping 44 matching lines @@
   }
 }
 
 /// Records that [constant] is used by [user.element].
 class Dependency {
   final Constant constant;
   final TreeElements user;
 
   const Dependency(this.constant, this.user);
 }