Convert isX() methods to isX getter.

pkg/analyzer_experimental/lib/src/generated/resolver.dart

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 library engine.resolver;
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'instrumentation.dart';
 import 'source.dart';
 import 'error.dart';
 import 'scanner.dart' as sc;
@@ skipping 214 matching lines @@
     initializer.labels = holder.labels;
     initializer.localVariables = holder.localVariables;
     initializer.parameters = holder.parameters;
     SimpleIdentifier parameterName = node.parameter.identifier;
     ParameterElementImpl parameter;
     if (node.parameter is FieldFormalParameter) {
       parameter = new DefaultFieldFormalParameterElementImpl(parameterName);
     } else {
       parameter = new DefaultParameterElementImpl(parameterName);
     }
-    parameter.const3 = node.isConst();
-    parameter.final2 = node.isFinal();
+    parameter.const3 = node.isConst;
+    parameter.final2 = node.isFinal;
     parameter.initializer = initializer;
     parameter.parameterKind = node.kind;
     Expression defaultValue = node.defaultValue;
     if (defaultValue != null) {
       parameter.setDefaultValueRange(defaultValue.offset, defaultValue.length);
     }
     FunctionBody body = getFunctionBody(node);
     if (body != null) {
       parameter.setVisibleRange(body.offset, body.length);
     }
@@ skipping 10 matching lines @@
       node.visitChildren(this);
     } finally {
       _inFieldContext = wasInField;
     }
     return null;
   }
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       FieldFormalParameterElementImpl parameter = new FieldFormalParameterElementImpl(parameterName);
-      parameter.const3 = node.isConst();
-      parameter.final2 = node.isFinal();
+      parameter.const3 = node.isConst;
+      parameter.final2 = node.isFinal;
       parameter.parameterKind = node.kind;
       _currentHolder.addParameter(parameter);
       parameterName.element = parameter;
     }
     return super.visitFieldFormalParameter(node);
   }
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     FunctionExpression expression = node.functionExpression;
     if (expression != null) {
       ElementHolder holder = new ElementHolder();
@@ skipping 133 matching lines @@
   }
   Object visitMethodDeclaration(MethodDeclaration node) {
     ElementHolder holder = new ElementHolder();
     bool wasInFunction = _inFunction;
     _inFunction = true;
     try {
       visitChildren(holder, node);
     } finally {
       _inFunction = wasInFunction;
     }
-    bool isStatic = node.isStatic();
+    bool isStatic = node.isStatic;
     sc.Token property = node.propertyKeyword;
     if (property == null) {
       SimpleIdentifier methodName = node.name;
       String nameOfMethod = methodName.name;
       if (nameOfMethod == sc.TokenType.MINUS.lexeme && node.parameters.parameters.length == 0) {
         nameOfMethod = "unary-";
       }
       MethodElementImpl element = new MethodElementImpl.con2(nameOfMethod, methodName.offset);
-      element.abstract = node.isAbstract();
+      element.abstract = node.isAbstract;
       element.functions = holder.functions;
       element.labels = holder.labels;
       element.localVariables = holder.localVariables;
       element.parameters = holder.parameters;
       element.static = isStatic;
       _currentHolder.addMethod(element);
       methodName.element = element;
     } else {
       SimpleIdentifier propertyNameNode = node.name;
       String propertyName = propertyNameNode.name;
@@ skipping 32 matching lines @@
         propertyNameNode.element = setter;
       }
     }
     holder.validate();
     return null;
   }
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       ParameterElementImpl parameter = new ParameterElementImpl(parameterName);
-      parameter.const3 = node.isConst();
-      parameter.final2 = node.isFinal();
+      parameter.const3 = node.isConst;
+      parameter.final2 = node.isFinal;
       parameter.parameterKind = node.kind;
       _currentHolder.addParameter(parameter);
       parameterName.element = parameter;
     }
     return super.visitSimpleFormalParameter(node);
   }
   Object visitSuperExpression(SuperExpression node) {
     _isValidMixin = false;
     return super.visitSuperExpression(node);
   }
@@ skipping 87 matching lines @@
       element.initializer = initializer;
       holder.validate();
     }
     if (element is PropertyInducingElementImpl) {
       PropertyInducingElementImpl variable = element as PropertyInducingElementImpl;
       if (_inFieldContext) {
         ((variable as FieldElementImpl)).static = matches(((node.parent.parent as FieldDeclaration)).keyword, sc.Keyword.STATIC);
       }
       PropertyAccessorElementImpl getter = new PropertyAccessorElementImpl.con2(variable);
       getter.getter = true;
-      getter.static = variable.isStatic();
+      getter.static = variable.isStatic;
       _currentHolder.addAccessor(getter);
       variable.getter = getter;
       if (!isFinal) {
         PropertyAccessorElementImpl setter = new PropertyAccessorElementImpl.con2(variable);
         setter.setter = true;
-        setter.static = variable.isStatic();
+        setter.static = variable.isStatic;
         _currentHolder.addAccessor(setter);
         variable.setter = setter;
       }
     }
     return null;
   }
 
   /**
    * Creates the [ConstructorElement]s array with the single default constructor element.
    * @param interfaceType the interface type for which to create a default constructor
@@ skipping 1179 matching lines @@
       }
       if (n is ConstructorDeclaration) {
         ConstructorDeclaration constructor = n as ConstructorDeclaration;
         return constructor.factoryKeyword == null;
       }
       if (n is ConstructorFieldInitializer) {
         return false;
       }
       if (n is MethodDeclaration) {
         MethodDeclaration method = n as MethodDeclaration;
-        return !method.isStatic();
+        return !method.isStatic;
       }
     }
     return false;
   }
 
   /**
    * The resolver driving this participant.
    */
   ResolverVisitor _resolver;
 
@@ skipping 39 matching lines @@
         node.element = select3(staticMethod, propagatedMethod);
         if (shouldReportMissingMember(staticType, staticMethod) && (_strictMode || propagatedType == null || shouldReportMissingMember(propagatedType, propagatedMethod))) {
           _resolver.reportError6(StaticTypeWarningCode.UNDEFINED_METHOD, operator, [methodName, staticType.displayName]);
         }
       }
     }
     return null;
   }
   Object visitBinaryExpression(BinaryExpression node) {
     sc.Token operator = node.operator;
-    if (operator.isUserDefinableOperator()) {
+    if (operator.isUserDefinableOperator) {
       Expression leftOperand = node.leftOperand;
       if (leftOperand != null) {
         String methodName = operator.lexeme;
         Type2 staticType = getStaticType(leftOperand);
         MethodElement staticMethod = lookUpMethod(leftOperand, staticType, methodName);
         node.staticElement = staticMethod;
         Type2 propagatedType = getPropagatedType(leftOperand);
         MethodElement propagatedMethod = lookUpMethod(leftOperand, propagatedType, methodName);
         node.element = select3(staticMethod, propagatedMethod);
         if (shouldReportMissingMember(staticType, staticMethod) && (_strictMode || propagatedType == null || shouldReportMissingMember(propagatedType, propagatedMethod))) {
           _resolver.reportError6(StaticTypeWarningCode.UNDEFINED_OPERATOR, operator, [methodName, staticType.displayName]);
         }
       }
     }
     return null;
   }
   Object visitBreakStatement(BreakStatement node) {
     SimpleIdentifier labelNode = node.label;
     LabelElementImpl labelElement = lookupLabel(node, labelNode);
-    if (labelElement != null && labelElement.isOnSwitchMember()) {
+    if (labelElement != null && labelElement.isOnSwitchMember) {
       _resolver.reportError(ResolverErrorCode.BREAK_LABEL_ON_SWITCH_MEMBER, labelNode, []);
     }
     return null;
   }
   Object visitClassDeclaration(ClassDeclaration node) {
     setMetadata(node.element, node);
     return null;
   }
   Object visitClassTypeAlias(ClassTypeAlias node) {
     setMetadata(node.element, node);
@@ skipping 92 matching lines @@
       }
       setMetadata(constructorElement, node);
     }
     return null;
   }
   Object visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
     SimpleIdentifier fieldName = node.fieldName;
     ClassElement enclosingClass = _resolver.enclosingClass;
     FieldElement fieldElement = ((enclosingClass as ClassElementImpl)).getField(fieldName.name);
     recordResolution(fieldName, fieldElement);
