Convert property methods into getters.

sdk/lib/_internal/compiler/implementation/compile_time_constants.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.
 
 part of dart2js;
 
 /// A [ConstantEnvironment] provides access for constants compiled for variable
 /// initializers.
 abstract class ConstantEnvironment {
   /// Returns the constant for the initializer of [element].
@@ skipping 88 matching lines @@
     return compileVariable(element, isConst: true);
   }
 
   Constant compileVariable(VariableElement element, {bool isConst: false}) {
 
     if (initialVariableValues.containsKey(element.declaration)) {
       Constant result = initialVariableValues[element.declaration];
       return result;
     }
     Element currentElement = element;
-    if (element.isParameter() ||
-        element.isFieldParameter() ||
-        element.isVariable()) {
+    if (element.isParameter ||
+        element.isFieldParameter ||
+        element.isVariable) {
       currentElement = element.enclosingElement;
     }
     return compiler.withCurrentElement(currentElement, () {
       TreeElements definitions =
           compiler.analyzeElement(currentElement.declaration);
       Constant constant = compileVariableWithDefinitions(
           element, definitions, isConst: isConst);
       return constant;
     });
   }
@@ skipping 20 matching lines @@
     Expression initializer = element.initializer;
     Constant value;
     if (initializer == null) {
       // No initial value.
       value = new NullConstant();
     } else {
       value = compileNodeWithDefinitions(
           initializer, definitions, isConst: isConst);
       if (compiler.enableTypeAssertions &&
           value != null &&
-          element.isField()) {
+          element.isField) {
         DartType elementType = element.type;
         if (elementType.kind == TypeKind.MALFORMED_TYPE && !value.isNull) {
           if (isConst) {
             ErroneousElement element = elementType.element;
             compiler.reportFatalError(
                 node, element.messageKind, element.messageArguments);
           } else {
             // We need to throw an exception at runtime.
             value = null;
           }
@@ skipping 110 matching lines @@
 
   Constant visitLiteralDouble(LiteralDouble node) {
     return constantSystem.createDouble(node.value);
   }
 
   Constant visitLiteralInt(LiteralInt node) {
     return constantSystem.createInt(node.value);
   }
 
   Constant visitLiteralList(LiteralList node) {
-    if (!node.isConst())  {
+    if (!node.isConst)  {
       return signalNotCompileTimeConstant(node);
     }
     List<Constant> arguments = <Constant>[];
     for (Link<Node> link = node.elements.nodes;
          !link.isEmpty;
          link = link.tail) {
       arguments.add(evaluateConstant(link.head));
     }
     DartType type = elements.getType(node);
     return new ListConstant(type, arguments);
   }
 
   Constant visitLiteralMap(LiteralMap node) {
-    if (!node.isConst()) {
+    if (!node.isConst) {
       return signalNotCompileTimeConstant(node);
     }
     List<Constant> keys = <Constant>[];
     Map<Constant, Constant> map = new Map<Constant, Constant>();
     for (Link<Node> link = node.entries.nodes;
          !link.isEmpty;
          link = link.tail) {
       LiteralMapEntry entry = link.head;
       Constant key = evaluateConstant(entry.key);
       if (!map.containsKey(key)) {
@@ skipping 127 matching lines @@
     Element element = elements[send];
     if (send.isPropertyAccess) {
       if (isDeferredUse(send)) {
         return signalNotCompileTimeConstant(send,
             message: MessageKind.DEFERRED_COMPILE_TIME_CONSTANT);
       }
       if (Elements.isStaticOrTopLevelFunction(element)) {
         return new FunctionConstant(element);
       } else if (Elements.isStaticOrTopLevelField(element)) {
         Constant result;
-        if (element.modifiers.isConst()) {
+        if (element.modifiers.isConst) {
           result = handler.compileConstant(element);
-        } else if (element.modifiers.isFinal() && !isEvaluatingConstant) {
+        } else if (element.modifiers.isFinal && !isEvaluatingConstant) {
           result = handler.compileVariable(element);
         }
         if (result != null) return result;
       } else if (Elements.isClass(element) || Elements.isTypedef(element)) {
         assert(elements.isTypeLiteral(send));
         return makeTypeConstant(element);
       } else if (send.receiver != null) {
         // Fall through to error handling.
       } else if (!Elements.isUnresolved(element)
-                 && element.isVariable()
-                 && element.modifiers.isConst()) {
+                 && element.isVariable
+                 && element.modifiers.isConst) {
         Constant result = handler.compileConstant(element);
         if (result != null) return result;
       }
       return signalNotCompileTimeConstant(send);
     } else if (send.isCall) {
       if (identical(element, compiler.identicalFunction)
           && send.argumentCount() == 2) {
         Constant left = evaluate(send.argumentsNode.nodes.head);
         Constant right = evaluate(send.argumentsNode.nodes.tail.head);
         Constant result = constantSystem.identity.fold(left, right);
@@ skipping 160 matching lines @@
                                                  compiler);
     if (!succeeded) {
       compiler.reportFatalError(
           node,
           MessageKind.INVALID_ARGUMENTS, {'methodName': target.name});
     }
     return compiledArguments;
   }
 
   Constant visitNewExpression(NewExpression node) {
-    if (!node.isConst()) {
+    if (!node.isConst) {
       return signalNotCompileTimeConstant(node);
     }
 
     Send send = node.send;
     FunctionElement constructor = elements[send];
     if (Elements.isUnresolved(constructor)) {
       return signalNotCompileTimeConstant(node);
     }
 
     // Deferred types can not be used in const instance creation expressions.
@@ skipping 88 matching lines @@
   }
 
   Constant makeConstructedConstant(
       Spannable node, InterfaceType type, FunctionElement constructor,
       List<Constant> getArguments(FunctionElement constructor)) {
     // The redirection chain of this element may not have been resolved through
     // a post-process action, so we have to make sure it is done here.
     compiler.resolver.resolveRedirectionChain(constructor, node);
     InterfaceType constructedType = constructor.computeTargetType(type);
     constructor = constructor.redirectionTarget;
-    ClassElement classElement = constructor.getEnclosingClass();
+    ClassElement classElement = constructor.enclosingClass;
     // The constructor must be an implementation to ensure that field
     // initializers are handled correctly.
     constructor = constructor.implementation;
     assert(invariant(node, constructor.isImplementation));
 
     List<Constant> arguments = getArguments(constructor);
     ConstructorEvaluator evaluator = new ConstructorEvaluator(
         constructedType, constructor, handler, compiler);
     evaluator.evaluateConstructorFieldValues(arguments);
     List<Constant> jsNewArguments = evaluator.buildJsNewArguments(classElement);
@@ skipping 98 matching lines @@
       if (parameter.kind == ElementKind.FIELD_PARAMETER) {
         FieldParameterElement fieldParameterElement = parameter;
         updateFieldValue(node, fieldParameterElement.fieldElement, argument);
       }
     });
   }
 
   void evaluateSuperOrRedirectSend(List<Constant> compiledArguments,
                                    FunctionElement targetConstructor) {
     ConstructorEvaluator evaluator = new ConstructorEvaluator(
-        constructedType.asInstanceOf(targetConstructor.getEnclosingClass()),
+        constructedType.asInstanceOf(targetConstructor.enclosingClass),
         targetConstructor, handler, compiler);
     evaluator.evaluateConstructorFieldValues(compiledArguments);
     // Copy over the fieldValues from the super/redirect-constructor.
     // No need to go through [updateFieldValue] because the
     // assignments have already been checked in checked mode.
     evaluator.fieldValues.forEach((key, value) => fieldValues[key] = value);
   }
 
   /**
    * Runs through the initializers of the given [constructor] and updates
@@ skipping 40 matching lines @@
           assert(!initArguments.isEmpty && initArguments.tail.isEmpty);
           Constant fieldValue = evaluate(initArguments.head);
           updateFieldValue(init, elements[init], fieldValue);
         }
       }
     }
 
     if (!foundSuperOrRedirect) {
       // No super initializer found. Try to find the default constructor if
       // the class is not Object.
-      ClassElement enclosingClass = constructor.getEnclosingClass();
+      ClassElement enclosingClass = constructor.enclosingClass;
       ClassElement superClass = enclosingClass.superclass;
       if (enclosingClass != compiler.objectClass) {
         assert(superClass != null);
         assert(superClass.resolutionState == STATE_DONE);
 
         Selector selector =
-            new Selector.callDefaultConstructor(enclosingClass.getLibrary());
+            new Selector.callDefaultConstructor(enclosingClass.library);
 
         FunctionElement targetConstructor =
             superClass.lookupConstructor(selector);
         if (targetConstructor == null) {
           compiler.internalError(functionNode,
               "No default constructor available.");
         }
         List<Constant> compiledArguments = evaluateArgumentsToConstructor(
             functionNode, selector, const Link<Node>(), targetConstructor);
         evaluateSuperOrRedirectSend(compiledArguments, targetConstructor);
@@ skipping 21 matching lines @@
           if (fieldValue == null) {
             // Use the default value.
             fieldValue = handler.compileConstant(field);
           }
           jsNewArguments.add(fieldValue);
         },
         includeSuperAndInjectedMembers: true);
     return jsNewArguments;
   }
 }