Reformat

pkg/analyzer/lib/src/generated/element_resolver.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library engine.resolver.element_resolver;
 
 import 'dart:collection';
 
 import 'ast.dart';
 import 'element.dart';
@@ skipping 126 matching lines @@
         String methodName = operatorType.lexeme;
         DartType staticType = _getStaticType(leftHandSide);
         MethodElement staticMethod =
             _lookUpMethod(leftHandSide, staticType, methodName);
         node.staticElement = staticMethod;
         DartType propagatedType = _getPropagatedType(leftHandSide);
         MethodElement propagatedMethod =
             _lookUpMethod(leftHandSide, propagatedType, methodName);
         node.propagatedElement = propagatedMethod;
         if (_shouldReportMissingMember(staticType, staticMethod)) {
-          _recordUndefinedToken(
-              staticType.element,
-              StaticTypeWarningCode.UNDEFINED_METHOD,
-              operator,
-              [methodName, staticType.displayName]);
+          _recordUndefinedToken(staticType.element,
+              StaticTypeWarningCode.UNDEFINED_METHOD, operator, [
+            methodName,
+            staticType.displayName
+          ]);
         } else if (_enableHints &&
             _shouldReportMissingMember(propagatedType, propagatedMethod) &&
-            !_memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
-          _recordUndefinedToken(
-              propagatedType.element,
-              HintCode.UNDEFINED_METHOD,
-              operator,
-              [methodName, propagatedType.displayName]);
+            !_memberFoundInSubclass(
+                propagatedType.element, methodName, true, false)) {
+          _recordUndefinedToken(propagatedType.element,
+              HintCode.UNDEFINED_METHOD, operator, [
+            methodName,
+            propagatedType.displayName
+          ]);
         }
       }
     }
     return null;
   }
 
   @override
   Object visitBinaryExpression(BinaryExpression node) {
     sc.Token operator = node.operator;
     if (operator.isUserDefinableOperator) {
@@ skipping 76 matching lines @@
           prefix.staticElement = element;
           // TODO(brianwilkerson) Report this error?
           element = _resolver.nameScope.lookup(identifier, _definingLibrary);
           name.staticElement = element;
           return null;
         }
         LibraryElement library = element.library;
         if (library == null) {
           // TODO(brianwilkerson) We need to understand how the library could
           // ever be null.
-          AnalysisEngine.instance.logger.logError(
-              "Found element with null library: ${element.name}");
+          AnalysisEngine.instance.logger
+              .logError("Found element with null library: ${element.name}");
         } else if (library != _definingLibrary) {
           // TODO(brianwilkerson) Report this error.
         }
         name.staticElement = element;
         if (node.newKeyword == null) {
           if (element is ClassElement) {
-            Element memberElement =
-                _lookupGetterOrMethod((element as ClassElement).type, name.name);
+            Element memberElement = _lookupGetterOrMethod(
+                (element as ClassElement).type, name.name);
             if (memberElement == null) {
               memberElement =
                   (element as ClassElement).getNamedConstructor(name.name);
               if (memberElement == null) {
-                memberElement =
-                    _lookUpSetter(prefix, (element as ClassElement).type, name.name);
+                memberElement = _lookUpSetter(
+                    prefix, (element as ClassElement).type, name.name);
               }
             }
             if (memberElement == null) {
 //              reportGetterOrSetterNotFound(prefixedIdentifier, name, element.getDisplayName());
             } else {
               name.staticElement = memberElement;
             }
           } else {
             // TODO(brianwilkerson) Report this error.
           }
@@ skipping 185 matching lines @@
     if (isInGetterContext && isInSetterContext) {
       // lookup setter
       MethodElement setterStaticMethod =
           _lookUpMethod(target, staticType, setterMethodName);
       MethodElement setterPropagatedMethod =
           _lookUpMethod(target, propagatedType, setterMethodName);
       // set setter element
       node.staticElement = setterStaticMethod;
       node.propagatedElement = setterPropagatedMethod;
       // generate undefined method warning
-      _checkForUndefinedIndexOperator(
-          node,
-          target,
-          getterMethodName,
-          setterStaticMethod,
-          setterPropagatedMethod,
-          staticType,
+      _checkForUndefinedIndexOperator(node, target, getterMethodName,
+          setterStaticMethod, setterPropagatedMethod, staticType,
           propagatedType);
       // lookup getter method
       MethodElement getterStaticMethod =
           _lookUpMethod(target, staticType, getterMethodName);
       MethodElement getterPropagatedMethod =
           _lookUpMethod(target, propagatedType, getterMethodName);
       // set getter element
       AuxiliaryElements auxiliaryElements =
           new AuxiliaryElements(getterStaticMethod, getterPropagatedMethod);
       node.auxiliaryElements = auxiliaryElements;
       // generate undefined method warning
-      _checkForUndefinedIndexOperator(
-          node,
-          target,
-          getterMethodName,
-          getterStaticMethod,
-          getterPropagatedMethod,
-          staticType,
+      _checkForUndefinedIndexOperator(node, target, getterMethodName,
+          getterStaticMethod, getterPropagatedMethod, staticType,
           propagatedType);
     } else if (isInGetterContext) {
       // lookup getter method
       MethodElement staticMethod =
           _lookUpMethod(target, staticType, getterMethodName);
       MethodElement propagatedMethod =
           _lookUpMethod(target, propagatedType, getterMethodName);
       // set getter element
       node.staticElement = staticMethod;
       node.propagatedElement = propagatedMethod;
       // generate undefined method warning
-      _checkForUndefinedIndexOperator(
-          node,
-          target,
-          getterMethodName,
-          staticMethod,
-          propagatedMethod,
-          staticType,
-          propagatedType);
+      _checkForUndefinedIndexOperator(node, target, getterMethodName,
+          staticMethod, propagatedMethod, staticType, propagatedType);
     } else if (isInSetterContext) {
       // lookup setter method
       MethodElement staticMethod =
           _lookUpMethod(target, staticType, setterMethodName);
       MethodElement propagatedMethod =
           _lookUpMethod(target, propagatedType, setterMethodName);
       // set setter element
       node.staticElement = staticMethod;
       node.propagatedElement = propagatedMethod;
       // generate undefined method warning
-      _checkForUndefinedIndexOperator(
-          node,
-          target,
-          setterMethodName,
-          staticMethod,
-          propagatedMethod,
-          staticType,
-          propagatedType);
+      _checkForUndefinedIndexOperator(node, target, setterMethodName,
+          staticMethod, propagatedMethod, staticType, propagatedType);
     }
     return null;
   }
 
   @override
   Object visitInstanceCreationExpression(InstanceCreationExpression node) {
     ConstructorElement invokedConstructor = node.constructorName.staticElement;
     node.staticElement = invokedConstructor;
     ArgumentList argumentList = node.argumentList;
-    List<ParameterElement> parameters =
-        _resolveArgumentsToFunction(node.isConst, argumentList, invokedConstructor);
+    List<ParameterElement> parameters = _resolveArgumentsToFunction(
+        node.isConst, argumentList, invokedConstructor);
     if (parameters != null) {
       argumentList.correspondingStaticParameters = parameters;
     }
     return null;
   }
 
   @override
   Object visitLibraryDirective(LibraryDirective node) {
     _setMetadata(node.element, node);
     return null;
@@ skipping 43 matching lines @@
       // then we don't call resolveInvokedElement(..) which walks up the class
       // hierarchy, instead we just look for the member in the type only.
       //
       ClassElementImpl typeReference = getTypeReference(target);
       if (typeReference != null) {
         staticElement =
             propagatedElement = _resolveElement(typeReference, methodName);
       } else {
         staticElement =
             _resolveInvokedElementWithTarget(target, staticType, methodName);
-        propagatedElement =
-            _resolveInvokedElementWithTarget(target, propagatedType, methodName);
+        propagatedElement = _resolveInvokedElementWithTarget(
+            target, propagatedType, methodName);
       }
     }
     staticElement = _convertSetterToGetter(staticElement);
     propagatedElement = _convertSetterToGetter(propagatedElement);
     //
     // Record the results.
     //
     methodName.staticElement = staticElement;
     methodName.propagatedElement = propagatedElement;
     ArgumentList argumentList = node.argumentList;
@@ skipping 17 matching lines @@
     ErrorCode errorCode = _checkForInvocationError(target, true, staticElement);
     bool generatedWithTypePropagation = false;
     if (_enableHints && errorCode == null && staticElement == null) {
       // The method lookup may have failed because there were multiple
       // incompatible choices. In this case we don't want to generate a hint.
       if (propagatedElement == null && propagatedType is UnionType) {
         // TODO(collinsn): an improvement here is to make the propagated type
         // of the method call the union of the propagated types of all possible
         // calls.
         if (_lookupMethods(
-            target,
-            propagatedType as UnionType,
-            methodName.name).length >
+                target, propagatedType as UnionType, methodName.name).length >
             1) {
           return null;
         }
       }
       errorCode = _checkForInvocationError(target, false, propagatedElement);
       if (identical(errorCode, StaticTypeWarningCode.UNDEFINED_METHOD)) {
         ClassElement classElementContext = null;
         if (target == null) {
           classElementContext = _resolver.enclosingClass;
         } else {
@@ skipping 14 matching lines @@
             }
           }
         }
       }
       generatedWithTypePropagation = true;
     }
     if (errorCode == null) {
       return null;
     }
     if (identical(
-        errorCode,
-        StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION)) {
+        errorCode, StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION)) {
       _resolver.reportErrorForNode(
-          StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION,
-          methodName,
-          [methodName.name]);
+          StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION, methodName, [
+        methodName.name
+      ]);
     } else if (identical(errorCode, StaticTypeWarningCode.UNDEFINED_FUNCTION)) {
-      _resolver.reportErrorForNode(
-          StaticTypeWarningCode.UNDEFINED_FUNCTION,
-          methodName,
-          [methodName.name]);
+      _resolver.reportErrorForNode(StaticTypeWarningCode.UNDEFINED_FUNCTION,
+          methodName, [methodName.name]);
     } else if (identical(errorCode, StaticTypeWarningCode.UNDEFINED_METHOD)) {
       String targetTypeName;
       if (target == null) {
         ClassElement enclosingClass = _resolver.enclosingClass;
         targetTypeName = enclosingClass.displayName;
-        ErrorCode proxyErrorCode = (generatedWithTypePropagation ?
-            HintCode.UNDEFINED_METHOD :
-            StaticTypeWarningCode.UNDEFINED_METHOD);
-        _recordUndefinedNode(
-            _resolver.enclosingClass,
-            proxyErrorCode,
-            methodName,
-            [methodName.name, targetTypeName]);
+        ErrorCode proxyErrorCode = (generatedWithTypePropagation
+            ? HintCode.UNDEFINED_METHOD
+            : StaticTypeWarningCode.UNDEFINED_METHOD);
+        _recordUndefinedNode(_resolver.enclosingClass, proxyErrorCode,
+            methodName, [methodName.name, targetTypeName]);
       } else {
         // ignore Function "call"
         // (if we are about to create a hint using type propagation,
         // then we can use type propagation here as well)
         DartType targetType = null;
         if (!generatedWithTypePropagation) {
           targetType = _getStaticType(target);
         } else {
           // choose the best type
           targetType = _getPropagatedType(target);
           if (targetType == null) {
             targetType = _getStaticType(target);
           }
         }
         if (targetType != null &&
             targetType.isDartCoreFunction &&
             methodName.name == FunctionElement.CALL_METHOD_NAME) {
           // TODO(brianwilkerson) Can we ever resolve the function being
           // invoked?
 //          resolveArgumentsToParameters(node.getArgumentList(), invokedFunction);
           return null;
         }
         targetTypeName = targetType == null ? null : targetType.displayName;
-        ErrorCode proxyErrorCode = (generatedWithTypePropagation ?
-            HintCode.UNDEFINED_METHOD :
-            StaticTypeWarningCode.UNDEFINED_METHOD);
-        _recordUndefinedNode(
-            targetType.element,
-            proxyErrorCode,
-            methodName,
-            [methodName.name, targetTypeName]);
+        ErrorCode proxyErrorCode = (generatedWithTypePropagation
+            ? HintCode.UNDEFINED_METHOD
+            : StaticTypeWarningCode.UNDEFINED_METHOD);
+        _recordUndefinedNode(targetType.element, proxyErrorCode,
+            methodName, [methodName.name, targetTypeName]);
       }
     } else if (identical(
-        errorCode,
-        StaticTypeWarningCode.UNDEFINED_SUPER_METHOD)) {
+        errorCode, StaticTypeWarningCode.UNDEFINED_SUPER_METHOD)) {
       // Generate the type name.
       // The error code will never be generated via type propagation
       DartType targetType = _getStaticType(target);
       if (targetType is InterfaceType && !targetType.isObject) {
         targetType = (targetType as InterfaceType).superclass;
       }
       String targetTypeName = targetType == null ? null : targetType.name;
-      _resolver.reportErrorForNode(
-          StaticTypeWarningCode.UNDEFINED_SUPER_METHOD,
-          methodName,
-          [methodName.name, targetTypeName]);
+      _resolver.reportErrorForNode(StaticTypeWarningCode.UNDEFINED_SUPER_METHOD,
+          methodName, [methodName.name, targetTypeName]);
     }
     return null;
   }
 
   @override
   Object visitPartDirective(PartDirective node) {
     _setMetadata(node.element, node);
     return null;
   }
 
   @override
   Object visitPartOfDirective(PartOfDirective node) {
     _setMetadata(node.element, node);
     return null;
   }
 
   @override
   Object visitPostfixExpression(PostfixExpression node) {
     Expression operand = node.operand;
     String methodName = _getPostfixOperator(node);
     DartType staticType = _getStaticType(operand);
     MethodElement staticMethod = _lookUpMethod(operand, staticType, methodName);
     node.staticElement = staticMethod;
     DartType propagatedType = _getPropagatedType(operand);
     MethodElement propagatedMethod =
         _lookUpMethod(operand, propagatedType, methodName);
     node.propagatedElement = propagatedMethod;
     if (_shouldReportMissingMember(staticType, staticMethod)) {
       if (operand is SuperExpression) {
-        _recordUndefinedToken(
-            staticType.element,
-            StaticTypeWarningCode.UNDEFINED_SUPER_OPERATOR,
-            node.operator,
-            [methodName, staticType.displayName]);
+        _recordUndefinedToken(staticType.element,
+            StaticTypeWarningCode.UNDEFINED_SUPER_OPERATOR, node.operator, [
+          methodName,
+          staticType.displayName
+        ]);
       } else {
-        _recordUndefinedToken(
-            staticType.element,
-            StaticTypeWarningCode.UNDEFINED_OPERATOR,
-            node.operator,
-            [methodName, staticType.displayName]);
+        _recordUndefinedToken(staticType.element,
+            StaticTypeWarningCode.UNDEFINED_OPERATOR, node.operator, [
+          methodName,
+          staticType.displayName
+        ]);
       }
     } else if (_enableHints &&
         _shouldReportMissingMember(propagatedType, propagatedMethod) &&
-        !_memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
-      _recordUndefinedToken(
-          propagatedType.element,
-          HintCode.UNDEFINED_OPERATOR,
-          node.operator,
-          [methodName, propagatedType.displayName]);
+        !_memberFoundInSubclass(
+            propagatedType.element, methodName, true, false)) {
+      _recordUndefinedToken(propagatedType.element, HintCode.UNDEFINED_OPERATOR,
+          node.operator, [methodName, propagatedType.displayName]);
     }
     return null;
   }
 
   @override
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
     SimpleIdentifier prefix = node.prefix;
     SimpleIdentifier identifier = node.identifier;
     //
     // First, check the "lib.loadLibrary" case
     //
     if (identifier.name == FunctionElement.LOAD_LIBRARY_NAME &&
         _isDeferredPrefix(prefix)) {
       LibraryElement importedLibrary = _getImportedLibrary(prefix);
       identifier.staticElement = importedLibrary.loadLibraryFunction;
       return null;
     }
     //
     // Check to see whether the prefix is really a prefix.
     //
     Element prefixElement = prefix.staticElement;
     if (prefixElement is PrefixElement) {
       Element element = _resolver.nameScope.lookup(node, _definingLibrary);
       if (element == null && identifier.inSetterContext()) {
         element = _resolver.nameScope.lookup(
-            new SyntheticIdentifier("${node.name}=", node),
-            _definingLibrary);
+            new SyntheticIdentifier("${node.name}=", node), _definingLibrary);
       }
       if (element == null) {
         if (identifier.inSetterContext()) {
-          _resolver.reportErrorForNode(
-              StaticWarningCode.UNDEFINED_SETTER,
-              identifier,
-              [identifier.name, prefixElement.name]);
+          _resolver.reportErrorForNode(StaticWarningCode.UNDEFINED_SETTER,
+              identifier, [identifier.name, prefixElement.name]);
         } else if (node.parent is Annotation) {
           Annotation annotation = node.parent as Annotation;
           _resolver.reportErrorForNode(
-              CompileTimeErrorCode.INVALID_ANNOTATION,
-              annotation);
+              CompileTimeErrorCode.INVALID_ANNOTATION, annotation);
           return null;
         } else {
-          _resolver.reportErrorForNode(
-              StaticWarningCode.UNDEFINED_GETTER,
-              identifier,
-              [identifier.name, prefixElement.name]);
+          _resolver.reportErrorForNode(StaticWarningCode.UNDEFINED_GETTER,
+              identifier, [identifier.name, prefixElement.name]);
         }
         return null;
       }
       if (element is PropertyAccessorElement && identifier.inSetterContext()) {
         PropertyInducingElement variable =
             (element as PropertyAccessorElement).variable;
         if (variable != null) {
           PropertyAccessorElement setter = variable.setter;
           if (setter != null) {
             element = setter;
@@ skipping 36 matching lines @@
       DartType staticType = _getStaticType(operand);
       MethodElement staticMethod =
           _lookUpMethod(operand, staticType, methodName);
       node.staticElement = staticMethod;
       DartType propagatedType = _getPropagatedType(operand);
       MethodElement propagatedMethod =
           _lookUpMethod(operand, propagatedType, methodName);
       node.propagatedElement = propagatedMethod;
       if (_shouldReportMissingMember(staticType, staticMethod)) {
         if (operand is SuperExpression) {
-          _recordUndefinedToken(
-              staticType.element,
-              StaticTypeWarningCode.UNDEFINED_SUPER_OPERATOR,
-              operator,
-              [methodName, staticType.displayName]);
+          _recordUndefinedToken(staticType.element,
+              StaticTypeWarningCode.UNDEFINED_SUPER_OPERATOR, operator, [
+            methodName,
+            staticType.displayName
+          ]);
         } else {
-          _recordUndefinedToken(
-              staticType.element,
-              StaticTypeWarningCode.UNDEFINED_OPERATOR,
-              operator,
-              [methodName, staticType.displayName]);
+          _recordUndefinedToken(staticType.element,
+              StaticTypeWarningCode.UNDEFINED_OPERATOR, operator, [
+            methodName,
+            staticType.displayName
+          ]);
         }
       } else if (_enableHints &&
           _shouldReportMissingMember(propagatedType, propagatedMethod) &&
-          !_memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
-        _recordUndefinedToken(
-            propagatedType.element,
-            HintCode.UNDEFINED_OPERATOR,
-            operator,
-            [methodName, propagatedType.displayName]);
+          !_memberFoundInSubclass(
+              propagatedType.element, methodName, true, false)) {
+        _recordUndefinedToken(propagatedType.element,
+            HintCode.UNDEFINED_OPERATOR, operator, [
+          methodName,
+          propagatedType.displayName
+        ]);
       }
     }
     return null;
   }
 
   @override
   Object visitPropertyAccess(PropertyAccess node) {
     Expression target = node.realTarget;
     if (target is SuperExpression && !_isSuperInValidContext(target)) {
       return null;
     }
     SimpleIdentifier propertyName = node.propertyName;
     _resolvePropertyAccess(target, propertyName);
     return null;
   }
 
   @override
-  Object
-      visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
+  Object visitRedirectingConstructorInvocation(
+      RedirectingConstructorInvocation node) {
     ClassElement enclosingClass = _resolver.enclosingClass;
     if (enclosingClass == null) {
       // TODO(brianwilkerson) Report this error.
       return null;
     }
     SimpleIdentifier name = node.constructorName;
     ConstructorElement element;
     if (name == null) {
       element = enclosingClass.unnamedConstructor;
     } else {
@@ skipping 48 matching lines @@
       return null;
     }
     //
     // Otherwise, the node should be resolved.
     //
     Element element = _resolveSimpleIdentifier(node);
     ClassElement enclosingClass = _resolver.enclosingClass;
     if (_isFactoryConstructorReturnType(node) &&
         !identical(element, enclosingClass)) {
       _resolver.reportErrorForNode(
-          CompileTimeErrorCode.INVALID_FACTORY_NAME_NOT_A_CLASS,
-          node);
+          CompileTimeErrorCode.INVALID_FACTORY_NAME_NOT_A_CLASS, node);
     } else if (_isConstructorReturnType(node) &&
         !identical(element, enclosingClass)) {
       _resolver.reportErrorForNode(
-          CompileTimeErrorCode.INVALID_CONSTRUCTOR_NAME,
-          node);
+          CompileTimeErrorCode.INVALID_CONSTRUCTOR_NAME, node);
       element = null;
     } else if (element == null ||
         (element is PrefixElement && !_isValidAsPrefix(node))) {
       // TODO(brianwilkerson) Recover from this error.
       if (_isConstructorReturnType(node)) {
         _resolver.reportErrorForNode(
-            CompileTimeErrorCode.INVALID_CONSTRUCTOR_NAME,
-            node);
+            CompileTimeErrorCode.INVALID_CONSTRUCTOR_NAME, node);
       } else if (node.parent is Annotation) {
         Annotation annotation = node.parent as Annotation;
         _resolver.reportErrorForNode(
-            CompileTimeErrorCode.INVALID_ANNOTATION,
-            annotation);
+            CompileTimeErrorCode.INVALID_ANNOTATION, annotation);
       } else {
-        _recordUndefinedNode(
-            _resolver.enclosingClass,
-            StaticWarningCode.UNDEFINED_IDENTIFIER,
-            node,
-            [node.name]);
+        _recordUndefinedNode(_resolver.enclosingClass,
+            StaticWarningCode.UNDEFINED_IDENTIFIER, node, [node.name]);
       }
     }
     node.staticElement = element;
     if (node.inSetterContext() &&
         node.inGetterContext() &&
         enclosingClass != null) {
       InterfaceType enclosingType = enclosingClass.type;
-      AuxiliaryElements auxiliaryElements =
-          new AuxiliaryElements(_lookUpGetter(null, enclosingType, node.name), null);
+      AuxiliaryElements auxiliaryElements = new AuxiliaryElements(
+          _lookUpGetter(null, enclosingType, node.name), null);
       node.auxiliaryElements = auxiliaryElements;
     }
     //
     // Validate annotation element.
     //
     if (node.parent is Annotation) {
       Annotation annotation = node.parent as Annotation;
       _resolveAnnotationElement(annotation);
     }
     return null;
