Convert property methods into getters.

sdk/lib/_internal/compiler/implementation/universe/universe.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 universe;
 
 import '../elements/elements.dart';
 import '../dart2jslib.dart';
 import '../dart_types.dart';
 import '../types/types.dart';
@@ skipping 169 matching lines @@
     Selector result = new Selector.internal(
         kind, name, library, argumentCount,
         namedArguments, orderedNamedArguments,
         hashCode);
     list.add(result);
     return result;
   }
 
   factory Selector.fromElement(Element element, Compiler compiler) {
     String name = element.name;
-    if (element.isFunction()) {
+    if (element.isFunction) {
       if (name == '[]') {
         return new Selector.index();
       } else if (name == '[]=') {
         return new Selector.indexSet();
       }
       FunctionSignature signature =
           element.asFunctionElement().computeSignature(compiler);
       int arity = signature.parameterCount;
       List<String> namedArguments = null;
       if (signature.optionalParametersAreNamed) {
         namedArguments =
             signature.orderedOptionalParameters.map((e) => e.name).toList();
       }
       if (Elements.operatorNameToIdentifier(name) != name) {
         // Operators cannot have named arguments, however, that doesn't prevent
         // a user from declaring such an operator.
         return new Selector(
             SelectorKind.OPERATOR, name, null, arity, namedArguments);
       } else {
         return new Selector.call(
-            name, element.getLibrary(), arity, namedArguments);
+            name, element.library, arity, namedArguments);
       }
-    } else if (element.isSetter()) {
-      return new Selector.setter(name, element.getLibrary());
-    } else if (element.isGetter()) {
-      return new Selector.getter(name, element.getLibrary());
-    } else if (element.isField()) {
-      return new Selector.getter(name, element.getLibrary());
+    } else if (element.isSetter) {
+      return new Selector.setter(name, element.library);
+    } else if (element.isGetter) {
+      return new Selector.getter(name, element.library);
+    } else if (element.isField) {
+      return new Selector.getter(name, element.library);
     } else {
       throw new SpannableAssertionFailure(
           element, "Can't get selector from $element");
     }
   }
 
   factory Selector.getter(String name, LibraryElement library)
       => new Selector(SelectorKind.GETTER, name, library, 0);
 
   factory Selector.getterFrom(Selector selector)
@@ skipping 38 matching lines @@
 
   factory Selector.callConstructor(String name, LibraryElement library,
                                    [int arity = 0,
                                     List<String> namedArguments])
       => new Selector(SelectorKind.CALL, name, library,
                       arity, namedArguments);
 
   factory Selector.callDefaultConstructor(LibraryElement library)
       => new Selector(SelectorKind.CALL, "", library, 0);
 
