Convert property methods into getters.

sdk/lib/_internal/compiler/implementation/deferred_load.dart

 // Copyright (c) 2014, 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.
 
 library deferred_load;
 
 import 'dart2jslib.dart' show
     Backend,
     Compiler,
     CompilerTask,
@@ skipping 226 matching lines @@
     for (MetadataAnnotation metadata in metadataList) {
       metadata.ensureResolved(compiler);
       Element element = metadata.value.computeType(compiler).element;
       if (element == deferredLibraryClass) {
         _allDeferredImports[import] = library.getLibraryFromTag(import);
         // On encountering a deferred library without a prefix we report an
         // error, but continue the compilation to possibly give more
         // information. Therefore it is neccessary to check if there is a prefix
         // here.
         Element maybePrefix = library.find(import.prefix.toString());
-        if (maybePrefix != null && maybePrefix.isPrefix()) {
+        if (maybePrefix != null && maybePrefix.isPrefix) {
           PrefixElement prefix = maybePrefix;
           prefix.markAsDeferred(import);
         }
       }
     }
   }
 
   /// Answers whether [element] is explicitly deferred when referred to from
   /// [library].
   bool _isExplicitlyDeferred(Element element, LibraryElement library) {
     Link<Import> imports = _getImports(element, library);
     // If the element is not imported explicitly, it is implicitly imported
     // not deferred.
     if (imports.isEmpty) return false;
     // An element could potentially be loaded by several imports. If all of them
     // is explicitly deferred, we say the element is explicitly deferred.
     // TODO(sigurdm): We might want to give a warning if the imports do not
     // agree.
     return imports.every(_isImportDeferred);
   }
 
   /// Returns a [Link] of every [Import] that imports [element] into [library].
   Link<Import> _getImports(Element element, LibraryElement library) {
-    if (element.isMember()) {
-      element = element.getEnclosingClass();
+    if (element.isMember) {
+      element = element.enclosingClass;
     }
-    if (element.isAccessor()) {
+    if (element.isAccessor) {
       element = (element as FunctionElement).abstractField;
     }
     return library.getImportsFor(element);
   }
 
   /// Replaces the imports of [outputUnit] with those in
   /// [replacementImports]. Because mainOutputUnit has a special handling we
   /// create a new outputUnit instead, and update the mapping from the
   /// dependency to its outputUnit.
   void _replaceOutputUnitImports(dynamic dependency,
@@ skipping 16 matching lines @@
   ///
   /// The collected dependent elements and constants are are added to
   /// [elementDependencies] and [constantDependencies] respectively.
   void _collectDependencies(Element element,
                             Set<Element> elementDependencies,
                             Set<Constant> constantDependencies) {
     TreeElements elements =
         compiler.enqueuer.resolution.getCachedElements(element);
     if (elements == null) return;
     for (Element dependency in elements.allElements) {
-      if (Elements.isLocal(dependency) && !dependency.isFunction()) continue;
+      if (Elements.isLocal(dependency) && !dependency.isFunction) continue;
       if (Elements.isUnresolved(dependency)) continue;
-      if (dependency.isStatement()) continue;
+      if (dependency.isStatement) continue;
       elementDependencies.add(dependency);
     }
     elements.forEachConstantNode((Node n, _) {
       // Explicitly depend on the backend constants.
       constantDependencies.add(
           backend.constants.getConstantForNode(n, elements));
     });
     elementDependencies.addAll(elements.otherDependencies);
   }
 
   /// Finds all elements and constants that [element] depends directly on.
   /// (not the transitive closure.)
   ///
   /// Adds the results to [elements] and [constants].
   void _collectAllElementsAndConstantsResolvedFrom(Element element,
       Set<Element> elements,
       Set<Constant> constants) {
     // TODO(sigurdm): How is metadata on a patch-class handled?
     for (MetadataAnnotation metadata in element.metadata) {
       Constant constant = backend.constants.getConstantForMetadata(metadata);
       if (constant != null) {
         constants.add(constant);
         elements.add(constant.computeType(compiler).element);
       }
     }
-    if (element.isClass()) {
+    if (element.isClass) {
       // If we see a class, add everything its instance members refer
       // to.  Static members are not relevant.
       ClassElement cls = element.declaration;
       cls.forEachLocalMember((Element e) {
-        if (!e.isInstanceMember()) return;
+        if (!e.isInstanceMember) return;
         _collectDependencies(e.implementation, elements, constants);
       });
       if (cls.implementation != cls) {
         // TODO(ahe): Why doesn't ClassElement.forEachLocalMember do this?
         cls.implementation.forEachLocalMember((Element e) {
-          if (!e.isInstanceMember()) return;
+          if (!e.isInstanceMember) return;
           _collectDependencies(e.implementation, elements, constants);
         });
       }
       for (var type in cls.implementation.allSupertypes) {
         elements.add(type.element.implementation);
       }
       elements.add(cls.implementation);
     } else if (Elements.isStaticOrTopLevel(element) ||
-               element.isConstructor()) {
+               element.isConstructor) {
       _collectDependencies(element, elements, constants);
     }
-    if (element.isGenerativeConstructor()) {
+    if (element.isGenerativeConstructor) {
       // When instantiating a class, we record a reference to the
       // constructor, not the class itself.  We must add all the
       // instance members of the constructor's class.
       ClassElement implementation =
-          element.getEnclosingClass().implementation;
+          element.enclosingClass.implementation;
       _collectAllElementsAndConstantsResolvedFrom(
           implementation, elements, constants);
     }
 
     // Other elements, in particular instance members, are ignored as
     // they are processed as part of the class.
   }
 
   /// Returns the transitive closure of all libraries that are imported
   /// from root without DeferredLibrary annotations.
@@ skipping 34 matching lines @@
 
     // Here we modify [_importedDeferredBy].
     elements.add(element);
 
     Set<Element> dependentElements = new Set<Element>();
 
     // This call can modify [_importedDeferredBy] and [_constantsDeferredBy].
     _collectAllElementsAndConstantsResolvedFrom(
         element, dependentElements, constants);
 
-    LibraryElement library = element.getLibrary();
+    LibraryElement library = element.library;
     for (Element dependency in dependentElements) {
       if (_isExplicitlyDeferred(dependency, library)) {
         for (Import deferredImport in _getImports(dependency, library)) {
           _mapDependencies(dependency, deferredImport);
         };
       } else {
         _mapDependencies(dependency, import);
       }
     }
   }
@@ skipping 45 matching lines @@
             // class will not be resolved. We just skip it.
             if (element is ClassElement &&!element.isResolved) {
               return;
             }
             _mapDependencies(element, deferredImport);
           }
 
           for (MirrorUsage usage in mirrorUsages) {
             if (usage.targets != null) {
               for (Element dependency in usage.targets) {
-                if (dependency.isLibrary()) {
+                if (dependency.isLibrary) {
                   LibraryElement library = dependency;
                   library.forEachLocalMember(mapDependenciesIfResolved);
                 } else {
                   mapDependenciesIfResolved(dependency);
                 }
               }
             }
             if (usage.metaTargets != null) {
               for (Element dependency in usage.metaTargets) {
                 _mapDependencies(dependency, deferredImport);
@@ skipping 191 matching lines @@
       }
     }
   }
 
   void onResolutionComplete(FunctionElement main) {
     if (!splitProgram) {
       allOutputUnits.add(mainOutputUnit);
       return;
     }
     if (main == null) return;
-    LibraryElement mainLibrary = main.getLibrary();
+    LibraryElement mainLibrary = main.library;
     _importedDeferredBy = new Map<Import, Set<Element>>();
     _constantsDeferredBy = new Map<Import, Set<Constant>>();
     _importedDeferredBy[_fakeMainImport] = _mainElements;
 
     measureElement(mainLibrary, () {
 
       // Starting from main, traverse the program and find all dependencies.
       _mapDependencies(compiler.mainFunction, _fakeMainImport);
 
       // Also add "global" dependencies to the main OutputUnit.  These are
@@ skipping 137 matching lines @@
   ///
   /// Returns null for a.loadLibrary() (the special
   /// function loadLibrary is not deferred). And returns the PrefixElement for
   /// a.run() and a.foo.
   /// a.loadLibrary.toString() and a.foo.method() are dynamic sends - and
   /// this functions should not be called on them.
   PrefixElement deferredPrefixElement(ast.Send send, TreeElements elements) {
     Element element = elements[send];
     // The DeferredLoaderGetter is not deferred, therefore we do not return the
     // prefix.
-    if (element != null && element.isDeferredLoaderGetter()) return null;
+    if (element != null && element.isDeferredLoaderGetter) return null;
 
     ast.Node firstNode(ast.Node node) {
       if (node is! ast.Send) {
         return node;
       } else {
         ast.Send send = node;
         ast.Node receiver = send.receiver;
         ast.Node receiverFirst = firstNode(receiver);
         if (receiverFirst != null) {
           return receiverFirst;
         } else {
           return firstNode(send.selector);
         }
       }
     }
     ast.Node first = firstNode(send);
     ast.Node identifier = first.asIdentifier();
     if (identifier == null) return null;
     Element maybePrefix = elements[identifier];
-    if (maybePrefix != null && maybePrefix.isPrefix()) {
+    if (maybePrefix != null && maybePrefix.isPrefix) {
       PrefixElement prefixElement = maybePrefix;
       if (prefixElement.isDeferred) {
         return prefixElement;
       }
     }
     return null;
   }
 }