@@ skipping 13 matching lines @@
     }
     SimpleIdentifier name = node.constructorName;
     String superName = name != null ? name.name : null;
     ConstructorElement element =
         superType.lookUpConstructor(superName, _definingLibrary);
     if (element == null ||
         (!enclosingClass.mixinErrorsReported &&
             !enclosingClass.isSuperConstructorAccessible(element))) {
       if (name != null) {
         _resolver.reportErrorForNode(
-            CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER,
-            node,
-            [superType.displayName, name]);
+            CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER, node, [
+          superType.displayName,
+          name
+        ]);
       } else {
         _resolver.reportErrorForNode(
             CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT,
-            node,
-            [superType.displayName]);
+            node, [superType.displayName]);
       }
       return null;
     } else {
       if (element.isFactory) {
         _resolver.reportErrorForNode(
-            CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR,
-            node,
-            [element]);
+            CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR, node, [element]);
       }
     }
     if (name != null) {
       name.staticElement = element;
     }
     node.staticElement = element;
     ArgumentList argumentList = node.argumentList;
-    List<ParameterElement> parameters =
-        _resolveArgumentsToFunction(isInConstConstructor, argumentList, element);
+    List<ParameterElement> parameters = _resolveArgumentsToFunction(
+        isInConstConstructor, argumentList, element);
     if (parameters != null) {
       argumentList.correspondingStaticParameters = parameters;
     }
     return null;
   }
 
   @override
   Object visitSuperExpression(SuperExpression node) {
     if (!_isSuperInValidContext(node)) {
       _resolver.reportErrorForNode(
-          CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT,
-          node);
+          CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT, node);
     }
     return super.visitSuperExpression(node);
   }
 
   @override
   Object visitTypeParameter(TypeParameter node) {
     _setMetadata(node.element, node);
     return null;
   }
 
