Convert property methods into getters.

sdk/lib/_internal/compiler/implementation/resolution/class_members.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.
 
 library resolution.compute_members;
 
 import '../elements/elements.dart'
     show Element,
          Name,
          PublicName,
@@ skipping 52 matching lines @@
 
   /// Compute all members of [cls] with the given names.
   void computeMembersByName(String name, Setlet<Name> names) {
     computeMembers(name, names);
   }
 
   /// Compute all members of [cls] and checked that [cls] implements its
   /// interface unless it is abstract or declares a `noSuchMethod` method.
   void computeAllMembers() {
     Map<Name, Member> declaredMembers = computeMembers(null, null);
-    if (!cls.modifiers.isAbstract() &&
+    if (!cls.modifiers.isAbstract &&
         !declaredMembers.containsKey(const PublicName('noSuchMethod'))) {
       // Check for unimplemented members on concrete classes that neither have
       // a `@proxy` annotation nor declare a `noSuchMethod` method.
       checkInterfaceImplementation();
     }
   }
 
   /// Compute declared and inherited members of [cls] and return a map of the
   /// declared members.
   ///
@@ skipping 69 matching lines @@
           for (Name memberName in names) {
             inheritMixinMember(
                 mixinApplication.mixin.lookupClassMember(memberName));
           }
         } else {
           computeAllClassMembers(compiler, mixinApplication.mixin);
           mixinApplication.mixin.forEachClassMember(inheritMixinMember);
         }
       }
     } else {
-      LibraryElement library = cls.getLibrary();
+      LibraryElement library = cls.library;
       InterfaceType thisType = cls.thisType;
 
       void createMember(Element element) {
-        if (element.isConstructor()) return;
+        if (element.isConstructor) return;
         String elementName = element.name;
         if (shouldSkipName(elementName)) return;
         if (nameText != null && elementName != nameText) return;
 
         void addDeclaredMember(Name name,
                                DartType type, FunctionType functionType) {
           DeclaredMember inherited = classMembers[name];
           DeclaredMember declared;
           if (element.isAbstract) {
             declared = new DeclaredAbstractMember(
                 name, element, thisType, type, functionType,
                 inherited);
           } else {
             declared =
                 new DeclaredMember(name, element, thisType, type, functionType);
           }
           declaredMembers[name] = declared;
           classMembers[name] = declared;
           checkValidOverride(declared, inherited);
         }
 
         Name name = new Name(element.name, library);
-        if (element.isField()) {
+        if (element.isField) {
           DartType type = element.computeType(compiler);
           addDeclaredMember(name, type,
               new FunctionType(compiler.functionClass, type));
-          if (!element.modifiers.isConst() &&
-              !element.modifiers.isFinal()) {
+          if (!element.modifiers.isConst &&
+              !element.modifiers.isFinal) {
             addDeclaredMember(name.setter, type,
                 new FunctionType(compiler.functionClass,
                                  compiler.types.voidType,
                                  const Link<DartType>().prepend(type)));
           }
-        } else if (element.isGetter()) {
+        } else if (element.isGetter) {
           FunctionType functionType = element.computeType(compiler);
           DartType type = functionType.returnType;
           addDeclaredMember(name, type, functionType);
-        } else if (element.isSetter()) {
+        } else if (element.isSetter) {
           FunctionType functionType = element.computeType(compiler);
           DartType type;
           if (!functionType.parameterTypes.isEmpty) {
             type = functionType.parameterTypes.head;
           } else {
             type = compiler.types.dynamicType;
           }
           name = name.setter;
           addDeclaredMember(name, type, functionType);
         } else {
-          assert(invariant(element, element.isFunction()));
+          assert(invariant(element, element.isFunction));
           FunctionType type = element.computeType(compiler);
           addDeclaredMember(name, type, type);
         }
       }
 
       cls.forEachLocalMember(createMember);
       if (cls.isPatched) {
         cls.implementation.forEachLocalMember((Element element) {
           if (element.isDeclaration) {
             createMember(element);
@@ skipping 207 matching lines @@
   }
 
   void reportErrorWithContext(Element errorneousElement,
                               MessageKind errorMessage,
                               Element contextElement,
                               MessageKind contextMessage) {
     compiler.reportError(
         errorneousElement,
         errorMessage,
         {'memberName': contextElement.name,
-         'className': contextElement.getEnclosingClass().name});
+         'className': contextElement.enclosingClass.name});
     compiler.reportInfo(contextElement, contextMessage);
   }
 
   /// Compute all class and interface names by the [name] in [cls].
   static void computeClassMembersByName(Compiler compiler,
                                         ClassMemberMixin cls,
                                         String name) {
     if (cls.isMemberComputed(name)) return;
-    LibraryElement library = cls.getLibrary();
+    LibraryElement library = cls.library;
     _computeClassMember(compiler, cls, name,
         new Setlet<Name>()..add(new Name(name, library))
                           ..add(new Name(name, library, isSetter: true)));
   }
 
   static void _computeClassMember(Compiler compiler,
                                   ClassMemberMixin cls,
                                   String name,
                                   Setlet<Name> names) {
     cls.computeClassMember(compiler, name, names);
@@ skipping 17 matching lines @@
   Map<Name, Member> computeMembers(String name, Setlet<Name> names) {
     computeSuperMembers(name, names);
     return computeClassMembers(name, names);
   }
 
   void computeSuperMembers(String name, Setlet<Name> names) {
     computeSuperClassMembers(name, names);
   }
 
   void checkInterfaceImplementation() {
-    LibraryElement library = cls.getLibrary();
+    LibraryElement library = cls.library;
     classMembers.forEach((Name name, Member classMember) {
       if (!name.isAccessibleFrom(library)) return;
      checkInterfaceMember(name, classMember, classMember.implementation);
     });
   }
 }
 
 /// Class Member creator for classes where the interface members might be
 /// different from the class members.
 class InterfaceMembersCreator extends MembersCreator {
@@ skipping 80 matching lines @@
         MembersCreator.computeAllClassMembers(compiler, superinterface.element);
         inheritInterfaceMembers(superinterface);
       }
     }
 
     return inheritedInterfaceMembers;
   }
 
   /// Checks that a class member exists for every interface member.
   void checkInterfaceImplementation() {
-    LibraryElement library = cls.getLibrary();
+    LibraryElement library = cls.library;
     interfaceMembers.forEach((Name name, MemberSignature interfaceMember) {
       if (!name.isAccessibleFrom(library)) return;
       Member classMember = classMembers[name];
       if (classMember != null) classMember = classMember.implementation;
       checkInterfaceMember(name, interfaceMember, classMember);
     });
   }
 
   /// Compute the interface members of [cls] given the set of inherited
   /// interface members [inheritedInterfaceMembers] and declared members
@@ skipping 202 matching lines @@
   }
 
   static Iterable<String> _EMPTY_MEMBERS_NAMES = const <String>[];
 
   /// Compute the members by the name [name] for this class. [names] collects
   /// the set of possible variations of [name], including getter, setter and
   /// and private names.
   void computeClassMember(Compiler compiler, String name, Setlet<Name> names) {
     if (isMemberComputed(name)) return;
     if (isPrivateName(name)) {
-      LibraryElement library = getLibrary();
       names..add(new Name(name, library))
            ..add(new Name(name, library, isSetter: true));
     }
     MembersCreator creator = _prepareCreator(compiler);
     creator.computeMembersByName(name, names);
     if (computedMemberNames == null) {
       computedMemberNames = _EMPTY_MEMBERS_NAMES;
     }
     if (name != Compiler.CALL_OPERATOR_NAME) {
       Setlet<String> set;
@@ skipping 56 matching lines @@
         message: "Members have not been fully computed for $this."));
     if (interfaceMembersAreClassMembers) {
       classMembers.forEach((_, member) {
         if (!member.isStatic) f(member);
       });
     } else {
       interfaceMembers.forEach((_, member) => f(member));
     }
   }
 }