Convert property methods into getters.

sdk/lib/_internal/compiler/implementation/mirrors_used.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.
 
 library dart2js.mirrors_used;
 
 import 'dart2jslib.dart' show
     Compiler,
     CompilerTask,
     Constant,
@@ skipping 99 matching lines @@
         symbols == null ? null : new Set<String>.from(symbols),
         targets == null ? null : new Set<Element>.from(targets),
         metaTargets == null ? null : new Set<Element>.from(metaTargets));
     librariesWithUsage = analyzer.librariesWithUsage;
   }
 
   /// Is there a @MirrorsUsed annotation in the library of [element]?  Used by
   /// the resolver to suppress hints about using new Symbol or
   /// MirrorSystem.getName.
   bool hasMirrorUsage(Element element) {
-    LibraryElement library = element.getLibrary();
+    LibraryElement library = element.library;
     // Internal libraries always have implicit mirror usage.
     return library.isInternalLibrary
         || (librariesWithUsage != null
             && librariesWithUsage.contains(library));
   }
 
   /// Call-back from the resolver to analyze MirorsUsed annotations. The result
   /// is stored in [analyzer] and later used to compute
   /// [:analyzer.mergedMirrorUsage:].
   void validate(NewExpression node, TreeElements mapping) {
     for (Node argument in node.send.arguments) {
       NamedArgument named = argument.asNamedArgument();
       if (named == null) continue;
       ConstantCompiler constantCompiler = compiler.resolver.constantCompiler;
       Constant value = constantCompiler.compileNode(named.expression, mapping);
 
       MirrorUsageBuilder builder =
           new MirrorUsageBuilder(
-              analyzer, mapping.currentElement.getLibrary(), named.expression,
+              analyzer, mapping.currentElement.library, named.expression,
               value, mapping);
 
       if (named.name.source == 'symbols') {
         analyzer.cachedStrings[value] =
             builder.convertConstantToUsageList(value, onlyStrings: true);
       } else if (named.name.source == 'targets') {
         analyzer.cachedElements[value] =
             builder.resolveUsageList(builder.convertConstantToUsageList(value));
       } else if (named.name.source == 'metaTargets') {
         analyzer.cachedElements[value] =
@@ skipping 278 matching lines @@
       compiler.reportHint(
           node,
           kind, {'name': node, 'type': apiTypeOf(constant)});
       return null;
     }
   }
 
   /// Find the first non-implementation interface of constant.
   DartType apiTypeOf(Constant constant) {
     DartType type = constant.computeType(compiler);
-    LibraryElement library = type.element.getLibrary();
+    LibraryElement library = type.element.library;
     if (type.kind == TypeKind.INTERFACE && library.isInternalLibrary) {
       InterfaceType interface = type;
       ClassElement cls = type.element;
       cls.ensureResolved(compiler);
       for (DartType supertype in cls.allSupertypes) {
         if (supertype.kind == TypeKind.INTERFACE
-            && !supertype.element.getLibrary().isInternalLibrary) {
+            && !supertype.element.library.isInternalLibrary) {
           return interface.asInstanceOf(supertype.element);
         }
       }
     }
     return type;
   }
 
   /// Convert a list of strings and types to a list of elements. Types are
   /// converted to their corresponding element, and strings are resolved as
   /// follows:
@@ skipping 63 matching lines @@
       return resolveLocalExpression(element, identifiers.sublist(1));
     }
   }
 
   /// Resolve [identifiers] in [element]'s local members.
   Element resolveLocalExpression(Element element, List<String> identifiers) {
     Element current = element;
     for (String identifier in identifiers) {
       Element e = findLocalMemberIn(current, identifier);
       if (e == null) {
-        if (current.isLibrary()) {
+        if (current.isLibrary) {
           LibraryElement library = current;
           compiler.reportHint(
               spannable, MessageKind.MIRRORS_CANNOT_RESOLVE_IN_LIBRARY,
               {'name': identifiers[0],
                'library': library.getLibraryOrScriptName()});
         } else {
           compiler.reportHint(
               spannable, MessageKind.MIRRORS_CANNOT_FIND_IN_ELEMENT,
               {'name': identifier, 'element': current.name});
         }
         return current;
       }
       current = e;
     }
     return current;
   }
 
   /// Helper method to lookup members in a [ScopeContainerElement]. If
   /// [element] is not a ScopeContainerElement, return null.
   Element findLocalMemberIn(Element element, String name) {
     if (element is ScopeContainerElement) {
       ScopeContainerElement scope = element;
-      if (element.isClass()) {
+      if (element.isClass) {
         ClassElement cls = element;
         cls.ensureResolved(compiler);
       }
       return scope.localLookup(name);
     }
     return null;
   }
 
   /// Attempt to find a [Spannable] corresponding to constant.
   Spannable positionOf(Constant constant) {
@@ skipping 19 matching lines @@
       // @MirrorsUsed(targets: fisk)
       //                       ^^^^
       //
       // Instead of saying 'fisk' should pretty print the problematic constant
       // value.
       return spannable;
     }
     return node;
   }
 }