@@ skipping 27 matching lines @@
 
   /**
    * Given that we have found code to invoke the given element, return the error code that should be
    * reported, or `null` if no error should be reported.
    *
    * @param target the target of the invocation, or `null` if there was no target
    * @param useStaticContext
    * @param element the element to be invoked
    * @return the error code that should be reported
    */
-  ErrorCode _checkForInvocationError(Expression target, bool useStaticContext,
-      Element element) {
+  ErrorCode _checkForInvocationError(
+      Expression target, bool useStaticContext, Element element) {
     // Prefix is not declared, instead "prefix.id" are declared.
     if (element is PrefixElement) {
       element = null;
     }
     if (element is PropertyAccessorElement) {
       //
       // This is really a function expression invocation.
       //
       // TODO(brianwilkerson) Consider the possibility of re-writing the AST.
       FunctionType getterType = element.type;
@@ skipping 71 matching lines @@
    * Check that the for some index expression that the method element was resolved, otherwise a
    * [StaticTypeWarningCode.UNDEFINED_OPERATOR] is generated.
    *
    * @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
    * @return `true` if and only if an error code is generated on the passed node
    */
   bool _checkForUndefinedIndexOperator(IndexExpression node, Expression target,
-      String methodName, MethodElement staticMethod, MethodElement propagatedMethod,
-      DartType staticType, DartType propagatedType) {
+      String methodName, MethodElement staticMethod,
+      MethodElement propagatedMethod, DartType staticType,
+      DartType propagatedType) {
     bool shouldReportMissingMember_static =
         _shouldReportMissingMember(staticType, staticMethod);
     bool shouldReportMissingMember_propagated =
         !shouldReportMissingMember_static &&
-        _enableHints &&
-        _shouldReportMissingMember(propagatedType, propagatedMethod) &&
-        !_memberFoundInSubclass(propagatedType.element, methodName, true, false);
+            _enableHints &&
+            _shouldReportMissingMember(propagatedType, propagatedMethod) &&
+            !_memberFoundInSubclass(
+                propagatedType.element, methodName, true, false);
     if (shouldReportMissingMember_static ||
         shouldReportMissingMember_propagated) {
       sc.Token leftBracket = node.leftBracket;
       sc.Token rightBracket = node.rightBracket;
       ErrorCode errorCode;
       if (shouldReportMissingMember_static) {
         if (target is SuperExpression) {
           errorCode = StaticTypeWarningCode.UNDEFINED_SUPER_OPERATOR;
         } else {
           errorCode = StaticTypeWarningCode.UNDEFINED_OPERATOR;
         }
       } else {
         errorCode = HintCode.UNDEFINED_OPERATOR;
       }
       DartType type =
           shouldReportMissingMember_static ? staticType : propagatedType;
       if (leftBracket == null || rightBracket == null) {
         _recordUndefinedNode(
-            type.element,
-            errorCode,
-            node,
-            [methodName, type.displayName]);
+            type.element, errorCode, node, [methodName, type.displayName]);
       } else {
         int offset = leftBracket.offset;
         int length = rightBracket.offset - offset + 1;
-        _recordUndefinedOffset(
-            type.element,
-            errorCode,
-            offset,
-            length,
-            [methodName, type.displayName]);
+        _recordUndefinedOffset(type.element, errorCode,
+            offset, length, [methodName, type.displayName]);
       }
       return true;
     }
     return false;
   }
 
   /**
    * Given a list of arguments and the element that will be invoked using those argument, compute
    * the list of parameters that correspond to the list of arguments. Return the parameters that
    * correspond to the arguments, or `null` if no correspondence could be computed.
    *
    * @param argumentList the list of arguments being passed to the element
    * @param executableElement the element that will be invoked with the arguments
    * @return the parameters that correspond to the arguments
    */
-  List<ParameterElement>
-      _computeCorrespondingParameters(ArgumentList argumentList, Element element) {
+  List<ParameterElement> _computeCorrespondingParameters(
+      ArgumentList argumentList, Element element) {
     if (element is PropertyAccessorElement) {
       //
       // This is an invocation of the call method defined on the value returned
       // by the getter.
       //
       FunctionType getterType = element.type;
       if (getterType != null) {
         DartType getterReturnType = getterType.returnType;
         if (getterReturnType is InterfaceType) {
           MethodElement callMethod = getterReturnType.lookUpMethod(
-              FunctionElement.CALL_METHOD_NAME,
-              _definingLibrary);
+              FunctionElement.CALL_METHOD_NAME, _definingLibrary);
           if (callMethod != null) {
             return _resolveArgumentsToFunction(false, argumentList, callMethod);
           }
         } else if (getterReturnType is FunctionType) {
           List<ParameterElement> parameters = getterReturnType.parameters;
           return _resolveArgumentsToParameters(false, argumentList, parameters);
         }
       }
     } else if (element is ExecutableElement) {
       return _resolveArgumentsToFunction(false, argumentList, element);
     } else if (element is VariableElement) {
       VariableElement variable = element;
       DartType type = _promoteManager.getStaticType(variable);
       if (type is FunctionType) {
         FunctionType functionType = type;
         List<ParameterElement> parameters = functionType.parameters;
         return _resolveArgumentsToParameters(false, argumentList, parameters);
       } else if (type is InterfaceType) {
         // "call" invocation
-        MethodElement callMethod =
-            type.lookUpMethod(FunctionElement.CALL_METHOD_NAME, _definingLibrary);
+        MethodElement callMethod = type.lookUpMethod(
+            FunctionElement.CALL_METHOD_NAME, _definingLibrary);
         if (callMethod != null) {
           List<ParameterElement> parameters = callMethod.parameters;
           return _resolveArgumentsToParameters(false, argumentList, parameters);
         }
       }
     }
     return null;
   }
 
   /**
@@ skipping 30 matching lines @@
    * @param identifier the identifier that might have been imported using a prefix
    * @return the element that was found
    */
   Element _findImportWithoutPrefix(SimpleIdentifier identifier) {
     Element element = null;
     Scope nameScope = _resolver.nameScope;
     for (ImportElement importElement in _definingLibrary.imports) {
       PrefixElement prefixElement = importElement.prefix;
       if (prefixElement != null) {
         Identifier prefixedIdentifier = new SyntheticIdentifier(
-            "${prefixElement.name}.${identifier.name}",
-            identifier);
+            "${prefixElement.name}.${identifier.name}", identifier);
         Element importedElement =
             nameScope.lookup(prefixedIdentifier, _definingLibrary);
         if (importedElement != null) {
           if (element == null) {
             element = importedElement;
           } else {
             element = MultiplyDefinedElementImpl.fromElements(
-                _definingLibrary.context,
-                element,
-                importedElement);
+                _definingLibrary.context, element, importedElement);
           }
         }
       }
     }
     return element;
   }
 
   /**
    * Assuming that the given expression is a prefix for a deferred import, return the library that
    * is being imported.
    *
    * @param expression the expression representing the deferred import's prefix
    * @return the library that is being imported by the import associated with the prefix
    */
   LibraryElement _getImportedLibrary(Expression expression) {
     PrefixElement prefixElement =
         (expression as SimpleIdentifier).staticElement as PrefixElement;
     List<ImportElement> imports =
         prefixElement.enclosingElement.getImportsWithPrefix(prefixElement);
     return imports[0].importedLibrary;
   }
 
   /**
    * Return the name of the method invoked by the given postfix expression.
    *
    * @param node the postfix expression being invoked
    * @return the name of the method invoked by the expression
    */
   String _getPostfixOperator(PostfixExpression node) =>