-  bool isGetter() => identical(kind, SelectorKind.GETTER);
-  bool isSetter() => identical(kind, SelectorKind.SETTER);
-  bool isCall() => identical(kind, SelectorKind.CALL);
-  bool isClosureCall() {
+  bool get isGetter => identical(kind, SelectorKind.GETTER);
+  bool get isSetter => identical(kind, SelectorKind.SETTER);
+  bool get isCall => identical(kind, SelectorKind.CALL);
+  bool get isClosureCall {
     String callName = Compiler.CALL_OPERATOR_NAME;
-    return isCall() && name == callName;
+    return isCall && name == callName;
   }
 
-  bool isIndex() => identical(kind, SelectorKind.INDEX) && argumentCount == 1;
-  bool isIndexSet() => identical(kind, SelectorKind.INDEX) && argumentCount == 2;
+  bool get isIndex => identical(kind, SelectorKind.INDEX) && argumentCount == 1;
+  bool get isIndexSet => identical(kind, SelectorKind.INDEX) && argumentCount == 2;
 
-  bool isOperator() => identical(kind, SelectorKind.OPERATOR);
-  bool isUnaryOperator() => isOperator() && argumentCount == 0;
+  bool get isOperator => identical(kind, SelectorKind.OPERATOR);
+  bool get isUnaryOperator => isOperator && argumentCount == 0;
 
   /** Check whether this is a call to 'assert'. */
-  bool isAssert() => isCall() && identical(name, "assert");
+  bool get isAssert => isCall && identical(name, "assert");
 
   int get namedArgumentCount => namedArguments.length;
   int get positionalArgumentCount => argumentCount - namedArgumentCount;
 
   bool get hasExactMask => false;
   TypeMask get mask => null;
   Selector get asUntyped => this;
 
   /**
    * The member name for invocation mirrors created from this selector.
    */
   String get invocationMirrorMemberName =>
-      isSetter() ? '$name=' : name;
+      isSetter ? '$name=' : name;
 
   int get invocationMirrorKind {
     const int METHOD = 0;
     const int GETTER = 1;
     const int SETTER = 2;
     int kind = METHOD;
-    if (isGetter()) {
+    if (isGetter) {
       kind = GETTER;
-    } else if (isSetter()) {
+    } else if (isSetter) {
       kind = SETTER;
     }
     return kind;
   }
 
   bool appliesUnnamed(Element element, Compiler compiler) {
     assert(sameNameHack(element, compiler));
     return appliesUntyped(element, compiler);
   }
 
   bool appliesUntyped(Element element, Compiler compiler) {
     assert(sameNameHack(element, compiler));
     if (Elements.isUnresolved(element)) return false;
-    if (isPrivateName(name) && library != element.getLibrary()) return false;
+    if (isPrivateName(name) && library != element.library) return false;
     if (element.isForeign(compiler)) return true;
-    if (element.isSetter()) return isSetter();
-    if (element.isGetter()) return isGetter() || isCall();
-    if (element.isField()) {
-      return isSetter()
-          ? !element.modifiers.isFinalOrConst()
-          : isGetter() || isCall();
+    if (element.isSetter) return isSetter;
+    if (element.isGetter) return isGetter || isCall;
+    if (element.isField) {
+      return isSetter
+          ? !element.modifiers.isFinalOrConst
+          : isGetter || isCall;
     }
-    if (isGetter()) return true;
-    if (isSetter()) return false;
+    if (isGetter) return true;
+    if (isSetter) return false;
     return signatureApplies(element, compiler);
   }
 
   bool signatureApplies(FunctionElement function, Compiler compiler) {
     FunctionSignature parameters = function.computeSignature(compiler);
     if (argumentCount > parameters.parameterCount) return false;
     int requiredParameterCount = parameters.requiredParameterCount;
     int optionalParameterCount = parameters.optionalParameterCount;
     if (positionalArgumentCount < requiredParameterCount) return false;
 
@@ skipping 19 matching lines @@
         // check in the resolver also.
         nameSet.remove(name);
       }
       return true;
     }
   }
 
   bool sameNameHack(Element element, Compiler compiler) {
     // TODO(ngeoffray): Remove workaround checks.
     return element == compiler.assertMethod
-        || element.isConstructor()
+        || element.isConstructor
         || name == element.name;
   }
 
   bool applies(Element element, Compiler compiler) {
     if (!sameNameHack(element, compiler)) return false;
     return appliesUnnamed(element, compiler);
   }
 
   /**
    * Fills [list] with the arguments in a defined order.
@@ skipping 110 matching lines @@
     Link<Node> nodes = computeCallNodesFromParameters();
 
     // Synthesize a selector for the call.
     // TODO(ngeoffray): Should the resolver do it instead?
     List<String> namedParameters;
     if (signature.optionalParametersAreNamed) {
       namedParameters =
           signature.optionalParameters.toList().map((e) => e.name).toList();
     }
     Selector selector = new Selector.call(callee.name,
-                                          caller.getLibrary(),
+                                          caller.library,
                                           signature.parameterCount,
                                           namedParameters);
 
     return selector.addArgumentsToList(nodes,
                                        list,
                                        callee,
                                        internalCompileArgument,
                                        compileConstant,
                                        compiler);
   }
@@ skipping 133 matching lines @@
   factory TypedSelector.subclass(ClassElement base, Selector selector)
       => new TypedSelector(new TypeMask.subclass(base), selector);
 
   factory TypedSelector.subtype(ClassElement base, Selector selector)
       => new TypedSelector(new TypeMask.subtype(base), selector);
 
   bool appliesUnnamed(Element element, Compiler compiler) {
     assert(sameNameHack(element, compiler));
     // [TypedSelector] are only used after resolution.
     assert(compiler.phase > Compiler.PHASE_RESOLVING);
-    if (!element.isMember()) return false;
+    if (!element.isMember) return false;
 
     // A closure can be called through any typed selector:
     // class A {
     //   get foo => () => 42;
     //   bar() => foo(); // The call to 'foo' is a typed selector.
     // }
-    if (element.getEnclosingClass().isClosure()) {
+    if (element.enclosingClass.isClosure) {
       return appliesUntyped(element, compiler);
     }
 
     if (!mask.canHit(element, this, compiler)) return false;
     return appliesUntyped(element, compiler);
   }
 
   Selector extendIfReachesAll(Compiler compiler) {
     bool canReachAll = compiler.enabledInvokeOn
         && mask.needsNoSuchMethodHandling(this, compiler);
     return canReachAll
         ? new TypedSelector(compiler.typesTask.dynamicType, this)
         : this;
   }
 }