Reformat

pkg/analyzer/lib/src/generated/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;
 
 import "dart:math" as math;
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/utilities_collection.dart';
@@ skipping 17 matching lines @@
 /**
  * Callback signature used by ImplicitConstructorBuilder to register
  * computations to be performed, and their dependencies.  A call to this
  * callback indicates that [computation] may be used to compute implicit
  * constructors for [classElement], but that the computation may not be invoked
  * until after implicit constructors have been built for [superclassElement].
  */
 typedef void ImplicitConstructorBuilderCallback(ClassElement classElement,
     ClassElement superclassElement, void computation());
 
-typedef ResolverVisitor ResolverVisitorFactory(Library library, Source source,
-    TypeProvider typeProvider);
+typedef ResolverVisitor ResolverVisitorFactory(
+    Library library, Source source, TypeProvider typeProvider);
 
 typedef StaticTypeAnalyzer StaticTypeAnalyzerFactory(ResolverVisitor visitor);
 
-typedef TypeResolverVisitor TypeResolverVisitorFactory(Library library,
-    Source source, TypeProvider typeProvider);
+typedef TypeResolverVisitor TypeResolverVisitorFactory(
+    Library library, Source source, TypeProvider typeProvider);
 
 typedef void VoidFunction();
 
 /**
  * Instances of the class `BestPracticesVerifier` traverse an AST structure looking for
  * violations of Dart best practices.
  */
 class BestPracticesVerifier extends RecursiveAstVisitor<Object> {
 //  static String _HASHCODE_GETTER_NAME = "hashCode";
 
@@ skipping 126 matching lines @@
     return super.visitPostfixExpression(node);
   }
 
   @override
   Object visitPrefixExpression(PrefixExpression node) {
     _checkForDeprecatedMemberUse(node.bestElement, node);
     return super.visitPrefixExpression(node);
   }
 
   @override
-  Object
-      visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
+  Object visitRedirectingConstructorInvocation(
+      RedirectingConstructorInvocation node) {
     _checkForDeprecatedMemberUse(node.staticElement, node);
     return super.visitRedirectingConstructorInvocation(node);
   }
 
   @override
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     _checkForDeprecatedMemberUseAtIdentifier(node);
     return super.visitSimpleIdentifier(node);
   }
 
@@ skipping 27 matching lines @@
     DartType rhsType = typeName.type;
     if (lhsType == null || rhsType == null) {
       return false;
     }
     String rhsNameStr = typeName.name.name;
     // if x is dynamic
     if (rhsType.isDynamic && rhsNameStr == sc.Keyword.DYNAMIC.syntax) {
       if (node.notOperator == null) {
         // the is case
         _errorReporter.reportErrorForNode(
-            HintCode.UNNECESSARY_TYPE_CHECK_TRUE,
-            node);
+            HintCode.UNNECESSARY_TYPE_CHECK_TRUE, node);
       } else {
         // the is not case
-        _errorReporter.reportErrorForNode(
-            HintCode.UNNECESSARY_TYPE_CHECK_FALSE,
-            node);
+        _errorReporter
+            .reportErrorForNode(HintCode.UNNECESSARY_TYPE_CHECK_FALSE, node);
       }
       return true;
     }
     Element rhsElement = rhsType.element;
     LibraryElement libraryElement =
         rhsElement != null ? rhsElement.library : null;
     if (libraryElement != null && libraryElement.isDartCore) {
       // if x is Object or null is Null
       if (rhsType.isObject ||
           (expression is NullLiteral && rhsNameStr == _NULL_TYPE_NAME)) {
         if (node.notOperator == null) {
           // the is case
           _errorReporter.reportErrorForNode(
-              HintCode.UNNECESSARY_TYPE_CHECK_TRUE,
-              node);
+              HintCode.UNNECESSARY_TYPE_CHECK_TRUE, node);
         } else {
           // the is not case
-          _errorReporter.reportErrorForNode(
-              HintCode.UNNECESSARY_TYPE_CHECK_FALSE,
-              node);
+          _errorReporter
+              .reportErrorForNode(HintCode.UNNECESSARY_TYPE_CHECK_FALSE, node);
         }
         return true;
       } else if (rhsNameStr == _NULL_TYPE_NAME) {
         if (node.notOperator == null) {
           // the is case
           _errorReporter.reportErrorForNode(HintCode.TYPE_CHECK_IS_NULL, node);
         } else {
           // the is not case
-          _errorReporter.reportErrorForNode(
-              HintCode.TYPE_CHECK_IS_NOT_NULL,
-              node);
+          _errorReporter
+              .reportErrorForNode(HintCode.TYPE_CHECK_IS_NOT_NULL, node);
         }
         return true;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed expression can be assigned to its corresponding parameters.
    *
@@ skipping 22 matching lines @@
       if (!actualStaticType.isAssignableTo(expectedStaticType)) {
         // A warning was created in the ErrorVerifier, return false, don't
         // create a hint when a warning has already been created.
         return false;
       }
     }
     //
     // Hint case: test propagated type information
     //
     // Compute the best types to use.
-    DartType expectedBestType =
-        expectedPropagatedType != null ? expectedPropagatedType : expectedStaticType;
+    DartType expectedBestType = expectedPropagatedType != null
+        ? expectedPropagatedType
+        : expectedStaticType;
     DartType actualBestType =
         actualPropagatedType != null ? actualPropagatedType : actualStaticType;
     if (actualBestType != null && expectedBestType != null) {
       if (!actualBestType.isAssignableTo(expectedBestType)) {
         _errorReporter.reportTypeErrorForNode(
-            hintCode,
-            expression,
-            [actualBestType, expectedBestType]);
+            hintCode, expression, [actualBestType, expectedBestType]);
         return true;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed argument can be assigned to its corresponding parameter.
    *
    * This method corresponds to ErrorCode.checkForArgumentTypeNotAssignableForArgument.
    *
    * @param argument the argument to evaluate
    * @return `true` if and only if an hint code is generated on the passed node
    * See [HintCode.ARGUMENT_TYPE_NOT_ASSIGNABLE].
    */
   bool _checkForArgumentTypeNotAssignableForArgument(Expression argument) {
     if (argument == null) {
       return false;
     }
     ParameterElement staticParameterElement = argument.staticParameterElement;
     DartType staticParameterType =
         staticParameterElement == null ? null : staticParameterElement.type;
     ParameterElement propagatedParameterElement =
         argument.propagatedParameterElement;
-    DartType propagatedParameterType =
-        propagatedParameterElement == null ? null : propagatedParameterElement.type;
-    return _checkForArgumentTypeNotAssignableWithExpectedTypes(
-        argument,
-        staticParameterType,
-        propagatedParameterType,
+    DartType propagatedParameterType = propagatedParameterElement == null
+        ? null
+        : propagatedParameterElement.type;
+    return _checkForArgumentTypeNotAssignableWithExpectedTypes(argument,
+        staticParameterType, propagatedParameterType,
         HintCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
   }
 
   /**
    * This verifies that the passed expression can be assigned to its corresponding parameters.
    *
    * This method corresponds to ErrorCode.checkForArgumentTypeNotAssignableWithExpectedTypes.
    *
    * @param expression the expression to evaluate
    * @param expectedStaticType the expected static type
    * @param expectedPropagatedType the expected propagated type, may be `null`
    * @return `true` if and only if an hint code is generated on the passed node
    * See [HintCode.ARGUMENT_TYPE_NOT_ASSIGNABLE].
    */
-  bool
-      _checkForArgumentTypeNotAssignableWithExpectedTypes(Expression expression,
-      DartType expectedStaticType, DartType expectedPropagatedType,
-      ErrorCode errorCode) =>
-      _checkForArgumentTypeNotAssignable(
-          expression,
-          expectedStaticType,
-          expression.staticType,
-          expectedPropagatedType,
-          expression.propagatedType,
-          errorCode);
+  bool _checkForArgumentTypeNotAssignableWithExpectedTypes(
+          Expression expression, DartType expectedStaticType,
+          DartType expectedPropagatedType, ErrorCode errorCode) =>
+      _checkForArgumentTypeNotAssignable(expression, expectedStaticType,
+          expression.staticType, expectedPropagatedType,
+          expression.propagatedType, errorCode);
 
   /**
    * This verifies that the passed arguments can be assigned to their corresponding parameters.
    *
    * This method corresponds to ErrorCode.checkForArgumentTypesNotAssignableInList.
    *
    * @param node the arguments to evaluate
    * @return `true` if and only if an hint code is generated on the passed node
    * See [HintCode.ARGUMENT_TYPE_NOT_ASSIGNABLE].
    */
@@ skipping 26 matching lines @@
         // TODO(jwren) We should modify ConstructorElement.getDisplayName(),
         // or have the logic centralized elsewhere, instead of doing this logic
         // here.
         ConstructorElement constructorElement = element;
         displayName = constructorElement.enclosingElement.displayName;
         if (!constructorElement.displayName.isEmpty) {
           displayName = "$displayName.${constructorElement.displayName}";
         }
       }
       _errorReporter.reportErrorForNode(
-          HintCode.DEPRECATED_MEMBER_USE,
-          node,
-          [displayName]);
+          HintCode.DEPRECATED_MEMBER_USE, node, [displayName]);
       return true;
     }
     return false;
   }
 
   /**
    * For [SimpleIdentifier]s, only call [checkForDeprecatedMemberUse]
    * if the node is not in a declaration context.
    *
    * Also, if the identifier is a constructor name in a constructor invocation, then calls to the
@@ skipping 45 matching lines @@
     // Report error if the (x/y) has toInt() invoked on it
     if (node.parent is ParenthesizedExpression) {
       ParenthesizedExpression parenthesizedExpression =
           _wrapParenthesizedExpression(node.parent as ParenthesizedExpression);
       if (parenthesizedExpression.parent is MethodInvocation) {
         MethodInvocation methodInvocation =
             parenthesizedExpression.parent as MethodInvocation;
         if (_TO_INT_METHOD_NAME == methodInvocation.methodName.name &&
             methodInvocation.argumentList.arguments.isEmpty) {
           _errorReporter.reportErrorForNode(
-              HintCode.DIVISION_OPTIMIZATION,
-              methodInvocation);
+              HintCode.DIVISION_OPTIMIZATION, methodInvocation);
           return true;
         }
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed left hand side and right hand side represent a valid assignment.
    *
    * This method corresponds to ErrorVerifier.checkForInvalidAssignment.
    *
    * @param lhs the left hand side expression
    * @param rhs the right hand side expression
    * @return `true` if and only if an error code is generated on the passed node
    * See [HintCode.INVALID_ASSIGNMENT].
    */
   bool _checkForInvalidAssignment(Expression lhs, Expression rhs) {
     if (lhs == null || rhs == null) {
       return false;
     }
     VariableElement leftVariableElement = ErrorVerifier.getVariableElement(lhs);
-    DartType leftType = (leftVariableElement == null) ?
-        ErrorVerifier.getStaticType(lhs) :
-        leftVariableElement.type;
+    DartType leftType = (leftVariableElement == null)
+        ? ErrorVerifier.getStaticType(lhs)
+        : leftVariableElement.type;
     DartType staticRightType = ErrorVerifier.getStaticType(rhs);
     if (!staticRightType.isAssignableTo(leftType)) {
       // The warning was generated on this rhs
       return false;
     }
     // Test for, and then generate the hint
     DartType bestRightType = rhs.bestType;
     if (leftType != null && bestRightType != null) {
       if (!bestRightType.isAssignableTo(leftType)) {
         _errorReporter.reportTypeErrorForNode(
-            HintCode.INVALID_ASSIGNMENT,
-            rhs,
-            [bestRightType, leftType]);
+            HintCode.INVALID_ASSIGNMENT, rhs, [bestRightType, leftType]);
         return true;
       }
     }
     return false;
   }
 
   /**
    * Check that the imported library does not define a loadLibrary function. The import has already
    * been determined to be deferred when this is called.
    *
    * @param node the import directive to evaluate
    * @param importElement the [ImportElement] retrieved from the node
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.IMPORT_DEFERRED_LIBRARY_WITH_LOAD_FUNCTION].
    */
-  bool _checkForLoadLibraryFunction(ImportDirective node,
-      ImportElement importElement) {
+  bool _checkForLoadLibraryFunction(
+      ImportDirective node, ImportElement importElement) {
     LibraryElement importedLibrary = importElement.importedLibrary;
     if (importedLibrary == null) {
       return false;
     }
     if (importedLibrary.hasLoadLibraryFunction) {
       _errorReporter.reportErrorForNode(
-          HintCode.IMPORT_DEFERRED_LIBRARY_WITH_LOAD_FUNCTION,
-          node,
-          [importedLibrary.name]);
+          HintCode.IMPORT_DEFERRED_LIBRARY_WITH_LOAD_FUNCTION, node, [
+        importedLibrary.name
+      ]);
       return true;
     }
     return false;
   }
 
   /**
    * Generate a hint for functions or methods that have a return type, but do not have a return
    * statement on all branches. At the end of blocks with no return, Dart implicitly returns
    * `null`, avoiding these implicit returns is considered a best practice.
    *
@@ skipping 25 matching lines @@
     }
     // For async, give no hint if Future<Null> is assignable to the return
     // type.
     if (body.isAsynchronous && _futureNullType.isAssignableTo(returnTypeType)) {
       return false;
     }
     // Check the block for a return statement, if not, create the hint
     BlockFunctionBody blockFunctionBody = body as BlockFunctionBody;
     if (!ExitDetector.exits(blockFunctionBody)) {
       _errorReporter.reportErrorForNode(
-          HintCode.MISSING_RETURN,
-          returnType,
-          [returnTypeType.displayName]);
+          HintCode.MISSING_RETURN, returnType, [returnTypeType.displayName]);
       return true;
     }
     return false;
   }
 
   /**
    * Check for the passed class declaration for the
    * [HintCode.OVERRIDE_EQUALS_BUT_NOT_HASH_CODE] hint code.
    *
    * @param node the class declaration to check
@@ skipping 82 matching lines @@
    * See [HintCode.USE_OF_VOID_RESULT].
    */
   bool _checkForUseOfVoidResult(Expression expression) {
     if (expression == null || expression is! MethodInvocation) {
       return false;
     }
     MethodInvocation methodInvocation = expression as MethodInvocation;
     if (identical(methodInvocation.staticType, VoidTypeImpl.instance)) {
       SimpleIdentifier methodName = methodInvocation.methodName;
       _errorReporter.reportErrorForNode(
-          HintCode.USE_OF_VOID_RESULT,
-          methodName,
-          [methodName.name]);
+          HintCode.USE_OF_VOID_RESULT, methodName, [methodName.name]);
       return true;
     }
     return false;
   }
 
   /**
    * Given a parenthesized expression, this returns the parent (or recursively grand-parent) of the
    * expression that is a parenthesized expression, but whose parent is not a parenthesized
    * expression.
    *
    * For example given the code `(((e)))`: `(e) -> (((e)))`.
    *
    * @param parenthesizedExpression some expression whose parent is a parenthesized expression
    * @return the first parent or grand-parent that is a parenthesized expression, that does not have
    *         a parenthesized expression parent
    */
-  static ParenthesizedExpression
-      _wrapParenthesizedExpression(ParenthesizedExpression parenthesizedExpression) {
+  static ParenthesizedExpression _wrapParenthesizedExpression(
+      ParenthesizedExpression parenthesizedExpression) {
     if (parenthesizedExpression.parent is ParenthesizedExpression) {
       return _wrapParenthesizedExpression(
           parenthesizedExpression.parent as ParenthesizedExpression);
     }
     return parenthesizedExpression;
   }
 }
 
 /**
  * Instances of the class `ClassScope` implement the scope defined by a class.
@@ skipping 10 matching lines @@
     if (typeElement == null) {
       throw new IllegalArgumentException("class element cannot be null");
     }
     _defineMembers(typeElement);
   }
 
   @override
   AnalysisError getErrorForDuplicate(Element existing, Element duplicate) {
     if (existing is PropertyAccessorElement && duplicate is MethodElement) {
       if (existing.nameOffset < duplicate.nameOffset) {
-        return new AnalysisError.con2(
-            duplicate.source,
-            duplicate.nameOffset,
+        return new AnalysisError.con2(duplicate.source, duplicate.nameOffset,
             duplicate.displayName.length,
-            CompileTimeErrorCode.METHOD_AND_GETTER_WITH_SAME_NAME,
-            [existing.displayName]);
+            CompileTimeErrorCode.METHOD_AND_GETTER_WITH_SAME_NAME, [
+          existing.displayName
+        ]);
       } else {
-        return new AnalysisError.con2(
-            existing.source,
-            existing.nameOffset,
+        return new AnalysisError.con2(existing.source, existing.nameOffset,
             existing.displayName.length,
-            CompileTimeErrorCode.GETTER_AND_METHOD_WITH_SAME_NAME,
-            [existing.displayName]);
+            CompileTimeErrorCode.GETTER_AND_METHOD_WITH_SAME_NAME, [
+          existing.displayName
+        ]);
       }
     }
     return super.getErrorForDuplicate(existing, duplicate);
   }
 
   /**
    * Define the instance members defined by the class.
    *
    * @param typeElement the element representing the type represented by this scope
    */