-      (node.operator.type == sc.TokenType.PLUS_PLUS) ?
-          sc.TokenType.PLUS.lexeme :
-          sc.TokenType.MINUS.lexeme;
+      (node.operator.type == sc.TokenType.PLUS_PLUS)
+          ? sc.TokenType.PLUS.lexeme
+          : sc.TokenType.MINUS.lexeme;
 
   /**
    * Return the name of the method invoked by the given postfix expression.
    *
    * @param node the postfix expression being invoked
    * @return the name of the method invoked by the expression
    */
   String _getPrefixOperator(PrefixExpression node) {
     sc.Token operator = node.operator;
     sc.TokenType operatorType = operator.type;
@@ skipping 86 matching lines @@
     } else if (type is InterfaceType) {
       ClassElement classElement = type.element;
       // 16078 from Gilad: If the type is a Functor with the @proxy annotation,
       // treat it as an executable type.
       // example code: NonErrorResolverTest.
       // test_invocationOfNonFunction_proxyOnFunctionClass()
       if (classElement.isProxy &&
           type.isSubtypeOf(_resolver.typeProvider.functionType)) {
         return true;
       }
-      MethodElement methodElement =
-          classElement.lookUpMethod(FunctionElement.CALL_METHOD_NAME, _definingLibrary);
+      MethodElement methodElement = classElement.lookUpMethod(
+          FunctionElement.CALL_METHOD_NAME, _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
@@ skipping 27 matching lines @@
     return false;
   }
 
   /**
    * Return the target of a break or continue statement, and update the static
    * element of its label (if any).  [parentNode] is the AST node of the break
    * or continue statement, [labelNode] is the label contained in that
    * statement (if any), and [isContinue] is true if the node being visited is
    * a continue statement.
    */
-  AstNode _lookupBreakOrContinueTarget(AstNode parentNode,
-      SimpleIdentifier labelNode, bool isContinue) {
+  AstNode _lookupBreakOrContinueTarget(
+      AstNode parentNode, SimpleIdentifier labelNode, bool isContinue) {
     if (labelNode == null) {
       return _resolver.implicitLabelScope.getTarget(isContinue);
     } else {
       LabelScope labelScope = _resolver.labelScope;
       if (labelScope == null) {
         // There are no labels in scope, so by definition the label is
         // undefined.
         _resolver.reportErrorForNode(
-            CompileTimeErrorCode.LABEL_UNDEFINED,
-            labelNode,
-            [labelNode.name]);
+            CompileTimeErrorCode.LABEL_UNDEFINED, labelNode, [labelNode.name]);
         return null;
       }
       LabelScope definingScope = labelScope.lookup(labelNode.name);
       if (definingScope == null) {
         // No definition of the given label name could be found in any
         // enclosing scope.
         _resolver.reportErrorForNode(
-            CompileTimeErrorCode.LABEL_UNDEFINED,
-            labelNode,
-            [labelNode.name]);
+            CompileTimeErrorCode.LABEL_UNDEFINED, labelNode, [labelNode.name]);
         return null;
       }
       // The target has been found.
       labelNode.staticElement = definingScope.element;
-      ExecutableElement labelContainer =
-          definingScope.element.getAncestor((element) => element is ExecutableElement);
+      ExecutableElement labelContainer = definingScope.element
+          .getAncestor((element) => element is ExecutableElement);
       if (!identical(labelContainer, _resolver.enclosingFunction)) {
-        _resolver.reportErrorForNode(
-            CompileTimeErrorCode.LABEL_IN_OUTER_SCOPE,
-            labelNode,
-            [labelNode.name]);
+        _resolver.reportErrorForNode(CompileTimeErrorCode.LABEL_IN_OUTER_SCOPE,
+            labelNode, [labelNode.name]);
       }
       return definingScope.node;
     }
   }
 
   /**
    * Look up the getter with the given name in the given type. Return the element representing the
    * getter that was found, or `null` if there is no getter with the given name.
    *
    * @param target the target of the invocation, or `null` if there is no target
    * @param type the type in which the getter is defined
    * @param getterName the name of the getter being looked up
    * @return the element representing the getter that was found
    */
