Convert property methods into getters.

sdk/lib/_internal/compiler/implementation/resolution/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.
 
 part of resolution;
 
 abstract class TreeElements {
   Element get currentElement;
   Setlet<Node> get superUses;
 
@@ skipping 67 matching lines @@
 
   final int hashCode = ++hashCodeCounter;
   static int hashCodeCounter = 0;
 
   TreeElementMapping(this.currentElement);
 
   operator []=(Node node, Element element) {
     assert(invariant(node, () {
       FunctionExpression functionExpression = node.asFunctionExpression();
       if (functionExpression != null) {
-        return !functionExpression.modifiers.isExternal();
+        return !functionExpression.modifiers.isExternal;
       }
       return true;
     }));
     // TODO(johnniwinther): Simplify this invariant to use only declarations in
     // [TreeElements].
     assert(invariant(node, () {
-      if (!element.isErroneous() && currentElement != null && element.isPatch) {
-        return currentElement.getImplementationLibrary().isPatch;
+      if (!element.isErroneous && currentElement != null && element.isPatch) {
+        return currentElement.implementationLibrary.isPatch;
       }
       return true;
     }));
     // TODO(ahe): Investigate why the invariant below doesn't hold.
     // assert(invariant(node,
     //                  getTreeElement(node) == element ||
     //                  getTreeElement(node) == null,
     //                  message: '${getTreeElement(node)}; $element'));
 
     elements.add(element);
@@ skipping 159 matching lines @@
       ElementKind kind = element.kind;
       if (identical(kind, ElementKind.GENERATIVE_CONSTRUCTOR) ||
           identical(kind, ElementKind.FUNCTION) ||
           identical(kind, ElementKind.GETTER) ||
           identical(kind, ElementKind.SETTER)) {
         return resolveMethodElement(element);
       }
 
       if (identical(kind, ElementKind.FIELD)) return resolveField(element);
 
-      if (element.isClass()) {
+      if (element.isClass) {
         ClassElement cls = element;
         cls.ensureResolved(compiler);
         return null;
-      } else if (element.isTypedef()) {
+      } else if (element.isTypedef) {
         TypedefElement typdef = element;
         return resolveTypedef(typdef);
       }
 
       compiler.unimplemented(element, "resolve($element)");
     });
   }
 
   String constructorNameForDiagnostics(String className,
                                        String constructorName) {
@@ skipping 139 matching lines @@
   TreeElements resolveMethodElement(FunctionElementX element) {
     assert(invariant(element, element.isDeclaration));
     return compiler.withCurrentElement(element, () {
       bool isConstructor =
           identical(element.kind, ElementKind.GENERATIVE_CONSTRUCTOR);
       TreeElements elements =
           compiler.enqueuer.resolution.getCachedElements(element);
       if (elements != null) {
         // TODO(karlklose): Remove the check for [isConstructor]. [elememts]
         // should never be non-null, not even for constructors.
-        assert(invariant(element, element.isConstructor(),
+        assert(invariant(element, element.isConstructor,
             message: 'Non-constructor element $element '
                      'has already been analyzed.'));
         return elements;
       }
       if (element.isSynthesized) {
         if (isConstructor) {
           TreeElements elements = _ensureTreeElements(element);
           Element target = element.targetConstructor;
           // Ensure the signature of the synthesized element is
           // resolved. This is the only place where the resolver is
           // seeing this element.
           element.computeSignature(compiler);
-          if (!target.isErroneous()) {
+          if (!target.isErroneous) {
             compiler.enqueuer.resolution.registerStaticUse(target);
             compiler.world.registerImplicitSuperCall(elements, target);
           }
           return elements;
         } else {
-          assert(element.isDeferredLoaderGetter());
+          assert(element.isDeferredLoaderGetter);
           return _ensureTreeElements(element);
         }
       }
       element.parseNode(compiler);
       element.computeType(compiler);
       if (element.isPatched) {
         FunctionElementX patch = element.patch;
         compiler.withCurrentElement(patch, () {
             patch.parseNode(compiler);
             patch.computeSignature(compiler);
         });
         checkMatchingPatchSignatures(element, patch);
         element = patch;
       }
       return compiler.withCurrentElement(element, () {
         FunctionExpression tree = element.node;
-        if (tree.modifiers.isExternal()) {
+        if (tree.modifiers.isExternal) {
           error(tree, MessageKind.PATCH_EXTERNAL_WITHOUT_IMPLEMENTATION);
           return null;
         }
-        if (isConstructor || element.isFactoryConstructor()) {
+        if (isConstructor || element.isFactoryConstructor) {
           if (tree.returnType != null) {
             error(tree, MessageKind.CONSTRUCTOR_WITH_RETURN_TYPE);
           }
-          if (element.modifiers.isConst() &&
+          if (element.modifiers.isConst &&
               tree.hasBody() &&
               !tree.isRedirectingFactory) {
             compiler.reportError(tree, MessageKind.CONST_CONSTRUCTOR_HAS_BODY);
           }
         }
 
         ResolverVisitor visitor = visitorFor(element);
         visitor.useElement(tree, element);
         visitor.setupFunction(tree, element);
 
@@ skipping 17 matching lines @@
           // we can analyze compile-time constants.
           visitor.visit(tree.body);
         }
 
         // Get the resolution tree and check that the resolved
         // function doesn't use 'super' if it is mixed into another
         // class. This is the part of the 'super' mixin check that
         // happens when a function is resolved after the mixin
         // application has been performed.
         TreeElements resolutionTree = visitor.mapping;
-        ClassElement enclosingClass = element.getEnclosingClass();
+        ClassElement enclosingClass = element.enclosingClass;
         if (enclosingClass != null) {
           Set<MixinApplicationElement> mixinUses =
               compiler.world.mixinUses[enclosingClass];
           if (mixinUses != null) {
             ClassElement mixin = enclosingClass;
             for (MixinApplicationElement mixinApplication in mixinUses) {
               checkMixinSuperUses(resolutionTree, mixinApplication, mixin);
             }
           }
         }
         return resolutionTree;
       });
     });
   }
 
   /// This method should only be used by this library (or tests of
   /// this library).
   ResolverVisitor visitorFor(Element element) {
     return new ResolverVisitor(compiler, element, _ensureTreeElements(element));
   }
 
   TreeElements resolveField(VariableElementX element) {
     VariableDefinitions tree = element.parseNode(compiler);
-    if(element.modifiers.isStatic() && element.isTopLevel()) {
+    if(element.modifiers.isStatic && element.isTopLevel) {
       error(element.modifiers.getStatic(),
             MessageKind.TOP_LEVEL_VARIABLE_DECLARED_STATIC);
     }
     ResolverVisitor visitor = visitorFor(element);
     // TODO(johnniwinther): Share the resolved type between all variables
     // declared in the same declaration.
     if (tree.type != null) {
       element.variables.type = visitor.resolveTypeAnnotation(tree.type);
     } else {
       element.variables.type = compiler.types.dynamicType;
     }
     visitor.useElement(tree, element);
 
     Expression initializer = element.initializer;
     Modifiers modifiers = element.modifiers;
     if (initializer != null) {
       // TODO(johnniwinther): Avoid analyzing initializers if
       // [Compiler.analyzeSignaturesOnly] is set.
       visitor.visit(initializer);
-    } else if (modifiers.isConst()) {
+    } else if (modifiers.isConst) {
       compiler.reportError(element, MessageKind.CONST_WITHOUT_INITIALIZER);
-    } else if (modifiers.isFinal() && !element.isInstanceMember()) {
+    } else if (modifiers.isFinal && !element.isInstanceMember) {
       compiler.reportError(element, MessageKind.FINAL_WITHOUT_INITIALIZER);
     } else {
       compiler.enqueuer.resolution.registerInstantiatedClass(
           compiler.nullClass, visitor.mapping);
     }
 
     if (Elements.isStaticOrTopLevelField(element)) {
       visitor.addDeferredAction(element, () {
-        if (element.modifiers.isConst()) {
+        if (element.modifiers.isConst) {
           constantCompiler.compileConstant(element);
         } else {
           constantCompiler.compileVariable(element);
         }
       });
       if (initializer != null) {
-        if (!element.modifiers.isConst()) {
+        if (!element.modifiers.isConst) {
           // TODO(johnniwinther): Determine the const-ness eagerly to avoid
           // unnecessary registrations.
           compiler.backend.registerLazyField(visitor.mapping);
         }
       }
     }
 
     // Perform various checks as side effect of "computing" the type.
     element.computeType(compiler);
 
@@ skipping 38 matching lines @@
       if (seen.contains(nextTarget)) {
         error(node, MessageKind.CYCLIC_REDIRECTING_FACTORY);
         break;
       }
       seen.add(target);
       target = nextTarget;
     }
 
     if (targetType == null) {
       assert(!target.isRedirectingFactory);
-      targetType = target.getEnclosingClass().thisType;
+      targetType = target.enclosingClass.thisType;
     }
 
     // [target] is now the actual target of the redirections.  Run through
     // the constructors again and set their [redirectionTarget], so that we
     // do not have to run the loop for these constructors again. Furthermore,
     // compute [redirectionTargetType] for each factory by computing the
     // substitution of the target type with respect to the factory type.
     while (!seen.isEmpty) {
       FunctionElementX factory = seen.removeLast();
 
@@ skipping 164 matching lines @@
         element.isProxy = true;
       }
     }
 
     // Force resolution of metadata on non-instance members since they may be
     // inspected by the backend while emitting. Metadata on instance members is
     // handled as a result of processing instantiated class members in the
     // enqueuer.
     // TODO(ahe): Avoid this eager resolution.
     element.forEachMember((_, Element member) {
-      if (!member.isInstanceMember()) {
+      if (!member.isInstanceMember) {
         compiler.withCurrentElement(member, () {
           for (MetadataAnnotation metadata in member.metadata) {
             metadata.ensureResolved(compiler);
           }
         });
       }
     });
 
     computeClassMember(element, Compiler.CALL_OPERATOR_NAME);
   }
@@ skipping 41 matching lines @@
     }
 
     // Check that the mixed in class has Object as its superclass.
     if (!mixin.superclass.isObject(compiler)) {
       compiler.reportError(mixin, MessageKind.ILLEGAL_MIXIN_SUPERCLASS);
     }
 
     // Check that the mixed in class doesn't have any constructors and
     // make sure we aren't mixing in methods that use 'super'.
     mixin.forEachLocalMember((Element member) {
-      if (member.isGenerativeConstructor() && !member.isSynthesized) {
+      if (member.isGenerativeConstructor && !member.isSynthesized) {
         compiler.reportError(member, MessageKind.ILLEGAL_MIXIN_CONSTRUCTOR);
       } else {
         // Get the resolution tree and check that the resolved member
         // doesn't use 'super'. This is the part of the 'super' mixin
         // check that happens when a function is resolved before the
         // mixin application has been performed.
         checkMixinSuperUses(
             compiler.enqueuer.resolution.resolvedElements[member],
             mixinApplication,
             mixin);
@@ skipping 24 matching lines @@
     // TODO(johnniwinther): Should this be done on the implementation element as
     // well?
     List<Element> constConstructors = <Element>[];
     List<Element> nonFinalInstanceFields = <Element>[];
     cls.forEachMember((holder, member) {
       compiler.withCurrentElement(member, () {
         // Perform various checks as side effect of "computing" the type.
         member.computeType(compiler);
 
         // Check modifiers.
-        if (member.isFunction() && member.modifiers.isFinal()) {
+        if (member.isFunction && member.modifiers.isFinal) {
           compiler.reportError(
               member, MessageKind.ILLEGAL_FINAL_METHOD_MODIFIER);
         }
-        if (member.isConstructor()) {
+        if (member.isConstructor) {
           final mismatchedFlagsBits =
               member.modifiers.flags &
               (Modifiers.FLAG_STATIC | Modifiers.FLAG_ABSTRACT);
           if (mismatchedFlagsBits != 0) {
             final mismatchedFlags =
                 new Modifiers.withFlags(null, mismatchedFlagsBits);
             compiler.reportError(
                 member,
                 MessageKind.ILLEGAL_CONSTRUCTOR_MODIFIERS,
                 {'modifiers': mismatchedFlags});
           }
-          if (member.modifiers.isConst()) {
+          if (member.modifiers.isConst) {
             constConstructors.add(member);
           }
         }
-        if (member.isField()) {
-          if (!member.modifiers.isStatic() &&
-              !member.modifiers.isFinal()) {
+        if (member.isField) {
+          if (!member.modifiers.isStatic &&
+              !member.modifiers.isFinal) {
             nonFinalInstanceFields.add(member);
           }
         }
         checkAbstractField(member);
         checkUserDefinableOperator(member);
       });
     });
     if (!constConstructors.isEmpty && !nonFinalInstanceFields.isEmpty) {
       Spannable span = constConstructors.length > 1
           ? cls : constConstructors[0];
@@ skipping 10 matching lines @@
         compiler.reportInfo(field,
             MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_FIELD);
       }
     }
   }
 
   void checkAbstractField(Element member) {
     // Only check for getters. The test can only fail if there is both a setter
     // and a getter with the same name, and we only need to check each abstract
     // field once, so we just ignore setters.
-    if (!member.isGetter()) return;
+    if (!member.isGetter) return;
 
     // Find the associated abstract field.
-    ClassElement classElement = member.getEnclosingClass();
+    ClassElement classElement = member.enclosingClass;
     Element lookupElement = classElement.lookupLocalMember(member.name);
     if (lookupElement == null) {
       compiler.internalError(member,
           "No abstract field for accessor");
     } else if (!identical(lookupElement.kind, ElementKind.ABSTRACT_FIELD)) {
       compiler.internalError(member,
           "Inaccessible abstract field for accessor");
     }
     AbstractFieldElement field = lookupElement;
 
@@ skipping 45 matching lines @@
       requiredParameterCount = 2;
     } else {
       compiler.internalError(function,
           'Unexpected user defined operator $value');
     }
     checkArity(function, requiredParameterCount, messageKind, isMinus);
   }
 
   void checkOverrideHashCode(FunctionElement operatorEquals) {
     if (operatorEquals.isAbstract) return;
-    ClassElement cls = operatorEquals.getEnclosingClass();
+    ClassElement cls = operatorEquals.enclosingClass;
     Element hashCodeImplementation =
         cls.lookupLocalMember('hashCode');
     if (hashCodeImplementation != null) return;
     compiler.reportHint(
         operatorEquals, MessageKind.OVERRIDE_EQUALS_NOT_HASH_CODE,
         {'class': cls.name});
   }
 
   void checkArity(FunctionElement function,
                   int requiredParameterCount, MessageKind messageKind,
@@ skipping 52 matching lines @@
   }
 
   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);
   }
 
 
   FunctionSignature resolveSignature(FunctionElementX element) {
     MessageKind defaultValuesError = null;
-    if (element.isFactoryConstructor()) {
+    if (element.isFactoryConstructor) {
       FunctionExpression body = element.parseNode(compiler);
       if (body.isRedirectingFactory) {
         defaultValuesError = MessageKind.REDIRECTING_FACTORY_WITH_DEFAULT;
       }
     }
     return compiler.withCurrentElement(element, () {
       FunctionExpression node =
           compiler.parser.measure(() => element.parseNode(compiler));
       return measure(() => SignatureResolver.analyze(
           compiler, node.parameters, node.returnType, element,
@@ skipping 98 matching lines @@
         existing,
         MessageKind.ALREADY_INITIALIZED, {'fieldName': field.name});
   }
 
   void checkForDuplicateInitializers(VariableElement field, Node init) {
     // [field] can be null if it could not be resolved.
     if (field == null) return;
     String name = field.name;
     if (initialized.containsKey(field)) {
       reportDuplicateInitializerError(field, init, initialized[field]);
-    } else if (field.modifiers.isFinal()) {
+    } else if (field.modifiers.isFinal) {
       field.parseNode(visitor.compiler);
       Expression initializer = field.initializer;
       if (initializer != null) {
         reportDuplicateInitializerError(field, init, initializer);
       }
     }
     initialized[field] = init;
   }
 
   void resolveFieldInitializer(FunctionElement constructor, SendSet init) {
     // init is of the form [this.]field = value.
     final Node selector = init.selector;
     final String name = selector.asIdentifier().source;
     // Lookup target field.
     Element target;
     if (isFieldInitializer(init)) {
-      target = constructor.getEnclosingClass().lookupLocalMember(name);
+      target = constructor.enclosingClass.lookupLocalMember(name);
       if (target == null) {
         error(selector, MessageKind.CANNOT_RESOLVE, {'name': name});
       } else if (target.kind != ElementKind.FIELD) {
         error(selector, MessageKind.NOT_A_FIELD, {'fieldName': name});
-      } else if (!target.isInstanceMember()) {
+      } else if (!target.isInstanceMember) {
         error(selector, MessageKind.INIT_STATIC_FIELD, {'fieldName': name});
       }
     } else {
       error(init, MessageKind.INVALID_RECEIVER_IN_INITIALIZER);
     }
     visitor.useElement(init, target);
     visitor.world.registerStaticUse(target);
     checkForDuplicateInitializers(target, init);
     // Resolve initializing value.
     visitor.visitInStaticContext(init.arguments.head);
   }
 
   ClassElement getSuperOrThisLookupTarget(FunctionElement constructor,
                                           bool isSuperCall,
                                           Node diagnosticNode) {
-    ClassElement lookupTarget = constructor.getEnclosingClass();
+    ClassElement lookupTarget = constructor.enclosingClass;
     if (isSuperCall) {
       // Calculate correct lookup target and constructor name.
       if (identical(lookupTarget, visitor.compiler.objectClass)) {
         error(diagnosticNode, MessageKind.SUPER_INITIALIZER_IN_OBJECT);
       } else {
         return lookupTarget.supertype.element;
       }
     }
     return lookupTarget;
   }
@@ skipping 29 matching lines @@
                                      constructorSelector);
 
     visitor.useElement(call, calledConstructor);
     visitor.world.registerStaticUse(calledConstructor);
     return calledConstructor;
   }
 
   void resolveImplicitSuperConstructorSend(FunctionElement constructor,
                                            FunctionExpression functionNode) {
     // If the class has a super resolve the implicit super call.
-    ClassElement classElement = constructor.getEnclosingClass();
+    ClassElement classElement = constructor.enclosingClass;
     ClassElement superClass = classElement.superclass;
     if (classElement != visitor.compiler.objectClass) {
       assert(superClass != null);
       assert(superClass.resolutionState == STATE_DONE);
       String constructorName = '';
       Selector callToMatch = new Selector.call(
           constructorName,
-          classElement.getLibrary(),
+          classElement.library,
           0);
 
       final bool isSuperCall = true;
       ClassElement lookupTarget = getSuperOrThisLookupTarget(constructor,
                                                              isSuperCall,
                                                              functionNode);
       Selector constructorSelector = new Selector.callDefaultConstructor(
-          visitor.enclosingElement.getLibrary());
+          visitor.enclosingElement.library);
       Element calledConstructor = lookupTarget.lookupConstructor(
           constructorSelector);
 
       final String className = lookupTarget.name;
       final bool isImplicitSuperCall = true;
       verifyThatConstructorMatchesCall(constructor,
                                        calledConstructor,
                                        callToMatch,
                                        isImplicitSuperCall,
                                        functionNode,
                                        className,
                                        constructorSelector);
       visitor.compiler.world
          .registerImplicitSuperCall(visitor.mapping, calledConstructor);
       visitor.world.registerStaticUse(calledConstructor);
     }
   }
 
   void verifyThatConstructorMatchesCall(
       FunctionElement caller,
       FunctionElement lookedupConstructor,
       Selector call,
       bool isImplicitSuperCall,
       Node diagnosticNode,
       String className,
       Selector constructorSelector) {
     if (lookedupConstructor == null
-        || !lookedupConstructor.isGenerativeConstructor()) {
+        || !lookedupConstructor.isGenerativeConstructor) {
       var fullConstructorName =
           visitor.compiler.resolver.constructorNameForDiagnostics(
               className,
               constructorSelector.name);
       MessageKind kind = isImplicitSuperCall
           ? MessageKind.CANNOT_RESOLVE_CONSTRUCTOR_FOR_IMPLICIT
           : MessageKind.CANNOT_RESOLVE_CONSTRUCTOR;
       visitor.compiler.reportError(
           diagnosticNode, kind, {'constructorName': fullConstructorName});
     } else {
       if (!call.applies(lookedupConstructor, visitor.compiler)) {
         MessageKind kind = isImplicitSuperCall
                            ? MessageKind.NO_MATCHING_CONSTRUCTOR_FOR_IMPLICIT
                            : MessageKind.NO_MATCHING_CONSTRUCTOR;
         visitor.compiler.reportError(diagnosticNode, kind);
-      } else if (caller.modifiers.isConst()
-                 && !lookedupConstructor.modifiers.isConst()) {
+      } else if (caller.modifiers.isConst
+                 && !lookedupConstructor.modifiers.isConst) {
         visitor.compiler.reportError(
             diagnosticNode, MessageKind.CONST_CALLS_NON_CONST);
       }
     }
   }
 
   /**
    * Resolve all initializers of this constructor. In the case of a redirecting
    * constructor, the resolved constructor's function element is returned.
    */
@@ skipping 30 matching lines @@
         if (Initializers.isSuperConstructorCall(call)) {
           if (resolvedSuper) {
             error(call, MessageKind.DUPLICATE_SUPER_INITIALIZER);
           }
           resolveSuperOrThisForSend(constructor, functionNode, call);
           resolvedSuper = true;
         } else if (Initializers.isConstructorRedirect(call)) {
           // Check that there is no body (Language specification 7.5.1).  If the
           // constructor is also const, we already reported an error in
           // [resolveMethodElement].
-          if (functionNode.hasBody() && !constructor.modifiers.isConst()) {
+          if (functionNode.hasBody() && !constructor.modifiers.isConst) {
             error(functionNode, MessageKind.REDIRECTING_CONSTRUCTOR_HAS_BODY);
           }
           // Check that there are no other initializers.
           if (!initializers.tail.isEmpty) {
             error(call, MessageKind.REDIRECTING_CONSTRUCTOR_HAS_INITIALIZER);
           }
           // Check that there are no field initializing parameters.
           Compiler compiler = visitor.compiler;
           FunctionSignature signature = constructor.functionSignature;
           signature.forEachParameter((ParameterElement parameter) {
-            if (parameter.isFieldParameter()) {
+            if (parameter.isFieldParameter) {
               Node node = parameter.node;
               error(node, MessageKind.INITIALIZING_FORMAL_NOT_ALLOWED);
             }
           });
           return resolveSuperOrThisForSend(constructor, functionNode, call);
         } else {
           visitor.error(call, MessageKind.CONSTRUCTOR_CALL_EXPECTED);
           return null;
         }
       } else {
@@ skipping 144 matching lines @@
   /// Tries to resolve the type name as an element.
   Element resolveTypeName(Identifier prefixName,
                           Identifier typeName,
                           Scope scope,
                           {bool deferredIsMalformed: true}) {
     Element element;
     bool deferredTypeAnnotation = false;
     if (prefixName != null) {
       Element prefixElement =
           lookupInScope(compiler, prefixName, scope, prefixName.source);
-      if (prefixElement != null && prefixElement.isPrefix()) {
+      if (prefixElement != null && prefixElement.isPrefix) {
         // The receiver is a prefix. Lookup in the imported members.
         PrefixElement prefix = prefixElement;
         element = prefix.lookupLocalMember(typeName.source);
         // TODO(17260, sigurdm): The test for DartBackend is there because
         // dart2dart outputs malformed types with prefix.
         if (element != null &&
             prefix.isDeferred &&
             deferredIsMalformed &&
             compiler.backend is! DartBackend) {
           element = new ErroneousElementX(MessageKind.DEFERRED_TYPE_ANNOTATION,
@@ skipping 68 matching lines @@
                 type, arguments.toLink());
       }
       return type;
     }
 
     // Try to construct the type from the element.
     DartType type;
     if (element == null) {
       type = reportFailureAndCreateType(
           MessageKind.CANNOT_RESOLVE_TYPE, {'typeName': node.typeName});
-    } else if (element.isAmbiguous()) {
+    } else if (element.isAmbiguous) {
       AmbiguousElement ambiguous = element;
       type = reportFailureAndCreateType(
           ambiguous.messageKind, ambiguous.messageArguments);
       ambiguous.diagnose(visitor.mapping.currentElement, compiler);
-    } else if (element.isErroneous()) {
+    } else if (element.isErroneous) {
       ErroneousElement erroneousElement = element;
       type = reportFailureAndCreateType(
           erroneousElement.messageKind, erroneousElement.messageArguments,
           erroneousElement: erroneousElement);
-    } else if (!element.impliesType()) {
+    } else if (!element.impliesType) {
       type = reportFailureAndCreateType(
           MessageKind.NOT_A_TYPE, {'node': node.typeName});
     } else {
       bool addTypeVariableBoundsCheck = false;
       if (identical(element, compiler.types.voidType.element) ||
           identical(element, compiler.dynamicClass)) {
         type = checkNoTypeArguments(element.computeType(compiler));
-      } else if (element.isClass()) {
+      } else if (element.isClass) {
         ClassElement cls = element;
         compiler.resolver._ensureClassWillBeResolved(cls);
         element.computeType(compiler);
         var arguments = new LinkBuilder<DartType>();
         bool hasTypeArgumentMismatch = resolveTypeArguments(
             visitor, node, cls.typeVariables, arguments);
         if (hasTypeArgumentMismatch) {
           type = new BadInterfaceType(cls.declaration,
               new InterfaceType.forUserProvidedBadType(cls.declaration,
                                                        arguments.toLink()));
         } else {
           if (arguments.isEmpty) {
             type = cls.rawType;
           } else {
             type = new InterfaceType(cls.declaration, arguments.toLink());
             addTypeVariableBoundsCheck = true;
           }
         }
-      } else if (element.isTypedef()) {
+      } else if (element.isTypedef) {
         TypedefElement typdef = element;
         // TODO(ahe): Should be [ensureResolved].
         compiler.resolveTypedef(typdef);
         var arguments = new LinkBuilder<DartType>();
         bool hasTypeArgumentMismatch = resolveTypeArguments(
             visitor, node, typdef.typeVariables, arguments);
         if (hasTypeArgumentMismatch) {
           type = new BadTypedefType(typdef,
               new TypedefType.forUserProvidedBadType(typdef,
                                                      arguments.toLink()));
         } else {
           if (arguments.isEmpty) {
             type = typdef.rawType;
           } else {
             type = new TypedefType(typdef, arguments.toLink());
             addTypeVariableBoundsCheck = true;
           }
         }
-      } else if (element.isTypeVariable()) {
+      } else if (element.isTypeVariable) {
         Element outer =
-            visitor.enclosingElement.getOutermostEnclosingMemberOrTopLevel();
+            visitor.enclosingElement.outermostEnclosingMemberOrTopLevel;
         bool isInFactoryConstructor =
-            outer != null && outer.isFactoryConstructor();
-        if (!outer.isClass() &&
-            !outer.isTypedef() &&
+            outer != null && outer.isFactoryConstructor;
+        if (!outer.isClass &&
+            !outer.isTypedef &&
             !isInFactoryConstructor &&
             Elements.isInStaticContext(visitor.enclosingElement)) {
           compiler.backend.registerThrowRuntimeError(visitor.mapping);
           type = reportFailureAndCreateType(
               MessageKind.TYPE_VARIABLE_WITHIN_STATIC_MEMBER,
               {'typeVariableName': node},
               userProvidedBadType: element.computeType(compiler));
         } else {
           type = element.computeType(compiler);
         }
@@ skipping 160 matching lines @@
   /// the initializer of the variable is implicit and we should not emit an
   /// error when verifying that all final variables are initialized.
   bool allowFinalWithoutInitializer = false;
 
   /// The nodes for which variable access and mutation must be registered in
   /// order to determine when the static type of variables types is promoted.
   Link<Node> promotionScope = const Link<Node>();
 
   bool isPotentiallyMutableTarget(Element target) {
     if (target == null) return false;
-    return (target.isVariable() || target.isParameter()) &&
-      !(target.modifiers.isFinal() || target.modifiers.isConst());
+    return (target.isVariable || target.isParameter) &&
+      !(target.modifiers.isFinal || target.modifiers.isConst);
   }
 
   // TODO(ahe): Find a way to share this with runtime implementation.
   static final RegExp symbolValidationPattern =
       new RegExp(r'^(?:[a-zA-Z$][a-zA-Z$0-9_]*\.)*(?:[a-zA-Z$][a-zA-Z$0-9_]*=?|'
                  r'-|'
                  r'unary-|'
                  r'\[\]=|'
                  r'~|'
                  r'==|'
@@ skipping 14 matching lines @@
                  r'\|'
                  r')$');
 
   ResolverVisitor(Compiler compiler,
                   Element element,
                   TreeElementMapping mapping)
     : this.enclosingElement = element,
       // When the element is a field, we are actually resolving its
       // initial value, which should not have access to instance
       // fields.
-      inInstanceContext = (element.isInstanceMember() && !element.isField())
-          || element.isGenerativeConstructor(),
-      this.currentClass = element.isMember() ? element.getEnclosingClass()
+      inInstanceContext = (element.isInstanceMember && !element.isField)
+          || element.isGenerativeConstructor,
+      this.currentClass = element.isMember ? element.enclosingClass
                                              : null,
       this.statementScope = new StatementScope(),
       scope = element.buildScope(),
       // The type annotations on a typedef do not imply type checks.
       // TODO(karlklose): clean this up (dartbug.com/8870).
       inCheckContext = compiler.enableTypeAssertions &&
-          !element.isLibrary() &&
-          !element.isTypedef() &&
-          !element.enclosingElement.isTypedef(),
+          !element.isLibrary &&
+          !element.isTypedef &&
+          !element.enclosingElement.isTypedef,
       inCatchBlock = false,
       super(compiler, mapping);
 
   ResolutionEnqueuer get world => compiler.enqueuer.resolution;
 
   Element reportLookupErrorIfAny(Element result, Node node, String name) {
     if (!Elements.isUnresolved(result)) {
-      if (!inInstanceContext && result.isInstanceMember()) {
+      if (!inInstanceContext && result.isInstanceMember) {
         compiler.reportError(
             node, MessageKind.NO_INSTANCE_AVAILABLE, {'name': name});
         return new ErroneousElementX(MessageKind.NO_INSTANCE_AVAILABLE,
                                      {'name': name},
                                      name, enclosingElement);
-      } else if (result.isAmbiguous()) {
+      } else if (result.isAmbiguous) {
         AmbiguousElement ambiguous = result;
         compiler.reportError(
             node, ambiguous.messageKind, ambiguous.messageArguments);
         ambiguous.diagnose(enclosingElement, compiler);
         return new ErroneousElementX(ambiguous.messageKind,
                                      ambiguous.messageArguments,
                                      name, enclosingElement);
       }
     }
     return result;
@@ skipping 65 matching lines @@
         element = compiler.dynamicClass;
       }
       element = reportLookupErrorIfAny(element, node, node.source);
       if (element == null) {
         if (!inInstanceContext) {
           element = warnAndCreateErroneousElement(
               node, node.source, MessageKind.CANNOT_RESOLVE,
               {'name': node});
           compiler.backend.registerThrowNoSuchMethod(mapping);
         }
-      } else if (element.isErroneous()) {
+      } else if (element.isErroneous) {
         // Use the erroneous element.
       } else {
         if ((element.kind.category & allowedCategory) == 0) {
           // TODO(ahe): Improve error message. Need UX input.
           error(node, MessageKind.GENERIC,
                 {'text': "is not an expression $element"});
         }
       }
-      if (!Elements.isUnresolved(element) && element.isClass()) {
+      if (!Elements.isUnresolved(element) && element.isClass) {
         ClassElement classElement = element;
         classElement.ensureResolved(compiler);
       }
       return useElement(node, element);
     }
   }
 
   Element visitTypeAnnotation(TypeAnnotation node) {
     DartType type = resolveTypeAnnotation(node);
     if (type != null) {
       if (inCheckContext) {
         compiler.enqueuer.resolution.registerIsCheck(type, mapping);
       }
       return type.element;
     }
     return null;
   }
 
   bool isNamedConstructor(Send node) => node.receiver != null;
 
   Selector getRedirectingThisOrSuperConstructorSelector(Send node) {
     if (isNamedConstructor(node)) {
       String constructorName = node.selector.asIdentifier().source;
       return new Selector.callConstructor(
           constructorName,
-          enclosingElement.getLibrary());
+          enclosingElement.library);
     } else {
       return new Selector.callDefaultConstructor(
-          enclosingElement.getLibrary());
+          enclosingElement.library);
     }
   }
 
   FunctionElement resolveConstructorRedirection(FunctionElement constructor) {
     FunctionExpression node = constructor.parseNode(compiler);
 
     // A synthetic constructor does not have a node.
     if (node == null) return null;
     if (node.initializers == null) return null;
     Link<Node> initializers = node.initializers.nodes;
     if (!initializers.isEmpty &&
         Initializers.isConstructorRedirect(initializers.head)) {
       Selector selector =
           getRedirectingThisOrSuperConstructorSelector(initializers.head);
-      final ClassElement classElement = constructor.getEnclosingClass();
+      final ClassElement classElement = constructor.enclosingClass;
       return classElement.lookupConstructor(selector);
     }
     return null;
   }
 
   void setupFunction(FunctionExpression node, FunctionElement function) {
     Element enclosingElement = function.enclosingElement;
-    if (node.modifiers.isStatic() &&
+    if (node.modifiers.isStatic &&
         enclosingElement.kind != ElementKind.CLASS) {
       compiler.reportError(node, MessageKind.ILLEGAL_STATIC);
     }
 
     scope = new MethodScope(scope, function);
     // Put the parameters in scope.
     FunctionSignature functionParameters = function.functionSignature;
     Link<Node> parameterNodes = (node.parameters == null)
         ? const Link<Node>() : node.parameters.nodes;
     functionParameters.forEachParameter((ParameterElement element) {
@@ skipping 135 matching lines @@
     visitIn(node.elsePart, new BlockScope(scope));
   }
 
   Element resolveSend(Send node) {
     Selector selector = resolveSelector(node, null);
     if (node.isSuperCall) mapping.superUses.add(node);
 
     if (node.receiver == null) {
       // If this send is of the form "assert(expr);", then
       // this is an assertion.
-      if (selector.isAssert()) {
+      if (selector.isAssert) {
         if (selector.argumentCount != 1) {
           error(node.selector,
                 MessageKind.WRONG_NUMBER_OF_ARGUMENTS_FOR_ASSERT,
                 {'argumentCount': selector.argumentCount});
         } else if (selector.namedArgumentCount != 0) {
           error(node.selector,
                 MessageKind.ASSERT_IS_GIVEN_NAMED_ARGUMENTS,
                 {'argumentCount': selector.namedArgumentCount});
         }
         return compiler.assertMethod;
@@ skipping 41 matching lines @@
             node, name, MessageKind.NO_SUCH_SUPER_MEMBER,
             {'className': currentClass, 'memberName': name});
         // We still need to register the invocation, because we might
         // call [:super.noSuchMethod:] which calls
         // [JSInvocationMirror._invokeOn].
         world.registerDynamicInvocation(selector);
         compiler.backend.registerSuperNoSuchMethod(mapping);
       }
     } else if (Elements.isUnresolved(resolvedReceiver)) {
       return null;
-    } else if (resolvedReceiver.isClass()) {
+    } else if (resolvedReceiver.isClass) {
       ClassElement receiverClass = resolvedReceiver;
       receiverClass.ensureResolved(compiler);
       if (node.isOperator) {
         // When the resolved receiver is a class, we can have two cases:
         //  1) a static send: C.foo, or
         //  2) an operator send, where the receiver is a class literal: 'C + 1'.
         // The following code that looks up the selector on the resolved
         // receiver will treat the second as the invocation of a static operator
         // if the resolved receiver is not null.
         return null;
       }
       MembersCreator.computeClassMembersByName(
           compiler, receiverClass.declaration, name);
       target = receiverClass.lookupLocalMember(name);
-      if (target == null || target.isInstanceMember()) {
+      if (target == null || target.isInstanceMember) {
         compiler.backend.registerThrowNoSuchMethod(mapping);
         // TODO(johnniwinther): With the simplified [TreeElements] invariant,
         // try to resolve injected elements if [currentClass] is in the patch
         // library of [receiverClass].
 
         // TODO(karlklose): this should be reported by the caller of
         // [resolveSend] to select better warning messages for getters and
         // setters.
         MessageKind kind = (target == null)
             ? MessageKind.MEMBER_NOT_FOUND
@@ skipping 67 matching lines @@
         !link.isEmpty;
         link = link.tail) {
       Expression argument = link.head;
       NamedArgument namedArgument = argument.asNamedArgument();
       if (namedArgument != null) {
         named.add(namedArgument.name.source);
       }
       arity++;
     }
 
-    if (element != null && element.isConstructor()) {
+    if (element != null && element.isConstructor) {
       return new Selector.callConstructor(
           element.name, library, arity, named);
     }
 
     // If we're invoking a closure, we do not have an identifier.
     return (identifier == null)
         ? new Selector.callClosure(arity, named)
         : new Selector.call(identifier.source, library, arity, named);
   }
 
   Selector resolveSelector(Send node, Element element) {
-    LibraryElement library = enclosingElement.getLibrary();
+    LibraryElement library = enclosingElement.library;
     Selector selector = computeSendSelector(node, library, element);
     if (selector != null) mapping.setSelector(node, selector);
     return selector;
   }
 
   void resolveArguments(NodeList list) {
     if (list == null) return;
     bool oldSendIsMemberAccess = sendIsMemberAccess;
     sendIsMemberAccess = false;
     Map<String, Node> seenNamedArguments = new Map<String, Node>();
@@ skipping 32 matching lines @@
     if (target != null
         && target == compiler.mirrorSystemGetNameFunction
         && !compiler.mirrorUsageAnalyzerTask.hasMirrorUsage(enclosingElement)) {
       compiler.reportHint(
           node.selector, MessageKind.STATIC_FUNCTION_BLOAT,
           {'class': compiler.mirrorSystemClass.name,
            'name': compiler.mirrorSystemGetNameFunction.name});
     }
 
     if (!Elements.isUnresolved(target)) {
-      if (target.isAbstractField()) {
+      if (target.isAbstractField) {
         AbstractFieldElement field = target;
         target = field.getter;
         if (target == null && !inInstanceContext) {
           compiler.backend.registerThrowNoSuchMethod(mapping);
           target =
               warnAndCreateErroneousElement(node.selector, field.name,
                                             MessageKind.CANNOT_RESOLVE_GETTER);
         }
-      } else if (target.isTypeVariable()) {
-        ClassElement cls = target.getEnclosingClass();
-        assert(enclosingElement.getEnclosingClass() == cls);
+      } else if (target.isTypeVariable) {
+        ClassElement cls = target.enclosingClass;
+        assert(enclosingElement.enclosingClass == cls);
         compiler.backend.registerClassUsingVariableExpression(cls);
         compiler.backend.registerTypeVariableExpression(mapping);
         // Set the type of the node to [Type] to mark this send as a
         // type variable expression.
         mapping.setType(node, compiler.typeClass.computeType(compiler));
         world.registerTypeLiteral(target, mapping);
-      } else if (target.impliesType() && (!sendIsMemberAccess || node.isCall)) {
+      } else if (target.impliesType && (!sendIsMemberAccess || node.isCall)) {
         // Set the type of the node to [Type] to mark this send as a
         // type literal.
         mapping.setType(node, compiler.typeClass.computeType(compiler));
         world.registerTypeLiteral(target, mapping);
 
         // Don't try to make constants of calls to type literals.
         if (!node.isCall) {
           analyzeConstant(node);
         } else {
           // The node itself is not a constant but we register the selector (the
@@ skipping 39 matching lines @@
       resolveArguments(node.argumentsNode);
     }
 
     // If the selector is null, it means that we will not be generating
     // code for this as a send.
     Selector selector = mapping.getSelector(node);
     if (selector == null) return null;
 
     if (node.isCall) {
       if (Elements.isUnresolved(target) ||
-          target.isGetter() ||
-          target.isField() ||
+          target.isGetter ||
+          target.isField ||
           Elements.isClosureSend(node, target)) {
         // If we don't know what we're calling or if we are calling a getter,
         // we need to register that fact that we may be calling a closure
         // with the same arguments.
         Selector call = new Selector.callClosureFrom(selector);
         world.registerDynamicInvocation(call);
-      } else if (target.impliesType()) {
+      } else if (target.impliesType) {
         // We call 'call()' on a Type instance returned from the reference to a
         // class or typedef literal. We do not need to register this call as a
         // dynamic invocation, because we statically know what the target is.
       } else if (!selector.applies(target, compiler)) {
         warnArgumentMismatch(node, target);
         if (node.isSuperCall) {
           // Similar to what we do when we can't find super via selector
           // in [resolveSend] above, we still need to register the invocation,
           // because we might call [:super.noSuchMethod:] which calls
           // [JSInvocationMirror._invokeOn].
@@ skipping 48 matching lines @@
     bool oldSendIsMemberAccess = sendIsMemberAccess;
     sendIsMemberAccess = node.isPropertyAccess || node.isCall;
     Element target = resolveSend(node);
     sendIsMemberAccess = oldSendIsMemberAccess;
     Element setter = target;
     Element getter = target;
     String operatorName = node.assignmentOperator.source;
     String source = operatorName;
     bool isComplex = !identical(source, '=');
     if (!Elements.isUnresolved(target)) {
-      if (target.isAbstractField()) {
+      if (target.isAbstractField) {
         AbstractFieldElement field = target;
         setter = field.setter;
         getter = field.getter;
         if (setter == null && !inInstanceContext) {
           setter = warnAndCreateErroneousElement(
               node.selector, field.name, MessageKind.CANNOT_RESOLVE_SETTER);
           compiler.backend.registerThrowNoSuchMethod(mapping);
         }
         if (isComplex && getter == null && !inInstanceContext) {
           getter = warnAndCreateErroneousElement(
               node.selector, field.name, MessageKind.CANNOT_RESOLVE_GETTER);
           compiler.backend.registerThrowNoSuchMethod(mapping);
         }
-      } else if (target.impliesType()) {
+      } else if (target.impliesType) {
         setter = warnAndCreateErroneousElement(
             node.selector, target.name, MessageKind.ASSIGNING_TYPE);
         compiler.backend.registerThrowNoSuchMethod(mapping);
-      } else if (target.modifiers.isFinal() ||
-                 target.modifiers.isConst() ||
-                 (target.isFunction() &&
+      } else if (target.modifiers.isFinal ||
+                 target.modifiers.isConst ||
+                 (target.isFunction &&
                   Elements.isStaticOrTopLevelFunction(target) &&
-                  !target.isSetter())) {
-        if (target.isFunction()) {
+                  !target.isSetter)) {
+        if (target.isFunction) {
           setter = warnAndCreateErroneousElement(
               node.selector, target.name, MessageKind.ASSIGNING_METHOD);
         } else {
           setter = warnAndCreateErroneousElement(
               node.selector, target.name, MessageKind.CANNOT_RESOLVE_SETTER);
         }
         compiler.backend.registerThrowNoSuchMethod(mapping);
       }
       if (isPotentiallyMutableTarget(target)) {
         mapping.setPotentiallyMutated(target, node);
         if (enclosingElement != target.enclosingElement) {
           mapping.registerPotentiallyMutatedInClosure(target, node);
         }
         for (Node scope in promotionScope) {
           mapping.registerPotentiallyMutatedIn(scope, target, node);
         }
       }
     }
 
     resolveArguments(node.argumentsNode);
 
     Selector selector = mapping.getSelector(node);
     if (isComplex) {
       Selector getterSelector;
-      if (selector.isSetter()) {
+      if (selector.isSetter) {
         getterSelector = new Selector.getterFrom(selector);
       } else {
-        assert(selector.isIndexSet());
+        assert(selector.isIndexSet);
         getterSelector = new Selector.index();
       }
       registerSend(getterSelector, getter);
       mapping.setGetterSelectorInComplexSendSet(node, getterSelector);
       if (node.isSuperCall) {
         getter = currentClass.lookupSuperSelector(getterSelector, compiler);
         if (getter == null) {
           target = warnAndCreateErroneousElement(
               node, selector.name, MessageKind.NO_SUCH_SUPER_MEMBER,
               {'className': currentClass, 'memberName': selector.name});
@@ skipping 18 matching lines @@
       } else if (source.endsWith('=')) {
         registerBinaryOperator(Elements.mapToUserOperator(operatorName));
       }
     }
 
     registerSend(selector, setter);
     return useElement(node, setter);
   }
 
   void registerSend(Selector selector, Element target) {
-    if (target == null || target.isInstanceMember()) {
-      if (selector.isGetter()) {
+    if (target == null || target.isInstanceMember) {
+      if (selector.isGetter) {
         world.registerDynamicGetter(selector);
-      } else if (selector.isSetter()) {
+      } else if (selector.isSetter) {
         world.registerDynamicSetter(selector);
       } else {
         world.registerDynamicInvocation(selector);
       }
     } else if (Elements.isStaticOrTopLevel(target)) {
       // Avoid registration of type variables since they are not analyzable but
       // instead resolved through their enclosing type declaration.
-      if (!target.isTypeVariable()) {
+      if (!target.isTypeVariable) {
         // [target] might be the implementation element and only declaration
         // elements may be registered.
         world.registerStaticUse(target.declaration);
       }
     }
   }
 
   visitLiteralInt(LiteralInt node) {
     world.registerInstantiatedClass(compiler.intClass, mapping);
   }
@@ skipping 46 matching lines @@
       error(node, MessageKind.THROW_WITHOUT_EXPRESSION);
     }
   }
 
   visitReturn(Return node) {
     if (node.isRedirectingFactoryBody) {
       handleRedirectingFactoryBody(node);
     } else {
       Node expression = node.expression;
       if (expression != null &&
-          enclosingElement.isGenerativeConstructor()) {
+          enclosingElement.isGenerativeConstructor) {
         // It is a compile-time error if a return statement of the form
         // `return e;` appears in a generative constructor.  (Dart Language
         // Specification 13.12.)
         compiler.reportError(expression,
                              MessageKind.CANNOT_RETURN_FROM_CONSTRUCTOR);
       }
       visit(node.expression);
     }
   }
 
   void handleRedirectingFactoryBody(Return node) {
     final isSymbolConstructor = enclosingElement == compiler.symbolConstructor;
-    if (!enclosingElement.isFactoryConstructor()) {
+    if (!enclosingElement.isFactoryConstructor) {
       compiler.reportError(
           node, MessageKind.FACTORY_REDIRECTION_IN_NON_FACTORY);
       compiler.reportHint(
           enclosingElement, MessageKind.MISSING_FACTORY_KEYWORD);
     }
     FunctionElement constructor = enclosingElement;
-    bool isConstConstructor = constructor.modifiers.isConst();
+    bool isConstConstructor = constructor.modifiers.isConst;
     FunctionElement redirectionTarget = resolveRedirectingFactory(
         node, inConstContext: isConstConstructor);
     constructor.defaultImplementation = redirectionTarget;
     useElement(node.expression, redirectionTarget);
     if (Elements.isUnresolved(redirectionTarget)) {
       compiler.backend.registerThrowNoSuchMethod(mapping);
       return;
     } else {
       if (isConstConstructor &&
-          !redirectionTarget.modifiers.isConst()) {
+          !redirectionTarget.modifiers.isConst) {
         compiler.reportError(node, MessageKind.CONSTRUCTOR_IS_NOT_CONST);
       }
       if (redirectionTarget == constructor) {
         compiler.reportError(node, MessageKind.CYCLIC_REDIRECTING_FACTORY);
         return;
       }
     }
 
     // Check that the target constructor is type compatible with the
     // redirecting constructor.
-    ClassElement targetClass = redirectionTarget.getEnclosingClass();
+    ClassElement targetClass = redirectionTarget.enclosingClass;
     InterfaceType type = mapping.getType(node.expression);
     FunctionType targetType = redirectionTarget.computeType(compiler)
         .subst(type.typeArguments, targetClass.typeVariables);
     FunctionType constructorType = constructor.computeType(compiler);
     bool isSubtype = compiler.types.isSubtype(targetType, constructorType);
     if (!isSubtype) {
       warning(node, MessageKind.NOT_ASSIGNABLE,
               {'fromType': targetType, 'toType': constructorType});
     }
 
@@ skipping 46 matching lines @@
            nodes = nodes.tail) {
         if (modifier == nodes.head.asIdentifier().source) {
           modifierNode = nodes.head;
           break;
         }
       }
       assert(modifierNode != null);
       compiler.reportError(modifierNode, MessageKind.EXTRANEOUS_MODIFIER,
           {'modifier': modifier});
     }
-    if (modifiers.isFinal() && (modifiers.isConst() || modifiers.isVar())) {
+    if (modifiers.isFinal && (modifiers.isConst || modifiers.isVar)) {
       reportExtraModifier('final');
     }
-    if (modifiers.isVar() && (modifiers.isConst() || node.type != null)) {
+    if (modifiers.isVar && (modifiers.isConst || node.type != null)) {
       reportExtraModifier('var');
     }
-    if (enclosingElement.isFunction()) {
-      if (modifiers.isAbstract()) {
+    if (enclosingElement.isFunction) {
+      if (modifiers.isAbstract) {
         reportExtraModifier('abstract');
       }
-      if (modifiers.isStatic()) {
+      if (modifiers.isStatic) {
         reportExtraModifier('static');
       }
     }
     if (node.metadata != null) {
       variables.metadata =
           compiler.resolver.resolveMetadata(enclosingElement, node);
     }
     visitor.visit(node.definitions);
   }
 
   visitWhile(While node) {
     visit(node.condition);
     visitLoopBodyIn(node, node.body, new BlockScope(scope));
   }
 
   visitParenthesizedExpression(ParenthesizedExpression node) {
     bool oldSendIsMemberAccess = sendIsMemberAccess;
     sendIsMemberAccess = false;
     visit(node.expression);
     sendIsMemberAccess = oldSendIsMemberAccess;
   }
 
   visitNewExpression(NewExpression node) {
     Node selector = node.send.selector;
     FunctionElement constructor = resolveConstructor(node);
     final bool isSymbolConstructor = constructor == compiler.symbolConstructor;
     final bool isMirrorsUsedConstant =
-        node.isConst() && (constructor == compiler.mirrorsUsedConstructor);
+        node.isConst && (constructor == compiler.mirrorsUsedConstructor);
     resolveSelector(node.send, constructor);
     resolveArguments(node.send.argumentsNode);
     useElement(node.send, constructor);
     if (Elements.isUnresolved(constructor)) return constructor;
     Selector callSelector = mapping.getSelector(node.send);
     if (!callSelector.applies(constructor, compiler)) {
       warnArgumentMismatch(node.send, constructor);
       compiler.backend.registerThrowNoSuchMethod(mapping);
     }
 
     // [constructor] might be the implementation element
     // and only declaration elements may be registered.
     world.registerStaticUse(constructor.declaration);
-    ClassElement cls = constructor.getEnclosingClass();
+    ClassElement cls = constructor.enclosingClass;
     InterfaceType type = mapping.getType(node);
-    if (node.isConst() && type.containsTypeVariables) {
+    if (node.isConst && type.containsTypeVariables) {
       compiler.reportError(node.send.selector,
                            MessageKind.TYPE_VARIABLE_IN_CONSTANT);
     }
     world.registerInstantiatedType(type, mapping);
-    if (constructor.isFactoryConstructor() && !type.typeArguments.isEmpty) {
+    if (constructor.isFactoryConstructor && !type.typeArguments.isEmpty) {
       world.registerFactoryWithTypeArguments(mapping);
     }
-    if (constructor.isGenerativeConstructor() && cls.isAbstract) {
+    if (constructor.isGenerativeConstructor && cls.isAbstract) {
       warning(node, MessageKind.ABSTRACT_CLASS_INSTANTIATION);
       compiler.backend.registerAbstractClassInstantiation(mapping);
     }
 
     if (isSymbolConstructor) {
-      if (node.isConst()) {
+      if (node.isConst) {
         Node argumentNode = node.send.arguments.head;
         Constant name = compiler.resolver.constantCompiler.compileNode(
             argumentNode, mapping);
         if (!name.isString) {
           DartType type = name.computeType(compiler);
           compiler.reportError(argumentNode, MessageKind.STRING_EXPECTED,
                                    {'type': type});
         } else {
           StringConstant stringConstant = name;
           String nameString = stringConstant.toDartString().slowToString();
           if (validateSymbol(argumentNode, nameString)) {
             world.registerConstSymbol(nameString, mapping);
           }
         }
       } else {
         if (!compiler.mirrorUsageAnalyzerTask.hasMirrorUsage(
                 enclosingElement)) {
           compiler.reportHint(
               node.newToken, MessageKind.NON_CONST_BLOAT,
               {'name': compiler.symbolClass.name});
         }
         world.registerNewSymbol(mapping);
       }
     } else if (isMirrorsUsedConstant) {
       compiler.mirrorUsageAnalyzerTask.validate(node, mapping);
     }
-    if (node.isConst()) {
+    if (node.isConst) {
       analyzeConstant(node);
     }
 
     return null;
   }
 
   void checkConstMapKeysDontOverrideEquals(Spannable spannable,
                                            MapConstant map) {
     for (Constant key in map.keys.entries) {
       if (!key.isObject) continue;
       ObjectConstant objectConstant = key;
       DartType keyType = objectConstant.type;
       ClassElement cls = keyType.element;
       if (cls == compiler.stringClass) continue;
       Element equals = cls.lookupMember('==');
-      if (equals.getEnclosingClass() != compiler.objectClass) {
+      if (equals.enclosingClass != compiler.objectClass) {
         compiler.reportError(spannable,
                              MessageKind.CONST_MAP_KEY_OVERRIDES_EQUALS,
                              {'type': keyType});
       }
     }
   }
 
   void analyzeConstant(Node node) {
     addDeferredAction(enclosingElement, () {
       Constant constant =
@@ skipping 91 matching lines @@
       } else {
         typeArgument = resolveTypeAnnotation(nodes.head);
         for (nodes = nodes.tail; !nodes.isEmpty; nodes = nodes.tail) {
           warning(nodes.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT);
           resolveTypeAnnotation(nodes.head);
         }
       }
     }
     DartType listType;
     if (typeArgument != null) {
-      if (node.isConst() && typeArgument.containsTypeVariables) {
+      if (node.isConst && typeArgument.containsTypeVariables) {
         compiler.reportError(arguments.nodes.head,
             MessageKind.TYPE_VARIABLE_IN_CONSTANT);
       }
       listType = new InterfaceType(compiler.listClass,
                                    new Link<DartType>.fromList([typeArgument]));
     } else {
       compiler.listClass.computeType(compiler);
       listType = compiler.listClass.rawType;
     }
     mapping.setType(node, listType);
     world.registerInstantiatedType(listType, mapping);
     compiler.backend.registerRequiredType(listType, enclosingElement);
     visit(node.elements);
-    if (node.isConst()) {
+    if (node.isConst) {
       analyzeConstant(node);
     }
 
     sendIsMemberAccess = false;
   }
 
   visitConditional(Conditional node) {
     doInPromotionScope(node.condition, () => visit(node.condition));
     doInPromotionScope(node.thenExpression, () => visit(node.thenExpression));
     visit(node.elseExpression);
@@ skipping 68 matching lines @@
     }
     mapping[node] = target;
   }
 
   registerImplicitInvocation(String name, int arity) {
     Selector selector = new Selector.call(name, null, arity);
     world.registerDynamicInvocation(selector);
   }
 
   visitForIn(ForIn node) {
-    LibraryElement library = enclosingElement.getLibrary();
+    LibraryElement library = enclosingElement.library;
     mapping.setIteratorSelector(node, compiler.iteratorSelector);
     world.registerDynamicGetter(compiler.iteratorSelector);
     mapping.setCurrentSelector(node, compiler.currentSelector);
     world.registerDynamicGetter(compiler.currentSelector);
     mapping.setMoveNextSelector(node, compiler.moveNextSelector);
     world.registerDynamicInvocation(compiler.moveNextSelector);
 
     visit(node.expression);
     Scope blockScope = new BlockScope(scope);
     Node declaration = node.declaredIdentifier;
@@ skipping 108 matching lines @@
       }
     }
     DartType mapType;
     if (valueTypeArgument != null) {
       mapType = new InterfaceType(compiler.mapClass,
           new Link<DartType>.fromList([keyTypeArgument, valueTypeArgument]));
     } else {
       compiler.mapClass.computeType(compiler);
       mapType = compiler.mapClass.rawType;
     }
-    if (node.isConst() && mapType.containsTypeVariables) {
+    if (node.isConst && mapType.containsTypeVariables) {
       compiler.reportError(arguments,
           MessageKind.TYPE_VARIABLE_IN_CONSTANT);
     }
     mapping.setType(node, mapType);
     world.registerInstantiatedType(mapType, mapping);
-    if (node.isConst()) {
+    if (node.isConst) {
       compiler.backend.registerConstantMap(mapping);
     }
     compiler.backend.registerRequiredType(mapType, enclosingElement);
     node.visitChildren(this);
-    if (node.isConst()) {
+    if (node.isConst) {
       analyzeConstant(node);
     }
 
     sendIsMemberAccess = false;
   }
 
   visitLiteralMapEntry(LiteralMapEntry node) {
     node.visitChildren(this);
   }
 
   visitNamedArgument(NamedArgument node) {
     visit(node.expression);
   }
 
   DartType typeOfConstant(Constant constant) {
     if (constant.isInt) return compiler.intClass.rawType;
     if (constant.isBool) return compiler.boolClass.rawType;
     if (constant.isDouble) return compiler.doubleClass.rawType;
     if (constant.isString) return compiler.stringClass.rawType;
     if (constant.isNull) return compiler.nullClass.rawType;
     if (constant.isFunction) return compiler.functionClass.rawType;
     assert(constant.isObject);
     ObjectConstant objectConstant = constant;
     return objectConstant.type;
   }
 
   bool overridesEquals(DartType type) {
     ClassElement cls = type.element;
     Element equals = cls.lookupMember('==');
-    return equals.getEnclosingClass() != compiler.objectClass;
+    return equals.enclosingClass != compiler.objectClass;
   }
 
   void checkCaseExpressions(SwitchStatement node) {
     TargetElement breakElement = getOrCreateTargetElement(node);
     Map<String, LabelElement> continueLabels = <String, LabelElement>{};
 
     Link<Node> cases = node.cases.nodes;
     SwitchCase switchCase = cases.head;
     CaseMatch firstCase = null;
     DartType firstCaseType = null;
@@ skipping 258 matching lines @@
       if (typeNode.bound != null) {
         DartType boundType = typeResolver.resolveTypeAnnotation(
             this, typeNode.bound);
         variableElement.boundCache = boundType;
 
         void checkTypeVariableBound() {
           Link<TypeVariableElement> seenTypeVariables =
               const Link<TypeVariableElement>();
           seenTypeVariables = seenTypeVariables.prepend(variableElement);
           DartType bound = boundType;
-          while (bound.element.isTypeVariable()) {
+          while (bound.element.isTypeVariable) {
             TypeVariableElement element = bound.element;
             if (seenTypeVariables.contains(element)) {
               if (identical(element, variableElement)) {
                 // Only report an error on the checked type variable to avoid
                 // generating multiple errors for the same cyclicity.
                 warning(typeNode.name, MessageKind.CYCLIC_TYPE_VARIABLE,
                     {'typeVariableName': variableElement.name});
               }
               break;
             }
@@ skipping 201 matching lines @@
 
     if (element.interfaces == null) {
       element.interfaces = resolveInterfaces(node.interfaces, node.superclass);
     } else {
       assert(invariant(element, element.hasIncompleteHierarchy));
     }
     calculateAllSupertypes(element);
 
     if (!element.hasConstructor) {
       Element superMember = element.superclass.localLookup('');
-      if (superMember == null || !superMember.isGenerativeConstructor()) {
+      if (superMember == null || !superMember.isGenerativeConstructor) {
         MessageKind kind = MessageKind.CANNOT_FIND_CONSTRUCTOR;
         Map arguments = {'constructorName': ''};
         // TODO(ahe): Why is this a compile-time error? Or if it is an error,
         // why do we bother to registerThrowNoSuchMethod below?
         compiler.reportError(node, kind, arguments);
         superMember = new ErroneousElementX(
             kind, arguments, '', element);
         compiler.backend.registerThrowNoSuchMethod(mapping);
       } else {
-        Selector callToMatch = new Selector.call("", element.getLibrary(), 0);
+        Selector callToMatch = new Selector.call("", element.library, 0);
         if (!callToMatch.applies(superMember, compiler)) {
           MessageKind kind = MessageKind.NO_MATCHING_CONSTRUCTOR_FOR_IMPLICIT;
           compiler.reportError(node, kind);
           superMember = new ErroneousElementX(kind, {}, '', element);
         }
       }
       FunctionElement constructor =
           new SynthesizedConstructorElementX.forDefault(superMember, element);
       element.setDefaultConstructor(constructor, compiler);
     }
@@ skipping 41 matching lines @@
     }
     doApplyMixinTo(element, supertype, checkMixinType(link.head));
     return element.computeType(compiler);
   }
 
   DartType applyMixin(DartType supertype, DartType mixinType, Node node) {
     String superName = supertype.name;
     String mixinName = mixinType.name;
     MixinApplicationElementX mixinApplication = new MixinApplicationElementX(
         "${superName}+${mixinName}",
-        element.getCompilationUnit(),
+        element.compilationUnit,
         compiler.getNextFreeClassId(),
         node,
         new Modifiers.withFlags(new NodeList.empty(), Modifiers.FLAG_ABSTRACT));
     // Create synthetic type variables for the mixin application.
     LinkBuilder<DartType> typeVariablesBuilder = new LinkBuilder<DartType>();
     element.typeVariables.forEach((TypeVariableType type) {
       TypeVariableElementX typeVariableElement = new TypeVariableElementX(
           type.name, mixinApplication, type.element.parseNode(compiler));
       TypeVariableType typeVariable = new TypeVariableType(typeVariableElement);
       typeVariablesBuilder.addLast(typeVariable);
@@ skipping 78 matching lines @@
       mixinApplication.allSupertypesAndSelf = superclass.allSupertypesAndSelf;
       return;
     }
 
     assert(mixinApplication.mixinType == null);
     mixinApplication.mixinType = resolveMixinFor(mixinApplication, mixinType);
 
     // Create forwarding constructors for constructor defined in the superclass
     // because they are now hidden by the mixin application.
     superclass.forEachLocalMember((Element member) {
-      if (!member.isGenerativeConstructor()) return;
+      if (!member.isGenerativeConstructor) return;
       FunctionElement forwarder =
           createForwardingConstructor(member, mixinApplication);
       mixinApplication.addConstructor(forwarder);
     });
     calculateAllSupertypes(mixinApplication);
   }
 
   InterfaceType resolveMixinFor(MixinApplicationElement mixinApplication,
                                 DartType mixinType) {
     ClassElement mixin = mixinType.element;
@@ skipping 141 matching lines @@
         message: "Supertypes not computed on $classElement "
                  "during resolution of $element"));
     while (!supertypes.isEmpty) {
       DartType supertype = supertypes.head;
       allSupertypes.add(compiler, supertype.substByContext(type));
       supertypes = supertypes.tail;
     }
   }
 
   isBlackListed(DartType type) {
-    LibraryElement lib = element.getLibrary();
+    LibraryElement lib = element.library;
     return
       !identical(lib, compiler.coreLibrary) &&
       !identical(lib, compiler.jsHelperLibrary) &&
       !identical(lib, compiler.interceptorsLibrary) &&
       (identical(type, compiler.types.dynamicType) ||
        identical(type.element, compiler.boolClass) ||
        identical(type.element, compiler.numClass) ||
        identical(type.element, compiler.intClass) ||
        identical(type.element, compiler.doubleClass) ||
        identical(type.element, compiler.stringClass) ||
@@ skipping 44 matching lines @@
     visitNodeList(node.mixins);
     visitNodeList(node.interfaces);
   }
 
   void visitTypeAnnotation(TypeAnnotation node) {
     node.typeName.accept(this);
   }
 
   void visitIdentifier(Identifier node) {
     Element element = lookupInScope(compiler, node, context, node.source);
-    if (element != null && element.isClass()) {
+    if (element != null && element.isClass) {
       loadSupertype(element, node);
     }
   }
 
   void visitSend(Send node) {
     Identifier prefix = node.receiver.asIdentifier();
     if (prefix == null) {
       error(node.receiver, MessageKind.NOT_A_PREFIX, {'node': node.receiver});
       return;
     }
     Element element = lookupInScope(compiler, prefix, context, prefix.source);
     if (element == null || !identical(element.kind, ElementKind.PREFIX)) {
       error(node.receiver, MessageKind.NOT_A_PREFIX, {'node': node.receiver});
       return;
     }
     PrefixElement prefixElement = element;
     Identifier selector = node.selector.asIdentifier();
     var e = prefixElement.lookupLocalMember(selector.source);
-    if (e == null || !e.impliesType()) {
+    if (e == null || !e.impliesType) {
       error(node.selector, MessageKind.CANNOT_RESOLVE_TYPE,
             {'typeName': node.selector});
       return;
     }
     loadSupertype(e, node);
   }
 }
 
 class VariableDefinitionsVisitor extends CommonResolverVisitor<Identifier> {
   VariableDefinitions definitions;
@@ skipping 21 matching lines @@
           identifier, MessageKind.REFERENCE_IN_INITIALIZATION,
           {'variableName': name});
     }
     return identifier;
   }
 
   Identifier visitIdentifier(Identifier node) {
     // The variable is initialized to null.
     resolver.world.registerInstantiatedClass(compiler.nullClass,
                                              resolver.mapping);
-    if (definitions.modifiers.isConst()) {
+    if (definitions.modifiers.isConst) {
       compiler.reportError(node, MessageKind.CONST_WITHOUT_INITIALIZER);
     }
-    if (definitions.modifiers.isFinal() &&
+    if (definitions.modifiers.isFinal &&
         !resolver.allowFinalWithoutInitializer) {
       compiler.reportError(node, MessageKind.FINAL_WITHOUT_INITIALIZER);
     }
     return node;
   }
 
   visitNodeList(NodeList node) {
     for (Link<Node> link = node.nodes; !link.isEmpty; link = link.tail) {
       Identifier name = visit(link.head);
       VariableElement element = new VariableElementX(
           name.source, kind, resolver.enclosingElement,
           variables, name.token);
       resolver.defineElement(link.head, element);
-      if (definitions.modifiers.isConst()) {
+      if (definitions.modifiers.isConst) {
         compiler.enqueuer.resolution.addDeferredAction(element, () {
           compiler.resolver.constantCompiler.compileConstant(element);
         });
       }
     }
   }
 }
 
 class ConstructorResolver extends CommonResolverVisitor<Element> {
   final ResolverVisitor resolver;
@@ skipping 20 matching lines @@
       compiler.reportError(diagnosticNode, kind, arguments);
     } else {
       compiler.reportWarning(diagnosticNode, kind, arguments);
     }
     return new ErroneousElementX(kind, arguments, targetName, enclosing);
   }
 
   Selector createConstructorSelector(String constructorName) {
     return constructorName == ''
         ? new Selector.callDefaultConstructor(
-            resolver.enclosingElement.getLibrary())
+            resolver.enclosingElement.library)
         : new Selector.callConstructor(
             constructorName,
-            resolver.enclosingElement.getLibrary());
+            resolver.enclosingElement.library);
   }
 
   FunctionElement resolveConstructor(ClassElement cls,
                                      Node diagnosticNode,
                                      String constructorName) {
     cls.ensureResolved(compiler);
     Selector selector = createConstructorSelector(constructorName);
     Element result = cls.lookupConstructor(selector);
     if (result == null) {
       String fullConstructorName =
           resolver.compiler.resolver.constructorNameForDiagnostics(
               cls.name,
               constructorName);
       return failOrReturnErroneousElement(
           cls,
           diagnosticNode,
           fullConstructorName,
           MessageKind.CANNOT_FIND_CONSTRUCTOR,
           {'constructorName': fullConstructorName});
-    } else if (inConstContext && !result.modifiers.isConst()) {
+    } else if (inConstContext && !result.modifiers.isConst) {
       error(diagnosticNode, MessageKind.CONSTRUCTOR_IS_NOT_CONST);
     }
     return result;
   }
 
   Element visitNewExpression(NewExpression node) {
-    inConstContext = node.isConst();
+    inConstContext = node.isConst;
     Node selector = node.send.selector;
     Element element = visit(selector);
     assert(invariant(selector, element != null,
         message: 'No element return for $selector.'));
     return finishConstructorReference(element, node.send.selector, node);
   }
 
   /// Finishes resolution of a constructor reference and records the
   /// type of the constructed instance on [expression].
   FunctionElement finishConstructorReference(Element element,
                                              Node diagnosticNode,
                                              Node expression) {
     assert(invariant(diagnosticNode, element != null,
         message: 'No element return for $diagnosticNode.'));
     // Find the unnamed constructor if the reference resolved to a
     // class.
-    if (!Elements.isUnresolved(element) && !element.isConstructor()) {
-      if (element.isClass()) {
+    if (!Elements.isUnresolved(element) && !element.isConstructor) {
+      if (element.isClass) {
         ClassElement cls = element;
         cls.ensureResolved(compiler);
         // The unnamed constructor may not exist, so [e] may become unresolved.
         element = resolveConstructor(cls, diagnosticNode, '');
       } else {
         element = failOrReturnErroneousElement(
             element, diagnosticNode, element.name, MessageKind.NOT_A_TYPE,
             {'node': diagnosticNode});
       }
     }
     if (type == null) {
       if (Elements.isUnresolved(element)) {
         type = compiler.types.dynamicType;
       } else {
-        type = element.getEnclosingClass().rawType;
+        type = element.enclosingClass.rawType;
       }
     }
     resolver.mapping.setType(expression, type);
     return element;
   }
 
   Element visitTypeAnnotation(TypeAnnotation node) {
     assert(invariant(node, type == null));
     // This is not really resolving a type-annotation, but the name of the
     // constructor. Therefore we allow deferred types.
     type = resolver.resolveTypeAnnotation(node,
                                           malformedIsError: inConstContext,
                                           deferredIsMalformed: false);
     compiler.backend.registerRequiredType(type, resolver.enclosingElement);
     return type.element;
   }
 
   Element visitSend(Send node) {
     Element element = visit(node.receiver);
     assert(invariant(node.receiver, element != null,
         message: 'No element return for $node.receiver.'));
     if (Elements.isUnresolved(element)) return element;
     Identifier name = node.selector.asIdentifier();
     if (name == null) internalError(node.selector, 'unexpected node');
 
-    if (element.isClass()) {
+    if (element.isClass) {
       ClassElement cls = element;
       cls.ensureResolved(compiler);
       return resolveConstructor(cls, name, name.source);
-    } else if (element.isPrefix()) {
+    } else if (element.isPrefix) {
       PrefixElement prefix = element;
       element = prefix.lookupLocalMember(name.source);
       element = Elements.unwrap(element, compiler, node);
       if (element == null) {
         return failOrReturnErroneousElement(
             resolver.enclosingElement, name,
             name.source,
             MessageKind.CANNOT_RESOLVE,
             {'name': name});
-      } else if (!element.isClass()) {
+      } else if (!element.isClass) {
         error(node, MessageKind.NOT_A_TYPE, {'node': name});
       }
     } else {
       internalError(node.receiver, 'unexpected element $element');
     }
     return element;
   }
 
   Element visitIdentifier(Identifier node) {
     String name = node.source;
     Element element = resolver.reportLookupErrorIfAny(
         lookupInScope(compiler, node, resolver.scope, name), node, name);
     resolver.useElement(node, element);
     // TODO(johnniwinther): Change errors to warnings, cf. 11.11.1.
     if (element == null) {
       return failOrReturnErroneousElement(resolver.enclosingElement, node, name,
                                           MessageKind.CANNOT_RESOLVE,
                                           {'name': name});
-    } else if (element.isErroneous()) {
+    } else if (element.isErroneous) {
       return element;
-    } else if (element.isTypedef()) {
+    } else if (element.isTypedef) {
       error(node, MessageKind.CANNOT_INSTANTIATE_TYPEDEF,
             {'typedefName': name});
-    } else if (element.isTypeVariable()) {
+    } else if (element.isTypeVariable) {
       error(node, MessageKind.CANNOT_INSTANTIATE_TYPE_VARIABLE,
             {'typeVariableName': name});
-    } else if (!element.isClass() && !element.isPrefix()) {
+    } else if (!element.isClass && !element.isPrefix) {
       error(node, MessageKind.NOT_A_TYPE, {'node': name});
     }
     return element;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
@@ skipping 17 matching lines @@
   TreeElements _treeElements;
 
   bool get hasTreeElements => _treeElements != null;
 
   TreeElements get treeElements {
     assert(invariant(this, _treeElements !=null,
         message: "TreeElements have not been computed for $this."));
     return _treeElements;
   }
 }