-    if (fieldElement == null || fieldElement.isSynthetic()) {
+    if (fieldElement == null || fieldElement.isSynthetic) {
       _resolver.reportError(CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTANT_FIELD, node, [fieldName]);
-    } else if (fieldElement.isStatic()) {
+    } else if (fieldElement.isStatic) {
       _resolver.reportError(CompileTimeErrorCode.INITIALIZER_FOR_STATIC_FIELD, node, [fieldName]);
     }
     return null;
   }
   Object visitConstructorName(ConstructorName node) {
     Type2 type = node.type.type;
-    if (type != null && type.isDynamic()) {
+    if (type != null && type.isDynamic) {
       return null;
     } else if (type is! InterfaceType) {
       ASTNode parent = node.parent;
       if (parent is InstanceCreationExpression) {
-        if (((parent as InstanceCreationExpression)).isConst()) {
+        if (((parent as InstanceCreationExpression)).isConst) {
         } else {
         }
       } else {
       }
       return null;
     }
     ConstructorElement constructor;
     SimpleIdentifier name = node.name;
     InterfaceType interfaceType = type as InterfaceType;
     LibraryElement definingLibrary = _resolver.definingLibrary;
     if (name == null) {
       constructor = interfaceType.lookUpConstructor(null, definingLibrary);
     } else {
       constructor = interfaceType.lookUpConstructor(name.name, definingLibrary);
       name.staticElement = constructor;
       name.element = constructor;
     }
     node.staticElement = constructor;
     node.element = constructor;
     return null;
   }
   Object visitContinueStatement(ContinueStatement node) {
     SimpleIdentifier labelNode = node.label;
     LabelElementImpl labelElement = lookupLabel(node, labelNode);
-    if (labelElement != null && labelElement.isOnSwitchStatement()) {
+    if (labelElement != null && labelElement.isOnSwitchStatement) {
       _resolver.reportError(ResolverErrorCode.CONTINUE_LABEL_ON_SWITCH, labelNode, []);
     }
     return null;
   }
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     setMetadata(node.element, node);
     return null;
   }
   Object visitExportDirective(ExportDirective node) {
     Element element = node.element;
@@ skipping 13 matching lines @@
       } else {
         ParameterElement parameterElement = node.element;
         if (parameterElement is FieldFormalParameterElementImpl) {
           FieldFormalParameterElementImpl fieldFormal = parameterElement as FieldFormalParameterElementImpl;
           fieldFormal.field = fieldElement;
           Type2 declaredType = fieldFormal.type;
           Type2 fieldType = fieldElement.type;
           if (node.type == null) {
             fieldFormal.type = fieldType;
           }
-          if (fieldElement.isSynthetic()) {
+          if (fieldElement.isSynthetic) {
             _resolver.reportError(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD, node, [fieldName]);
-          } else if (fieldElement.isStatic()) {
+          } else if (fieldElement.isStatic) {
             _resolver.reportError(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_STATIC_FIELD, node, [fieldName]);
           } else if (declaredType != null && fieldType != null && !declaredType.isAssignableTo(fieldType)) {
             _resolver.reportError(StaticWarningCode.FIELD_INITIALIZING_FORMAL_NOT_ASSIGNABLE, node, [declaredType.displayName, fieldType.displayName]);
           }
         } else {
-          if (fieldElement.isSynthetic()) {
+          if (fieldElement.isSynthetic) {
             _resolver.reportError(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD, node, [fieldName]);
-          } else if (fieldElement.isStatic()) {
+          } else if (fieldElement.isStatic) {
             _resolver.reportError(CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_STATIC_FIELD, node, [fieldName]);
           }
         }
       }
     }
     return super.visitFieldFormalParameter(node);
   }
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     setMetadata(node.element, node);
     return null;
@@ skipping 40 matching lines @@
       String methodName = sc.TokenType.INDEX_EQ.lexeme;
       lookUpCheckIndexOperator(node, target, methodName, staticType, propagatedType);
     }
     return null;
   }
   Object visitInstanceCreationExpression(InstanceCreationExpression node) {
     ConstructorElement invokedConstructor = node.constructorName.element;
     node.staticElement = invokedConstructor;
     node.element = invokedConstructor;
     ArgumentList argumentList = node.argumentList;
-    List<ParameterElement> parameters = resolveArgumentsToParameters(node.isConst(), argumentList, invokedConstructor);
+    List<ParameterElement> parameters = resolveArgumentsToParameters(node.isConst, argumentList, invokedConstructor);
     if (parameters != null) {
       argumentList.correspondingStaticParameters = parameters;
     }
     return null;
   }
   Object visitLibraryDirective(LibraryDirective node) {
     setMetadata(node.element, node);
     return null;
   }
   Object visitMethodDeclaration(MethodDeclaration node) {
@@ skipping 115 matching lines @@
       }
       recordResolution(identifier, element);
       return null;
     }
     resolvePropertyAccess(prefix, identifier);
     return null;
   }
   Object visitPrefixExpression(PrefixExpression node) {
     sc.Token operator = node.operator;
     sc.TokenType operatorType = operator.type;
-    if (operatorType.isUserDefinableOperator() || identical(operatorType, sc.TokenType.PLUS_PLUS) || identical(operatorType, sc.TokenType.MINUS_MINUS)) {
+    if (operatorType.isUserDefinableOperator || identical(operatorType, sc.TokenType.PLUS_PLUS) || identical(operatorType, sc.TokenType.MINUS_MINUS)) {
       Expression operand = node.operand;
       String methodName = getPrefixOperator(node);
       Type2 staticType = getStaticType(operand);
       MethodElement staticMethod = lookUpMethod(operand, staticType, methodName);
       node.staticElement = staticMethod;
       Type2 propagatedType = getPropagatedType(operand);
       MethodElement propagatedMethod = lookUpMethod(operand, propagatedType, methodName);
       node.element = select3(staticMethod, propagatedMethod);
       if (shouldReportMissingMember(staticType, staticMethod) && (_strictMode || propagatedType == null || shouldReportMissingMember(propagatedType, propagatedMethod))) {
         _resolver.reportError6(StaticTypeWarningCode.UNDEFINED_OPERATOR, operator, [methodName, staticType.displayName]);
@@ skipping 71 matching lines @@
       element = superclass.getNamedConstructor(name.name);
     }
     if (element == null) {
       if (name != null) {
         _resolver.reportError(CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER, node, [superclass.name, name]);
       } else {
         _resolver.reportError(CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT, node, [superclass.name]);
       }
       return null;
     } else {
-      if (element.isFactory()) {
+      if (element.isFactory) {
         _resolver.reportError(CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR, node, [element]);
       }
     }
     if (name != null) {
       recordResolution(name, element);
     }
     node.staticElement = element;
     node.element = element;
     ArgumentList argumentList = node.argumentList;
     List<ParameterElement> parameters = resolveArgumentsToParameters(false, argumentList, element);
@@ skipping 86 matching lines @@
             if (!classDeclaresNoSuchMethod(enclosingClass)) {
               return StaticTypeWarningCode.UNDEFINED_METHOD;
             }
           } else {
             return StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION;
           }
         } else {
           Type2 targetType = getStaticType(target);
           if (targetType == null) {
             return StaticTypeWarningCode.UNDEFINED_FUNCTION;
-          } else if (!targetType.isDynamic() && !classDeclaresNoSuchMethod2(targetType.element)) {
+          } else if (!targetType.isDynamic && !classDeclaresNoSuchMethod2(targetType.element)) {
             return StaticTypeWarningCode.UNDEFINED_METHOD;
           }
         }
       }
     }
     return null;
   }
 
   /**
    * Return `true` if the given class declares a method named "noSuchMethod" and is not the
@@ skipping 176 matching lines @@
     return superType.element;
   }
 
   /**
    * Return `true` if the given type represents an object that could be invoked using the call
    * operator '()'.
    * @param type the type being tested
    * @return `true` if the given type represents an object that could be invoked
    */
   bool isExecutableType(Type2 type) {
-    if (type.isDynamic() || (type is FunctionType) || type.isDartCoreFunction()) {
+    if (type.isDynamic || (type is FunctionType) || type.isDartCoreFunction) {
       return true;
     } else if (type is InterfaceType) {
       ClassElement classElement = ((type as InterfaceType)).element;
       MethodElement methodElement = classElement.lookUpMethod(CALL_METHOD_NAME, _resolver.definingLibrary);
       return methodElement != null;
     }
     return false;
   }
 
   /**
    * Return `true` if the given element is a static element.
    * @param element the element being tested
    * @return `true` if the given element is a static element
    */
   bool isStatic(Element element) {
     if (element is ExecutableElement) {
-      return ((element as ExecutableElement)).isStatic();
+      return ((element as ExecutableElement)).isStatic;
     } else if (element is PropertyInducingElement) {
-      return ((element as PropertyInducingElement)).isStatic();
+      return ((element as PropertyInducingElement)).isStatic;
     }
     return false;
   }
 
   /**
    * Looks up the method element with the given name for index expression, reports[StaticWarningCode#UNDEFINED_OPERATOR] if not found.
    * @param node the index expression to resolve
    * @param target the target of the expression
    * @param methodName the name of the operator associated with the context of using of the given
    * index expression
@@ skipping 728 matching lines @@
   }
 
   /**
    * Return `true` if we should report an error as a result of looking up a member in the
    * given type and not finding any member.
    * @param type the type in which we attempted to perform the look-up
    * @param member the result of the look-up
    * @return `true` if we should report an error
    */
   bool shouldReportMissingMember(Type2 type, ExecutableElement member) {
-    if (member != null || type == null || type.isDynamic()) {
+    if (member != null || type == null || type.isDynamic) {
       return false;
     }
     if (type is InterfaceType) {
       return !classDeclaresNoSuchMethod(((type as InterfaceType)).element);
     }
     return true;
   }
 }
 /**
  * Instances of the class `SyntheticIdentifier` implement an identifier that can be used to
@@ skipping 261 matching lines @@
   Map<String, ExecutableElement> computeInterfaceLookupMap(ClassElement classElt, Set<ClassElement> visitedInterfaces) {
     Map<String, ExecutableElement> resultMap = _interfaceLookup[classElt];
     if (resultMap != null) {
       return resultMap;
     } else {
       resultMap = new Map<String, ExecutableElement>();
     }
     InterfaceType supertype = classElt.supertype;
     ClassElement superclassElement = supertype != null ? supertype.element : null;
     List<InterfaceType> interfaces = classElt.interfaces;
-    if ((superclassElement == null || supertype.isObject()) && interfaces.length == 0) {
+    if ((superclassElement == null || supertype.isObject) && interfaces.length == 0) {
       _interfaceLookup[classElt] = resultMap;
       return resultMap;
     }
     List<Map<String, ExecutableElement>> lookupMaps = new List<Map<String, ExecutableElement>>();
     if (superclassElement != null) {
       if (!visitedInterfaces.contains(superclassElement)) {
         try {
           javaSetAdd(visitedInterfaces, superclassElement);
           lookupMaps.add(computeInterfaceLookupMap(superclassElement, visitedInterfaces));
         } finally {
@@ skipping 43 matching lines @@
           javaSetAdd(set, entry.getValue());
           unionMap[key] = set;
         } else {
           javaSetAdd(unionMap[key], entry.getValue());
         }
       }
     }
     if (superclassElement != null) {
       List<MethodElement> methods = superclassElement.methods;
       for (MethodElement method in methods) {
-        if (method.isAccessibleIn(_library) && !method.isStatic()) {
+        if (method.isAccessibleIn(_library) && !method.isStatic) {
           String key = method.name;
           if (!unionMap.containsKey(key)) {
             Set<ExecutableElement> set = new Set<ExecutableElement>();
             javaSetAdd(set, method);
             unionMap[key] = set;
           } else {
             javaSetAdd(unionMap[key], method);
           }
         }
       }
       List<PropertyAccessorElement> accessors = superclassElement.accessors;
       for (PropertyAccessorElement accessor in accessors) {
-        if (accessor.isAccessibleIn(_library) && !accessor.isStatic()) {
+        if (accessor.isAccessibleIn(_library) && !accessor.isStatic) {
           String key = accessor.name;
           if (!unionMap.containsKey(key)) {
             Set<ExecutableElement> set = new Set<ExecutableElement>();
             javaSetAdd(set, accessor);
             unionMap[key] = set;
           } else {
             javaSetAdd(unionMap[key], accessor);
           }
         }
       }
     }
     for (InterfaceType interfaceType in interfaces) {
       ClassElement interfaceElement = interfaceType.element;
       if (interfaceElement != null) {
         List<MethodElement> methods = interfaceElement.methods;
         for (MethodElement method in methods) {
-          if (method.isAccessibleIn(_library) && !method.isStatic()) {
+          if (method.isAccessibleIn(_library) && !method.isStatic) {
             String key = method.name;
             if (!unionMap.containsKey(key)) {
               Set<ExecutableElement> set = new Set<ExecutableElement>();
               javaSetAdd(set, method);
               unionMap[key] = set;
             } else {
               javaSetAdd(unionMap[key], method);
             }
           }
         }
         List<PropertyAccessorElement> accessors = interfaceElement.accessors;
         for (PropertyAccessorElement accessor in accessors) {
-          if (accessor.isAccessibleIn(_library) && !accessor.isStatic()) {
+          if (accessor.isAccessibleIn(_library) && !accessor.isStatic) {
             String key = accessor.name;
             if (!unionMap.containsKey(key)) {
               Set<ExecutableElement> set = new Set<ExecutableElement>();
               javaSetAdd(set, accessor);
               unionMap[key] = set;
             } else {
               javaSetAdd(unionMap[key], accessor);
             }
           }
         }
       }
     }
     for (MapEntry<String, Set<ExecutableElement>> entry in getMapEntrySet(unionMap)) {
       String key = entry.getKey();
       Set<ExecutableElement> set = entry.getValue();
       int numOfEltsWithMatchingNames = set.length;
       if (numOfEltsWithMatchingNames == 1) {
         resultMap[key] = new JavaIterator(set).next();
       } else {
         bool allMethods = true;
         bool allSetters = true;
         bool allGetters = true;
         for (ExecutableElement executableElement in set) {
           if (executableElement is PropertyAccessorElement) {
             allMethods = false;
-            if (((executableElement as PropertyAccessorElement)).isSetter()) {
+            if (((executableElement as PropertyAccessorElement)).isSetter) {
               allGetters = false;
             } else {
               allSetters = false;
             }
           } else {
             allGetters = false;
             allSetters = false;
           }
         }
         if (allMethods || allGetters || allSetters) {
@@ skipping 42 matching lines @@
    * Given some [ClassElement], this method finds and returns the [ExecutableElement] of
    * the passed name in the class element. Static members, members in super types and members not
    * accessible from the current library are not considered.
    * @param classElt the class element to query
    * @param memberName the name of the member to lookup in the class
    * @return the found [ExecutableElement], or `null` if no such member was found
    */
   ExecutableElement lookupMemberInClass(ClassElement classElt, String memberName) {
     List<MethodElement> methods = classElt.methods;
     for (MethodElement method in methods) {
-      if (memberName == method.name && method.isAccessibleIn(_library) && !method.isStatic()) {
+      if (memberName == method.name && method.isAccessibleIn(_library) && !method.isStatic) {
         return method;
       }
     }
     List<PropertyAccessorElement> accessors = classElt.accessors;
     for (PropertyAccessorElement accessor in accessors) {
-      if (memberName == accessor.name && accessor.isAccessibleIn(_library) && !accessor.isStatic()) {
+      if (memberName == accessor.name && accessor.isAccessibleIn(_library) && !accessor.isStatic) {
         return accessor;
       }
     }
     return null;
   }
 
   /**
    * Record the passed map with the set of all members (methods, getters and setters) in the class
    * into the passed map.
    * @param map some non-`null`
    * @param classElt the class element that will be recorded into the passed map
    */
   void recordMapWithClassMembers(Map<String, ExecutableElement> map, ClassElement classElt) {
     List<MethodElement> methods = classElt.methods;
     for (MethodElement method in methods) {
-      if (method.isAccessibleIn(_library) && !method.isStatic()) {
+      if (method.isAccessibleIn(_library) && !method.isStatic) {
         map[method.name] = method;
       }
     }
     List<PropertyAccessorElement> accessors = classElt.accessors;
     for (PropertyAccessorElement accessor in accessors) {
-      if (accessor.isAccessibleIn(_library) && !accessor.isStatic()) {
+      if (accessor.isAccessibleIn(_library) && !accessor.isStatic) {
         map[accessor.name] = accessor;
       }
     }
   }
 
   /**
    * This method is used to report errors on when they are found computing inheritance information.
    * See [ErrorVerifier#checkForInconsistentMethodInheritance] to see where these generated
    * error codes are reported back into the analysis engine.
    * @param classElt the location of the source for which the exception occurred
@@ skipping 401 matching lines @@
 
   /**
    * Add all of the non-synthetic getters and setters defined in the given compilation unit that
    * have no corresponding accessor to one of the given collections.
    * @param getters the map to which getters are to be added
    * @param setters the list to which setters are to be added
    * @param unit the compilation unit defining the accessors that are potentially being added
    */
   void collectAccessors(Map<String, PropertyAccessorElement> getters, List<PropertyAccessorElement> setters, CompilationUnitElement unit) {
     for (PropertyAccessorElement accessor in unit.accessors) {
-      if (accessor.isGetter()) {
-        if (!accessor.isSynthetic() && accessor.correspondingSetter == null) {
+      if (accessor.isGetter) {
+        if (!accessor.isSynthetic && accessor.correspondingSetter == null) {
           getters[accessor.displayName] = accessor;
         }
       } else {
-        if (!accessor.isSynthetic() && accessor.correspondingGetter == null) {
+        if (!accessor.isSynthetic && accessor.correspondingGetter == null) {
           setters.add(accessor);
         }
       }
     }
   }
 
   /**
    * Search the top-level functions defined in the given compilation unit for the entry point.
    * @param element the compilation unit to be searched
    * @return the entry point that was found, or `null` if the compilation unit does not define
@@ skipping 1119 matching lines @@
    * type.
    * @param element the element whose type might be overridden
    * @param potentialType the potential type of the element
    */
   void override(VariableElement element, Type2 potentialType) {
     if (potentialType == null || identical(potentialType, BottomTypeImpl.instance)) {
       return;
     }
     if (element is PropertyInducingElement) {
       PropertyInducingElement variable = element as PropertyInducingElement;
-      if (!variable.isConst() && !variable.isFinal()) {
+      if (!variable.isConst && !variable.isFinal) {
         return;
       }
     }
     Type2 currentType = getBestType(element);
     if (currentType == null || !currentType.isMoreSpecificThan(potentialType)) {
       _overrideManager.setType(element, potentialType);
     }
   }
   void visitForEachStatementInScope(ForEachStatement node) {
     Expression iterator = node.iterator;
@@ skipping 1687 matching lines @@
           }
           MethodElement callMethod = ((returnType as InterfaceType)).lookUpMethod(ElementResolver.CALL_METHOD_NAME, _resolver.definingLibrary);
           if (callMethod != null) {
             return callMethod.type.returnType;
           }
         } else if (returnType is FunctionType) {
           Type2 innerReturnType = ((returnType as FunctionType)).returnType;
           if (innerReturnType != null) {
             return innerReturnType;
           }
-        } else if (returnType.isDartCoreFunction()) {
+        } else if (returnType.isDartCoreFunction) {
           return _dynamicType;
         }
         if (returnType != null) {
           return returnType;
         }
       }
     } else if (element is ExecutableElement) {
       FunctionType type = ((element as ExecutableElement)).type;
       if (type != null) {
         return type.returnType;
@@ skipping 160 matching lines @@
    * @param context if the accessor element has context \[by being the RHS of a[PrefixedIdentifier] or [PropertyAccess]\], and the return type of the
    * accessor is a parameter type, then the type of the LHS can be used to get more
    * specific type information
    * @return the type that should be recorded for a node that resolved to the given accessor
    */
   Type2 getType(PropertyAccessorElement accessor, Type2 context) {
     FunctionType functionType = accessor.type;
     if (functionType == null) {
       return _dynamicType;
     }
-    if (accessor.isSetter()) {
+    if (accessor.isSetter) {
       List<Type2> parameterTypes = functionType.normalParameterTypes;
       if (parameterTypes != null && parameterTypes.length > 0) {
         return parameterTypes[0];
       }
       PropertyAccessorElement getter = accessor.variable.getter;
       if (getter != null) {
         functionType = getter.type;
         if (functionType != null) {
           return functionType.returnType;
         }
@@ skipping 45 matching lines @@
     ASTNode parent = node.parent;
     return parent is TypeName || (parent is PrefixedIdentifier && (parent.parent is TypeName || identical(((parent as PrefixedIdentifier)).prefix, node))) || (parent is PropertyAccess && identical(((parent as PropertyAccess)).target, node)) || (parent is MethodInvocation && identical(node, ((parent as MethodInvocation)).target));
   }
 
   /**
    * Record that the propagated type of the given node is the given type.
    * @param expression the node whose type is to be recorded
    * @param type the propagated type of the node
    */
   void recordPropagatedType(Expression expression, Type2 type) {
-    if (type != null && !type.isDynamic()) {
+    if (type != null && !type.isDynamic) {
       expression.propagatedType = type;
     }
   }
 
   /**
    * Record that the static type of the given node is the given type.
    * @param expression the node whose type is to be recorded
    * @param type the static type of the node
    */
   void recordStaticType(Expression expression, Type2 type) {
@@ skipping 192 matching lines @@
   Map<Element, Type2> captureLocalOverrides() => _overridenTypes;
 
   /**
    * Return a map from the elements for the variables in the given list that have their types
    * overridden to the overriding type.
    * @param variableList the list of variables whose overriding types are to be captured
    * @return a table mapping elements to their overriding types
    */
   Map<Element, Type2> captureOverrides(VariableDeclarationList variableList) {
     Map<Element, Type2> overrides = new Map<Element, Type2>();
-    if (variableList.isConst() || variableList.isFinal()) {
+    if (variableList.isConst || variableList.isFinal) {
       for (VariableDeclaration variable in variableList.variables) {
         Element element = variable.element;
         if (element != null) {
           Type2 type = _overridenTypes[element];
           if (type != null) {
             overrides[element] = type;
           }
         }
       }
     }
@@ skipping 452 matching lines @@
     FunctionTypeImpl type = new FunctionTypeImpl.con1(element);
     ClassElement definingClass = element.getAncestor(ClassElement);
     if (definingClass != null) {
       type.typeArguments = definingClass.type.typeArguments;
     }
     setTypeInformation(type, element.parameters);
     element.type = type;
     if (element is PropertyAccessorElement) {
       PropertyAccessorElement accessor = element as PropertyAccessorElement;
       PropertyInducingElementImpl variable = accessor.variable as PropertyInducingElementImpl;
-      if (accessor.isGetter()) {
+      if (accessor.isGetter) {
         variable.type = type.returnType;
       } else if (variable.type == null) {
         List<Type2> parameterTypes = type.normalParameterTypes;
         if (parameterTypes != null && parameterTypes.length > 0) {
           variable.type = parameterTypes[0];
         }
       }
     }
     return null;
   }
@@ skipping 53 matching lines @@
             node.name = prefix;
             typeName = prefix;
           }
         }
       }
     }
     bool elementValid = element is! MultiplyDefinedElement;
     if (elementValid && element is! ClassElement && isTypeNameInInstanceCreationExpression(node)) {
       SimpleIdentifier typeNameSimple = getTypeSimpleIdentifier(typeName);
       InstanceCreationExpression creation = node.parent.parent as InstanceCreationExpression;
-      if (creation.isConst()) {
+      if (creation.isConst) {
         if (element == null) {
           reportError(CompileTimeErrorCode.UNDEFINED_CLASS, typeNameSimple, [typeName]);
         } else {
           reportError(CompileTimeErrorCode.CONST_WITH_NON_TYPE, typeNameSimple, [typeName]);
         }
         elementValid = false;
       } else {
         if (element != null) {
           reportError(StaticWarningCode.NEW_WITH_NON_TYPE, typeNameSimple, [typeName]);
           elementValid = false;
@@ skipping 200 matching lines @@
    * error.
    * @param node the type name with the wrong number of type arguments
    * @return the error code that should be used to report that the wrong number of type arguments
    * were provided
    */
   ErrorCode getInvalidTypeParametersErrorCode(TypeName node) {
     ASTNode parent = node.parent;
     if (parent is ConstructorName) {
       parent = parent.parent;
       if (parent is InstanceCreationExpression) {
-        if (((parent as InstanceCreationExpression)).isConst()) {
+        if (((parent as InstanceCreationExpression)).isConst) {
           return CompileTimeErrorCode.CONST_WITH_INVALID_TYPE_PARAMETERS;
         } else {
           return CompileTimeErrorCode.NEW_WITH_INVALID_TYPE_PARAMETERS;
         }
       }
     }
     return StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS;
   }
 
   /**
@@ skipping 388 matching lines @@
    */
   void defineParameters(ExecutableElement functionElement) {
     Scope parameterScope = enclosingScope;
     if (functionElement.enclosingElement is ExecutableElement) {
       String name = functionElement.name;
       if (name != null && !name.isEmpty) {
         parameterScope.define(functionElement);
       }
     }
     for (ParameterElement parameter in functionElement.parameters) {
-      if (!parameter.isInitializingFormal()) {
+      if (!parameter.isInitializingFormal) {
         parameterScope.define(parameter);
       }
     }
   }
 }
 /**
  * Instances of the class `FunctionTypeScope` implement the scope defined by a function type
  * alias.
  * @coverage dart.engine.resolver
  */
@@ skipping 262 matching lines @@
    * @param errorListener the listener that is to be informed when an error is encountered
    */
   LibraryScope(LibraryElement definingLibrary, AnalysisErrorListener errorListener) : super(new LibraryImportScope(definingLibrary, errorListener)) {
     defineTopLevelNames(definingLibrary);
   }
   AnalysisError getErrorForDuplicate(Element existing, Element duplicate) {
     if (existing is PrefixElement) {
       int offset = duplicate.nameOffset;
       if (duplicate is PropertyAccessorElement) {
         PropertyAccessorElement accessor = duplicate as PropertyAccessorElement;
-        if (accessor.isSynthetic()) {
+        if (accessor.isSynthetic) {
           offset = accessor.variable.nameOffset;
         }
       }
       return new AnalysisError.con2(source, offset, duplicate.displayName.length, CompileTimeErrorCode.PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER, [existing.displayName]);
     }
     return super.getErrorForDuplicate(existing, duplicate);
   }
 
   /**
    * Add to this scope all of the public top-level names that are defined in the given compilation
@@ skipping 553 matching lines @@
     return null;
   }
   Object visitSwitchCase(SwitchCase node) {
     super.visitSwitchCase(node);
     validate(node.expression, CompileTimeErrorCode.NON_CONSTANT_CASE_EXPRESSION);
     return null;
   }
   Object visitVariableDeclaration(VariableDeclaration node) {
     super.visitVariableDeclaration(node);
     Expression initializer = node.initializer;
-    if (initializer != null && node.isConst()) {
+    if (initializer != null && node.isConst) {
       VariableElementImpl element = node.element as VariableElementImpl;
       EvaluationResultImpl result = element.evaluationResult;
       if (result == null) {
         result = validate(initializer, CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE);
         element.evaluationResult = result;
       } else if (result is ErrorResult) {
         reportErrors(result, CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE);
       }
     }
     return null;
@@ skipping 39 matching lines @@
     reportErrors(result, errorCode);
     return result;
   }
 
   /**
    * Validate that if the passed instance creation is 'const' then all its arguments are constant
    * expressions.
    * @param node the instance creation evaluate
    */
   void validateConstantArguments(InstanceCreationExpression node) {
-    if (!node.isConst()) {
+    if (!node.isConst) {
       return;
     }
     ArgumentList argumentList = node.argumentList;
     if (argumentList == null) {
       return;
     }
     for (Expression argument in argumentList.arguments) {
       if (argument is NamedExpression) {
         argument = ((argument as NamedExpression)).expression;
       }
@@ skipping 76 matching lines @@
 class ConstantVisitor_9 extends ConstantVisitor {
   final ConstantVerifier ConstantVerifier_this;
   List<ParameterElement> parameterElements;
   ConstantVisitor_9(this.ConstantVerifier_this, this.parameterElements) : super();
   EvaluationResultImpl visitSimpleIdentifier(SimpleIdentifier node) {
     Element element = node.element;
     for (ParameterElement parameterElement in parameterElements) {
       if (identical(parameterElement, element) && parameterElement != null) {
         Type2 type = parameterElement.type;
         if (type != null) {
-          if (type.isDynamic()) {
+          if (type.isDynamic) {
             return ValidResult.RESULT_DYNAMIC;
           }
           if (type.isSubtypeOf(ConstantVerifier_this._boolType)) {
             return ValidResult.RESULT_BOOL;
           }
           if (type.isSubtypeOf(ConstantVerifier_this._intType)) {
             return ValidResult.RESULT_INT;
           }
           if (type.isSubtypeOf(ConstantVerifier_this._numType)) {
             return ValidResult.RESULT_NUM;
@@ skipping 126 matching lines @@
    */
   Set<String> _namesForReferenceToDeclaredVariableInInitializer = new Set<String>();
 
   /**
    * A list of types used by the [CompileTimeErrorCode#EXTENDS_DISALLOWED_CLASS] and[CompileTimeErrorCode#IMPLEMENTS_DISALLOWED_CLASS] error codes.
    */
   List<InterfaceType> _DISALLOWED_TYPES_TO_EXTEND_OR_IMPLEMENT;
   ErrorVerifier(ErrorReporter errorReporter, LibraryElement currentLibrary, TypeProvider typeProvider, InheritanceManager inheritanceManager) {
     this._errorReporter = errorReporter;
     this._currentLibrary = currentLibrary;
-    this._isInSystemLibrary = currentLibrary.source.isInSystemLibrary();
+    this._isInSystemLibrary = currentLibrary.source.isInSystemLibrary;
     this._typeProvider = typeProvider;
     this._inheritanceManager = inheritanceManager;
     _strictMode = currentLibrary.context.analysisOptions.strictMode;
     _isEnclosingConstructorConst = false;
     _isInCatchClause = false;
     _dynamicType = typeProvider.dynamicType;
     _DISALLOWED_TYPES_TO_EXTEND_OR_IMPLEMENT = <InterfaceType> [typeProvider.numType, typeProvider.intType, typeProvider.doubleType, typeProvider.boolType, typeProvider.stringType];
   }
   Object visitArgumentDefinitionTest(ArgumentDefinitionTest node) {
     checkForArgumentDefinitionTestNonParameter(node);
@@ skipping 47 matching lines @@
           checkForNonAbstractClassInheritsAbstractMember(node);
           checkForInconsistentMethodInheritance();
           checkForRecursiveInterfaceInheritance(_enclosingClass, new List<ClassElement>());
         }
       }
       ClassElement classElement = node.element;
       if (classElement != null) {
         List<FieldElement> fieldElements = classElement.fields;
         _initialFieldElementsMap = new Map<FieldElement, INIT_STATE>();
         for (FieldElement fieldElement in fieldElements) {
-          if (!fieldElement.isSynthetic()) {
+          if (!fieldElement.isSynthetic) {
             _initialFieldElementsMap[fieldElement] = fieldElement.initializer == null ? INIT_STATE.NOT_INIT : INIT_STATE.INIT_IN_DECLARATION;
           }
         }
       }
       checkForFinalNotInitialized(node);
       return super.visitClassDeclaration(node);
     } finally {
       _initialFieldElementsMap = null;
       _enclosingClass = outerClass;
     }
@@ skipping 58 matching lines @@
     checkForExportInternalLibrary(node);
     return super.visitExportDirective(node);
   }
   Object visitExpressionFunctionBody(ExpressionFunctionBody node) {
     FunctionType functionType = _enclosingFunction == null ? null : _enclosingFunction.type;
     Type2 expectedReturnType = functionType == null ? DynamicTypeImpl.instance : functionType.returnType;
     checkForReturnOfInvalidType(node.expression, expectedReturnType);
     return super.visitExpressionFunctionBody(node);
   }
   Object visitFieldDeclaration(FieldDeclaration node) {
-    if (!node.isStatic()) {
+    if (!node.isStatic) {
       VariableDeclarationList variables = node.fields;
-      if (variables.isConst()) {
+      if (variables.isConst) {
         _errorReporter.reportError4(CompileTimeErrorCode.CONST_INSTANCE_FIELD, variables.keyword, []);
       }
     }
     return super.visitFieldDeclaration(node);
   }
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     checkForConstFormalParameter(node);
     checkForFieldInitializingFormalRedirectingConstructor(node);
     return super.visitFieldFormalParameter(node);
   }
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     ExecutableElement outerFunction = _enclosingFunction;
     try {
       SimpleIdentifier identifier = node.name;
       String methodName = "";
       if (identifier != null) {
         methodName = identifier.name;
       }
       _enclosingFunction = node.element;
-      if (node.isSetter() || node.isGetter()) {
+      if (node.isSetter || node.isGetter) {
         checkForMismatchedAccessorTypes(node, methodName);
-        if (node.isSetter()) {
+        if (node.isSetter) {
           FunctionExpression functionExpression = node.functionExpression;
           if (functionExpression != null) {
             checkForWrongNumberOfParametersForSetter(node.name, functionExpression.parameters);
           }
           TypeName returnType = node.returnType;
           checkForNonVoidReturnTypeForSetter(returnType);
         }
       }
       return super.visitFunctionDeclaration(node);
     } finally {
@@ skipping 31 matching lines @@
     checkForArgumentTypeNotAssignable2(node.index);
     return super.visitIndexExpression(node);
   }
   Object visitInstanceCreationExpression(InstanceCreationExpression node) {
     ConstructorName constructorName = node.constructorName;
     TypeName typeName = constructorName.type;
     Type2 type = typeName.type;
     if (type is InterfaceType) {
       InterfaceType interfaceType = type as InterfaceType;
       checkForConstOrNewWithAbstractClass(node, typeName, interfaceType);
-      if (node.isConst()) {
+      if (node.isConst) {
         checkForConstWithNonConst(node);
         checkForConstWithUndefinedConstructor(node);
         checkForConstWithTypeParameters(node);
       } else {
         checkForNewWithUndefinedConstructor(node);
       }
       checkForTypeArgumentNotMatchingBounds(node, constructorName.element, typeName);
     }
     return super.visitInstanceCreationExpression(node);
   }
@@ skipping 25 matching lines @@
   }
   Object visitMethodDeclaration(MethodDeclaration node) {
     ExecutableElement previousFunction = _enclosingFunction;
     try {
       _enclosingFunction = node.element;
       SimpleIdentifier identifier = node.name;
       String methoName = "";
       if (identifier != null) {
         methoName = identifier.name;
       }
-      if (node.isSetter() || node.isGetter()) {
+      if (node.isSetter || node.isGetter) {
         checkForMismatchedAccessorTypes(node, methoName);
         checkForConflictingInstanceGetterAndSuperclassMember(node);
       }
-      if (node.isGetter()) {
+      if (node.isGetter) {
         checkForConflictingStaticGetterAndInstanceSetter(node);
-      } else if (node.isSetter()) {
+      } else if (node.isSetter) {
         checkForWrongNumberOfParametersForSetter(node.name, node.parameters);
         checkForNonVoidReturnTypeForSetter(node.returnType);
         checkForConflictingStaticSetterAndInstanceMember(node);
-      } else if (node.isOperator()) {
+      } else if (node.isOperator) {
         checkForOptionalParameterInOperator(node);
         checkForWrongNumberOfParametersForOperator(node);
         checkForNonVoidReturnTypeForOperator(node);
       }
       checkForConcreteClassWithAbstractMember(node);
       checkForAllInvalidOverrideErrorCodes(node);
       return super.visitMethodDeclaration(node);
     } finally {
       _enclosingFunction = previousFunction;
     }
   }
   Object visitMethodInvocation(MethodInvocation node) {
     checkForStaticAccessToInstanceMember(node.target, node.methodName);
     return super.visitMethodInvocation(node);
   }
   Object visitNativeFunctionBody(NativeFunctionBody node) {
     checkForNativeFunctionBodyInNonSDKCode(node);
     return super.visitNativeFunctionBody(node);
   }
   Object visitPostfixExpression(PostfixExpression node) {
     checkForAssignmentToFinal2(node.operand);
     return super.visitPostfixExpression(node);
   }
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
     checkForStaticAccessToInstanceMember(node.prefix, node.identifier);
     return super.visitPrefixedIdentifier(node);
   }
   Object visitPrefixExpression(PrefixExpression node) {
-    if (node.operator.type.isIncrementOperator()) {
+    if (node.operator.type.isIncrementOperator) {
       checkForAssignmentToFinal2(node.operand);
     }
     return super.visitPrefixExpression(node);
   }
   Object visitPropertyAccess(PropertyAccess node) {
     checkForStaticAccessToInstanceMember(node.target, node.propertyName);
     return super.visitPropertyAccess(node);
   }
   Object visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
     _isInConstructorInitializer = true;
@@ skipping 100 matching lines @@
       FormalParameter parameter = formalParameter;
       if (parameter is DefaultFormalParameter) {
         parameter = ((parameter as DefaultFormalParameter)).parameter;
       }
       if (parameter is FieldFormalParameter) {
         FieldElement fieldElement = ((parameter.element as FieldFormalParameterElementImpl)).field;
         INIT_STATE state = fieldElementsMap[fieldElement];
         if (identical(state, INIT_STATE.NOT_INIT)) {
           fieldElementsMap[fieldElement] = INIT_STATE.INIT_IN_FIELD_FORMAL;
         } else if (identical(state, INIT_STATE.INIT_IN_DECLARATION)) {
-          if (fieldElement.isFinal() || fieldElement.isConst()) {
+          if (fieldElement.isFinal || fieldElement.isConst) {
             _errorReporter.reportError2(CompileTimeErrorCode.FINAL_INITIALIZED_IN_DECLARATION_AND_CONSTRUCTOR, formalParameter.identifier, [fieldElement.displayName]);
             foundError = true;
           }
         } else if (identical(state, INIT_STATE.INIT_IN_FIELD_FORMAL)) {
-          if (fieldElement.isFinal() || fieldElement.isConst()) {
+          if (fieldElement.isFinal || fieldElement.isConst) {
             _errorReporter.reportError2(CompileTimeErrorCode.FINAL_INITIALIZED_MULTIPLE_TIMES, formalParameter.identifier, [fieldElement.displayName]);
             foundError = true;
           }
         }
       }
     }
     NodeList<ConstructorInitializer> initializers = node.initializers;
     for (ConstructorInitializer constructorInitializer in initializers) {
       if (constructorInitializer is ConstructorFieldInitializer) {
         ConstructorFieldInitializer constructorFieldInitializer = constructorInitializer as ConstructorFieldInitializer;
         SimpleIdentifier fieldName = constructorFieldInitializer.fieldName;
         Element element = fieldName.element;
         if (element is FieldElement) {
           FieldElement fieldElement = element as FieldElement;
           INIT_STATE state = fieldElementsMap[fieldElement];
           if (identical(state, INIT_STATE.NOT_INIT)) {
             fieldElementsMap[fieldElement] = INIT_STATE.INIT_IN_INITIALIZERS;
           } else if (identical(state, INIT_STATE.INIT_IN_DECLARATION)) {
-            if (fieldElement.isFinal() || fieldElement.isConst()) {
+            if (fieldElement.isFinal || fieldElement.isConst) {
               _errorReporter.reportError2(CompileTimeErrorCode.FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION, fieldName, []);
               foundError = true;
             }
           } else if (identical(state, INIT_STATE.INIT_IN_FIELD_FORMAL)) {
             _errorReporter.reportError2(CompileTimeErrorCode.FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZER, fieldName, []);
             foundError = true;
           } else if (identical(state, INIT_STATE.INIT_IN_INITIALIZERS)) {
             _errorReporter.reportError2(CompileTimeErrorCode.FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS, fieldName, [fieldElement.displayName]);
             foundError = true;
           }
@@ skipping 13 matching lines @@
    * @see CompileTimeErrorCode#INVALID_OVERRIDE_NAMED
    * @see StaticWarningCode#INVALID_GETTER_OVERRIDE_RETURN_TYPE
    * @see StaticWarningCode#INVALID_METHOD_OVERRIDE_RETURN_TYPE
    * @see StaticWarningCode#INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE
    * @see StaticWarningCode#INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE
    * @see StaticWarningCode#INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE
    * @see StaticWarningCode#INVALID_METHOD_OVERRIDE_NAMED_PARAM_TYPE
    * @see StaticWarningCode#INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES
    */
   bool checkForAllInvalidOverrideErrorCodes(MethodDeclaration node) {
-    if (_enclosingClass == null || node.isStatic() || node.body is NativeFunctionBody) {
+    if (_enclosingClass == null || node.isStatic || node.body is NativeFunctionBody) {
       return false;
     }
     ExecutableElement executableElement = node.element;
     if (executableElement == null) {
       return false;
     }
     SimpleIdentifier methodName = node.name;
-    if (methodName.isSynthetic()) {
+    if (methodName.isSynthetic) {
       return false;
     }
     String methodNameStr = methodName.name;
     ExecutableElement overriddenExecutable = _inheritanceManager.lookupInheritance(_enclosingClass, executableElement.name);
     if (overriddenExecutable == null) {
-      if (!node.isGetter() && !node.isSetter() && !node.isOperator()) {
+      if (!node.isGetter && !node.isSetter && !node.isOperator) {
         Set<ClassElement> visitedClasses = new Set<ClassElement>();
         InterfaceType superclassType = _enclosingClass.supertype;
         ClassElement superclassElement = superclassType == null ? null : superclassType.element;
         while (superclassElement != null && !visitedClasses.contains(superclassElement)) {
           javaSetAdd(visitedClasses, superclassElement);
           List<FieldElement> fieldElts = superclassElement.fields;
           for (FieldElement fieldElt in fieldElts) {
-            if (fieldElt.name == methodNameStr && fieldElt.isStatic()) {
+            if (fieldElt.name == methodNameStr && fieldElt.isStatic) {
               _errorReporter.reportError2(StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC, methodName, [methodNameStr, fieldElt.enclosingElement.displayName]);
               return true;
             }
           }
           List<PropertyAccessorElement> propertyAccessorElts = superclassElement.accessors;
           for (PropertyAccessorElement accessorElt in propertyAccessorElts) {
-            if (accessorElt.name == methodNameStr && accessorElt.isStatic()) {
+            if (accessorElt.name == methodNameStr && accessorElt.isStatic) {
               _errorReporter.reportError2(StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC, methodName, [methodNameStr, accessorElt.enclosingElement.displayName]);
               return true;
             }
           }
           List<MethodElement> methodElements = superclassElement.methods;
           for (MethodElement methodElement in methodElements) {
-            if (methodElement.name == methodNameStr && methodElement.isStatic()) {
+            if (methodElement.name == methodNameStr && methodElement.isStatic) {
               _errorReporter.reportError2(StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC, methodName, [methodNameStr, methodElement.enclosingElement.displayName]);
               return true;
             }
           }
           superclassType = superclassElement.supertype;
           superclassElement = superclassType == null ? null : superclassType.element;
         }
       }
       return false;
     }
@@ skipping 23 matching lines @@
     Set<String> overridingParameterNameSet = overridingNamedPT.keys.toSet();
     JavaIterator<String> overriddenParameterNameIterator = new JavaIterator(overriddenNamedPT.keys.toSet());
     while (overriddenParameterNameIterator.hasNext) {
       String overriddenParamName = overriddenParameterNameIterator.next();
       if (!overridingParameterNameSet.contains(overriddenParamName)) {
         _errorReporter.reportError2(CompileTimeErrorCode.INVALID_OVERRIDE_NAMED, methodName, [overriddenParamName, overriddenExecutable.enclosingElement.displayName]);
         return true;
       }
     }
     if (overriddenFTReturnType != VoidTypeImpl.instance && !overridingFTReturnType.isAssignableTo(overriddenFTReturnType)) {
-      _errorReporter.reportError2(!node.isGetter() ? StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE : StaticWarningCode.INVALID_GETTER_OVERRIDE_RETURN_TYPE, methodName, [overridingFTReturnType.displayName, overriddenFTReturnType.displayName, overriddenExecutable.enclosingElement.displayName]);
+      _errorReporter.reportError2(!node.isGetter ? StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE : StaticWarningCode.INVALID_GETTER_OVERRIDE_RETURN_TYPE, methodName, [overridingFTReturnType.displayName, overriddenFTReturnType.displayName, overriddenExecutable.enclosingElement.displayName]);
       return true;
     }
     FormalParameterList formalParameterList = node.parameters;
     if (formalParameterList == null) {
       return false;
     }
     NodeList<FormalParameter> parameterNodeList = formalParameterList.parameters;
     int parameterIndex = 0;
     for (int i = 0; i < overridingNormalPT.length; i++) {
       if (!overridingNormalPT[i].isAssignableTo(overriddenNormalPT[i])) {
-        _errorReporter.reportError2(!node.isSetter() ? StaticWarningCode.INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE : StaticWarningCode.INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE, parameterNodeList[parameterIndex], [overridingNormalPT[i].displayName, overriddenNormalPT[i].displayName, overriddenExecutable.enclosingElement.displayName]);
+        _errorReporter.reportError2(!node.isSetter ? StaticWarningCode.INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE : StaticWarningCode.INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE, parameterNodeList[parameterIndex], [overridingNormalPT[i].displayName, overriddenNormalPT[i].displayName, overriddenExecutable.enclosingElement.displayName]);
         return true;
       }
       parameterIndex++;
     }
     for (int i = 0; i < overriddenPositionalPT.length; i++) {
       if (!overridingPositionalPT[i].isAssignableTo(overriddenPositionalPT[i])) {
         _errorReporter.reportError2(StaticWarningCode.INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE, parameterNodeList[parameterIndex], [overridingPositionalPT[i].displayName, overriddenPositionalPT[i].displayName, overriddenExecutable.enclosingElement.displayName]);
         return true;
       }
       parameterIndex++;
@@ skipping 22 matching lines @@
           return true;
         }
       }
     }
     bool foundError = false;
     List<FormalParameter> formalParameters = new List<FormalParameter>();
     List<ParameterElementImpl> parameterElts = new List<ParameterElementImpl>();
     List<ParameterElementImpl> overriddenParameterElts = new List<ParameterElementImpl>();
     List<ParameterElement> overriddenPEs = overriddenExecutable.parameters;
     for (FormalParameter formalParameter in parameterNodeList) {
-      if (formalParameter.kind.isOptional()) {
+      if (formalParameter.kind.isOptional) {
         formalParameters.add(formalParameter);
         parameterElts.add((formalParameter.element as ParameterElementImpl));
       }
     }
     for (ParameterElement parameterElt in overriddenPEs) {
-      if (parameterElt.parameterKind.isOptional()) {
+      if (parameterElt.parameterKind.isOptional) {
         overriddenParameterElts.add((parameterElt as ParameterElementImpl));
       }
     }
     if (parameterElts.length > 0) {
       if (identical(parameterElts[0].parameterKind, ParameterKind.NAMED)) {
         for (int i = 0; i < parameterElts.length; i++) {
           ParameterElementImpl parameterElt = parameterElts[i];
           EvaluationResultImpl result = parameterElt.evaluationResult;
           if (result == null || identical(result, ValidResult.RESULT_OBJECT)) {
             continue;
@@ skipping 117 matching lines @@
    * @param node the return statement to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#RETURN_IN_GENERATIVE_CONSTRUCTOR
    * @see StaticWarningCode#RETURN_WITHOUT_VALUE
    * @see StaticTypeWarningCode#RETURN_OF_INVALID_TYPE
    */
   bool checkForAllReturnStatementErrorCodes(ReturnStatement node) {
     FunctionType functionType = _enclosingFunction == null ? null : _enclosingFunction.type;
     Type2 expectedReturnType = functionType == null ? DynamicTypeImpl.instance : functionType.returnType;
     Expression returnExpression = node.expression;
-    bool isGenerativeConstructor = _enclosingFunction is ConstructorElement && !((_enclosingFunction as ConstructorElement)).isFactory();
+    bool isGenerativeConstructor = _enclosingFunction is ConstructorElement && !((_enclosingFunction as ConstructorElement)).isFactory;
     if (isGenerativeConstructor) {
       if (returnExpression == null) {
         return false;
       }
       _errorReporter.reportError2(CompileTimeErrorCode.RETURN_IN_GENERATIVE_CONSTRUCTOR, returnExpression, []);
       return true;
     }
     if (returnExpression == null) {
       if (VoidTypeImpl.instance.isAssignableTo(expectedReturnType)) {
         return false;
@@ skipping 127 matching lines @@
   bool checkForAssignmentToFinal2(Expression expression) {
     Element element = null;
     if (expression is Identifier) {
       element = ((expression as Identifier)).element;
     }
     if (expression is PropertyAccess) {
       element = ((expression as PropertyAccess)).propertyName.element;
     }
     if (element is VariableElement) {
       VariableElement leftVar = element as VariableElement;
-      if (leftVar.isFinal()) {
+      if (leftVar.isFinal) {
         _errorReporter.reportError2(StaticWarningCode.ASSIGNMENT_TO_FINAL, expression, []);
         return true;
       }
       return false;
     }
     if (element is PropertyAccessorElement) {
       PropertyAccessorElement leftAccessor = element as PropertyAccessorElement;
-      if (!leftAccessor.isSetter()) {
+      if (!leftAccessor.isSetter) {
         _errorReporter.reportError2(StaticWarningCode.ASSIGNMENT_TO_FINAL, expression, []);
         return true;
       }
       return false;
     }
     return false;
   }
 
   /**
    * This verifies that the passed identifier is not a keyword, and generates the passed error code
@@ skipping 119 matching lines @@
   }
 
   /**
    * This verifies that the passed method declaration is abstract only if the enclosing class is
    * also abstract.
    * @param node the method declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#CONCRETE_CLASS_WITH_ABSTRACT_MEMBER
    */
   bool checkForConcreteClassWithAbstractMember(MethodDeclaration node) {
-    if (node.isAbstract() && _enclosingClass != null && !_enclosingClass.isAbstract()) {
+    if (node.isAbstract && _enclosingClass != null && !_enclosingClass.isAbstract) {
       SimpleIdentifier methodName = node.name;
       _errorReporter.reportError2(StaticWarningCode.CONCRETE_CLASS_WITH_ABSTRACT_MEMBER, methodName, [methodName.name, _enclosingClass.displayName]);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies all possible conflicts of the constructor name with other constructors and
    * members of the same class.
@@ skipping 16 matching lines @@
       }
       if (name == otherConstructor.name) {
         if (name == null || name.length == 0) {
           _errorReporter.reportError2(CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_DEFAULT, node, []);
         } else {
           _errorReporter.reportError2(CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_NAME, node, [name]);
         }
         return true;
       }
     }
-    if (constructorName != null && constructorElement != null && !constructorName.isSynthetic()) {
+    if (constructorName != null && constructorElement != null && !constructorName.isSynthetic) {
       List<FieldElement> fields = classElement.fields;
       for (FieldElement field in fields) {
         if (field.name == name) {
           _errorReporter.reportError2(CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_FIELD, node, [name]);
           return true;
         }
       }
       List<MethodElement> methods = classElement.methods;
       for (MethodElement method in methods) {
         if (method.name == name) {
           _errorReporter.reportError2(CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_METHOD, node, [name]);
           return true;
         }
       }
     }
     return false;
   }
 
   /**
    * This verifies that the superclass of the enclosing class does not declare accessible static
    * member with the same name as the passed instance getter/setter method declaration.
    * @param node the method declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER
    * @see StaticWarningCode#CONFLICTING_INSTANCE_SETTER_AND_SUPERCLASS_MEMBER
    */
   bool checkForConflictingInstanceGetterAndSuperclassMember(MethodDeclaration node) {
-    if (node.isStatic()) {
+    if (node.isStatic) {
       return false;
     }
     SimpleIdentifier nameNode = node.name;
     if (nameNode == null) {
       return false;
     }
     String name = nameNode.name;
     if (_enclosingClass == null) {
       return false;
     }
     InterfaceType enclosingType = _enclosingClass.type;
     ExecutableElement superElement;
     superElement = enclosingType.lookUpGetterInSuperclass(name, _currentLibrary);
     if (superElement == null) {
       superElement = enclosingType.lookUpSetterInSuperclass(name, _currentLibrary);
     }
     if (superElement == null) {
       superElement = enclosingType.lookUpMethodInSuperclass(name, _currentLibrary);
     }
     if (superElement == null) {
       return false;
     }
-    if (!superElement.isStatic()) {
+    if (!superElement.isStatic) {
       return false;
     }
     ClassElement superElementClass = superElement.enclosingElement as ClassElement;
     InterfaceType superElementType = superElementClass.type;
-    if (node.isGetter()) {
+    if (node.isGetter) {
       _errorReporter.reportError2(StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER, nameNode, [superElementType.displayName]);
     } else {
       _errorReporter.reportError2(StaticWarningCode.CONFLICTING_INSTANCE_SETTER_AND_SUPERCLASS_MEMBER, nameNode, [superElementType.displayName]);
     }
     return true;
   }
 
   /**
    * This verifies that the enclosing class does not have an instance member with the same name as
    * the passed static getter method declaration.
    * @param node the method declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER
    */
   bool checkForConflictingStaticGetterAndInstanceSetter(MethodDeclaration node) {
-    if (!node.isStatic()) {
+    if (!node.isStatic) {
       return false;
     }
     SimpleIdentifier nameNode = node.name;
     if (nameNode == null) {
       return false;
     }
     String name = nameNode.name;
     if (_enclosingClass == null) {
       return false;
     }
     InterfaceType enclosingType = _enclosingClass.type;
     ExecutableElement setter = enclosingType.lookUpSetter(name, _currentLibrary);
     if (setter == null) {
       return false;
     }
-    if (setter.isStatic()) {
+    if (setter.isStatic) {
       return false;
     }
     ClassElement setterClass = setter.enclosingElement as ClassElement;
     InterfaceType setterType = setterClass.type;
     _errorReporter.reportError2(StaticWarningCode.CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER, nameNode, [setterType.displayName]);
     return true;
   }
 
   /**
    * This verifies that the enclosing class does not have an instance member with the same name as
    * the passed static getter method declaration.
    * @param node the method declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#CONFLICTING_STATIC_SETTER_AND_INSTANCE_MEMBER
    */
   bool checkForConflictingStaticSetterAndInstanceMember(MethodDeclaration node) {
-    if (!node.isStatic()) {
+    if (!node.isStatic) {
       return false;
     }
     SimpleIdentifier nameNode = node.name;
     if (nameNode == null) {
       return false;
     }
     String name = nameNode.name;
     if (_enclosingClass == null) {
       return false;
     }
     InterfaceType enclosingType = _enclosingClass.type;
     ExecutableElement member;
     member = enclosingType.lookUpMethod(name, _currentLibrary);
     if (member == null) {
       member = enclosingType.lookUpGetter(name, _currentLibrary);
     }
     if (member == null) {
       member = enclosingType.lookUpSetter(name, _currentLibrary);
     }
     if (member == null) {
       return false;
     }
-    if (member.isStatic()) {
+    if (member.isStatic) {
       return false;
     }
     ClassElement memberClass = member.enclosingElement as ClassElement;
     InterfaceType memberType = memberClass.type;
     _errorReporter.reportError2(StaticWarningCode.CONFLICTING_STATIC_SETTER_AND_INSTANCE_MEMBER, nameNode, [memberType.displayName]);
     return true;
   }
 
   /**
    * This verifies that the passed constructor declaration is 'const' then there are no non-final
@@ skipping 30 matching lines @@
     return false;
   }
 
   /**
    * This verifies that the passed normal formal parameter is not 'const'.
    * @param node the normal formal parameter to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CONST_FORMAL_PARAMETER
    */
   bool checkForConstFormalParameter(NormalFormalParameter node) {
-    if (node.isConst()) {
+    if (node.isConst) {
       _errorReporter.reportError2(CompileTimeErrorCode.CONST_FORMAL_PARAMETER, node, []);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the passed instance creation expression is not being invoked on an abstract
    * class.
    * @param node the instance creation expression to evaluate
    * @param typeName the [TypeName] of the [ConstructorName] from the[InstanceCreationExpression], this is the AST node that the error is attached to
    * @param type the type being constructed with this [InstanceCreationExpression]
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#CONST_WITH_ABSTRACT_CLASS
    * @see StaticWarningCode#NEW_WITH_ABSTRACT_CLASS
    */
   bool checkForConstOrNewWithAbstractClass(InstanceCreationExpression node, TypeName typeName, InterfaceType type) {
-    if (type.element.isAbstract()) {
+    if (type.element.isAbstract) {
       ConstructorElement element = node.element;
-      if (element != null && !element.isFactory()) {
+      if (element != null && !element.isFactory) {
         if (identical(((node.keyword as sc.KeywordToken)).keyword, sc.Keyword.CONST)) {
           _errorReporter.reportError2(StaticWarningCode.CONST_WITH_ABSTRACT_CLASS, typeName, []);
         } else {
           _errorReporter.reportError2(StaticWarningCode.NEW_WITH_ABSTRACT_CLASS, typeName, []);
         }
         return true;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed 'const' instance creation expression is not being invoked on a
    * constructor that is not 'const'.
    *
    * This method assumes that the instance creation was tested to be 'const' before being called.
    * @param node the instance creation expression to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CONST_WITH_NON_CONST
    */
   bool checkForConstWithNonConst(InstanceCreationExpression node) {
     ConstructorElement constructorElement = node.element;
-    if (constructorElement != null && !constructorElement.isConst()) {
+    if (constructorElement != null && !constructorElement.isConst) {
       _errorReporter.reportError2(CompileTimeErrorCode.CONST_WITH_NON_CONST, node, []);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the passed 'const' instance creation expression does not reference any type
    * parameters.
    *
@@ skipping 137 matching lines @@
     if (element is! ExportElement) {
       return false;
     }
     ExportElement exportElement = element as ExportElement;
     DartSdk sdk = _currentLibrary.context.sourceFactory.dartSdk;
     String uri = exportElement.uri;
     SdkLibrary sdkLibrary = sdk.getSdkLibrary(uri);
     if (sdkLibrary == null) {
       return false;
     }
-    if (!sdkLibrary.isInternal()) {
+    if (!sdkLibrary.isInternal) {
       return false;
     }
     _errorReporter.reportError2(CompileTimeErrorCode.EXPORT_INTERNAL_LIBRARY, node, [node.uri]);
     return true;
   }
 
   /**
    * This verifies that the passed extends clause does not extend classes such as num or String.
    * @param node the extends clause to test
    * @return `true` if and only if an error code is generated on the passed node
@@ skipping 10 matching lines @@
    * This verifies that the passed type name does not extend or implement classes such as 'num' or
    * 'String'.
    * @param node the type name to test
    * @return `true` if and only if an error code is generated on the passed node
    * @see #checkForExtendsDisallowedClass(ExtendsClause)
    * @see #checkForImplementsDisallowedClass(ImplementsClause)
    * @see CompileTimeErrorCode#EXTENDS_DISALLOWED_CLASS
    * @see CompileTimeErrorCode#IMPLEMENTS_DISALLOWED_CLASS
    */
   bool checkForExtendsOrImplementsDisallowedClass(TypeName typeName, ErrorCode errorCode) {
-    if (typeName.isSynthetic()) {
+    if (typeName.isSynthetic) {
       return false;
     }
     Type2 superType = typeName.type;
     for (InterfaceType disallowedType in _DISALLOWED_TYPES_TO_EXTEND_OR_IMPLEMENT) {
       if (superType != null && superType == disallowedType) {
         if (superType == _typeProvider.numType) {
           ASTNode grandParent = typeName.parent.parent;
           if (grandParent is ClassDeclaration) {
             ClassElement classElement = ((grandParent as ClassDeclaration)).element;
             Type2 classType = classElement.type;
@@ skipping 106 matching lines @@
 
   /**
    * This verifies that the passed variable declaration list has only initialized variables if the
    * list is final or const. This method is called by[checkForFinalNotInitialized],[visitTopLevelVariableDeclaration] and[visitVariableDeclarationStatement].
    * @param node the class declaration to test
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#FINAL_NOT_INITIALIZED
    */
   bool checkForFinalNotInitialized2(VariableDeclarationList node) {
     bool foundError = false;
-    if (!node.isSynthetic() && (node.isConst() || node.isFinal())) {
+    if (!node.isSynthetic && (node.isConst || node.isFinal)) {
       NodeList<VariableDeclaration> variables = node.variables;
       for (VariableDeclaration variable in variables) {
         if (variable.initializer == null) {
           _errorReporter.reportError2(StaticWarningCode.FINAL_NOT_INITIALIZED, variable, [variable.name.name]);
           foundError = true;
         }
       }
     }
     return foundError;
   }
@@ skipping 25 matching lines @@
    */
   bool checkForImplicitThisReferenceInInitializer(SimpleIdentifier node) {
     if (!_isInConstructorInitializer) {
       return false;
     }
     Element element = node.element;
     if (!(element is MethodElement || element is PropertyAccessorElement)) {
       return false;
     }
     ExecutableElement executableElement = element as ExecutableElement;
-    if (executableElement.isStatic()) {
+    if (executableElement.isStatic) {
       return false;
     }
     Element enclosingElement = element.enclosingElement;
     if (enclosingElement is! ClassElement) {
       return false;
     }
     ASTNode parent = node.parent;
     if (parent is MethodInvocation) {
       MethodInvocation invocation = parent as MethodInvocation;
       if (identical(invocation.methodName, node) && invocation.realTarget != null) {
@@ skipping 62 matching lines @@
     if (element is! ImportElement) {
       return false;
     }
     ImportElement importElement = element as ImportElement;
     DartSdk sdk = _currentLibrary.context.sourceFactory.dartSdk;
     String uri = importElement.uri;
     SdkLibrary sdkLibrary = sdk.getSdkLibrary(uri);
     if (sdkLibrary == null) {
       return false;
     }
-    if (!sdkLibrary.isInternal()) {
+    if (!sdkLibrary.isInternal) {
       return false;
     }
     _errorReporter.reportError2(CompileTimeErrorCode.IMPORT_INTERNAL_LIBRARY, node, [node.uri]);
     return true;
   }
 
   /**
    * This verifies that the passed switch statement case expressions all have the same type.
    * @param node the switch statement to evaluate
    * @return `true` if and only if an error code is generated on the passed node
@@ skipping 182 matching lines @@
     if (accessorElement is! PropertyAccessorElement) {
       return;
     }
     PropertyAccessorElement propertyAccessorElement = accessorElement as PropertyAccessorElement;
     counterpartAccessor = propertyAccessorElement.correspondingSetter;
     if (counterpartAccessor == null) {
       return;
     }
     Type2 getterType = null;
     Type2 setterType = null;
-    if (propertyAccessorElement.isGetter()) {
+    if (propertyAccessorElement.isGetter) {
       getterType = getGetterType(propertyAccessorElement);
       setterType = getSetterType(counterpartAccessor);
-    } else if (propertyAccessorElement.isSetter()) {
+    } else if (propertyAccessorElement.isSetter) {
       setterType = getSetterType(propertyAccessorElement);
       counterpartAccessor = propertyAccessorElement.correspondingGetter;
       getterType = getGetterType(counterpartAccessor);
     }
     if (setterType != null && getterType != null && !getterType.isAssignableTo(setterType)) {
       _errorReporter.reportError2(StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES, accessorDeclaration, [accessorTextName, setterType.displayName, getterType.displayName]);
     }
   }
 
   /**
    * This verifies that the passed mixin does not have an explicitly declared constructor.
    * @param mixinName the node to report problem on
    * @param mixinElement the mixing to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#MIXIN_DECLARES_CONSTRUCTOR
    */
   bool checkForMixinDeclaresConstructor(TypeName mixinName, ClassElement mixinElement) {
     for (ConstructorElement constructor in mixinElement.constructors) {
-      if (!constructor.isSynthetic() && !constructor.isFactory()) {
+      if (!constructor.isSynthetic && !constructor.isFactory) {
         _errorReporter.reportError2(CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR, mixinName, [mixinElement.name]);
         return true;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed mixin has the 'Object' superclass.
    * @param mixinName the node to report problem on
    * @param mixinElement the mixing to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#MIXIN_INHERITS_FROM_NOT_OBJECT
    */
   bool checkForMixinInheritsNotFromObject(TypeName mixinName, ClassElement mixinElement) {
     InterfaceType mixinSupertype = mixinElement.supertype;
     if (mixinSupertype != null) {
-      if (!mixinSupertype.isObject() || !mixinElement.isTypedef() && mixinElement.mixins.length != 0) {
+      if (!mixinSupertype.isObject || !mixinElement.isTypedef && mixinElement.mixins.length != 0) {
         _errorReporter.reportError2(CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT, mixinName, [mixinElement.name]);
         return true;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed mixin does not reference 'super'.
    * @param mixinName the node to report problem on
@@ skipping 73 matching lines @@
 
   /**
    * This checks that passed if the passed class declaration implicitly calls default constructor of
    * its superclass, there should be such default constructor - implicit or explicit.
    * @param node the [ClassDeclaration] to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT
    */
   bool checkForNoDefaultSuperConstructorImplicit(ClassDeclaration node) {
     List<ConstructorElement> constructors = _enclosingClass.constructors;
-    if (!constructors[0].isSynthetic()) {
+    if (!constructors[0].isSynthetic) {
       return false;
     }
     InterfaceType superType = _enclosingClass.supertype;
     if (superType == null) {
       return false;
     }
     ClassElement superClass = superType.element;
     if (superClass.hasDefaultConstructor()) {
       return false;
     }
     _errorReporter.reportError2(StaticWarningCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT, node.name, [superType.displayName]);
     return true;
   }
 
   /**
    * This checks that passed class declaration overrides all members required by its superclasses
    * and interfaces.
    * @param node the [ClassDeclaration] to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE
    * @see StaticWarningCode#NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO
    * @see StaticWarningCode#NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_THREE
    * @see StaticWarningCode#NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FOUR
    * @see StaticWarningCode#NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FIVE_PLUS
    */
   bool checkForNonAbstractClassInheritsAbstractMember(ClassDeclaration node) {
-    if (_enclosingClass.isAbstract()) {
+    if (_enclosingClass.isAbstract) {
       return false;
     }
     Set<ExecutableElement> missingOverrides = new Set<ExecutableElement>();
     Set<String> methodsInEnclosingClass = new Set<String>();
     Set<String> accessorsInEnclosingClass = new Set<String>();
     List<MethodElement> methods = _enclosingClass.methods;
     for (MethodElement method in methods) {
       javaSetAdd(methodsInEnclosingClass, method.name);
     }
     List<PropertyAccessorElement> accessors = _enclosingClass.accessors;
     for (PropertyAccessorElement accessor in accessors) {
       javaSetAdd(accessorsInEnclosingClass, accessor.name);
     }
     Map<String, ExecutableElement> membersInheritedFromSuperclasses = _inheritanceManager.getMapOfMembersInheritedFromClasses(_enclosingClass);
     for (MapEntry<String, ExecutableElement> entry in getMapEntrySet(membersInheritedFromSuperclasses)) {
       ExecutableElement executableElt = entry.getValue();
       if (executableElt is MethodElement) {
         MethodElement methodElt = executableElt as MethodElement;
-        if (methodElt.isAbstract()) {
+        if (methodElt.isAbstract) {
           String methodName = entry.getKey();
           if (!methodsInEnclosingClass.contains(methodName)) {
             javaSetAdd(missingOverrides, executableElt);
           }
         }
       } else if (executableElt is PropertyAccessorElement) {
         PropertyAccessorElement propertyAccessorElt = executableElt as PropertyAccessorElement;
-        if (propertyAccessorElt.isAbstract()) {
+        if (propertyAccessorElt.isAbstract) {
           String accessorName = entry.getKey();
           if (!accessorsInEnclosingClass.contains(accessorName)) {
             javaSetAdd(missingOverrides, executableElt);
           }
         }
       }
     }
     Map<String, ExecutableElement> membersInheritedFromInterfaces = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(_enclosingClass);
     for (MapEntry<String, ExecutableElement> entry in getMapEntrySet(membersInheritedFromInterfaces)) {
       ExecutableElement executableElt = entry.getValue();
       ExecutableElement elt = membersInheritedFromSuperclasses[executableElt.name];
       if (elt != null) {
-        if (elt is MethodElement && !((elt as MethodElement)).isAbstract()) {
+        if (elt is MethodElement && !((elt as MethodElement)).isAbstract) {
           continue;
-        } else if (elt is PropertyAccessorElement && !((elt as PropertyAccessorElement)).isAbstract()) {
+        } else if (elt is PropertyAccessorElement && !((elt as PropertyAccessorElement)).isAbstract) {
           continue;
         }
       }
       if (executableElt is MethodElement) {
         String methodName = entry.getKey();
         if (!methodsInEnclosingClass.contains(methodName)) {
           javaSetAdd(missingOverrides, executableElt);
         }
       } else if (executableElt is PropertyAccessorElement) {
         String accessorName = entry.getKey();
         if (!accessorsInEnclosingClass.contains(accessorName)) {
           javaSetAdd(missingOverrides, executableElt);
         }
       }
     }
     int missingOverridesSize = missingOverrides.length;
     if (missingOverridesSize == 0) {
       return false;
     }
     List<ExecutableElement> missingOverridesArray = new List.from(missingOverrides);
     List<String> stringTypeArray = new List<String>(Math.min(missingOverridesSize, 4));
     String GET = "get ";
     String SET = "set ";
     for (int i = 0; i < stringTypeArray.length; i++) {
       stringTypeArray[i] = StringUtilities.EMPTY;
       if (missingOverridesArray[i] is PropertyAccessorElement) {
-        stringTypeArray[i] = ((missingOverridesArray[i] as PropertyAccessorElement)).isGetter() ? GET : SET;
+        stringTypeArray[i] = ((missingOverridesArray[i] as PropertyAccessorElement)).isGetter ? GET : SET;
       }
     }
     AnalysisErrorWithProperties analysisError;
     if (missingOverridesSize == 1) {
       analysisError = _errorReporter.newErrorWithProperties(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE, node.name, [stringTypeArray[0], missingOverridesArray[0].enclosingElement.displayName, missingOverridesArray[0].displayName]);
     } else if (missingOverridesSize == 2) {
       analysisError = _errorReporter.newErrorWithProperties(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO, node.name, [stringTypeArray[0], missingOverridesArray[0].enclosingElement.displayName, missingOverridesArray[0].displayName, stringTypeArray[1], missingOverridesArray[1].enclosingElement.displayName, missingOverridesArray[1].displayName]);
     } else if (missingOverridesSize == 3) {
       analysisError = _errorReporter.newErrorWithProperties(StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_THREE, node.name, [stringTypeArray[0], missingOverridesArray[0].enclosingElement.displayName, missingOverridesArray[0].displayName, stringTypeArray[1], missingOverridesArray[1].enclosingElement.displayName, missingOverridesArray[1].displayName, stringTypeArray[2], missingOverridesArray[2].enclosingElement.displayName, missingOverridesArray[2].displayName]);
     } else if (missingOverridesSize == 4) {
@@ skipping 83 matching lines @@
    * @see StaticWarningCode#NON_VOID_RETURN_FOR_OPERATOR
    */
   bool checkForNonVoidReturnTypeForOperator(MethodDeclaration node) {
     SimpleIdentifier name = node.name;
     if (name.name != "[]=") {
       return false;
     }
     TypeName typeName = node.returnType;
     if (typeName != null) {
       Type2 type = typeName.type;
-      if (type != null && !type.isVoid()) {
+      if (type != null && !type.isVoid) {
         _errorReporter.reportError2(StaticWarningCode.NON_VOID_RETURN_FOR_OPERATOR, typeName, []);
       }
     }
     return false;
   }
 
   /**
    * This verifies the passed setter has no return type or the `void` return type.
    * @param typeName the type name to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#NON_VOID_RETURN_FOR_SETTER
    */
   bool checkForNonVoidReturnTypeForSetter(TypeName typeName) {
     if (typeName != null) {
       Type2 type = typeName.type;
-      if (type != null && !type.isVoid()) {
+      if (type != null && !type.isVoid) {
         _errorReporter.reportError2(StaticWarningCode.NON_VOID_RETURN_FOR_SETTER, typeName, []);
       }
     }
     return false;
   }
 
   /**
    * This verifies the passed operator-method declaration, does not have an optional parameter.
    *
    * This method assumes that the method declaration was tested to be an operator declaration before
    * being called.
    * @param node the method declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#OPTIONAL_PARAMETER_IN_OPERATOR
    */
   bool checkForOptionalParameterInOperator(MethodDeclaration node) {
     FormalParameterList parameterList = node.parameters;
     if (parameterList == null) {
       return false;
     }
     bool foundError = false;
     NodeList<FormalParameter> formalParameters = parameterList.parameters;
     for (FormalParameter formalParameter in formalParameters) {
-      if (formalParameter.kind.isOptional()) {
+      if (formalParameter.kind.isOptional) {
         _errorReporter.reportError2(CompileTimeErrorCode.OPTIONAL_PARAMETER_IN_OPERATOR, formalParameter, []);
         foundError = true;
       }
     }
     return foundError;
   }
 
   /**
    * This checks for named optional parameters that begin with '_'.
    * @param node the default formal parameter to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#PRIVATE_OPTIONAL_PARAMETER
    */
   bool checkForPrivateOptionalParameter(DefaultFormalParameter node) {
     sc.Token separator = node.separator;
     if (separator != null && separator.lexeme == ":") {
       NormalFormalParameter parameter = node.parameter;
       SimpleIdentifier name = parameter.identifier;
-      if (!name.isSynthetic() && name.name.startsWith("_")) {
+      if (!name.isSynthetic && name.name.startsWith("_")) {
         _errorReporter.reportError2(CompileTimeErrorCode.PRIVATE_OPTIONAL_PARAMETER, node, []);
         return true;
       }
     }
     return false;
   }
 
   /**
    * This checks if the passed constructor declaration is the redirecting generative constructor and
    * references itself directly or indirectly.
@@ skipping 74 matching lines @@
       }
     }
     for (int i = 1; i < list.length - 1; i++) {
       if (classElt == list[i]) {
         list.removeAt(list.length - 1);
         return false;
       }
     }
     List<ClassElement> interfaceElements;
     List<InterfaceType> interfaceTypes = classElt.interfaces;
-    if (supertype != null && !supertype.isObject()) {
+    if (supertype != null && !supertype.isObject) {
       interfaceElements = new List<ClassElement>(interfaceTypes.length + 1);
       interfaceElements[0] = supertype.element;
       for (int i = 0; i < interfaceTypes.length; i++) {
         interfaceElements[i + 1] = interfaceTypes[i].element;
       }
     } else {
       interfaceElements = new List<ClassElement>(interfaceTypes.length);
       for (int i = 0; i < interfaceTypes.length; i++) {
         interfaceElements[i] = interfaceTypes[i].element;
       }
@@ skipping 52 matching lines @@
    */
   bool checkForRedirectToNonConstConstructor(ConstructorDeclaration node) {
     ConstructorName redirectedConstructorNode = node.redirectedConstructor;
     if (redirectedConstructorNode == null) {
       return false;
     }
     ConstructorElement element = node.element;
     if (element == null) {
       return false;
     }
-    if (!element.isConst()) {
+    if (!element.isConst) {
       return false;
     }
     ConstructorElement redirectedConstructor = element.redirectedConstructor;
     if (redirectedConstructor == null) {
       return false;
     }
-    if (redirectedConstructor.isConst()) {
+    if (redirectedConstructor.isConst) {
       return false;
     }
     _errorReporter.reportError2(CompileTimeErrorCode.REDIRECT_TO_NON_CONST_CONSTRUCTOR, redirectedConstructorNode, []);
     return true;
   }
 
   /**
    * This checks if the passed identifier is banned because it is part of the variable declaration
    * with the same name.
    * @param node the identifier to evaluate
@@ skipping 59 matching lines @@
    * enclosing method or function.
    *
    * This method is called both by [checkForAllReturnStatementErrorCodes]and [visitExpressionFunctionBody].
    * @param returnExpression the returned expression to evaluate
    * @param expectedReturnType the expressed return type by the enclosing method or function
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#RETURN_OF_INVALID_TYPE
    */
   bool checkForReturnOfInvalidType(Expression returnExpression, Type2 expectedReturnType) {
     Type2 staticReturnType = getStaticType(returnExpression);
-    if (expectedReturnType.isVoid()) {
-      if (staticReturnType.isVoid() || staticReturnType.isDynamic() || identical(staticReturnType, BottomTypeImpl.instance)) {
+    if (expectedReturnType.isVoid) {
+      if (staticReturnType.isVoid || staticReturnType.isDynamic || identical(staticReturnType, BottomTypeImpl.instance)) {
         return false;
       }
       _errorReporter.reportError2(StaticTypeWarningCode.RETURN_OF_INVALID_TYPE, returnExpression, [staticReturnType.displayName, expectedReturnType.displayName, _enclosingFunction.displayName]);
       return true;
     }
     bool isStaticAssignable = staticReturnType.isAssignableTo(expectedReturnType);
     Type2 propagatedReturnType = getPropagatedType(returnExpression);
     if (_strictMode || propagatedReturnType == null) {
       if (isStaticAssignable) {
         return false;
@@ skipping 17 matching lines @@
    * @param name the accessed name to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#STATIC_ACCESS_TO_INSTANCE_MEMBER
    */
   bool checkForStaticAccessToInstanceMember(Expression target, SimpleIdentifier name2) {
     Element element = name2.element;
     if (element is! ExecutableElement) {
       return false;
     }
     ExecutableElement memberElement = element as ExecutableElement;
-    if (memberElement.isStatic()) {
+    if (memberElement.isStatic) {
       return false;
     }
     if (!isTypeReference(target)) {
       return false;
     }
     _errorReporter.reportError2(StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER, name2, [name2.name]);
     return true;
   }
 
   /**
@@ skipping 78 matching lines @@
     if (_enclosingClass == null) {
       return false;
     }
     InterfaceType superType = _enclosingClass.supertype;
     if (superType == null) {
       return false;
     }
     ClassElement superElement = superType.element;
     ConstructorElement superUnnamedConstructor = superElement.unnamedConstructor;
     if (superUnnamedConstructor != null) {
-      if (superUnnamedConstructor.isFactory()) {
+      if (superUnnamedConstructor.isFactory) {
         _errorReporter.reportError2(CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR, node.returnType, [superUnnamedConstructor]);
         return true;
       }
-      if (!superUnnamedConstructor.isDefaultConstructor()) {
+      if (!superUnnamedConstructor.isDefaultConstructor) {
         int offset;
         int length;
         {
           Identifier returnType = node.returnType;
           SimpleIdentifier name = node.name;
           offset = returnType.offset;
           length = (name != null ? name.end : returnType.end) - offset;
         }
         _errorReporter.reportError3(StaticWarningCode.NO_DEFAULT_SUPER_CONSTRUCTOR_EXPLICIT, offset, length, [superType.displayName]);
       }
@@ skipping 173 matching lines @@
       }
       if (n is ConstructorDeclaration) {
         ConstructorDeclaration constructor = n as ConstructorDeclaration;
         return constructor.factoryKeyword == null;
       }
       if (n is ConstructorFieldInitializer) {
         return false;
       }
       if (n is MethodDeclaration) {
         MethodDeclaration method = n as MethodDeclaration;
-        return !method.isStatic();
+        return !method.isStatic;
       }
     }
     return false;
   }
 }
 /**
  * This enum holds one of four states of a field initialization state through a constructor
  * signature, not initialized, initialized in the field declaration, initialized in the field
  * formal, and finally, initialized in the initializers list.
  */
@@ skipping 200 matching lines @@
     this._type = type;
     this._message = message;
   }
   ErrorSeverity get errorSeverity => _type.severity;
   String get message => _message;
   ErrorType get type => _type;
   int compareTo(ResolverErrorCode other) => ordinal - other.ordinal;
   int get hashCode => ordinal;
   String toString() => name;
 }