Convert property methods into getters.

sdk/lib/_internal/compiler/implementation/ssa/builder.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 ssa;
 
 /**
  * A special element for the extra parameter taken by intercepted
  * methods. We need to implement [TypedElement.type] because our
  * optimizers may look at its declared type.
@@ skipping 29 matching lines @@
         HGraph graph;
         ElementKind kind = element.kind;
         if (kind == ElementKind.GENERATIVE_CONSTRUCTOR) {
           graph = compileConstructor(builder, work);
         } else if (kind == ElementKind.GENERATIVE_CONSTRUCTOR_BODY ||
                    kind == ElementKind.FUNCTION ||
                    kind == ElementKind.GETTER ||
                    kind == ElementKind.SETTER) {
           graph = builder.buildMethod(element);
         } else if (kind == ElementKind.FIELD) {
-          if (element.isInstanceMember()) {
+          if (element.isInstanceMember) {
             assert(compiler.enableTypeAssertions);
             graph = builder.buildCheckedSetter(element);
           } else {
             graph = builder.buildLazyInitializer(element);
           }
         } else {
           compiler.internalError(element, 'Unexpected element kind $kind.');
         }
         assert(graph.isValid());
         if (!identical(kind, ElementKind.FIELD)) {
           FunctionElement function = element;
           FunctionSignature signature = function.functionSignature;
           signature.forEachOptionalParameter((Element parameter) {
             // This ensures the default value will be computed.
             Constant constant =
                 backend.constants.getConstantForVariable(parameter);
             backend.registerCompileTimeConstant(constant, work.resolutionTree);
             backend.constants.addCompileTimeConstantForEmission(constant);
           });
         }
         if (compiler.tracer.enabled) {
           String name;
-          if (element.isMember()) {
-            String className = element.getEnclosingClass().name;
+          if (element.isMember) {
+            String className = element.enclosingClass.name;
             String memberName = element.name;
             name = "$className.$memberName";
-            if (element.isGenerativeConstructorBody()) {
+            if (element.isGenerativeConstructorBody) {
               name = "$name (body)";
             }
           } else {
             name = "${element.name}";
           }
           compiler.tracer.traceCompilation(
               name, work.compilationContext, compiler);
           compiler.tracer.traceGraph('builder', graph);
         }
         return graph;
@@ skipping 69 matching lines @@
    * If the scope (function or loop) [node] has captured variables then this
    * method creates a box and sets up the redirections.
    */
   void enterScope(ast.Node node, Element element) {
     // See if any variable in the top-scope of the function is captured. If yes
     // we need to create a box-object.
     ClosureScope scopeData = closureData.capturingScopes[node];
     if (scopeData == null) return;
     HInstruction box;
     // The scope has captured variables.
-    if (element != null && element.isGenerativeConstructorBody()) {
+    if (element != null && element.isGenerativeConstructorBody) {
       // The box is passed as a parameter to a generative
       // constructor body.
       JavaScriptBackend backend = builder.backend;
       box = builder.addParameter(scopeData.boxElement, backend.nonNullType);
     } else {
       box = createBox();
     }
     // Add the box to the known locals.
     directLocals[scopeData.boxElement] = box;
     // Make sure that accesses to the boxed locals go into the box. We also
     // need to make sure that parameters are copied into the box if necessary.
     scopeData.capturedVariableMapping.forEach((Element from, Element to) {
       // The [from] can only be a parameter for function-scopes and not
       // loop scopes.
-      if (from.isParameter() && !element.isGenerativeConstructorBody()) {
+      if (from.isParameter && !element.isGenerativeConstructorBody) {
         // Now that the redirection is set up, the update to the local will
         // write the parameter value into the box.
         // Store the captured parameter in the box. Get the current value
         // before we put the redirection in place.
         // We don't need to update the local for a generative
         // constructor body, because it receives a box that already
         // contains the updates as the last parameter.
         HInstruction instruction = readLocal(from);
         redirectElement(from, to);
         updateLocal(from, instruction);
@@ skipping 31 matching lines @@
   void startFunction(Element element, ast.Node node) {
     assert(invariant(element, element.isImplementation));
     Compiler compiler = builder.compiler;
     closureData = compiler.closureToClassMapper.computeClosureToClassMapping(
             element, node, builder.elements);
 
     if (element is FunctionElement) {
       FunctionElement functionElement = element;
       FunctionSignature params = functionElement.functionSignature;
       params.orderedForEachParameter((Element parameterElement) {
-        if (element.isGenerativeConstructorBody()) {
+        if (element.isGenerativeConstructorBody) {
           ClosureScope scopeData = closureData.capturingScopes[node];
           if (scopeData != null
               && scopeData.capturedVariableMapping.containsKey(
                   parameterElement)) {
             // The parameter will be a field in the box passed as the
             // last parameter. So no need to have it.
             return;
           }
         }
         HInstruction parameter = builder.addParameter(
             parameterElement,
             TypeMaskFactory.inferredTypeForElement(parameterElement, compiler));
         builder.parameters[parameterElement] = parameter;
         directLocals[parameterElement] = parameter;
       });
     }
 
     enterScope(node, element);
 
     // If the freeVariableMapping is not empty, then this function was a
     // nested closure that captures variables. Redirect the captured
     // variables to fields in the closure.
     closureData.freeVariableMapping.forEach((Element from, Element to) {
       redirectElement(from, to);
     });
     JavaScriptBackend backend = compiler.backend;
-    if (closureData.isClosure()) {
+    if (closureData.isClosure) {
       // Inside closure redirect references to itself to [:this:].
       HThis thisInstruction = new HThis(closureData.thisElement,
                                         backend.nonNullType);
       builder.graph.thisInstruction = thisInstruction;
       builder.graph.entry.addAtEntry(thisInstruction);
       updateLocal(closureData.closureElement, thisInstruction);
-    } else if (element.isInstanceMember()) {
+    } else if (element.isInstanceMember) {
       // Once closures have been mapped to classes their instance members might
       // not have any thisElement if the closure was created inside a static
       // context.
       HThis thisInstruction = new HThis(
           closureData.thisElement, builder.getTypeOfThis());
       builder.graph.thisInstruction = thisInstruction;
       builder.graph.entry.addAtEntry(thisInstruction);
       directLocals[closureData.thisElement] = thisInstruction;
     }
 
     // If this method is an intercepted method, add the extra
     // parameter to it, that is the actual receiver for intercepted
     // classes, or the same as [:this:] for non-intercepted classes.
-    ClassElement cls = element.getEnclosingClass();
+    ClassElement cls = element.enclosingClass;
 
     // When the class extends a native class, the instance is pre-constructed
     // and passed to the generative constructor factory function as a parameter.
     // Instead of allocating and initializing the object, the constructor
     // 'upgrades' the native subclass object by initializing the Dart fields.
-    bool isNativeUpgradeFactory = element.isGenerativeConstructor()
+    bool isNativeUpgradeFactory = element.isGenerativeConstructor
         && Elements.isNativeOrExtendsNative(cls);
     if (backend.isInterceptedMethod(element)) {
       bool isInterceptorClass = backend.isInterceptorClass(cls.declaration);
       String name = isInterceptorClass ? 'receiver' : '_';
       Element parameter = new InterceptedElement(
           cls.thisType, name, element);
       HParameterValue value =
           new HParameterValue(parameter, builder.getTypeOfThis());
       builder.graph.explicitReceiverParameter = value;
       builder.graph.entry.addAfter(
@@ skipping 22 matching lines @@
     assert(element != null);
     return redirectionMapping[element] == null
         && !closureData.usedVariablesInTry.contains(element);
   }
 
   bool isStoredInClosureField(Element element) {
     assert(element != null);
     if (isAccessedDirectly(element)) return false;
     Element redirectTarget = redirectionMapping[element];
     if (redirectTarget == null) return false;
-    if (redirectTarget.isMember()) {
+    if (redirectTarget.isMember) {
       assert(redirectTarget is ClosureFieldElement);
       return true;
     }
     return false;
   }
 
   bool isBoxed(Element element) {
     if (isAccessedDirectly(element)) return false;
     if (isStoredInClosureField(element)) return false;
     return redirectionMapping[element] != null;
   }
 
   bool isUsedInTry(Element element) {
     return closureData.usedVariablesInTry.contains(element);
   }
 
   /**
    * Returns an [HInstruction] for the given element. If the element is
    * boxed or stored in a closure then the method generates code to retrieve
    * the value.
    */
   HInstruction readLocal(Element element) {
     if (isAccessedDirectly(element)) {
       if (directLocals[element] == null) {
-        if (element.isTypeVariable()) {
+        if (element.isTypeVariable) {
           builder.compiler.internalError(builder.compiler.currentElement,
               "Runtime type information not available for $element.");
         } else {
           builder.compiler.internalError(element,
               "Cannot find value $element.");
         }
       }
       return directLocals[element];
     } else if (isStoredInClosureField(element)) {
       Element redirect = redirectionMapping[element];
@@ skipping 36 matching lines @@
     }
     return res;
   }
 
   HLocalValue getLocal(Element element) {
     // If the element is a parameter, we already have a
     // HParameterValue for it. We cannot create another one because
     // it could then have another name than the real parameter. And
     // the other one would not know it is just a copy of the real
     // parameter.
-    if (element.isParameter()) return builder.parameters[element];
+    if (element.isParameter) return builder.parameters[element];
 
     return builder.activationVariables.putIfAbsent(element, () {
       JavaScriptBackend backend = builder.backend;
       HLocalValue local = new HLocalValue(element, backend.nonNullType);
       builder.graph.entry.addAtExit(local);
       return local;
     });
   }
 
   /**
@@ skipping 607 matching lines @@
     add(attachPosition(instruction, node));
   }
 
   SourceFile currentSourceFile() {
     Element element = sourceElement;
     // TODO(johnniwinther): remove the 'element.patch' hack.
     if (element is FunctionElement) {
       FunctionElement functionElement = element;
       if (functionElement.patch != null) element = functionElement.patch;
     }
-    Script script = element.getCompilationUnit().script;
+    Script script = element.compilationUnit.script;
     return script.file;
   }
 
   void checkValidSourceFileLocation(
       SourceFileLocation location, SourceFile sourceFile, int offset) {
     if (!location.isValid()) {
       throw MessageKind.INVALID_SOURCE_FILE_LOCATION.message(
           {'offset': offset,
            'fileName': sourceFile.filename,
            'length': sourceFile.length});
     }
   }
 
   /**
    * Returns a complete argument list for a call of [function].
    */
   List<HInstruction> completeSendArgumentsList(
       FunctionElement function,
       Selector selector,
       List<HInstruction> providedArguments,
       ast.Node currentNode) {
     assert(invariant(function, function.isImplementation));
     assert(providedArguments != null);
 
-    bool isInstanceMember = function.isInstanceMember();
+    bool isInstanceMember = function.isInstanceMember;
     // For static calls, [providedArguments] is complete, default arguments
     // have been included if necessary, see [addStaticSendArgumentsToList].
     if (!isInstanceMember
         || currentNode == null // In erroneous code, currentNode can be null.
         || providedArgumentsKnownToBeComplete(currentNode)
-        || function.isGenerativeConstructorBody()
-        || selector.isGetter()) {
+        || function.isGenerativeConstructorBody
+        || selector.isGetter) {
       // For these cases, the provided argument list is known to be complete.
       return providedArguments;
     } else {
       return completeDynamicSendArgumentsList(
           selector, function, providedArguments);
     }
   }
 
   /**
    * Returns a complete argument list for a dynamic call of [function]. The
@@ skipping 89 matching lines @@
       // Don't inline from one output unit to another. If something is deferred
       // it is to save space in the loading code.
       if (!compiler.deferredLoadTask
           .inSameOutputUnit(element,compiler.currentElement)) {
         return false;
       }
       if (compiler.disableInlining) return false;
 
       assert(selector != null
              || Elements.isStaticOrTopLevel(element)
-             || element.isGenerativeConstructorBody());
+             || element.isGenerativeConstructorBody);
       if (selector != null && !selector.applies(function, compiler)) {
         return false;
       }
 
       // Don't inline operator== methods if the parameter can be null.
       if (element.name == '==') {
-        if (element.getEnclosingClass() != compiler.objectClass
+        if (element.enclosingClass != compiler.objectClass
             && providedArguments[1].canBeNull()) {
           return false;
         }
       }
 
       // Generative constructors of native classes should not be called directly
       // and have an extra argument that causes problems with inlining.
-      if (element.isGenerativeConstructor()
-          && Elements.isNativeOrExtendsNative(element.getEnclosingClass())) {
+      if (element.isGenerativeConstructor
+          && Elements.isNativeOrExtendsNative(element.enclosingClass)) {
         return false;
       }
 
       // A generative constructor body is not seen by global analysis,
       // so we should not query for its type.
-      if (!element.isGenerativeConstructorBody()) {
+      if (!element.isGenerativeConstructorBody) {
         // Don't inline if the return type was inferred to be non-null empty.
         // This means that the function always throws an exception.
         TypeMask returnType =
             compiler.typesTask.getGuaranteedReturnTypeOfElement(element);
         if (returnType != null
             && returnType.isEmpty
             && !returnType.isNullable) {
           isReachable = false;
           return false;
         }
@@ skipping 43 matching lines @@
       } else {
         backend.inlineCache.markAsNonInlinable(element, insideLoop: insideLoop);
       }
       return canInline;
     }
 
     void doInlining() {
       // Add an explicit null check on the receiver before doing the
       // inlining. We use [element] to get the same name in the
       // NoSuchMethodError message as if we had called it.
-      if (element.isInstanceMember()
-          && !element.isGenerativeConstructorBody()
+      if (element.isInstanceMember
+          && !element.isGenerativeConstructorBody
           && (selector.mask == null || selector.mask.isNullable)) {
         addWithPosition(
             new HFieldGet(null, providedArguments[0], backend.dynamicType,
                           isAssignable: false),
             currentNode);
       }
       List<HInstruction> compiledArguments = completeSendArgumentsList(
           function, selector, providedArguments, currentNode);
       enterInlinedMethod(function, currentNode, compiledArguments);
       inlinedFrom(function, () {
@@ skipping 27 matching lines @@
 
   HInstruction handleConstantForOptionalParameter(Element parameter) {
     Constant constant =
         backend.constants.getConstantForVariable(parameter);
     assert(invariant(parameter, constant != null,
         message: 'No constant computed for $parameter'));
     return graph.addConstant(constant, compiler);
   }
 
   Element get currentNonClosureClass {
-    ClassElement cls = sourceElement.getEnclosingClass();
-    if (cls != null && cls.isClosure()) {
+    ClassElement cls = sourceElement.enclosingClass;
+    if (cls != null && cls.isClosure) {
       var closureClass = cls;
-      return closureClass.methodElement.getEnclosingClass();
+      return closureClass.methodElement.enclosingClass;
     } else {
       return cls;
     }
   }
 
   /**
    * Returns whether this builder is building code for [element].
    */
   bool isBuildingFor(Element element) {
     return work.element == element;
@@ skipping 31 matching lines @@
         backend.constants.getConstantForVariable(element);
     return initialValue == null;
   }
 
   TypeMask cachedTypeOfThis;
 
   TypeMask getTypeOfThis() {
     TypeMask result = cachedTypeOfThis;
     if (result == null) {
       Element element = localsHandler.closureData.thisElement;
-      ClassElement cls = element.enclosingElement.getEnclosingClass();
+      ClassElement cls = element.enclosingElement.enclosingClass;
       if (compiler.world.isUsedAsMixin(cls)) {
         // If the enclosing class is used as a mixin, [:this:] can be
         // of the class that mixins the enclosing class. These two
         // classes do not have a subclass relationship, so, for
         // simplicity, we mark the type as an interface type.
         result = new TypeMask.nonNullSubtype(cls.declaration);
       } else {
         result = new TypeMask.nonNullSubclass(cls.declaration);
       }
       cachedTypeOfThis = result;
     }
     return result;
   }
 
   Map<Element, TypeMask> cachedTypesOfCapturedVariables =
       new Map<Element, TypeMask>();
 
   TypeMask getTypeOfCapturedVariable(Element element) {
-    assert(element.isField());
+    assert(element.isField);
     return cachedTypesOfCapturedVariables.putIfAbsent(element, () {
       return TypeMaskFactory.inferredTypeForElement(element, compiler);
     });
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [functionElement] must be an implementation element.
    */
   HGraph buildMethod(FunctionElement functionElement) {
     assert(invariant(functionElement, functionElement.isImplementation));
     graph.calledInLoop = compiler.world.isCalledInLoop(functionElement);
     ast.FunctionExpression function = functionElement.parseNode(compiler);
     assert(function != null);
-    assert(!function.modifiers.isExternal());
+    assert(!function.modifiers.isExternal);
     assert(elements[function] != null);
     openFunction(functionElement, function);
     String name = functionElement.name;
     // If [functionElement] is `operator==` we explicitely add a null check at
     // the beginning of the method. This is to avoid having call sites do the
     // null check.
     if (name == '==') {
       if (!backend.operatorEqHandlesNullArgument(functionElement)) {
         handleIf(
             function,
@@ skipping 41 matching lines @@
     return closeFunction();
   }
 
   /**
    * Returns the constructor body associated with the given constructor or
    * creates a new constructor body, if none can be found.
    *
    * Returns [:null:] if the constructor does not have a body.
    */
   ConstructorBodyElement getConstructorBody(FunctionElement constructor) {
-    assert(constructor.isGenerativeConstructor());
+    assert(constructor.isGenerativeConstructor);
     assert(invariant(constructor, constructor.isImplementation));
     if (constructor.isSynthesized) return null;
     ast.FunctionExpression node = constructor.parseNode(compiler);
     // If we know the body doesn't have any code, we don't generate it.
     if (!node.hasBody()) return null;
     if (node.hasEmptyBody()) return null;
-    ClassElement classElement = constructor.getEnclosingClass();
+    ClassElement classElement = constructor.enclosingClass;
     ConstructorBodyElement bodyElement;
     classElement.forEachBackendMember((Element backendMember) {
-      if (backendMember.isGenerativeConstructorBody()) {
+      if (backendMember.isGenerativeConstructorBody) {
         ConstructorBodyElement body = backendMember;
         if (body.constructor == constructor) {
           // TODO(kasperl): Find a way of stopping the iteration
           // through the backend members.
           bodyElement = backendMember;
         }
       }
     });
     if (bodyElement == null) {
       bodyElement = new ConstructorBodyElementX(constructor);
       classElement.addBackendMember(bodyElement);
 
       if (constructor.isPatch) {
         // Create origin body element for patched constructors.
         ConstructorBodyElementX patch = bodyElement;
         ConstructorBodyElementX origin =
             new ConstructorBodyElementX(constructor.origin);
         origin.applyPatch(patch);
         classElement.origin.addBackendMember(bodyElement.origin);
       }
     }
-    assert(bodyElement.isGenerativeConstructorBody());
+    assert(bodyElement.isGenerativeConstructorBody);
     return bodyElement;
   }
 
   HParameterValue addParameter(Element element, TypeMask type) {
     assert(inliningStack.isEmpty);
     HParameterValue result = new HParameterValue(element, type);
     if (lastAddedParameter == null) {
       graph.entry.addBefore(graph.entry.first, result);
     } else {
       graph.entry.addAfter(lastAddedParameter, result);
@@ skipping 19 matching lines @@
             function, function.parseNode(compiler), elements);
     // TODO(kasperl): Bad smell. We shouldn't be constructing elements here.
     returnElement = new VariableElementX.synthetic("result",
         ElementKind.VARIABLE, function);
     localsHandler.updateLocal(returnElement,
         graph.addConstantNull(compiler));
 
     inTryStatement = false; // TODO(lry): why? Document.
 
     int argumentIndex = 0;
-    if (function.isInstanceMember()) {
+    if (function.isInstanceMember) {
       localsHandler.updateLocal(localsHandler.closureData.thisElement,
           compiledArguments[argumentIndex++]);
     }
 
     FunctionSignature signature = function.functionSignature;
     signature.orderedForEachParameter((Element parameter) {
       HInstruction argument = compiledArguments[argumentIndex++];
       localsHandler.updateLocal(parameter, argument);
     });
 
-    ClassElement enclosing = function.getEnclosingClass();
-    if ((function.isConstructor() || function.isGenerativeConstructorBody())
+    ClassElement enclosing = function.enclosingClass;
+    if ((function.isConstructor || function.isGenerativeConstructorBody)
         && backend.classNeedsRti(enclosing)) {
       enclosing.typeVariables.forEach((TypeVariableType typeVariable) {
         HInstruction argument = compiledArguments[argumentIndex++];
         localsHandler.updateLocal(typeVariable.element, argument);
       });
     }
     assert(argumentIndex == compiledArguments.length);
 
     elements = compiler.enqueuer.resolution.getCachedElements(function);
     assert(elements != null);
     returnType = signature.type.returnType;
     stack = <HInstruction>[];
   }
 
   void restoreState(AstInliningState state) {
     localsHandler = state.oldLocalsHandler;
     returnElement = state.oldReturnElement;
     inTryStatement = state.inTryStatement;
     elements = state.oldElements;
     returnType = state.oldReturnType;
     assert(stack.isEmpty);
     stack = state.oldStack;
   }
 
   /**
    * Run this builder on the body of the [function] to be inlined.
    */
   void visitInlinedFunction(FunctionElement function) {
     potentiallyCheckInlinedParameterTypes(function);
-    if (function.isGenerativeConstructor()) {
+    if (function.isGenerativeConstructor) {
       buildFactory(function);
     } else {
       ast.FunctionExpression functionNode = function.parseNode(compiler);
       functionNode.body.accept(this);
     }
   }
 
 
   addInlinedInstantiation(DartType type) {
     if (type != null) {
@@ skipping 20 matching lines @@
   /**
    * In checked mode, generate type tests for the parameters of the inlined
    * function.
    */
   void potentiallyCheckInlinedParameterTypes(FunctionElement function) {
     if (!compiler.enableTypeAssertions) return;
 
     FunctionSignature signature = function.functionSignature;
 
     InterfaceType contextType;
-    if (function.isSynthesized && function.isGenerativeConstructor()) {
+    if (function.isSynthesized && function.isGenerativeConstructor) {
       // Synthesized constructors reuse the parameters from the
       // [targetConstructor]. In face of generic types, the type variables
       // occurring in the parameter types must be substituted by the type
       // arguments of the enclosing class.
       FunctionElement target = function;
       while (target.targetConstructor != null) {
         target = target.targetConstructor;
       }
       if (target != function) {
-        ClassElement functionClass = function.getEnclosingClass();
-        ClassElement targetClass = target.getEnclosingClass();
+        ClassElement functionClass = function.enclosingClass;
+        ClassElement targetClass = target.enclosingClass;
         contextType = functionClass.thisType.asInstanceOf(targetClass);
       }
     }
 
     signature.orderedForEachParameter((ParameterElement parameter) {
       HInstruction argument = localsHandler.readLocal(parameter);
       DartType parameterType = parameter.type;
       if (contextType != null) {
         parameterType = parameterType.substByContext(contextType);
       }
       potentiallyCheckType(argument, parameterType);
     });
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [constructors] must contain only implementation elements.
    */
   void inlineSuperOrRedirect(FunctionElement callee,
                              List<HInstruction> compiledArguments,
                              List<FunctionElement> constructors,
                              Map<Element, HInstruction> fieldValues,
                              FunctionElement caller) {
     callee = callee.implementation;
     compiler.withCurrentElement(callee, () {
       constructors.add(callee);
-      ClassElement enclosingClass = callee.getEnclosingClass();
+      ClassElement enclosingClass = callee.enclosingClass;
       if (backend.classNeedsRti(enclosingClass)) {
         // If [enclosingClass] needs RTI, we have to give a value to its
         // type parameters.
-        ClassElement currentClass = caller.getEnclosingClass();
+        ClassElement currentClass = caller.enclosingClass;
         // For a super constructor call, the type is the supertype of
         // [currentClass]. For a redirecting constructor, the type is
         // the current type. [InterfaceType.asInstanceOf] takes care
         // of both.
         InterfaceType type = currentClass.thisType.asInstanceOf(enclosingClass);
         Link<DartType> typeVariables = enclosingClass.typeVariables;
         type.typeArguments.forEach((DartType argument) {
           localsHandler.updateLocal(
               typeVariables.head.element,
               analyzeTypeArgument(argument));
           typeVariables = typeVariables.tail;
         });
         // If the supertype is a raw type, we need to set to null the
         // type variables.
         assert(typeVariables.isEmpty
                || enclosingClass.typeVariables == typeVariables);
         while (!typeVariables.isEmpty) {
           localsHandler.updateLocal(typeVariables.head.element,
               graph.addConstantNull(compiler));
           typeVariables = typeVariables.tail;
         }
       }
 
       // For redirecting constructors, the fields have already been
       // initialized by the caller.
-      if (callee.getEnclosingClass() != caller.getEnclosingClass()) {
+      if (callee.enclosingClass != caller.enclosingClass) {
         inlinedFrom(callee, () {
           buildFieldInitializers(callee.enclosingElement.implementation,
                                fieldValues);
         });
       }
 
       int index = 0;
       FunctionSignature params = callee.functionSignature;
       params.orderedForEachParameter((Element parameter) {
         HInstruction argument = compiledArguments[index++];
@@ skipping 99 matching lines @@
             visit(arguments.head);
           });
           fieldValues[elements[init]] = pop();
         }
       }
     }
 
     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.isObject(compiler)) {
         assert(superClass != null);
         assert(superClass.resolutionState == STATE_DONE);
         Selector selector =
-            new Selector.callDefaultConstructor(enclosingClass.getLibrary());
+            new Selector.callDefaultConstructor(enclosingClass.library);
         // TODO(johnniwinther): Should we find injected constructors as well?
         FunctionElement target = superClass.lookupConstructor(selector);
         if (target == null) {
           compiler.internalError(superClass,
               "No default constructor available.");
         }
         List<HInstruction> arguments = <HInstruction>[];
         selector.addArgumentsToList(const Link<ast.Node>(),
                                     arguments,
                                     target.implementation,
@@ skipping 51 matching lines @@
    * [functionElement]:
    *  - Initialize fields with the values of the field initializers of the
    *    current constructor and super constructors or constructors redirected
    *    to, starting from the current constructor.
    *  - Call the constructor bodies, starting from the constructor(s) in the
    *    super class(es).
    */
   HGraph buildFactory(FunctionElement functionElement) {
     functionElement = functionElement.implementation;
     ClassElement classElement =
-        functionElement.getEnclosingClass().implementation;
+        functionElement.enclosingClass.implementation;
     bool isNativeUpgradeFactory =
         Elements.isNativeOrExtendsNative(classElement);
     ast.FunctionExpression function = functionElement.parseNode(compiler);
     // Note that constructors (like any other static function) do not need
     // to deal with optional arguments. It is the callers job to provide all
     // arguments as if they were positional.
 
     if (inliningStack.isEmpty) {
       // The initializer list could contain closures.
       openFunction(functionElement, function);
@@ skipping 108 matching lines @@
         HConstant index = invoke.inputs[1];
         HInstruction newSource = invoke.inputs[0];
         if (newSource is! HThis) {
           return false;
         }
         if (source == null) {
           // This is the first match. Extract the context class for the type
           // variables and get the list of type variables to keep track of how
           // many arguments we need to process.
           source = newSource;
-          contextClass = source.sourceElement.getEnclosingClass();
+          contextClass = source.sourceElement.enclosingClass;
           typeVariables = contextClass.typeVariables;
         } else {
           assert(source == newSource);
         }
         // If there are no more type variables, then there are more type
         // arguments for the new object than the source has, and it can't be
         // a copy.  Otherwise remove one argument.
         if (typeVariables.isEmpty) return false;
         typeVariables = typeVariables.tail;
         // Check that the index is the one we expect.
@@ skipping 44 matching lines @@
       FunctionSignature functionSignature = body.functionSignature;
       // Provide the parameters to the generative constructor body.
       functionSignature.orderedForEachParameter((parameter) {
         // If [parameter] is boxed, it will be a field in the box passed as the
         // last parameter. So no need to directly pass it.
         if (!localsHandler.isBoxed(parameter)) {
           bodyCallInputs.add(localsHandler.readLocal(parameter));
         }
       });
 
-      ClassElement currentClass = constructor.getEnclosingClass();
+      ClassElement currentClass = constructor.enclosingClass;
       if (backend.classNeedsRti(currentClass)) {
         // If [currentClass] needs RTI, we add the type variables as
         // parameters of the generative constructor body.
         currentClass.typeVariables.forEach((DartType argument) {
           bodyCallInputs.add(localsHandler.readLocal(argument.element));
         });
       }
 
       // If there are locals that escape (ie mutated in closures), we
       // pass the box to the constructor.
@@ skipping 34 matching lines @@
 
     localsHandler.startFunction(element, node);
     close(new HGoto()).addSuccessor(block);
 
     open(block);
 
     // Add the type parameters of the class as parameters of this method.  This
     // must be done before adding the normal parameters, because their types
     // may contain references to type variables.
     var enclosing = element.enclosingElement;
-    if ((element.isConstructor() || element.isGenerativeConstructorBody())
+    if ((element.isConstructor || element.isGenerativeConstructorBody)
         && backend.classNeedsRti(enclosing)) {
       enclosing.typeVariables.forEach((TypeVariableType typeVariable) {
         HParameterValue param = addParameter(
             typeVariable.element, backend.nonNullType);
         localsHandler.directLocals[typeVariable.element] = param;
       });
     }
 
     if (element is FunctionElement) {
       FunctionElement functionElement = element;
       FunctionSignature signature = functionElement.functionSignature;
 
       // Put the type checks in the first successor of the entry,
       // because that is where the type guards will also be inserted.
       // This way we ensure that a type guard will dominate the type
       // check.
       signature.orderedForEachParameter((ParameterElement parameterElement) {
-        if (element.isGenerativeConstructorBody()) {
+        if (element.isGenerativeConstructorBody) {
           ClosureScope scopeData =
               localsHandler.closureData.capturingScopes[node];
           if (scopeData != null
               && scopeData.capturedVariableMapping.containsKey(
                   parameterElement)) {
             // The parameter will be a field in the box passed as the
             // last parameter. So no need to have it.
             return;
           }
         }
@@ skipping 644 matching lines @@
     // TODO(ahe): This should be registered in codegen, not here.
     compiler.enqueuer.codegen.addToWorkList(callElement);
     // TODO(ahe): This should be registered in codegen, not here.
     compiler.enqueuer.codegen.registerInstantiatedClass(
         closureClassElement, work.resolutionTree);
 
     List<HInstruction> capturedVariables = <HInstruction>[];
     closureClassElement.forEachMember((_, Element member) {
       // The backendMembers also contains the call method(s). We are only
       // interested in the fields.
-      if (member.isField()) {
+      if (member.isField) {
         Element capturedLocal = nestedClosureData.capturedFieldMapping[member];
         assert(capturedLocal != null);
         capturedVariables.add(localsHandler.readLocal(capturedLocal));
       }
     });
 
     TypeMask type = new TypeMask.nonNullExact(compiler.functionClass);
     push(new HForeignNew(closureClassElement, type, capturedVariables));
 
     Element methodElement = nestedClosureData.closureElement;
@@ skipping 108 matching lines @@
   }
 
   /**
    * Returns a set of interceptor classes that contain the given
    * [selector].
    */
   void generateInstanceGetterWithCompiledReceiver(ast.Send send,
                                                   Selector selector,
                                                   HInstruction receiver) {
     assert(Elements.isInstanceSend(send, elements));
-    assert(selector.isGetter());
+    assert(selector.isGetter);
     pushInvokeDynamic(send, selector, [receiver]);
   }
 
   /// Inserts a call to checkDeferredIsLoaded if the send has a prefix that
   /// resolves to a deferred library.
   void generateIsDeferredLoadedCheckIfNeeded(ast.Send node) {
     DeferredLoadTask deferredTask = compiler.deferredLoadTask;
     PrefixElement prefixElement =
          deferredTask.deferredPrefixElement(node, elements);
     if (prefixElement != null) {
       String loadId =
           deferredTask.importDeferName[prefixElement.deferredImport];
       HInstruction loadIdConstant = addConstantString(loadId);
       String uri = prefixElement.deferredImport.uri.dartString.slowToString();
       HInstruction uriConstant = addConstantString(uri);
       Element helper = backend.getCheckDeferredIsLoaded();
       pushInvokeStatic(node, helper, [loadIdConstant, uriConstant]);
       pop();
     }
   }
 
   void generateGetter(ast.Send send, Element element) {
     if (element != null && element.isForeign(compiler)) {
       visitForeignGetter(send);
     } else if (Elements.isStaticOrTopLevelField(element)) {
       Constant value;
-      if (element.isField() && !element.isAssignable()) {
+      if (element.isField && !element.isAssignable) {
         // A static final or const. Get its constant value and inline it if
         // the value can be compiled eagerly.
         value = backend.constants.getConstantForVariable(element);
       }
       if (value != null) {
         HConstant instruction = graph.addConstant(value, compiler);
         stack.add(instruction);
         // The inferrer may have found a better type than the constant
         // handler in the case of lists, because the constant handler
         // does not look at elements in the list.
         TypeMask type =
             TypeMaskFactory.inferredTypeForElement(element, compiler);
         if (!type.containsAll(compiler) && !instruction.isConstantNull()) {
           // TODO(13429): The inferrer should know that an element
           // cannot be null.
           instruction.instructionType = type.nonNullable();
         }
-      } else if (element.isField() && isLazilyInitialized(element)) {
+      } else if (element.isField && isLazilyInitialized(element)) {
         HInstruction instruction = new HLazyStatic(
             element,
             TypeMaskFactory.inferredTypeForElement(element, compiler));
         push(instruction);
       } else {
-        if (element.isGetter()) {
+        if (element.isGetter) {
           pushInvokeStatic(send, element, <HInstruction>[]);
         } else {
           // TODO(5346): Try to avoid the need for calling [declaration] before
           // creating an [HStatic].
           HInstruction instruction = new HStatic(
               element.declaration,
               TypeMaskFactory.inferredTypeForElement(element, compiler));
           push(instruction);
         }
       }
@@ skipping 25 matching lines @@
                                                    ast.Node location}) {
     assert(send == null || Elements.isInstanceSend(send, elements));
     if (selector == null) {
       assert(send != null);
       selector = elements.getSelector(send);
     }
     if (location == null) {
       assert(send != null);
       location = send;
     }
-    assert(selector.isSetter());
+    assert(selector.isSetter);
     pushInvokeDynamic(location, selector, [receiver, value]);
     pop();
     stack.add(value);
   }
 
   void generateNonInstanceSetter(ast.SendSet send,
                                  Element element,
                                  HInstruction value,
                                  {ast.Node location}) {
     assert(send == null || !Elements.isInstanceSend(send, elements));
     if (location == null) {
       assert(send != null);
       location = send;
     }
     if (Elements.isStaticOrTopLevelField(element)) {
-      if (element.isSetter()) {
+      if (element.isSetter) {
         pushInvokeStatic(location, element, <HInstruction>[value]);
         pop();
       } else {
         VariableElement field = element;
         value =
             potentiallyCheckType(value, field.type);
         addWithPosition(new HStaticStore(element, value), location);
       }
       stack.add(value);
     } else if (Elements.isErroneousElement(element)) {
@@ skipping 35 matching lines @@
   }
 
   // TODO(karlklose): change construction of the representations to be GVN'able
   // (dartbug.com/7182).
   HInstruction buildTypeArgumentRepresentations(DartType type) {
     // Compute the representation of the type arguments, including access
     // to the runtime type information for type variables as instructions.
     if (type.kind == TypeKind.TYPE_VARIABLE) {
       return buildLiteralList(<HInstruction>[addTypeVariableReference(type)]);
     } else {
-      assert(type.element.isClass());
+      assert(type.element.isClass);
       InterfaceType interface = type;
       List<HInstruction> inputs = <HInstruction>[];
       bool first = true;
       List<String> templates = <String>[];
       for (DartType argument in interface.typeArguments) {
         templates.add(rti.getTypeRepresentationWithHashes(argument, (variable) {
           HInstruction runtimeType = addTypeVariableReference(variable);
           inputs.add(runtimeType);
         }));
       }
@@ skipping 177 matching lines @@
 
   visitDynamicSend(ast.Send node) {
     Selector selector = elements.getSelector(node);
 
     List<HInstruction> inputs = <HInstruction>[];
     HInstruction receiver = generateInstanceSendReceiver(node);
     inputs.add(receiver);
     addDynamicSendArgumentsToList(node, inputs);
 
     pushInvokeDynamic(node, selector, inputs);
-    if (selector.isSetter() || selector.isIndexSet()) {
+    if (selector.isSetter || selector.isIndexSet) {
       pop();
       stack.add(inputs.last);
     }
   }
 
   visitClosureSend(ast.Send node) {
     Selector selector = elements.getSelector(node);
     assert(node.receiver == null);
     Element element = elements[node];
     HInstruction closureTarget;
@@ skipping 345 matching lines @@
     } else if (name == 'JS_STRING_CONCAT') {
       handleJsStringConcat(node);
     } else {
       throw "Unknown foreign: ${selector}";
     }
   }
 
   visitForeignGetter(ast.Send node) {
     Element element = elements[node];
     // Until now we only handle these as getters.
-    invariant(node, element.isDeferredLoaderGetter());
+    invariant(node, element.isDeferredLoaderGetter);
     FunctionElement deferredLoader = element;
     Element loadFunction = compiler.loadLibraryFunction;
     PrefixElement prefixElement = deferredLoader.enclosingElement;
     String loadId = compiler.deferredLoadTask
         .importDeferName[prefixElement.deferredImport];
     var inputs = [graph.addConstantString(
         new ast.DartString.literal(loadId), compiler)];
     push(new HInvokeStatic(loadFunction, inputs, backend.nonNullType,
                            targetCanThrow: false));
   }
 
   generateSuperNoSuchMethodSend(ast.Send node,
                                 Selector selector,
                                 List<HInstruction> arguments) {
     String name = selector.name;
 
     ClassElement cls = currentNonClosureClass;
     Element element = cls.lookupSuperMember(Compiler.NO_SUCH_METHOD);
     if (compiler.enabledInvokeOn
         && element.enclosingElement.declaration != compiler.objectClass) {
       // Register the call as dynamic if [noSuchMethod] on the super
       // class is _not_ the default implementation from [Object], in
       // case the [noSuchMethod] implementation calls
       // [JSInvocationMirror._invokeOn].
       compiler.enqueuer.codegen.registerSelectorUse(selector.asUntyped);
     }
     String publicName = name;
-    if (selector.isSetter()) publicName += '=';
+    if (selector.isSetter) publicName += '=';
 
     Constant nameConstant = constantSystem.createString(
         new ast.DartString.literal(publicName));
 
     String internalName = backend.namer.invocationName(selector);
     Constant internalNameConstant =
         constantSystem.createString(new ast.DartString.literal(internalName));
 
     Element createInvocationMirror = backend.getCreateInvocationMirror();
     var argumentsInstruction = buildLiteralList(arguments);
@@ skipping 30 matching lines @@
     if (Elements.isUnresolved(element)) {
       List<HInstruction> arguments = <HInstruction>[];
       if (!node.isPropertyAccess) {
         addGenericSendArgumentsToList(node.arguments, arguments);
       }
       return generateSuperNoSuchMethodSend(node, selector, arguments);
     }
     List<HInstruction> inputs = <HInstruction>[];
     if (node.isPropertyAccess) {
       push(buildInvokeSuper(selector, element, inputs));
-    } else if (element.isFunction() || element.isGenerativeConstructor()) {
+    } else if (element.isFunction || element.isGenerativeConstructor) {
       if (selector.applies(element, compiler)) {
         // TODO(5347): Try to avoid the need for calling [implementation] before
         // calling [addStaticSendArgumentsToList].
         FunctionElement function = element.implementation;
         bool succeeded = addStaticSendArgumentsToList(selector, node.arguments,
                                                       function, inputs);
         assert(succeeded);
         push(buildInvokeSuper(selector, element, inputs));
-      } else if (element.isGenerativeConstructor()) {
+      } else if (element.isGenerativeConstructor) {
         generateWrongArgumentCountError(node, element, node.arguments);
       } else {
         addGenericSendArgumentsToList(node.arguments, inputs);
         generateSuperNoSuchMethodSend(node, selector, inputs);
       }
     } else {
       HInstruction target = buildInvokeSuper(selector, element, inputs);
       add(target);
       inputs = <HInstruction>[target];
       addDynamicSendArgumentsToList(node, inputs);
@@ skipping 12 matching lines @@
   }
 
   /**
    * Generate code to extract the type arguments from the object, substitute
    * them as an instance of the type we are testing against (if necessary), and
    * extract the type argument by the index of the variable in the list of type
    * variables for that class.
    */
   HInstruction readTypeVariable(ClassElement cls,
                                 TypeVariableElement variable) {
-    assert(sourceElement.isInstanceMember());
+    assert(sourceElement.isInstanceMember);
 
     HInstruction target = localsHandler.readThis();
     HConstant index = graph.addConstantInt(
         RuntimeTypes.getTypeVariableIndex(variable),
         compiler);
 
     if (needsSubstitutionForTypeVariableAccess(cls)) {
       // TODO(ahe): Creating a string here is unfortunate. It is slow (due to
       // string concatenation in the implementation), and may prevent
       // segmentation of '$'.
@@ skipping 18 matching lines @@
   bool hasDirectLocal(Element element) {
     return !localsHandler.isAccessedDirectly(element) ||
         localsHandler.directLocals[element] != null;
   }
 
   /**
    * Helper to create an instruction that gets the value of a type variable.
    */
   HInstruction addTypeVariableReference(TypeVariableType type) {
     Element member = sourceElement;
-    bool isClosure = member.enclosingElement.isClosure();
+    bool isClosure = member.enclosingElement.isClosure;
     if (isClosure) {
       ClosureClassElement closureClass = member.enclosingElement;
       member = closureClass.methodElement;
-      member = member.getOutermostEnclosingMemberOrTopLevel();
+      member = member.outermostEnclosingMemberOrTopLevel;
     }
-    bool isInConstructorContext = member.isConstructor() ||
-        member.isGenerativeConstructorBody();
+    bool isInConstructorContext = member.isConstructor ||
+        member.isGenerativeConstructorBody;
     if (isClosure) {
-      if (member.isFactoryConstructor() ||
+      if (member.isFactoryConstructor ||
           (isInConstructorContext && hasDirectLocal(type.element))) {
         // The type variable is used from a closure in a factory constructor.
         // The value of the type argument is stored as a local on the closure
         // itself.
         return localsHandler.readLocal(type.element);
-      } else if (member.isFunction() ||
-          member.isGetter() ||
-          member.isSetter() ||
+      } else if (member.isFunction ||
+          member.isGetter ||
+          member.isSetter ||
           isInConstructorContext) {
         // The type variable is stored on the "enclosing object" and needs to be
         // accessed using the this-reference in the closure.
-        return readTypeVariable(member.getEnclosingClass(), type.element);
+        return readTypeVariable(member.enclosingClass, type.element);
       } else {
-        assert(member.isField());
+        assert(member.isField);
         // The type variable is stored in a parameter of the method.
         return localsHandler.readLocal(type.element);
       }
     } else if (isInConstructorContext ||
                // When [member] is a field, we can be either
                // generating a checked setter or inlining its
                // initializer in a constructor. An initializer is
                // never built standalone, so [isBuildingFor] will
                // always return true when seeing one.
-               (member.isField() && !isBuildingFor(member))) {
+               (member.isField && !isBuildingFor(member))) {
       // The type variable is stored in a parameter of the method.
       return localsHandler.readLocal(type.element);
-    } else if (member.isInstanceMember()) {
+    } else if (member.isInstanceMember) {
       // The type variable is stored on the object.
-      return readTypeVariable(member.getEnclosingClass(),
+      return readTypeVariable(member.enclosingClass,
                               type.element);
     } else {
       // TODO(ngeoffray): Match the VM behavior and throw an
       // exception at runtime.
       compiler.internalError(type.element,
           'Unimplemented unresolved type variable.');
       return null;
     }
   }
 
@@ skipping 91 matching lines @@
         TypeMask inferred =
             TypeMaskFactory.inferredForNode(sourceElement, send, compiler);
         return inferred.containsAll(compiler)
             ? backend.extendableArrayType
             : inferred;
       } else if (Elements.isConstructorOfTypedArraySubclass(
                     originalElement, compiler)) {
         isFixedList = true;
         TypeMask inferred =
             TypeMaskFactory.inferredForNode(sourceElement, send, compiler);
-        ClassElement cls = element.getEnclosingClass();
-        assert(cls.thisType.element.isNative());
+        ClassElement cls = element.enclosingClass;
+        assert(cls.thisType.element.isNative);
         return inferred.containsAll(compiler)
             ? new TypeMask.nonNullExact(cls.thisType.element)
             : inferred;
-      } else if (element.isGenerativeConstructor()) {
-        ClassElement cls = element.getEnclosingClass();
+      } else if (element.isGenerativeConstructor) {
+        ClassElement cls = element.enclosingClass;
         return new TypeMask.nonNullExact(cls.thisType.element);
       } else {
         return TypeMaskFactory.inferredReturnTypeForElement(
             originalElement, compiler);
       }
     }
 
     Element constructor = elements[send];
     Selector selector = elements.getSelector(send);
     FunctionElement functionElement = constructor;
@@ skipping 13 matching lines @@
                        message: 'Constructor Symbol.validated is missing'));
     }
 
     bool isRedirected = functionElement.isRedirectingFactory;
     InterfaceType type = elements.getType(node);
     InterfaceType expectedType = functionElement.computeTargetType(type);
 
     if (checkTypeVariableBounds(node, type)) return;
 
     var inputs = <HInstruction>[];
-    if (constructor.isGenerativeConstructor() &&
-        Elements.isNativeOrExtendsNative(constructor.getEnclosingClass())) {
+    if (constructor.isGenerativeConstructor &&
+        Elements.isNativeOrExtendsNative(constructor.enclosingClass)) {
       // Native class generative constructors take a pre-constructed object.
       inputs.add(graph.addConstantNull(compiler));
     }
     // TODO(5347): Try to avoid the need for calling [implementation] before
     // calling [addStaticSendArgumentsToList].
     bool succeeded = addStaticSendArgumentsToList(selector, send.arguments,
                                                   constructor.implementation,
                                                   inputs);
     if (!succeeded) {
       generateWrongArgumentCountError(send, constructor, send.arguments);
       return;
     }
 
-    if (constructor.isFactoryConstructor() &&
+    if (constructor.isFactoryConstructor &&
         !expectedType.typeArguments.isEmpty) {
       compiler.enqueuer.codegen.registerFactoryWithTypeArguments(elements);
     }
 
     TypeMask elementType = computeType(constructor);
     if (isFixedListConstructorCall) {
       if (!inputs[0].isNumber(compiler)) {
         HTypeConversion conversion = new HTypeConversion(
           null, HTypeConversion.ARGUMENT_TYPE_CHECK, backend.numType,
           inputs[0], null);
@@ skipping 19 matching lines @@
         js.Template code = js.js.parseForeignJS(r'#.fixed$length = init');
         // We set the instruction as [canThrow] to avoid it being dead code.
         // We need a finer grained side effect.
         add(new HForeign(
               code, backend.nullType, [stack.last], canThrow: true));
       }
     } else if (isGrowableListConstructorCall) {
       push(buildLiteralList(<HInstruction>[]));
       stack.last.instructionType = elementType;
     } else {
-      ClassElement cls = constructor.getEnclosingClass();
-      if (cls.isAbstract && constructor.isGenerativeConstructor()) {
+      ClassElement cls = constructor.enclosingClass;
+      if (cls.isAbstract && constructor.isGenerativeConstructor) {
         generateAbstractClassInstantiationError(send, cls.name);
         return;
       }
       if (backend.classNeedsRti(cls)) {
         Link<DartType> typeVariable = cls.typeVariables;
         expectedType.typeArguments.forEach((DartType argument) {
           inputs.add(analyzeTypeArgument(argument));
           typeVariable = typeVariable.tail;
         });
         assert(typeVariable.isEmpty);
@@ skipping 93 matching lines @@
     if (!compiler.enableUserAssertions) {
       stack.add(graph.addConstantNull(compiler));
       return;
     }
     visitStaticSend(node);
   }
 
   visitStaticSend(ast.Send node) {
     Selector selector = elements.getSelector(node);
     Element element = elements[node];
-    if (element.isForeign(compiler) && element.isFunction()) {
+    if (element.isForeign(compiler) && element.isFunction) {
       visitForeignSend(node);
       return;
     }
-    if (element.isErroneous()) {
+    if (element.isErroneous) {
       // An erroneous element indicates that the funciton could not be resolved
       // (a warning has been issued).
       generateThrowNoSuchMethod(node,
                                 getTargetName(element),
                                 argumentNodes: node.arguments);
       return;
     }
-    invariant(element, !element.isGenerativeConstructor());
+    invariant(element, !element.isGenerativeConstructor);
     generateIsDeferredLoadedCheckIfNeeded(node);
-    if (element.isFunction()) {
+    if (element.isFunction) {
       var inputs = <HInstruction>[];
       // TODO(5347): Try to avoid the need for calling [implementation] before
       // calling [addStaticSendArgumentsToList].
       bool succeeded = addStaticSendArgumentsToList(selector, node.arguments,
                                                     element.implementation,
                                                     inputs);
       if (!succeeded) {
         generateWrongArgumentCountError(node, element, node.arguments);
         return;
       }
@@ skipping 17 matching lines @@
   }
 
   HConstant addConstantString(String string) {
     ast.DartString dartString = new ast.DartString.literal(string);
     Constant constant = constantSystem.createString(dartString);
     return graph.addConstant(constant, compiler);
   }
 
   visitTypeReferenceSend(ast.Send node) {
     Element element = elements[node];
-    if (element.isClass() || element.isTypedef()) {
+    if (element.isClass || element.isTypedef) {
       // TODO(karlklose): add type representation
       if (node.isCall) {
         // The node itself is not a constant but we register the selector (the
         // identifier that refers to the class/typedef) as a constant.
         stack.add(addConstant(node.selector));
       } else {
         stack.add(addConstant(node));
       }
-    } else if (element.isTypeVariable()) {
+    } else if (element.isTypeVariable) {
       TypeVariableElement typeVariable = element;
       HInstruction value = addTypeVariableReference(typeVariable.type);
       pushInvokeStatic(node,
                        backend.getRuntimeTypeToString(),
                        [value],
                        backend.stringType);
       pushInvokeStatic(node,
                        backend.getCreateRuntimeType(),
                        [pop()]);
     } else {
@@ skipping 111 matching lines @@
     if (Elements.isErroneousElement(element)) {
       ErroneousElement error = element;
       if (error.messageKind == MessageKind.CANNOT_FIND_CONSTRUCTOR) {
         generateThrowNoSuchMethod(node.send,
                                   getTargetName(error, 'constructor'),
                                   argumentNodes: node.send.arguments);
       } else {
         Message message = error.messageKind.message(error.messageArguments);
         generateRuntimeError(node.send, message.toString());
       }
-    } else if (node.isConst()) {
+    } else if (node.isConst) {
       stack.add(addConstant(node));
       if (isSymbolConstructor) {
         ConstructedConstant symbol = getConstantForNode(node);
         StringConstant stringConstant = symbol.fields.single;
         String nameString = stringConstant.toDartString().slowToString();
         compiler.enqueuer.codegen.registerConstSymbol(nameString, elements);
       }
     } else {
       handleNewSend(node);
     }
   }
 
   void pushInvokeDynamic(ast.Node node,
                          Selector selector,
                          List<HInstruction> arguments,
                          {ast.Node location}) {
     if (location == null) location = node;
 
     // We prefer to not inline certain operations on indexables,
     // because the constant folder will handle them better and turn
     // them into simpler instructions that allow further
     // optimizations.
     bool isOptimizableOperationOnIndexable(Selector selector, Element element) {
-      bool isLength = selector.isGetter()
+      bool isLength = selector.isGetter
           && selector.name == "length";
-      if (isLength || selector.isIndex()) {
+      if (isLength || selector.isIndex) {
         TypeMask type = new TypeMask.nonNullExact(
-            element.getEnclosingClass().declaration);
+            element.enclosingClass.declaration);
         return type.satisfies(backend.jsIndexableClass, compiler);
-      } else if (selector.isIndexSet()) {
+      } else if (selector.isIndexSet) {
         TypeMask type = new TypeMask.nonNullExact(
-            element.getEnclosingClass().declaration);
+            element.enclosingClass.declaration);
         return type.satisfies(backend.jsMutableIndexableClass, compiler);
       } else {
         return false;
       }
     }
 
     bool isOptimizableOperation(Selector selector, Element element) {
-      ClassElement cls = element.getEnclosingClass();
+      ClassElement cls = element.enclosingClass;
       if (isOptimizableOperationOnIndexable(selector, element)) return true;
       if (!backend.interceptedClasses.contains(cls)) return false;
-      if (selector.isOperator()) return true;
-      if (selector.isSetter()) return true;
-      if (selector.isIndex()) return true;
-      if (selector.isIndexSet()) return true;
+      if (selector.isOperator) return true;
+      if (selector.isSetter) return true;
+      if (selector.isIndex) return true;
+      if (selector.isIndexSet) return true;
       if (element == backend.jsArrayAdd
           || element == backend.jsArrayRemoveLast
           || element == backend.jsStringSplit) {
         return true;
       }
       return false;
     }
 
     Element element = compiler.world.locateSingleElement(selector);
     if (element != null
-        && !element.isField()
-        && !(element.isGetter() && selector.isCall())
-        && !(element.isFunction() && selector.isGetter())
+        && !element.isField
+        && !(element.isGetter && selector.isCall)
+        && !(element.isFunction && selector.isGetter)
         && !isOptimizableOperation(selector, element)) {
       if (tryInlineMethod(element, selector, arguments, node)) {
         return;
       }
     }
 
     HInstruction receiver = arguments[0];
     List<HInstruction> inputs = <HInstruction>[];
     bool isIntercepted = backend.isInterceptedSelector(selector);
     if (isIntercepted) {
       inputs.add(invokeInterceptor(receiver));
     }
     inputs.addAll(arguments);
     TypeMask type = TypeMaskFactory.inferredTypeForSelector(selector, compiler);
-    if (selector.isGetter()) {
+    if (selector.isGetter) {
       pushWithPosition(
           new HInvokeDynamicGetter(selector, null, inputs, type),
           location);
-    } else if (selector.isSetter()) {
+    } else if (selector.isSetter) {
       pushWithPosition(
           new HInvokeDynamicSetter(selector, null, inputs, type),
           location);
     } else {
       pushWithPosition(
           new HInvokeDynamicMethod(selector, inputs, type, isIntercepted),
           location);
     }
   }
 
@@ skipping 34 matching lines @@
     List<HInstruction> inputs = <HInstruction>[];
     if (backend.isInterceptedSelector(selector) &&
         // Fields don't need an interceptor; consider generating HFieldGet/Set
         // instead.
         element.kind != ElementKind.FIELD) {
       inputs.add(invokeInterceptor(receiver));
     }
     inputs.add(receiver);
     inputs.addAll(arguments);
     TypeMask type;
-    if (!element.isGetter() && selector.isGetter()) {
+    if (!element.isGetter && selector.isGetter) {
       type = TypeMaskFactory.inferredTypeForElement(element, compiler);
     } else {
       type = TypeMaskFactory.inferredReturnTypeForElement(element, compiler);
     }
     HInstruction instruction = new HInvokeSuper(
         element,
         currentNonClosureClass,
         selector,
         inputs,
         type,
-        isSetter: selector.isSetter() || selector.isIndexSet());
+        isSetter: selector.isSetter || selector.isIndexSet);
     instruction.sideEffects = compiler.world.getSideEffectsOfSelector(selector);
     return instruction;
   }
 
   void handleComplexOperatorSend(ast.SendSet node,
                                  HInstruction receiver,
                                  Link<ast.Node> arguments) {
     HInstruction rhs;
     if (node.isPrefix || node.isPostfix) {
       rhs = graph.addConstantInt(1, compiler);
     } else {
       visit(arguments.head);
       assert(arguments.tail.isEmpty);
       rhs = pop();
     }
     visitBinary(receiver, node.assignmentOperator, rhs,
                 elements.getOperatorSelectorInComplexSendSet(node), node);
   }
 
   visitSendSet(ast.SendSet node) {
     generateIsDeferredLoadedCheckIfNeeded(node);
     Element element = elements[node];
-    if (!Elements.isUnresolved(element) && element.impliesType()) {
+    if (!Elements.isUnresolved(element) && element.impliesType) {
       ast.Identifier selector = node.selector;
       generateThrowNoSuchMethod(node, selector.source,
                                 argumentNodes: node.arguments);
       return;
     }
     ast.Operator op = node.assignmentOperator;
     if (node.isSuperCall) {
       HInstruction result;
       List<HInstruction> setterInputs = <HInstruction>[];
       if (identical(node.assignmentOperator.source, '=')) {
@@ skipping 94 matching lines @@
     } else if (identical(op.source, "is")) {
       compiler.internalError(op, "is-operator as SendSet.");
     } else {
       assert("++" == op.source || "--" == op.source ||
              node.assignmentOperator.source.endsWith("="));
 
       // [receiver] is only used if the node is an instance send.
       HInstruction receiver = null;
       Element getter = elements[node.selector];
 
-      if (!Elements.isUnresolved(getter) && getter.impliesType()) {
+      if (!Elements.isUnresolved(getter) && getter.impliesType) {
         ast.Identifier selector = node.selector;
         generateThrowNoSuchMethod(node, selector.source,
                                   argumentNodes: node.arguments);
         return;
       } else if (Elements.isInstanceSend(node, elements)) {
         receiver = generateInstanceSendReceiver(node);
         generateInstanceGetterWithCompiledReceiver(
             node, elements.getGetterSelectorInComplexSendSet(node), receiver);
       } else {
         generateGetter(node, getter);
@@ skipping 98 matching lines @@
     if (exception == null) {
       exception = graph.addConstantNull(compiler);
       compiler.internalError(node,
           'rethrowableException should not be null.');
     }
     handleInTryStatement();
     closeAndGotoExit(new HThrow(exception, isRethrow: true));
   }
 
   visitReturn(ast.Return node) {
-    if (identical(node.getBeginToken().stringValue, 'native')) {
+    if (identical(node.beginToken.stringValue, 'native')) {
       native.handleSsaNative(this, node.expression);
       return;
     }
     HInstruction value;
     if (node.isRedirectingFactoryBody) {
       FunctionElement targetConstructor =
           elements[node.expression].implementation;
       FunctionElement redirectingConstructor = sourceElement;
       List<HInstruction> inputs = <HInstruction>[];
       FunctionSignature targetSignature = targetConstructor.functionSignature;
       FunctionSignature redirectingSignature =
           redirectingConstructor.functionSignature;
       redirectingSignature.forEachRequiredParameter((Element element) {
         inputs.add(localsHandler.readLocal(element));
       });
       List<Element> targetOptionals =
           targetSignature.orderedOptionalParameters;
       List<Element> redirectingOptionals =
           redirectingSignature.orderedOptionalParameters;
       int i = 0;
       for (; i < redirectingOptionals.length; i++) {
         inputs.add(localsHandler.readLocal(redirectingOptionals[i]));
       }
       for (; i < targetOptionals.length; i++) {
         inputs.add(handleConstantForOptionalParameter(targetOptionals[i]));
       }
 
-      ClassElement targetClass = targetConstructor.getEnclosingClass();
+      ClassElement targetClass = targetConstructor.enclosingClass;
       if (backend.classNeedsRti(targetClass)) {
-        ClassElement cls = redirectingConstructor.getEnclosingClass();
+        ClassElement cls = redirectingConstructor.enclosingClass;
         InterfaceType targetType =
             redirectingConstructor.computeTargetType(cls.thisType);
         targetType.typeArguments.forEach((DartType argument) {
           inputs.add(analyzeTypeArgument(argument));
         });
       }
       pushInvokeStatic(node, targetConstructor, inputs);
       value = pop();
     } else if (node.expression == null) {
       value = graph.addConstantNull(compiler);
@@ skipping 48 matching lines @@
       arguments.add(analyzeTypeArgument(argument));
     }
     // TODO(15489): Register at codegen.
     compiler.enqueuer.codegen.registerInstantiatedType(type, elements);
     return callSetRuntimeTypeInfo(type.element, arguments, object);
   }
 
   visitLiteralList(ast.LiteralList node) {
     HInstruction instruction;
 
-    if (node.isConst()) {
+    if (node.isConst) {
       instruction = addConstant(node);
     } else {
       List<HInstruction> inputs = <HInstruction>[];
       for (Link<ast.Node> link = node.elements.nodes;
            !link.isEmpty;
            link = link.tail) {
         visit(link.head);
         inputs.add(pop());
       }
       instruction = buildLiteralList(inputs);
@@ skipping 178 matching lines @@
       // There was at least one reachable break, so the label is needed.
       entryBlock.setBlockFlow(
           new HLabeledBlockInformation(new HSubGraphBlockInformation(bodyGraph),
                                        handler.labels()),
           joinBlock);
     }
     handler.close();
   }
 
   visitLiteralMap(ast.LiteralMap node) {
-    if (node.isConst()) {
+    if (node.isConst) {
       stack.add(addConstant(node));
       return;
     }
     List<HInstruction> listInputs = <HInstruction>[];
     for (Link<ast.Node> link = node.entries.nodes;
          !link.isEmpty;
          link = link.tail) {
       visit(link.head);
       listInputs.add(pop());
       listInputs.add(pop());
     }
 
     Element constructor;
     List<HInstruction> inputs = <HInstruction>[];
 
     if (listInputs.isEmpty) {
       constructor = backend.mapLiteralConstructorEmpty;
     } else {
       constructor = backend.mapLiteralConstructor;
       HLiteralList keyValuePairs = buildLiteralList(listInputs);
       add(keyValuePairs);
       inputs.add(keyValuePairs);
     }
 
-    assert(constructor.isFactoryConstructor());
+    assert(constructor.isFactoryConstructor);
 
     FunctionElement functionElement = constructor;
     constructor = functionElement.redirectionTarget;
 
     InterfaceType type = elements.getType(node);
     InterfaceType expectedType = functionElement.computeTargetType(type);
 
-    if (constructor.isFactoryConstructor()) {
+    if (constructor.isFactoryConstructor) {
       compiler.enqueuer.codegen.registerFactoryWithTypeArguments(elements);
     }
 
-    ClassElement cls = constructor.getEnclosingClass();
+    ClassElement cls = constructor.enclosingClass;
 
     if (backend.classNeedsRti(cls)) {
       Link<DartType> typeVariable = cls.typeVariables;
       expectedType.typeArguments.forEach((DartType argument) {
             inputs.add(analyzeTypeArgument(argument));
             typeVariable = typeVariable.tail;
           });
       assert(typeVariable.isEmpty);
     }
 
@@ skipping 791 matching lines @@
   }
 
   void visitRethrow(ast.Rethrow node) {
     if (!registerNode()) return;
     tooDifficult = true;
   }
 
   void visitReturn(ast.Return node) {
     if (!registerNode()) return;
     if (seenReturn
-        || identical(node.getBeginToken().stringValue, 'native')
+        || identical(node.beginToken.stringValue, 'native')
         || node.isRedirectingFactoryBody) {
       tooDifficult = true;
       return;
     }
     node.visitChildren(this);
     seenReturn = true;
   }
 
   void visitTryStatement(ast.Node node) {
     if (!registerNode()) return;
@@ skipping 282 matching lines @@
 
   void visitVoidType(VoidType type, SsaBuilder builder) {
     ClassElement cls = builder.compiler.findHelper('VoidRuntimeType');
     builder.push(new HVoidType(type, new TypeMask.exact(cls)));
   }
 
   void visitTypeVariableType(TypeVariableType type,
                              SsaBuilder builder) {
     ClassElement cls = builder.compiler.findHelper('RuntimeType');
     TypeMask instructionType = new TypeMask.subclass(cls);
-    if (!builder.sourceElement.enclosingElement.isClosure() &&
-        builder.sourceElement.isInstanceMember()) {
+    if (!builder.sourceElement.enclosingElement.isClosure &&
+        builder.sourceElement.isInstanceMember) {
       HInstruction receiver = builder.localsHandler.readThis();
       builder.push(new HReadTypeVariable(type, receiver, instructionType));
     } else {
       builder.push(
           new HReadTypeVariable.noReceiver(
               type, builder.addTypeVariableReference(type), instructionType));
     }
   }
 
   void visitFunctionType(FunctionType type, SsaBuilder builder) {
@@ skipping 56 matching lines @@
     DartType unaliased = type.unalias(builder.compiler);
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     ClassElement cls = builder.compiler.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls)));
   }
 }