Convert property methods into getters.

sdk/lib/_internal/compiler/implementation/patch_parser.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.
 
 /**
  * This library contains the infrastructure to parse and integrate patch files.
  *
  * Three types of elements can be patched: [LibraryElement], [ClassElement],
  * [FunctionElement]. Patches are introduced in patch libraries which are loaded
  * together with the corresponding origin library. Which libraries that are
@@ skipping 316 matching lines @@
 
   void addLibraryTag(tree.LibraryTag tag) {
     super.addLibraryTag(tag);
     imports.addLast(tag);
   }
 
   void pushElement(Element patch) {
     if (isMemberPatch || (isClassPatch && patch is ClassElement)) {
       // Apply patch.
       patch.addMetadata(popMetadataHack());
-      LibraryElement originLibrary = compilationUnitElement.getLibrary();
+      LibraryElement originLibrary = compilationUnitElement.library;
       assert(originLibrary.isPatched);
       Element origin = originLibrary.localLookup(patch.name);
       patchElement(listener, origin, patch);
     }
     super.pushElement(patch);
   }
 }
 
 /**
  * Extension of [MemberListener] for parsing patch class bodies.
@@ skipping 49 matching lines @@
 }
 
 void patchElement(leg.DiagnosticListener listener,
                    Element origin,
                    Element patch) {
   if (origin == null) {
     listener.reportError(
         patch, leg.MessageKind.PATCH_NON_EXISTING, {'name': patch.name});
     return;
   }
-  if (!(origin.isClass() ||
-        origin.isConstructor() ||
-        origin.isFunction() ||
-        origin.isAbstractField())) {
+  if (!(origin.isClass ||
+        origin.isConstructor ||
+        origin.isFunction ||
+        origin.isAbstractField)) {
     // TODO(ahe): Remove this error when the parser rejects all bad modifiers.
     listener.reportError(origin, leg.MessageKind.PATCH_NONPATCHABLE);
     return;
   }
-  if (patch.isClass()) {
+  if (patch.isClass) {
     tryPatchClass(listener, origin, patch);
-  } else if (patch.isGetter()) {
+  } else if (patch.isGetter) {
     tryPatchGetter(listener, origin, patch);
-  } else if (patch.isSetter()) {
+  } else if (patch.isSetter) {
     tryPatchSetter(listener, origin, patch);
-  } else if (patch.isConstructor()) {
+  } else if (patch.isConstructor) {
     tryPatchConstructor(listener, origin, patch);
-  } else if(patch.isFunction()) {
+  } else if(patch.isFunction) {
     tryPatchFunction(listener, origin, patch);
   } else {
     // TODO(ahe): Remove this error when the parser rejects all bad modifiers.
     listener.reportError(patch, leg.MessageKind.PATCH_NONPATCHABLE);
   }
 }
 
 void tryPatchClass(leg.DiagnosticListener listener,
                     Element origin,
                     ClassElement patch) {
-  if (!origin.isClass()) {
+  if (!origin.isClass) {
     listener.reportError(
         origin, leg.MessageKind.PATCH_NON_CLASS, {'className': patch.name});
     listener.reportInfo(
         patch, leg.MessageKind.PATCH_POINT_TO_CLASS, {'className': patch.name});
     return;
   }
   patchClass(listener, origin, patch);
 }
 
 void patchClass(leg.DiagnosticListener listener,
                 ClassElementX origin,
                 ClassElementX patch) {
   if (origin.isPatched) {
     listener.internalError(origin,
         "Patching the same class more than once.");
   }
   origin.applyPatch(patch);
 }
 
 void tryPatchGetter(leg.DiagnosticListener listener,
                     Element origin,
                     FunctionElement patch) {
-  if (!origin.isAbstractField()) {
+  if (!origin.isAbstractField) {
     listener.reportError(
         origin, leg.MessageKind.PATCH_NON_GETTER, {'name': origin.name});
     listener.reportInfo(
         patch,
         leg.MessageKind.PATCH_POINT_TO_GETTER, {'getterName': patch.name});
     return;
   }
   AbstractFieldElement originField = origin;
   if (originField.getter == null) {
     listener.reportError(
         origin, leg.MessageKind.PATCH_NO_GETTER, {'getterName': patch.name});
     listener.reportInfo(
         patch,
         leg.MessageKind.PATCH_POINT_TO_GETTER, {'getterName': patch.name});
     return;
   }
   patchFunction(listener, originField.getter, patch);
 }
 
 void tryPatchSetter(leg.DiagnosticListener listener,
                      Element origin,
                      FunctionElement patch) {
-  if (!origin.isAbstractField()) {
+  if (!origin.isAbstractField) {
     listener.reportError(
         origin, leg.MessageKind.PATCH_NON_SETTER, {'name': origin.name});
     listener.reportInfo(
         patch,
         leg.MessageKind.PATCH_POINT_TO_SETTER, {'setterName': patch.name});
     return;
   }
   AbstractFieldElement originField = origin;
   if (originField.setter == null) {
     listener.reportError(
         origin, leg.MessageKind.PATCH_NO_SETTER, {'setterName': patch.name});
     listener.reportInfo(
         patch,
         leg.MessageKind.PATCH_POINT_TO_SETTER, {'setterName': patch.name});
     return;
   }
   patchFunction(listener, originField.setter, patch);
 }
 
 void tryPatchConstructor(leg.DiagnosticListener listener,
                           Element origin,
                           FunctionElement patch) {
-  if (!origin.isConstructor()) {
+  if (!origin.isConstructor) {
     listener.reportError(
         origin,
         leg.MessageKind.PATCH_NON_CONSTRUCTOR, {'constructorName': patch.name});
     listener.reportInfo(
         patch,
         leg.MessageKind.PATCH_POINT_TO_CONSTRUCTOR,
         {'constructorName': patch.name});
     return;
   }
   patchFunction(listener, origin, patch);
 }
 
 void tryPatchFunction(leg.DiagnosticListener listener,
                       Element origin,
                       FunctionElement patch) {
-  if (!origin.isFunction()) {
+  if (!origin.isFunction) {
     listener.reportError(
         origin,
         leg.MessageKind.PATCH_NON_FUNCTION, {'functionName': patch.name});
     listener.reportInfo(
         patch,
         leg.MessageKind.PATCH_POINT_TO_FUNCTION, {'functionName': patch.name});
     return;
   }
   patchFunction(listener, origin, patch);
 }
 
 void patchFunction(leg.DiagnosticListener listener,
                    FunctionElementX origin,
                    FunctionElementX patch) {
-  if (!origin.modifiers.isExternal()) {
+  if (!origin.modifiers.isExternal) {
     listener.reportError(origin, leg.MessageKind.PATCH_NON_EXTERNAL);
     listener.reportInfo(
         patch,
         leg.MessageKind.PATCH_POINT_TO_FUNCTION, {'functionName': patch.name});
     return;
   }
   if (origin.isPatched) {
     listener.internalError(origin,
         "Trying to patch a function more than once.");
   }
   if (origin.cachedNode != null) {
     listener.internalError(origin,
         "Trying to patch an already compiled function.");
   }
   origin.applyPatch(patch);
 }
 
 // TODO(johnniwinther): Add unittest when patch is (real) metadata.
 bool isPatchElement(Element element) {
   // TODO(lrn): More checks needed if we introduce metadata for real.
   // In that case, it must have the identifier "native" as metadata.
   for (Link link = element.metadata; !link.isEmpty; link = link.tail) {
     if (link.head is PatchMetadataAnnotation) return true;
   }
   return false;
 }