-  PropertyAccessorElement _lookUpGetter(Expression target, DartType type,
-      String getterName) {
+  PropertyAccessorElement _lookUpGetter(
+      Expression target, DartType type, String getterName) {
     type = _resolveTypeParameter(type);
     if (type is InterfaceType) {
       InterfaceType interfaceType = type;
       PropertyAccessorElement accessor;
       if (target is SuperExpression) {
-        accessor =
-            interfaceType.lookUpGetterInSuperclass(getterName, _definingLibrary);
+        accessor = interfaceType.lookUpGetterInSuperclass(
+            getterName, _definingLibrary);
       } else {
         accessor = interfaceType.lookUpGetter(getterName, _definingLibrary);
       }
       if (accessor != null) {
         return accessor;
       }
       return _lookUpGetterInInterfaces(
-          interfaceType,
-          false,
-          getterName,
-          new HashSet<ClassElement>());
+          interfaceType, false, getterName, new HashSet<ClassElement>());
     }
     return null;
   }
 
   /**
    * Look up the getter with the given name in the interfaces implemented by the given type, either
    * directly or indirectly. Return the element representing the getter that was found, or
    * `null` if there is no getter with the given name.
    *
    * @param targetType the type in which the getter might be defined
@@ skipping 15 matching lines @@
       return null;
     }
     visitedInterfaces.add(targetClass);
     if (includeTargetType) {
       PropertyAccessorElement getter = targetType.getGetter(getterName);
       if (getter != null && getter.isAccessibleIn(_definingLibrary)) {
         return getter;
       }
     }
     for (InterfaceType interfaceType in targetType.interfaces) {
-      PropertyAccessorElement getter =
-          _lookUpGetterInInterfaces(interfaceType, true, getterName, visitedInterfaces);
+      PropertyAccessorElement getter = _lookUpGetterInInterfaces(
+          interfaceType, true, getterName, visitedInterfaces);
       if (getter != null) {
         return getter;
       }
     }
     for (InterfaceType mixinType in targetType.mixins.reversed) {
-      PropertyAccessorElement getter =
-          _lookUpGetterInInterfaces(mixinType, true, getterName, visitedInterfaces);
+      PropertyAccessorElement getter = _lookUpGetterInInterfaces(
+          mixinType, true, getterName, visitedInterfaces);
       if (getter != null) {
         return getter;
       }
     }
     InterfaceType superclass = targetType.superclass;
     if (superclass == null) {
       return null;
     }
     return _lookUpGetterInInterfaces(
-        superclass,
-        true,
-        getterName,
-        visitedInterfaces);
+        superclass, true, getterName, visitedInterfaces);
   }
 
   /**
    * Look up the method or getter with the given name in the given type. Return the element
    * representing the method or getter that was found, or `null` if there is no method or
    * getter with the given name.
    *
    * @param type the type in which the method or getter is defined
    * @param memberName the name of the method or getter being looked up
    * @return the element representing the method or getter that was found
    */
   ExecutableElement _lookupGetterOrMethod(DartType type, String memberName) {
     type = _resolveTypeParameter(type);
     if (type is InterfaceType) {
       InterfaceType interfaceType = type;
       ExecutableElement member =
           interfaceType.lookUpMethod(memberName, _definingLibrary);
       if (member != null) {
         return member;
       }
       member = interfaceType.lookUpGetter(memberName, _definingLibrary);
       if (member != null) {
         return member;
       }
       return _lookUpGetterOrMethodInInterfaces(
-          interfaceType,
-          false,
-          memberName,
-          new HashSet<ClassElement>());
+          interfaceType, false, memberName, new HashSet<ClassElement>());
     }
     return null;
   }
 
   /**
    * Look up the method or getter with the given name in the interfaces implemented by the given
    * type, either directly or indirectly. Return the element representing the method or getter that
    * was found, or `null` if there is no method or getter with the given name.
    *
    * @param targetType the type in which the method or getter might be defined
@@ skipping 20 matching lines @@
       if (member != null) {
         return member;
       }
       member = targetType.getGetter(memberName);
       if (member != null) {
         return member;
       }
     }
     for (InterfaceType interfaceType in targetType.interfaces) {
       ExecutableElement member = _lookUpGetterOrMethodInInterfaces(
-          interfaceType,
-          true,
-          memberName,
-          visitedInterfaces);
+          interfaceType, true, memberName, visitedInterfaces);
       if (member != null) {
         return member;
       }
     }
     for (InterfaceType mixinType in targetType.mixins.reversed) {
       ExecutableElement member = _lookUpGetterOrMethodInInterfaces(
-          mixinType,
-          true,
-          memberName,
-          visitedInterfaces);
+          mixinType, true, memberName, visitedInterfaces);
       if (member != null) {
         return member;
       }
     }
     InterfaceType superclass = targetType.superclass;
     if (superclass == null) {
       return null;
     }
     return _lookUpGetterOrMethodInInterfaces(
-        superclass,
-        true,
-        memberName,
-        visitedInterfaces);
+        superclass, true, memberName, visitedInterfaces);
   }
 
   /**
    * Look up the method with the given name in the given type. Return the element representing the
    * method that was found, or `null` if there is no method with the given name.
    *
    * @param target the target of the invocation, or `null` if there is no target
    * @param type the type in which the method is defined
    * @param methodName the name of the method being looked up
    * @return the element representing the method that was found
    */
-  MethodElement _lookUpMethod(Expression target, DartType type,
-      String methodName) {
+  MethodElement _lookUpMethod(
+      Expression target, DartType type, String methodName) {
     type = _resolveTypeParameter(type);
     if (type is InterfaceType) {
       InterfaceType interfaceType = type;
       MethodElement method;
       if (target is SuperExpression) {
-        method =
-            interfaceType.lookUpMethodInSuperclass(methodName, _definingLibrary);
+        method = interfaceType.lookUpMethodInSuperclass(
+            methodName, _definingLibrary);
       } else {
         method = interfaceType.lookUpMethod(methodName, _definingLibrary);
       }
       if (method != null) {
         return method;
       }
       return _lookUpMethodInInterfaces(
-          interfaceType,
-          false,
-          methodName,
-          new HashSet<ClassElement>());
+          interfaceType, false, methodName, new HashSet<ClassElement>());
     } else if (type is UnionType) {
       // TODO (collinsn): I want [computeMergedExecutableElement] to be general
       // and work with functions, methods, constructors, and property accessors.
       // However, I won't be able to assume it returns [MethodElement] here
       // then.
       return _maybeMergeExecutableElements(
           _lookupMethods(target, type, methodName)) as MethodElement;
     }
     return null;
   }
@@ skipping 22 matching lines @@
       return null;
     }
     visitedInterfaces.add(targetClass);
     if (includeTargetType) {
       MethodElement method = targetType.getMethod(methodName);
       if (method != null && method.isAccessibleIn(_definingLibrary)) {
         return method;
       }
     }
     for (InterfaceType interfaceType in targetType.interfaces) {
-      MethodElement method =
-          _lookUpMethodInInterfaces(interfaceType, true, methodName, visitedInterfaces);
+      MethodElement method = _lookUpMethodInInterfaces(
+          interfaceType, true, methodName, visitedInterfaces);
       if (method != null) {
         return method;
       }
     }
     for (InterfaceType mixinType in targetType.mixins.reversed) {
-      MethodElement method =
-          _lookUpMethodInInterfaces(mixinType, true, methodName, visitedInterfaces);
+      MethodElement method = _lookUpMethodInInterfaces(
+          mixinType, true, methodName, visitedInterfaces);
       if (method != null) {
         return method;
       }
     }
     InterfaceType superclass = targetType.superclass;
     if (superclass == null) {
       return null;
     }
     return _lookUpMethodInInterfaces(
-        superclass,
-        true,
-        methodName,
-        visitedInterfaces);
+        superclass, true, methodName, visitedInterfaces);
   }
 
   /**
    * Look up all methods of a given name defined on a union type.
    *
    * @param target
    * @param type
    * @param methodName
    * @return all methods named `methodName` defined on the union type `type`.
    */