@@ skipping 10 matching lines @@
 /**
  * A `CompilationUnitBuilder` builds an element model for a single compilation
  * unit.
  */
 class CompilationUnitBuilder {
   /**
    * Build the compilation unit element for the given [source] based on the
    * compilation [unit] associated with the source. Throw an AnalysisException
    * if the element could not be built.
    */
-  CompilationUnitElementImpl buildCompilationUnit(Source source,
-      CompilationUnit unit) {
+  CompilationUnitElementImpl buildCompilationUnit(
+      Source source, CompilationUnit unit) {
     return PerformanceStatistics.resolve.makeCurrentWhile(() {
       if (unit == null) {
         return null;
       }
       ElementHolder holder = new ElementHolder();
       ElementBuilder builder = new ElementBuilder(holder);
       unit.accept(builder);
       CompilationUnitElementImpl element =
           new CompilationUnitElementImpl(source.shortName);
       element.accessors = holder.accessors;
@@ skipping 49 matching lines @@
   /**
    * The current library that is being analyzed.
    */
   final LibraryElement _currentLibrary;
 
   /**
    * Initialize a newly created constant verifier.
    *
    * @param errorReporter the error reporter by which errors will be reported
    */
-  ConstantVerifier(this._errorReporter, this._currentLibrary,
-      this._typeProvider) {
+  ConstantVerifier(
+      this._errorReporter, this._currentLibrary, this._typeProvider) {
     this._boolType = _typeProvider.boolType;
     this._intType = _typeProvider.intType;
     this._numType = _typeProvider.numType;
     this._stringType = _typeProvider.stringType;
   }
 
   @override
   Object visitAnnotation(Annotation node) {
     super.visitAnnotation(node);
     // check annotation creation
     Element element = node.element;
     if (element is ConstructorElement) {
       ConstructorElement constructorElement = element;
       // should 'const' constructor
       if (!constructorElement.isConst) {
         _errorReporter.reportErrorForNode(
-            CompileTimeErrorCode.NON_CONSTANT_ANNOTATION_CONSTRUCTOR,
-            node);
+            CompileTimeErrorCode.NON_CONSTANT_ANNOTATION_CONSTRUCTOR, node);
         return null;
       }
       // should have arguments
       ArgumentList argumentList = node.arguments;
       if (argumentList == null) {
         _errorReporter.reportErrorForNode(
-            CompileTimeErrorCode.NO_ANNOTATION_CONSTRUCTOR_ARGUMENTS,
-            node);
+            CompileTimeErrorCode.NO_ANNOTATION_CONSTRUCTOR_ARGUMENTS, node);
         return null;
       }
       // arguments should be constants
       _validateConstantArguments(argumentList);
     }
     return null;
   }
 
   @override
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
@@ skipping 28 matching lines @@
 
   @override
   Object visitListLiteral(ListLiteral node) {
     super.visitListLiteral(node);
     if (node.constKeyword != null) {
       DartObjectImpl result;
       for (Expression element in node.elements) {
         result =
             _validate(element, CompileTimeErrorCode.NON_CONSTANT_LIST_ELEMENT);
         if (result != null) {
-          _reportErrorIfFromDeferredLibrary(
-              element,
+          _reportErrorIfFromDeferredLibrary(element,
               CompileTimeErrorCode.NON_CONSTANT_LIST_ELEMENT_FROM_DEFERRED_LIBRARY);
         }
       }
     }
     return null;
   }
 
   @override
   Object visitMapLiteral(MapLiteral node) {
     super.visitMapLiteral(node);
     bool isConst = node.constKeyword != null;
     bool reportEqualKeys = true;
     HashSet<DartObject> keys = new HashSet<DartObject>();
     List<Expression> invalidKeys = new List<Expression>();
     for (MapLiteralEntry entry in node.entries) {
       Expression key = entry.key;
       if (isConst) {
         DartObjectImpl keyResult =
             _validate(key, CompileTimeErrorCode.NON_CONSTANT_MAP_KEY);
         Expression valueExpression = entry.value;
-        DartObjectImpl valueResult =
-            _validate(valueExpression, CompileTimeErrorCode.NON_CONSTANT_MAP_VALUE);
+        DartObjectImpl valueResult = _validate(
+            valueExpression, CompileTimeErrorCode.NON_CONSTANT_MAP_VALUE);
         if (valueResult != null) {
-          _reportErrorIfFromDeferredLibrary(
-              valueExpression,
+          _reportErrorIfFromDeferredLibrary(valueExpression,
               CompileTimeErrorCode.NON_CONSTANT_MAP_VALUE_FROM_DEFERRED_LIBRARY);
         }
         if (keyResult != null) {
-          _reportErrorIfFromDeferredLibrary(
-              key,
+          _reportErrorIfFromDeferredLibrary(key,
               CompileTimeErrorCode.NON_CONSTANT_MAP_KEY_FROM_DEFERRED_LIBRARY);
           if (keys.contains(keyResult)) {
             invalidKeys.add(key);
           } else {
             keys.add(keyResult);
           }
           DartType type = keyResult.type;
           if (_implementsEqualsWhenNotAllowed(type)) {
             _errorReporter.reportErrorForNode(
                 CompileTimeErrorCode.CONST_MAP_KEY_EXPRESSION_TYPE_IMPLEMENTS_EQUALS,
-                key,
-                [type.displayName]);
+                key, [type.displayName]);
           }
         }
       } else {
         // Note: we throw the errors away because this isn't actually a const.
         AnalysisErrorListener errorListener =
             AnalysisErrorListener.NULL_LISTENER;
         ErrorReporter subErrorReporter =
             new ErrorReporter(errorListener, _errorReporter.source);
-        DartObjectImpl result =
-            key.accept(new ConstantVisitor.con1(_typeProvider, subErrorReporter));
+        DartObjectImpl result = key
+            .accept(new ConstantVisitor.con1(_typeProvider, subErrorReporter));
         if (result != null) {
           if (keys.contains(result)) {
             invalidKeys.add(key);
           } else {
             keys.add(result);
           }
         } else {
           reportEqualKeys = false;
         }
       }
     }
     if (reportEqualKeys) {
       for (Expression key in invalidKeys) {
         _errorReporter.reportErrorForNode(
-            StaticWarningCode.EQUAL_KEYS_IN_MAP,
-            key);
+            StaticWarningCode.EQUAL_KEYS_IN_MAP, key);
       }
     }
     return null;
   }
 
   @override
   Object visitMethodDeclaration(MethodDeclaration node) {
     super.visitMethodDeclaration(node);
     _validateDefaultValues(node.parameters);
     return null;
   }
 
   @override
   Object visitSwitchStatement(SwitchStatement node) {
     // TODO(paulberry): to minimize error messages, it would be nice to
     // compare all types with the most popular type rather than the first
     // type.
     NodeList<SwitchMember> switchMembers = node.members;
     bool foundError = false;
     DartType firstType = null;
     for (SwitchMember switchMember in switchMembers) {
       if (switchMember is SwitchCase) {
         SwitchCase switchCase = switchMember;
         Expression expression = switchCase.expression;
-        DartObjectImpl caseResult =
-            _validate(expression, CompileTimeErrorCode.NON_CONSTANT_CASE_EXPRESSION);
+        DartObjectImpl caseResult = _validate(
+            expression, CompileTimeErrorCode.NON_CONSTANT_CASE_EXPRESSION);
         if (caseResult != null) {
-          _reportErrorIfFromDeferredLibrary(
-              expression,
+          _reportErrorIfFromDeferredLibrary(expression,
               CompileTimeErrorCode.NON_CONSTANT_CASE_EXPRESSION_FROM_DEFERRED_LIBRARY);
           DartObject value = caseResult;
           if (firstType == null) {
             firstType = value.type;
           } else {
             DartType nType = value.type;
             if (firstType != nType) {
               _errorReporter.reportErrorForNode(
                   CompileTimeErrorCode.INCONSISTENT_CASE_EXPRESSION_TYPES,
-                  expression,
-                  [expression.toSource(), firstType.displayName]);
+                  expression, [expression.toSource(), firstType.displayName]);
               foundError = true;
             }
           }
         }
       }
     }
     if (!foundError) {
       _checkForCaseExpressionTypeImplementsEquals(node, firstType);
     }
     return super.visitSwitchStatement(node);
   }
 
   @override
   Object visitVariableDeclaration(VariableDeclaration node) {
     super.visitVariableDeclaration(node);
     Expression initializer = node.initializer;
     if (initializer != null && node.isConst) {
       VariableElementImpl element = node.element as VariableElementImpl;
       EvaluationResultImpl result = element.evaluationResult;
       if (result == null) {
         //
         // Normally we don't need to visit const variable declarations because
         // we have already computed their values. But if we missed it for some
         // reason, this gives us a second chance.
         //
-        result = new EvaluationResultImpl.con1(
-            _validate(
-                initializer,
-                CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE));
+        result = new EvaluationResultImpl.con1(_validate(initializer,
+            CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE));
         element.evaluationResult = result;
         return null;
       }
-      _reportErrors(
-          result.errors,
+      _reportErrors(result.errors,
           CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE);
-      _reportErrorIfFromDeferredLibrary(
-          initializer,
+      _reportErrorIfFromDeferredLibrary(initializer,
           CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE_FROM_DEFERRED_LIBRARY);
     }
     return null;
   }
 
   /**
    * This verifies that the passed switch statement does not have a case expression with the
    * operator '==' overridden.
    *
    * @param node the switch statement to evaluate
    * @param type the common type of all 'case' expressions
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS].
    */
-  bool _checkForCaseExpressionTypeImplementsEquals(SwitchStatement node,
-      DartType type) {
+  bool _checkForCaseExpressionTypeImplementsEquals(
+      SwitchStatement node, DartType type) {
     if (!_implementsEqualsWhenNotAllowed(type)) {
       return false;
     }
     // report error
     _errorReporter.reportErrorForToken(
         CompileTimeErrorCode.CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS,
-        node.switchKeyword,
-        [type.displayName]);
+        node.switchKeyword, [type.displayName]);
     return true;
   }
 
   /**
    * @return `true` if given [Type] implements operator <i>==</i>, and it is not
    *         <i>int</i> or <i>String</i>.
    */
   bool _implementsEqualsWhenNotAllowed(DartType type) {
     // ignore int or String
     if (type == null || type == _intType || type == _typeProvider.stringType) {
@@ skipping 18 matching lines @@
   }
 
   /**
    * Given some computed [Expression], this method generates the passed [ErrorCode] on
    * the node if its' value consists of information from a deferred library.
    *
    * @param expression the expression to be tested for a deferred library reference
    * @param errorCode the error code to be used if the expression is or consists of a reference to a
    *          deferred library
    */
-  void _reportErrorIfFromDeferredLibrary(Expression expression,
-      ErrorCode errorCode) {
+  void _reportErrorIfFromDeferredLibrary(
+      Expression expression, ErrorCode errorCode) {
     DeferredLibraryReferenceDetector referenceDetector =
         new DeferredLibraryReferenceDetector();
     expression.accept(referenceDetector);
     if (referenceDetector.result) {
       _errorReporter.reportErrorForNode(errorCode, expression);
     }
   }
 
   /**
    * Report any errors in the given list. Except for special cases, use the given error code rather
    * than the one reported in the error.
    *
    * @param errors the errors that need to be reported
    * @param errorCode the error code to be used
    */
   void _reportErrors(List<AnalysisError> errors, ErrorCode errorCode) {
     for (AnalysisError data in errors) {
       ErrorCode dataErrorCode = data.errorCode;
-      if (identical(
-          dataErrorCode,
-          CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION) ||
-          identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_THROWS_IDBZE) ||
+      if (identical(dataErrorCode,
+              CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION) ||
           identical(
-              dataErrorCode,
+              dataErrorCode, CompileTimeErrorCode.CONST_EVAL_THROWS_IDBZE) ||
+          identical(dataErrorCode,
               CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL_NUM_STRING) ||
           identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL) ||
           identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_TYPE_INT) ||
           identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM) ||
-          identical(
-              dataErrorCode,
+          identical(dataErrorCode,
               CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_FIELD_TYPE_MISMATCH) ||
-          identical(
-              dataErrorCode,
+          identical(dataErrorCode,
               CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH) ||
-          identical(
-              dataErrorCode,
+          identical(dataErrorCode,
               CheckedModeCompileTimeErrorCode.VARIABLE_TYPE_MISMATCH)) {
         _errorReporter.reportError(data);
       } else if (errorCode != null) {
-        _errorReporter.reportError(
-            new AnalysisError.con2(data.source, data.offset, data.length, errorCode));
+        _errorReporter.reportError(new AnalysisError.con2(
+            data.source, data.offset, data.length, errorCode));
       }
     }
   }
 
   /**
    * Validate that the given expression is a compile time constant. Return the value of the compile
    * time constant, or `null` if the expression is not a compile time constant.
    *
    * @param expression the expression to be validated
    * @param errorCode the error code to be used if the expression is not a compile time constant
    * @return the value of the compile time constant
    */
   DartObjectImpl _validate(Expression expression, ErrorCode errorCode) {
     RecordingErrorListener errorListener = new RecordingErrorListener();
     ErrorReporter subErrorReporter =
         new ErrorReporter(errorListener, _errorReporter.source);
-    DartObjectImpl result =
-        expression.accept(new ConstantVisitor.con1(_typeProvider, subErrorReporter));
+    DartObjectImpl result = expression
+        .accept(new ConstantVisitor.con1(_typeProvider, subErrorReporter));
     _reportErrors(errorListener.errors, errorCode);
     return result;
   }
 
   /**
    * Validate that if the passed arguments are constant expressions.
    *
    * @param argumentList the argument list to evaluate
    */
   void _validateConstantArguments(ArgumentList argumentList) {
     for (Expression argument in argumentList.arguments) {
       if (argument is NamedExpression) {
         argument = (argument as NamedExpression).expression;
       }
       _validate(
-          argument,
-          CompileTimeErrorCode.CONST_WITH_NON_CONSTANT_ARGUMENT);
+          argument, CompileTimeErrorCode.CONST_WITH_NON_CONSTANT_ARGUMENT);
     }
   }
 
   /**
    * Validates that the expressions of the given initializers (of a constant constructor) are all
    * compile time constants.
    *
    * @param constructor the constant constructor declaration to validate
    */
   void _validateConstructorInitializers(ConstructorDeclaration constructor) {
     List<ParameterElement> parameterElements =
         constructor.parameters.parameterElements;
     NodeList<ConstructorInitializer> initializers = constructor.initializers;
     for (ConstructorInitializer initializer in initializers) {
       if (initializer is ConstructorFieldInitializer) {
         ConstructorFieldInitializer fieldInitializer = initializer;
         _validateInitializerExpression(
-            parameterElements,
-            fieldInitializer.expression);
+            parameterElements, fieldInitializer.expression);
       }
       if (initializer is RedirectingConstructorInvocation) {
         RedirectingConstructorInvocation invocation = initializer;
         _validateInitializerInvocationArguments(
-            parameterElements,
-            invocation.argumentList);
+            parameterElements, invocation.argumentList);
       }
       if (initializer is SuperConstructorInvocation) {
         SuperConstructorInvocation invocation = initializer;
         _validateInitializerInvocationArguments(
-            parameterElements,
-            invocation.argumentList);
+            parameterElements, invocation.argumentList);
       }
     }
   }
 
   /**
    * Validate that the default value associated with each of the parameters in the given list is a
    * compile time constant.
    *
    * @param parameters the list of parameters to be validated
    */
   void _validateDefaultValues(FormalParameterList parameters) {
     if (parameters == null) {
       return;
     }
     for (FormalParameter parameter in parameters.parameters) {
       if (parameter is DefaultFormalParameter) {
         DefaultFormalParameter defaultParameter = parameter;
         Expression defaultValue = defaultParameter.defaultValue;
         DartObjectImpl result;
         if (defaultValue == null) {
           result =
               new DartObjectImpl(_typeProvider.nullType, NullState.NULL_STATE);
         } else {
-          result =
-              _validate(defaultValue, CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE);
+          result = _validate(
+              defaultValue, CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE);
           if (result != null) {
-            _reportErrorIfFromDeferredLibrary(
-                defaultValue,
+            _reportErrorIfFromDeferredLibrary(defaultValue,
                 CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE_FROM_DEFERRED_LIBRARY);
           }
         }
         VariableElementImpl element = parameter.element as VariableElementImpl;
         element.evaluationResult = new EvaluationResultImpl.con1(result);
       }
     }
   }
 
   /**
    * Validates that the expressions of any field initializers in the class declaration are all
    * compile time constants. Since this is only required if the class has a constant constructor,
    * the error is reported at the constructor site.
    *
    * @param classDeclaration the class which should be validated
    * @param errorSite the site at which errors should be reported.
    */
-  void _validateFieldInitializers(ClassDeclaration classDeclaration,
-      ConstructorDeclaration errorSite) {
+  void _validateFieldInitializers(
+      ClassDeclaration classDeclaration, ConstructorDeclaration errorSite) {
     NodeList<ClassMember> members = classDeclaration.members;
     for (ClassMember member in members) {
       if (member is FieldDeclaration) {
         FieldDeclaration fieldDeclaration = member;
         if (!fieldDeclaration.isStatic) {
-          for (VariableDeclaration variableDeclaration in
-              fieldDeclaration.fields.variables) {
+          for (VariableDeclaration variableDeclaration
+              in fieldDeclaration.fields.variables) {
             Expression initializer = variableDeclaration.initializer;
             if (initializer != null) {
               // Ignore any errors produced during validation--if the constant
               // can't be eavluated we'll just report a single error.
               AnalysisErrorListener errorListener =
                   AnalysisErrorListener.NULL_LISTENER;
               ErrorReporter subErrorReporter =
                   new ErrorReporter(errorListener, _errorReporter.source);
-              DartObjectImpl result =
-                  initializer.accept(new ConstantVisitor.con1(_typeProvider, subErrorReporter));
+              DartObjectImpl result = initializer.accept(
+                  new ConstantVisitor.con1(_typeProvider, subErrorReporter));
               if (result == null) {
                 _errorReporter.reportErrorForNode(
                     CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_FIELD_INITIALIZED_BY_NON_CONST,
-                    errorSite,
-                    [variableDeclaration.name.name]);
+                    errorSite, [variableDeclaration.name.name]);
               }
             }
           }
         }
       }
     }
   }
 
   /**
    * Validates that the given expression is a compile time constant.
    *
    * @param parameterElements the elements of parameters of constant constructor, they are
    *          considered as a valid potentially constant expressions
    * @param expression the expression to validate
    */
-  void _validateInitializerExpression(List<ParameterElement> parameterElements,
-      Expression expression) {
+  void _validateInitializerExpression(
+      List<ParameterElement> parameterElements, Expression expression) {
     RecordingErrorListener errorListener = new RecordingErrorListener();
     ErrorReporter subErrorReporter =
         new ErrorReporter(errorListener, _errorReporter.source);
     DartObjectImpl result = expression.accept(
         new _ConstantVerifier_validateInitializerExpression(
-            _typeProvider,
-            subErrorReporter,
-            this,
-            parameterElements));
-    _reportErrors(
-        errorListener.errors,
+            _typeProvider, subErrorReporter, this, parameterElements));
+    _reportErrors(errorListener.errors,
         CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER);
     if (result != null) {
-      _reportErrorIfFromDeferredLibrary(
-          expression,
+      _reportErrorIfFromDeferredLibrary(expression,
           CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER_FROM_DEFERRED_LIBRARY);
     }
   }
 
   /**
    * Validates that all of the arguments of a constructor initializer are compile time constants.
    *
    * @param parameterElements the elements of parameters of constant constructor, they are
    *          considered as a valid potentially constant expressions
    * @param argumentList the argument list to validate
    */
-  void
-      _validateInitializerInvocationArguments(List<ParameterElement> parameterElements,
-      ArgumentList argumentList) {
+  void _validateInitializerInvocationArguments(
+      List<ParameterElement> parameterElements, ArgumentList argumentList) {
     if (argumentList == null) {
       return;
     }
     for (Expression argument in argumentList.arguments) {
       _validateInitializerExpression(parameterElements, argument);
     }
   }
 
   /**
    * Validate that if the passed instance creation is 'const' then all its arguments are constant
@@ skipping 106 matching lines @@
     bool isAmpAmp = operator.type == sc.TokenType.AMPERSAND_AMPERSAND;
     bool isBarBar = operator.type == sc.TokenType.BAR_BAR;
     if (isAmpAmp || isBarBar) {
       Expression lhsCondition = node.leftOperand;
       if (!_isDebugConstant(lhsCondition)) {
         EvaluationResultImpl lhsResult = _getConstantBooleanValue(lhsCondition);
         if (lhsResult != null) {
           if (lhsResult.value.isTrue && isBarBar) {
             // report error on else block: true || !e!
             _errorReporter.reportErrorForNode(
-                HintCode.DEAD_CODE,
-                node.rightOperand);
+                HintCode.DEAD_CODE, node.rightOperand);
             // only visit the LHS:
             _safelyVisit(lhsCondition);
             return null;
           } else if (lhsResult.value.isFalse && isAmpAmp) {
             // report error on if block: false && !e!
             _errorReporter.reportErrorForNode(
-                HintCode.DEAD_CODE,
-                node.rightOperand);
+                HintCode.DEAD_CODE, node.rightOperand);
             // only visit the LHS:
             _safelyVisit(lhsCondition);
             return null;
           }
         }
       }
       // How do we want to handle the RHS? It isn't dead code, but "pointless"
       // or "obscure"...
 //            Expression rhsCondition = node.getRightOperand();
 //            ValidResult rhsResult = getConstantBooleanValue(rhsCondition);
@@ skipping 33 matching lines @@
   Object visitConditionalExpression(ConditionalExpression node) {
     Expression conditionExpression = node.condition;
     _safelyVisit(conditionExpression);
     if (!_isDebugConstant(conditionExpression)) {
       EvaluationResultImpl result =
           _getConstantBooleanValue(conditionExpression);
       if (result != null) {
         if (result.value.isTrue) {
           // report error on else block: true ? 1 : !2!
           _errorReporter.reportErrorForNode(
-              HintCode.DEAD_CODE,
-              node.elseExpression);
+              HintCode.DEAD_CODE, node.elseExpression);
           _safelyVisit(node.thenExpression);
           return null;
         } else {
           // report error on if block: false ? !1! : 2
-          _errorReporter.reportErrorForNode(
-              HintCode.DEAD_CODE,
-              node.thenExpression);
+          _errorReporter
+              .reportErrorForNode(HintCode.DEAD_CODE, node.thenExpression);
           _safelyVisit(node.elseExpression);
           return null;
         }
       }
     }
     return super.visitConditionalExpression(node);
   }
 
   @override
   Object visitIfStatement(IfStatement node) {
     Expression conditionExpression = node.condition;
     _safelyVisit(conditionExpression);
     if (!_isDebugConstant(conditionExpression)) {
       EvaluationResultImpl result =
           _getConstantBooleanValue(conditionExpression);
       if (result != null) {
         if (result.value.isTrue) {
           // report error on else block: if(true) {} else {!}
           Statement elseStatement = node.elseStatement;
           if (elseStatement != null) {
             _errorReporter.reportErrorForNode(
-                HintCode.DEAD_CODE,
-                elseStatement);
+                HintCode.DEAD_CODE, elseStatement);
             _safelyVisit(node.thenStatement);
             return null;
           }
         } else {
           // report error on if block: if (false) {!} else {}
-          _errorReporter.reportErrorForNode(
-              HintCode.DEAD_CODE,
-              node.thenStatement);
+          _errorReporter
+              .reportErrorForNode(HintCode.DEAD_CODE, node.thenStatement);
           _safelyVisit(node.elseStatement);
           return null;
         }
       }
     }
     return super.visitIfStatement(node);
   }
 
   @override
   Object visitSwitchCase(SwitchCase node) {
@@ skipping 28 matching lines @@
             // exception type, visit the block, but generate an error on any
             // following catch clauses (and don't visit them).
             _safelyVisit(catchClause);
             if (i + 1 != numOfCatchClauses) {
               // this catch clause is not the last in the try statement
               CatchClause nextCatchClause = catchClauses[i + 1];
               CatchClause lastCatchClause = catchClauses[numOfCatchClauses - 1];
               int offset = nextCatchClause.offset;
               int length = lastCatchClause.end - offset;
               _errorReporter.reportErrorForOffset(
-                  HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH,
-                  offset,
-                  length);
+                  HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH, offset, length);
               return null;
             }
           }
           for (DartType type in visitedTypes) {
             if (currentType.isSubtypeOf(type)) {
               CatchClause lastCatchClause = catchClauses[numOfCatchClauses - 1];
               int offset = catchClause.offset;
               int length = lastCatchClause.end - offset;
               _errorReporter.reportErrorForOffset(
-                  HintCode.DEAD_CODE_ON_CATCH_SUBTYPE,
-                  offset,
-                  length,
-                  [currentType.displayName, type.displayName]);
+                  HintCode.DEAD_CODE_ON_CATCH_SUBTYPE, offset, length, [
+                currentType.displayName,
+                type.displayName
+              ]);
               return null;
             }
           }
           visitedTypes.add(currentType);
         }
         _safelyVisit(catchClause);
       } else {
         // Found catch clause clause that doesn't have an exception type,
         // visit the block, but generate an error on any following catch clauses
         // (and don't visit them).
         _safelyVisit(catchClause);
         if (i + 1 != numOfCatchClauses) {
           // this catch clause is not the last in the try statement
           CatchClause nextCatchClause = catchClauses[i + 1];
           CatchClause lastCatchClause = catchClauses[numOfCatchClauses - 1];
           int offset = nextCatchClause.offset;
           int length = lastCatchClause.end - offset;
           _errorReporter.reportErrorForOffset(
-              HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH,
-              offset,
-              length);
+              HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH, offset, length);
           return null;
         }
       }
     }
     return null;
   }
 
   @override
   Object visitWhileStatement(WhileStatement node) {
     Expression conditionExpression = node.condition;
@@ skipping 18 matching lines @@
    * [SwitchMember], this loops through the list in reverse order searching for statements
    * after a return, unlabeled break or unlabeled continue statement to mark them as dead code.
    *
    * @param statements some ordered list of statements in a [Block] or [SwitchMember]
    */
   void _checkForDeadStatementsInNodeList(NodeList<Statement> statements) {
     int size = statements.length;
     for (int i = 0; i < size; i++) {
       Statement currentStatement = statements[i];
       _safelyVisit(currentStatement);
-      bool returnOrBreakingStatement =
-          currentStatement is ReturnStatement ||
-          (currentStatement is BreakStatement && currentStatement.label == null) ||
-          (currentStatement is ContinueStatement && currentStatement.label == null);
+      bool returnOrBreakingStatement = currentStatement is ReturnStatement ||
+          (currentStatement is BreakStatement &&
+              currentStatement.label == null) ||
+          (currentStatement is ContinueStatement &&
+              currentStatement.label == null);
       if (returnOrBreakingStatement && i != size - 1) {
         Statement nextStatement = statements[i + 1];
         Statement lastStatement = statements[size - 1];
         int offset = nextStatement.offset;
         int length = lastStatement.end - offset;
         _errorReporter.reportErrorForOffset(HintCode.DEAD_CODE, offset, length);
         return;
       }
     }
   }
@@ skipping 215 matching lines @@
       _findIdentifier(constants, constant.name);
     }
     return super.visitEnumDeclaration(node);
   }
 
   @override
   Object visitExportDirective(ExportDirective node) {
     String uri = _getStringValue(node.uri);
     if (uri != null) {
       LibraryElement library = _enclosingUnit.library;
-      ExportElement exportElement = _findExport(
-          library.exports,
-          _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri));
+      ExportElement exportElement = _findExport(library.exports,
+          _enclosingUnit.context.sourceFactory.resolveUri(
+              _enclosingUnit.source, uri));
       node.element = exportElement;
     }
     return super.visitExportDirective(node);
   }
 
   @override
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       ParameterElement element = _getElementForParameter(node, parameterName);
@@ skipping 83 matching lines @@
     } else {
       return super.visitFunctionTypedFormalParameter(node);
     }
   }
 
   @override
   Object visitImportDirective(ImportDirective node) {
     String uri = _getStringValue(node.uri);
     if (uri != null) {
       LibraryElement library = _enclosingUnit.library;
-      ImportElement importElement = _findImport(
-          library.imports,
-          _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri),
-          node.prefix);
+      ImportElement importElement = _findImport(library.imports,
+          _enclosingUnit.context.sourceFactory.resolveUri(
+              _enclosingUnit.source, uri), node.prefix);
       node.element = importElement;
     }
     return super.visitImportDirective(node);
   }
 
   @override
   Object visitLabeledStatement(LabeledStatement node) {
     for (Label label in node.labels) {
       SimpleIdentifier labelName = label.label;
       _findIdentifier(_enclosingExecutable.labels, labelName);
@@ skipping 13 matching lines @@
     try {
       sc.Token property = node.propertyKeyword;
       SimpleIdentifier methodName = node.name;
       String nameOfMethod = methodName.name;
       if (nameOfMethod == sc.TokenType.MINUS.lexeme &&
           node.parameters.parameters.length == 0) {
         nameOfMethod = "unary-";
       }
       if (property == null) {
         _enclosingExecutable = _findWithNameAndOffset(
-            _enclosingClass.methods,
-            nameOfMethod,
-            methodName.offset);
+            _enclosingClass.methods, nameOfMethod, methodName.offset);
         methodName.staticElement = _enclosingExecutable;
       } else {
         PropertyAccessorElement accessor =
             _findIdentifier(_enclosingClass.accessors, methodName);
         if ((property as sc.KeywordToken).keyword == sc.Keyword.SET) {
           accessor = accessor.variable.setter;
           methodName.staticElement = accessor;
         }
         _enclosingExecutable = accessor;
       }
       return super.visitMethodDeclaration(node);
     } finally {
       _enclosingExecutable = outerExecutable;
     }
   }
 
   @override
   Object visitPartDirective(PartDirective node) {
     String uri = _getStringValue(node.uri);
     if (uri != null) {
-      Source partSource =
-          _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri);
+      Source partSource = _enclosingUnit.context.sourceFactory.resolveUri(
+          _enclosingUnit.source, uri);
       node.element = _findPart(_enclosingUnit.library.parts, partSource);
     }
     return super.visitPartDirective(node);
   }
 
   @override
   Object visitPartOfDirective(PartOfDirective node) {
     node.element = _enclosingUnit.library;
     return super.visitPartOfDirective(node);
   }
 
   @override
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       ParameterElement element = _getElementForParameter(node, parameterName);
       ParameterElement outerParameter = _enclosingParameter;
       try {
         _enclosingParameter = element;
         return super.visitSimpleFormalParameter(node);
       } finally {
         _enclosingParameter = outerParameter;
       }
-    } else {
-    }
+    } else {}
     return super.visitSimpleFormalParameter(node);
   }
 
   @override
   Object visitSwitchCase(SwitchCase node) {
     for (Label label in node.labels) {
       SimpleIdentifier labelName = label.label;
       _findIdentifier(_enclosingExecutable.labels, labelName);
     }
     return super.visitSwitchCase(node);
@@ skipping 97 matching lines @@
   /**
    * Return the import element from the given array whose library has the given source and that has
    * the given prefix, or `null` if there is no such import.
    *
    * @param imports the import elements being searched
    * @param source the source of the library associated with the import element to being searched
    *          for
    * @param prefix the prefix with which the library was imported
    * @return the import element whose library has the given source and prefix
    */
-  ImportElement _findImport(List<ImportElement> imports, Source source,
-      SimpleIdentifier prefix) {
+  ImportElement _findImport(
+      List<ImportElement> imports, Source source, SimpleIdentifier prefix) {
     for (ImportElement element in imports) {
       if (element.importedLibrary.source == source) {
         PrefixElement prefixElement = element.prefix;
         if (prefix == null) {
           if (prefixElement == null) {
             return element;
           }
         } else {
           if (prefixElement != null &&
               prefix.name == prefixElement.displayName) {
             return element;
           }
         }
       }
     }
     return null;
   }
 
   /**
    * Return the element for the part with the given source, or `null` if there is no element
    * for the given source.
    *
    * @param parts the elements for the parts
    * @param partSource the source for the part whose element is to be returned
    * @return the element for the part with the given source
    */
-  CompilationUnitElement _findPart(List<CompilationUnitElement> parts,
-      Source partSource) {
+  CompilationUnitElement _findPart(
+      List<CompilationUnitElement> parts, Source partSource) {
     for (CompilationUnitElement part in parts) {
       if (part.source == partSource) {
         return part;
       }
     }
     return null;
   }
 
   /**
    * Return the element in the given array of elements that was created for the declaration with the
    * given name at the given offset.
    *
    * @param elements the elements of the appropriate kind that exist in the current context
    * @param name the name of the element to be returned
    * @param offset the offset of the name of the element to be returned
    * @return the element with the given name and offset
    */
-  Element _findWithNameAndOffset(List<Element> elements, String name,
-      int offset) {
+  Element _findWithNameAndOffset(
+      List<Element> elements, String name, int offset) {
     for (Element element in elements) {
       if (element.displayName == name && element.nameOffset == offset) {
         return element;
       }
     }
     return null;
   }
 
   /**
    * Search the most closely enclosing list of parameters for a parameter with the given name.
    *
    * @param node the node defining the parameter with the given name
    * @param parameterName the name of the parameter being searched for
    * @return the element representing the parameter with that name
    */
-  ParameterElement _getElementForParameter(FormalParameter node,
-      SimpleIdentifier parameterName) {
+  ParameterElement _getElementForParameter(
+      FormalParameter node, SimpleIdentifier parameterName) {
     List<ParameterElement> parameters = null;
     if (_enclosingParameter != null) {
       parameters = _enclosingParameter.parameters;
     }
     if (parameters == null && _enclosingExecutable != null) {
       parameters = _enclosingExecutable.parameters;
     }
     if (parameters == null && _enclosingAlias != null) {
       parameters = _enclosingAlias.parameters;
     }
     ParameterElement element =
         parameters == null ? null : _findIdentifier(parameters, parameterName);
     if (element == null) {
       StringBuffer buffer = new StringBuffer();
       buffer.writeln("Invalid state found in the Analysis Engine:");
       buffer.writeln(
           "DeclarationResolver.getElementForParameter() is visiting a parameter that does not appear to be in a method or function.");
       buffer.writeln("Ancestors:");
       AstNode parent = node.parent;
       while (parent != null) {
         buffer.writeln(parent.runtimeType.toString());
         buffer.writeln("---------");
         parent = parent.parent;
       }
-      AnalysisEngine.instance.logger.logError(
-          buffer.toString(),
+      AnalysisEngine.instance.logger.logError(buffer.toString(),
           new CaughtException(new AnalysisException(), null));
     }
     return element;
   }
 
   /**
    * Return the value of the given string literal, or `null` if the string is not a constant
    * string without any string interpolation.
    *
    * @param literal the string literal whose value is to be returned
@@ skipping 378 matching lines @@
         _currentHolder.addFunction(element);
         expression.element = element;
         functionName.staticElement = element;
       } else {
         SimpleIdentifier propertyNameNode = node.name;
         if (propertyNameNode == null) {
           // TODO(brianwilkerson) Report this internal error.
           return null;
         }
         String propertyName = propertyNameNode.name;
-        TopLevelVariableElementImpl variable =
-            _currentHolder.getTopLevelVariable(propertyName) as TopLevelVariableElementImpl;
+        TopLevelVariableElementImpl variable = _currentHolder
+            .getTopLevelVariable(propertyName) as TopLevelVariableElementImpl;
         if (variable == null) {
           variable = new TopLevelVariableElementImpl(node.name.name, -1);
           variable.final2 = true;
           variable.synthetic = true;
           _currentHolder.addTopLevelVariable(variable);
         }
         if (node.isGetter) {
           PropertyAccessorElementImpl getter =
               new PropertyAccessorElementImpl.forNode(propertyNameNode);
           getter.functions = holder.functions;
@@ skipping 233 matching lines @@
       if (node.name.staticElement == null) {
         ClassDeclaration classNode =
             node.getAncestor((node) => node is ClassDeclaration);
         StringBuffer buffer = new StringBuffer();
         buffer.write("The element for the method ");
         buffer.write(node.name);
         buffer.write(" in ");
         buffer.write(classNode.name);
         buffer.write(" was not set while trying to build the element model.");
         AnalysisEngine.instance.logger.logError(
-            buffer.toString(),
-            new CaughtException(exception, stackTrace));
+            buffer.toString(), new CaughtException(exception, stackTrace));
       } else {
         String message =
             "Exception caught in ElementBuilder.visitMethodDeclaration()";
         AnalysisEngine.instance.logger.logError(
-            message,
-            new CaughtException(exception, stackTrace));
+            message, new CaughtException(exception, stackTrace));
       }
     } finally {
       if (node.name.staticElement == null) {
         ClassDeclaration classNode =
             node.getAncestor((node) => node is ClassDeclaration);
         StringBuffer buffer = new StringBuffer();
         buffer.write("The element for the method ");
         buffer.write(node.name);
         buffer.write(" in ");
         buffer.write(classNode.name);
         buffer.write(" was not set while trying to resolve types.");
-        AnalysisEngine.instance.logger.logError(
-            buffer.toString(),
-            new CaughtException(new AnalysisException(buffer.toString()), null));
+        AnalysisEngine.instance.logger.logError(buffer.toString(),
+            new CaughtException(
+                new AnalysisException(buffer.toString()), null));
       }
     }
     return null;
   }
 
   @override
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       ParameterElementImpl parameter =
@@ skipping 157 matching lines @@
       _fieldMap[field.name] = field;
     }
   }
 
   /**
    * Creates the [ConstructorElement]s array with the single default constructor element.
    *
    * @param interfaceType the interface type for which to create a default constructor
    * @return the [ConstructorElement]s array with the single default constructor element
    */
-  List<ConstructorElement>
-      _createDefaultConstructors(InterfaceTypeImpl interfaceType) {
+  List<ConstructorElement> _createDefaultConstructors(
+      InterfaceTypeImpl interfaceType) {
     ConstructorElementImpl constructor =
         new ConstructorElementImpl.forNode(null);
     constructor.synthetic = true;
     constructor.returnType = interfaceType;
     FunctionTypeImpl type = new FunctionTypeImpl.con1(constructor);
     _functionTypesToFix.add(type);
     constructor.type = type;
     return <ConstructorElement>[constructor];
   }
 
   /**
    * Create the types associated with the given type parameters, setting the type of each type
    * parameter, and return an array of types corresponding to the given parameters.
    *
    * @param typeParameters the type parameters for which types are to be created
    * @return an array of types corresponding to the given parameters
    */
-  List<DartType>
-      _createTypeParameterTypes(List<TypeParameterElement> typeParameters) {
+  List<DartType> _createTypeParameterTypes(
+      List<TypeParameterElement> typeParameters) {
     int typeParameterCount = typeParameters.length;
     List<DartType> typeArguments = new List<DartType>(typeParameterCount);
     for (int i = 0; i < typeParameterCount; i++) {
       TypeParameterElementImpl typeParameter =
           typeParameters[i] as TypeParameterElementImpl;
       TypeParameterTypeImpl typeParameterType =
           new TypeParameterTypeImpl(typeParameter);
       typeParameter.type = typeParameterType;
       typeArguments[i] = typeParameterType;
     }
@@ skipping 18 matching lines @@
         return (parent as MethodDeclaration).body;
       }
       parent = parent.parent;
     }
     return null;
   }
 
   /**
    * Sets the visible source range for formal parameter.
    */
-  void _setParameterVisibleRange(FormalParameter node,
-      ParameterElementImpl element) {
+  void _setParameterVisibleRange(
+      FormalParameter node, ParameterElementImpl element) {
     FunctionBody body = _getFunctionBody(node);
     if (body != null) {
       element.setVisibleRange(body.offset, body.length);
     }
   }
 
   /**
    * Make the given holder be the current holder while visiting the given node.
    *
    * @param holder the holder that will gather elements that are built while visiting the children
@@ skipping 378 matching lines @@
       buffer.write(" type aliases");
     }
     if (_typeParameters != null) {
       if (buffer.length > 0) {
         buffer.write("; ");
       }
       buffer.write(_typeParameters.length);
       buffer.write(" type parameters");
     }
     if (buffer.length > 0) {
-      AnalysisEngine.instance.logger.logError(
-          "Failed to capture elements: $buffer");
+      AnalysisEngine.instance.logger
+          .logError("Failed to capture elements: $buffer");
     }
   }
 }
 
 /**
  * Instances of the class `EnclosedScope` implement a scope that is lexically enclosed in
  * another scope.
  */
 class EnclosedScope extends Scope {
   /**
@@ skipping 34 matching lines @@
     if (element != null) {
       String name = element.name;
       if (name != null && !name.isEmpty) {
         _hiddenElements[name] = element;
         _hasHiddenName = true;
       }
     }
   }
 
   @override
-  Element internalLookup(Identifier identifier, String name,
-      LibraryElement referencingLibrary) {
+  Element internalLookup(
+      Identifier identifier, String name, LibraryElement referencingLibrary) {
     Element element = localLookup(name, referencingLibrary);
     if (element != null) {
       return element;
     }
     // May be there is a hidden Element.
     if (_hasHiddenName) {
       Element hiddenElement = _hiddenElements[name];
       if (hiddenElement != null) {
-        errorListener.onError(
-            new AnalysisError.con2(
-                getSource(identifier),
-                identifier.offset,
-                identifier.length,
-                CompileTimeErrorCode.REFERENCED_BEFORE_DECLARATION,
-                []));
+        errorListener.onError(new AnalysisError.con2(getSource(identifier),
+            identifier.offset, identifier.length,
+            CompileTimeErrorCode.REFERENCED_BEFORE_DECLARATION, []));
         return hiddenElement;
       }
     }
     // Check enclosing scope.
     return enclosingScope.internalLookup(identifier, name, referencingLibrary);
   }
 }
 
 /**
  * Instances of the class `EnumMemberBuilder` build the members in enum declarations.
@@ skipping 249 matching lines @@
       Expression conditionExpression = node.condition;
       if (conditionExpression != null && _nodeExits(conditionExpression)) {
         return true;
       }
       if (_visitExpressions(node.updaters)) {
         return true;
       }
       // TODO(jwren) Do we want to take all constant expressions into account?
       // If for(; true; ) (or for(;;)), and the body doesn't return or the body
       // doesn't have a break, then return true.
-      bool implicitOrExplictTrue =
-          conditionExpression == null ||
+      bool implicitOrExplictTrue = conditionExpression == null ||
           (conditionExpression is BooleanLiteral && conditionExpression.value);
       if (implicitOrExplictTrue) {
         bool blockReturns = _nodeExits(node.body);
         if (blockReturns || !_enclosingBlockContainsBreak) {
           return true;
         }
       }
       return false;
     } finally {
       _enclosingBlockContainsBreak = outerBreakValue;
@@ skipping 257 matching lines @@
 
   bool _visitStatements(NodeList<Statement> statements) {
     for (int i = statements.length - 1; i >= 0; i--) {
       if (statements[i].accept(this)) {
         return true;
       }
     }
     return false;
   }
 
-  bool
-      _visitVariableDeclarations(NodeList<VariableDeclaration> variableDeclarations) {
+  bool _visitVariableDeclarations(
+      NodeList<VariableDeclaration> variableDeclarations) {
     for (int i = variableDeclarations.length - 1; i >= 0; i--) {
       if (variableDeclarations[i].accept(this)) {
         return true;
       }
     }
     return false;
   }
 
   /**
    * Return `true` if the given [node] exits.
    */
   static bool exits(AstNode node) {
     return new ExitDetector()._nodeExits(node);
   }
 }
 
-
 /**
  * Instances of the class `FunctionScope` implement the scope defined by a function.
  */
 class FunctionScope extends EnclosedScope {
   final ExecutableElement _functionElement;
 
   bool _parametersDefined = false;
 
   /**
    * Initialize a newly created scope enclosed within another scope.
@@ skipping 114 matching lines @@
         if (element != null) {
           if (i == 0) {
             _importsVerifier.inDefiningCompilationUnit = true;
             _generateForCompilationUnit(_compilationUnits[i], element.source);
             _importsVerifier.inDefiningCompilationUnit = false;
           } else {
             _generateForCompilationUnit(_compilationUnits[i], element.source);
           }
         }
       }
-      ErrorReporter definingCompilationUnitErrorReporter =
-          new ErrorReporter(_errorListener, _compilationUnits[0].element.source);
-      _importsVerifier.generateDuplicateImportHints(
-          definingCompilationUnitErrorReporter);
-      _importsVerifier.generateUnusedImportHints(
-          definingCompilationUnitErrorReporter);
-      _library.accept(
-          new _UnusedElementsVerifier(_errorListener, _usedElementsVisitor.usedElements));
+      ErrorReporter definingCompilationUnitErrorReporter = new ErrorReporter(
+          _errorListener, _compilationUnits[0].element.source);
+      _importsVerifier
+          .generateDuplicateImportHints(definingCompilationUnitErrorReporter);
+      _importsVerifier
+          .generateUnusedImportHints(definingCompilationUnitErrorReporter);
+      _library.accept(new _UnusedElementsVerifier(
+          _errorListener, _usedElementsVisitor.usedElements));
     });
   }
 
   void _generateForCompilationUnit(CompilationUnit unit, Source source) {
     ErrorReporter errorReporter = new ErrorReporter(_errorListener, source);
     unit.accept(_importsVerifier);
     // dead code analysis
     unit.accept(new DeadCodeVerifier(errorReporter));
     unit.accept(_usedElementsVisitor);
     // dart2js analysis
@@ skipping 129 matching lines @@
   visitHtmlScriptTagNode(ht.HtmlScriptTagNode node) {
     visitXmlTagNode(node);
   }
 
   @override
   visitHtmlUnit(ht.HtmlUnit node) {
     node.visitChildren(this);
   }
 
   @override
-  visitXmlAttributeNode(ht.XmlAttributeNode node) {
-  }
+  visitXmlAttributeNode(ht.XmlAttributeNode node) {}
 
   @override
   visitXmlTagNode(ht.XmlTagNode node) {
     node.visitChildren(this);
     String tagName = node.tag;
     tagSet.add(tagName);
     for (ht.XmlAttributeNode attribute in node.attributes) {
       String attributeName = attribute.name;
       if (attributeName == ID_ATTRIBUTE) {
         String attributeValue = attribute.text;
@@ skipping 170 matching lines @@
         if (scriptSourcePath != null) {
           try {
             scriptSourcePath = Uri.encodeFull(scriptSourcePath);
             // Force an exception to be thrown if the URI is invalid so that we
             // can report the problem.
             parseUriWithException(scriptSourcePath);
             Source scriptSource =
                 _context.sourceFactory.resolveUri(htmlSource, scriptSourcePath);
             script.scriptSource = scriptSource;
             if (!_context.exists(scriptSource)) {
-              _reportValueError(
-                  HtmlWarningCode.URI_DOES_NOT_EXIST,
-                  scriptAttribute,
-                  [scriptSourcePath]);
+              _reportValueError(HtmlWarningCode.URI_DOES_NOT_EXIST,
+                  scriptAttribute, [scriptSourcePath]);
             }
           } on URISyntaxException catch (exception) {
-            _reportValueError(
-                HtmlWarningCode.INVALID_URI,
-                scriptAttribute,
-                [scriptSourcePath]);
+            _reportValueError(HtmlWarningCode.INVALID_URI, scriptAttribute, [
+              scriptSourcePath
+            ]);
           }
         }
         node.scriptElement = script;
         _scripts.add(script);
       }
     } finally {
       _parentNodes.remove(node);
     }
     return null;
   }
@@ skipping 74 matching lines @@
 
   /**
    * Report an error with the given error code at the given location. Use the given arguments to
    * compose the error message.
    *
    * @param errorCode the error code of the error to be reported
    * @param offset the offset of the first character to be highlighted
    * @param length the number of characters to be highlighted
    * @param arguments the arguments used to compose the error message
    */
-  void _reportErrorForOffset(ErrorCode errorCode, int offset, int length,
-      List<Object> arguments) {
-    _errorListener.onError(
-        new AnalysisError.con2(
-            _htmlElement.source,
-            offset,
-            length,
-            errorCode,
-            arguments));
+  void _reportErrorForOffset(
+      ErrorCode errorCode, int offset, int length, List<Object> arguments) {
+    _errorListener.onError(new AnalysisError.con2(
+        _htmlElement.source, offset, length, errorCode, arguments));
   }
 
   /**
    * Report an error with the given error code at the location of the value of the given attribute.
    * Use the given arguments to compose the error message.
    *
    * @param errorCode the error code of the error to be reported
    * @param offset the offset of the first character to be highlighted
    * @param length the number of characters to be highlighted
    * @param arguments the arguments used to compose the error message
@@ skipping 26 matching lines @@
   /**
    * Initialize a newly created visitor to build implicit constructors for file
    * [source], in library [libraryElement], which has scope [libraryScope]. Use
    * [typeProvider] to access types from the core library.
    *
    * The visit methods will pass closures to [_callback] to indicate what
    * computation needs to be performed, and its dependency order.
    */
   ImplicitConstructorBuilder(Source source, LibraryElement libraryElement,
       LibraryScope libraryScope, TypeProvider typeProvider, this._callback)
-      : super.con3(
-          libraryElement,
-          source,
-          typeProvider,
-          libraryScope,
+      : super.con3(libraryElement, source, typeProvider, libraryScope,
           libraryScope.errorListener);
 
   @override
   Object visitClassDeclaration(ClassDeclaration node) {
     ClassElementImpl classElement = node.element;
     classElement.mixinErrorsReported = false;
     if (node.extendsClause != null && node.withClause != null) {
       // We don't need to build any implicitly constructors for the mixin
       // application (since there isn't an explicit element for it), but we
       // need to verify that they _could_ be built.
       InterfaceType superclassType = null;
       TypeName superclassName = node.extendsClause.superclass;
       DartType type = superclassName.type;
       if (type is InterfaceType) {
         superclassType = type;
       } else {
         superclassType = typeProvider.objectType;
       }
       ClassElement superclassElement = classElement.supertype.element;
       if (superclassElement != null) {
         _callback(classElement, superclassElement, () {
           bool constructorFound = false;
           void callback(ConstructorElement explicitConstructor,
               List<DartType> parameterTypes, List<DartType> argumentTypes) {
             constructorFound = true;
           }
           if (_findForwardedConstructors(
-              classElement,
-              superclassName,
-              superclassType,
-              callback) &&
+                  classElement, superclassName, superclassType, callback) &&
               !constructorFound) {
-            reportErrorForNode(
-                CompileTimeErrorCode.MIXIN_HAS_NO_CONSTRUCTORS,
-                node.withClause,
-                [superclassType.element.name]);
+            reportErrorForNode(CompileTimeErrorCode.MIXIN_HAS_NO_CONSTRUCTORS,
+                node.withClause, [superclassType.element.name]);
             classElement.mixinErrorsReported = true;
           }
         });
       }
     }
     return null;
   }
 
   @override
   Object visitClassTypeAlias(ClassTypeAlias node) {
     super.visitClassTypeAlias(node);
     InterfaceType superclassType = null;
     TypeName superclassName = node.superclass;
     DartType type = superclassName.type;
     if (type is InterfaceType) {
       superclassType = type;
     } else {
       superclassType = typeProvider.objectType;
     }
     ClassElementImpl classElement = node.element as ClassElementImpl;
     if (classElement != null) {
       ClassElement superclassElement = superclassType.element;
       if (superclassElement != null) {
         _callback(classElement, superclassElement, () {
           List<ConstructorElement> implicitConstructors =
               new List<ConstructorElement>();
           void callback(ConstructorElement explicitConstructor,
               List<DartType> parameterTypes, List<DartType> argumentTypes) {
-            implicitConstructors.add(
-                _createImplicitContructor(
-                    classElement.type,
-                    explicitConstructor,
-                    parameterTypes,
-                    argumentTypes));
+            implicitConstructors.add(_createImplicitContructor(
+                classElement.type, explicitConstructor, parameterTypes,
+                argumentTypes));
           }
           if (_findForwardedConstructors(
-              classElement,
-              superclassName,
-              superclassType,
-              callback)) {
+              classElement, superclassName, superclassType, callback)) {
             if (implicitConstructors.isEmpty) {
-              reportErrorForNode(
-                  CompileTimeErrorCode.MIXIN_HAS_NO_CONSTRUCTORS,
-                  node,
-                  [superclassElement.name]);
+              reportErrorForNode(CompileTimeErrorCode.MIXIN_HAS_NO_CONSTRUCTORS,
+                  node, [superclassElement.name]);
             } else {
               classElement.constructors = implicitConstructors;
             }
           }
         });
       }
     }
     return null;
   }
 
@@ skipping 55 matching lines @@
    * Find all the constructors that should be forwarded from the superclass
    * named [superclassName], having type [superclassType], to the class or
    * mixin application [classElement], and pass information about them to
    * [callback].
    *
    * Return true if some constructors were considered.  (A false return value
    * can only happen if the supeclass is a built-in type, in which case it
    * can't be used as a mixin anyway).
    */
   bool _findForwardedConstructors(ClassElementImpl classElement,
-      TypeName superclassName, InterfaceType superclassType, void
-      callback(ConstructorElement explicitConstructor, List<DartType> parameterTypes,
-      List<DartType> argumentTypes)) {
+      TypeName superclassName, InterfaceType superclassType, void callback(
+          ConstructorElement explicitConstructor, List<DartType> parameterTypes,
+          List<DartType> argumentTypes)) {
     ClassElement superclassElement = superclassType.element;
     List<ConstructorElement> constructors = superclassElement.constructors;
     int count = constructors.length;
     if (count == 0) {
       return false;
     }
     List<DartType> parameterTypes =
         TypeParameterTypeImpl.getTypes(superclassType.typeParameters);
     List<DartType> argumentTypes =
         _getArgumentTypes(superclassName.typeArguments, parameterTypes);
     for (int i = 0; i < count; i++) {
       ConstructorElement explicitConstructor = constructors[i];
       if (!explicitConstructor.isFactory &&
           classElement.isSuperConstructorAccessible(explicitConstructor)) {
         callback(explicitConstructor, parameterTypes, argumentTypes);
       }
     }
     return true;
   }
 
   /**
    * Return an array of argument types that corresponds to the array of parameter types and that are
    * derived from the given list of type arguments.
    *
    * @param typeArguments the type arguments from which the types will be taken
    * @param parameterTypes the parameter types that must be matched by the type arguments
    * @return the argument types that correspond to the parameter types
    */
-  List<DartType> _getArgumentTypes(TypeArgumentList typeArguments,
-      List<DartType> parameterTypes) {
+  List<DartType> _getArgumentTypes(
+      TypeArgumentList typeArguments, List<DartType> parameterTypes) {
     DynamicTypeImpl dynamic = DynamicTypeImpl.instance;
     int parameterCount = parameterTypes.length;
     List<DartType> types = new List<DartType>(parameterCount);
     if (typeArguments == null) {
       for (int i = 0; i < parameterCount; i++) {
         types[i] = dynamic;
       }
     } else {
       NodeList<TypeName> arguments = typeArguments.arguments;
       int argumentCount = math.min(arguments.length, parameterCount);
@@ skipping 40 matching lines @@
   ImplicitConstructorComputer(this.typeProvider);
 
   /**
    * Add the given [unit] to the list of units which need to have implicit
    * constructors built for them.  [source] is the source file corresponding to
    * the compilation unit, [libraryElement] is the library element containing
    * that source, and [libraryScope] is the scope for the library element.
    */
   void add(CompilationUnit unit, Source source, LibraryElement libraryElement,
       LibraryScope libraryScope) {
-    unit.accept(
-        new ImplicitConstructorBuilder(
-            source,
-            libraryElement,
-            libraryScope,
-            typeProvider,
-            _defer));
+    unit.accept(new ImplicitConstructorBuilder(
+        source, libraryElement, libraryScope, typeProvider, _defer));
   }
 
   /**
    * Compute the implicit constructors for all compilation units that have been
    * passed to [add].
    */
   void compute() {
     List<List<ClassElement>> topologicalSort =
         _dependencies.computeTopologicalSort();
     for (List<ClassElement> classesInCycle in topologicalSort) {
       // Note: a cycle could occur if there is a loop in the inheritance graph.
       // Such loops are forbidden by Dart but could occur in the analysis of
       // incorrect code.  If this happens, we simply visit the classes
       // constituting the loop in any order.
       for (ClassElement classElement in classesInCycle) {
         VoidFunction computation = _computations[classElement];
         if (computation != null) {
           computation();
         }
       }
     }
   }
 
   /**
    * Defer execution of [computation], which builds implicit constructors for
    * [classElement], until after implicit constructors have been built for
    * [superclassElement].
    */
-  void _defer(ClassElement classElement, ClassElement superclassElement, void
-      computation()) {
+  void _defer(ClassElement classElement, ClassElement superclassElement,
+      void computation()) {
     assert(!_computations.containsKey(classElement));
     _computations[classElement] = computation;
     _dependencies.addEdge(classElement, superclassElement);
   }
 }
 
 /**
  * Instances of the class `ImplicitLabelScope` represent the scope statements
  * that can be the target of unlabeled break and continue statements.
  */
@@ skipping 138 matching lines @@
    * Any time after the defining compilation unit has been visited by this visitor, this method can
    * be called to report an [HintCode.DUPLICATE_IMPORT] hint for each of the import directives
    * in the [duplicateImports] list.
    *
    * @param errorReporter the error reporter to report the set of [HintCode.DUPLICATE_IMPORT]
    *          hints to
    */
   void generateDuplicateImportHints(ErrorReporter errorReporter) {
     for (ImportDirective duplicateImport in _duplicateImports) {
       errorReporter.reportErrorForNode(
-          HintCode.DUPLICATE_IMPORT,
-          duplicateImport.uri);
+          HintCode.DUPLICATE_IMPORT, duplicateImport.uri);
     }
   }
 
   /**
    * After all of the compilation units have been visited by this visitor, this method can be called
    * to report an [HintCode.UNUSED_IMPORT] hint for each of the import directives in the
    * [unusedImports] list.
    *
    * @param errorReporter the error reporter to report the set of [HintCode.UNUSED_IMPORT]
    *          hints to
    */
   void generateUnusedImportHints(ErrorReporter errorReporter) {
     for (ImportDirective unusedImport in _unusedImports) {
       // Check that the import isn't dart:core
       ImportElement importElement = unusedImport.element;
       if (importElement != null) {
         LibraryElement libraryElement = importElement.importedLibrary;
         if (libraryElement != null && libraryElement.isDartCore) {
           continue;
         }
       }
       errorReporter.reportErrorForNode(
-          HintCode.UNUSED_IMPORT,
-          unusedImport.uri);
+          HintCode.UNUSED_IMPORT, unusedImport.uri);
     }
   }
 
   @override
   Object visitCompilationUnit(CompilationUnit node) {
     if (_inDefiningCompilationUnit) {
       NodeList<Directive> directives = node.directives;
       for (Directive directive in directives) {
         if (directive is ImportDirective) {
           ImportDirective importDirective = directive;
@@ skipping 22 matching lines @@
             }
             //
             // Initialize libraryMap: libraryElement -> importDirective
             //
             _putIntoLibraryMap(libraryElement, importDirective);
             //
             // For this new addition to the libraryMap, also recursively add any
             // exports from the libraryElement.
             //
             _addAdditionalLibrariesForExports(
-                libraryElement,
-                importDirective,
-                new List<LibraryElement>());
+                libraryElement, importDirective, new List<LibraryElement>());
           }
         }
       }
     }
     // If there are no imports in this library, don't visit the identifiers in
     // the library- there can be no unused imports.
     if (_unusedImports.isEmpty) {
       return null;
     }
     if (_unusedImports.length > 1) {
@@ skipping 76 matching lines @@
    */
   void _addAdditionalLibrariesForExports(LibraryElement library,
       ImportDirective importDirective, List<LibraryElement> exportPath) {
     if (exportPath.contains(library)) {
       return;
     }
     exportPath.add(library);
     for (LibraryElement exportedLibraryElt in library.exportedLibraries) {
       _putIntoLibraryMap(exportedLibraryElt, importDirective);
       _addAdditionalLibrariesForExports(
-          exportedLibraryElt,
-          importDirective,
-          exportPath);
+          exportedLibraryElt, importDirective, exportPath);
     }
   }
 
   /**
    * Lookup and return the [Namespace] from the [namespaceMap], if the map does not
    * have the computed namespace, compute it and cache it in the map. If the import directive is not
    * resolved or is not resolvable, `null` is returned.
    *
    * @param importDirective the import directive used to compute the returned namespace
    * @return the computed or looked up [Namespace]
@@ skipping 12 matching lines @@
     }
     return namespace;
   }
 
   /**
    * The [libraryMap] is a mapping between a library elements and a list of import
    * directives, but when adding these mappings into the [libraryMap], this method can be
    * used to simply add the mapping between the library element an an import directive without
    * needing to check to see if a list needs to be created.
    */
-  void _putIntoLibraryMap(LibraryElement libraryElement,
-      ImportDirective importDirective) {
+  void _putIntoLibraryMap(
+      LibraryElement libraryElement, ImportDirective importDirective) {
     List<ImportDirective> importList = _libraryMap[libraryElement];
     if (importList == null) {
       importList = new List<ImportDirective>();
       _libraryMap[libraryElement] = importList;
     }
     importList.add(importDirective);
   }
 
   Object _visitIdentifier(Element element, String name) {
     if (element == null) {
@@ skipping 155 matching lines @@
    * Given some [ClassElement] and some member name, this returns the
    * [ExecutableElement] that the class inherits from the mixins,
    * superclasses or interfaces, that has the member name, if no member is inherited `null` is
    * returned.
    *
    * @param classElt the class element to query
    * @param memberName the name of the executable element to find and return
    * @return the inherited executable element with the member name, or `null` if no such
    *         member exists
    */
-  ExecutableElement lookupInheritance(ClassElement classElt,
-      String memberName) {
+  ExecutableElement lookupInheritance(
+      ClassElement classElt, String memberName) {
     if (memberName == null || memberName.isEmpty) {
       return null;
     }
     ExecutableElement executable = _computeClassChainLookupMap(
-        classElt,
-        new HashSet<ClassElement>()).get(memberName);
+        classElt, new HashSet<ClassElement>()).get(memberName);
     if (executable == null) {
-      return _computeInterfaceLookupMap(
-          classElt,
-          new HashSet<ClassElement>()).get(memberName);
+      return _computeInterfaceLookupMap(classElt, new HashSet<ClassElement>())
+          .get(memberName);
     }
     return executable;
   }
 
   /**
    * Given some [ClassElement] and some member name, this returns the
    * [ExecutableElement] that the class either declares itself, or
    * inherits, that has the member name, if no member is inherited `null` is returned.
    *
    * @param classElt the class element to query
@@ skipping 13 matching lines @@
    * Given some [InterfaceType] and some member name, this returns the
    * [FunctionType] of the [ExecutableElement] that the
    * class either declares itself, or inherits, that has the member name, if no member is inherited
    * `null` is returned. The returned [FunctionType] has all type
    * parameters substituted with corresponding type arguments from the given [InterfaceType].
    *
    * @param interfaceType the interface type to query
    * @param memberName the name of the executable element to find and return
    * @return the member's function type, or `null` if no such member exists
    */
-  FunctionType lookupMemberType(InterfaceType interfaceType,
-      String memberName) {
+  FunctionType lookupMemberType(
+      InterfaceType interfaceType, String memberName) {
     ExecutableElement iteratorMember =
         lookupMember(interfaceType.element, memberName);
     if (iteratorMember == null) {
       return null;
     }
     return substituteTypeArgumentsInMemberFromInheritance(
-        iteratorMember.type,
-        memberName,
-        interfaceType);
+        iteratorMember.type, memberName, interfaceType);
   }
 
   /**
    * Determine the set of methods which is overridden by the given class member. If no member is
    * inherited, an empty list is returned. If one of the inherited members is a
    * [MultiplyInheritedExecutableElement], then it is expanded into its constituent inherited
    * elements.
    *
    * @param classElt the class to query
    * @param memberName the name of the class member to query
    * @return a list of overridden methods
    */
-  List<ExecutableElement> lookupOverrides(ClassElement classElt,
-      String memberName) {
+  List<ExecutableElement> lookupOverrides(
+      ClassElement classElt, String memberName) {
     List<ExecutableElement> result = new List<ExecutableElement>();
     if (memberName == null || memberName.isEmpty) {
       return result;
     }
     List<MemberMap> interfaceMaps =
         _gatherInterfaceLookupMaps(classElt, new HashSet<ClassElement>());
     if (interfaceMaps != null) {
       for (MemberMap interfaceMap in interfaceMaps) {
         ExecutableElement overriddenElement = interfaceMap.get(memberName);
         if (overriddenElement != null) {
           if (overriddenElement is MultiplyInheritedExecutableElement) {
             MultiplyInheritedExecutableElement multiplyInheritedElement =
                 overriddenElement;
-            for (ExecutableElement element in
-                multiplyInheritedElement.inheritedElements) {
+            for (ExecutableElement element
+                in multiplyInheritedElement.inheritedElements) {
               result.add(element);
             }
           } else {
             result.add(overriddenElement);
           }
         }
       }
     }
     return result;
   }
 
   /**
    * This method takes some inherited [FunctionType], and resolves all the parameterized types
    * in the function type, dependent on the class in which it is being overridden.
    *
    * @param baseFunctionType the function type that is being overridden
    * @param memberName the name of the member, this is used to lookup the inheritance path of the
    *          override
    * @param definingType the type that is overriding the member
    * @return the passed function type with any parameterized types substituted
    */
-  FunctionType
-      substituteTypeArgumentsInMemberFromInheritance(FunctionType baseFunctionType,
-      String memberName, InterfaceType definingType) {
+  FunctionType substituteTypeArgumentsInMemberFromInheritance(
+      FunctionType baseFunctionType, String memberName,
+      InterfaceType definingType) {
     // if the baseFunctionType is null, or does not have any parameters,
     // return it.
     if (baseFunctionType == null ||
         baseFunctionType.typeArguments.length == 0) {
       return baseFunctionType;
     }
     // First, generate the path from the defining type to the overridden member
     Queue<InterfaceType> inheritancePath = new Queue<InterfaceType>();
     _computeInheritancePath(inheritancePath, definingType, memberName);
     if (inheritancePath == null || inheritancePath.isEmpty) {
@@ skipping 16 matching lines @@
    * Compute and return a mapping between the set of all string names of the members inherited from
    * the passed [ClassElement] superclass hierarchy, and the associated
    * [ExecutableElement].
    *
    * @param classElt the class element to query
    * @param visitedClasses a set of visited classes passed back into this method when it calls
    *          itself recursively
    * @return a mapping between the set of all string names of the members inherited from the passed
    *         [ClassElement] superclass hierarchy, and the associated [ExecutableElement]
    */
-  MemberMap _computeClassChainLookupMap(ClassElement classElt,
-      HashSet<ClassElement> visitedClasses) {
+  MemberMap _computeClassChainLookupMap(
+      ClassElement classElt, HashSet<ClassElement> visitedClasses) {
     MemberMap resultMap = _classLookup[classElt];
     if (resultMap != null) {
       return resultMap;
     } else {
       resultMap = new MemberMap();
     }
     ClassElement superclassElt = null;
     InterfaceType supertype = classElt.supertype;
     if (supertype != null) {
       superclassElt = supertype.element;
     } else {
       // classElt is Object
       _classLookup[classElt] = resultMap;
       return resultMap;
     }
     if (superclassElt != null) {
       if (!visitedClasses.contains(superclassElt)) {
         visitedClasses.add(superclassElt);
         try {
-          resultMap =
-              new MemberMap.con2(_computeClassChainLookupMap(superclassElt, visitedClasses));
+          resultMap = new MemberMap.con2(
+              _computeClassChainLookupMap(superclassElt, visitedClasses));
           //
           // Substitute the super types down the hierarchy.
           //
           _substituteTypeParametersDownHierarchy(supertype, resultMap);
           //
           // Include the members from the superclass in the resultMap.
           //
           _recordMapWithClassMembers(resultMap, supertype, false);
         } finally {
           visitedClasses.remove(superclassElt);
@@ skipping 11 matching lines @@
     // multiple mixins, visit them in the order listed so that methods in later
     // mixins will overwrite identically-named methods in earlier mixins.
     //
     List<InterfaceType> mixins = classElt.mixins;
     for (InterfaceType mixin in mixins) {
       ClassElement mixinElement = mixin.element;
       if (mixinElement != null) {
         if (!visitedClasses.contains(mixinElement)) {
           visitedClasses.add(mixinElement);
           try {
-            MemberMap map =
-                new MemberMap.con2(_computeClassChainLookupMap(mixinElement, visitedClasses));
+            MemberMap map = new MemberMap.con2(
+                _computeClassChainLookupMap(mixinElement, visitedClasses));
             //
             // Substitute the super types down the hierarchy.
             //
             _substituteTypeParametersDownHierarchy(mixin, map);
             //
             // Include the members from the superclass in the resultMap.
             //
             _recordMapWithClassMembers(map, mixin, false);
             //
             // Add the members from map into result map.
@@ skipping 92 matching lines @@
    * Compute and return a mapping between the set of all string names of the members inherited from
    * the passed [ClassElement] interface hierarchy, and the associated
    * [ExecutableElement].
    *
    * @param classElt the class element to query
    * @param visitedInterfaces a set of visited classes passed back into this method when it calls
    *          itself recursively
    * @return a mapping between the set of all string names of the members inherited from the passed
    *         [ClassElement] interface hierarchy, and the associated [ExecutableElement]
    */
-  MemberMap _computeInterfaceLookupMap(ClassElement classElt,
-      HashSet<ClassElement> visitedInterfaces) {
+  MemberMap _computeInterfaceLookupMap(
+      ClassElement classElt, HashSet<ClassElement> visitedInterfaces) {
     MemberMap resultMap = _interfaceLookup[classElt];
     if (resultMap != null) {
       return resultMap;
     }
     List<MemberMap> lookupMaps =
         _gatherInterfaceLookupMaps(classElt, visitedInterfaces);
     if (lookupMaps == null) {
       resultMap = new MemberMap();
     } else {
       HashMap<String, List<ExecutableElement>> unionMap =
@@ skipping 11 matching lines @@
    * returned by [computeInterfaceLookupMap] for the corresponding super, except with type
    * parameters appropriately substituted.
    *
    * @param classElt the class element to query
    * @param visitedInterfaces a set of visited classes passed back into this method when it calls
    *          itself recursively
    * @return `null` if there was a problem (such as a loop in the class hierarchy) or if there
    *         are no classes above this one in the class hierarchy. Otherwise, a list of interface
    *         lookup maps.
    */
-  List<MemberMap> _gatherInterfaceLookupMaps(ClassElement classElt,
-      HashSet<ClassElement> visitedInterfaces) {
+  List<MemberMap> _gatherInterfaceLookupMaps(
+      ClassElement classElt, HashSet<ClassElement> visitedInterfaces) {
     InterfaceType supertype = classElt.supertype;
     ClassElement superclassElement =
         supertype != null ? supertype.element : null;
     List<InterfaceType> mixins = classElt.mixins;
     List<InterfaceType> interfaces = classElt.interfaces;
     // Recursively collect the list of mappings from all of the interface types
     List<MemberMap> lookupMaps = new List<MemberMap>();
     //
     // Superclass element
     //
@@ skipping 96 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) {
+  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) {
         return method;
       }
     }
     List<PropertyAccessorElement> accessors = classElt.accessors;
     for (PropertyAccessorElement accessor in accessors) {
       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 type
    * into the passed map.
    *
    * @param map some non-`null` map to put the methods and accessors from the passed
    *          [ClassElement] into
    * @param type the type that will be recorded into the passed map
    * @param doIncludeAbstract `true` if abstract members will be put into the map
    */
-  void _recordMapWithClassMembers(MemberMap map, InterfaceType type,
-      bool doIncludeAbstract) {
+  void _recordMapWithClassMembers(
+      MemberMap map, InterfaceType type, bool doIncludeAbstract) {
     List<MethodElement> methods = type.methods;
     for (MethodElement method in methods) {
       if (method.isAccessibleIn(_library) &&
           !method.isStatic &&
           (doIncludeAbstract || !method.isAbstract)) {
         map.put(method.name, method);
       }
     }
     List<PropertyAccessorElement> accessors = type.accessors;
     for (PropertyAccessorElement accessor in accessors) {
@@ skipping 16 matching lines @@
    * @param errorCode the error code to be associated with this error
    * @param arguments the arguments used to build the error message
    */
   void _reportError(ClassElement classElt, int offset, int length,
       ErrorCode errorCode, List<Object> arguments) {
     HashSet<AnalysisError> errorSet = _errorsInClassElement[classElt];
     if (errorSet == null) {
       errorSet = new HashSet<AnalysisError>();
       _errorsInClassElement[classElt] = errorSet;
     }
-    errorSet.add(
-        new AnalysisError.con2(classElt.source, offset, length, errorCode, arguments));
+    errorSet.add(new AnalysisError.con2(
+        classElt.source, offset, length, errorCode, arguments));
   }
 
   /**
    * Given the set of methods defined by classes above [classElt] in the class hierarchy,
    * apply the appropriate inheritance rules to determine those methods inherited by or overridden
    * by [classElt]. Also report static warnings
    * [StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE] and
    * [StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD] if appropriate.
    *
    * @param classElt the class element to query.
    * @param unionMap a mapping from method name to the set of unique (in terms of signature) methods
    *          defined in superclasses of [classElt].
    * @return the inheritance lookup map for [classElt].
    */
-  MemberMap _resolveInheritanceLookup(ClassElement classElt, HashMap<String,
-      List<ExecutableElement>> unionMap) {
+  MemberMap _resolveInheritanceLookup(ClassElement classElt,
+      HashMap<String, List<ExecutableElement>> unionMap) {
     MemberMap resultMap = new MemberMap();
     unionMap.forEach((String key, List<ExecutableElement> list) {
       int numOfEltsWithMatchingNames = list.length;
       if (numOfEltsWithMatchingNames == 1) {
         //
         // Example: class A inherits only 1 method named 'm'.
         // Since it is the only such method, it is inherited.
         // Another example: class A inherits 2 methods named 'm' from 2
         // different interfaces, but they both have the same signature, so it is
         // the method inherited.
@@ skipping 34 matching lines @@
           for (int i = 0; i < numOfEltsWithMatchingNames; i++) {
             executableElementTypes[i] = elements[i].type;
           }
           List<int> subtypesOfAllOtherTypesIndexes = new List<int>();
           for (int i = 0; i < numOfEltsWithMatchingNames; i++) {
             FunctionType subtype = executableElementTypes[i];
             if (subtype == null) {
               continue;
             }
             bool subtypeOfAllTypes = true;
-            for (int j =
-                0; j < numOfEltsWithMatchingNames && subtypeOfAllTypes; j++) {
+            for (int j = 0;
+                j < numOfEltsWithMatchingNames && subtypeOfAllTypes;
+                j++) {
               if (i != j) {
                 if (!subtype.isSubtypeOf(executableElementTypes[j])) {
                   subtypeOfAllTypes = false;
                   break;
                 }
               }
             }
             if (subtypeOfAllTypes) {
               subtypesOfAllOtherTypesIndexes.add(i);
             }
@@ skipping 32 matching lines @@
               }
               //
               // Example: class A inherited only 2 method named 'm'.
               // One has the function type '() -> int' and one has the function
               // type '() -> String'. Since neither is a subtype of the other,
               // we create a warning, and have this class inherit nothing.
               //
               if (!classHasMember) {
                 String firstTwoFuntionTypesStr =
                     "${executableElementTypes[0]}, ${executableElementTypes[1]}";
-                _reportError(
-                    classElt,
-                    classElt.nameOffset,
+                _reportError(classElt, classElt.nameOffset,
                     classElt.displayName.length,
-                    StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE,
-                    [key, firstTwoFuntionTypesStr]);
+                    StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE, [
+                  key,
+                  firstTwoFuntionTypesStr
+                ]);
               }
             } else {
               //
               // Example: class A inherits 2 methods named 'm'.
               // One has the function type '(int) -> dynamic' and one has the
               // function type '(num) -> dynamic'. Since they are both a subtype
               // of the other, a synthetic function '(dynamic) -> dynamic' is
               // inherited.
               // Tests: test_getMapOfMembersInheritedFromInterfaces_
               // union_multipleSubtypes_*
               //
               List<ExecutableElement> elementArrayToMerge =
-                  new List<ExecutableElement>(subtypesOfAllOtherTypesIndexes.length);
+                  new List<ExecutableElement>(
+                      subtypesOfAllOtherTypesIndexes.length);
               for (int i = 0; i < elementArrayToMerge.length; i++) {
                 elementArrayToMerge[i] =
                     elements[subtypesOfAllOtherTypesIndexes[i]];
               }
               ExecutableElement mergedExecutableElement =
                   _computeMergedExecutableElement(elementArrayToMerge);
               resultMap.put(key, mergedExecutableElement);
             }
           }
         } else {
-          _reportError(
-              classElt,
-              classElt.nameOffset,
+          _reportError(classElt, classElt.nameOffset,
               classElt.displayName.length,
               StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD,
               [key]);
         }
       }
     });
     return resultMap;
   }
 
   /**
    * Loop through all of the members in some [MemberMap], performing type parameter
    * substitutions using a passed supertype.
    *
    * @param superType the supertype to substitute into the members of the [MemberMap]
    * @param map the MemberMap to perform the substitutions on
    */
-  void _substituteTypeParametersDownHierarchy(InterfaceType superType,
-      MemberMap map) {
+  void _substituteTypeParametersDownHierarchy(
+      InterfaceType superType, MemberMap map) {
     for (int i = 0; i < map.size; i++) {
       ExecutableElement executableElement = map.getValue(i);
       if (executableElement is MethodMember) {
         executableElement =
             MethodMember.from(executableElement as MethodMember, superType);
         map.setValue(i, executableElement);
       } else if (executableElement is PropertyAccessorMember) {
         executableElement = PropertyAccessorMember.from(
-            executableElement as PropertyAccessorMember,
-            superType);
+            executableElement as PropertyAccessorMember, superType);
         map.setValue(i, executableElement);
       }
     }
   }
 
   /**
    * Union all of the [lookupMaps] together into a single map, grouping the ExecutableElements
    * into a list where none of the elements are equal where equality is determined by having equal
    * function types. (We also take note too of the kind of the element: ()->int and () -> int may
    * not be equal if one is a getter and the other is a method.)
    *
    * @param lookupMaps the maps to be unioned together.
    * @return the resulting union map.
    */
-  HashMap<String, List<ExecutableElement>>
-      _unionInterfaceLookupMaps(List<MemberMap> lookupMaps) {
+  HashMap<String, List<ExecutableElement>> _unionInterfaceLookupMaps(
+      List<MemberMap> lookupMaps) {
     HashMap<String, List<ExecutableElement>> unionMap =
         new HashMap<String, List<ExecutableElement>>();
     for (MemberMap lookupMap in lookupMaps) {
       int lookupMapSize = lookupMap.size;
       for (int i = 0; i < lookupMapSize; i++) {
         // Get the string key, if null, break.
         String key = lookupMap.getKey(i);
         if (key == null) {
           break;
         }
@@ skipping 12 matching lines @@
           list.add(newExecutableElementEntry);
         } else {
           // Otherwise, only add the newExecutableElementEntry if it isn't
           // already in the list, this covers situation where a class inherits
           // two methods (or two getters) that are identical.
           bool alreadyInList = false;
           bool isMethod1 = newExecutableElementEntry is MethodElement;
           for (ExecutableElement executableElementInList in list) {
             bool isMethod2 = executableElementInList is MethodElement;
             if (isMethod1 == isMethod2 &&
-                executableElementInList.type == newExecutableElementEntry.type) {
+                executableElementInList.type ==
+                    newExecutableElementEntry.type) {
               alreadyInList = true;
               break;
             }
           }
           if (!alreadyInList) {
             list.add(newExecutableElementEntry);
           }
         }
       }
     }
     return unionMap;
   }
 
   /**
    * Given some array of [ExecutableElement]s, this method creates a synthetic element as
    * described in 8.1.1:
    *
    * Let <i>numberOfPositionals</i>(<i>f</i>) denote the number of positional parameters of a
    * function <i>f</i>, and let <i>numberOfRequiredParams</i>(<i>f</i>) denote the number of
    * required parameters of a function <i>f</i>. Furthermore, let <i>s</i> denote the set of all
    * named parameters of the <i>m<sub>1</sub>, &hellip;, m<sub>k</sub></i>. Then let
    * * <i>h = max(numberOfPositionals(m<sub>i</sub>)),</i>
    * * <i>r = min(numberOfRequiredParams(m<sub>i</sub>)), for all <i>i</i>, 1 <= i <= k.</i>
    * Then <i>I</i> has a method named <i>n</i>, with <i>r</i> required parameters of type
    * <b>dynamic</b>, <i>h</i> positional parameters of type <b>dynamic</b>, named parameters
    * <i>s</i> of type <b>dynamic</b> and return type <b>dynamic</b>.
    *
    */
-  static ExecutableElement
-      _computeMergedExecutableElement(List<ExecutableElement> elementArrayToMerge) {
+  static ExecutableElement _computeMergedExecutableElement(
+      List<ExecutableElement> elementArrayToMerge) {
     int h = _getNumOfPositionalParameters(elementArrayToMerge[0]);
     int r = _getNumOfRequiredParameters(elementArrayToMerge[0]);
     Set<String> namedParametersList = new HashSet<String>();
     for (int i = 1; i < elementArrayToMerge.length; i++) {
       ExecutableElement element = elementArrayToMerge[i];
       int numOfPositionalParams = _getNumOfPositionalParameters(element);
       if (h < numOfPositionalParams) {
         h = numOfPositionalParams;
       }
       int numOfRequiredParams = _getNumOfRequiredParameters(element);
       if (r > numOfRequiredParams) {
         r = numOfRequiredParams;
       }
       namedParametersList.addAll(_getNamedParameterNames(element));
     }
-    return _createSyntheticExecutableElement(
-        elementArrayToMerge,
-        elementArrayToMerge[0].displayName,
-        r,
-        h - r,
+    return _createSyntheticExecutableElement(elementArrayToMerge,
+        elementArrayToMerge[0].displayName, r, h - r,
         new List.from(namedParametersList));
   }
 
   /**
    * Used by [computeMergedExecutableElement] to actually create the
    * synthetic element.
    *
    * @param elementArrayToMerge the array used to create the synthetic element
    * @param name the name of the method, getter or setter
    * @param numOfRequiredParameters the number of required parameters
    * @param numOfPositionalParameters the number of positional parameters
    * @param namedParameters the list of [String]s that are the named parameters
    * @return the created synthetic element
    */
-  static ExecutableElement
-      _createSyntheticExecutableElement(List<ExecutableElement> elementArrayToMerge,
-      String name, int numOfRequiredParameters, int numOfPositionalParameters,
+  static ExecutableElement _createSyntheticExecutableElement(
+      List<ExecutableElement> elementArrayToMerge, String name,
+      int numOfRequiredParameters, int numOfPositionalParameters,
       List<String> namedParameters) {
     DynamicTypeImpl dynamicType = DynamicTypeImpl.instance;
-    SimpleIdentifier nameIdentifier =
-        new SimpleIdentifier(new sc.StringToken(sc.TokenType.IDENTIFIER, name, 0));
+    SimpleIdentifier nameIdentifier = new SimpleIdentifier(
+        new sc.StringToken(sc.TokenType.IDENTIFIER, name, 0));
     ExecutableElementImpl executable;
     if (elementArrayToMerge[0] is MethodElement) {
       MultiplyInheritedMethodElementImpl unionedMethod =
           new MultiplyInheritedMethodElementImpl(nameIdentifier);
       unionedMethod.inheritedElements = elementArrayToMerge;
       executable = unionedMethod;
     } else {
       MultiplyInheritedPropertyAccessorElementImpl unionedPropertyAccessor =
           new MultiplyInheritedPropertyAccessorElementImpl(nameIdentifier);
       unionedPropertyAccessor.getter =
           (elementArrayToMerge[0] as PropertyAccessorElement).isGetter;
       unionedPropertyAccessor.setter =
           (elementArrayToMerge[0] as PropertyAccessorElement).isSetter;
       unionedPropertyAccessor.inheritedElements = elementArrayToMerge;
       executable = unionedPropertyAccessor;
     }
-    int numOfParameters =
-        numOfRequiredParameters +
+    int numOfParameters = numOfRequiredParameters +
         numOfPositionalParameters +
         namedParameters.length;
     List<ParameterElement> parameters =
         new List<ParameterElement>(numOfParameters);
     int i = 0;
     for (int j = 0; j < numOfRequiredParameters; j++, i++) {
       ParameterElementImpl parameter = new ParameterElementImpl("", 0);
       parameter.type = dynamicType;
       parameter.parameterKind = ParameterKind.REQUIRED;
       parameters[i] = parameter;
@@ skipping 14 matching lines @@
     executable.returnType = dynamicType;
     executable.parameters = parameters;
     FunctionTypeImpl methodType = new FunctionTypeImpl.con1(executable);
     executable.type = methodType;
     return executable;
   }
 
   /**
    * Given some [ExecutableElement], return the list of named parameters.
    */
-  static List<String>
-      _getNamedParameterNames(ExecutableElement executableElement) {
+  static List<String> _getNamedParameterNames(
+      ExecutableElement executableElement) {
     List<String> namedParameterNames = new List<String>();
     List<ParameterElement> parameters = executableElement.parameters;
     for (int i = 0; i < parameters.length; i++) {
       ParameterElement parameterElement = parameters[i];
       if (parameterElement.parameterKind == ParameterKind.NAMED) {
         namedParameterNames.add(parameterElement.name);
       }
     }
     return namedParameterNames;
   }
 
   /**
    * Given some [ExecutableElement] return the number of parameters of the specified kind.
    */
-  static int _getNumOfParameters(ExecutableElement executableElement,
-      ParameterKind parameterKind) {
+  static int _getNumOfParameters(
+      ExecutableElement executableElement, ParameterKind parameterKind) {
     int parameterCount = 0;
     List<ParameterElement> parameters = executableElement.parameters;
     for (int i = 0; i < parameters.length; i++) {
       ParameterElement parameterElement = parameters[i];
       if (parameterElement.parameterKind == parameterKind) {
         parameterCount++;
       }
     }
     return parameterCount;
   }
 
   /**
    * Given some [ExecutableElement] return the number of positional parameters.
    *
    * Note: by positional we mean [ParameterKind.REQUIRED] or [ParameterKind.POSITIONAL].
    */
-  static int
-      _getNumOfPositionalParameters(ExecutableElement executableElement) =>
+  static int _getNumOfPositionalParameters(
+          ExecutableElement executableElement) =>
       _getNumOfParameters(executableElement, ParameterKind.REQUIRED) +
           _getNumOfParameters(executableElement, ParameterKind.POSITIONAL);
 
   /**
    * Given some [ExecutableElement] return the number of required parameters.
    */
   static int _getNumOfRequiredParameters(ExecutableElement executableElement) =>
       _getNumOfParameters(executableElement, ParameterKind.REQUIRED);
 
   /**
@@ skipping 24 matching lines @@
   static const INIT_STATE INIT_IN_DECLARATION =
       const INIT_STATE('INIT_IN_DECLARATION', 1);
 
   static const INIT_STATE INIT_IN_FIELD_FORMAL =
       const INIT_STATE('INIT_IN_FIELD_FORMAL', 2);
 
   static const INIT_STATE INIT_IN_INITIALIZERS =
       const INIT_STATE('INIT_IN_INITIALIZERS', 3);
 
   static const List<INIT_STATE> values = const [
-      NOT_INIT,
-      INIT_IN_DECLARATION,
-      INIT_IN_FIELD_FORMAL,
-      INIT_IN_INITIALIZERS];
+    NOT_INIT,
+    INIT_IN_DECLARATION,
+    INIT_IN_FIELD_FORMAL,
+    INIT_IN_INITIALIZERS
+  ];
 
   const INIT_STATE(String name, int ordinal) : super(name, ordinal);
 }
 
 /**
  * Instances of the class `LabelScope` represent a scope in which a single label is defined.
  */
 class LabelScope {
   /**
    * The label scope enclosing this label scope.
@@ skipping 221 matching lines @@
   }
 
   /**
    * Return the library element representing this library, creating it if necessary.
    *
    * @return the library element representing this library
    */
   LibraryElementImpl get libraryElement {
     if (_libraryElement == null) {
       try {
-        _libraryElement =
-            _analysisContext.computeLibraryElement(librarySource) as LibraryElementImpl;
+        _libraryElement = _analysisContext
+            .computeLibraryElement(librarySource) as LibraryElementImpl;
       } on AnalysisException catch (exception, stackTrace) {
         AnalysisEngine.instance.logger.logError(
             "Could not compute library element for ${librarySource.fullName}",
             new CaughtException(exception, stackTrace));
       }
     }
     return _libraryElement;
   }
 
   /**
@@ skipping 39 matching lines @@
   /**
    * Return the result of resolving the URI of the given URI-based directive against the URI of the
    * library, or `null` if the URI is not valid. If the URI is not valid, report the error.
    *
    * @param directive the directive which URI should be resolved
    * @return the result of resolving the URI against the URI of the library
    */
   Source getSource(UriBasedDirective directive) {
     StringLiteral uriLiteral = directive.uri;
     if (uriLiteral is StringInterpolation) {
-      _errorListener.onError(
-          new AnalysisError.con2(
-              librarySource,
-              uriLiteral.offset,
-              uriLiteral.length,
-              CompileTimeErrorCode.URI_WITH_INTERPOLATION));
+      _errorListener.onError(new AnalysisError.con2(librarySource,
+          uriLiteral.offset, uriLiteral.length,
+          CompileTimeErrorCode.URI_WITH_INTERPOLATION));
       return null;
     }
     String uriContent = uriLiteral.stringValue.trim();
     _directiveUris[directive] = uriContent;
     uriContent = Uri.encodeFull(uriContent);
     if (directive is ImportDirective &&
         uriContent.startsWith(_DART_EXT_SCHEME)) {
       _libraryElement.hasExtUri = true;
       return null;
     }
     try {
       parseUriWithException(uriContent);
       Source source =
           _analysisContext.sourceFactory.resolveUri(librarySource, uriContent);
       if (!_analysisContext.exists(source)) {
-        _errorListener.onError(
-            new AnalysisError.con2(
-                librarySource,
-                uriLiteral.offset,
-                uriLiteral.length,
-                CompileTimeErrorCode.URI_DOES_NOT_EXIST,
-                [uriContent]));
+        _errorListener.onError(new AnalysisError.con2(librarySource,
+            uriLiteral.offset, uriLiteral.length,
+            CompileTimeErrorCode.URI_DOES_NOT_EXIST, [uriContent]));
       }
       return source;
     } on URISyntaxException catch (exception) {
-      _errorListener.onError(
-          new AnalysisError.con2(
-              librarySource,
-              uriLiteral.offset,
-              uriLiteral.length,
-              CompileTimeErrorCode.INVALID_URI,
-              [uriContent]));
+      _errorListener.onError(new AnalysisError.con2(librarySource,
+          uriLiteral.offset, uriLiteral.length,
+          CompileTimeErrorCode.INVALID_URI, [uriContent]));
     }
     return null;
   }
 
   /**
    * Returns the URI value of the given directive.
    */
   String getUri(UriBasedDirective directive) => _directiveUris[directive];
 
   /**
@@ skipping 83 matching lines @@
           part.uriOffset = partUri.offset;
           part.uriEnd = partUri.end;
           part.uri = partDirective.uriContent;
           //
           // Validate that the part contains a part-of directive with the same
           // name as the library.
           //
           String partLibraryName =
               _getPartLibraryName(partSource, partUnit, directivesToResolve);
           if (partLibraryName == null) {
-            _errorListener.onError(
-                new AnalysisError.con2(
-                    librarySource,
-                    partUri.offset,
-                    partUri.length,
-                    CompileTimeErrorCode.PART_OF_NON_PART,
-                    [partUri.toSource()]));
+            _errorListener.onError(new AnalysisError.con2(librarySource,
+                partUri.offset, partUri.length,
+                CompileTimeErrorCode.PART_OF_NON_PART, [partUri.toSource()]));
           } else if (libraryNameNode == null) {
             // TODO(brianwilkerson) Collect the names declared by the part.
             // If they are all the same then we can use that name as the
             // inferred name of the library and present it in a quick-fix.
             // partLibraryNames.add(partLibraryName);
           } else if (libraryNameNode.name != partLibraryName) {
-            _errorListener.onError(
-                new AnalysisError.con2(
-                    librarySource,
-                    partUri.offset,
-                    partUri.length,
-                    StaticWarningCode.PART_OF_DIFFERENT_LIBRARY,
-                    [libraryNameNode.name, partLibraryName]));
+            _errorListener.onError(new AnalysisError.con2(librarySource,
+                partUri.offset, partUri.length,
+                StaticWarningCode.PART_OF_DIFFERENT_LIBRARY, [
+              libraryNameNode.name,
+              partLibraryName
+            ]));
           }
           if (entryPoint == null) {
             entryPoint = _findEntryPoint(part);
           }
           directive.element = part;
           sourcedCompilationUnits.add(part);
         }
       }
     }
     if (hasPartDirective && libraryNameNode == null) {
-      _errorListener.onError(
-          new AnalysisError.con1(
-              librarySource,
-              ResolverErrorCode.MISSING_LIBRARY_DIRECTIVE_WITH_PART));
+      _errorListener.onError(new AnalysisError.con1(librarySource,
+          ResolverErrorCode.MISSING_LIBRARY_DIRECTIVE_WITH_PART));
     }
     //
     // Create and populate the library element.
     //
     LibraryElementImpl libraryElement = new LibraryElementImpl.forNode(
-        _analysisContext.getContextFor(librarySource),
-        libraryNameNode);
+        _analysisContext.getContextFor(librarySource), libraryNameNode);
     libraryElement.definingCompilationUnit = definingCompilationUnitElement;
     if (entryPoint != null) {
       libraryElement.entryPoint = entryPoint;
     }
     int sourcedUnitCount = sourcedCompilationUnits.length;
     libraryElement.parts = sourcedCompilationUnits;
     for (Directive directive in directivesToResolve) {
       directive.element = libraryElement;
     }
     library.libraryElement = libraryElement;
@@ skipping 50 matching lines @@
             part.uriOffset = partUri.offset;
             part.uriEnd = partUri.end;
             part.uri = partDirective.uriContent;
             //
             // Validate that the part contains a part-of directive with the same
             // name as the library.
             //
             String partLibraryName =
                 _getPartLibraryName(partSource, partUnit, directivesToResolve);
             if (partLibraryName == null) {
-              _errorListener.onError(
-                  new AnalysisError.con2(
-                      librarySource,
-                      partUri.offset,
-                      partUri.length,
-                      CompileTimeErrorCode.PART_OF_NON_PART,
-                      [partUri.toSource()]));
+              _errorListener.onError(new AnalysisError.con2(librarySource,
+                  partUri.offset, partUri.length,
+                  CompileTimeErrorCode.PART_OF_NON_PART, [partUri.toSource()]));
             } else if (libraryNameNode == null) {
               // TODO(brianwilkerson) Collect the names declared by the part.
               // If they are all the same then we can use that name as the
               // inferred name of the library and present it in a quick-fix.
               // partLibraryNames.add(partLibraryName);
             } else if (libraryNameNode.name != partLibraryName) {
-              _errorListener.onError(
-                  new AnalysisError.con2(
-                      librarySource,
-                      partUri.offset,
-                      partUri.length,
-                      StaticWarningCode.PART_OF_DIFFERENT_LIBRARY,
-                      [libraryNameNode.name, partLibraryName]));
+              _errorListener.onError(new AnalysisError.con2(librarySource,
+                  partUri.offset, partUri.length,
+                  StaticWarningCode.PART_OF_DIFFERENT_LIBRARY, [
+                libraryNameNode.name,
+                partLibraryName
+              ]));
             }
             if (entryPoint == null) {
               entryPoint = _findEntryPoint(part);
             }
             directive.element = part;
             sourcedCompilationUnits.add(part);
           }
         }
       }
     }
     if (hasPartDirective && libraryNameNode == null) {
-      _errorListener.onError(
-          new AnalysisError.con1(
-              librarySource,
-              ResolverErrorCode.MISSING_LIBRARY_DIRECTIVE_WITH_PART));
+      _errorListener.onError(new AnalysisError.con1(librarySource,
+          ResolverErrorCode.MISSING_LIBRARY_DIRECTIVE_WITH_PART));
     }
     //
     // Create and populate the library element.
     //
     LibraryElementImpl libraryElement = new LibraryElementImpl.forNode(
-        _analysisContext.getContextFor(librarySource),
-        libraryNameNode);
+        _analysisContext.getContextFor(librarySource), libraryNameNode);
     libraryElement.definingCompilationUnit = definingCompilationUnitElement;
     if (entryPoint != null) {
       libraryElement.entryPoint = entryPoint;
     }
     int sourcedUnitCount = sourcedCompilationUnits.length;
     libraryElement.parts = sourcedCompilationUnits;
     for (Directive directive in directivesToResolve) {
       directive.element = libraryElement;
     }
     library.libraryElement = libraryElement;
@@ skipping 134 matching lines @@
   @override
   Source getSource(AstNode node) {
     Source source = super.getSource(node);
     if (source == null) {
       source = _definingLibrary.definingCompilationUnit.source;
     }
     return source;
   }
 
   @override
-  Element internalLookup(Identifier identifier, String name,
-      LibraryElement referencingLibrary) {
+  Element internalLookup(
+      Identifier identifier, String name, LibraryElement referencingLibrary) {
     Element foundElement = localLookup(name, referencingLibrary);
     if (foundElement != null) {
       return foundElement;
     }
     for (int i = 0; i < _importedNamespaces.length; i++) {
       Namespace nameSpace = _importedNamespaces[i];
       Element element = nameSpace.get(name);
       if (element != null) {
         if (foundElement == null) {
           foundElement = element;
         } else if (!identical(foundElement, element)) {
           foundElement = MultiplyDefinedElementImpl.fromElements(
-              _definingLibrary.context,
-              foundElement,
-              element);
+              _definingLibrary.context, foundElement, element);
         }
       }
     }
     if (foundElement is MultiplyDefinedElementImpl) {
       foundElement = _removeSdkElements(
-          identifier,
-          name,
-          foundElement as MultiplyDefinedElementImpl);
+          identifier, name, foundElement as MultiplyDefinedElementImpl);
     }
     if (foundElement is MultiplyDefinedElementImpl) {
       String foundEltName = foundElement.displayName;
       List<Element> conflictingMembers =
           (foundElement as MultiplyDefinedElementImpl).conflictingElements;
       int count = conflictingMembers.length;
       List<String> libraryNames = new List<String>(count);
       for (int i = 0; i < count; i++) {
         libraryNames[i] = _getLibraryName(conflictingMembers[i]);
       }
       libraryNames.sort();
-      errorListener.onError(
-          new AnalysisError.con2(
-              getSource(identifier),
-              identifier.offset,
-              identifier.length,
-              StaticWarningCode.AMBIGUOUS_IMPORT,
-              [foundEltName, StringUtilities.printListOfQuotedNames(libraryNames)]));
+      errorListener.onError(new AnalysisError.con2(getSource(identifier),
+          identifier.offset, identifier.length,
+          StaticWarningCode.AMBIGUOUS_IMPORT, [
+        foundEltName,
+        StringUtilities.printListOfQuotedNames(libraryNames)
+      ]));
       return foundElement;
     }
     if (foundElement != null) {
       defineNameWithoutChecking(name, foundElement);
     }
     return foundElement;
   }
 
   /**
    * Create all of the namespaces associated with the libraries imported into this library. The
@@ skipping 31 matching lines @@
     int count = imports.length;
     for (int i = 0; i < count; i++) {
       if (identical(imports[i].importedLibrary, library)) {
         return library.definingCompilationUnit.displayName;
       }
     }
     List<String> indirectSources = new List<String>();
     for (int i = 0; i < count; i++) {
       LibraryElement importedLibrary = imports[i].importedLibrary;
       if (importedLibrary != null) {
-        for (LibraryElement exportedLibrary in
-            importedLibrary.exportedLibraries) {
+        for (LibraryElement exportedLibrary
+            in importedLibrary.exportedLibraries) {
           if (identical(exportedLibrary, library)) {
-            indirectSources.add(
-                importedLibrary.definingCompilationUnit.displayName);
+            indirectSources
+                .add(importedLibrary.definingCompilationUnit.displayName);
           }
         }
       }
     }
     int indirectCount = indirectSources.length;
     StringBuffer buffer = new StringBuffer();
     buffer.write(library.definingCompilationUnit.displayName);
     if (indirectCount > 0) {
       buffer.write(" (via ");
       if (indirectCount > 1) {
@@ skipping 26 matching lines @@
     for (Element member in conflictingMembers) {
       if (member.library.isInSdk) {
         sdkElement = member;
       } else {
         conflictingMembers[to++] = member;
       }
     }
     if (sdkElement != null && to > 0) {
       String sdkLibName = _getLibraryName(sdkElement);
       String otherLibName = _getLibraryName(conflictingMembers[0]);
-      errorListener.onError(
-          new AnalysisError.con2(
-              getSource(identifier),
-              identifier.offset,
-              identifier.length,
-              StaticWarningCode.CONFLICTING_DART_IMPORT,
-              [name, sdkLibName, otherLibName]));
+      errorListener.onError(new AnalysisError.con2(getSource(identifier),
+          identifier.offset, identifier.length,
+          StaticWarningCode.CONFLICTING_DART_IMPORT, [
+        name,
+        sdkLibName,
+        otherLibName
+      ]));
     }
     if (to == length) {
       // None of the members were removed
       return foundElement;
     } else if (to == 1) {
       // All but one member was removed
       return conflictingMembers[0];
     } else if (to == 0) {
       // All members were removed
-      AnalysisEngine.instance.logger.logInformation(
-          "Multiply defined SDK element: $foundElement");
+      AnalysisEngine.instance.logger
+          .logInformation("Multiply defined SDK element: $foundElement");
       return foundElement;
     }
     List<Element> remaining = new List<Element>(to);
     JavaSystem.arraycopy(conflictingMembers, 0, remaining, 0, to);
     return new MultiplyDefinedElementImpl(_definingLibrary.context, remaining);
   }
 }
 
 /**
  * Instances of the class `LibraryResolver` are used to resolve one or more mutually dependent
@@ skipping 93 matching lines @@
    * Resolve the library specified by the given source in the given context. The library is assumed
    * to be embedded in the given source.
    *
    * @param librarySource the source specifying the defining compilation unit of the library to be
    *          resolved
    * @param unit the compilation unit representing the embedded library
    * @param fullAnalysis `true` if a full analysis should be performed
    * @return the element representing the resolved library
    * @throws AnalysisException if the library could not be resolved for some reason
    */
-  LibraryElement resolveEmbeddedLibrary(Source librarySource,
-      CompilationUnit unit, bool fullAnalysis) {
+  LibraryElement resolveEmbeddedLibrary(
+      Source librarySource, CompilationUnit unit, bool fullAnalysis) {
     //
     // Create the objects representing the library being resolved and the core
     // library.
     //
     Library targetLibrary = _createLibraryWithUnit(librarySource, unit);
     _coreLibrary = _libraryMap[_coreLibrarySource];
     if (_coreLibrary == null) {
       // This will only happen if the library being analyzed is the core
       // library.
       _coreLibrary = createLibrary(_coreLibrarySource);
       if (_coreLibrary == null) {
         LibraryResolver2.missingCoreLibrary(
-            analysisContext,
-            _coreLibrarySource);
+            analysisContext, _coreLibrarySource);
       }
     }
     _asyncLibrary = _libraryMap[_asyncLibrarySource];
     if (_asyncLibrary == null) {
       // This will only happen if the library being analyzed is the async
       // library.
       _asyncLibrary = createLibrary(_asyncLibrarySource);
       if (_asyncLibrary == null) {
         LibraryResolver2.missingAsyncLibrary(
-            analysisContext,
-            _asyncLibrarySource);
+            analysisContext, _asyncLibrarySource);
       }
     }
     //
     // Compute the set of libraries that need to be resolved together.
     //
     _computeEmbeddedLibraryDependencies(targetLibrary, unit);
     _librariesInCycles = _computeLibrariesInCycles(targetLibrary);
     //
     // Build the element models representing the libraries being resolved.
     // This is done in three steps:
@@ skipping 151 matching lines @@
    * @param dependencyMap a table mapping libraries to the collection of libraries from which those
    *          libraries are referenced
    */
   void _addLibrariesInCycle(Library library, Set<Library> librariesInCycle,
       HashMap<Library, List<Library>> dependencyMap) {
     if (librariesInCycle.add(library)) {
       List<Library> dependentLibraries = dependencyMap[library];
       if (dependentLibraries != null) {
         for (Library dependentLibrary in dependentLibraries) {
           _addLibrariesInCycle(
-              dependentLibrary,
-              librariesInCycle,
-              dependencyMap);
+              dependentLibrary, librariesInCycle, dependencyMap);
         }
       }
     }
   }
 
   /**
    * Add the given library, and all libraries reachable from it that have not already been visited,
    * to the given dependency map.
    *
    * @param library the library currently being added to the dependency map
    * @param dependencyMap the dependency map being computed
    * @param visitedLibraries the libraries that have already been visited, used to prevent infinite
    *          recursion
    */
-  void _addToDependencyMap(Library library, HashMap<Library,
-      List<Library>> dependencyMap, Set<Library> visitedLibraries) {
+  void _addToDependencyMap(Library library,
+      HashMap<Library, List<Library>> dependencyMap,
+      Set<Library> visitedLibraries) {
     if (visitedLibraries.add(library)) {
       bool asyncFound = false;
       for (Library referencedLibrary in library.importsAndExports) {
         _addDependencyToMap(dependencyMap, library, referencedLibrary);
         _addToDependencyMap(referencedLibrary, dependencyMap, visitedLibraries);
         if (identical(referencedLibrary, _asyncLibrary)) {
           asyncFound = true;
         }
       }
       if (!library.explicitlyImportsCore && !identical(library, _coreLibrary)) {
@@ skipping 79 matching lines @@
                   prefix = new PrefixElementImpl.forNode(prefixNode);
                   nameToPrefixMap[prefixName] = prefix;
                 }
                 importElement.prefix = prefix;
                 prefixNode.staticElement = prefix;
               }
               directive.element = importElement;
               imports.add(importElement);
               if (analysisContext.computeKindOf(importedSource) !=
                   SourceKind.LIBRARY) {
-                ErrorCode errorCode = (importElement.isDeferred ?
-                    StaticWarningCode.IMPORT_OF_NON_LIBRARY :
-                    CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY);
-                _errorListener.onError(
-                    new AnalysisError.con2(
-                        library.librarySource,
-                        uriLiteral.offset,
-                        uriLiteral.length,
-                        errorCode,
-                        [uriLiteral.toSource()]));
+                ErrorCode errorCode = (importElement.isDeferred
+                    ? StaticWarningCode.IMPORT_OF_NON_LIBRARY
+                    : CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY);
+                _errorListener.onError(new AnalysisError.con2(
+                    library.librarySource, uriLiteral.offset, uriLiteral.length,
+                    errorCode, [uriLiteral.toSource()]));
               }
             }
           }
         } else if (directive is ExportDirective) {
           ExportDirective exportDirective = directive;
           Source exportedSource = exportDirective.source;
           if (exportedSource != null) {
             // The exported source will be null if the URI in the export
             // directive was invalid.
             Library exportedLibrary = _libraryMap[exportedSource];
             if (exportedLibrary != null) {
               ExportElementImpl exportElement = new ExportElementImpl();
               StringLiteral uriLiteral = exportDirective.uri;
               exportElement.uriOffset = uriLiteral.offset;
               exportElement.uriEnd = uriLiteral.end;
               exportElement.uri = exportDirective.uriContent;
               exportElement.combinators = _buildCombinators(exportDirective);
               LibraryElement exportedLibraryElement =
                   exportedLibrary.libraryElement;
               if (exportedLibraryElement != null) {
                 exportElement.exportedLibrary = exportedLibraryElement;
               }
               directive.element = exportElement;
               exports.add(exportElement);
               if (analysisContext.computeKindOf(exportedSource) !=
                   SourceKind.LIBRARY) {
-                _errorListener.onError(
-                    new AnalysisError.con2(
-                        library.librarySource,
-                        uriLiteral.offset,
-                        uriLiteral.length,
-                        CompileTimeErrorCode.EXPORT_OF_NON_LIBRARY,
-                        [uriLiteral.toSource()]));
+                _errorListener.onError(new AnalysisError.con2(
+                    library.librarySource, uriLiteral.offset, uriLiteral.length,
+                    CompileTimeErrorCode.EXPORT_OF_NON_LIBRARY, [
+                  uriLiteral.toSource()
+                ]));
               }
             }
           }
         }
       }
       Source librarySource = library.librarySource;
       if (!library.explicitlyImportsCore &&
           _coreLibrarySource != librarySource) {
         ImportElementImpl importElement = new ImportElementImpl(-1);
         importElement.importedLibrary = _coreLibrary.libraryElement;
         importElement.synthetic = true;
         imports.add(importElement);
       }
       LibraryElementImpl libraryElement = library.libraryElement;
       libraryElement.imports = imports;
       libraryElement.exports = exports;
       if (libraryElement.entryPoint == null) {
-        Namespace namespace =
-            new NamespaceBuilder().createExportNamespaceForLibrary(libraryElement);
+        Namespace namespace = new NamespaceBuilder()
+            .createExportNamespaceForLibrary(libraryElement);
         Element element = namespace.get(LibraryElementBuilder.ENTRY_POINT_NAME);
         if (element is FunctionElement) {
           libraryElement.entryPoint = element;
         }
       }
     }
   }
 
   /**
    * Build element models for all of the libraries in the current cycle.
@@ skipping 32 matching lines @@
    * [ImplicitConstructorBuilder].
    *
    * @throws AnalysisException if any of the type hierarchies could not be resolved
    */
   void _buildImplicitConstructors() {
     PerformanceStatistics.resolve.makeCurrentWhile(() {
       ImplicitConstructorComputer computer =
           new ImplicitConstructorComputer(_typeProvider);
       for (Library library in _librariesInCycles) {
         for (Source source in library.compilationUnitSources) {
-          computer.add(
-              library.getAST(source),
-              source,
-              library.libraryElement,
+          computer.add(library.getAST(source), source, library.libraryElement,
               library.libraryScope);
         }
       }
       computer.compute();
     });
   }
 
   /**
    * Resolve the types referenced by function type aliases across all of the function type aliases
    * defined in the current cycle.
@@ skipping 11 matching lines @@
             if (member is FunctionTypeAlias) {
               typeAliases.add(
                   new LibraryResolver_TypeAliasInfo(library, source, member));
             }
           }
         }
       }
       // TODO(brianwilkerson) We need to sort the type aliases such that all
       // aliases referenced by an alias T are resolved before we resolve T.
       for (LibraryResolver_TypeAliasInfo info in typeAliases) {
-        TypeResolverVisitor visitor =
-            new TypeResolverVisitor.con1(info._library, info._source, _typeProvider);
+        TypeResolverVisitor visitor = new TypeResolverVisitor.con1(
+            info._library, info._source, _typeProvider);
         info._typeAlias.accept(visitor);
       }
     });
   }
 
   /**
    * Resolve the type hierarchy across all of the types declared in the libraries in the current
    * cycle.
    *
    * @throws AnalysisException if any of the type hierarchies could not be resolved
    */
   void _buildTypeHierarchies() {
     PerformanceStatistics.resolve.makeCurrentWhile(() {
       for (Library library in _librariesInCycles) {
         for (Source source in library.compilationUnitSources) {
           TypeResolverVisitorFactory typeResolverVisitorFactory =
               analysisContext.typeResolverVisitorFactory;
-          TypeResolverVisitor visitor = (typeResolverVisitorFactory == null) ?
-              new TypeResolverVisitor.con1(library, source, _typeProvider) :
-              typeResolverVisitorFactory(library, source, _typeProvider);
+          TypeResolverVisitor visitor = (typeResolverVisitorFactory == null)
+              ? new TypeResolverVisitor.con1(library, source, _typeProvider)
+              : typeResolverVisitorFactory(library, source, _typeProvider);
           library.getAST(source).accept(visitor);
         }
       }
     });
   }
 
   /**
    * Compute a dependency map of libraries reachable from the given library. A dependency map is a
    * table that maps individual libraries to a list of the libraries that either import or export
    * those libraries.
@@ skipping 11 matching lines @@
     return dependencyMap;
   }
 
   /**
    * Recursively traverse the libraries reachable from the given library, creating instances of the
    * class [Library] to represent them, and record the references in the library objects.
    *
    * @param library the library to be processed to find libraries that have not yet been traversed
    * @throws AnalysisException if some portion of the library graph could not be traversed
    */
-  void _computeEmbeddedLibraryDependencies(Library library,
-      CompilationUnit unit) {
+  void _computeEmbeddedLibraryDependencies(
+      Library library, CompilationUnit unit) {
     Source librarySource = library.librarySource;
     HashSet<Source> exportedSources = new HashSet<Source>();
     HashSet<Source> importedSources = new HashSet<Source>();
     for (Directive directive in unit.directives) {
       if (directive is ExportDirective) {
         Source exportSource = _resolveSource(librarySource, directive);
         if (exportSource != null) {
           exportedSources.add(exportSource);
         }
       } else if (directive is ImportDirective) {
         Source importSource = _resolveSource(librarySource, directive);
         if (importSource != null) {
           importedSources.add(importSource);
         }
       }
     }
-    _computeLibraryDependenciesFromDirectives(
-        library,
-        new List.from(importedSources),
-        new List.from(exportedSources));
+    _computeLibraryDependenciesFromDirectives(library,
+        new List.from(importedSources), new List.from(exportedSources));
   }
 
   /**
    * Return a collection containing all of the libraries reachable from the given library that are
    * contained in a cycle that includes the given library.
    *
    * @param library the library that must be included in any cycles whose members are to be returned
    * @return all of the libraries referenced by the given library that have a circular reference
    *         back to the given library
    */
   Set<Library> _computeLibrariesInCycles(Library library) {
     HashMap<Library, List<Library>> dependencyMap =
         _computeDependencyMap(library);
     Set<Library> librariesInCycle = new HashSet<Library>();
     _addLibrariesInCycle(library, librariesInCycle, dependencyMap);
     return librariesInCycle;
   }
 
   /**
    * Recursively traverse the libraries reachable from the given library, creating instances of the
    * class [Library] to represent them, and record the references in the library objects.
    *
    * @param library the library to be processed to find libraries that have not yet been traversed
    * @throws AnalysisException if some portion of the library graph could not be traversed
    */
   void _computeLibraryDependencies(Library library) {
     Source librarySource = library.librarySource;
-    _computeLibraryDependenciesFromDirectives(
-        library,
+    _computeLibraryDependenciesFromDirectives(library,
         analysisContext.computeImportedLibraries(librarySource),
         analysisContext.computeExportedLibraries(librarySource));
   }
 
   /**
    * Recursively traverse the libraries reachable from the given library, creating instances of the
    * class [Library] to represent them, and record the references in the library objects.
    *
    * @param library the library to be processed to find libraries that have not yet been traversed
    * @param importedSources an array containing the sources that are imported into the given library
@@ skipping 107 matching lines @@
       identifiers[i] = names[i].name;
     }
     return identifiers;
   }
 
   /**
    * Compute a value for all of the constants in the libraries being analyzed.
    */
   void _performConstantEvaluation() {
     PerformanceStatistics.resolve.makeCurrentWhile(() {
-      ConstantValueComputer computer =
-          new ConstantValueComputer(_typeProvider, analysisContext.declaredVariables);
+      ConstantValueComputer computer = new ConstantValueComputer(
+          _typeProvider, analysisContext.declaredVariables);
       for (Library library in _librariesInCycles) {
         for (Source source in library.compilationUnitSources) {
           try {
             CompilationUnit unit = library.getAST(source);
             if (unit != null) {
               computer.add(unit);
             }
           } on AnalysisException catch (exception, stackTrace) {
             AnalysisEngine.instance.logger.logError(
                 "Internal Error: Could not access AST for ${source.fullName} during constant evaluation",
                 new CaughtException(exception, stackTrace));
           }
         }
       }
       computer.computeValues();
       // As a temporary workaround for issue 21572, run ConstantVerifier now.
       // TODO(paulberry): remove this workaround once issue 21572 is fixed.
       for (Library library in _librariesInCycles) {
         for (Source source in library.compilationUnitSources) {
           try {
             CompilationUnit unit = library.getAST(source);
             ErrorReporter errorReporter =
                 new ErrorReporter(_errorListener, source);
-            ConstantVerifier constantVerifier =
-                new ConstantVerifier(errorReporter, library.libraryElement, _typeProvider);
+            ConstantVerifier constantVerifier = new ConstantVerifier(
+                errorReporter, library.libraryElement, _typeProvider);
             unit.accept(constantVerifier);
           } on AnalysisException catch (exception, stackTrace) {
             AnalysisEngine.instance.logger.logError(
                 "Internal Error: Could not access AST for ${source.fullName} "
-                    "during constant verification",
+                "during constant verification",
                 new CaughtException(exception, stackTrace));
           }
         }
       }
     });
   }
 
   /**
    * Resolve the identifiers and perform type analysis in the libraries in the current cycle.
    *
@@ skipping 14 matching lines @@
    *           the library cannot be analyzed
    */
   void _resolveReferencesAndTypesInLibrary(Library library) {
     PerformanceStatistics.resolve.makeCurrentWhile(() {
       for (Source source in library.compilationUnitSources) {
         CompilationUnit ast = library.getAST(source);
         ast.accept(
             new VariableResolverVisitor.con1(library, source, _typeProvider));
         ResolverVisitorFactory visitorFactory =
             analysisContext.resolverVisitorFactory;
-        ResolverVisitor visitor = visitorFactory != null ?
-            visitorFactory(library, source, _typeProvider) :
-            new ResolverVisitor.con1(library, source, _typeProvider);
+        ResolverVisitor visitor = visitorFactory != null
+            ? visitorFactory(library, source, _typeProvider)
+            : new ResolverVisitor.con1(library, source, _typeProvider);
         ast.accept(visitor);
       }
     });
   }
 
   /**
    * Return the result of resolving the URI of the given URI-based directive against the URI of the
    * given library, or `null` if the URI is not valid.
    *
    * @param librarySource the source representing the library containing the directive
@@ skipping 100 matching lines @@
    * Note that because Dart allows circular imports between libraries, it is possible that more than
    * one library will need to be resolved. In such cases the error listener can receive errors from
    * multiple libraries.
    *
    * @param librarySource the source specifying the defining compilation unit of the library to be
    *          resolved
    * @param fullAnalysis `true` if a full analysis should be performed
    * @return the element representing the resolved library
    * @throws AnalysisException if the library could not be resolved for some reason
    */
-  LibraryElement resolveLibrary(Source librarySource,
-      List<ResolvableLibrary> librariesInCycle) {
+  LibraryElement resolveLibrary(
+      Source librarySource, List<ResolvableLibrary> librariesInCycle) {
     //
     // Build the map of libraries that are known.
     //
     this._librariesInCycle = librariesInCycle;
     _libraryMap = _buildLibraryMap();
     ResolvableLibrary targetLibrary = _libraryMap[librarySource];
     _coreLibrary = _libraryMap[_coreLibrarySource];
     _asyncLibrary = _libraryMap[_asyncLibrarySource];
     //
     // Build the element models representing the libraries being resolved.
@@ skipping 124 matching lines @@
                   prefix = new PrefixElementImpl.forNode(prefixNode);
                   nameToPrefixMap[prefixName] = prefix;
                 }
                 importElement.prefix = prefix;
                 prefixNode.staticElement = prefix;
               }
               directive.element = importElement;
               imports.add(importElement);
               if (analysisContext.computeKindOf(importedSource) !=
                   SourceKind.LIBRARY) {
-                ErrorCode errorCode = (importElement.isDeferred ?
-                    StaticWarningCode.IMPORT_OF_NON_LIBRARY :
-                    CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY);
-                _errorListener.onError(
-                    new AnalysisError.con2(
-                        library.librarySource,
-                        uriLiteral.offset,
-                        uriLiteral.length,
-                        errorCode,
-                        [uriLiteral.toSource()]));
+                ErrorCode errorCode = (importElement.isDeferred
+                    ? StaticWarningCode.IMPORT_OF_NON_LIBRARY
+                    : CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY);
+                _errorListener.onError(new AnalysisError.con2(
+                    library.librarySource, uriLiteral.offset, uriLiteral.length,
+                    errorCode, [uriLiteral.toSource()]));
               }
             }
           }
         } else if (directive is ExportDirective) {
           ExportDirective exportDirective = directive;
           Source exportedSource = exportDirective.source;
           if (exportedSource != null &&
               analysisContext.exists(exportedSource)) {
             // The exported source will be null if the URI in the export
             // directive was invalid.
             ResolvableLibrary exportedLibrary = _libraryMap[exportedSource];
             if (exportedLibrary != null) {
               ExportElementImpl exportElement = new ExportElementImpl();
               StringLiteral uriLiteral = exportDirective.uri;
               if (uriLiteral != null) {
                 exportElement.uriOffset = uriLiteral.offset;
                 exportElement.uriEnd = uriLiteral.end;
               }
               exportElement.uri = exportDirective.uriContent;
               exportElement.combinators = _buildCombinators(exportDirective);
               LibraryElement exportedLibraryElement =
                   exportedLibrary.libraryElement;
               if (exportedLibraryElement != null) {
                 exportElement.exportedLibrary = exportedLibraryElement;
               }
               directive.element = exportElement;
               exports.add(exportElement);
               if (analysisContext.computeKindOf(exportedSource) !=
                   SourceKind.LIBRARY) {
-                _errorListener.onError(
-                    new AnalysisError.con2(
-                        library.librarySource,
-                        uriLiteral.offset,
-                        uriLiteral.length,
-                        CompileTimeErrorCode.EXPORT_OF_NON_LIBRARY,
-                        [uriLiteral.toSource()]));
+                _errorListener.onError(new AnalysisError.con2(
+                    library.librarySource, uriLiteral.offset, uriLiteral.length,
+                    CompileTimeErrorCode.EXPORT_OF_NON_LIBRARY, [
+                  uriLiteral.toSource()
+                ]));
               }
             }
           }
         }
       }
       Source librarySource = library.librarySource;
       if (!library.explicitlyImportsCore &&
           _coreLibrarySource != librarySource) {
         ImportElementImpl importElement = new ImportElementImpl(-1);
         importElement.importedLibrary = _coreLibrary.libraryElement;
         importElement.synthetic = true;
         imports.add(importElement);
       }
       LibraryElementImpl libraryElement = library.libraryElement;
       libraryElement.imports = imports;
       libraryElement.exports = exports;
       if (libraryElement.entryPoint == null) {
-        Namespace namespace =
-            new NamespaceBuilder().createExportNamespaceForLibrary(libraryElement);
+        Namespace namespace = new NamespaceBuilder()
+            .createExportNamespaceForLibrary(libraryElement);
         Element element = namespace.get(LibraryElementBuilder.ENTRY_POINT_NAME);
         if (element is FunctionElement) {
           libraryElement.entryPoint = element;
         }
       }
     }
   }
 
   /**
    * Build element models for all of the libraries in the current cycle.
@@ skipping 30 matching lines @@
    * Finish steps that the [buildTypeHierarchies] could not perform, see
    * [ImplicitConstructorBuilder].
    *
    * @throws AnalysisException if any of the type hierarchies could not be resolved
    */
   void _buildImplicitConstructors() {
     PerformanceStatistics.resolve.makeCurrentWhile(() {
       ImplicitConstructorComputer computer =
           new ImplicitConstructorComputer(_typeProvider);
       for (ResolvableLibrary library in _librariesInCycle) {
-        for (ResolvableCompilationUnit unit in
-            library.resolvableCompilationUnits) {
+        for (ResolvableCompilationUnit unit
+            in library.resolvableCompilationUnits) {
           Source source = unit.source;
           CompilationUnit ast = unit.compilationUnit;
-          computer.add(
-              ast,
-              source,
-              library.libraryElement,
-              library.libraryScope);
+          computer
+              .add(ast, source, library.libraryElement, library.libraryScope);
         }
       }
       computer.compute();
     });
   }
 
   HashMap<Source, ResolvableLibrary> _buildLibraryMap() {
     HashMap<Source, ResolvableLibrary> libraryMap =
         new HashMap<Source, ResolvableLibrary>();
     int libraryCount = _librariesInCycle.length;
@@ skipping 16 matching lines @@
    * Resolve the types referenced by function type aliases across all of the function type aliases
    * defined in the current cycle.
    *
    * @throws AnalysisException if any of the function type aliases could not be resolved
    */
   void _buildTypeAliases() {
     PerformanceStatistics.resolve.makeCurrentWhile(() {
       List<LibraryResolver2_TypeAliasInfo> typeAliases =
           new List<LibraryResolver2_TypeAliasInfo>();
       for (ResolvableLibrary library in _librariesInCycle) {
-        for (ResolvableCompilationUnit unit in
-            library.resolvableCompilationUnits) {
-          for (CompilationUnitMember member in
-              unit.compilationUnit.declarations) {
+        for (ResolvableCompilationUnit unit
+            in library.resolvableCompilationUnits) {
+          for (CompilationUnitMember member
+              in unit.compilationUnit.declarations) {
             if (member is FunctionTypeAlias) {
-              typeAliases.add(
-                  new LibraryResolver2_TypeAliasInfo(library, unit.source, member));
+              typeAliases.add(new LibraryResolver2_TypeAliasInfo(
+                  library, unit.source, member));
             }
           }
         }
       }
       // TODO(brianwilkerson) We need to sort the type aliases such that all
       // aliases referenced by an alias T are resolved before we resolve T.
       for (LibraryResolver2_TypeAliasInfo info in typeAliases) {
-        TypeResolverVisitor visitor =
-            new TypeResolverVisitor.con4(info._library, info._source, _typeProvider);
+        TypeResolverVisitor visitor = new TypeResolverVisitor.con4(
+            info._library, info._source, _typeProvider);
         info._typeAlias.accept(visitor);
       }
     });
   }
 
   /**
    * Resolve the type hierarchy across all of the types declared in the libraries in the current
    * cycle.
    *
    * @throws AnalysisException if any of the type hierarchies could not be resolved
    */
   void _buildTypeHierarchies() {
     PerformanceStatistics.resolve.makeCurrentWhile(() {
       for (ResolvableLibrary library in _librariesInCycle) {
-        for (ResolvableCompilationUnit unit in
-            library.resolvableCompilationUnits) {
+        for (ResolvableCompilationUnit unit
+            in library.resolvableCompilationUnits) {
           Source source = unit.source;
           CompilationUnit ast = unit.compilationUnit;
           TypeResolverVisitor visitor =
               new TypeResolverVisitor.con4(library, source, _typeProvider);
           ast.accept(visitor);
         }
       }
     });
   }
 
@@ skipping 10 matching lines @@
       identifiers[i] = names[i].name;
     }
     return identifiers;
   }
 
   /**
    * Compute a value for all of the constants in the libraries being analyzed.
    */
   void _performConstantEvaluation() {
     PerformanceStatistics.resolve.makeCurrentWhile(() {
-      ConstantValueComputer computer =
-          new ConstantValueComputer(_typeProvider, analysisContext.declaredVariables);
+      ConstantValueComputer computer = new ConstantValueComputer(
+          _typeProvider, analysisContext.declaredVariables);
       for (ResolvableLibrary library in _librariesInCycle) {
-        for (ResolvableCompilationUnit unit in
-            library.resolvableCompilationUnits) {
+        for (ResolvableCompilationUnit unit
+            in library.resolvableCompilationUnits) {
           CompilationUnit ast = unit.compilationUnit;
           if (ast != null) {
             computer.add(ast);
           }
         }
       }
       computer.computeValues();
       // As a temporary workaround for issue 21572, run ConstantVerifier now.
       // TODO(paulberry): remove this workaround once issue 21572 is fixed.
       for (ResolvableLibrary library in _librariesInCycle) {
-        for (ResolvableCompilationUnit unit in
-            library.resolvableCompilationUnits) {
+        for (ResolvableCompilationUnit unit
+            in library.resolvableCompilationUnits) {
           CompilationUnit ast = unit.compilationUnit;
           ErrorReporter errorReporter =
               new ErrorReporter(_errorListener, unit.source);
-          ConstantVerifier constantVerifier =
-              new ConstantVerifier(errorReporter, library.libraryElement, _typeProvider);
+          ConstantVerifier constantVerifier = new ConstantVerifier(
+              errorReporter, library.libraryElement, _typeProvider);
           ast.accept(constantVerifier);
         }
       }
     });
   }
 
   /**
    * Resolve the identifiers and perform type analysis in the libraries in the current cycle.
    *
    * @throws AnalysisException if any of the identifiers could not be resolved or if any of the
    *           libraries could not have their types analyzed
    */
   void _resolveReferencesAndTypes() {
     for (ResolvableLibrary library in _librariesInCycle) {
       _resolveReferencesAndTypesInLibrary(library);
     }
   }
 
   /**
    * Resolve the identifiers and perform type analysis in the given library.
    *
    * @param library the library to be resolved
    * @throws AnalysisException if any of the identifiers could not be resolved or if the types in
    *           the library cannot be analyzed
    */
   void _resolveReferencesAndTypesInLibrary(ResolvableLibrary library) {
     PerformanceStatistics.resolve.makeCurrentWhile(() {
-      for (ResolvableCompilationUnit unit in library.resolvableCompilationUnits)
-          {
+      for (ResolvableCompilationUnit unit
+          in library.resolvableCompilationUnits) {
         Source source = unit.source;
         CompilationUnit ast = unit.compilationUnit;
         ast.accept(
             new VariableResolverVisitor.con3(library, source, _typeProvider));
         ResolverVisitor visitor =
             new ResolverVisitor.con4(library, source, _typeProvider);
         ast.accept(visitor);
       }
     });
   }
 
   /**
    * Report that the async library could not be resolved in the given
    * [analysisContext] and throw an exception.  [asyncLibrarySource] is the source
    * representing the async library.
    */
-  static void missingAsyncLibrary(AnalysisContext analysisContext,
-      Source asyncLibrarySource) {
+  static void missingAsyncLibrary(
+      AnalysisContext analysisContext, Source asyncLibrarySource) {
     throw new AnalysisException("Could not resolve dart:async");
   }
 
   /**
    * Report that the core library could not be resolved in the given analysis context and throw an
    * exception.
    *
    * @param analysisContext the analysis context in which the failure occurred
    * @param coreLibrarySource the source representing the core library
    * @throws AnalysisException always
    */
-  static void missingCoreLibrary(AnalysisContext analysisContext,
-      Source coreLibrarySource) {
+  static void missingCoreLibrary(
+      AnalysisContext analysisContext, Source coreLibrarySource) {
     throw new AnalysisException("Could not resolve dart:core");
   }
 }
 
-
 /**
  * Instances of the class `TypeAliasInfo` hold information about a [TypeAlias].
  */
 class LibraryResolver2_TypeAliasInfo {
   final ResolvableLibrary _library;
 
   final Source _source;
 
   final FunctionTypeAlias _typeAlias;
 
@@ skipping 31 matching lines @@
  * Instances of the class `LibraryScope` implement a scope containing all of the names defined
  * in a given library.
  */
 class LibraryScope extends EnclosedScope {
   /**
    * Initialize a newly created scope representing the names defined in the given library.
    *
    * @param definingLibrary the element representing the library represented by this scope
    * @param errorListener the listener that is to be informed when an error is encountered
    */
-  LibraryScope(LibraryElement definingLibrary,
-      AnalysisErrorListener errorListener)
+  LibraryScope(
+      LibraryElement definingLibrary, AnalysisErrorListener errorListener)
       : super(new LibraryImportScope(definingLibrary, errorListener)) {
     _defineTopLevelNames(definingLibrary);
   }
 
   @override
   AnalysisError getErrorForDuplicate(Element existing, Element duplicate) {
     if (existing is PrefixElement) {
       // TODO(scheglov) consider providing actual 'nameOffset' from the
       // synthetic accessor
       int offset = duplicate.nameOffset;
       if (duplicate is PropertyAccessorElement) {
         PropertyAccessorElement accessor = duplicate;
         if (accessor.isSynthetic) {
           offset = accessor.variable.nameOffset;
         }
       }
-      return new AnalysisError.con2(
-          duplicate.source,
-          offset,
+      return new AnalysisError.con2(duplicate.source, offset,
           duplicate.displayName.length,
-          CompileTimeErrorCode.PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER,
-          [existing.displayName]);
+          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
    * unit.
    *
    * @param compilationUnit the compilation unit defining the top-level names to be added to this
    *          scope
    */
   void _defineLocalNames(CompilationUnitElement compilationUnit) {
     for (PropertyAccessorElement element in compilationUnit.accessors) {
       define(element);
     }
     for (ClassElement element in compilationUnit.enums) {
       define(element);
     }
     for (FunctionElement element in compilationUnit.functions) {
       define(element);
     }
-    for (FunctionTypeAliasElement element in
-        compilationUnit.functionTypeAliases) {
+    for (FunctionTypeAliasElement element
+        in compilationUnit.functionTypeAliases) {
       define(element);
     }
     for (ClassElement element in compilationUnit.types) {
       define(element);
     }
   }
 
   /**
    * Add to this scope all of the names that are explicitly defined in the given library.
    *
@@ skipping 244 matching lines @@
     return new Namespace(definedNames);
   }
 
   /**
    * Create a namespace representing the export namespace of the given library.
    *
    * @param library the library whose export namespace is to be created
    * @return the export namespace that was created
    */
   Namespace createExportNamespaceForLibrary(LibraryElement library) =>
-      new Namespace(_createExportMapping(library, new HashSet<LibraryElement>()));
+      new Namespace(
+          _createExportMapping(library, new HashSet<LibraryElement>()));
 
   /**
    * Create a namespace representing the import namespace of the given library.
    *
    * @param library the library whose import namespace is to be created
    * @return the import namespace that was created
    */
   Namespace createImportNamespaceForDirective(ImportElement element) {
     LibraryElement importedLibrary = element.importedLibrary;
     if (importedLibrary == null) {
@@ skipping 24 matching lines @@
     }
     return new Namespace(definedNames);
   }
 
   /**
    * Add all of the names in the given namespace to the given mapping table.
    *
    * @param definedNames the mapping table to which the names in the given namespace are to be added
    * @param namespace the namespace containing the names to be added to this namespace
    */
-  void _addAllFromMap(Map<String, Element> definedNames, Map<String,
-      Element> newNames) {
+  void _addAllFromMap(
+      Map<String, Element> definedNames, Map<String, Element> newNames) {
     newNames.forEach((String name, Element element) {
       definedNames[name] = element;
     });
   }
 
   /**
    * Add all of the names in the given namespace to the given mapping table.
    *
    * @param definedNames the mapping table to which the names in the given namespace are to be added
    * @param namespace the namespace containing the names to be added to this namespace
    */
-  void _addAllFromNamespace(Map<String, Element> definedNames,
-      Namespace namespace) {
+  void _addAllFromNamespace(
+      Map<String, Element> definedNames, Namespace namespace) {
     if (namespace != null) {
       _addAllFromMap(definedNames, namespace.definedNames);
     }
   }
 
   /**
    * Add the given element to the given mapping table if it has a publicly visible name.
    *
    * @param definedNames the mapping table to which the public name is to be added
    * @param element the element to be added
@@ skipping 17 matching lines @@
       CompilationUnitElement compilationUnit) {
     for (PropertyAccessorElement element in compilationUnit.accessors) {
       _addIfPublic(definedNames, element);
     }
     for (ClassElement element in compilationUnit.enums) {
       _addIfPublic(definedNames, element);
     }
     for (FunctionElement element in compilationUnit.functions) {
       _addIfPublic(definedNames, element);
     }
-    for (FunctionTypeAliasElement element in
-        compilationUnit.functionTypeAliases) {
+    for (FunctionTypeAliasElement element
+        in compilationUnit.functionTypeAliases) {
       _addIfPublic(definedNames, element);
     }
     for (ClassElement element in compilationUnit.types) {
       _addIfPublic(definedNames, element);
     }
   }
 
   /**
    * Apply the given combinators to all of the names in the given mapping table.
    *
    * @param definedNames the mapping table to which the namespace operations are to be applied
    * @param combinators the combinators to be applied
    */
-  HashMap<String, Element> _applyCombinators(HashMap<String,
-      Element> definedNames, List<NamespaceCombinator> combinators) {
+  HashMap<String, Element> _applyCombinators(
+      HashMap<String, Element> definedNames,
+      List<NamespaceCombinator> combinators) {
     for (NamespaceCombinator combinator in combinators) {
       if (combinator is HideElementCombinator) {
         _hide(definedNames, combinator.hiddenNames);
       } else if (combinator is ShowElementCombinator) {
         definedNames = _show(definedNames, combinator.shownNames);
       } else {
         // Internal error.
-        AnalysisEngine.instance.logger.logError(
-            "Unknown type of combinator: ${combinator.runtimeType}");
+        AnalysisEngine.instance.logger
+            .logError("Unknown type of combinator: ${combinator.runtimeType}");
       }
     }
     return definedNames;
   }
 
   /**
    * Apply the given prefix to all of the names in the table of defined names.
    *
    * @param definedNames the names that were defined before this operation
    * @param prefixElement the element defining the prefix to be added to the names
    */
-  HashMap<String, Element> _applyPrefix(HashMap<String, Element> definedNames,
-      PrefixElement prefixElement) {
+  HashMap<String, Element> _applyPrefix(
+      HashMap<String, Element> definedNames, PrefixElement prefixElement) {
     if (prefixElement != null) {
       String prefix = prefixElement.name;
       HashMap<String, Element> newNames = new HashMap<String, Element>();
       definedNames.forEach((String name, Element element) {
         newNames["$prefix.$name"] = element;
       });
       return newNames;
     } else {
       return definedNames;
     }
   }
 
   /**
    * Create a mapping table representing the export namespace of the given library.
    *
    * @param library the library whose public namespace is to be created
    * @param visitedElements a set of libraries that do not need to be visited when processing the
    *          export directives of the given library because all of the names defined by them will
    *          be added by another library
    * @return the mapping table that was created
    */
-  HashMap<String, Element> _createExportMapping(LibraryElement library,
-      HashSet<LibraryElement> visitedElements) {
+  HashMap<String, Element> _createExportMapping(
+      LibraryElement library, HashSet<LibraryElement> visitedElements) {
     visitedElements.add(library);
     try {
       HashMap<String, Element> definedNames = new HashMap<String, Element>();
       for (ExportElement element in library.exports) {
         LibraryElement exportedLibrary = element.exportedLibrary;
         if (exportedLibrary != null &&
             !visitedElements.contains(exportedLibrary)) {
           //
           // The exported library will be null if the URI does not reference a
           // valid library.
           //
           HashMap<String, Element> exportedNames =
               _createExportMapping(exportedLibrary, visitedElements);
           exportedNames = _applyCombinators(exportedNames, element.combinators);
           _addAllFromMap(definedNames, exportedNames);
         }
       }
-      _addAllFromNamespace(
-          definedNames,
-          (library.context as InternalAnalysisContext).getPublicNamespace(library));
+      _addAllFromNamespace(definedNames,
+          (library.context as InternalAnalysisContext)
+              .getPublicNamespace(library));
       return definedNames;
     } finally {
       visitedElements.remove(library);
     }
   }
 
   /**
    * Hide all of the given names by removing them from the given collection of defined names.
    *
    * @param definedNames the names that were defined before this operation
    * @param hiddenNames the names to be hidden
    */
   void _hide(HashMap<String, Element> definedNames, List<String> hiddenNames) {
     for (String name in hiddenNames) {
       definedNames.remove(name);
       definedNames.remove("$name=");
     }
   }
 
   /**
    * Show only the given names by removing all other names from the given collection of defined
    * names.
    *
    * @param definedNames the names that were defined before this operation
    * @param shownNames the names to be shown
    */
-  HashMap<String, Element> _show(HashMap<String, Element> definedNames,
-      List<String> shownNames) {
+  HashMap<String, Element> _show(
+      HashMap<String, Element> definedNames, List<String> shownNames) {
     HashMap<String, Element> newNames = new HashMap<String, Element>();
     for (String name in shownNames) {
       Element element = definedNames[name];
       if (element != null) {
         newNames[name] = element;
       }
       String setterName = "$name=";
       element = definedNames[setterName];
       if (element != null) {
         newNames[setterName] = element;
@@ skipping 26 matching lines @@
    */
   OverrideVerifier(this._manager, this._errorReporter);
 
   @override
   Object visitMethodDeclaration(MethodDeclaration node) {
     ExecutableElement element = node.element;
     if (_isOverride(element)) {
       if (_getOverriddenMember(element) == null) {
         if (element is MethodElement) {
           _errorReporter.reportErrorForNode(
-              HintCode.OVERRIDE_ON_NON_OVERRIDING_METHOD,
-              node.name);
+              HintCode.OVERRIDE_ON_NON_OVERRIDING_METHOD, node.name);
         } else if (element is PropertyAccessorElement) {
           if (element.isGetter) {
             _errorReporter.reportErrorForNode(
-                HintCode.OVERRIDE_ON_NON_OVERRIDING_GETTER,
-                node.name);
+                HintCode.OVERRIDE_ON_NON_OVERRIDING_GETTER, node.name);
           } else {
             _errorReporter.reportErrorForNode(
-                HintCode.OVERRIDE_ON_NON_OVERRIDING_SETTER,
-                node.name);
+                HintCode.OVERRIDE_ON_NON_OVERRIDING_SETTER, node.name);
           }
         }
       }
     }
     return super.visitMethodDeclaration(node);
   }
 
   /**
    * Return the member that overrides the given member.
    *
@@ skipping 501 matching lines @@
 
 /**
  * The enumeration `ResolverErrorCode` defines the error codes used for errors
  * detected by the resolver. The convention for this class is for the name of
  * the error code to indicate the problem that caused the error to be generated
  * and for the error message to explain what is wrong and, when appropriate, how
  * the problem can be corrected.
  */
 class ResolverErrorCode extends ErrorCode {
   static const ResolverErrorCode BREAK_LABEL_ON_SWITCH_MEMBER =
-      const ResolverErrorCode(
-          'BREAK_LABEL_ON_SWITCH_MEMBER',
+      const ResolverErrorCode('BREAK_LABEL_ON_SWITCH_MEMBER',
           "Break label resolves to case or default statement");
 
   static const ResolverErrorCode CONTINUE_LABEL_ON_SWITCH =
-      const ResolverErrorCode(
-          'CONTINUE_LABEL_ON_SWITCH',
+      const ResolverErrorCode('CONTINUE_LABEL_ON_SWITCH',
           "A continue label resolves to switch, must be loop or switch member");
 
   static const ResolverErrorCode MISSING_LIBRARY_DIRECTIVE_WITH_PART =
-      const ResolverErrorCode(
-          'MISSING_LIBRARY_DIRECTIVE_WITH_PART',
+      const ResolverErrorCode('MISSING_LIBRARY_DIRECTIVE_WITH_PART',
           "Libraries that have parts must have a library directive");
 
   /**
    * Initialize a newly created error code to have the given [name]. The message
    * associated with the error will be created from the given [message]
    * template. The correction associated with the error will be created from the
    * given [correction] template.
    */
   const ResolverErrorCode(String name, String message, [String correction])
       : super(name, message, correction);
@@ skipping 75 matching lines @@
    */
   bool resolveOnlyCommentInFunctionBody = false;
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param library the library containing the compilation unit being resolved
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    */
-  ResolverVisitor.con1(Library library, Source source,
-      TypeProvider typeProvider, {StaticTypeAnalyzer typeAnalyzer,
+  ResolverVisitor.con1(
+      Library library, Source source, TypeProvider typeProvider,
+      {StaticTypeAnalyzer typeAnalyzer,
       StaticTypeAnalyzerFactory typeAnalyzerFactory})
       : super.con1(library, source, typeProvider) {
     this._inheritanceManager = library.inheritanceManager;
     this._elementResolver = new ElementResolver(this);
-    this._typeAnalyzer = typeAnalyzer != null ?
-        typeAnalyzer :
-        (typeAnalyzerFactory != null ?
-            typeAnalyzerFactory(this) :
-            new StaticTypeAnalyzer(this));
+    this._typeAnalyzer = typeAnalyzer != null
+        ? typeAnalyzer
+        : (typeAnalyzerFactory != null
+            ? typeAnalyzerFactory(this)
+            : new StaticTypeAnalyzer(this));
   }
 
-
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param definingLibrary the element for the library containing the compilation unit being
    *          visited
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    * @param errorListener the error listener that will be informed of any errors that are found
    *          during resolution
    */
@@ skipping 10 matching lines @@
    * Initialize a newly created visitor to resolve the nodes in an AST node.
    *
    * @param definingLibrary the element for the library containing the node being visited
    * @param source the source representing the compilation unit containing the node being visited
    * @param typeProvider the object used to access the types from the core library
    * @param nameScope the scope used to resolve identifiers in the node that will first be visited
    * @param errorListener the error listener that will be informed of any errors that are found
    *          during resolution
    */
   ResolverVisitor.con3(LibraryElement definingLibrary, Source source,
-      TypeProvider typeProvider, Scope nameScope, AnalysisErrorListener errorListener)
+      TypeProvider typeProvider, Scope nameScope,
+      AnalysisErrorListener errorListener)
       : super.con3(
-          definingLibrary,
-          source,
-          typeProvider,
-          nameScope,
-          errorListener) {
+          definingLibrary, source, typeProvider, nameScope, errorListener) {
     this._inheritanceManager = new InheritanceManager(definingLibrary);
     this._elementResolver = new ElementResolver(this);
     this._typeAnalyzer = new StaticTypeAnalyzer(this);
   }
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param library the library containing the compilation unit being resolved
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    */
-  ResolverVisitor.con4(ResolvableLibrary library, Source source,
-      TypeProvider typeProvider)
+  ResolverVisitor.con4(
+      ResolvableLibrary library, Source source, TypeProvider typeProvider)
       : super.con4(library, source, typeProvider) {
     this._inheritanceManager = library.inheritanceManager;
     this._elementResolver = new ElementResolver(this);
     this._typeAnalyzer = new StaticTypeAnalyzer(this);
   }
 
   get elementResolver_J2DAccessor => _elementResolver;
 
   set elementResolver_J2DAccessor(__v) => _elementResolver = __v;
 
@@ skipping 114 matching lines @@
   /**
    * If it is appropriate to do so, override the current type of the static and propagated elements
    * associated with the given expression with the given type. Generally speaking, it is appropriate
    * if the given type is more specific than the current type.
    *
    * @param expression the expression used to access the static and propagated elements whose types
    *          might be overridden
    * @param potentialType the potential type of the elements
    * @param allowPrecisionLoss see @{code overrideVariable} docs
    */
-  void overrideExpression(Expression expression, DartType potentialType,
-      bool allowPrecisionLoss) {
+  void overrideExpression(
+      Expression expression, DartType potentialType, bool allowPrecisionLoss) {
     VariableElement element = getOverridableStaticElement(expression);
     if (element != null) {
       overrideVariable(element, potentialType, allowPrecisionLoss);
     }
     element = getOverridablePropagatedElement(expression);
     if (element != null) {
       overrideVariable(element, potentialType, allowPrecisionLoss);
     }
   }
 
@@ skipping 689 matching lines @@
     // We visit the target, but do not visit the property name because it needs
     // to be visited in the context of the property access node.
     //
     safelyVisit(node.target);
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
 
   @override
-  Object
-      visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
+  Object visitRedirectingConstructorInvocation(
+      RedirectingConstructorInvocation node) {
     //
     // We visit the argument list, but do not visit the optional identifier
     // because it needs to be visited in the context of the constructor
     // invocation.
     //
     safelyVisit(node.argumentList);
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
@@ skipping 82 matching lines @@
     return null;
   }
 
   /**
    * Checks each promoted variable in the current scope for compliance with the following
    * specification statement:
    *
    * If the variable <i>v</i> is accessed by a closure in <i>s<sub>1</sub></i> then the variable
    * <i>v</i> is not potentially mutated anywhere in the scope of <i>v</i>.
    */
-  void
-      _clearTypePromotionsIfAccessedInClosureAndProtentiallyMutated(AstNode target) {
+  void _clearTypePromotionsIfAccessedInClosureAndProtentiallyMutated(
+      AstNode target) {
     for (Element element in _promoteManager.promotedElements) {
       if ((element as VariableElementImpl).isPotentiallyMutatedInScope) {
         if (_isVariableAccessedInClosure(element, target)) {
           _promoteManager.setType(element, null);
         }
       }
     }
   }
 
   /**
@@ skipping 24 matching lines @@
       InterfaceType interfaceType = expressionType;
       FunctionType iteratorFunction =
           _inheritanceManager.lookupMemberType(interfaceType, "iterator");
       if (iteratorFunction == null) {
         // TODO(brianwilkerson) Should we report this error?
         return null;
       }
       DartType iteratorType = iteratorFunction.returnType;
       if (iteratorType is InterfaceType) {
         InterfaceType iteratorInterfaceType = iteratorType;
-        FunctionType currentFunction =
-            _inheritanceManager.lookupMemberType(iteratorInterfaceType, "current");
+        FunctionType currentFunction = _inheritanceManager.lookupMemberType(
+            iteratorInterfaceType, "current");
         if (currentFunction == null) {
           // TODO(brianwilkerson) Should we report this error?
           return null;
         }
         return currentFunction.returnType;
       }
     }
     return null;
   }
 
   /**
    * If given "mayBeClosure" is [FunctionExpression] without explicit parameters types and its
    * required type is [FunctionType], then infer parameters types from [FunctionType].
    */
-  void _inferFunctionExpressionParametersTypes(Expression mayBeClosure,
-      DartType mayByFunctionType) {
+  void _inferFunctionExpressionParametersTypes(
+      Expression mayBeClosure, DartType mayByFunctionType) {
     // prepare closure
     if (mayBeClosure is! FunctionExpression) {
       return;
     }
     FunctionExpression closure = mayBeClosure as FunctionExpression;
     // prepare expected closure type
     if (mayByFunctionType is! FunctionType) {
       return;
     }
     FunctionType expectedClosureType = mayByFunctionType as FunctionType;
     // If the expectedClosureType is not more specific than the static type,
     // return.
     DartType staticClosureType =
         (closure.element != null ? closure.element.type : null) as DartType;
     if (staticClosureType != null &&
         !expectedClosureType.isMoreSpecificThan(staticClosureType)) {
       return;
     }
     // set propagated type for the closure
     closure.propagatedType = expectedClosureType;
     // set inferred types for parameters
     NodeList<FormalParameter> parameters = closure.parameters.parameters;
     List<ParameterElement> expectedParameters = expectedClosureType.parameters;
-    for (int i =
-        0; i < parameters.length && i < expectedParameters.length; i++) {
+    for (int i = 0;
+        i < parameters.length && i < expectedParameters.length;
+        i++) {
       FormalParameter parameter = parameters[i];
       ParameterElement element = parameter.element;
       DartType currentType = _overrideManager.getBestType(element);
       // may be override the type
       DartType expectedType = expectedParameters[i].type;
       if (currentType == null || expectedType.isMoreSpecificThan(currentType)) {
         _overrideManager.setType(element, expectedType);
       }
     }
   }
@@ skipping 56 matching lines @@
       return true;
     } else if (statement is ExpressionStatement) {
       return _isAbruptTerminationExpression(statement.expression);
     } else if (statement is Block) {
       NodeList<Statement> statements = statement.statements;
       int size = statements.length;
       if (size == 0) {
         return false;
       }
 
-
       // This last-statement-is-return heuristic is unsound for adversarial
       // code, but probably works well in the common case:
       //
       //   var x = 123;
       //   var c = true;
       //   L: if (c) {
       //     x = "hello";
       //     c = false;
       //     break L;
       //     return;
@@ skipping 237 matching lines @@
    * in this scope, then an error will be generated and the original element will continue to be
    * mapped to the name. If there is an element with the given name in an enclosing scope, then a
    * warning will be generated but the given element will hide the inherited element.
    *
    * @param element the element to be added to this scope
    */
   void define(Element element) {
     String name = _getName(element);
     if (name != null && !name.isEmpty) {
       if (_definedNames.containsKey(name)) {
-        errorListener.onError(
-            getErrorForDuplicate(_definedNames[name], element));
+        errorListener
+            .onError(getErrorForDuplicate(_definedNames[name], element));
       } else {
         _definedNames[name] = element;
         _hasName = true;
       }
     }
   }
 
   /**
    * Add the given element to this scope without checking for duplication or hiding.
    *
@@ skipping 22 matching lines @@
    * @param existing the first element to be declared with the conflicting name
    * @param duplicate another element declared with the conflicting name
    * @return the error code used to report duplicate names within a scope
    */
   AnalysisError getErrorForDuplicate(Element existing, Element duplicate) {
     // TODO(brianwilkerson) Customize the error message based on the types of
     // elements that share the same name.
     // TODO(jwren) There are 4 error codes for duplicate, but only 1 is being
     // generated.
     Source source = duplicate.source;
-    return new AnalysisError.con2(
-        source,
-        duplicate.nameOffset,
-        duplicate.displayName.length,
-        CompileTimeErrorCode.DUPLICATE_DEFINITION,
+    return new AnalysisError.con2(source, duplicate.nameOffset,
+        duplicate.displayName.length, CompileTimeErrorCode.DUPLICATE_DEFINITION,
         [existing.displayName]);
   }
 
   /**
    * Return the source that contains the given identifier, or the source associated with this scope
    * if the source containing the identifier could not be determined.
    *
    * @param identifier the identifier whose source is to be returned
    * @return the source that contains the given identifier
    */
@@ skipping 12 matching lines @@
    * Return the element with which the given name is associated, or `null` if the name is not
    * defined within this scope.
    *
    * @param identifier the identifier node to lookup element for, used to report correct kind of a
    *          problem and associate problem with
    * @param name the name associated with the element to be returned
    * @param referencingLibrary the library that contains the reference to the name, used to
    *          implement library-level privacy
    * @return the element with which the given name is associated
    */
-  Element internalLookup(Identifier identifier, String name,
-      LibraryElement referencingLibrary);
+  Element internalLookup(
+      Identifier identifier, String name, LibraryElement referencingLibrary);
 
   /**
    * Return the element with which the given name is associated, or `null` if the name is not
    * defined within this scope. This method only returns elements that are directly defined within
    * this scope, not elements that are defined in an enclosing scope.
    *
    * @param name the name associated with the element to be returned
    * @param referencingLibrary the library that contains the reference to the name, used to
    *          implement library-level privacy
    * @return the element with which the given name is associated
@@ skipping 139 matching lines @@
     this._nameScope = nameScope;
   }
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param library the library containing the compilation unit being resolved
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    */
-  ScopedVisitor.con4(ResolvableLibrary library, this.source, this.typeProvider)
-      {
+  ScopedVisitor.con4(
+      ResolvableLibrary library, this.source, this.typeProvider) {
     this._definingLibrary = library.libraryElement;
     LibraryScope libraryScope = library.libraryScope;
     this._errorListener = libraryScope.errorListener;
     this._nameScope = libraryScope;
   }
 
   /**
    * Return the library element for the library containing the compilation unit being resolved.
    *
    * @return the library element for the library containing the compilation unit being resolved
@@ skipping 43 matching lines @@
 
   /**
    * Report an error with the given error code and arguments.
    *
    * @param errorCode the error code of the error to be reported
    * @param node the node specifying the location of the error
    * @param arguments the arguments to the error, used to compose the error message
    */
   void reportErrorForNode(ErrorCode errorCode, AstNode node,
       [List<Object> arguments]) {
-    _errorListener.onError(
-        new AnalysisError.con2(source, node.offset, node.length, errorCode, arguments));
+    _errorListener.onError(new AnalysisError.con2(
+        source, node.offset, node.length, errorCode, arguments));
   }
 
   /**
    * Report an error with the given error code and arguments.
    *
    * @param errorCode the error code of the error to be reported
    * @param offset the offset of the location of the error
    * @param length the length of the location of the error
    * @param arguments the arguments to the error, used to compose the error message
    */
   void reportErrorForOffset(ErrorCode errorCode, int offset, int length,
       [List<Object> arguments]) {
     _errorListener.onError(
         new AnalysisError.con2(source, offset, length, errorCode, arguments));
   }
 
   /**
    * Report an error with the given error code and arguments.
    *
    * @param errorCode the error code of the error to be reported
    * @param token the token specifying the location of the error
    * @param arguments the arguments to the error, used to compose the error message
    */
   void reportErrorForToken(ErrorCode errorCode, sc.Token token,
       [List<Object> arguments]) {
-    _errorListener.onError(
-        new AnalysisError.con2(
-            source,
-            token.offset,
-            token.length,
-            errorCode,
-            arguments));
+    _errorListener.onError(new AnalysisError.con2(
+        source, token.offset, token.length, errorCode, arguments));
   }
 
   /**
    * Visit the given AST node if it is not null.
    *
    * @param node the node to be visited
    */
   void safelyVisit(AstNode node) {
     if (node != null) {
       node.accept(this);
@@ skipping 113 matching lines @@
       if (constructorElement == null) {
         StringBuffer buffer = new StringBuffer();
         buffer.write("Missing element for constructor ");
         buffer.write(node.returnType.name);
         if (node.name != null) {
           buffer.write(".");
           buffer.write(node.name.name);
         }
         buffer.write(" in ");
         buffer.write(definingLibrary.source.fullName);
-        AnalysisEngine.instance.logger.logInformation(
-            buffer.toString(),
+        AnalysisEngine.instance.logger.logInformation(buffer.toString(),
             new CaughtException(new AnalysisException(), null));
       } else {
         _nameScope = new FunctionScope(_nameScope, constructorElement);
       }
       super.visitConstructorDeclaration(node);
     } finally {
       _nameScope = outerScope;
     }
     return null;
   }
@@ skipping 130 matching lines @@
       Scope outerScope = _nameScope;
       try {
         ExecutableElement functionElement = node.element;
         if (functionElement == null) {
           StringBuffer buffer = new StringBuffer();
           buffer.write("Missing element for function ");
           AstNode parent = node.parent;
           while (parent != null) {
             if (parent is Declaration) {
               Element parentElement = (parent as Declaration).element;
-              buffer.write(
-                  parentElement == null ? "<unknown> " : "${parentElement.name} ");
+              buffer.write(parentElement == null
+                  ? "<unknown> "
+                  : "${parentElement.name} ");
             }
             parent = parent.parent;
           }
           buffer.write("in ");
           buffer.write(definingLibrary.source.fullName);
-          AnalysisEngine.instance.logger.logInformation(
-              buffer.toString(),
+          AnalysisEngine.instance.logger.logInformation(buffer.toString(),
               new CaughtException(new AnalysisException(), null));
         } else {
           _nameScope = new FunctionScope(_nameScope, functionElement);
         }
         super.visitFunctionExpression(node);
       } finally {
         _nameScope = outerScope;
       }
     }
     return null;
@@ skipping 209 matching lines @@
    *
    * @param classElement the class to recursively return the set of subtypes of
    */
   HashSet<ClassElement> computeAllSubtypes(ClassElement classElement) {
     // Ensure that we have generated the subtype map for the library
     _computeSubtypesInLibrary(classElement.library);
     // use the subtypeMap to compute the set of all subtypes and subtype's
     // subtypes
     HashSet<ClassElement> allSubtypes = new HashSet<ClassElement>();
     _safelyComputeAllSubtypes(
-        classElement,
-        new HashSet<ClassElement>(),
-        allSubtypes);
+        classElement, new HashSet<ClassElement>(), allSubtypes);
     return allSubtypes;
   }
 
   /**
    * Given some [LibraryElement], visit all of the types in the library, the passed library,
    * and any imported libraries, will be in the [visitedLibraries] set.
    *
    * @param libraryElement the library to visit, it it hasn't been visited already
    */
   void ensureLibraryVisited(LibraryElement libraryElement) {
@@ skipping 71 matching lines @@
       _computeSubtypesInLibrary(exportElt.library);
     }
   }
 
   /**
    * Add some key/ value pair into the [subtypeMap] map.
    *
    * @param supertypeElement the key for the [subtypeMap] map
    * @param subtypeElement the value for the [subtypeMap] map
    */
-  void _putInSubtypeMap(ClassElement supertypeElement,
-      ClassElement subtypeElement) {
+  void _putInSubtypeMap(
+      ClassElement supertypeElement, ClassElement subtypeElement) {
     HashSet<ClassElement> subtypes = _subtypeMap[supertypeElement];
     if (subtypes == null) {
       subtypes = new HashSet<ClassElement>();
       _subtypeMap[supertypeElement] = subtypes;
     }
     subtypes.add(subtypeElement);
   }
 
   /**
    * Given some [ClassElement] and a [HashSet<ClassElement>], this method recursively
@@ skipping 69 matching lines @@
   /**
    * Look for user defined tasks in comments and convert them into info level analysis issues.
    *
    * @param commentToken the comment token to analyze
    */
   void _scrapeTodoComment(sc.Token commentToken) {
     JavaPatternMatcher matcher =
         new JavaPatternMatcher(TodoCode.TODO_REGEX, commentToken.lexeme);
     if (matcher.find()) {
       int offset =
-          commentToken.offset +
-          matcher.start() +
-          matcher.group(1).length;
+          commentToken.offset + matcher.start() + matcher.group(1).length;
       int length = matcher.group(2).length;
       _errorReporter.reportErrorForOffset(
-          TodoCode.TODO,
-          offset,
-          length,
-          [matcher.group(2)]);
+          TodoCode.TODO, offset, length, [matcher.group(2)]);
     }
   }
 }
 
 /**
  * Instances of the class `TypeOverrideManager` manage the ability to override the type of an
  * element within a given context.
  */
 class TypeOverrideManager {
   /**
@@ skipping 27 matching lines @@
     return _currentScope.captureLocalOverrides();
   }
 
   /**
    * 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<VariableElement, DartType>
-      captureOverrides(VariableDeclarationList variableList) {
+  Map<VariableElement, DartType> captureOverrides(
+      VariableDeclarationList variableList) {
     if (_currentScope == null) {
       throw new IllegalStateException(
           "Cannot capture overrides without a scope");
     }
     return _currentScope.captureOverrides(variableList);
   }
 
   /**
    * Enter a new override scope.
    */
@@ skipping 166 matching lines @@
    */
   Map<VariableElement, DartType> 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<VariableElement, DartType>
-      captureOverrides(VariableDeclarationList variableList) {
+  Map<VariableElement, DartType> captureOverrides(
+      VariableDeclarationList variableList) {
     Map<VariableElement, DartType> overrides =
         new HashMap<VariableElement, DartType>();
     if (variableList.isConst || variableList.isFinal) {
       for (VariableDeclaration variable in variableList.variables) {
         VariableElement element = variable.element;
         if (element != null) {
           DartType type = _overridenTypes[element];
           if (type != null) {
             overrides[element] = type;
           }
@@ skipping 564 matching lines @@
    * Return the type with the given name from the given namespace, or `null` if there is no
    * class with the given name.
    *
    * @param namespace the namespace in which to search for the given name
    * @param typeName the name of the type being searched for
    * @return the type that was found
    */
   InterfaceType _getType(Namespace namespace, String typeName) {
     Element element = namespace.get(typeName);
     if (element == null) {
-      AnalysisEngine.instance.logger.logInformation(
-          "No definition of type $typeName");
+      AnalysisEngine.instance.logger
+          .logInformation("No definition of type $typeName");
       return null;
     }
     return (element as ClassElement).type;
   }
 
   /**
    * Initialize the types provided by this type provider from the given library.
    *
    * @param library the library containing the definitions of the core types
    */
-  void _initializeFrom(LibraryElement coreLibrary,
-      LibraryElement asyncLibrary) {
+  void _initializeFrom(
+      LibraryElement coreLibrary, LibraryElement asyncLibrary) {
     Namespace coreNamespace =
         new NamespaceBuilder().createPublicNamespaceForLibrary(coreLibrary);
     Namespace asyncNamespace =
         new NamespaceBuilder().createPublicNamespaceForLibrary(asyncLibrary);
     _boolType = _getType(coreNamespace, "bool");
     _bottomType = BottomTypeImpl.instance;
     _deprecatedType = _getType(coreNamespace, "Deprecated");
     _doubleType = _getType(coreNamespace, "double");
     _dynamicType = DynamicTypeImpl.instance;
     _functionType = _getType(coreNamespace, "Function");
@@ skipping 40 matching lines @@
    */
   bool _hasReferenceToSuper = false;
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param library the library containing the compilation unit being resolved
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    */
-  TypeResolverVisitor.con1(Library library, Source source,
-      TypeProvider typeProvider)
+  TypeResolverVisitor.con1(
+      Library library, Source source, TypeProvider typeProvider)
       : super.con1(library, source, typeProvider) {
     _dynamicType = typeProvider.dynamicType;
     _undefinedType = typeProvider.undefinedType;
   }
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param definingLibrary the element for the library containing the compilation unit being
    *          visited
@@ skipping 13 matching lines @@
    * Initialize a newly created visitor to resolve the nodes in an AST node.
    *
    * @param definingLibrary the element for the library containing the node being visited
    * @param source the source representing the compilation unit containing the node being visited
    * @param typeProvider the object used to access the types from the core library
    * @param nameScope the scope used to resolve identifiers in the node that will first be visited
    * @param errorListener the error listener that will be informed of any errors that are found
    *          during resolution
    */
   TypeResolverVisitor.con3(LibraryElement definingLibrary, Source source,
-      TypeProvider typeProvider, Scope nameScope, AnalysisErrorListener errorListener)
+      TypeProvider typeProvider, Scope nameScope,
+      AnalysisErrorListener errorListener)
       : super.con3(
-          definingLibrary,
-          source,
-          typeProvider,
-          nameScope,
-          errorListener) {
+          definingLibrary, source, typeProvider, nameScope, errorListener) {
     _dynamicType = typeProvider.dynamicType;
     _undefinedType = typeProvider.undefinedType;
   }
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param library the library containing the compilation unit being resolved
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    */
-  TypeResolverVisitor.con4(ResolvableLibrary library, Source source,
-      TypeProvider typeProvider)
+  TypeResolverVisitor.con4(
+      ResolvableLibrary library, Source source, TypeProvider typeProvider)
       : super.con4(library, source, typeProvider) {
     _dynamicType = typeProvider.dynamicType;
     _undefinedType = typeProvider.undefinedType;
   }
 
   @override
   Object visitAnnotation(Annotation node) {
     //
     // Visit annotations, if the annotation is @proxy, on a class, and "proxy"
     // resolves to the proxy annotation in dart.core, then create create the
@@ skipping 68 matching lines @@
 
   @override
   void visitClassDeclarationInScope(ClassDeclaration node) {
     super.visitClassDeclarationInScope(node);
     ExtendsClause extendsClause = node.extendsClause;
     WithClause withClause = node.withClause;
     ImplementsClause implementsClause = node.implementsClause;
     ClassElementImpl classElement = _getClassElement(node.name);
     InterfaceType superclassType = null;
     if (extendsClause != null) {
-      ErrorCode errorCode = (withClause == null ?
-          CompileTimeErrorCode.EXTENDS_NON_CLASS :
-          CompileTimeErrorCode.MIXIN_WITH_NON_CLASS_SUPERCLASS);
-      superclassType = _resolveType(
-          extendsClause.superclass,
-          errorCode,
-          CompileTimeErrorCode.EXTENDS_ENUM,
-          errorCode);
+      ErrorCode errorCode = (withClause == null
+          ? CompileTimeErrorCode.EXTENDS_NON_CLASS
+          : CompileTimeErrorCode.MIXIN_WITH_NON_CLASS_SUPERCLASS);
+      superclassType = _resolveType(extendsClause.superclass, errorCode,
+          CompileTimeErrorCode.EXTENDS_ENUM, errorCode);
       if (!identical(superclassType, typeProvider.objectType)) {
         classElement.validMixin = false;
       }
     }
     if (classElement != null) {
       if (superclassType == null) {
         InterfaceType objectType = typeProvider.objectType;
         if (!identical(classElement.type, objectType)) {
           superclassType = objectType;
         }
@@ skipping 16 matching lines @@
     int count = nonFields.length;
     for (int i = 0; i < count; i++) {
       nonFields[i].accept(this);
     }
   }
 
   @override
   Object visitClassTypeAlias(ClassTypeAlias node) {
     super.visitClassTypeAlias(node);
     ErrorCode errorCode = CompileTimeErrorCode.MIXIN_WITH_NON_CLASS_SUPERCLASS;
-    InterfaceType superclassType = _resolveType(
-        node.superclass,
-        errorCode,
-        CompileTimeErrorCode.EXTENDS_ENUM,
-        errorCode);
+    InterfaceType superclassType = _resolveType(node.superclass, errorCode,
+        CompileTimeErrorCode.EXTENDS_ENUM, errorCode);
     if (superclassType == null) {
       superclassType = typeProvider.objectType;
     }
     ClassElementImpl classElement = _getClassElement(node.name);
     if (classElement != null) {
       classElement.supertype = superclassType;
     }
     _resolve(classElement, node.withClause, node.implementsClause);
     return null;
   }
@@ skipping 10 matching lines @@
       buffer.write(node.name == null ? "<unnamed>" : node.name.name);
       buffer.write(" in ");
       if (classNode == null) {
         buffer.write("<unknown class>");
       } else {
         buffer.write(classNode.name.name);
       }
       buffer.write(" in ");
       buffer.write(source.fullName);
       buffer.write(" was not set while trying to resolve types.");
-      AnalysisEngine.instance.logger.logError(
-          buffer.toString(),
+      AnalysisEngine.instance.logger.logError(buffer.toString(),
           new CaughtException(new AnalysisException(), null));
     } else {
       ClassElement definingClass = element.enclosingElement as ClassElement;
       element.returnType = definingClass.type;
       FunctionTypeImpl type = new FunctionTypeImpl.con1(element);
       type.typeArguments = definingClass.type.typeArguments;
       element.type = type;
     }
     return null;
   }
@@ skipping 49 matching lines @@
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     super.visitFunctionDeclaration(node);
     ExecutableElementImpl element = node.element as ExecutableElementImpl;
     if (element == null) {
       StringBuffer buffer = new StringBuffer();
       buffer.write("The element for the top-level function ");
       buffer.write(node.name);
       buffer.write(" in ");
       buffer.write(source.fullName);
       buffer.write(" was not set while trying to resolve types.");
-      AnalysisEngine.instance.logger.logError(
-          buffer.toString(),
+      AnalysisEngine.instance.logger.logError(buffer.toString(),
           new CaughtException(new AnalysisException(), null));
     }
     element.returnType = _computeReturnType(node.returnType);
     FunctionTypeImpl type = new FunctionTypeImpl.con1(element);
     ClassElement definingClass =
         element.getAncestor((element) => element is ClassElement);
     if (definingClass != null) {
       type.typeArguments = definingClass.type.typeArguments;
     }
     element.type = type;
@@ skipping 36 matching lines @@
       buffer.write(node.name.name);
       buffer.write(" in ");
       if (classNode == null) {
         buffer.write("<unknown class>");
       } else {
         buffer.write(classNode.name.name);
       }
       buffer.write(" in ");
       buffer.write(source.fullName);
       buffer.write(" was not set while trying to resolve types.");
-      AnalysisEngine.instance.logger.logError(
-          buffer.toString(),
+      AnalysisEngine.instance.logger.logError(buffer.toString(),
           new CaughtException(new AnalysisException(), null));
     }
     element.returnType = _computeReturnType(node.returnType);
     FunctionTypeImpl type = new FunctionTypeImpl.con1(element);
     ClassElement definingClass =
         element.getAncestor((element) => element is ClassElement);
     if (definingClass != null) {
       type.typeArguments = definingClass.type.typeArguments;
     }
     element.type = type;
@@ skipping 84 matching lines @@
         if (name.name == null) {
           PrefixedIdentifier prefixedIdentifier =
               typeName as PrefixedIdentifier;
           SimpleIdentifier prefix = prefixedIdentifier.prefix;
           element = nameScope.lookup(prefix, definingLibrary);
           if (element is PrefixElement) {
             if (parent.parent is InstanceCreationExpression &&
                 (parent.parent as InstanceCreationExpression).isConst) {
               // If, if this is a const expression, then generate a
               // CompileTimeErrorCode.CONST_WITH_NON_TYPE error.
-              reportErrorForNode(
-                  CompileTimeErrorCode.CONST_WITH_NON_TYPE,
+              reportErrorForNode(CompileTimeErrorCode.CONST_WITH_NON_TYPE,
                   prefixedIdentifier.identifier,
                   [prefixedIdentifier.identifier.name]);
             } else {
               // Else, if this expression is a new expression, report a
               // NEW_WITH_NON_TYPE warning.
-              reportErrorForNode(
-                  StaticWarningCode.NEW_WITH_NON_TYPE,
-                  prefixedIdentifier.identifier,
-                  [prefixedIdentifier.identifier.name]);
+              reportErrorForNode(StaticWarningCode.NEW_WITH_NON_TYPE,
+                  prefixedIdentifier.identifier, [
+                prefixedIdentifier.identifier.name
+              ]);
             }
             _setElement(prefix, element);
             return null;
           } else if (element != null) {
             //
             // Rewrite the constructor name. The parser, when it sees a
             // constructor named "a.b", cannot tell whether "a" is a prefix and
             // "b" is a class name, or whether "a" is a class name and "b" is a
             // constructor name. It arbitrarily chooses the former, but in this
             // case was wrong.
@@ skipping 10 matching lines @@
     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 (element == null) {
           reportErrorForNode(
-              CompileTimeErrorCode.UNDEFINED_CLASS,
-              typeNameSimple,
-              [typeName]);
+              CompileTimeErrorCode.UNDEFINED_CLASS, typeNameSimple, [typeName]);
         } else {
-          reportErrorForNode(
-              CompileTimeErrorCode.CONST_WITH_NON_TYPE,
-              typeNameSimple,
-              [typeName]);
+          reportErrorForNode(CompileTimeErrorCode.CONST_WITH_NON_TYPE,
+              typeNameSimple, [typeName]);
         }
         elementValid = false;
       } else {
         if (element != null) {
           reportErrorForNode(
-              StaticWarningCode.NEW_WITH_NON_TYPE,
-              typeNameSimple,
-              [typeName]);
+              StaticWarningCode.NEW_WITH_NON_TYPE, typeNameSimple, [typeName]);
           elementValid = false;
         }
       }
     }
     if (elementValid && element == null) {
       // We couldn't resolve the type name.
       // TODO(jwren) Consider moving the check for
       // CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE from the
       // ErrorVerifier, so that we don't have two errors on a built in
       // identifier being used as a class name.
       // See CompileTimeErrorCodeTest.test_builtInIdentifierAsType().
       SimpleIdentifier typeNameSimple = _getTypeSimpleIdentifier(typeName);
       RedirectingConstructorKind redirectingConstructorKind;
       if (_isBuiltInIdentifier(node) && _isTypeAnnotation(node)) {
-        reportErrorForNode(
-            CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE,
-            typeName,
-            [typeName.name]);
+        reportErrorForNode(CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE,
+            typeName, [typeName.name]);
       } else if (typeNameSimple.name == "boolean") {
         reportErrorForNode(
-            StaticWarningCode.UNDEFINED_CLASS_BOOLEAN,
-            typeNameSimple,
-            []);
+            StaticWarningCode.UNDEFINED_CLASS_BOOLEAN, typeNameSimple, []);
       } else if (_isTypeNameInCatchClause(node)) {
-        reportErrorForNode(
-            StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE,
-            typeName,
+        reportErrorForNode(StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE, typeName,
             [typeName.name]);
       } else if (_isTypeNameInAsExpression(node)) {
         reportErrorForNode(
-            StaticWarningCode.CAST_TO_NON_TYPE,
-            typeName,
-            [typeName.name]);
+            StaticWarningCode.CAST_TO_NON_TYPE, typeName, [typeName.name]);
       } else if (_isTypeNameInIsExpression(node)) {
-        reportErrorForNode(
-            StaticWarningCode.TYPE_TEST_WITH_UNDEFINED_NAME,
-            typeName,
-            [typeName.name]);
+        reportErrorForNode(StaticWarningCode.TYPE_TEST_WITH_UNDEFINED_NAME,
+            typeName, [typeName.name]);
       } else if ((redirectingConstructorKind =
-          _getRedirectingConstructorKind(node)) != null) {
-        ErrorCode errorCode =
-            (redirectingConstructorKind == RedirectingConstructorKind.CONST ?
-                CompileTimeErrorCode.REDIRECT_TO_NON_CLASS :
-                StaticWarningCode.REDIRECT_TO_NON_CLASS);
+              _getRedirectingConstructorKind(node)) !=
+          null) {
+        ErrorCode errorCode = (redirectingConstructorKind ==
+                RedirectingConstructorKind.CONST
+            ? CompileTimeErrorCode.REDIRECT_TO_NON_CLASS
+            : StaticWarningCode.REDIRECT_TO_NON_CLASS);
         reportErrorForNode(errorCode, typeName, [typeName.name]);
       } else if (_isTypeNameInTypeArgumentList(node)) {
-        reportErrorForNode(
-            StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT,
-            typeName,
-            [typeName.name]);
+        reportErrorForNode(StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT,
+            typeName, [typeName.name]);
       } else {
         reportErrorForNode(
-            StaticWarningCode.UNDEFINED_CLASS,
-            typeName,
-            [typeName.name]);
+            StaticWarningCode.UNDEFINED_CLASS, typeName, [typeName.name]);
       }
       elementValid = false;
     }
     if (!elementValid) {
       if (element is MultiplyDefinedElement) {
         _setElement(typeName, element);
       } else {
         _setElement(typeName, _dynamicType.element);
       }
       typeName.staticType = _undefinedType;
@@ skipping 19 matching lines @@
       List<Element> elements =
           (element as MultiplyDefinedElement).conflictingElements;
       type = _getTypeWhenMultiplyDefined(elements);
       if (type != null) {
         node.type = type;
       }
     } else {
       // The name does not represent a type.
       RedirectingConstructorKind redirectingConstructorKind;
       if (_isTypeNameInCatchClause(node)) {
-        reportErrorForNode(
-            StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE,
-            typeName,
+        reportErrorForNode(StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE, typeName,
             [typeName.name]);
       } else if (_isTypeNameInAsExpression(node)) {
         reportErrorForNode(
-            StaticWarningCode.CAST_TO_NON_TYPE,
-            typeName,
-            [typeName.name]);
+            StaticWarningCode.CAST_TO_NON_TYPE, typeName, [typeName.name]);
       } else if (_isTypeNameInIsExpression(node)) {
-        reportErrorForNode(
-            StaticWarningCode.TYPE_TEST_WITH_NON_TYPE,
-            typeName,
+        reportErrorForNode(StaticWarningCode.TYPE_TEST_WITH_NON_TYPE, typeName,
             [typeName.name]);
       } else if ((redirectingConstructorKind =
-          _getRedirectingConstructorKind(node)) != null) {
-        ErrorCode errorCode =
-            (redirectingConstructorKind == RedirectingConstructorKind.CONST ?
-                CompileTimeErrorCode.REDIRECT_TO_NON_CLASS :
-                StaticWarningCode.REDIRECT_TO_NON_CLASS);
+              _getRedirectingConstructorKind(node)) !=
+          null) {
+        ErrorCode errorCode = (redirectingConstructorKind ==
+                RedirectingConstructorKind.CONST
+            ? CompileTimeErrorCode.REDIRECT_TO_NON_CLASS
+            : StaticWarningCode.REDIRECT_TO_NON_CLASS);
         reportErrorForNode(errorCode, typeName, [typeName.name]);
       } else if (_isTypeNameInTypeArgumentList(node)) {
-        reportErrorForNode(
-            StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT,
-            typeName,
-            [typeName.name]);
+        reportErrorForNode(StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT,
+            typeName, [typeName.name]);
       } else {
         AstNode parent = typeName.parent;
         while (parent is TypeName) {
           parent = parent.parent;
         }
         if (parent is ExtendsClause ||
             parent is ImplementsClause ||
             parent is WithClause ||
             parent is ClassTypeAlias) {
           // Ignored. The error will be reported elsewhere.
         } else {
           reportErrorForNode(
-              StaticWarningCode.NOT_A_TYPE,
-              typeName,
-              [typeName.name]);
+              StaticWarningCode.NOT_A_TYPE, typeName, [typeName.name]);
         }
       }
       _setElement(typeName, _dynamicType.element);
       typeName.staticType = _dynamicType;
       node.type = _dynamicType;
       return null;
     }
     if (argumentList != null) {
       NodeList<TypeName> arguments = argumentList.arguments;
       int argumentCount = arguments.length;
       List<DartType> parameters = _getTypeArguments(type);
       int parameterCount = parameters.length;
       List<DartType> typeArguments = new List<DartType>(parameterCount);
       if (argumentCount == parameterCount) {
         for (int i = 0; i < parameterCount; i++) {
           TypeName argumentTypeName = arguments[i];
           DartType argumentType = _getType(argumentTypeName);
           if (argumentType == null) {
             argumentType = _dynamicType;
           }
           typeArguments[i] = argumentType;
         }
       } else {
-        reportErrorForNode(
-            _getInvalidTypeParametersErrorCode(node),
-            node,
-            [typeName.name, parameterCount, argumentCount]);
+        reportErrorForNode(_getInvalidTypeParametersErrorCode(node), node, [
+          typeName.name,
+          parameterCount,
+          argumentCount
+        ]);
         for (int i = 0; i < parameterCount; i++) {
           typeArguments[i] = _dynamicType;
         }
       }
       if (type is InterfaceTypeImpl) {
         InterfaceTypeImpl interfaceType = type as InterfaceTypeImpl;
         type = interfaceType.substitute4(typeArguments);
       } else if (type is FunctionTypeImpl) {
         FunctionTypeImpl functionType = type as FunctionTypeImpl;
         type = functionType.substitute3(typeArguments);
@@ skipping 173 matching lines @@
    */
   RedirectingConstructorKind _getRedirectingConstructorKind(TypeName typeName) {
     AstNode parent = typeName.parent;
     if (parent is ConstructorName) {
       ConstructorName constructorName = parent as ConstructorName;
       parent = constructorName.parent;
       if (parent is ConstructorDeclaration) {
         ConstructorDeclaration constructorDeclaration =
             parent as ConstructorDeclaration;
         if (identical(
-            constructorDeclaration.redirectedConstructor,
-            constructorName)) {
+            constructorDeclaration.redirectedConstructor, constructorName)) {
           if (constructorDeclaration.constKeyword != null) {
             return RedirectingConstructorKind.CONST;
           }
           return RedirectingConstructorKind.NORMAL;
         }
       }
     }
     return null;
   }
 
@@ skipping 152 matching lines @@
    * given class element.
    *
    * @param classElement the class element with which the mixin and interface types are to be
    *          associated
    * @param withClause the with clause to be resolved
    * @param implementsClause the implements clause to be resolved
    */
   void _resolve(ClassElementImpl classElement, WithClause withClause,
       ImplementsClause implementsClause) {
     if (withClause != null) {
-      List<InterfaceType> mixinTypes = _resolveTypes(
-          withClause.mixinTypes,
+      List<InterfaceType> mixinTypes = _resolveTypes(withClause.mixinTypes,
           CompileTimeErrorCode.MIXIN_OF_NON_CLASS,
           CompileTimeErrorCode.MIXIN_OF_ENUM,
           CompileTimeErrorCode.MIXIN_OF_NON_CLASS);
       if (classElement != null) {
         classElement.mixins = mixinTypes;
       }
     }
     if (implementsClause != null) {
       NodeList<TypeName> interfaces = implementsClause.interfaces;
-      List<InterfaceType> interfaceTypes = _resolveTypes(
-          interfaces,
+      List<InterfaceType> interfaceTypes = _resolveTypes(interfaces,
           CompileTimeErrorCode.IMPLEMENTS_NON_CLASS,
           CompileTimeErrorCode.IMPLEMENTS_ENUM,
           CompileTimeErrorCode.IMPLEMENTS_DYNAMIC);
       if (classElement != null) {
         classElement.interfaces = interfaceTypes;
       }
       // TODO(brianwilkerson) Move the following checks to ErrorVerifier.
       int count = interfaces.length;
       List<bool> detectedRepeatOnIndex = new List<bool>.filled(count, false);
       for (int i = 0; i < detectedRepeatOnIndex.length; i++) {
         detectedRepeatOnIndex[i] = false;
       }
       for (int i = 0; i < count; i++) {
         TypeName typeName = interfaces[i];
         if (!detectedRepeatOnIndex[i]) {
           Element element = typeName.name.staticElement;
           for (int j = i + 1; j < count; j++) {
             TypeName typeName2 = interfaces[j];
             Identifier identifier2 = typeName2.name;
             String name2 = identifier2.name;
             Element element2 = identifier2.staticElement;
             if (element != null && element == element2) {
               detectedRepeatOnIndex[j] = true;
               reportErrorForNode(
-                  CompileTimeErrorCode.IMPLEMENTS_REPEATED,
-                  typeName2,
-                  [name2]);
+                  CompileTimeErrorCode.IMPLEMENTS_REPEATED, typeName2, [name2]);
             }
           }
         }
       }
     }
   }
 
   /**
    * Return the type specified by the given name.
    *
@@ skipping 30 matching lines @@
    * Resolve the types in the given list of type names.
    *
    * @param typeNames the type names to be resolved
    * @param nonTypeError the error to produce if the type name is defined to be something other than
    *          a type
    * @param enumTypeError the error to produce if the type name is defined to be an enum
    * @param dynamicTypeError the error to produce if the type name is "dynamic"
    * @return an array containing all of the types that were resolved.
    */
   List<InterfaceType> _resolveTypes(NodeList<TypeName> typeNames,
-      ErrorCode nonTypeError, ErrorCode enumTypeError, ErrorCode dynamicTypeError) {
+      ErrorCode nonTypeError, ErrorCode enumTypeError,
+      ErrorCode dynamicTypeError) {
     List<InterfaceType> types = new List<InterfaceType>();
     for (TypeName typeName in typeNames) {
       InterfaceType type =
           _resolveType(typeName, nonTypeError, enumTypeError, dynamicTypeError);
       if (type != null) {
         types.add(type);
       }
     }
     return types;
   }
@@ skipping 96 matching lines @@
    */
   ExecutableElement _enclosingFunction;
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param library the library containing the compilation unit being resolved
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    */
-  VariableResolverVisitor.con1(Library library, Source source,
-      TypeProvider typeProvider)
+  VariableResolverVisitor.con1(
+      Library library, Source source, TypeProvider typeProvider)
       : super.con1(library, source, typeProvider);
 
   /**
    * Initialize a newly created visitor to resolve the nodes in an AST node.
    *
    * @param definingLibrary the element for the library containing the node being visited
    * @param source the source representing the compilation unit containing the node being visited
    * @param typeProvider the object used to access the types from the core library
    * @param nameScope the scope used to resolve identifiers in the node that will first be visited
    * @param errorListener the error listener that will be informed of any errors that are found
    *          during resolution
    */
   VariableResolverVisitor.con2(LibraryElement definingLibrary, Source source,
-      TypeProvider typeProvider, Scope nameScope, AnalysisErrorListener errorListener)
+      TypeProvider typeProvider, Scope nameScope,
+      AnalysisErrorListener errorListener)
       : super.con3(
-          definingLibrary,
-          source,
-          typeProvider,
-          nameScope,
-          errorListener);
+          definingLibrary, source, typeProvider, nameScope, errorListener);
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param library the library containing the compilation unit being resolved
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    */
-  VariableResolverVisitor.con3(ResolvableLibrary library, Source source,
-      TypeProvider typeProvider)
+  VariableResolverVisitor.con3(
+      ResolvableLibrary library, Source source, TypeProvider typeProvider)
       : super.con4(library, source, typeProvider);
 
   @override
   Object visitExportDirective(ExportDirective node) => null;
 
   @override
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     ExecutableElement outerFunction = _enclosingFunction;
     try {
       _enclosingFunction = node.element;
@@ skipping 91 matching lines @@
 
   @override
   DartObjectImpl visitSimpleIdentifier(SimpleIdentifier node) {
     Element element = node.staticElement;
     for (ParameterElement parameterElement in parameterElements) {
       if (identical(parameterElement, element) && parameterElement != null) {
         DartType type = parameterElement.type;
         if (type != null) {
           if (type.isDynamic) {
             return new DartObjectImpl(
-                verifier._typeProvider.objectType,
-                DynamicState.DYNAMIC_STATE);
+                verifier._typeProvider.objectType, DynamicState.DYNAMIC_STATE);
           } else if (type.isSubtypeOf(verifier._boolType)) {
             return new DartObjectImpl(
-                verifier._typeProvider.boolType,
-                BoolState.UNKNOWN_VALUE);
+                verifier._typeProvider.boolType, BoolState.UNKNOWN_VALUE);
           } else if (type.isSubtypeOf(verifier._typeProvider.doubleType)) {
             return new DartObjectImpl(
-                verifier._typeProvider.doubleType,
-                DoubleState.UNKNOWN_VALUE);
+                verifier._typeProvider.doubleType, DoubleState.UNKNOWN_VALUE);
           } else if (type.isSubtypeOf(verifier._intType)) {
             return new DartObjectImpl(
-                verifier._typeProvider.intType,
-                IntState.UNKNOWN_VALUE);
+                verifier._typeProvider.intType, IntState.UNKNOWN_VALUE);
           } else if (type.isSubtypeOf(verifier._numType)) {
             return new DartObjectImpl(
-                verifier._typeProvider.numType,
-                NumState.UNKNOWN_VALUE);
+                verifier._typeProvider.numType, NumState.UNKNOWN_VALUE);
           } else if (type.isSubtypeOf(verifier._stringType)) {
             return new DartObjectImpl(
-                verifier._typeProvider.stringType,
-                StringState.UNKNOWN_VALUE);
+                verifier._typeProvider.stringType, StringState.UNKNOWN_VALUE);
           }
           //
           // We don't test for other types of objects (such as List, Map,
           // Function or Type) because there are no operations allowed on such
           // types other than '==' and '!=', which means that we don't need to
           // know the type when there is no specific data about the state of
           // such objects.
           //
         }
         return new DartObjectImpl(
             type is InterfaceType ? type : verifier._typeProvider.objectType,
             GenericState.UNKNOWN_VALUE);
       }
     }
     return super.visitSimpleIdentifier(node);
   }
 }
 
 class _ElementBuilder_visitClassDeclaration extends UnifyingAstVisitor<Object> {
   final ElementBuilder builder;
 
   List<ClassMember> nonFields;
 
-  _ElementBuilder_visitClassDeclaration(this.builder, this.nonFields)
-      : super();
+  _ElementBuilder_visitClassDeclaration(this.builder, this.nonFields) : super();
 
   @override
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitMethodDeclaration(MethodDeclaration node) {
     nonFields.add(node);
@@ skipping 165 matching lines @@
       // v++;
       // ++v;
       // v += 2;
       return false;
     }
     // OK
     return true;
   }
 }
 
-class _ResolverVisitor_isVariableAccessedInClosure extends
-    RecursiveAstVisitor<Object> {
+class _ResolverVisitor_isVariableAccessedInClosure
+    extends RecursiveAstVisitor<Object> {
   final Element variable;
 
   bool result = false;
 
   bool _inClosure = false;
 
   _ResolverVisitor_isVariableAccessedInClosure(this.variable);
 
   @override
   Object visitFunctionExpression(FunctionExpression node) {
@@ skipping 11 matching lines @@
     if (result) {
       return null;
     }
     if (_inClosure && identical(node.staticElement, variable)) {
       result = true;
     }
     return null;
   }
 }
 
-
-class _ResolverVisitor_isVariablePotentiallyMutatedIn extends
-    RecursiveAstVisitor<Object> {
+class _ResolverVisitor_isVariablePotentiallyMutatedIn
+    extends RecursiveAstVisitor<Object> {
   final Element variable;
 
   bool result = false;
 
   _ResolverVisitor_isVariablePotentiallyMutatedIn(this.variable);
 
   @override
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     if (result) {
       return null;
     }
     if (identical(node.staticElement, variable)) {
       if (node.inSetterContext()) {
         result = true;
       }
     }
     return null;
   }
 }
 
-
-class _TypeResolverVisitor_visitClassMembersInScope extends
-    UnifyingAstVisitor<Object> {
+class _TypeResolverVisitor_visitClassMembersInScope
+    extends UnifyingAstVisitor<Object> {
   final TypeResolverVisitor TypeResolverVisitor_this;
 
   List<ClassMember> nonFields;
 
-  _TypeResolverVisitor_visitClassMembersInScope(this.TypeResolverVisitor_this,
-      this.nonFields)
+  _TypeResolverVisitor_visitClassMembersInScope(
+      this.TypeResolverVisitor_this, this.nonFields)
       : super();
 
   @override
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitExtendsClause(ExtendsClause node) => null;
 
   @override
   Object visitImplementsClause(ImplementsClause node) => null;
 
   @override
   Object visitMethodDeclaration(MethodDeclaration node) {
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
 
   @override
   Object visitWithClause(WithClause node) => null;
 }
 
-
 /**
  * Instances of the class [_UnusedElementsVerifier] traverse an element
  * structure looking for cases of [HintCode.UNUSED_ELEMENT] and
  * [HintCode.UNUSED_LOCAL_VARIABLE].
  */
 class _UnusedElementsVerifier extends RecursiveElementVisitor {
   /**
    * The error listener to which errors will be reported.
    */
   final AnalysisErrorListener _errorListener;
 
   /**
    * The elements know to be used.
    */
   final _UsedElements _usedElements;
 
   /**
    * Create a new instance of the [_UnusedElementsVerifier].
    */
   _UnusedElementsVerifier(this._errorListener, this._usedElements);
 
   @override
   visitClassElement(ClassElement element) {
     if (!_isUsedElement(element)) {
-      _reportErrorForElement(
-          HintCode.UNUSED_ELEMENT,
-          element,
-          [element.kind.displayName, element.displayName]);
+      _reportErrorForElement(HintCode.UNUSED_ELEMENT, element, [
+        element.kind.displayName,
+        element.displayName
+      ]);
     }
     super.visitClassElement(element);
   }
 
   @override
   visitFieldElement(FieldElement element) {
     if (!_isReadMember(element)) {
       _reportErrorForElement(
-          HintCode.UNUSED_FIELD,
-          element,
-          [element.displayName]);
+          HintCode.UNUSED_FIELD, element, [element.displayName]);
     }
     super.visitFieldElement(element);
   }
 
   @override
   visitFunctionElement(FunctionElement element) {
     if (!_isUsedElement(element)) {
-      _reportErrorForElement(
-          HintCode.UNUSED_ELEMENT,
-          element,
-          [element.kind.displayName, element.displayName]);
+      _reportErrorForElement(HintCode.UNUSED_ELEMENT, element, [
+        element.kind.displayName,
+        element.displayName
+      ]);
     }
     super.visitFunctionElement(element);
   }
 
   @override
   visitLocalVariableElement(LocalVariableElement element) {
     if (!_isUsedElement(element)) {
       _reportErrorForElement(
-          HintCode.UNUSED_LOCAL_VARIABLE,
-          element,
-          [element.displayName]);
+          HintCode.UNUSED_LOCAL_VARIABLE, element, [element.displayName]);
     }
   }
 
   @override
   visitMethodElement(MethodElement element) {
     if (!_isUsedMember(element)) {
-      _reportErrorForElement(
-          HintCode.UNUSED_ELEMENT,
-          element,
-          [element.kind.displayName, element.displayName]);
+      _reportErrorForElement(HintCode.UNUSED_ELEMENT, element, [
+        element.kind.displayName,
+        element.displayName
+      ]);
     }
     super.visitMethodElement(element);
   }
 
   @override
   visitPropertyAccessorElement(PropertyAccessorElement element) {
     if (!_isUsedMember(element)) {
-      _reportErrorForElement(
-          HintCode.UNUSED_ELEMENT,
-          element,
-          [element.kind.displayName, element.displayName]);
+      _reportErrorForElement(HintCode.UNUSED_ELEMENT, element, [
+        element.kind.displayName,
+        element.displayName
+      ]);
     }
     super.visitPropertyAccessorElement(element);
   }
 
   bool _isReadMember(Element element) {
     if (element.isPublic) {
       return true;
     }
     if (element.isSynthetic) {
       return true;
@@ skipping 22 matching lines @@
     }
     if (element.isSynthetic) {
       return true;
     }
     if (_usedElements.members.contains(element.displayName)) {
       return true;
     }
     return _usedElements.elements.contains(element);
   }
 
-  void _reportErrorForElement(ErrorCode errorCode, Element element,
-      List<Object> arguments) {
+  void _reportErrorForElement(
+      ErrorCode errorCode, Element element, List<Object> arguments) {
     if (element != null) {
-      _errorListener.onError(
-          new AnalysisError.con2(
-              element.source,
-              element.nameOffset,
-              element.displayName.length,
-              errorCode,
-              arguments));
+      _errorListener.onError(new AnalysisError.con2(element.source,
+          element.nameOffset, element.displayName.length, errorCode,
+          arguments));
     }
   }
 }
 
-
 class _UsedElements {
   /**
    * Resolved, locally defined elements that are used or potentially can be
    * used.
    */
   final HashSet<Element> elements = new HashSet<Element>();
 
   /**
    * Names of resolved or unresolved class members that are referenced in the
    * library.
    */
   final HashSet<String> members = new HashSet<String>();
 
   /**
    * Names of resolved or unresolved class members that are read in the
    * library.
    */
   final HashSet<String> readMembers = new HashSet<String>();
 }