Convert property methods into getters.

sdk/lib/_internal/compiler/implementation/resolution/signatures.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.
 
 part of resolution;
 
 /**
  * [SignatureResolver] resolves function signatures.
  */
 class SignatureResolver extends MappingVisitor<ParameterElementX> {
@@ skipping 39 matching lines @@
       return null;
     }
     if (!definitions.tail.isEmpty) {
       internalError(definitions.tail.head, 'extra definition');
       return null;
     }
     Node definition = definitions.head;
     if (definition is NodeList) {
       internalError(node, 'optional parameters are not implemented');
     }
-    if (node.modifiers.isConst()) {
+    if (node.modifiers.isConst) {
       compiler.reportError(node, MessageKind.FORMAL_DECLARED_CONST);
     }
-    if (node.modifiers.isStatic()) {
+    if (node.modifiers.isStatic) {
       compiler.reportError(node, MessageKind.FORMAL_DECLARED_STATIC);
     }
 
     if (currentDefinitions != null) {
       internalError(node, 'function type parameters not supported');
     }
     currentDefinitions = node;
     ParameterElementX element = definition.accept(this);
     if (currentDefinitions.metadata != null) {
       element.metadata = compiler.resolver.resolveMetadata(element, node);
@@ skipping 94 matching lines @@
     if (node.receiver.asIdentifier() == null ||
         !node.receiver.asIdentifier().isThis()) {
       error(node, MessageKind.INVALID_PARAMETER);
     } else if (!identical(enclosingElement.kind,
                           ElementKind.GENERATIVE_CONSTRUCTOR)) {
       error(node, MessageKind.INITIALIZING_FORMAL_NOT_ALLOWED);
     } else {
       Identifier name = getParameterName(node);
       validateName(name);
       Element fieldElement =
-          enclosingElement.getEnclosingClass().lookupLocalMember(name.source);
+          enclosingElement.enclosingClass.lookupLocalMember(name.source);
       if (fieldElement == null ||
           !identical(fieldElement.kind, ElementKind.FIELD)) {
         error(node, MessageKind.NOT_A_FIELD, {'fieldName': name});
-      } else if (!fieldElement.isInstanceMember()) {
+      } else if (!fieldElement.isInstanceMember) {
         error(node, MessageKind.NOT_INSTANCE_FIELD, {'fieldName': name});
       }
       element = new FieldParameterElementX(enclosingElement,
           currentDefinitions, name, initializer, fieldElement);
       computeParameterType(element, fieldElement);
     }
     return element;
   }
 
   /// A [SendSet] node is an optional parameter with a default value.
   Element visitSendSet(SendSet node) {
     ParameterElementX element;
     if (node.receiver != null) {
       element = createFieldParameter(node, node.arguments.first);
     } else if (node.selector.asIdentifier() != null ||
                node.selector.asFunctionExpression() != null) {
       element = createParameter(getParameterName(node), node.arguments.first);
     }
     Node defaultValue = node.arguments.head;
     if (!defaultValuesAllowed) {
       compiler.reportError(defaultValue, defaultValuesError);
     }
     return element;
   }
 
   Element visitFunctionExpression(FunctionExpression node) {
     // This is a function typed parameter.
     Modifiers modifiers = currentDefinitions.modifiers;
-    if (modifiers.isFinal()) {
+    if (modifiers.isFinal) {
       compiler.reportError(modifiers,
           MessageKind.FINAL_FUNCTION_TYPE_PARAMETER);
     }
-    if (modifiers.isVar()) {
+    if (modifiers.isVar) {
       compiler.reportError(modifiers, MessageKind.VAR_FUNCTION_TYPE_PARAMETER);
     }
 
     return createParameter(node.name, null);
   }
 
   LinkBuilder<Element> analyzeNodes(Link<Node> link) {
     LinkBuilder<Element> elements = new LinkBuilder<Element>();
     for (; !link.isEmpty; link = link.tail) {
       Element element = link.head.accept(this);
@@ skipping 18 matching lines @@
                                    NodeList formalParameters,
                                    Node returnNode,
                                    Element element,
                                    TreeElementMapping mapping,
                                    {MessageKind defaultValuesError}) {
     SignatureResolver visitor = new SignatureResolver(compiler, element,
         mapping, defaultValuesError: defaultValuesError);
     Link<Element> parameters = const Link<Element>();
     int requiredParameterCount = 0;
     if (formalParameters == null) {
-      if (!element.isGetter()) {
+      if (!element.isGetter) {
         compiler.reportError(element, MessageKind.MISSING_FORMALS);
       }
     } else {
-      if (element.isGetter()) {
-        if (!identical(formalParameters.getEndToken().next.stringValue,
+      if (element.isGetter) {
+        if (!identical(formalParameters.endToken.next.stringValue,
                        // TODO(ahe): Remove the check for native keyword.
                        'native')) {
           compiler.reportError(formalParameters,
                                MessageKind.EXTRA_FORMALS);
         }
       }
       LinkBuilder<Element> parametersBuilder =
         visitor.analyzeNodes(formalParameters.nodes);
       requiredParameterCount  = parametersBuilder.length;
       parameters = parametersBuilder.toLink();
     }
     DartType returnType;
-    if (element.isFactoryConstructor()) {
-      returnType = element.getEnclosingClass().thisType;
+    if (element.isFactoryConstructor) {
+      returnType = element.enclosingClass.thisType;
       // Because there is no type annotation for the return type of
       // this element, we explicitly add one.
       if (compiler.enableTypeAssertions) {
         compiler.enqueuer.resolution.registerIsCheck(returnType, mapping);
       }
     } else {
       returnType = visitor.resolveReturnType(returnNode);
     }
 
-    if (element.isSetter() && (requiredParameterCount != 1 ||
+    if (element.isSetter && (requiredParameterCount != 1 ||
                                visitor.optionalParameterCount != 0)) {
       // If there are no formal parameters, we already reported an error above.
       if (formalParameters != null) {
         compiler.reportError(formalParameters,
                                  MessageKind.ILLEGAL_SETTER_FORMALS);
       }
     }
     LinkBuilder<DartType> parameterTypes = new LinkBuilder<DartType>();
     for (ParameterElement parameter in parameters) {
        parameterTypes.addLast(parameter.type);
@@ skipping 50 matching lines @@
 
   DartType resolveReturnType(TypeAnnotation annotation) {
     if (annotation == null) return compiler.types.dynamicType;
     DartType result = resolver.resolveTypeAnnotation(annotation);
     if (result == null) {
       return compiler.types.dynamicType;
     }
     return result;
   }
 }