-  Set<ExecutableElement> _lookupMethods(Expression target, UnionType type,
-      String methodName) {
+  Set<ExecutableElement> _lookupMethods(
+      Expression target, UnionType type, String methodName) {
     Set<ExecutableElement> methods = new HashSet<ExecutableElement>();
     bool allElementsHaveMethod = true;
     for (DartType t in type.elements) {
       MethodElement m = _lookUpMethod(target, t, methodName);
       if (m != null) {
         methods.add(m);
       } else {
         allElementsHaveMethod = false;
       }
     }
@@ skipping 12 matching lines @@
 
   /**
    * Look up the setter with the given name in the given type. Return the element representing the
    * setter that was found, or `null` if there is no setter with the given name.
    *
    * @param target the target of the invocation, or `null` if there is no target
    * @param type the type in which the setter is defined
    * @param setterName the name of the setter being looked up
    * @return the element representing the setter that was found
    */
-  PropertyAccessorElement _lookUpSetter(Expression target, DartType type,
-      String setterName) {
+  PropertyAccessorElement _lookUpSetter(
+      Expression target, DartType type, String setterName) {
     type = _resolveTypeParameter(type);
     if (type is InterfaceType) {
       InterfaceType interfaceType = type;
       PropertyAccessorElement accessor;
       if (target is SuperExpression) {
-        accessor =
-            interfaceType.lookUpSetterInSuperclass(setterName, _definingLibrary);
+        accessor = interfaceType.lookUpSetterInSuperclass(
+            setterName, _definingLibrary);
       } else {
         accessor = interfaceType.lookUpSetter(setterName, _definingLibrary);
       }
       if (accessor != null) {
         return accessor;
       }
       return _lookUpSetterInInterfaces(
-          interfaceType,
-          false,
-          setterName,
-          new HashSet<ClassElement>());
+          interfaceType, false, setterName, new HashSet<ClassElement>());
     }
     return null;
   }
 
   /**
    * Look up the setter with the given name in the interfaces implemented by the given type, either
    * directly or indirectly. Return the element representing the setter that was found, or
    * `null` if there is no setter with the given name.
    *
    * @param targetType the type in which the setter might be defined
@@ skipping 15 matching lines @@
       return null;
     }
     visitedInterfaces.add(targetClass);
     if (includeTargetType) {
       PropertyAccessorElement setter = targetType.getSetter(setterName);
       if (setter != null && setter.isAccessibleIn(_definingLibrary)) {
         return setter;
       }
     }
     for (InterfaceType interfaceType in targetType.interfaces) {
-      PropertyAccessorElement setter =
-          _lookUpSetterInInterfaces(interfaceType, true, setterName, visitedInterfaces);
+      PropertyAccessorElement setter = _lookUpSetterInInterfaces(
+          interfaceType, true, setterName, visitedInterfaces);
       if (setter != null) {
         return setter;
       }
     }
     for (InterfaceType mixinType in targetType.mixins.reversed) {
-      PropertyAccessorElement setter =
-          _lookUpSetterInInterfaces(mixinType, true, setterName, visitedInterfaces);
+      PropertyAccessorElement setter = _lookUpSetterInInterfaces(
+          mixinType, true, setterName, visitedInterfaces);
       if (setter != null) {
         return setter;
       }
     }
     InterfaceType superclass = targetType.superclass;
     if (superclass == null) {
       return null;
     }
     return _lookUpSetterInInterfaces(
-        superclass,
-        true,
-        setterName,
-        visitedInterfaces);
+        superclass, true, setterName, visitedInterfaces);
   }
 
   /**
    * Given some class element, this method uses [subtypeManager] to find the set of all
    * subtypes; the subtypes are then searched for a member (method, getter, or setter), that matches
    * a passed
    *
    * @param element the class element to search the subtypes of, if a non-ClassElement element is
    *          passed, then `false` is returned
    * @param memberName the member name to search for
    * @param asMethod `true` if the methods should be searched for in the subtypes
    * @param asAccessor `true` if the accessors (getters and setters) should be searched for in
    *          the subtypes
    * @return `true` if and only if the passed memberName was found in a subtype
    */
-  bool _memberFoundInSubclass(Element element, String memberName, bool asMethod,
-      bool asAccessor) {
+  bool _memberFoundInSubclass(
+      Element element, String memberName, bool asMethod, bool asAccessor) {
     if (element is ClassElement) {
       _subtypeManager.ensureLibraryVisited(_definingLibrary);
       HashSet<ClassElement> subtypeElements =
           _subtypeManager.computeAllSubtypes(element);
       for (ClassElement subtypeElement in subtypeElements) {
         if (asMethod && subtypeElement.getMethod(memberName) != null) {
           return true;
         } else if (asAccessor &&
             (subtypeElement.getGetter(memberName) != null ||
                 subtypeElement.getSetter(memberName) != null)) {
@@ skipping 87 matching lines @@
    * @param token the token which is undefined.
    * @param arguments arguments to the error message.
    */
   void _recordUndefinedToken(Element declaringElement, ErrorCode errorCode,
       sc.Token token, List<Object> arguments) {
     if (_doesntHaveProxy(declaringElement)) {
       _resolver.reportErrorForToken(errorCode, token, arguments);
     }
   }
 
-  void _resolveAnnotationConstructorInvocationArguments(Annotation annotation,
-      ConstructorElement constructor) {
+  void _resolveAnnotationConstructorInvocationArguments(
+      Annotation annotation, ConstructorElement constructor) {
     ArgumentList argumentList = annotation.arguments;
     // error will be reported in ConstantVerifier
     if (argumentList == null) {
       return;
     }
     // resolve arguments to parameters
     List<ParameterElement> parameters =
         _resolveArgumentsToFunction(true, argumentList, constructor);
     if (parameters != null) {
       argumentList.correspondingStaticParameters = parameters;
@@ skipping 27 matching lines @@
     if (nameNode1 != null && nameNode2 == null && nameNode3 == null) {
       Element element1 = nameNode1.staticElement;
       // CONST
       if (element1 is PropertyAccessorElement) {
         _resolveAnnotationElementGetter(annotation, element1);
         return;
       }
       // Class(args)
       if (element1 is ClassElement) {
         ClassElement classElement = element1;
-        constructor = new InterfaceTypeImpl.con1(
-            classElement).lookUpConstructor(null, _definingLibrary);
+        constructor = new InterfaceTypeImpl.con1(classElement)
+            .lookUpConstructor(null, _definingLibrary);
       }
     }
     //
     // prefix.CONST or prefix.Class() or Class.CONST or Class.constructor(args)
     //
     if (nameNode1 != null && nameNode2 != null && nameNode3 == null) {
       Element element1 = nameNode1.staticElement;
       Element element2 = nameNode2.staticElement;
       // Class.CONST - not resolved yet
       if (element1 is ClassElement) {
         ClassElement classElement = element1;
         element2 = classElement.lookUpGetter(nameNode2.name, _definingLibrary);
       }
       // prefix.CONST or Class.CONST
       if (element2 is PropertyAccessorElement) {
         nameNode2.staticElement = element2;
         annotation.element = element2;
         _resolveAnnotationElementGetter(
-            annotation,
-            element2 as PropertyAccessorElement);
+            annotation, element2 as PropertyAccessorElement);
         return;
       }
       // prefix.Class()
       if (element2 is ClassElement) {
         ClassElement classElement = element2 as ClassElement;
         constructor = classElement.unnamedConstructor;
       }
       // Class.constructor(args)
       if (element1 is ClassElement) {
         ClassElement classElement = element1;
-        constructor = new InterfaceTypeImpl.con1(
-            classElement).lookUpConstructor(nameNode2.name, _definingLibrary);
+        constructor = new InterfaceTypeImpl.con1(classElement)
+            .lookUpConstructor(nameNode2.name, _definingLibrary);
         nameNode2.staticElement = constructor;
       }
     }
     //
     // prefix.Class.CONST or prefix.Class.constructor(args)
     //
     if (nameNode1 != null && nameNode2 != null && nameNode3 != null) {
       Element element2 = nameNode2.staticElement;
       // element2 should be ClassElement
       if (element2 is ClassElement) {
         ClassElement classElement = element2;
         String name3 = nameNode3.name;
         // prefix.Class.CONST
         PropertyAccessorElement getter =
             classElement.lookUpGetter(name3, _definingLibrary);
         if (getter != null) {
           nameNode3.staticElement = getter;
           annotation.element = element2;
           _resolveAnnotationElementGetter(annotation, getter);
           return;
         }
         // prefix.Class.constructor(args)
-        constructor = new InterfaceTypeImpl.con1(
-            classElement).lookUpConstructor(name3, _definingLibrary);
+        constructor = new InterfaceTypeImpl.con1(classElement)
+            .lookUpConstructor(name3, _definingLibrary);
         nameNode3.staticElement = constructor;
       }
     }
     // we need constructor
     if (constructor == null) {
       _resolver.reportErrorForNode(
-          CompileTimeErrorCode.INVALID_ANNOTATION,
-          annotation);
+          CompileTimeErrorCode.INVALID_ANNOTATION, annotation);
       return;
     }
     // record element
     annotation.element = constructor;
     // resolve arguments
     _resolveAnnotationConstructorInvocationArguments(annotation, constructor);
   }
 
-  void _resolveAnnotationElementGetter(Annotation annotation,
-      PropertyAccessorElement accessorElement) {
+  void _resolveAnnotationElementGetter(
+      Annotation annotation, PropertyAccessorElement accessorElement) {
     // accessor should be synthetic
     if (!accessorElement.isSynthetic) {
       _resolver.reportErrorForNode(
-          CompileTimeErrorCode.INVALID_ANNOTATION,
-          annotation);
+          CompileTimeErrorCode.INVALID_ANNOTATION, annotation);
       return;
     }
     // variable should be constant
     VariableElement variableElement = accessorElement.variable;
     if (!variableElement.isConst) {
       _resolver.reportErrorForNode(
-          CompileTimeErrorCode.INVALID_ANNOTATION,
-          annotation);
+          CompileTimeErrorCode.INVALID_ANNOTATION, annotation);
     }
     // OK
     return;
   }
 
   /**
    * Given a list of arguments and the element that will be invoked using those argument, compute
    * the list of parameters that correspond to the list of arguments. Return the parameters that
    * correspond to the arguments, or `null` if no correspondence could be computed.
    *
@@ skipping 51 matching lines @@
     int positionalArgumentCount = 0;
     HashSet<String> usedNames = new HashSet<String>();
     bool noBlankArguments = true;
     for (int i = 0; i < argumentCount; i++) {
       Expression argument = arguments[i];
       if (argument is NamedExpression) {
         SimpleIdentifier nameNode = argument.name.label;
         String name = nameNode.name;
         ParameterElement element = namedParameters[name];
         if (element == null) {
-          ErrorCode errorCode = (reportError ?
-              CompileTimeErrorCode.UNDEFINED_NAMED_PARAMETER :
-              StaticWarningCode.UNDEFINED_NAMED_PARAMETER);
+          ErrorCode errorCode = (reportError
+              ? CompileTimeErrorCode.UNDEFINED_NAMED_PARAMETER
+              : StaticWarningCode.UNDEFINED_NAMED_PARAMETER);
           _resolver.reportErrorForNode(errorCode, nameNode, [name]);
         } else {
           resolvedParameters[i] = element;
           nameNode.staticElement = element;
         }
         if (!usedNames.add(name)) {
           _resolver.reportErrorForNode(
-              CompileTimeErrorCode.DUPLICATE_NAMED_ARGUMENT,
-              nameNode,
-              [name]);
+              CompileTimeErrorCode.DUPLICATE_NAMED_ARGUMENT, nameNode, [name]);
         }
       } else {
         if (argument is SimpleIdentifier && argument.name.isEmpty) {
           noBlankArguments = false;
         }
         positionalArgumentCount++;
         if (unnamedIndex < unnamedParameterCount) {
           resolvedParameters[i] = unnamedParameters[unnamedIndex++];
         }
       }
     }
     if (positionalArgumentCount < requiredParameters.length &&
         noBlankArguments) {
-      ErrorCode errorCode = (reportError ?
-          CompileTimeErrorCode.NOT_ENOUGH_REQUIRED_ARGUMENTS :
-          StaticWarningCode.NOT_ENOUGH_REQUIRED_ARGUMENTS);
-      _resolver.reportErrorForNode(
-          errorCode,
-          argumentList,
+      ErrorCode errorCode = (reportError
+          ? CompileTimeErrorCode.NOT_ENOUGH_REQUIRED_ARGUMENTS
+          : StaticWarningCode.NOT_ENOUGH_REQUIRED_ARGUMENTS);
+      _resolver.reportErrorForNode(errorCode, argumentList,
           [requiredParameters.length, positionalArgumentCount]);
     } else if (positionalArgumentCount > unnamedParameterCount &&
         noBlankArguments) {
-      ErrorCode errorCode = (reportError ?
-          CompileTimeErrorCode.EXTRA_POSITIONAL_ARGUMENTS :
-          StaticWarningCode.EXTRA_POSITIONAL_ARGUMENTS);
-      _resolver.reportErrorForNode(
-          errorCode,
-          argumentList,
+      ErrorCode errorCode = (reportError
+          ? CompileTimeErrorCode.EXTRA_POSITIONAL_ARGUMENTS
+          : StaticWarningCode.EXTRA_POSITIONAL_ARGUMENTS);
+      _resolver.reportErrorForNode(errorCode, argumentList,
           [unnamedParameterCount, positionalArgumentCount]);
     }
     return resolvedParameters;
   }
 
   void _resolveBinaryExpression(BinaryExpression node, String methodName) {
     Expression leftOperand = node.leftOperand;
     if (leftOperand != null) {
       DartType staticType = _getStaticType(leftOperand);
       MethodElement staticMethod =
           _lookUpMethod(leftOperand, staticType, methodName);
       node.staticElement = staticMethod;
       DartType propagatedType = _getPropagatedType(leftOperand);
       MethodElement propagatedMethod =
           _lookUpMethod(leftOperand, propagatedType, methodName);
       node.propagatedElement = propagatedMethod;
       if (_shouldReportMissingMember(staticType, staticMethod)) {
         if (leftOperand is SuperExpression) {
-          _recordUndefinedToken(
-              staticType.element,
-              StaticTypeWarningCode.UNDEFINED_SUPER_OPERATOR,
-              node.operator,
-              [methodName, staticType.displayName]);
+          _recordUndefinedToken(staticType.element,
+              StaticTypeWarningCode.UNDEFINED_SUPER_OPERATOR, node.operator, [
+            methodName,
+            staticType.displayName
+          ]);
         } else {
-          _recordUndefinedToken(
-              staticType.element,
-              StaticTypeWarningCode.UNDEFINED_OPERATOR,
-              node.operator,
-              [methodName, staticType.displayName]);
+          _recordUndefinedToken(staticType.element,
+              StaticTypeWarningCode.UNDEFINED_OPERATOR, node.operator, [
+            methodName,
+            staticType.displayName
+          ]);
         }
       } else if (_enableHints &&
           _shouldReportMissingMember(propagatedType, propagatedMethod) &&
-          !_memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
-        _recordUndefinedToken(
-            propagatedType.element,
-            HintCode.UNDEFINED_OPERATOR,
-            node.operator,
-            [methodName, propagatedType.displayName]);
+          !_memberFoundInSubclass(
+              propagatedType.element, methodName, true, false)) {
+        _recordUndefinedToken(propagatedType.element,
+            HintCode.UNDEFINED_OPERATOR, node.operator, [
+          methodName,
+          propagatedType.displayName
+        ]);
       }
     }
   }
 
   /**
    * Resolve the names in the given combinators in the scope of the given library.
    *
    * @param library the library that defines the names
    * @param combinators the combinators containing the names to be resolved
    */
-  void _resolveCombinators(LibraryElement library,
-      NodeList<Combinator> combinators) {
+  void _resolveCombinators(
+      LibraryElement library, NodeList<Combinator> combinators) {
     if (library == null) {
       //
       // The library will be null if the directive containing the combinators
       // has a URI that is not valid.
       //
       return;
     }
     Namespace namespace =
         new NamespaceBuilder().createExportNamespaceForLibrary(library);
     for (Combinator combinator in combinators) {
@@ skipping 18 matching lines @@
           name.staticElement = element;
         }
       }
     }
   }
 
   /**
    * Given that we are accessing a property of the given [classElement] with
    * the given [propertyName], return the element that represents the property.
    */
-  Element _resolveElement(ClassElementImpl classElement,
-      SimpleIdentifier propertyName) {
+  Element _resolveElement(
+      ClassElementImpl classElement, SimpleIdentifier propertyName) {
     String name = propertyName.name;
     Element element = null;
     if (propertyName.inSetterContext()) {
       element = classElement.getSetter(name);
     }
     if (element == null) {
       element = classElement.getGetter(name);
     }
     if (element == null) {
       element = classElement.getMethod(name);
@@ skipping 44 matching lines @@
    * Given an invocation of the form 'e.m(a1, ..., an)', resolve 'e.m' to the element being invoked.
    * If the returned element is a method, then the method will be invoked. If the returned element
    * is a getter, the getter will be invoked without arguments and the result of that invocation
    * will then be invoked with the arguments.
    *
    * @param target the target of the invocation ('e')
    * @param targetType the type of the target
    * @param methodName the name of the method being invoked ('m')
    * @return the element being invoked
    */
-  Element _resolveInvokedElementWithTarget(Expression target,
-      DartType targetType, SimpleIdentifier methodName) {
+  Element _resolveInvokedElementWithTarget(
+      Expression target, DartType targetType, SimpleIdentifier methodName) {
     if (targetType is InterfaceType || targetType is UnionType) {
       Element element = _lookUpMethod(target, targetType, methodName.name);
       if (element == null) {
         //
         // If there's no method, then it's possible that 'm' is a getter that
         // returns a function.
         //
         // TODO (collinsn): need to add union type support here too, in the
         // style of [lookUpMethod].
         element = _lookUpGetter(target, targetType, methodName.name);
@@ skipping 25 matching lines @@
 
   /**
    * Given that we are accessing a property of the given type with the given name, return the
    * element that represents the property.
    *
    * @param target the target of the invocation ('e')
    * @param targetType the type in which the search for the property should begin
    * @param propertyName the name of the property being accessed
    * @return the element that represents the property
    */
-  ExecutableElement _resolveProperty(Expression target, DartType targetType,
-      SimpleIdentifier propertyName) {
+  ExecutableElement _resolveProperty(
+      Expression target, DartType targetType, SimpleIdentifier propertyName) {
     ExecutableElement memberElement = null;
     if (propertyName.inSetterContext()) {
       memberElement = _lookUpSetter(target, targetType, propertyName.name);
     }
     if (memberElement == null) {
       memberElement = _lookUpGetter(target, targetType, propertyName.name);
     }
     if (memberElement == null) {
       memberElement = _lookUpMethod(target, targetType, propertyName.name);
     }
     return memberElement;
   }
 
-  void _resolvePropertyAccess(Expression target,
-      SimpleIdentifier propertyName) {
+  void _resolvePropertyAccess(
+      Expression target, SimpleIdentifier propertyName) {
     DartType staticType = _getStaticType(target);
     DartType propagatedType = _getPropagatedType(target);
     Element staticElement = null;
     Element propagatedElement = null;
     //
     // If this property access is of the form 'C.m' where 'C' is a class,
     // then we don't call resolveProperty(..) which walks up the class
     // hierarchy, instead we just look for the member in the type only.
     //
     ClassElementImpl typeReference = getTypeReference(target);
@@ skipping 14 matching lines @@
         propertyName.staticElement = staticElement;
       }
       return;
     }
     propertyName.staticElement = staticElement;
     propertyName.propagatedElement = propagatedElement;
     bool shouldReportMissingMember_static =
         _shouldReportMissingMember(staticType, staticElement);
     bool shouldReportMissingMember_propagated =
         !shouldReportMissingMember_static &&
-        _enableHints &&
-        _shouldReportMissingMember(propagatedType, propagatedElement) &&
-        !_memberFoundInSubclass(propagatedType.element, propertyName.name, false, true);
+            _enableHints &&
+            _shouldReportMissingMember(propagatedType, propagatedElement) &&
+            !_memberFoundInSubclass(
+                propagatedType.element, propertyName.name, false, true);
     // TODO(collinsn): add support for errors on union types by extending
     // [lookupGetter] and [lookupSetter] in analogy with the earlier
     // [lookupMethod] extensions.
     if (propagatedType is UnionType) {
       shouldReportMissingMember_propagated = false;
     }
     if (shouldReportMissingMember_static ||
         shouldReportMissingMember_propagated) {
       DartType staticOrPropagatedType =
           shouldReportMissingMember_static ? staticType : propagatedType;
       Element staticOrPropagatedEnclosingElt = staticOrPropagatedType.element;
       bool isStaticProperty = _isStatic(staticOrPropagatedEnclosingElt);
-      DartType displayType = staticOrPropagatedType != null ?
-          staticOrPropagatedType :
-          propagatedType != null ? propagatedType : staticType;
+      DartType displayType = staticOrPropagatedType != null
+          ? staticOrPropagatedType
+          : propagatedType != null ? propagatedType : staticType;
       // Special getter cases.
       if (propertyName.inGetterContext()) {
         if (!isStaticProperty &&
             staticOrPropagatedEnclosingElt is ClassElement) {
           ClassElement classElement = staticOrPropagatedEnclosingElt;
           InterfaceType targetType = classElement.type;
           if (targetType != null &&
               targetType.isDartCoreFunction &&
               propertyName.name == FunctionElement.CALL_METHOD_NAME) {
             // TODO(brianwilkerson) Can we ever resolve the function being
             // invoked?
 //            resolveArgumentsToParameters(node.getArgumentList(), invokedFunction);
             return;
           } else if (classElement.isEnum && propertyName.name == "_name") {
             _resolver.reportErrorForNode(
-                CompileTimeErrorCode.ACCESS_PRIVATE_ENUM_FIELD,
-                propertyName,
-                [propertyName.name]);
+                CompileTimeErrorCode.ACCESS_PRIVATE_ENUM_FIELD, propertyName, [
+              propertyName.name
+            ]);
             return;
           }
         }
       }
       Element declaringElement =
           staticType.isVoid ? null : staticOrPropagatedEnclosingElt;
       if (propertyName.inSetterContext()) {
         ErrorCode errorCode;
         if (shouldReportMissingMember_static) {
           if (target is SuperExpression) {
             if (isStaticProperty && !staticType.isVoid) {
               errorCode = StaticWarningCode.UNDEFINED_SUPER_SETTER;
             } else {
               errorCode = StaticTypeWarningCode.UNDEFINED_SUPER_SETTER;
             }
           } else {
             if (isStaticProperty && !staticType.isVoid) {
               errorCode = StaticWarningCode.UNDEFINED_SETTER;
             } else {
               errorCode = StaticTypeWarningCode.UNDEFINED_SETTER;
             }
           }
         } else {
           errorCode = HintCode.UNDEFINED_SETTER;
         }
-        _recordUndefinedNode(
-            declaringElement,
-            errorCode,
-            propertyName,
-            [propertyName.name, displayType.displayName]);
+        _recordUndefinedNode(declaringElement, errorCode, propertyName, [
+          propertyName.name,
+          displayType.displayName
+        ]);
       } else if (propertyName.inGetterContext()) {
         ErrorCode errorCode;
         if (shouldReportMissingMember_static) {
           if (target is SuperExpression) {
             if (isStaticProperty && !staticType.isVoid) {
               errorCode = StaticWarningCode.UNDEFINED_SUPER_GETTER;
             } else {
               errorCode = StaticTypeWarningCode.UNDEFINED_SUPER_GETTER;
             }
           } else {
             if (isStaticProperty && !staticType.isVoid) {
               errorCode = StaticWarningCode.UNDEFINED_GETTER;
             } else {
               errorCode = StaticTypeWarningCode.UNDEFINED_GETTER;
             }
           }
         } else {
           errorCode = HintCode.UNDEFINED_GETTER;
         }
-        _recordUndefinedNode(
-            declaringElement,
-            errorCode,
-            propertyName,
-            [propertyName.name, displayType.displayName]);
+        _recordUndefinedNode(declaringElement, errorCode, propertyName, [
+          propertyName.name,
+          displayType.displayName
+        ]);
       } else {
-        _recordUndefinedNode(
-            declaringElement,
-            StaticWarningCode.UNDEFINED_IDENTIFIER,
-            propertyName,
-            [propertyName.name]);
+        _recordUndefinedNode(declaringElement,
+            StaticWarningCode.UNDEFINED_IDENTIFIER, propertyName, [
+          propertyName.name
+        ]);
       }
     }
   }
 
   /**
    * Resolve the given simple identifier if possible. Return the element to which it could be
    * resolved, or `null` if it could not be resolved. This does not record the results of the
    * resolution.
    *
    * @param node the identifier to be resolved
@@ skipping 16 matching lines @@
             setter = _lookUpSetter(null, enclosingClass.type, node.name);
           }
         }
         if (setter != null) {
           element = setter;
         }
       }
     } else if (element == null &&
         (node.inSetterContext() || node.parent is CommentReference)) {
       element = _resolver.nameScope.lookup(
-          new SyntheticIdentifier("${node.name}=", node),
-          _definingLibrary);
+          new SyntheticIdentifier("${node.name}=", node), _definingLibrary);
     }
     ClassElement enclosingClass = _resolver.enclosingClass;
     if (element == null && enclosingClass != null) {
       InterfaceType enclosingType = enclosingClass.type;
       if (element == null &&
           (node.inSetterContext() || node.parent is CommentReference)) {
         element = _lookUpSetter(null, enclosingType, node.name);
       }
       if (element == null && node.inGetterContext()) {
         element = _lookUpGetter(null, enclosingType, node.name);
@@ skipping 107 matching lines @@
     }
     return null;
   }
 
   /**
    * Helper function for `maybeMergeExecutableElements` that does the actual merging.
    *
    * @param elementArrayToMerge non-empty array of elements to merge.
    * @return
    */
-  static ExecutableElement
-      _computeMergedExecutableElement(List<ExecutableElement> elementArrayToMerge) {
+  static ExecutableElement _computeMergedExecutableElement(
+      List<ExecutableElement> elementArrayToMerge) {
     // Flatten methods structurally. Based on
     // [InheritanceManager.computeMergedExecutableElement] and
     // [InheritanceManager.createSyntheticExecutableElement].
     //
     // However, the approach we take here is much simpler, but expected to work
     // well in the common case. It degrades gracefully in the uncommon case,
     // by computing the type [dynamic] for the method, preventing any
     // hints from being generated (TODO: not done yet).
     //
     // The approach is: we require that each [ExecutableElement] has the
@@ skipping 110 matching lines @@
   }
 
   /**
    * Return a method representing the merge of the given elements. The type of the merged element is
    * the component-wise union of the types of the given elements. If not all input elements have the
    * same shape then [null] is returned.
    *
    * @param elements the `ExecutableElement`s to merge
    * @return an `ExecutableElement` representing the merge of `elements`
    */
-  static ExecutableElement
-      _maybeMergeExecutableElements(Set<ExecutableElement> elements) {
+  static ExecutableElement _maybeMergeExecutableElements(
+      Set<ExecutableElement> elements) {
     List<ExecutableElement> elementArrayToMerge = new List.from(elements);
     if (elementArrayToMerge.length == 0) {
       return null;
     } else if (elementArrayToMerge.length == 1) {
       // If all methods are equal, don't bother building a new one.
       return elementArrayToMerge[0];
     } else {
       return _computeMergedExecutableElement(elementArrayToMerge);
     }
   }
@@ skipping 52 matching lines @@
   @override
   Element get propagatedElement => null;
 
   @override
   Element get staticElement => null;
 
   @override
   accept(AstVisitor visitor) => null;
 
   @override
-  void visitChildren(AstVisitor visitor) {
-  }
+  void visitChildren(AstVisitor visitor) {}
 }