Reformat

pkg/analyzer/lib/src/generated/error_verifier.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.error_verifier;
 
 import "dart:math" as math;
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/static_type_analyzer.dart';
@@ skipping 247 matching lines @@
     _isEnclosingConstructorConst = false;
     _isInCatchClause = false;
     _isInStaticVariableDeclaration = false;
     _isInInstanceVariableDeclaration = false;
     _isInInstanceVariableInitializer = false;
     _isInConstructorInitializer = false;
     _isInStaticMethod = false;
     _boolType = _typeProvider.boolType;
     _intType = _typeProvider.intType;
     _DISALLOWED_TYPES_TO_EXTEND_OR_IMPLEMENT = <InterfaceType>[
-        _typeProvider.nullType,
-        _typeProvider.numType,
-        _intType,
-        _typeProvider.doubleType,
-        _boolType,
-        _typeProvider.stringType];
+      _typeProvider.nullType,
+      _typeProvider.numType,
+      _intType,
+      _typeProvider.doubleType,
+      _boolType,
+      _typeProvider.stringType
+    ];
   }
 
   @override
   Object visitAnnotation(Annotation node) {
     _checkForInvalidAnnotationFromDeferredLibrary(node);
     return super.visitAnnotation(node);
   }
 
   @override
   Object visitArgumentList(ArgumentList node) {
@@ skipping 25 matching lines @@
       _checkForArgumentTypeNotAssignableForArgument(rhs);
     }
     _checkForAssignmentToFinal(lhs);
     return super.visitAssignmentExpression(node);
   }
 
   @override
   Object visitAwaitExpression(AwaitExpression node) {
     if (!_inAsync) {
       _errorReporter.reportErrorForToken(
-          CompileTimeErrorCode.AWAIT_IN_WRONG_CONTEXT,
-          node.awaitKeyword);
+          CompileTimeErrorCode.AWAIT_IN_WRONG_CONTEXT, node.awaitKeyword);
     }
     return super.visitAwaitExpression(node);
   }
 
   @override
   Object visitBinaryExpression(BinaryExpression node) {
     sc.Token operator = node.operator;
     sc.TokenType type = operator.type;
     if (type == sc.TokenType.AMPERSAND_AMPERSAND ||
         type == sc.TokenType.BAR_BAR) {
       String lexeme = operator.lexeme;
-      _checkForAssignability(
-          node.leftOperand,
-          _boolType,
-          StaticTypeWarningCode.NON_BOOL_OPERAND,
-          [lexeme]);
-      _checkForAssignability(
-          node.rightOperand,
-          _boolType,
-          StaticTypeWarningCode.NON_BOOL_OPERAND,
-          [lexeme]);
+      _checkForAssignability(node.leftOperand, _boolType,
+          StaticTypeWarningCode.NON_BOOL_OPERAND, [lexeme]);
+      _checkForAssignability(node.rightOperand, _boolType,
+          StaticTypeWarningCode.NON_BOOL_OPERAND, [lexeme]);
     } else {
       _checkForArgumentTypeNotAssignableForArgument(node.rightOperand);
     }
     return super.visitBinaryExpression(node);
   }
 
   @override
   Object visitBlockFunctionBody(BlockFunctionBody node) {
     bool wasInAsync = _inAsync;
     bool wasInGenerator = _inGenerator;
@@ skipping 18 matching lines @@
     return null;
   }
 
   @override
   Object visitBreakStatement(BreakStatement node) {
     SimpleIdentifier labelNode = node.label;
     if (labelNode != null) {
       Element labelElement = labelNode.staticElement;
       if (labelElement is LabelElementImpl && labelElement.isOnSwitchMember) {
         _errorReporter.reportErrorForNode(
-            ResolverErrorCode.BREAK_LABEL_ON_SWITCH_MEMBER,
-            labelNode);
+            ResolverErrorCode.BREAK_LABEL_ON_SWITCH_MEMBER, labelNode);
       }
     }
     return null;
   }
 
   @override
   Object visitCatchClause(CatchClause node) {
     bool previousIsInCatchClause = _isInCatchClause;
     try {
       _isInCatchClause = true;
       _checkForTypeAnnotationDeferredClass(node.exceptionType);
       return super.visitCatchClause(node);
     } finally {
       _isInCatchClause = previousIsInCatchClause;
     }
   }
 
   @override
   Object visitClassDeclaration(ClassDeclaration node) {
     ClassElement outerClass = _enclosingClass;
     try {
       _isInNativeClass = node.nativeClause != null;
       _enclosingClass = node.element;
       ExtendsClause extendsClause = node.extendsClause;
       ImplementsClause implementsClause = node.implementsClause;
       WithClause withClause = node.withClause;
       _checkForBuiltInIdentifierAsName(
-          node.name,
-          CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME);
+          node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME);
       _checkForMemberWithClassName();
       _checkForNoDefaultSuperConstructorImplicit(node);
       _checkForConflictingTypeVariableErrorCodes(node);
       // Only do error checks on the clause nodes if there is a non-null clause
       if (implementsClause != null ||
           extendsClause != null ||
           withClause != null) {
         // Only check for all of the inheritance logic around clauses if there
         // isn't an error code such as "Cannot extend double" already on the
         // class.
@@ skipping 29 matching lines @@
    */
   visitClassDeclarationIncrementally(ClassDeclaration node) {
     _isInNativeClass = node.nativeClause != null;
     _enclosingClass = node.element;
     // initialize initialFieldElementsMap
     if (_enclosingClass != null) {
       List<FieldElement> fieldElements = _enclosingClass.fields;
       _initialFieldElementsMap = new HashMap<FieldElement, INIT_STATE>();
       for (FieldElement fieldElement in fieldElements) {
         if (!fieldElement.isSynthetic) {
-          _initialFieldElementsMap[fieldElement] =
-              fieldElement.initializer == null ?
-                  INIT_STATE.NOT_INIT :
-                  INIT_STATE.INIT_IN_DECLARATION;
+          _initialFieldElementsMap[fieldElement] = fieldElement.initializer ==
+              null ? INIT_STATE.NOT_INIT : INIT_STATE.INIT_IN_DECLARATION;
         }
       }
     }
   }
 
   @override
   Object visitClassTypeAlias(ClassTypeAlias node) {
     _checkForBuiltInIdentifierAsName(
-        node.name,
-        CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME);
+        node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME);
     ClassElement outerClassElement = _enclosingClass;
     try {
       _enclosingClass = node.element;
       ImplementsClause implementsClause = node.implementsClause;
       // Only check for all of the inheritance logic around clauses if there
       // isn't an error code such as "Cannot extend double" already on the
       // class.
       if (!_checkForExtendsDisallowedClassInTypeAlias(node) &&
           !_checkForImplementsDisallowedClass(implementsClause) &&
           !_checkForAllMixinErrorCodes(node.withClause)) {
@@ skipping 32 matching lines @@
 
   @override
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     ExecutableElement outerFunction = _enclosingFunction;
     try {
       ConstructorElement constructorElement = node.element;
       _enclosingFunction = constructorElement;
       _isEnclosingConstructorConst = node.constKeyword != null;
       _isInFactory = node.factoryKeyword != null;
       _checkForInvalidModifierOnBody(
-          node.body,
-          CompileTimeErrorCode.INVALID_MODIFIER_ON_CONSTRUCTOR);
+          node.body, CompileTimeErrorCode.INVALID_MODIFIER_ON_CONSTRUCTOR);
       _checkForConstConstructorWithNonFinalField(node, constructorElement);
       _checkForConstConstructorWithNonConstSuper(node);
       _checkForConflictingConstructorNameAndMember(node, constructorElement);
       _checkForAllFinalInitializedErrorCodes(node);
       _checkForRedirectingConstructorErrorCodes(node);
       _checkForMultipleSuperInitializers(node);
       _checkForRecursiveConstructorRedirect(node, constructorElement);
       if (!_checkForRecursiveFactoryRedirect(node, constructorElement)) {
         _checkForAllRedirectConstructorErrorCodes(node);
       }
@@ skipping 23 matching lines @@
   }
 
   @override
   Object visitContinueStatement(ContinueStatement node) {
     SimpleIdentifier labelNode = node.label;
     if (labelNode != null) {
       Element labelElement = labelNode.staticElement;
       if (labelElement is LabelElementImpl &&
           labelElement.isOnSwitchStatement) {
         _errorReporter.reportErrorForNode(
-            ResolverErrorCode.CONTINUE_LABEL_ON_SWITCH,
-            labelNode);
+            ResolverErrorCode.CONTINUE_LABEL_ON_SWITCH, labelNode);
       }
     }
     return null;
   }
 
   @override
   Object visitDefaultFormalParameter(DefaultFormalParameter node) {
     _checkForInvalidAssignment(node.identifier, node.defaultValue);
     _checkForDefaultValueInFunctionTypedParameter(node);
     return super.visitDefaultFormalParameter(node);
@@ skipping 19 matching lines @@
 
   @override
   Object visitExpressionFunctionBody(ExpressionFunctionBody node) {
     bool wasInAsync = _inAsync;
     bool wasInGenerator = _inGenerator;
     try {
       _inAsync = node.isAsynchronous;
       _inGenerator = node.isGenerator;
       FunctionType functionType =
           _enclosingFunction == null ? null : _enclosingFunction.type;
-      DartType expectedReturnType =
-          functionType == null ? DynamicTypeImpl.instance : functionType.returnType;
+      DartType expectedReturnType = functionType == null
+          ? DynamicTypeImpl.instance
+          : functionType.returnType;
       _checkForReturnOfInvalidType(node.expression, expectedReturnType);
       return super.visitExpressionFunctionBody(node);
     } finally {
       _inAsync = wasInAsync;
       _inGenerator = wasInGenerator;
     }
   }
 
   @override
   Object visitFieldDeclaration(FieldDeclaration node) {
     _isInStaticVariableDeclaration = node.isStatic;
     _isInInstanceVariableDeclaration = !_isInStaticVariableDeclaration;
     if (_isInInstanceVariableDeclaration) {
       VariableDeclarationList variables = node.fields;
       if (variables.isConst) {
         _errorReporter.reportErrorForToken(
-            CompileTimeErrorCode.CONST_INSTANCE_FIELD,
-            variables.keyword);
+            CompileTimeErrorCode.CONST_INSTANCE_FIELD, variables.keyword);
       }
     }
     try {
       _checkForAllInvalidOverrideErrorCodesForField(node);
       return super.visitFieldDeclaration(node);
     } finally {
       _isInStaticVariableDeclaration = false;
       _isInInstanceVariableDeclaration = false;
     }
   }
@@ skipping 18 matching lines @@
         methodName = identifier.name;
       }
       _enclosingFunction = node.element;
       TypeName returnType = node.returnType;
       if (node.isSetter || node.isGetter) {
         _checkForMismatchedAccessorTypes(node, methodName);
         if (node.isSetter) {
           FunctionExpression functionExpression = node.functionExpression;
           if (functionExpression != null) {
             _checkForWrongNumberOfParametersForSetter(
-                identifier,
-                functionExpression.parameters);
+                identifier, functionExpression.parameters);
           }
           _checkForNonVoidReturnTypeForSetter(returnType);
         }
       }
       if (node.isSetter) {
-        _checkForInvalidModifierOnBody(
-            node.functionExpression.body,
+        _checkForInvalidModifierOnBody(node.functionExpression.body,
             CompileTimeErrorCode.INVALID_MODIFIER_ON_SETTER);
       }
       _checkForTypeAnnotationDeferredClass(returnType);
       _checkForIllegalReturnType(returnType);
       return super.visitFunctionDeclaration(node);
     } finally {
       _enclosingFunction = outerFunction;
     }
   }
 
@@ skipping 22 matching lines @@
       _errorReporter.reportErrorForNode(
           StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION_EXPRESSION,
           functionExpression);
     }
     return super.visitFunctionExpressionInvocation(node);
   }
 
   @override
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     _checkForBuiltInIdentifierAsName(
-        node.name,
-        CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME);
+        node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME);
     _checkForDefaultValueInFunctionTypeAlias(node);
     _checkForTypeAliasCannotReferenceItself_function(node);
     return super.visitFunctionTypeAlias(node);
   }
 
   @override
   Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     bool old = _isInFunctionTypedFormalParameter;
     _isInFunctionTypedFormalParameter = true;
     try {
@@ skipping 34 matching lines @@
       ConstructorName constructorName = node.constructorName;
       TypeName typeName = constructorName.type;
       DartType type = typeName.type;
       if (type is InterfaceType) {
         InterfaceType interfaceType = type;
         _checkForConstOrNewWithAbstractClass(node, typeName, interfaceType);
         _checkForConstOrNewWithEnum(node, typeName, interfaceType);
         if (_isInConstInstanceCreation) {
           _checkForConstWithNonConst(node);
           _checkForConstWithUndefinedConstructor(
-              node,
-              constructorName,
-              typeName);
+              node, constructorName, typeName);
           _checkForConstWithTypeParameters(typeName);
           _checkForConstDeferredClass(node, constructorName, typeName);
         } else {
           _checkForNewWithUndefinedConstructor(node, constructorName, typeName);
         }
       }
       return super.visitInstanceCreationExpression(node);
     } finally {
       _isInConstInstanceCreation = wasInConstInstanceCreation;
     }
   }
 
   @override
   Object visitIsExpression(IsExpression node) {
     _checkForTypeAnnotationDeferredClass(node.type);
     return super.visitIsExpression(node);
   }
 
   @override
   Object visitListLiteral(ListLiteral node) {
     TypeArgumentList typeArguments = node.typeArguments;
     if (typeArguments != null) {
       if (node.constKeyword != null) {
         NodeList<TypeName> arguments = typeArguments.arguments;
         if (arguments.length != 0) {
-          _checkForInvalidTypeArgumentInConstTypedLiteral(
-              arguments,
+          _checkForInvalidTypeArgumentInConstTypedLiteral(arguments,
               CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_LIST);
         }
       }
       _checkForExpectedOneListTypeArgument(node, typeArguments);
       _checkForListElementTypeNotAssignable(node, typeArguments);
     }
     return super.visitListLiteral(node);
   }
 
   @override
   Object visitMapLiteral(MapLiteral node) {
     TypeArgumentList typeArguments = node.typeArguments;
     if (typeArguments != null) {
       NodeList<TypeName> arguments = typeArguments.arguments;
       if (arguments.length != 0) {
         if (node.constKeyword != null) {
-          _checkForInvalidTypeArgumentInConstTypedLiteral(
-              arguments,
+          _checkForInvalidTypeArgumentInConstTypedLiteral(arguments,
               CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_MAP);
         }
       }
       _checkExpectedTwoMapTypeArguments(typeArguments);
       _checkForMapTypeNotAssignable(node, typeArguments);
     }
     _checkForNonConstMapAsExpressionStatement(node);
     return super.visitMapLiteral(node);
   }
 
@@ skipping 10 matching lines @@
       }
       TypeName returnTypeName = node.returnType;
       if (node.isSetter || node.isGetter) {
         _checkForMismatchedAccessorTypes(node, methodName);
       }
       if (node.isGetter) {
         _checkForVoidReturnType(node);
         _checkForConflictingStaticGetterAndInstanceSetter(node);
       } else if (node.isSetter) {
         _checkForInvalidModifierOnBody(
-            node.body,
-            CompileTimeErrorCode.INVALID_MODIFIER_ON_SETTER);
+            node.body, CompileTimeErrorCode.INVALID_MODIFIER_ON_SETTER);
         _checkForWrongNumberOfParametersForSetter(node.name, node.parameters);
         _checkForNonVoidReturnTypeForSetter(returnTypeName);
         _checkForConflictingStaticSetterAndInstanceMember(node);
       } else if (node.isOperator) {
         _checkForOptionalParameterInOperator(node);
         _checkForWrongNumberOfParametersForOperator(node);
         _checkForNonVoidReturnTypeForOperator(node);
       }
       _checkForConcreteClassWithAbstractMember(node);
       _checkForAllInvalidOverrideErrorCodesForMethod(node);
@@ skipping 19 matching lines @@
     }
     return super.visitMethodInvocation(node);
   }
 
   @override
   Object visitNativeClause(NativeClause node) {
     // TODO(brianwilkerson) Figure out the right rule for when 'native' is
     // allowed.
     if (!_isInSystemLibrary) {
       _errorReporter.reportErrorForNode(
-          ParserErrorCode.NATIVE_CLAUSE_IN_NON_SDK_CODE,
-          node);
+          ParserErrorCode.NATIVE_CLAUSE_IN_NON_SDK_CODE, node);
     }
     return super.visitNativeClause(node);
   }
 
   @override
   Object visitNativeFunctionBody(NativeFunctionBody node) {
     _checkForNativeFunctionBodyInNonSDKCode(node);
     return super.visitNativeFunctionBody(node);
   }
 
@@ skipping 33 matching lines @@
   Object visitPropertyAccess(PropertyAccess node) {
     ClassElement typeReference =
         ElementResolver.getTypeReference(node.realTarget);
     SimpleIdentifier propertyName = node.propertyName;
     _checkForStaticAccessToInstanceMember(typeReference, propertyName);
     _checkForInstanceAccessToStaticMember(typeReference, propertyName);
     return super.visitPropertyAccess(node);
   }
 
   @override
-  Object
-      visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
+  Object visitRedirectingConstructorInvocation(
+      RedirectingConstructorInvocation node) {
     _isInConstructorInitializer = true;
     try {
       return super.visitRedirectingConstructorInvocation(node);
     } finally {
       _isInConstructorInitializer = false;
     }
   }
 
   @override
   Object visitRethrowExpression(RethrowExpression node) {
@@ skipping 76 matching lines @@
 
   @override
   Object visitTypeName(TypeName node) {
     _checkForTypeArgumentNotMatchingBounds(node);
     _checkForTypeParameterReferencedByStatic(node);
     return super.visitTypeName(node);
   }
 
   @override
   Object visitTypeParameter(TypeParameter node) {
-    _checkForBuiltInIdentifierAsName(
-        node.name,
+    _checkForBuiltInIdentifierAsName(node.name,
         CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_PARAMETER_NAME);
     _checkForTypeParameterSupertypeOfItsBound(node);
     _checkForTypeAnnotationDeferredClass(node.bound);
     return super.visitTypeParameter(node);
   }
 
   @override
   Object visitVariableDeclaration(VariableDeclaration node) {
     SimpleIdentifier nameNode = node.name;
     Expression initializerNode = node.initializer;
@@ skipping 60 matching lines @@
    * See [StaticTypeWarningCode.EXPECTED_TWO_MAP_TYPE_ARGUMENTS].
    */
   bool _checkExpectedTwoMapTypeArguments(TypeArgumentList typeArguments) {
     // check number of type arguments
     int num = typeArguments.arguments.length;
     if (num == 2) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(
-        StaticTypeWarningCode.EXPECTED_TWO_MAP_TYPE_ARGUMENTS,
-        typeArguments,
-        [num]);
+        StaticTypeWarningCode.EXPECTED_TWO_MAP_TYPE_ARGUMENTS, typeArguments, [
+      num
+    ]);
     return true;
   }
 
   /**
    * This verifies that the passed constructor declaration does not violate any of the error codes
    * relating to the initialization of fields in the enclosing class.
    *
    * @param node the [ConstructorDeclaration] to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [_initialFieldElementsMap],
@@ skipping 23 matching lines @@
       if (parameter is FieldFormalParameter) {
         FieldElement fieldElement =
             (parameter.element as FieldFormalParameterElementImpl).field;
         INIT_STATE state = fieldElementsMap[fieldElement];
         if (state == INIT_STATE.NOT_INIT) {
           fieldElementsMap[fieldElement] = INIT_STATE.INIT_IN_FIELD_FORMAL;
         } else if (state == INIT_STATE.INIT_IN_DECLARATION) {
           if (fieldElement.isFinal || fieldElement.isConst) {
             _errorReporter.reportErrorForNode(
                 StaticWarningCode.FINAL_INITIALIZED_IN_DECLARATION_AND_CONSTRUCTOR,
-                formalParameter.identifier,
-                [fieldElement.displayName]);
+                formalParameter.identifier, [fieldElement.displayName]);
             foundError = true;
           }
         } else if (state == INIT_STATE.INIT_IN_FIELD_FORMAL) {
           if (fieldElement.isFinal || fieldElement.isConst) {
             _errorReporter.reportErrorForNode(
                 CompileTimeErrorCode.FINAL_INITIALIZED_MULTIPLE_TIMES,
-                formalParameter.identifier,
-                [fieldElement.displayName]);
+                formalParameter.identifier, [fieldElement.displayName]);
             foundError = true;
           }
         }
       }
     }
     // Visit all of the initializers
     NodeList<ConstructorInitializer> initializers = node.initializers;
     for (ConstructorInitializer constructorInitializer in initializers) {
       if (constructorInitializer is RedirectingConstructorInvocation) {
         return false;
@@ skipping 16 matching lines @@
               foundError = true;
             }
           } else if (state == INIT_STATE.INIT_IN_FIELD_FORMAL) {
             _errorReporter.reportErrorForNode(
                 CompileTimeErrorCode.FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZER,
                 fieldName);
             foundError = true;
           } else if (state == INIT_STATE.INIT_IN_INITIALIZERS) {
             _errorReporter.reportErrorForNode(
                 CompileTimeErrorCode.FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS,
-                fieldName,
-                [fieldElement.displayName]);
+                fieldName, [fieldElement.displayName]);
             foundError = true;
           }
         }
       }
     }
     // Visit all of the states in the map to ensure that none were never
     // initialized.
     fieldElementsMap.forEach((FieldElement fieldElement, INIT_STATE state) {
       if (state == INIT_STATE.NOT_INIT) {
         if (fieldElement.isConst) {
           _errorReporter.reportErrorForNode(
-              CompileTimeErrorCode.CONST_NOT_INITIALIZED,
-              node.returnType,
-              [fieldElement.name]);
+              CompileTimeErrorCode.CONST_NOT_INITIALIZED, node.returnType, [
+            fieldElement.name
+          ]);
           foundError = true;
         } else if (fieldElement.isFinal) {
           _errorReporter.reportErrorForNode(
-              StaticWarningCode.FINAL_NOT_INITIALIZED,
-              node.returnType,
-              [fieldElement.name]);
+              StaticWarningCode.FINAL_NOT_INITIALIZED, node.returnType, [
+            fieldElement.name
+          ]);
           foundError = true;
         }
       }
     });
     return foundError;
   }
 
   /**
    * This checks the passed executable element against override-error codes.
    *
    * @param executableElement a non-null [ExecutableElement] to evaluate
    * @param overriddenExecutable the element that the executableElement is overriding
    * @param parameters the parameters of the executable element
    * @param errorNameTarget the node to report problems on
    * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC],
    * [CompileTimeErrorCode.INVALID_OVERRIDE_REQUIRED],
    * [CompileTimeErrorCode.INVALID_OVERRIDE_POSITIONAL],
    * [CompileTimeErrorCode.INVALID_OVERRIDE_NAMED],
    * [StaticWarningCode.INVALID_GETTER_OVERRIDE_RETURN_TYPE],
    * [StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE],
    * [StaticWarningCode.INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE],
    * [StaticWarningCode.INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE],
    * [StaticWarningCode.INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE],
    * [StaticWarningCode.INVALID_METHOD_OVERRIDE_NAMED_PARAM_TYPE], and
    * [StaticWarningCode.INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES].
    */
-  bool
-      _checkForAllInvalidOverrideErrorCodes(ExecutableElement executableElement,
+  bool _checkForAllInvalidOverrideErrorCodes(
+      ExecutableElement executableElement,
       ExecutableElement overriddenExecutable, List<ParameterElement> parameters,
       List<AstNode> parameterLocations, SimpleIdentifier errorNameTarget) {
     bool isGetter = false;
     bool isSetter = false;
     if (executableElement is PropertyAccessorElement) {
       PropertyAccessorElement accessorElement = executableElement;
       isGetter = accessorElement.isGetter;
       isSetter = accessorElement.isSetter;
     }
     String executableElementName = executableElement.name;
     FunctionType overridingFT = executableElement.type;
     FunctionType overriddenFT = overriddenExecutable.type;
     InterfaceType enclosingType = _enclosingClass.type;
-    overriddenFT =
-        _inheritanceManager.substituteTypeArgumentsInMemberFromInheritance(
-            overriddenFT,
-            executableElementName,
-            enclosingType);
+    overriddenFT = _inheritanceManager
+        .substituteTypeArgumentsInMemberFromInheritance(
+            overriddenFT, executableElementName, enclosingType);
     if (overridingFT == null || overriddenFT == null) {
       return false;
     }
     DartType overridingFTReturnType = overridingFT.returnType;
     DartType overriddenFTReturnType = overriddenFT.returnType;
     List<DartType> overridingNormalPT = overridingFT.normalParameterTypes;
     List<DartType> overriddenNormalPT = overriddenFT.normalParameterTypes;
     List<DartType> overridingPositionalPT = overridingFT.optionalParameterTypes;
     List<DartType> overriddenPositionalPT = overriddenFT.optionalParameterTypes;
     Map<String, DartType> overridingNamedPT = overridingFT.namedParameterTypes;
     Map<String, DartType> overriddenNamedPT = overriddenFT.namedParameterTypes;
     // CTEC.INVALID_OVERRIDE_REQUIRED, CTEC.INVALID_OVERRIDE_POSITIONAL and
     // CTEC.INVALID_OVERRIDE_NAMED
     if (overridingNormalPT.length > overriddenNormalPT.length) {
       _errorReporter.reportErrorForNode(
-          StaticWarningCode.INVALID_OVERRIDE_REQUIRED,
-          errorNameTarget,
-          [overriddenNormalPT.length, overriddenExecutable.enclosingElement.displayName]);
+          StaticWarningCode.INVALID_OVERRIDE_REQUIRED, errorNameTarget, [
+        overriddenNormalPT.length,
+        overriddenExecutable.enclosingElement.displayName
+      ]);
       return true;
     }
     if (overridingNormalPT.length + overridingPositionalPT.length <
         overriddenPositionalPT.length + overriddenNormalPT.length) {
       _errorReporter.reportErrorForNode(
-          StaticWarningCode.INVALID_OVERRIDE_POSITIONAL,
-          errorNameTarget,
-          [
-              overriddenPositionalPT.length + overriddenNormalPT.length,
-              overriddenExecutable.enclosingElement.displayName]);
+          StaticWarningCode.INVALID_OVERRIDE_POSITIONAL, errorNameTarget, [
+        overriddenPositionalPT.length + overriddenNormalPT.length,
+        overriddenExecutable.enclosingElement.displayName
+      ]);
       return true;
     }
     // For each named parameter in the overridden method, verify that there is
     // the same name in the overriding method.
     for (String overriddenParamName in overriddenNamedPT.keys) {
       if (!overridingNamedPT.containsKey(overriddenParamName)) {
         // The overridden method expected the overriding method to have
         // overridingParamName, but it does not.
         _errorReporter.reportErrorForNode(
-            StaticWarningCode.INVALID_OVERRIDE_NAMED,
-            errorNameTarget,
-            [overriddenParamName, overriddenExecutable.enclosingElement.displayName]);
+            StaticWarningCode.INVALID_OVERRIDE_NAMED, errorNameTarget, [
+          overriddenParamName,
+          overriddenExecutable.enclosingElement.displayName
+        ]);
         return true;
       }
     }
     // SWC.INVALID_METHOD_OVERRIDE_RETURN_TYPE
     if (overriddenFTReturnType != VoidTypeImpl.instance &&
         !overridingFTReturnType.isAssignableTo(overriddenFTReturnType)) {
-      _errorReporter.reportTypeErrorForNode(
-          !isGetter ?
-              StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE :
-              StaticWarningCode.INVALID_GETTER_OVERRIDE_RETURN_TYPE,
-          errorNameTarget,
-          [
-              overridingFTReturnType,
-              overriddenFTReturnType,
-              overriddenExecutable.enclosingElement.displayName]);
+      _errorReporter.reportTypeErrorForNode(!isGetter
+              ? StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE
+              : StaticWarningCode.INVALID_GETTER_OVERRIDE_RETURN_TYPE,
+          errorNameTarget, [
+        overridingFTReturnType,
+        overriddenFTReturnType,
+        overriddenExecutable.enclosingElement.displayName
+      ]);
       return true;
     }
     // SWC.INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE
     if (parameterLocations == null) {
       return false;
     }
     int parameterIndex = 0;
     for (int i = 0; i < overridingNormalPT.length; i++) {
       if (!overridingNormalPT[i].isAssignableTo(overriddenNormalPT[i])) {
-        _errorReporter.reportTypeErrorForNode(
-            !isSetter ?
-                StaticWarningCode.INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE :
-                StaticWarningCode.INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE,
-            parameterLocations[parameterIndex],
-            [
-                overridingNormalPT[i],
-                overriddenNormalPT[i],
-                overriddenExecutable.enclosingElement.displayName]);
+        _errorReporter.reportTypeErrorForNode(!isSetter
+                ? StaticWarningCode.INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE
+                : StaticWarningCode.INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE,
+            parameterLocations[parameterIndex], [
+          overridingNormalPT[i],
+          overriddenNormalPT[i],
+          overriddenExecutable.enclosingElement.displayName
+        ]);
         return true;
       }
       parameterIndex++;
     }
     // SWC.INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE
     for (int i = 0; i < overriddenPositionalPT.length; i++) {
-      if (!overridingPositionalPT[i].isAssignableTo(
-          overriddenPositionalPT[i])) {
+      if (!overridingPositionalPT[i]
+          .isAssignableTo(overriddenPositionalPT[i])) {
         _errorReporter.reportTypeErrorForNode(
             StaticWarningCode.INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE,
-            parameterLocations[parameterIndex],
-            [
-                overridingPositionalPT[i],
-                overriddenPositionalPT[i],
-                overriddenExecutable.enclosingElement.displayName]);
+            parameterLocations[parameterIndex], [
+          overridingPositionalPT[i],
+          overriddenPositionalPT[i],
+          overriddenExecutable.enclosingElement.displayName
+        ]);
         return true;
       }
       parameterIndex++;
     }
     // SWC.INVALID_METHOD_OVERRIDE_NAMED_PARAM_TYPE &
     // SWC.INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES
     for (String overriddenName in overriddenNamedPT.keys) {
       DartType overridingType = overridingNamedPT[overriddenName];
       if (overridingType == null) {
         // Error, this is never reached- INVALID_OVERRIDE_NAMED would have been
@@ skipping 10 matching lines @@
           if (parameter.parameterKind == ParameterKind.NAMED &&
               overriddenName == parameter.name) {
             parameterToSelect = parameter;
             parameterLocationToSelect = parameterLocations[i];
             break;
           }
         }
         if (parameterToSelect != null) {
           _errorReporter.reportTypeErrorForNode(
               StaticWarningCode.INVALID_METHOD_OVERRIDE_NAMED_PARAM_TYPE,
-              parameterLocationToSelect,
-              [
-                  overridingType,
-                  overriddenType,
-                  overriddenExecutable.enclosingElement.displayName]);
+              parameterLocationToSelect, [
+            overridingType,
+            overriddenType,
+            overriddenExecutable.enclosingElement.displayName
+          ]);
           return true;
         }
       }
     }
     // SWC.INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES
     //
     // Create three arrays: an array of the optional parameter ASTs
     // (FormalParameters), an array of the optional parameters elements from our
     // method, and finally an array of the optional parameter elements from the
     // method we are overriding.
@@ skipping 46 matching lines @@
             if (parameterName != null &&
                 parameterName == overriddenParameterName) {
               EvaluationResultImpl overriddenResult =
                   overriddenParameterElt.evaluationResult;
               if (_isUserDefinedObject(overriddenResult)) {
                 break;
               }
               if (!result.equalValues(_typeProvider, overriddenResult)) {
                 _errorReporter.reportErrorForNode(
                     StaticWarningCode.INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES_NAMED,
-                    formalParameters[i],
-                    [
-                        overriddenExecutable.enclosingElement.displayName,
-                        overriddenExecutable.displayName,
-                        parameterName]);
+                    formalParameters[i], [
+                  overriddenExecutable.enclosingElement.displayName,
+                  overriddenExecutable.displayName,
+                  parameterName
+                ]);
                 foundError = true;
               }
             }
           }
         }
       } else {
         // Positional parameters, consider the positions when matching the
         // parameterElts to the overriddenParameterElts
-        for (int i =
-            0; i < parameterElts.length && i < overriddenParameterElts.length; i++) {
+        for (int i = 0;
+            i < parameterElts.length && i < overriddenParameterElts.length;
+            i++) {
           ParameterElementImpl parameterElt = parameterElts[i];
           EvaluationResultImpl result = parameterElt.evaluationResult;
           // TODO (jwren) Ignore Object types, see Dart bug 11287
           if (_isUserDefinedObject(result)) {
             continue;
           }
           ParameterElementImpl overriddenParameterElt =
               overriddenParameterElts[i];
           if (overriddenParameterElt.initializer == null) {
             // There is no warning if the overridden parameter has an implicit
             // default.
             continue;
           }
           EvaluationResultImpl overriddenResult =
               overriddenParameterElt.evaluationResult;
           if (_isUserDefinedObject(overriddenResult)) {
             continue;
           }
           if (!result.equalValues(_typeProvider, overriddenResult)) {
             _errorReporter.reportErrorForNode(
                 StaticWarningCode.INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES_POSITIONAL,
-                formalParameters[i],
-                [
-                    overriddenExecutable.enclosingElement.displayName,
-                    overriddenExecutable.displayName]);
+                formalParameters[i], [
+              overriddenExecutable.enclosingElement.displayName,
+              overriddenExecutable.displayName
+            ]);
             foundError = true;
           }
         }
       }
     }
     return foundError;
   }
 
   /**
    * This checks the passed executable element against override-error codes. This method computes
    * the passed executableElement is overriding and calls
    * [checkForAllInvalidOverrideErrorCodes]
    * when the [InheritanceManager] returns a [MultiplyInheritedExecutableElement], this
    * method loops through the array in the [MultiplyInheritedExecutableElement].
    *
    * @param executableElement a non-null [ExecutableElement] to evaluate
    * @param parameters the parameters of the executable element
    * @param errorNameTarget the node to report problems on
    * @return `true` if and only if an error code is generated on the passed node
    */
-  bool
-      _checkForAllInvalidOverrideErrorCodesForExecutable(ExecutableElement executableElement,
-      List<ParameterElement> parameters, List<AstNode> parameterLocations,
-      SimpleIdentifier errorNameTarget) {
+  bool _checkForAllInvalidOverrideErrorCodesForExecutable(
+      ExecutableElement executableElement, List<ParameterElement> parameters,
+      List<AstNode> parameterLocations, SimpleIdentifier errorNameTarget) {
     //
     // Compute the overridden executable from the InheritanceManager
     //
-    List<ExecutableElement> overriddenExecutables =
-        _inheritanceManager.lookupOverrides(_enclosingClass, executableElement.name);
+    List<ExecutableElement> overriddenExecutables = _inheritanceManager
+        .lookupOverrides(_enclosingClass, executableElement.name);
     if (_checkForInstanceMethodNameCollidesWithSuperclassStatic(
-        executableElement,
-        errorNameTarget)) {
+        executableElement, errorNameTarget)) {
       return true;
     }
     for (ExecutableElement overriddenElement in overriddenExecutables) {
-      if (_checkForAllInvalidOverrideErrorCodes(
-          executableElement,
-          overriddenElement,
-          parameters,
-          parameterLocations,
-          errorNameTarget)) {
+      if (_checkForAllInvalidOverrideErrorCodes(executableElement,
+          overriddenElement, parameters, parameterLocations, errorNameTarget)) {
         return true;
       }
     }
     return false;
   }
 
   /**
    * This checks the passed field declaration against override-error codes.
    *
    * @param node the [MethodDeclaration] to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [_checkForAllInvalidOverrideErrorCodes].
    */
   bool _checkForAllInvalidOverrideErrorCodesForField(FieldDeclaration node) {
     if (_enclosingClass == null || node.isStatic) {
       return false;
     }
     bool hasProblems = false;
     VariableDeclarationList fields = node.fields;
     for (VariableDeclaration field in fields.variables) {
       FieldElement element = field.element as FieldElement;
       if (element == null) {
         continue;
       }
       PropertyAccessorElement getter = element.getter;
       PropertyAccessorElement setter = element.setter;
       SimpleIdentifier fieldName = field.name;
       if (getter != null) {
-        if (_checkForAllInvalidOverrideErrorCodesForExecutable(
-            getter,
-            ParameterElementImpl.EMPTY_ARRAY,
-            AstNode.EMPTY_LIST,
-            fieldName)) {
+        if (_checkForAllInvalidOverrideErrorCodesForExecutable(getter,
+            ParameterElementImpl.EMPTY_ARRAY, AstNode.EMPTY_LIST, fieldName)) {
           hasProblems = true;
         }
       }
       if (setter != null) {
         if (_checkForAllInvalidOverrideErrorCodesForExecutable(
-            setter,
-            setter.parameters,
-            <AstNode>[fieldName],
-            fieldName)) {
+            setter, setter.parameters, <AstNode>[fieldName], fieldName)) {
           hasProblems = true;
         }
       }
     }
     return hasProblems;
   }
 
   /**
    * This checks the passed method declaration against override-error codes.
    *
@@ skipping 13 matching lines @@
     }
     SimpleIdentifier methodName = node.name;
     if (methodName.isSynthetic) {
       return false;
     }
     FormalParameterList formalParameterList = node.parameters;
     NodeList<FormalParameter> parameterList =
         formalParameterList != null ? formalParameterList.parameters : null;
     List<AstNode> parameters =
         parameterList != null ? new List.from(parameterList) : null;
-    return _checkForAllInvalidOverrideErrorCodesForExecutable(
-        executableElement,
-        executableElement.parameters,
-        parameters,
-        methodName);
+    return _checkForAllInvalidOverrideErrorCodesForExecutable(executableElement,
+        executableElement.parameters, parameters, methodName);
   }
 
   /**
    * This verifies that all classes of the passed 'with' clause are valid.
    *
    * @param node the 'with' clause to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR],
    * [CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT], and
    * [CompileTimeErrorCode.MIXIN_REFERENCES_SUPER].
    */
   bool _checkForAllMixinErrorCodes(WithClause withClause) {
     if (withClause == null) {
       return false;
     }
     bool problemReported = false;
     for (TypeName mixinName in withClause.mixinTypes) {
       DartType mixinType = mixinName.type;
       if (mixinType is! InterfaceType) {
         continue;
       }
       if (_checkForExtendsOrImplementsDisallowedClass(
-          mixinName,
-          CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS)) {
+          mixinName, CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS)) {
         problemReported = true;
       } else {
         ClassElement mixinElement = (mixinType as InterfaceType).element;
         if (_checkForExtendsOrImplementsDeferredClass(
-            mixinName,
-            CompileTimeErrorCode.MIXIN_DEFERRED_CLASS)) {
+            mixinName, CompileTimeErrorCode.MIXIN_DEFERRED_CLASS)) {
           problemReported = true;
         }
         if (_checkForMixinDeclaresConstructor(mixinName, mixinElement)) {
           problemReported = true;
         }
         if (_checkForMixinInheritsNotFromObject(mixinName, mixinElement)) {
           problemReported = true;
         }
         if (_checkForMixinReferencesSuper(mixinName, mixinElement)) {
           problemReported = true;
@@ skipping 34 matching lines @@
       if (redirectedType != null &&
           redirectedType.element != null &&
           !redirectedType.isDynamic) {
         //
         // Prepare the constructor name
         //
         String constructorStrName = constructorTypeName.name.name;
         if (redirectedConstructor.name != null) {
           constructorStrName += ".${redirectedConstructor.name.name}";
         }
-        ErrorCode errorCode = (node.constKeyword != null ?
-            CompileTimeErrorCode.REDIRECT_TO_MISSING_CONSTRUCTOR :
-            StaticWarningCode.REDIRECT_TO_MISSING_CONSTRUCTOR);
-        _errorReporter.reportErrorForNode(
-            errorCode,
-            redirectedConstructor,
+        ErrorCode errorCode = (node.constKeyword != null
+            ? CompileTimeErrorCode.REDIRECT_TO_MISSING_CONSTRUCTOR
+            : StaticWarningCode.REDIRECT_TO_MISSING_CONSTRUCTOR);
+        _errorReporter.reportErrorForNode(errorCode, redirectedConstructor,
             [constructorStrName, redirectedType.displayName]);
         return true;
       }
       return false;
     }
     FunctionType redirectedType = redirectedElement.type;
     DartType redirectedReturnType = redirectedType.returnType;
     //
     // Report specific problem when return type is incompatible
     //
     FunctionType constructorType = node.element.type;
     DartType constructorReturnType = constructorType.returnType;
     if (!redirectedReturnType.isAssignableTo(constructorReturnType)) {
       _errorReporter.reportErrorForNode(
           StaticWarningCode.REDIRECT_TO_INVALID_RETURN_TYPE,
-          redirectedConstructor,
-          [redirectedReturnType, constructorReturnType]);
+          redirectedConstructor, [redirectedReturnType, constructorReturnType]);
       return true;
     }
     //
     // Check parameters
     //
     if (!redirectedType.isSubtypeOf(constructorType)) {
       _errorReporter.reportErrorForNode(
           StaticWarningCode.REDIRECT_TO_INVALID_FUNCTION_TYPE,
-          redirectedConstructor,
-          [redirectedType, constructorType]);
+          redirectedConstructor, [redirectedType, constructorType]);
       return true;
     }
     return false;
   }
 
   /**
    * This checks that the return statement of the form <i>return e;</i> is not in a generative
    * constructor.
    *
    * This checks that return statements without expressions are not in a generative constructor and
    * the return type is not assignable to `null`; that is, we don't have `return;` if
    * the enclosing method has a return type.
    *
    * This checks that the return type matches the type of the declared return type in the enclosing
    * method or function.
    *
    * @param node the return statement to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.RETURN_IN_GENERATIVE_CONSTRUCTOR],
    * [StaticWarningCode.RETURN_WITHOUT_VALUE], and
    * [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE].
    */
   bool _checkForAllReturnStatementErrorCodes(ReturnStatement node) {
     FunctionType functionType =
         _enclosingFunction == null ? null : _enclosingFunction.type;
-    DartType expectedReturnType =
-        functionType == null ? DynamicTypeImpl.instance : functionType.returnType;
+    DartType expectedReturnType = functionType == null
+        ? DynamicTypeImpl.instance
+        : functionType.returnType;
     Expression returnExpression = node.expression;
     // RETURN_IN_GENERATIVE_CONSTRUCTOR
-    bool isGenerativeConstructor =
-        _enclosingFunction is ConstructorElement &&
+    bool isGenerativeConstructor = _enclosingFunction is ConstructorElement &&
         !(_enclosingFunction as ConstructorElement).isFactory;
     if (isGenerativeConstructor) {
       if (returnExpression == null) {
         return false;
       }
       _errorReporter.reportErrorForNode(
           CompileTimeErrorCode.RETURN_IN_GENERATIVE_CONSTRUCTOR,
           returnExpression);
       return true;
     }
     // RETURN_WITHOUT_VALUE
     if (returnExpression == null) {
       if (_inGenerator ||
-          _computeReturnTypeForMethod(null).isAssignableTo(expectedReturnType)) {
+          _computeReturnTypeForMethod(null)
+              .isAssignableTo(expectedReturnType)) {
         return false;
       }
       _hasReturnWithoutValue = true;
-      _errorReporter.reportErrorForNode(
-          StaticWarningCode.RETURN_WITHOUT_VALUE,
-          node);
+      _errorReporter
+          .reportErrorForNode(StaticWarningCode.RETURN_WITHOUT_VALUE, node);
       return true;
     } else if (_inGenerator) {
       // RETURN_IN_GENERATOR
-      _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.RETURN_IN_GENERATOR,
-          node);
+      _errorReporter
+          .reportErrorForNode(CompileTimeErrorCode.RETURN_IN_GENERATOR, node);
     }
     // RETURN_OF_INVALID_TYPE
     return _checkForReturnOfInvalidType(returnExpression, expectedReturnType);
   }
 
   /**
    * This verifies that the export namespace of the passed export directive does not export any name
    * already exported by other export directive.
    *
    * @param node the export directive node to report problem on
    * @param exportElement the [ExportElement] retrieved from the node, if the element in the
    *          node was `null`, then this method is not called
    * @param exportedLibrary the library element containing the exported element
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.AMBIGUOUS_EXPORT].
    */
   bool _checkForAmbiguousExport(ExportDirective node,
       ExportElement exportElement, LibraryElement exportedLibrary) {
     if (exportedLibrary == null) {
       return false;
     }
     // check exported names
     Namespace namespace =
         new NamespaceBuilder().createExportNamespaceForDirective(exportElement);
     Map<String, Element> definedNames = namespace.definedNames;
     for (String name in definedNames.keys) {
       Element element = definedNames[name];
       Element prevElement = _exportedElements[name];
       if (element != null && prevElement != null && prevElement != element) {
-        _errorReporter.reportErrorForNode(
-            CompileTimeErrorCode.AMBIGUOUS_EXPORT,
-            node,
-            [
-                name,
-                prevElement.library.definingCompilationUnit.displayName,
-                element.library.definingCompilationUnit.displayName]);
+        _errorReporter.reportErrorForNode(CompileTimeErrorCode.AMBIGUOUS_EXPORT,
+            node, [
+          name,
+          prevElement.library.definingCompilationUnit.displayName,
+          element.library.definingCompilationUnit.displayName
+        ]);
         return true;
       } else {
         _exportedElements[name] = element;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed expression can be assigned to its corresponding parameters.
    *
    * This method corresponds to BestPracticesVerifier.checkForArgumentTypeNotAssignable.
    *
    * @param expression the expression to evaluate
    * @param expectedStaticType the expected static type of the parameter
    * @param actualStaticType the actual static type of the argument
    * @param expectedPropagatedType the expected propagated type of the parameter, may be
    *          `null`
    * @param actualPropagatedType the expected propagated type of the parameter, may be `null`
    * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE],
    * [CompileTimeErrorCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE],
    * [StaticWarningCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE],
    * [CompileTimeErrorCode.MAP_KEY_TYPE_NOT_ASSIGNABLE],
    * [CompileTimeErrorCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE],
    * [StaticWarningCode.MAP_KEY_TYPE_NOT_ASSIGNABLE], and
    * [StaticWarningCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE].
    */
   bool _checkForArgumentTypeNotAssignable(Expression expression,
-      DartType expectedStaticType, DartType actualStaticType, ErrorCode errorCode) {
+      DartType expectedStaticType, DartType actualStaticType,
+      ErrorCode errorCode) {
     //
     // Warning case: test static type information
     //
     if (actualStaticType != null && expectedStaticType != null) {
       if (!actualStaticType.isAssignableTo(expectedStaticType)) {
         _errorReporter.reportTypeErrorForNode(
-            errorCode,
-            expression,
-            [actualStaticType, expectedStaticType]);
+            errorCode, expression, [actualStaticType, expectedStaticType]);
         return true;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed argument can be assigned to its corresponding parameter.
    *
    * This method corresponds to BestPracticesVerifier.checkForArgumentTypeNotAssignableForArgument.
    *
    * @param argument the argument to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE].
    */
   bool _checkForArgumentTypeNotAssignableForArgument(Expression argument) {
     if (argument == null) {
       return false;
     }
     ParameterElement staticParameterElement = argument.staticParameterElement;
     DartType staticParameterType =
         staticParameterElement == null ? null : staticParameterElement.type;
-    return _checkForArgumentTypeNotAssignableWithExpectedTypes(
-        argument,
-        staticParameterType,
-        StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
+    return _checkForArgumentTypeNotAssignableWithExpectedTypes(argument,
+        staticParameterType, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
   }
 
   /**
    * This verifies that the passed expression can be assigned to its corresponding parameters.
    *
    * This method corresponds to
    * BestPracticesVerifier.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 error code is generated on the passed node
    * See [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE],
    * [CompileTimeErrorCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE],
    * [StaticWarningCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE],
    * [CompileTimeErrorCode.MAP_KEY_TYPE_NOT_ASSIGNABLE],
    * [CompileTimeErrorCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE],
    * [StaticWarningCode.MAP_KEY_TYPE_NOT_ASSIGNABLE], and
    * [StaticWarningCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE].
    */
-  bool
-      _checkForArgumentTypeNotAssignableWithExpectedTypes(Expression expression,
-      DartType expectedStaticType, ErrorCode errorCode) =>
-      _checkForArgumentTypeNotAssignable(
-          expression,
-          expectedStaticType,
-          getStaticType(expression),
-          errorCode);
+  bool _checkForArgumentTypeNotAssignableWithExpectedTypes(
+      Expression expression, DartType expectedStaticType,
+      ErrorCode errorCode) => _checkForArgumentTypeNotAssignable(
+          expression, expectedStaticType, getStaticType(expression), errorCode);
 
   /**
    * This verifies that the passed arguments can be assigned to their corresponding parameters.
    *
    * This method corresponds to BestPracticesVerifier.checkForArgumentTypesNotAssignableInList.
    *
    * @param node the arguments to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE].
    */
@@ skipping 61 matching lines @@
     }
     // check if element is assignable
     if (element is PropertyAccessorElement) {
       PropertyAccessorElement accessor = element as PropertyAccessorElement;
       element = accessor.variable;
     }
     if (element is VariableElement) {
       VariableElement variable = element as VariableElement;
       if (variable.isConst) {
         _errorReporter.reportErrorForNode(
-            StaticWarningCode.ASSIGNMENT_TO_CONST,
-            expression);
+            StaticWarningCode.ASSIGNMENT_TO_CONST, expression);
         return true;
       }
       if (variable.isFinal) {
         if (variable is FieldElementImpl &&
             variable.setter == null &&
             variable.isSynthetic) {
           _errorReporter.reportErrorForNode(
-              StaticWarningCode.ASSIGNMENT_TO_FINAL_NO_SETTER,
-              highlightedNode,
+              StaticWarningCode.ASSIGNMENT_TO_FINAL_NO_SETTER, highlightedNode,
               [variable.name, variable.enclosingElement.displayName]);
           return true;
         }
-        _errorReporter.reportErrorForNode(
-            StaticWarningCode.ASSIGNMENT_TO_FINAL,
-            highlightedNode,
-            [variable.name]);
+        _errorReporter.reportErrorForNode(StaticWarningCode.ASSIGNMENT_TO_FINAL,
+            highlightedNode, [variable.name]);
         return true;
       }
       return false;
     }
     if (element is FunctionElement) {
       _errorReporter.reportErrorForNode(
-          StaticWarningCode.ASSIGNMENT_TO_FUNCTION,
-          expression);
+          StaticWarningCode.ASSIGNMENT_TO_FUNCTION, expression);
       return true;
     }
     if (element is MethodElement) {
       _errorReporter.reportErrorForNode(
-          StaticWarningCode.ASSIGNMENT_TO_METHOD,
-          expression);
+          StaticWarningCode.ASSIGNMENT_TO_METHOD, expression);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the passed identifier is not a keyword, and generates the passed error code
    * on the identifier if it is a keyword.
    *
    * @param identifier the identifier to check to ensure that it is not a keyword
    * @param errorCode if the passed identifier is a keyword then this error code is created on the
    *          identifier, the error code will be one of
    *          [CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME],
    *          [CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_PARAMETER_NAME] or
    *          [CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME]
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME],
    * [CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_PARAMETER_NAME], and
    * [CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME].
    */
-  bool _checkForBuiltInIdentifierAsName(SimpleIdentifier identifier,
-      ErrorCode errorCode) {
+  bool _checkForBuiltInIdentifierAsName(
+      SimpleIdentifier identifier, ErrorCode errorCode) {
     sc.Token token = identifier.token;
     if (token.type == sc.TokenType.KEYWORD) {
       _errorReporter.reportErrorForNode(
-          errorCode,
-          identifier,
-          [identifier.name]);
+          errorCode, identifier, [identifier.name]);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the given switch case is terminated with 'break', 'continue', 'return' or
    * 'throw'.
    *
    * @param node the switch case to evaluate
@@ skipping 25 matching lines @@
       // terminated with 'throw' expression
       if (statement is ExpressionStatement) {
         Expression expression = statement.expression;
         if (expression is ThrowExpression) {
           return false;
         }
       }
     }
     // report error
     _errorReporter.reportErrorForToken(
-        StaticWarningCode.CASE_BLOCK_NOT_TERMINATED,
-        node.keyword);
+        StaticWarningCode.CASE_BLOCK_NOT_TERMINATED, node.keyword);
     return true;
   }
 
   /**
    * This verifies that the switch cases in the given switch statement is terminated with 'break',
    * 'continue', 'return' or 'throw'.
    *
    * @param node the switch statement containing the cases to be checked
    * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.CASE_BLOCK_NOT_TERMINATED].
@@ skipping 20 matching lines @@
    * See [StaticWarningCode.CONCRETE_CLASS_WITH_ABSTRACT_MEMBER].
    */
   bool _checkForConcreteClassWithAbstractMember(MethodDeclaration node) {
     if (node.isAbstract &&
         _enclosingClass != null &&
         !_enclosingClass.isAbstract) {
       SimpleIdentifier nameNode = node.name;
       String memberName = nameNode.name;
       ExecutableElement overriddenMember;
       if (node.isGetter) {
-        overriddenMember =
-            _enclosingClass.lookUpInheritedConcreteGetter(memberName, _currentLibrary);
+        overriddenMember = _enclosingClass.lookUpInheritedConcreteGetter(
+            memberName, _currentLibrary);
       } else if (node.isSetter) {
-        overriddenMember =
-            _enclosingClass.lookUpInheritedConcreteSetter(memberName, _currentLibrary);
+        overriddenMember = _enclosingClass.lookUpInheritedConcreteSetter(
+            memberName, _currentLibrary);
       } else {
-        overriddenMember =
-            _enclosingClass.lookUpInheritedConcreteMethod(memberName, _currentLibrary);
+        overriddenMember = _enclosingClass.lookUpInheritedConcreteMethod(
+            memberName, _currentLibrary);
       }
       if (overriddenMember == null) {
         _errorReporter.reportErrorForNode(
-            StaticWarningCode.CONCRETE_CLASS_WITH_ABSTRACT_MEMBER,
-            nameNode,
-            [memberName, _enclosingClass.displayName]);
+            StaticWarningCode.CONCRETE_CLASS_WITH_ABSTRACT_MEMBER, nameNode, [
+          memberName,
+          _enclosingClass.displayName
+        ]);
         return true;
       }
     }
     return false;
   }
 
   /**
    * This verifies all possible conflicts of the constructor name with other constructors and
    * members of the same class.
    *
    * @param node the constructor declaration to evaluate
    * @param constructorElement the constructor element
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_DEFAULT],
    * [CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_NAME],
    * [CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_FIELD], and
    * [CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_METHOD].
    */
-  bool _checkForConflictingConstructorNameAndMember(ConstructorDeclaration node,
-      ConstructorElement constructorElement) {
+  bool _checkForConflictingConstructorNameAndMember(
+      ConstructorDeclaration node, ConstructorElement constructorElement) {
     SimpleIdentifier constructorName = node.name;
     String name = constructorElement.name;
     ClassElement classElement = constructorElement.enclosingElement;
     // constructors
     List<ConstructorElement> constructors = classElement.constructors;
     for (ConstructorElement otherConstructor in constructors) {
       if (identical(otherConstructor, constructorElement)) {
         continue;
       }
       if (name == otherConstructor.name) {
         if (name == null || name.length == 0) {
           _errorReporter.reportErrorForNode(
-              CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_DEFAULT,
-              node);
+              CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_DEFAULT, node);
         } else {
           _errorReporter.reportErrorForNode(
-              CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_NAME,
-              node,
-              [name]);
+              CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_NAME, node, [name]);
         }
         return true;
       }
     }
     // conflict with class member
     if (constructorName != null &&
         constructorElement != null &&
         !constructorName.isSynthetic) {
       // fields
       FieldElement field = classElement.getField(name);
       if (field != null) {
         _errorReporter.reportErrorForNode(
-            CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_FIELD,
-            node,
-            [name]);
+            CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_FIELD, node, [
+          name
+        ]);
         return true;
       }
       // methods
       MethodElement method = classElement.getMethod(name);
       if (method != null) {
         _errorReporter.reportErrorForNode(
-            CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_METHOD,
-            node,
+            CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_METHOD, node,
             [name]);
         return true;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the [enclosingClass] does not have a method and getter pair with the
    * same name on, via inheritance.
@@ skipping 12 matching lines @@
       String name = method.name;
       // find inherited property accessor (and can be only getter)
       ExecutableElement inherited =
           _inheritanceManager.lookupInheritance(_enclosingClass, name);
       if (inherited is! PropertyAccessorElement) {
         continue;
       }
       // report problem
       hasProblem = true;
       _errorReporter.reportErrorForOffset(
-          CompileTimeErrorCode.CONFLICTING_GETTER_AND_METHOD,
-          method.nameOffset,
-          name.length,
-          [_enclosingClass.displayName, inherited.enclosingElement.displayName, name]);
+          CompileTimeErrorCode.CONFLICTING_GETTER_AND_METHOD, method.nameOffset,
+          name.length, [
+        _enclosingClass.displayName,
+        inherited.enclosingElement.displayName,
+        name
+      ]);
     }
     // getter declared in the enclosing class vs. inherited method
     for (PropertyAccessorElement accessor in _enclosingClass.accessors) {
       if (!accessor.isGetter) {
         continue;
       }
       String name = accessor.name;
       // find inherited method
       ExecutableElement inherited =
           _inheritanceManager.lookupInheritance(_enclosingClass, name);
       if (inherited is! MethodElement) {
         continue;
       }
       // report problem
       hasProblem = true;
       _errorReporter.reportErrorForOffset(
           CompileTimeErrorCode.CONFLICTING_METHOD_AND_GETTER,
-          accessor.nameOffset,
-          name.length,
-          [_enclosingClass.displayName, inherited.enclosingElement.displayName, name]);
+          accessor.nameOffset, name.length, [
+        _enclosingClass.displayName,
+        inherited.enclosingElement.displayName,
+        name
+      ]);
     }
     // done
     return hasProblem;
   }
 
   /**
    * This verifies that the superclass of the [enclosingClass] does not declare accessible
    * static members with the same name as the instance getters/setters declared in
    * [enclosingClass].
    *
@@ skipping 43 matching lines @@
       }
       // prepare "super" type to report its name
       ClassElement superElementClass =
           superElement.enclosingElement as ClassElement;
       InterfaceType superElementType = superElementClass.type;
       // report problem
       hasProblem = true;
       if (getter) {
         _errorReporter.reportErrorForElement(
             StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER,
-            accessor,
-            [superElementType.displayName]);
+            accessor, [superElementType.displayName]);
       } else {
         _errorReporter.reportErrorForElement(
             StaticWarningCode.CONFLICTING_INSTANCE_SETTER_AND_SUPERCLASS_MEMBER,
-            accessor,
-            [superElementType.displayName]);
+            accessor, [superElementType.displayName]);
       }
     }
     // done
     return hasProblem;
   }
 
   /**
    * This verifies that the enclosing class does not have a setter with the same name as the passed
    * instance method declaration.
    *
@@ skipping 36 matching lines @@
         // member is a method or a setter for
         // StaticWarningCode.CONFLICTING_INSTANCE_METHOD_SETTER warning.
         if (isMethod) {
           String setterName = "${name.name}=";
           Element enclosingElementOfSetter = null;
           ClassMember conflictingSetter = memberHashMap[setterName];
           if (conflictingSetter != null) {
             enclosingElementOfSetter =
                 conflictingSetter.element.enclosingElement;
           } else {
-            ExecutableElement elementFromInheritance =
-                _inheritanceManager.lookupInheritance(_enclosingClass, setterName);
+            ExecutableElement elementFromInheritance = _inheritanceManager
+                .lookupInheritance(_enclosingClass, setterName);
             if (elementFromInheritance != null) {
               enclosingElementOfSetter =
                   elementFromInheritance.enclosingElement;
             }
           }
           if (enclosingElementOfSetter != null) {
             // report problem
             _errorReporter.reportErrorForNode(
-                StaticWarningCode.CONFLICTING_INSTANCE_METHOD_SETTER,
-                name,
-                [_enclosingClass.displayName, name.name, enclosingElementOfSetter.displayName]);
+                StaticWarningCode.CONFLICTING_INSTANCE_METHOD_SETTER, name, [
+              _enclosingClass.displayName,
+              name.name,
+              enclosingElementOfSetter.displayName
+            ]);
             foundError = true;
             addThisMemberToTheMap = false;
           }
         } else if (isSetter) {
           String methodName = name.name;
           ClassMember conflictingMethod = memberHashMap[methodName];
           if (conflictingMethod != null &&
               conflictingMethod is MethodDeclaration &&
               !conflictingMethod.isGetter) {
             // report problem
             _errorReporter.reportErrorForNode(
-                StaticWarningCode.CONFLICTING_INSTANCE_METHOD_SETTER2,
-                name,
+                StaticWarningCode.CONFLICTING_INSTANCE_METHOD_SETTER2, name,
                 [_enclosingClass.displayName, name.name]);
             foundError = true;
             addThisMemberToTheMap = false;
           }
         }
         // Finally, add this member into the HashMap.
         if (addThisMemberToTheMap) {
           if (method.isSetter) {
             memberHashMap["${name.name}="] = method;
           } else {
             memberHashMap[name.name] = method;
           }
         }
       }
     }
     return foundError;
   }
 
   /**
    * This verifies that the enclosing class does not have an instance member with the same name as
    * the passed static getter method declaration.
    *
    * @param node the method declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER].
    */
-  bool
-      _checkForConflictingStaticGetterAndInstanceSetter(MethodDeclaration node) {
+  bool _checkForConflictingStaticGetterAndInstanceSetter(
+      MethodDeclaration node) {
     if (!node.isStatic) {
       return false;
     }
     // prepare name
     SimpleIdentifier nameNode = node.name;
     if (nameNode == null) {
       return false;
     }
     String name = nameNode.name;
     // prepare enclosing type
@@ skipping 10 matching lines @@
     // OK, also static
     if (setter.isStatic) {
       return false;
     }
     // prepare "setter" type to report its name
     ClassElement setterClass = setter.enclosingElement as ClassElement;
     InterfaceType setterType = setterClass.type;
     // report problem
     _errorReporter.reportErrorForNode(
         StaticWarningCode.CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER,
-        nameNode,
-        [setterType.displayName]);
+        nameNode, [setterType.displayName]);
     return true;
   }
 
   /**
    * This verifies that the enclosing class does not have an instance member with the same name as
    * the passed static getter method declaration.
    *
    * @param node the method declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.CONFLICTING_STATIC_SETTER_AND_INSTANCE_MEMBER].
    */
-  bool
-      _checkForConflictingStaticSetterAndInstanceMember(MethodDeclaration node) {
+  bool _checkForConflictingStaticSetterAndInstanceMember(
+      MethodDeclaration node) {
     if (!node.isStatic) {
       return false;
     }
     // prepare name
     SimpleIdentifier nameNode = node.name;
     if (nameNode == null) {
       return false;
     }
     String name = nameNode.name;
     // prepare enclosing type
@@ skipping 16 matching lines @@
     // OK, also static
     if (member.isStatic) {
       return false;
     }
     // prepare "member" type to report its name
     ClassElement memberClass = member.enclosingElement as ClassElement;
     InterfaceType memberType = memberClass.type;
     // report problem
     _errorReporter.reportErrorForNode(
         StaticWarningCode.CONFLICTING_STATIC_SETTER_AND_INSTANCE_MEMBER,
-        nameNode,
-        [memberType.displayName]);
+        nameNode, [memberType.displayName]);
     return true;
   }
 
   /**
    * This verifies all conflicts between type variable and enclosing class. TODO(scheglov)
    *
    * @param node the class declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.CONFLICTING_TYPE_VARIABLE_AND_CLASS], and
    * [CompileTimeErrorCode.CONFLICTING_TYPE_VARIABLE_AND_MEMBER].
    */
   bool _checkForConflictingTypeVariableErrorCodes(ClassDeclaration node) {
     bool problemReported = false;
     for (TypeParameterElement typeParameter in _enclosingClass.typeParameters) {
       String name = typeParameter.name;
       // name is same as the name of the enclosing class
       if (_enclosingClass.name == name) {
         _errorReporter.reportErrorForOffset(
             CompileTimeErrorCode.CONFLICTING_TYPE_VARIABLE_AND_CLASS,
-            typeParameter.nameOffset,
-            name.length,
-            [name]);
+            typeParameter.nameOffset, name.length, [name]);
         problemReported = true;
       }
       // check members
       if (_enclosingClass.getMethod(name) != null ||
           _enclosingClass.getGetter(name) != null ||
           _enclosingClass.getSetter(name) != null) {
         _errorReporter.reportErrorForOffset(
             CompileTimeErrorCode.CONFLICTING_TYPE_VARIABLE_AND_MEMBER,
-            typeParameter.nameOffset,
-            name.length,
-            [name]);
+            typeParameter.nameOffset, name.length, [name]);
         problemReported = true;
       }
     }
     return problemReported;
   }
 
   /**
    * This verifies that if the passed constructor declaration is 'const' then there are no
    * invocations of non-'const' super constructors.
    *
    * @param node the constructor declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_CONST_SUPER].
    */
   bool _checkForConstConstructorWithNonConstSuper(ConstructorDeclaration node) {
     if (!_isEnclosingConstructorConst) {
       return false;
     }
     // OK, const factory, checked elsewhere
     if (node.factoryKeyword != null) {
       return false;
     }
     // check for mixins
     if (_enclosingClass.mixins.length != 0) {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_MIXIN,
-          node.returnType);
+          CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_MIXIN, node.returnType);
       return true;
     }
     // try to find and check super constructor invocation
     for (ConstructorInitializer initializer in node.initializers) {
       if (initializer is SuperConstructorInvocation) {
         SuperConstructorInvocation superInvocation = initializer;
         ConstructorElement element = superInvocation.staticElement;
         if (element == null || element.isConst) {
           return false;
         }
         _errorReporter.reportErrorForNode(
             CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_CONST_SUPER,
-            superInvocation,
-            [element.enclosingElement.displayName]);
+            superInvocation, [element.enclosingElement.displayName]);
         return true;
       }
     }
     // no explicit super constructor invocation, check default constructor
     InterfaceType supertype = _enclosingClass.supertype;
     if (supertype == null) {
       return false;
     }
     if (supertype.isObject) {
       return false;
     }
     ConstructorElement unnamedConstructor =
         supertype.element.unnamedConstructor;
     if (unnamedConstructor == null) {
       return false;
     }
     if (unnamedConstructor.isConst) {
       return false;
     }
     // default constructor is not 'const', report problem
     _errorReporter.reportErrorForNode(
         CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_CONST_SUPER,
-        node.returnType,
-        [supertype.displayName]);
+        node.returnType, [supertype.displayName]);
     return true;
   }
 
   /**
    * This verifies that if the passed constructor declaration is 'const' then there are no non-final
    * instance variable.
    *
    * @param node the constructor declaration to evaluate
    * @param constructorElement the constructor element
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_FINAL_FIELD].
    */
-  bool _checkForConstConstructorWithNonFinalField(ConstructorDeclaration node,
-      ConstructorElement constructorElement) {
+  bool _checkForConstConstructorWithNonFinalField(
+      ConstructorDeclaration node, ConstructorElement constructorElement) {
     if (!_isEnclosingConstructorConst) {
       return false;
     }
     // check if there is non-final field
     ClassElement classElement = constructorElement.enclosingElement;
     if (!classElement.hasNonFinalField) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(
-        CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_FINAL_FIELD,
-        node);
+        CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_FINAL_FIELD, node);
     return true;
   }
 
   /**
    * This verifies that the passed 'const' instance creation expression is not creating a deferred
    * type.
    *
    * @param node the instance creation expression to evaluate
    * @param constructorName the constructor name, always non-`null`
    * @param typeName the name of the type defining the constructor, always non-`null`
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.CONST_DEFERRED_CLASS].
    */
   bool _checkForConstDeferredClass(InstanceCreationExpression node,
       ConstructorName constructorName, TypeName typeName) {
     if (typeName.isDeferred) {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.CONST_DEFERRED_CLASS,
-          constructorName,
-          [typeName.name.name]);
+          CompileTimeErrorCode.CONST_DEFERRED_CLASS, constructorName, [
+        typeName.name.name
+      ]);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the passed throw expression is not enclosed in a 'const' constructor
    * declaration.
    *
    * @param node the throw expression expression to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.CONST_CONSTRUCTOR_THROWS_EXCEPTION].
    */
   bool _checkForConstEvalThrowsException(ThrowExpression node) {
     if (_isEnclosingConstructorConst) {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.CONST_CONSTRUCTOR_THROWS_EXCEPTION,
-          node);
+          CompileTimeErrorCode.CONST_CONSTRUCTOR_THROWS_EXCEPTION, node);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the passed normal formal parameter is not 'const'.
    *
    * @param node the normal formal parameter to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.CONST_FORMAL_PARAMETER].
    */
   bool _checkForConstFormalParameter(NormalFormalParameter node) {
     if (node.isConst) {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.CONST_FORMAL_PARAMETER,
-          node);
+          CompileTimeErrorCode.CONST_FORMAL_PARAMETER, node);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the passed instance creation expression is not being invoked on an abstract
    * class.
    *
    * @param node the instance creation expression to evaluate
    * @param typeName the [TypeName] of the [ConstructorName] from the
    *          [InstanceCreationExpression], this is the AST node that the error is attached to
    * @param type the type being constructed with this [InstanceCreationExpression]
    * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.CONST_WITH_ABSTRACT_CLASS], and
    * [StaticWarningCode.NEW_WITH_ABSTRACT_CLASS].
    */
-  bool _checkForConstOrNewWithAbstractClass(InstanceCreationExpression node,
-      TypeName typeName, InterfaceType type) {
+  bool _checkForConstOrNewWithAbstractClass(
+      InstanceCreationExpression node, TypeName typeName, InterfaceType type) {
     if (type.element.isAbstract) {
       ConstructorElement element = node.staticElement;
       if (element != null && !element.isFactory) {
         if ((node.keyword as sc.KeywordToken).keyword == sc.Keyword.CONST) {
           _errorReporter.reportErrorForNode(
-              StaticWarningCode.CONST_WITH_ABSTRACT_CLASS,
-              typeName);
+              StaticWarningCode.CONST_WITH_ABSTRACT_CLASS, typeName);
         } else {
           _errorReporter.reportErrorForNode(
-              StaticWarningCode.NEW_WITH_ABSTRACT_CLASS,
-              typeName);
+              StaticWarningCode.NEW_WITH_ABSTRACT_CLASS, typeName);
         }
         return true;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed instance creation expression is not being invoked on an enum.
    *
    * @param node the instance creation expression to verify
    * @param typeName the [TypeName] of the [ConstructorName] from the
    *          [InstanceCreationExpression], this is the AST node that the error is attached to
    * @param type the type being constructed with this [InstanceCreationExpression]
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.INSTANTIATE_ENUM].
    */
-  bool _checkForConstOrNewWithEnum(InstanceCreationExpression node,
-      TypeName typeName, InterfaceType type) {
+  bool _checkForConstOrNewWithEnum(
+      InstanceCreationExpression node, TypeName typeName, InterfaceType type) {
     if (type.element.isEnum) {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.INSTANTIATE_ENUM,
-          typeName);
+          CompileTimeErrorCode.INSTANTIATE_ENUM, typeName);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the passed 'const' instance creation expression is not being invoked on a
    * constructor that is not 'const'.
    *
    * This method assumes that the instance creation was tested to be 'const' before being called.
    *
    * @param node the instance creation expression to verify
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.CONST_WITH_NON_CONST].
    */
   bool _checkForConstWithNonConst(InstanceCreationExpression node) {
     ConstructorElement constructorElement = node.staticElement;
     if (constructorElement != null && !constructorElement.isConst) {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.CONST_WITH_NON_CONST,
-          node);
+          CompileTimeErrorCode.CONST_WITH_NON_CONST, node);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the passed type name does not reference any type parameters.
    *
    * @param typeName the type name to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.CONST_WITH_TYPE_PARAMETERS].
    */
   bool _checkForConstWithTypeParameters(TypeName typeName) {
     // something wrong with AST
     if (typeName == null) {
       return false;
     }
     Identifier name = typeName.name;
     if (name == null) {
       return false;
     }
     // should not be a type parameter
     if (name.staticElement is TypeParameterElement) {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.CONST_WITH_TYPE_PARAMETERS,
-          name);
+          CompileTimeErrorCode.CONST_WITH_TYPE_PARAMETERS, name);
     }
     // check type arguments
     TypeArgumentList typeArguments = typeName.typeArguments;
     if (typeArguments != null) {
       bool hasError = false;
       for (TypeName argument in typeArguments.arguments) {
         if (_checkForConstWithTypeParameters(argument)) {
           hasError = true;
         }
       }
@@ skipping 28 matching lines @@
       if (element != null && element.isEnum) {
         // We have already reported the error.
         return false;
       }
     }
     Identifier className = typeName.name;
     // report as named or default constructor absence
     SimpleIdentifier name = constructorName.name;
     if (name != null) {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR,
-          name,
-          [className, name]);
+          CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR, name, [
+        className,
+        name
+      ]);
     } else {
       _errorReporter.reportErrorForNode(
           CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT,
-          constructorName,
-          [className]);
+          constructorName, [className]);
     }
     return true;
   }
 
   /**
    * This verifies that there are no default parameters in the passed function type alias.
    *
    * @param node the function type alias to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE_ALIAS].
    */
   bool _checkForDefaultValueInFunctionTypeAlias(FunctionTypeAlias node) {
     bool result = false;
     FormalParameterList formalParameterList = node.parameters;
     NodeList<FormalParameter> parameters = formalParameterList.parameters;
     for (FormalParameter formalParameter in parameters) {
       if (formalParameter is DefaultFormalParameter) {
         DefaultFormalParameter defaultFormalParameter = formalParameter;
         if (defaultFormalParameter.defaultValue != null) {
           _errorReporter.reportErrorForNode(
-              CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE_ALIAS,
-              node);
+              CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE_ALIAS, node);
           result = true;
         }
       }
     }
     return result;
   }
 
   /**
    * This verifies that the given default formal parameter is not part of a function typed
    * parameter.
    *
    * @param node the default formal parameter to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER].
    */
-  bool
-      _checkForDefaultValueInFunctionTypedParameter(DefaultFormalParameter node) {
+  bool _checkForDefaultValueInFunctionTypedParameter(
+      DefaultFormalParameter node) {
     // OK, not in a function typed parameter.
     if (!_isInFunctionTypedFormalParameter) {
       return false;
     }
     // OK, no default value.
     if (node.defaultValue == null) {
       return false;
     }
     // Report problem.
     _errorReporter.reportErrorForNode(
-        CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER,
-        node);
+        CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER, node);
     return true;
   }
 
   /**
    * This verifies that any deferred imports in the given compilation unit have a unique prefix.
    *
    * @param node the compilation unit containing the imports to be checked
    * @return `true` if an error was generated
    * See [CompileTimeErrorCode.SHARED_DEFERRED_PREFIX].
    */
@@ skipping 87 matching lines @@
     String displayName;
     Element enclosingElement = inheritedMember.enclosingElement;
     if (enclosingElement.source == _enclosingClass.source) {
       displayName = enclosingElement.displayName;
     } else {
       displayName = enclosingElement.getExtendedDisplayName(null);
     }
     // report problem
     _errorReporter.reportErrorForOffset(
         CompileTimeErrorCode.DUPLICATE_DEFINITION_INHERITANCE,
-        staticMember.nameOffset,
-        name.length,
-        [name, displayName]);
+        staticMember.nameOffset, name.length, [name, displayName]);
     return true;
   }
 
   /**
    * This verifies if the passed list literal has type arguments then there is exactly one.
    *
    * @param node the list literal to evaluate
    * @param typeArguments the type arguments, always non-`null`
    * @return `true` if and only if an error code is generated on the passed node
    * See [StaticTypeWarningCode.EXPECTED_ONE_LIST_TYPE_ARGUMENTS].
    */
-  bool _checkForExpectedOneListTypeArgument(ListLiteral node,
-      TypeArgumentList typeArguments) {
+  bool _checkForExpectedOneListTypeArgument(
+      ListLiteral node, TypeArgumentList typeArguments) {
     // check number of type arguments
     int num = typeArguments.arguments.length;
     if (num == 1) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(
-        StaticTypeWarningCode.EXPECTED_ONE_LIST_TYPE_ARGUMENTS,
-        typeArguments,
-        [num]);
+        StaticTypeWarningCode.EXPECTED_ONE_LIST_TYPE_ARGUMENTS, typeArguments, [
+      num
+    ]);
     return true;
   }
 
   /**
    * This verifies the passed import has unique name among other exported libraries.
    *
    * @param node the export directive to evaluate
    * @param exportElement the [ExportElement] retrieved from the node, if the element in the
    *          node was `null`, then this method is not called
    * @param exportedLibrary the library element containing the exported element
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.EXPORT_DUPLICATED_LIBRARY_NAME].
    */
   bool _checkForExportDuplicateLibraryName(ExportDirective node,
       ExportElement exportElement, LibraryElement exportedLibrary) {
     if (exportedLibrary == null) {
       return false;
     }
     String name = exportedLibrary.name;
     // check if there is other exported library with the same name
     LibraryElement prevLibrary = _nameToExportElement[name];
     if (prevLibrary != null) {
       if (prevLibrary != exportedLibrary) {
         if (name.isEmpty) {
           _errorReporter.reportErrorForNode(
-              StaticWarningCode.EXPORT_DUPLICATED_LIBRARY_UNNAMED,
-              node,
-              [
-                  prevLibrary.definingCompilationUnit.displayName,
-                  exportedLibrary.definingCompilationUnit.displayName]);
+              StaticWarningCode.EXPORT_DUPLICATED_LIBRARY_UNNAMED, node, [
+            prevLibrary.definingCompilationUnit.displayName,
+            exportedLibrary.definingCompilationUnit.displayName
+          ]);
         } else {
           _errorReporter.reportErrorForNode(
-              StaticWarningCode.EXPORT_DUPLICATED_LIBRARY_NAMED,
-              node,
-              [
-                  prevLibrary.definingCompilationUnit.displayName,
-                  exportedLibrary.definingCompilationUnit.displayName,
-                  name]);
+              StaticWarningCode.EXPORT_DUPLICATED_LIBRARY_NAMED, node, [
+            prevLibrary.definingCompilationUnit.displayName,
+            exportedLibrary.definingCompilationUnit.displayName,
+            name
+          ]);
         }
         return true;
       }
     } else {
       _nameToExportElement[name] = exportedLibrary;
     }
     // OK
     return false;
   }
 
   /**
    * Check that if the visiting library is not system, then any passed library should not be SDK
    * internal library.
    *
    * @param node the export directive to evaluate
    * @param exportElement the [ExportElement] retrieved from the node, if the element in the
    *          node was `null`, then this method is not called
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.EXPORT_INTERNAL_LIBRARY].
    */
-  bool _checkForExportInternalLibrary(ExportDirective node,
-      ExportElement exportElement) {
+  bool _checkForExportInternalLibrary(
+      ExportDirective node, ExportElement exportElement) {
     if (_isInSystemLibrary) {
       return false;
     }
     // should be private
     DartSdk sdk = _currentLibrary.context.sourceFactory.dartSdk;
     String uri = exportElement.uri;
     SdkLibrary sdkLibrary = sdk.getSdkLibrary(uri);
     if (sdkLibrary == null) {
       return false;
     }
     if (!sdkLibrary.isInternal) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(
-        CompileTimeErrorCode.EXPORT_INTERNAL_LIBRARY,
-        node,
-        [node.uri]);
+        CompileTimeErrorCode.EXPORT_INTERNAL_LIBRARY, node, [node.uri]);
     return true;
   }
 
   /**
    * This verifies that the passed extends clause does not extend a deferred class.
    *
    * @param node the extends clause to test
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.EXTENDS_DEFERRED_CLASS].
    */
   bool _checkForExtendsDeferredClass(ExtendsClause node) {
     if (node == null) {
       return false;
     }
     return _checkForExtendsOrImplementsDeferredClass(
-        node.superclass,
-        CompileTimeErrorCode.EXTENDS_DEFERRED_CLASS);
+        node.superclass, CompileTimeErrorCode.EXTENDS_DEFERRED_CLASS);
   }
 
   /**
    * This verifies that the passed type alias does not extend a deferred class.
    *
    * @param node the extends clause to test
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS].
    */
   bool _checkForExtendsDeferredClassInTypeAlias(ClassTypeAlias node) {
     if (node == null) {
       return false;
     }
     return _checkForExtendsOrImplementsDeferredClass(
-        node.superclass,
-        CompileTimeErrorCode.EXTENDS_DEFERRED_CLASS);
+        node.superclass, CompileTimeErrorCode.EXTENDS_DEFERRED_CLASS);
   }
 
   /**
    * This verifies that the passed extends clause does not extend classes such as num or String.
    *
    * @param node the extends clause to test
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS].
    */
   bool _checkForExtendsDisallowedClass(ExtendsClause node) {
     if (node == null) {
       return false;
     }
     return _checkForExtendsOrImplementsDisallowedClass(
-        node.superclass,
-        CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS);
+        node.superclass, CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS);
   }
 
   /**
    * This verifies that the passed type alias does not extend classes such as num or String.
    *
    * @param node the extends clause to test
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS].
    */
   bool _checkForExtendsDisallowedClassInTypeAlias(ClassTypeAlias node) {
     if (node == null) {
       return false;
     }
     return _checkForExtendsOrImplementsDisallowedClass(
-        node.superclass,
-        CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS);
+        node.superclass, CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS);
   }
 
   /**
    * This verifies that the passed type name does not extend, implement or mixin classes that are
    * deferred.
    *
    * @param node the type name to test
    * @return `true` if and only if an error code is generated on the passed node
    * See [_checkForExtendsDeferredClass],
    * [_checkForExtendsDeferredClassInTypeAlias],
    * [_checkForImplementsDeferredClass],
    * [_checkForAllMixinErrorCodes],
    * [CompileTimeErrorCode.EXTENDS_DEFERRED_CLASS],
    * [CompileTimeErrorCode.IMPLEMENTS_DEFERRED_CLASS], and
    * [CompileTimeErrorCode.MIXIN_DEFERRED_CLASS].
    */
-  bool _checkForExtendsOrImplementsDeferredClass(TypeName typeName,
-      ErrorCode errorCode) {
+  bool _checkForExtendsOrImplementsDeferredClass(
+      TypeName typeName, ErrorCode errorCode) {
     if (typeName.isSynthetic) {
       return false;
     }
     if (typeName.isDeferred) {
       _errorReporter.reportErrorForNode(
-          errorCode,
-          typeName,
-          [typeName.name.name]);
+          errorCode, typeName, [typeName.name.name]);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the passed type name does not extend, implement or mixin classes such as
    * 'num' or 'String'.
    *
    * @param node the type name to test
    * @return `true` if and only if an error code is generated on the passed node
    * See [_checkForExtendsDisallowedClass],
    * [_checkForExtendsDisallowedClassInTypeAlias],
    * [_checkForImplementsDisallowedClass],
    * [_checkForAllMixinErrorCodes],
    * [CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS],
    * [CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS], and
    * [CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS].
    */
-  bool _checkForExtendsOrImplementsDisallowedClass(TypeName typeName,
-      ErrorCode errorCode) {
+  bool _checkForExtendsOrImplementsDisallowedClass(
+      TypeName typeName, ErrorCode errorCode) {
     if (typeName.isSynthetic) {
       return false;
     }
     DartType superType = typeName.type;
-    for (InterfaceType disallowedType in
-        _DISALLOWED_TYPES_TO_EXTEND_OR_IMPLEMENT) {
+    for (InterfaceType disallowedType
+        in _DISALLOWED_TYPES_TO_EXTEND_OR_IMPLEMENT) {
       if (superType != null && superType == disallowedType) {
         // if the violating type happens to be 'num', we need to rule out the
         // case where the enclosing class is 'int' or 'double'
         if (superType == _typeProvider.numType) {
           AstNode grandParent = typeName.parent.parent;
           // Note: this is a corner case that won't happen often, so adding a
           // field currentClass (see currentFunction) to ErrorVerifier isn't
           // worth if for this case, but if the field currentClass is added,
           // then this message should become a todo to not lookup the
           // grandparent node.
           if (grandParent is ClassDeclaration) {
             ClassElement classElement = grandParent.element;
             DartType classType = classElement.type;
             if (classType != null &&
-                (classType == _intType || classType == _typeProvider.doubleType)) {
+                (classType == _intType ||
+                    classType == _typeProvider.doubleType)) {
               return false;
             }
           }
         }
         // otherwise, report the error
         _errorReporter.reportErrorForNode(
-            errorCode,
-            typeName,
-            [disallowedType.displayName]);
+            errorCode, typeName, [disallowedType.displayName]);
         return true;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed constructor field initializer has compatible field and
    * initializer expression types.
    *
    * @param node the constructor field initializer to test
    * @param staticElement the static element from the name in the
    *          [ConstructorFieldInitializer]
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.CONST_FIELD_INITIALIZER_NOT_ASSIGNABLE], and
    * [StaticWarningCode.FIELD_INITIALIZER_NOT_ASSIGNABLE].
    */
-  bool _checkForFieldInitializerNotAssignable(ConstructorFieldInitializer node,
-      Element staticElement) {
+  bool _checkForFieldInitializerNotAssignable(
+      ConstructorFieldInitializer node, Element staticElement) {
     // prepare field element
     if (staticElement is! FieldElement) {
       return false;
     }
     FieldElement fieldElement = staticElement as FieldElement;
     // prepare field type
     DartType fieldType = fieldElement.type;
     // prepare expression type
     Expression expression = node.expression;
     if (expression == null) {
       return false;
     }
     // test the static type of the expression
     DartType staticType = getStaticType(expression);
     if (staticType == null) {
       return false;
     }
     if (staticType.isAssignableTo(fieldType)) {
       return false;
     }
     // report problem
     if (_isEnclosingConstructorConst) {
       // TODO(paulberry): this error should be based on the actual type of the
       // constant, not the static type.  See dartbug.com/21119.
       _errorReporter.reportTypeErrorForNode(
           CheckedModeCompileTimeErrorCode.CONST_FIELD_INITIALIZER_NOT_ASSIGNABLE,
-          expression,
-          [staticType, fieldType]);
+          expression, [staticType, fieldType]);
     }
     _errorReporter.reportTypeErrorForNode(
-        StaticWarningCode.FIELD_INITIALIZER_NOT_ASSIGNABLE,
-        expression,
-        [staticType, fieldType]);
+        StaticWarningCode.FIELD_INITIALIZER_NOT_ASSIGNABLE, expression, [
+      staticType,
+      fieldType
+    ]);
     return true;
     // TODO(brianwilkerson) Define a hint corresponding to these errors and
     // report it if appropriate.
 //        // test the propagated type of the expression
 //        Type propagatedType = expression.getPropagatedType();
 //        if (propagatedType != null && propagatedType.isAssignableTo(fieldType)) {
 //          return false;
 //        }
 //        // report problem
 //        if (isEnclosingConstructorConst) {
@@ skipping 12 matching lines @@
 //        return true;
   }
 
   /**
    * This verifies that the passed field formal parameter is in a constructor declaration.
    *
    * @param node the field formal parameter to test
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR].
    */
-  bool
-      _checkForFieldInitializingFormalRedirectingConstructor(FieldFormalParameter node) {
+  bool _checkForFieldInitializingFormalRedirectingConstructor(
+      FieldFormalParameter node) {
     ConstructorDeclaration constructor =
         node.getAncestor((node) => node is ConstructorDeclaration);
     if (constructor == null) {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR,
-          node);
+          CompileTimeErrorCode.FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR, node);
       return true;
     }
     // constructor cannot be a factory
     if (constructor.factoryKeyword != null) {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.FIELD_INITIALIZER_FACTORY_CONSTRUCTOR,
-          node);
+          CompileTimeErrorCode.FIELD_INITIALIZER_FACTORY_CONSTRUCTOR, node);
       return true;
     }
     // constructor cannot have a redirection
     for (ConstructorInitializer initializer in constructor.initializers) {
       if (initializer is RedirectingConstructorInvocation) {
         _errorReporter.reportErrorForNode(
             CompileTimeErrorCode.FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR,
             node);
         return true;
       }
@@ skipping 18 matching lines @@
     if (_isInNativeClass) {
       return false;
     }
     bool foundError = false;
     if (!node.isSynthetic) {
       NodeList<VariableDeclaration> variables = node.variables;
       for (VariableDeclaration variable in variables) {
         if (variable.initializer == null) {
           if (node.isConst) {
             _errorReporter.reportErrorForNode(
-                CompileTimeErrorCode.CONST_NOT_INITIALIZED,
-                variable.name,
-                [variable.name.name]);
+                CompileTimeErrorCode.CONST_NOT_INITIALIZED, variable.name, [
+              variable.name.name
+            ]);
           } else if (node.isFinal) {
             _errorReporter.reportErrorForNode(
-                StaticWarningCode.FINAL_NOT_INITIALIZED,
-                variable.name,
-                [variable.name.name]);
+                StaticWarningCode.FINAL_NOT_INITIALIZED, variable.name, [
+              variable.name.name
+            ]);
           }
           foundError = true;
         }
       }
     }
     return foundError;
   }
 
   /**
    * This verifies that final fields that are declared, without any constructors in the enclosing
@@ skipping 28 matching lines @@
    * respectively.  If not, report the error using [node].
    */
   void _checkForIllegalReturnType(TypeName node) {
     if (node == null) {
       // No declared return type, so the return type must be dynamic, which is
       // assignable to everything.
       return;
     }
     if (_enclosingFunction.isAsynchronous) {
       if (_enclosingFunction.isGenerator) {
-        if (!_enclosingFunction.returnType.isAssignableTo(
-            _typeProvider.streamDynamicType)) {
+        if (!_enclosingFunction.returnType
+            .isAssignableTo(_typeProvider.streamDynamicType)) {
           _errorReporter.reportErrorForNode(
-              StaticTypeWarningCode.ILLEGAL_ASYNC_GENERATOR_RETURN_TYPE,
-              node);
+              StaticTypeWarningCode.ILLEGAL_ASYNC_GENERATOR_RETURN_TYPE, node);
         }
       } else {
-        if (!_enclosingFunction.returnType.isAssignableTo(
-            _typeProvider.futureDynamicType)) {
+        if (!_enclosingFunction.returnType
+            .isAssignableTo(_typeProvider.futureDynamicType)) {
           _errorReporter.reportErrorForNode(
-              StaticTypeWarningCode.ILLEGAL_ASYNC_RETURN_TYPE,
-              node);
+              StaticTypeWarningCode.ILLEGAL_ASYNC_RETURN_TYPE, node);
         }
       }
     } else if (_enclosingFunction.isGenerator) {
-      if (!_enclosingFunction.returnType.isAssignableTo(
-          _typeProvider.iterableDynamicType)) {
+      if (!_enclosingFunction.returnType
+          .isAssignableTo(_typeProvider.iterableDynamicType)) {
         _errorReporter.reportErrorForNode(
-            StaticTypeWarningCode.ILLEGAL_SYNC_GENERATOR_RETURN_TYPE,
-            node);
+            StaticTypeWarningCode.ILLEGAL_SYNC_GENERATOR_RETURN_TYPE, node);
       }
     }
   }
 
   /**
    * This verifies that the passed implements clause does not implement classes that are deferred.
    *
    * @param node the implements clause to test
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.IMPLEMENTS_DEFERRED_CLASS].
    */
   bool _checkForImplementsDeferredClass(ImplementsClause node) {
     if (node == null) {
       return false;
     }
     bool foundError = false;
     for (TypeName type in node.interfaces) {
       if (_checkForExtendsOrImplementsDeferredClass(
-          type,
-          CompileTimeErrorCode.IMPLEMENTS_DEFERRED_CLASS)) {
+          type, CompileTimeErrorCode.IMPLEMENTS_DEFERRED_CLASS)) {
         foundError = true;
       }
     }
     return foundError;
   }
 
   /**
    * This verifies that the passed implements clause does not implement classes such as 'num' or
    * 'String'.
    *
    * @param node the implements clause to test
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS].
    */
   bool _checkForImplementsDisallowedClass(ImplementsClause node) {
     if (node == null) {
       return false;
     }
     bool foundError = false;
     for (TypeName type in node.interfaces) {
       if (_checkForExtendsOrImplementsDisallowedClass(
-          type,
-          CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS)) {
+          type, CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS)) {
         foundError = true;
       }
     }
     return foundError;
   }
 
   /**
    * This verifies that if the passed identifier is part of constructor initializer, then it does
    * not reference implicitly 'this' expression.
    *
@@ skipping 48 matching lines @@
     }
     if (parent is PrefixedIdentifier) {
       PrefixedIdentifier prefixed = parent;
       if (identical(prefixed.identifier, node)) {
         return false;
       }
     }
     // report problem
     if (_isInStaticMethod) {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_STATIC,
-          node);
+          CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_STATIC, node);
     } else if (_isInFactory) {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_FACTORY,
-          node);
+          CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_FACTORY, node);
     } else {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.IMPLICIT_THIS_REFERENCE_IN_INITIALIZER,
-          node);
+          CompileTimeErrorCode.IMPLICIT_THIS_REFERENCE_IN_INITIALIZER, node);
     }
     return true;
   }
 
   /**
    * This verifies the passed import has unique name among other imported libraries.
    *
    * @param node the import directive to evaluate
    * @param importElement the [ImportElement] retrieved from the node, if the element in the
    *          node was `null`, then this method is not called
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.IMPORT_DUPLICATED_LIBRARY_NAME].
    */
-  bool _checkForImportDuplicateLibraryName(ImportDirective node,
-      ImportElement importElement) {
+  bool _checkForImportDuplicateLibraryName(
+      ImportDirective node, ImportElement importElement) {
     // prepare imported library
     LibraryElement nodeLibrary = importElement.importedLibrary;
     if (nodeLibrary == null) {
       return false;
     }
     String name = nodeLibrary.name;
     // check if there is another imported library with the same name
     LibraryElement prevLibrary = _nameToImportElement[name];
     if (prevLibrary != null) {
       if (prevLibrary != nodeLibrary) {
         if (name.isEmpty) {
           _errorReporter.reportErrorForNode(
-              StaticWarningCode.IMPORT_DUPLICATED_LIBRARY_UNNAMED,
-              node,
-              [
-                  prevLibrary.definingCompilationUnit.displayName,
-                  nodeLibrary.definingCompilationUnit.displayName]);
+              StaticWarningCode.IMPORT_DUPLICATED_LIBRARY_UNNAMED, node, [
+            prevLibrary.definingCompilationUnit.displayName,
+            nodeLibrary.definingCompilationUnit.displayName
+          ]);
         } else {
           _errorReporter.reportErrorForNode(
-              StaticWarningCode.IMPORT_DUPLICATED_LIBRARY_NAMED,
-              node,
-              [
-                  prevLibrary.definingCompilationUnit.displayName,
-                  nodeLibrary.definingCompilationUnit.displayName,
-                  name]);
+              StaticWarningCode.IMPORT_DUPLICATED_LIBRARY_NAMED, node, [
+            prevLibrary.definingCompilationUnit.displayName,
+            nodeLibrary.definingCompilationUnit.displayName,
+            name
+          ]);
         }
         return true;
       }
     } else {
       _nameToImportElement[name] = nodeLibrary;
     }
     // OK
     return false;
   }
 
   /**
    * Check that if the visiting library is not system, then any passed library should not be SDK
    * internal library.
    *
    * @param node the import directive to evaluate
    * @param importElement the [ImportElement] retrieved from the node, if the element in the
    *          node was `null`, then this method is not called
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.IMPORT_INTERNAL_LIBRARY].
    */
-  bool _checkForImportInternalLibrary(ImportDirective node,
-      ImportElement importElement) {
+  bool _checkForImportInternalLibrary(
+      ImportDirective node, ImportElement importElement) {
     if (_isInSystemLibrary) {
       return false;
     }
     // should be private
     DartSdk sdk = _currentLibrary.context.sourceFactory.dartSdk;
     String uri = importElement.uri;
     SdkLibrary sdkLibrary = sdk.getSdkLibrary(uri);
     if (sdkLibrary == null) {
       return false;
     }
     if (!sdkLibrary.isInternal) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(
-        CompileTimeErrorCode.IMPORT_INTERNAL_LIBRARY,
-        node,
-        [node.uri]);
+        CompileTimeErrorCode.IMPORT_INTERNAL_LIBRARY, node, [node.uri]);
     return true;
   }
 
   /**
    * For each class declaration, this method is called which verifies that all inherited members are
    * inherited consistently.
    *
    * @return `true` if and only if an error code is generated on the passed node
    * See [StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE].
    */
@@ skipping 17 matching lines @@
    * This checks the given "typeReference" is not a type reference and that then the "name" is
    * reference to an instance member.
    *
    * @param typeReference the resolved [ClassElement] of the left hand side of the expression,
    *          or `null`, aka, the class element of 'C' in 'C.x', see
    *          [getTypeReference]
    * @param name the accessed name to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER].
    */
-  bool _checkForInstanceAccessToStaticMember(ClassElement typeReference,
-      SimpleIdentifier name) {
+  bool _checkForInstanceAccessToStaticMember(
+      ClassElement typeReference, SimpleIdentifier name) {
     // OK, in comment
     if (_isInComment) {
       return false;
     }
     // OK, target is a type
     if (typeReference != null) {
       return false;
     }
     // prepare member Element
     Element element = name.staticElement;
     if (element is! ExecutableElement) {
       return false;
     }
     ExecutableElement executableElement = element as ExecutableElement;
     // OK, top-level element
     if (executableElement.enclosingElement is! ClassElement) {
       return false;
     }
     // OK, instance member
     if (!executableElement.isStatic) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(
-        StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER,
-        name,
-        [name.name]);
+        StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER, name, [
+      name.name
+    ]);
     return true;
   }
 
   /**
    * This checks whether the given [executableElement] collides with the name of a static
    * method in one of its superclasses, and reports the appropriate warning if it does.
    *
    * @param executableElement the method to check.
    * @param errorNameTarget the node to report problems on.
    * @return `true` if and only if a warning was generated.
    * See [StaticTypeWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC].
    */
-  bool
-      _checkForInstanceMethodNameCollidesWithSuperclassStatic(ExecutableElement executableElement,
-      SimpleIdentifier errorNameTarget) {
+  bool _checkForInstanceMethodNameCollidesWithSuperclassStatic(
+      ExecutableElement executableElement, SimpleIdentifier errorNameTarget) {
     String executableElementName = executableElement.name;
     if (executableElement is! PropertyAccessorElement &&
         !executableElement.isOperator) {
       HashSet<ClassElement> visitedClasses = new HashSet<ClassElement>();
       InterfaceType superclassType = _enclosingClass.supertype;
       ClassElement superclassElement =
           superclassType == null ? null : superclassType.element;
       bool executableElementPrivate =
           Identifier.isPrivateName(executableElementName);
       while (superclassElement != null &&
           !visitedClasses.contains(superclassElement)) {
         visitedClasses.add(superclassElement);
         LibraryElement superclassLibrary = superclassElement.library;
         // Check fields.
-        FieldElement fieldElt = superclassElement.getField(executableElementName);
+        FieldElement fieldElt =
+            superclassElement.getField(executableElementName);
         if (fieldElt != null) {
           // Ignore if private in a different library - cannot collide.
           if (executableElementPrivate &&
               _currentLibrary != superclassLibrary) {
             continue;
           }
           // instance vs. static
           if (fieldElt.isStatic) {
             _errorReporter.reportErrorForNode(
                 StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC,
-                errorNameTarget,
-                [executableElementName, fieldElt.enclosingElement.displayName]);
+                errorNameTarget, [
+              executableElementName,
+              fieldElt.enclosingElement.displayName
+            ]);
             return true;
           }
         }
         // Check methods.
         List<MethodElement> methodElements = superclassElement.methods;
         for (MethodElement methodElement in methodElements) {
           // We need the same name.
           if (methodElement.name != executableElementName) {
             continue;
           }
           // Ignore if private in a different library - cannot collide.
           if (executableElementPrivate &&
               _currentLibrary != superclassLibrary) {
             continue;
           }
           // instance vs. static
           if (methodElement.isStatic) {
             _errorReporter.reportErrorForNode(
                 StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC,
-                errorNameTarget,
-                [executableElementName, methodElement.enclosingElement.displayName]);
+                errorNameTarget, [
+              executableElementName,
+              methodElement.enclosingElement.displayName
+            ]);
             return true;
           }
         }
         superclassType = superclassElement.supertype;
         superclassElement =
             superclassType == null ? null : superclassType.element;
       }
     }
     return false;
   }
 
   /**
    * This verifies that an 'int' can be assigned to the parameter corresponding to the given
    * expression. This is used for prefix and postfix expressions where the argument value is
    * implicit.
    *
    * @param argument the expression to which the operator is being applied
    * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE].
    */
   bool _checkForIntNotAssignable(Expression argument) {
     if (argument == null) {
       return false;
     }
     ParameterElement staticParameterElement = argument.staticParameterElement;
     DartType staticParameterType =
         staticParameterElement == null ? null : staticParameterElement.type;
-    return _checkForArgumentTypeNotAssignable(
-        argument,
-        staticParameterType,
-        _intType,
-        StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
+    return _checkForArgumentTypeNotAssignable(argument, staticParameterType,
+        _intType, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE);
   }
 
   /**
    * This verifies that the passed [Annotation] isn't defined in a deferred library.
    *
    * @param node the [Annotation]
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.INVALID_ANNOTATION_FROM_DEFERRED_LIBRARY].
    */
   bool _checkForInvalidAnnotationFromDeferredLibrary(Annotation node) {
@@ skipping 15 matching lines @@
    * @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 [StaticTypeWarningCode.INVALID_ASSIGNMENT].
    */
   bool _checkForInvalidAssignment(Expression lhs, Expression rhs) {
     if (lhs == null || rhs == null) {
       return false;
     }
     VariableElement leftVariableElement = getVariableElement(lhs);
-    DartType leftType =
-        (leftVariableElement == null) ? getStaticType(lhs) : leftVariableElement.type;
+    DartType leftType = (leftVariableElement == null)
+        ? getStaticType(lhs)
+        : leftVariableElement.type;
     DartType staticRightType = getStaticType(rhs);
     if (!staticRightType.isAssignableTo(leftType)) {
       _errorReporter.reportTypeErrorForNode(
-          StaticTypeWarningCode.INVALID_ASSIGNMENT,
-          rhs,
-          [staticRightType, leftType]);
+          StaticTypeWarningCode.INVALID_ASSIGNMENT, rhs, [
+        staticRightType,
+        leftType
+      ]);
       return true;
     }
     return false;
   }
 
   /**
    * Given an assignment using a compound assignment operator, this verifies that the given
    * assignment is valid.
    *
    * @param node the assignment expression being tested
    * @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 [StaticTypeWarningCode.INVALID_ASSIGNMENT].
    */
-  bool _checkForInvalidCompoundAssignment(AssignmentExpression node,
-      Expression lhs, Expression rhs) {
+  bool _checkForInvalidCompoundAssignment(
+      AssignmentExpression node, Expression lhs, Expression rhs) {
     if (lhs == null) {
       return false;
     }
     VariableElement leftVariableElement = getVariableElement(lhs);
-    DartType leftType =
-        (leftVariableElement == null) ? getStaticType(lhs) : leftVariableElement.type;
+    DartType leftType = (leftVariableElement == null)
+        ? getStaticType(lhs)
+        : leftVariableElement.type;
     MethodElement invokedMethod = node.staticElement;
     if (invokedMethod == null) {
       return false;
     }
     DartType rightType = invokedMethod.type.returnType;
     if (leftType == null || rightType == null) {
       return false;
     }
     if (!rightType.isAssignableTo(leftType)) {
       _errorReporter.reportTypeErrorForNode(
-          StaticTypeWarningCode.INVALID_ASSIGNMENT,
-          rhs,
-          [rightType, leftType]);
+          StaticTypeWarningCode.INVALID_ASSIGNMENT, rhs, [rightType, leftType]);
       return true;
     }
     return false;
   }
 
   /**
    * Check the given initializer to ensure that the field being initialized is a valid field.
    *
    * @param node the field initializer being checked
    * @param fieldName the field name from the [ConstructorFieldInitializer]
    * @param staticElement the static element from the name in the
    *          [ConstructorFieldInitializer]
    */
   void _checkForInvalidField(ConstructorFieldInitializer node,
       SimpleIdentifier fieldName, Element staticElement) {
     if (staticElement is FieldElement) {
       FieldElement fieldElement = staticElement;
       if (fieldElement.isSynthetic) {
         _errorReporter.reportErrorForNode(
-            CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTENT_FIELD,
-            node,
-            [fieldName]);
+            CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTENT_FIELD, node, [
+          fieldName
+        ]);
       } else if (fieldElement.isStatic) {
         _errorReporter.reportErrorForNode(
-            CompileTimeErrorCode.INITIALIZER_FOR_STATIC_FIELD,
-            node,
-            [fieldName]);
+            CompileTimeErrorCode.INITIALIZER_FOR_STATIC_FIELD, node, [
+          fieldName
+        ]);
       }
     } else {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTENT_FIELD,
-          node,
-          [fieldName]);
+          CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTENT_FIELD, node, [
+        fieldName
+      ]);
       return;
     }
   }
 
   /**
    * Check to see whether the given function body has a modifier associated with it, and report it
    * as an error if it does.
    *
    * @param body the function body being checked
    * @param errorCode the error code to be reported if a modifier is found
    * @return `true` if an error was reported
    */
-  bool _checkForInvalidModifierOnBody(FunctionBody body,
-      CompileTimeErrorCode errorCode) {
+  bool _checkForInvalidModifierOnBody(
+      FunctionBody body, CompileTimeErrorCode errorCode) {
     sc.Token keyword = body.keyword;
     if (keyword != null) {
       _errorReporter.reportErrorForToken(errorCode, keyword, [keyword.lexeme]);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the usage of the passed 'this' is valid.
    *
    * @param node the 'this' expression to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS].
    */
   bool _checkForInvalidReferenceToThis(ThisExpression node) {
     if (!_isThisInValidContext(node)) {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS,
-          node);
+          CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS, node);
       return true;
     }
     return false;
   }
 
   /**
    * Checks to ensure that the passed [ListLiteral] or [MapLiteral] does not have a type
    * parameter as a type argument.
    *
    * @param arguments a non-`null`, non-empty [TypeName] node list from the respective
    *          [ListLiteral] or [MapLiteral]
    * @param errorCode either [CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_LIST] or
    *          [CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_MAP]
    * @return `true` if and only if an error code is generated on the passed node
    */
-  bool
-      _checkForInvalidTypeArgumentInConstTypedLiteral(NodeList<TypeName> arguments,
-      ErrorCode errorCode) {
+  bool _checkForInvalidTypeArgumentInConstTypedLiteral(
+      NodeList<TypeName> arguments, ErrorCode errorCode) {
     bool foundError = false;
     for (TypeName typeName in arguments) {
       if (typeName.type is TypeParameterType) {
         _errorReporter.reportErrorForNode(errorCode, typeName, [typeName.name]);
         foundError = true;
       }
     }
     return foundError;
   }
 
   /**
    * This verifies that the elements given [ListLiteral] are subtypes of the specified element
    * type.
    *
    * @param node the list literal to evaluate
    * @param typeArguments the type arguments, always non-`null`
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE], and
    * [StaticWarningCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE].
    */
-  bool _checkForListElementTypeNotAssignable(ListLiteral node,
-      TypeArgumentList typeArguments) {
+  bool _checkForListElementTypeNotAssignable(
+      ListLiteral node, TypeArgumentList typeArguments) {
     NodeList<TypeName> typeNames = typeArguments.arguments;
     if (typeNames.length < 1) {
       return false;
     }
     DartType listElementType = typeNames[0].type;
     // Check every list element.
     bool hasProblems = false;
     for (Expression element in node.elements) {
       if (node.constKeyword != null) {
         // TODO(paulberry): this error should be based on the actual type of the
         // list element, not the static type.  See dartbug.com/21119.
-        if (_checkForArgumentTypeNotAssignableWithExpectedTypes(
-            element,
+        if (_checkForArgumentTypeNotAssignableWithExpectedTypes(element,
             listElementType,
             CheckedModeCompileTimeErrorCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE)) {
           hasProblems = true;
         }
       }
-      if (_checkForArgumentTypeNotAssignableWithExpectedTypes(
-          element,
+      if (_checkForArgumentTypeNotAssignableWithExpectedTypes(element,
           listElementType,
           StaticWarningCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE)) {
         hasProblems = true;
       }
     }
     return hasProblems;
   }
 
   /**
    * This verifies that the key/value of entries of the given [MapLiteral] are subtypes of the
    * key/value types specified in the type arguments.
    *
    * @param node the map literal to evaluate
    * @param typeArguments the type arguments, always non-`null`
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.MAP_KEY_TYPE_NOT_ASSIGNABLE],
    * [CompileTimeErrorCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE],
    * [StaticWarningCode.MAP_KEY_TYPE_NOT_ASSIGNABLE], and
    * [StaticWarningCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE].
    */
-  bool _checkForMapTypeNotAssignable(MapLiteral node,
-      TypeArgumentList typeArguments) {
+  bool _checkForMapTypeNotAssignable(
+      MapLiteral node, TypeArgumentList typeArguments) {
     // Prepare maps key/value types.
     NodeList<TypeName> typeNames = typeArguments.arguments;
     if (typeNames.length < 2) {
       return false;
     }
     DartType keyType = typeNames[0].type;
     DartType valueType = typeNames[1].type;
     // Check every map entry.
     bool hasProblems = false;
     NodeList<MapLiteralEntry> entries = node.entries;
     for (MapLiteralEntry entry in entries) {
       Expression key = entry.key;
       Expression value = entry.value;
       if (node.constKeyword != null) {
         // TODO(paulberry): this error should be based on the actual type of the
         // list element, not the static type.  See dartbug.com/21119.
-        if (_checkForArgumentTypeNotAssignableWithExpectedTypes(
-            key,
-            keyType,
+        if (_checkForArgumentTypeNotAssignableWithExpectedTypes(key, keyType,
             CheckedModeCompileTimeErrorCode.MAP_KEY_TYPE_NOT_ASSIGNABLE)) {
           hasProblems = true;
         }
-        if (_checkForArgumentTypeNotAssignableWithExpectedTypes(
-            value,
+        if (_checkForArgumentTypeNotAssignableWithExpectedTypes(value,
             valueType,
             CheckedModeCompileTimeErrorCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE)) {
           hasProblems = true;
         }
       }
       if (_checkForArgumentTypeNotAssignableWithExpectedTypes(
-          key,
-          keyType,
-          StaticWarningCode.MAP_KEY_TYPE_NOT_ASSIGNABLE)) {
+          key, keyType, StaticWarningCode.MAP_KEY_TYPE_NOT_ASSIGNABLE)) {
         hasProblems = true;
       }
       if (_checkForArgumentTypeNotAssignableWithExpectedTypes(
-          value,
-          valueType,
-          StaticWarningCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE)) {
+          value, valueType, StaticWarningCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE)) {
         hasProblems = true;
       }
     }
     return hasProblems;
   }
 
   /**
    * This verifies that the [enclosingClass] does not define members with the same name as
    * the enclosing class.
    *
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.MEMBER_WITH_CLASS_NAME].
    */
   bool _checkForMemberWithClassName() {
     if (_enclosingClass == null) {
       return false;
     }
     String className = _enclosingClass.name;
     if (className == null) {
       return false;
     }
     bool problemReported = false;
     // check accessors
     for (PropertyAccessorElement accessor in _enclosingClass.accessors) {
       if (className == accessor.name) {
         _errorReporter.reportErrorForOffset(
-            CompileTimeErrorCode.MEMBER_WITH_CLASS_NAME,
-            accessor.nameOffset,
+            CompileTimeErrorCode.MEMBER_WITH_CLASS_NAME, accessor.nameOffset,
             className.length);
         problemReported = true;
       }
     }
     // don't check methods, they would be constructors
     // done
     return problemReported;
   }
 
   /**
    * Check to make sure that all similarly typed accessors are of the same type (including inherited
    * accessors).
    *
    * @param node the accessor currently being visited
    * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES], and
    * [StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE].
    */
-  bool _checkForMismatchedAccessorTypes(Declaration accessorDeclaration,
-      String accessorTextName) {
+  bool _checkForMismatchedAccessorTypes(
+      Declaration accessorDeclaration, String accessorTextName) {
     ExecutableElement accessorElement =
         accessorDeclaration.element as ExecutableElement;
     if (accessorElement is! PropertyAccessorElement) {
       return false;
     }
     PropertyAccessorElement propertyAccessorElement =
         accessorElement as PropertyAccessorElement;
     PropertyAccessorElement counterpartAccessor = null;
     ClassElement enclosingClassForCounterpart = null;
     if (propertyAccessorElement.isGetter) {
       counterpartAccessor = propertyAccessorElement.correspondingSetter;
     } else {
       counterpartAccessor = propertyAccessorElement.correspondingGetter;
       // If the setter and getter are in the same enclosing element, return,
       // this prevents having MISMATCHED_GETTER_AND_SETTER_TYPES reported twice.
       if (counterpartAccessor != null &&
-          identical(
-              counterpartAccessor.enclosingElement,
+          identical(counterpartAccessor.enclosingElement,
               propertyAccessorElement.enclosingElement)) {
         return false;
       }
     }
     if (counterpartAccessor == null) {
       // If the accessor is declared in a class, check the superclasses.
       if (_enclosingClass != null) {
         // Figure out the correct identifier to lookup in the inheritance graph,
         // if 'x', then 'x=', or if 'x=', then 'x'.
         String lookupIdentifier = propertyAccessorElement.name;
         if (StringUtilities.endsWithChar(lookupIdentifier, 0x3D)) {
           lookupIdentifier =
               lookupIdentifier.substring(0, lookupIdentifier.length - 1);
         } else {
           lookupIdentifier += "=";
         }
         // lookup with the identifier.
-        ExecutableElement elementFromInheritance =
-            _inheritanceManager.lookupInheritance(_enclosingClass, lookupIdentifier);
+        ExecutableElement elementFromInheritance = _inheritanceManager
+            .lookupInheritance(_enclosingClass, lookupIdentifier);
         // Verify that we found something, and that it is an accessor
         if (elementFromInheritance != null &&
             elementFromInheritance is PropertyAccessorElement) {
           enclosingClassForCounterpart =
               elementFromInheritance.enclosingElement as ClassElement;
           counterpartAccessor = elementFromInheritance;
         }
       }
       if (counterpartAccessor == null) {
         return false;
@@ skipping 11 matching lines @@
       getterType = _getGetterType(counterpartAccessor);
     }
     // If either types are not assignable to each other, report an error
     // (if the getter is null, it is dynamic which is assignable to everything).
     if (setterType != null &&
         getterType != null &&
         !getterType.isAssignableTo(setterType)) {
       if (enclosingClassForCounterpart == null) {
         _errorReporter.reportTypeErrorForNode(
             StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES,
-            accessorDeclaration,
-            [accessorTextName, setterType, getterType]);
+            accessorDeclaration, [accessorTextName, setterType, getterType]);
         return true;
       } else {
         _errorReporter.reportTypeErrorForNode(
             StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE,
-            accessorDeclaration,
-            [
-                accessorTextName,
-                setterType,
-                getterType,
-                enclosingClassForCounterpart.displayName]);
+            accessorDeclaration, [
+          accessorTextName,
+          setterType,
+          getterType,
+          enclosingClassForCounterpart.displayName
+        ]);
       }
     }
     return false;
   }
 
   /**
    * Check to make sure that switch statements whose static type is an enum type either have a
    * default case or include all of the enum constants.
    *
    * @param statement the switch statement to check
@@ skipping 35 matching lines @@
       if (constantName != null) {
         constantNames.remove(constantName);
       }
     }
     int nameCount = constantNames.length;
     if (nameCount == 0) {
       return false;
     }
     for (int i = 0; i < nameCount; i++) {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.MISSING_ENUM_CONSTANT_IN_SWITCH,
-          statement,
-          [constantNames[i]]);
+          CompileTimeErrorCode.MISSING_ENUM_CONSTANT_IN_SWITCH, statement, [
+        constantNames[i]
+      ]);
     }
     return true;
   }
 
   /**
    * This verifies that the given function body does not contain return statements that both have
    * and do not have return values.
    *
    * @param node the function body being tested
    * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.MIXED_RETURN_TYPES].
    */
   bool _checkForMixedReturns(BlockFunctionBody node) {
     if (_hasReturnWithoutValue) {
       return false;
     }
     int withCount = _returnsWith.length;
     int withoutCount = _returnsWithout.length;
     if (withCount > 0 && withoutCount > 0) {
       for (int i = 0; i < withCount; i++) {
-        _errorReporter.reportErrorForToken(
-            StaticWarningCode.MIXED_RETURN_TYPES,
+        _errorReporter.reportErrorForToken(StaticWarningCode.MIXED_RETURN_TYPES,
             _returnsWith[i].returnKeyword);
       }
       for (int i = 0; i < withoutCount; i++) {
-        _errorReporter.reportErrorForToken(
-            StaticWarningCode.MIXED_RETURN_TYPES,
+        _errorReporter.reportErrorForToken(StaticWarningCode.MIXED_RETURN_TYPES,
             _returnsWithout[i].returnKeyword);
       }
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the passed mixin does not have an explicitly declared constructor.
    *
    * @param mixinName the node to report problem on
    * @param mixinElement the mixing to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR].
    */
-  bool _checkForMixinDeclaresConstructor(TypeName mixinName,
-      ClassElement mixinElement) {
+  bool _checkForMixinDeclaresConstructor(
+      TypeName mixinName, ClassElement mixinElement) {
     for (ConstructorElement constructor in mixinElement.constructors) {
       if (!constructor.isSynthetic && !constructor.isFactory) {
         _errorReporter.reportErrorForNode(
-            CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR,
-            mixinName,
-            [mixinElement.name]);
+            CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR, mixinName, [
+          mixinElement.name
+        ]);
         return true;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed mixin has the 'Object' superclass.
    *
    * @param mixinName the node to report problem on
    * @param mixinElement the mixing to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT].
    */
-  bool _checkForMixinInheritsNotFromObject(TypeName mixinName,
-      ClassElement mixinElement) {
+  bool _checkForMixinInheritsNotFromObject(
+      TypeName mixinName, ClassElement mixinElement) {
     InterfaceType mixinSupertype = mixinElement.supertype;
     if (mixinSupertype != null) {
       if (!mixinSupertype.isObject ||
           !mixinElement.isTypedef && mixinElement.mixins.length != 0) {
         _errorReporter.reportErrorForNode(
-            CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT,
-            mixinName,
-            [mixinElement.name]);
+            CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT, mixinName, [
+          mixinElement.name
+        ]);
         return true;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed mixin does not reference 'super'.
    *
    * @param mixinName the node to report problem on
    * @param mixinElement the mixing to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.MIXIN_REFERENCES_SUPER].
    */
-  bool _checkForMixinReferencesSuper(TypeName mixinName,
-      ClassElement mixinElement) {
+  bool _checkForMixinReferencesSuper(
+      TypeName mixinName, ClassElement mixinElement) {
     if (mixinElement.hasReferenceToSuper) {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.MIXIN_REFERENCES_SUPER,
-          mixinName,
-          [mixinElement.name]);
+          CompileTimeErrorCode.MIXIN_REFERENCES_SUPER, mixinName, [
+        mixinElement.name
+      ]);
     }
     return false;
   }
 
   /**
    * This verifies that the passed constructor has at most one 'super' initializer.
    *
    * @param node the constructor declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.MULTIPLE_SUPER_INITIALIZERS].
    */
   bool _checkForMultipleSuperInitializers(ConstructorDeclaration node) {
     int numSuperInitializers = 0;
     for (ConstructorInitializer initializer in node.initializers) {
       if (initializer is SuperConstructorInvocation) {
         numSuperInitializers++;
         if (numSuperInitializers > 1) {
           _errorReporter.reportErrorForNode(
-              CompileTimeErrorCode.MULTIPLE_SUPER_INITIALIZERS,
-              initializer);
+              CompileTimeErrorCode.MULTIPLE_SUPER_INITIALIZERS, initializer);
         }
       }
     }
     return numSuperInitializers > 0;
   }
 
   /**
    * Checks to ensure that native function bodies can only in SDK code.
    *
    * @param node the native function body to test
    * @return `true` if and only if an error code is generated on the passed node
    * See [ParserErrorCode.NATIVE_FUNCTION_BODY_IN_NON_SDK_CODE].
    */
   bool _checkForNativeFunctionBodyInNonSDKCode(NativeFunctionBody node) {
     if (!_isInSystemLibrary && !_hasExtUri) {
       _errorReporter.reportErrorForNode(
-          ParserErrorCode.NATIVE_FUNCTION_BODY_IN_NON_SDK_CODE,
-          node);
+          ParserErrorCode.NATIVE_FUNCTION_BODY_IN_NON_SDK_CODE, node);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the passed 'new' instance creation expression invokes existing constructor.
    *
    * This method assumes that the instance creation was tested to be 'new' before being called.
    *
@@ skipping 16 matching lines @@
         // We have already reported the error.
         return false;
       }
     }
     // prepare class name
     Identifier className = typeName.name;
     // report as named or default constructor absence
     SimpleIdentifier name = constructorName.name;
     if (name != null) {
       _errorReporter.reportErrorForNode(
-          StaticWarningCode.NEW_WITH_UNDEFINED_CONSTRUCTOR,
-          name,
-          [className, name]);
+          StaticWarningCode.NEW_WITH_UNDEFINED_CONSTRUCTOR, name, [
+        className,
+        name
+      ]);
     } else {
       _errorReporter.reportErrorForNode(
           StaticWarningCode.NEW_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT,
-          constructorName,
-          [className]);
+          constructorName, [className]);
     }
     return true;
   }
 
   /**
    * This checks that if the passed class declaration implicitly calls default constructor of its
    * superclass, there should be such default constructor - implicit or explicit.
    *
    * @param node the [ClassDeclaration] to evaluate
    * @return `true` if and only if an error code is generated on the passed node
@@ skipping 15 matching lines @@
     if (superType == null) {
       return false;
     }
     ClassElement superElement = superType.element;
     // try to find default generative super constructor
     ConstructorElement superUnnamedConstructor =
         superElement.unnamedConstructor;
     if (superUnnamedConstructor != null) {
       if (superUnnamedConstructor.isFactory) {
         _errorReporter.reportErrorForNode(
-            CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR,
-            node.name,
-            [superUnnamedConstructor]);
+            CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR, node.name, [
+          superUnnamedConstructor
+        ]);
         return true;
       }
       if (superUnnamedConstructor.isDefaultConstructor &&
-          _enclosingClass.isSuperConstructorAccessible(superUnnamedConstructor)) {
+          _enclosingClass
+              .isSuperConstructorAccessible(superUnnamedConstructor)) {
         return true;
       }
     }
     // report problem
     _errorReporter.reportErrorForNode(
-        CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT,
-        node.name,
-        [superType.displayName]);
+        CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT, node.name, [
+      superType.displayName
+    ]);
     return true;
   }
 
   /**
    * This checks that passed class declaration overrides all members required by its superclasses
    * and interfaces.
    *
    * @param classNameNode the [SimpleIdentifier] to be used if there is a violation, this is
    *          either the named from the [ClassDeclaration] or from the [ClassTypeAlias].
    * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE],
    * [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO],
    * [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_THREE],
    * [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FOUR], and
    * [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FIVE_PLUS].
    */
-  bool
-      _checkForNonAbstractClassInheritsAbstractMember(SimpleIdentifier classNameNode) {
+  bool _checkForNonAbstractClassInheritsAbstractMember(
+      SimpleIdentifier classNameNode) {
     if (_enclosingClass.isAbstract) {
       return false;
     }
     //
     // Store in local sets the set of all method and accessor names
     //
     MethodElement method =
         _enclosingClass.getMethod(FunctionElement.NO_SUCH_METHOD_METHOD_NAME);
     if (method != null) {
       // If the enclosing class declares the method noSuchMethod(), then return.
       // From Spec:  It is a static warning if a concrete class does not have an
       // implementation for a method in any of its superinterfaces unless it
       // declares its own noSuchMethod method (7.10).
       return false;
     }
     HashSet<ExecutableElement> missingOverrides =
         new HashSet<ExecutableElement>();
     //
     // Loop through the set of all executable elements declared in the implicit
     // interface.
     //
-    MemberMap membersInheritedFromInterfaces =
-        _inheritanceManager.getMapOfMembersInheritedFromInterfaces(_enclosingClass);
-    MemberMap membersInheritedFromSuperclasses =
-        _inheritanceManager.getMapOfMembersInheritedFromClasses(_enclosingClass);
+    MemberMap membersInheritedFromInterfaces = _inheritanceManager
+        .getMapOfMembersInheritedFromInterfaces(_enclosingClass);
+    MemberMap membersInheritedFromSuperclasses = _inheritanceManager
+        .getMapOfMembersInheritedFromClasses(_enclosingClass);
     for (int i = 0; i < membersInheritedFromInterfaces.size; i++) {
       String memberName = membersInheritedFromInterfaces.getKey(i);
       ExecutableElement executableElt =
           membersInheritedFromInterfaces.getValue(i);
       if (memberName == null) {
         break;
       }
       // If the element is not synthetic and can be determined to be defined in
       // Object, skip it.
       if (executableElt.enclosingElement != null &&
@@ skipping 27 matching lines @@
         // Some element was found in the superclass chain that matches the name
         // of the required member.
         // If it is not abstract and it is the correct one (types match- the
         // version of this method that we have has the correct number of
         // parameters, etc), then this class has a valid implementation of this
         // method, so skip it.
         if ((elt is MethodElement && !elt.isAbstract) ||
             (elt is PropertyAccessorElement && !elt.isAbstract)) {
           // Since we are comparing two function types, we need to do the
           // appropriate type substitutions first ().
-          FunctionType foundConcreteFT =
-              _inheritanceManager.substituteTypeArgumentsInMemberFromInheritance(
-                  concreteType,
-                  memberName,
-                  enclosingType);
-          FunctionType requiredMemberFT =
-              _inheritanceManager.substituteTypeArgumentsInMemberFromInheritance(
-                  requiredMemberType,
-                  memberName,
-                  enclosingType);
+          FunctionType foundConcreteFT = _inheritanceManager
+              .substituteTypeArgumentsInMemberFromInheritance(
+                  concreteType, memberName, enclosingType);
+          FunctionType requiredMemberFT = _inheritanceManager
+              .substituteTypeArgumentsInMemberFromInheritance(
+                  requiredMemberType, memberName, enclosingType);
           if (foundConcreteFT.isSubtypeOf(requiredMemberFT)) {
             continue;
           }
         }
       }
       // The not qualifying concrete executable element was found, add it to the
       // list.
       missingOverrides.add(executableElt);
     }
     // Now that we have the set of missing overrides, generate a warning on this
@@ skipping 26 matching lines @@
       } else {
         newStrMember = "$prefix'${missingOverridesArray[i].displayName}'";
       }
       stringMembersArrayListSet.add(newStrMember);
     }
     List<String> stringMembersArray = new List.from(stringMembersArrayListSet);
     AnalysisErrorWithProperties analysisError;
     if (stringMembersArray.length == 1) {
       analysisError = _errorReporter.newErrorWithProperties(
           StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE,
-          classNameNode,
-          [stringMembersArray[0]]);
+          classNameNode, [stringMembersArray[0]]);
     } else if (stringMembersArray.length == 2) {
       analysisError = _errorReporter.newErrorWithProperties(
           StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO,
-          classNameNode,
-          [stringMembersArray[0], stringMembersArray[1]]);
+          classNameNode, [stringMembersArray[0], stringMembersArray[1]]);
     } else if (stringMembersArray.length == 3) {
       analysisError = _errorReporter.newErrorWithProperties(
           StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_THREE,
-          classNameNode,
-          [stringMembersArray[0], stringMembersArray[1], stringMembersArray[2]]);
+          classNameNode, [
+        stringMembersArray[0],
+        stringMembersArray[1],
+        stringMembersArray[2]
+      ]);
     } else if (stringMembersArray.length == 4) {
       analysisError = _errorReporter.newErrorWithProperties(
           StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FOUR,
-          classNameNode,
-          [
-              stringMembersArray[0],
-              stringMembersArray[1],
-              stringMembersArray[2],
-              stringMembersArray[3]]);
+          classNameNode, [
+        stringMembersArray[0],
+        stringMembersArray[1],
+        stringMembersArray[2],
+        stringMembersArray[3]
+      ]);
     } else {
       analysisError = _errorReporter.newErrorWithProperties(
           StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FIVE_PLUS,
-          classNameNode,
-          [
-              stringMembersArray[0],
-              stringMembersArray[1],
-              stringMembersArray[2],
-              stringMembersArray[3],
-              stringMembersArray.length - 4]);
+          classNameNode, [
+        stringMembersArray[0],
+        stringMembersArray[1],
+        stringMembersArray[2],
+        stringMembersArray[3],
+        stringMembersArray.length - 4
+      ]);
     }
     analysisError.setProperty(
-        ErrorProperty.UNIMPLEMENTED_METHODS,
-        missingOverridesArray);
+        ErrorProperty.UNIMPLEMENTED_METHODS, missingOverridesArray);
     _errorReporter.reportError(analysisError);
     return true;
   }
 
   /**
    * Checks to ensure that the expressions that need to be of type bool, are. Otherwise an error is
    * reported on the expression.
    *
    * @param condition the conditional expression to test
    * @return `true` if and only if an error code is generated on the passed node
    * See [StaticTypeWarningCode.NON_BOOL_CONDITION].
    */
   bool _checkForNonBoolCondition(Expression condition) {
     DartType conditionType = getStaticType(condition);
     if (conditionType != null && !conditionType.isAssignableTo(_boolType)) {
       _errorReporter.reportErrorForNode(
-          StaticTypeWarningCode.NON_BOOL_CONDITION,
-          condition);
+          StaticTypeWarningCode.NON_BOOL_CONDITION, condition);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the passed assert statement has either a 'bool' or '() -> bool' input.
    *
    * @param node the assert statement to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [StaticTypeWarningCode.NON_BOOL_EXPRESSION].
    */
   bool _checkForNonBoolExpression(AssertStatement node) {
     Expression expression = node.condition;
     DartType type = getStaticType(expression);
     if (type is InterfaceType) {
       if (!type.isAssignableTo(_boolType)) {
         _errorReporter.reportErrorForNode(
-            StaticTypeWarningCode.NON_BOOL_EXPRESSION,
-            expression);
+            StaticTypeWarningCode.NON_BOOL_EXPRESSION, expression);
         return true;
       }
     } else if (type is FunctionType) {
       FunctionType functionType = type;
       if (functionType.typeArguments.length == 0 &&
           !functionType.returnType.isAssignableTo(_boolType)) {
         _errorReporter.reportErrorForNode(
-            StaticTypeWarningCode.NON_BOOL_EXPRESSION,
-            expression);
+            StaticTypeWarningCode.NON_BOOL_EXPRESSION, expression);
         return true;
       }
     }
     return false;
   }
 
   /**
    * Checks to ensure that the given expression is assignable to bool.
    *
    * @param expression the expression expression to test
    * @return `true` if and only if an error code is generated on the passed node
    * See [StaticTypeWarningCode.NON_BOOL_NEGATION_EXPRESSION].
    */
   bool _checkForNonBoolNegationExpression(Expression expression) {
     DartType conditionType = getStaticType(expression);
     if (conditionType != null && !conditionType.isAssignableTo(_boolType)) {
       _errorReporter.reportErrorForNode(
-          StaticTypeWarningCode.NON_BOOL_NEGATION_EXPRESSION,
-          expression);
+          StaticTypeWarningCode.NON_BOOL_NEGATION_EXPRESSION, expression);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies the passed map literal either:
    * * has `const modifier`
    * * has explicit type arguments
    * * is not start of the statement
@@ skipping 16 matching lines @@
         node.getAncestor((node) => node is ExpressionStatement);
     if (statement == null) {
       return false;
     }
     // OK, statement does not start with map
     if (!identical(statement.beginToken, node.beginToken)) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(
-        CompileTimeErrorCode.NON_CONST_MAP_AS_EXPRESSION_STATEMENT,
-        node);
+        CompileTimeErrorCode.NON_CONST_MAP_AS_EXPRESSION_STATEMENT, node);
     return true;
   }
 
   /**
    * This verifies the passed method declaration of operator `[]=`, has `void` return
    * type.
    *
    * @param node the method declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.NON_VOID_RETURN_FOR_OPERATOR].
    */
   bool _checkForNonVoidReturnTypeForOperator(MethodDeclaration node) {
     // check that []= operator
     SimpleIdentifier name = node.name;
     if (name.name != "[]=") {
       return false;
     }
     // check return type
     TypeName typeName = node.returnType;
     if (typeName != null) {
       DartType type = typeName.type;
       if (type != null && !type.isVoid) {
         _errorReporter.reportErrorForNode(
-            StaticWarningCode.NON_VOID_RETURN_FOR_OPERATOR,
-            typeName);
+            StaticWarningCode.NON_VOID_RETURN_FOR_OPERATOR, typeName);
       }
     }
     // no warning
     return false;
   }
 
   /**
    * This verifies the passed setter has no return type or the `void` return type.
    *
    * @param typeName the type name to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.NON_VOID_RETURN_FOR_SETTER].
    */
   bool _checkForNonVoidReturnTypeForSetter(TypeName typeName) {
     if (typeName != null) {
       DartType type = typeName.type;
       if (type != null && !type.isVoid) {
         _errorReporter.reportErrorForNode(
-            StaticWarningCode.NON_VOID_RETURN_FOR_SETTER,
-            typeName);
+            StaticWarningCode.NON_VOID_RETURN_FOR_SETTER, typeName);
       }
     }
     return false;
   }
 
   /**
    * This verifies the passed operator-method declaration, does not have an optional parameter.
    *
    * This method assumes that the method declaration was tested to be an operator declaration before
    * being called.
@@ skipping 32 matching lines @@
     if (node.kind != ParameterKind.NAMED) {
       return false;
     }
     // name should start with '_'
     SimpleIdentifier name = node.identifier;
     if (name.isSynthetic || !StringUtilities.startsWithChar(name.name, 0x5F)) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(
-        CompileTimeErrorCode.PRIVATE_OPTIONAL_PARAMETER,
-        node);
+        CompileTimeErrorCode.PRIVATE_OPTIONAL_PARAMETER, node);
     return true;
   }
 
   /**
    * This checks if the passed constructor declaration is the redirecting generative constructor and
    * references itself directly or indirectly.
    *
    * @param node the constructor declaration to evaluate
    * @param constructorElement the constructor element
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.RECURSIVE_CONSTRUCTOR_REDIRECT].
    */
-  bool _checkForRecursiveConstructorRedirect(ConstructorDeclaration node,
-      ConstructorElement constructorElement) {
+  bool _checkForRecursiveConstructorRedirect(
+      ConstructorDeclaration node, ConstructorElement constructorElement) {
     // we check generative constructor here
     if (node.factoryKeyword != null) {
       return false;
     }
     // try to find redirecting constructor invocation and analyzer it for
     // recursion
     for (ConstructorInitializer initializer in node.initializers) {
       if (initializer is RedirectingConstructorInvocation) {
         // OK if no cycle
         if (!_hasRedirectingFactoryConstructorCycle(constructorElement)) {
           return false;
         }
         // report error
         _errorReporter.reportErrorForNode(
-            CompileTimeErrorCode.RECURSIVE_CONSTRUCTOR_REDIRECT,
-            initializer);
+            CompileTimeErrorCode.RECURSIVE_CONSTRUCTOR_REDIRECT, initializer);
         return true;
       }
     }
     // OK, no redirecting constructor invocation
     return false;
   }
 
   /**
    * This checks if the passed constructor declaration has redirected constructor and references
    * itself directly or indirectly.
    *
    * @param node the constructor declaration to evaluate
    * @param constructorElement the constructor element
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT].
    */
-  bool _checkForRecursiveFactoryRedirect(ConstructorDeclaration node,
-      ConstructorElement constructorElement) {
+  bool _checkForRecursiveFactoryRedirect(
+      ConstructorDeclaration node, ConstructorElement constructorElement) {
     // prepare redirected constructor
     ConstructorName redirectedConstructorNode = node.redirectedConstructor;
     if (redirectedConstructorNode == null) {
       return false;
     }
     // OK if no cycle
     if (!_hasRedirectingFactoryConstructorCycle(constructorElement)) {
       return false;
     }
     // report error
@@ skipping 10 matching lines @@
    * @return `true` if and only if an error code is generated on the passed element
    * See [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE],
    * [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS], and
    * [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS].
    */
   bool _checkForRecursiveInterfaceInheritance(ClassElement classElt) {
     if (classElt == null) {
       return false;
     }
     return _safeCheckForRecursiveInterfaceInheritance(
-        classElt,
-        new List<ClassElement>());
+        classElt, new List<ClassElement>());
   }
 
   /**
    * This checks the passed constructor declaration has a valid combination of redirected
    * constructor invocation(s), super constructor invocations and field initializers.
    *
    * @param node the constructor declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.DEFAULT_VALUE_IN_REDIRECTING_FACTORY_CONSTRUCTOR],
    * [CompileTimeErrorCode.FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR],
@@ skipping 32 matching lines @@
           RedirectingConstructorInvocation invocation = initializer;
           ConstructorElement redirectingElement = invocation.staticElement;
           if (redirectingElement == null) {
             String enclosingTypeName = _enclosingClass.displayName;
             String constructorStrName = enclosingTypeName;
             if (invocation.constructorName != null) {
               constructorStrName += ".${invocation.constructorName.name}";
             }
             _errorReporter.reportErrorForNode(
                 CompileTimeErrorCode.REDIRECT_GENERATIVE_TO_MISSING_CONSTRUCTOR,
-                invocation,
-                [constructorStrName, enclosingTypeName]);
+                invocation, [constructorStrName, enclosingTypeName]);
           } else {
             if (redirectingElement.isFactory) {
               _errorReporter.reportErrorForNode(
                   CompileTimeErrorCode.REDIRECT_GENERATIVE_TO_NON_GENERATIVE_CONSTRUCTOR,
                   initializer);
             }
           }
         }
         numRedirections++;
       }
@@ skipping 21 matching lines @@
 
   /**
    * This checks if the passed constructor declaration has redirected constructor and references
    * itself directly or indirectly.
    *
    * @param node the constructor declaration to evaluate
    * @param constructorElement the constructor element
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.REDIRECT_TO_NON_CONST_CONSTRUCTOR].
    */
-  bool _checkForRedirectToNonConstConstructor(ConstructorDeclaration node,
-      ConstructorElement constructorElement) {
+  bool _checkForRedirectToNonConstConstructor(
+      ConstructorDeclaration node, ConstructorElement constructorElement) {
     // prepare redirected constructor
     ConstructorName redirectedConstructorNode = node.redirectedConstructor;
     if (redirectedConstructorNode == null) {
       return false;
     }
     // prepare element
     if (constructorElement == null) {
       return false;
     }
     // OK, it is not 'const'
@@ skipping 20 matching lines @@
   /**
    * This checks that the rethrow is inside of a catch clause.
    *
    * @param node the rethrow expression to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.RETHROW_OUTSIDE_CATCH].
    */
   bool _checkForRethrowOutsideCatch(RethrowExpression node) {
     if (!_isInCatchClause) {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.RETHROW_OUTSIDE_CATCH,
-          node);
+          CompileTimeErrorCode.RETHROW_OUTSIDE_CATCH, node);
       return true;
     }
     return false;
   }
 
   /**
    * This checks that if the the given constructor declaration is generative, then it does not have
    * an expression function body.
    *
    * @param node the constructor to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.RETURN_IN_GENERATIVE_CONSTRUCTOR].
    */
   bool _checkForReturnInGenerativeConstructor(ConstructorDeclaration node) {
     // ignore factory
     if (node.factoryKeyword != null) {
       return false;
     }
     // block body (with possible return statement) is checked elsewhere
     FunctionBody body = node.body;
     if (body is! ExpressionFunctionBody) {
       return false;
     }
     // report error
     _errorReporter.reportErrorForNode(
-        CompileTimeErrorCode.RETURN_IN_GENERATIVE_CONSTRUCTOR,
-        body);
+        CompileTimeErrorCode.RETURN_IN_GENERATIVE_CONSTRUCTOR, body);
     return true;
   }
 
   /**
    * This checks that a type mis-match between the return type and the expressed return type by the
    * enclosing method or function.
    *
    * This method is called both by [checkForAllReturnStatementErrorCodes]
    * and [visitExpressionFunctionBody].
    *
    * @param returnExpression the returned expression to evaluate
    * @param expectedReturnType the expressed return type by the enclosing method or function
    * @return `true` if and only if an error code is generated on the passed node
    * See [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE].
    */
-  bool _checkForReturnOfInvalidType(Expression returnExpression,
-      DartType expectedReturnType) {
+  bool _checkForReturnOfInvalidType(
+      Expression returnExpression, DartType expectedReturnType) {
     if (_enclosingFunction == null) {
       return false;
     }
     if (_inGenerator) {
       // "return expression;" is disallowed in generators, but this is checked
       // elsewhere.  Bare "return" is always allowed in generators regardless
       // of the return type.  So no need to do any further checking.
       return false;
     }
     DartType staticReturnType = _computeReturnTypeForMethod(returnExpression);
     if (expectedReturnType.isVoid) {
       if (staticReturnType.isVoid ||
           staticReturnType.isDynamic ||
           staticReturnType.isBottom) {
         return false;
       }
       _errorReporter.reportTypeErrorForNode(
-          StaticTypeWarningCode.RETURN_OF_INVALID_TYPE,
-          returnExpression,
-          [staticReturnType, expectedReturnType, _enclosingFunction.displayName]);
+          StaticTypeWarningCode.RETURN_OF_INVALID_TYPE, returnExpression, [
+        staticReturnType,
+        expectedReturnType,
+        _enclosingFunction.displayName
+      ]);
       return true;
     }
     if (staticReturnType.isAssignableTo(expectedReturnType)) {
       return false;
     }
     _errorReporter.reportTypeErrorForNode(
-        StaticTypeWarningCode.RETURN_OF_INVALID_TYPE,
-        returnExpression,
-        [staticReturnType, expectedReturnType, _enclosingFunction.displayName]);
+        StaticTypeWarningCode.RETURN_OF_INVALID_TYPE, returnExpression, [
+      staticReturnType,
+      expectedReturnType,
+      _enclosingFunction.displayName
+    ]);
     return true;
     // TODO(brianwilkerson) Define a hint corresponding to the warning and
     // report it if appropriate.
 //        Type propagatedReturnType = returnExpression.getPropagatedType();
 //        boolean isPropagatedAssignable = propagatedReturnType.isAssignableTo(expectedReturnType);
 //        if (isStaticAssignable || isPropagatedAssignable) {
 //          return false;
 //        }
 //        errorReporter.reportTypeErrorForNode(
 //            StaticTypeWarningCode.RETURN_OF_INVALID_TYPE,
 //            returnExpression,
 //            staticReturnType,
 //            expectedReturnType,
 //            enclosingFunction.getDisplayName());
 //        return true;
   }
 
   /**
    * This checks the given "typeReference" and that the "name" is not the reference to an instance
    * member.
    *
    * @param typeReference the resolved [ClassElement] of the left hand side of the expression,
    *          or `null`, aka, the class element of 'C' in 'C.x', see
    *          [getTypeReference]
    * @param name the accessed name to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER].
    */
-  bool _checkForStaticAccessToInstanceMember(ClassElement typeReference,
-      SimpleIdentifier name) {
+  bool _checkForStaticAccessToInstanceMember(
+      ClassElement typeReference, SimpleIdentifier name) {
     // OK, target is not a type
     if (typeReference == null) {
       return false;
     }
     // prepare member Element
     Element element = name.staticElement;
     if (element is! ExecutableElement) {
       return false;
     }
     ExecutableElement memberElement = element as ExecutableElement;
     // OK, static
     if (memberElement.isStatic) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(
-        StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER,
-        name,
-        [name.name]);
+        StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER, name, [name.name]);
     return true;
   }
 
   /**
    * This checks that the type of the passed 'switch' expression is assignable to the type of the
    * 'case' members.
    *
    * @param node the 'switch' statement to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.SWITCH_EXPRESSION_NOT_ASSIGNABLE].
@@ skipping 14 matching lines @@
       SwitchCase switchCase = switchMember as SwitchCase;
       // prepare 'case' type
       Expression caseExpression = switchCase.expression;
       DartType caseType = getStaticType(caseExpression);
       // check types
       if (expressionType.isAssignableTo(caseType)) {
         return false;
       }
       // report problem
       _errorReporter.reportErrorForNode(
-          StaticWarningCode.SWITCH_EXPRESSION_NOT_ASSIGNABLE,
-          expression,
-          [expressionType, caseType]);
+          StaticWarningCode.SWITCH_EXPRESSION_NOT_ASSIGNABLE, expression, [
+        expressionType,
+        caseType
+      ]);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the passed function type alias does not reference itself directly.
    *
    * @param node the function type alias to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF].
    */
-  bool
-      _checkForTypeAliasCannotReferenceItself_function(FunctionTypeAlias node) {
+  bool _checkForTypeAliasCannotReferenceItself_function(
+      FunctionTypeAlias node) {
     FunctionTypeAliasElement element = node.element;
     if (!_hasTypedefSelfReference(element)) {
       return false;
     }
     _errorReporter.reportErrorForNode(
-        CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF,
-        node);
+        CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF, node);
     return true;
   }
 
   /**
    * This verifies that the passed type name is not a deferred type.
    *
    * @param expression the expression to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS].
    */
   bool _checkForTypeAnnotationDeferredClass(TypeName node) {
     if (node != null && node.isDeferred) {
       _errorReporter.reportErrorForNode(
-          StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS,
-          node,
-          [node.name]);
+          StaticWarningCode.TYPE_ANNOTATION_DEFERRED_CLASS, node, [node.name]);
     }
     return false;
   }
 
   /**
    * This verifies that the type arguments in the passed type name are all within their bounds.
    *
    * @param node the [TypeName] to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS].
@@ skipping 32 matching lines @@
           boundType = boundType.substitute2(typeArguments, typeParameters);
         }
         if (!argType.isSubtypeOf(boundType)) {
           ErrorCode errorCode;
           if (_isInConstInstanceCreation) {
             errorCode = CompileTimeErrorCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS;
           } else {
             errorCode = StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS;
           }
           _errorReporter.reportTypeErrorForNode(
-              errorCode,
-              argTypeName,
-              [argType, boundType]);
+              errorCode, argTypeName, [argType, boundType]);
           foundError = true;
         }
       }
     }
     return foundError;
   }
 
   /**
    * This checks that if the passed type name is a type parameter being used to define a static
    * member.
    *
    * @param node the type name to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC].
    */
   bool _checkForTypeParameterReferencedByStatic(TypeName node) {
     if (_isInStaticMethod || _isInStaticVariableDeclaration) {
       DartType type = node.type;
       if (type is TypeParameterType) {
         _errorReporter.reportErrorForNode(
-            StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC,
-            node);
+            StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC, node);
         return true;
       }
     }
     return false;
   }
 
   /**
    * This checks that if the passed type parameter is a supertype of its bound.
    *
    * @param node the type parameter to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [StaticTypeWarningCode.TYPE_PARAMETER_SUPERTYPE_OF_ITS_BOUND].
    */
   bool _checkForTypeParameterSupertypeOfItsBound(TypeParameter node) {
     TypeParameterElement element = node.element;
     // prepare bound
     DartType bound = element.bound;
     if (bound == null) {
       return false;
     }
     // OK, type parameter is not supertype of its bound
     if (!bound.isMoreSpecificThan(element.type)) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(
-        StaticTypeWarningCode.TYPE_PARAMETER_SUPERTYPE_OF_ITS_BOUND,
-        node,
-        [element.displayName]);
+        StaticTypeWarningCode.TYPE_PARAMETER_SUPERTYPE_OF_ITS_BOUND, node, [
+      element.displayName
+    ]);
     return true;
   }
 
   /**
    * This checks that if the passed generative constructor has neither an explicit super constructor
    * invocation nor a redirecting constructor invocation, that the superclass has a default
    * generative constructor.
    *
    * @param node the constructor declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT],
    * [CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR], and
    * [StaticWarningCode.NO_DEFAULT_SUPER_CONSTRUCTOR_EXPLICIT].
    */
-  bool
-      _checkForUndefinedConstructorInInitializerImplicit(ConstructorDeclaration node) {
+  bool _checkForUndefinedConstructorInInitializerImplicit(
+      ConstructorDeclaration node) {
     if (_enclosingClass == null) {
       return false;
     }
     // do nothing if mixin errors have already been reported for this class.
     ClassElementImpl enclosingClass = _enclosingClass;
     if (enclosingClass.mixinErrorsReported) {
       return false;
     }
     //
     // Ignore if the constructor is not generative.
@@ skipping 18 matching lines @@
     InterfaceType superType = _enclosingClass.supertype;
     if (superType == null) {
       return false;
     }
     ClassElement superElement = superType.element;
     ConstructorElement superUnnamedConstructor =
         superElement.unnamedConstructor;
     if (superUnnamedConstructor != null) {
       if (superUnnamedConstructor.isFactory) {
         _errorReporter.reportErrorForNode(
-            CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR,
-            node.returnType,
-            [superUnnamedConstructor]);
+            CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR, node.returnType, [
+          superUnnamedConstructor
+        ]);
         return true;
       }
       if (!superUnnamedConstructor.isDefaultConstructor ||
-          !_enclosingClass.isSuperConstructorAccessible(superUnnamedConstructor)) {
+          !_enclosingClass
+              .isSuperConstructorAccessible(superUnnamedConstructor)) {
         int offset;
         int length;
         {
           Identifier returnType = node.returnType;
           SimpleIdentifier name = node.name;
           offset = returnType.offset;
           length = (name != null ? name.end : returnType.end) - offset;
         }
         _errorReporter.reportErrorForOffset(
-            CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_EXPLICIT,
-            offset,
-            length,
-            [superType.displayName]);
+            CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_EXPLICIT, offset,
+            length, [superType.displayName]);
       }
       return false;
     }
     _errorReporter.reportErrorForNode(
         CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT,
-        node.returnType,
-        [superElement.name]);
+        node.returnType, [superElement.name]);
     return true;
   }
 
   /**
    * This checks that if the given name is a reference to a static member it is defined in the
    * enclosing class rather than in a superclass.
    *
    * @param name the name to be evaluated
    * @return `true` if and only if an error code is generated on the passed node
    * See [StaticTypeWarningCode.UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_MEMBER].
    */
-  bool
-      _checkForUnqualifiedReferenceToNonLocalStaticMember(SimpleIdentifier name) {
+  bool _checkForUnqualifiedReferenceToNonLocalStaticMember(
+      SimpleIdentifier name) {
     Element element = name.staticElement;
     if (element == null || element is TypeParameterElement) {
       return false;
     }
     Element enclosingElement = element.enclosingElement;
     if (enclosingElement is! ClassElement) {
       return false;
     }
     if ((element is MethodElement && !element.isStatic) ||
         (element is PropertyAccessorElement && !element.isStatic)) {
       return false;
     }
     if (identical(enclosingElement, _enclosingClass)) {
       return false;
     }
     _errorReporter.reportErrorForNode(
         StaticTypeWarningCode.UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_MEMBER,
-        name,
-        [name.name]);
+        name, [name.name]);
     return true;
   }
 
   void _checkForValidField(FieldFormalParameter node) {
     ParameterElement element = node.element;
     if (element is FieldFormalParameterElement) {
       FieldElement fieldElement = element.field;
       if (fieldElement == null || fieldElement.isSynthetic) {
         _errorReporter.reportErrorForNode(
             CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTENT_FIELD,
-            node,
-            [node.identifier.name]);
+            node, [node.identifier.name]);
       } else {
         ParameterElement parameterElement = node.element;
         if (parameterElement is FieldFormalParameterElementImpl) {
           FieldFormalParameterElementImpl fieldFormal = parameterElement;
           DartType declaredType = fieldFormal.type;
           DartType fieldType = fieldElement.type;
           if (fieldElement.isSynthetic) {
             _errorReporter.reportErrorForNode(
                 CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTENT_FIELD,
-                node,
-                [node.identifier.name]);
+                node, [node.identifier.name]);
           } else if (fieldElement.isStatic) {
             _errorReporter.reportErrorForNode(
-                CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_STATIC_FIELD,
-                node,
+                CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_STATIC_FIELD, node,
                 [node.identifier.name]);
           } else if (declaredType != null &&
               fieldType != null &&
               !declaredType.isAssignableTo(fieldType)) {
             _errorReporter.reportTypeErrorForNode(
                 StaticWarningCode.FIELD_INITIALIZING_FORMAL_NOT_ASSIGNABLE,
-                node,
-                [declaredType, fieldType]);
+                node, [declaredType, fieldType]);
           }
         } else {
           if (fieldElement.isSynthetic) {
             _errorReporter.reportErrorForNode(
                 CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTENT_FIELD,
-                node,
-                [node.identifier.name]);
+                node, [node.identifier.name]);
           } else if (fieldElement.isStatic) {
             _errorReporter.reportErrorForNode(
-                CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_STATIC_FIELD,
-                node,
+                CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_STATIC_FIELD, node,
                 [node.identifier.name]);
           }
         }
       }
     }
 //        else {
 //        // TODO(jwren) Report error, constructor initializer variable is a top level element
 //        // (Either here or in ErrorVerifier.checkForAllFinalInitializedErrorCodes)
 //        }
   }
 
   /**
    * This verifies that the given getter does not have a return type of 'void'.
    *
    * @param node the method declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.VOID_RETURN_FOR_GETTER].
    */
   bool _checkForVoidReturnType(MethodDeclaration node) {
     TypeName returnType = node.returnType;
     if (returnType == null || returnType.name.name != "void") {
       return false;
     }
     _errorReporter.reportErrorForNode(
-        StaticWarningCode.VOID_RETURN_FOR_GETTER,
-        returnType);
+        StaticWarningCode.VOID_RETURN_FOR_GETTER, returnType);
     return true;
   }
 
   /**
    * This verifies the passed operator-method declaration, has correct number of parameters.
    *
    * This method assumes that the method declaration was tested to be an operator declaration before
    * being called.
    *
    * @param node the method declaration to evaluate
@@ skipping 33 matching lines @@
         "<<" == name ||
         ">>" == name ||
         "[]" == name) {
       expected = 1;
     } else if ("~" == name) {
       expected = 0;
     }
     if (expected != -1 && numParameters != expected) {
       _errorReporter.reportErrorForNode(
           CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR,
-          nameNode,
-          [name, expected, numParameters]);
+          nameNode, [name, expected, numParameters]);
       return true;
     }
     // check for operator "-"
     if ("-" == name && numParameters > 1) {
       _errorReporter.reportErrorForNode(
           CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR_MINUS,
-          nameNode,
-          [numParameters]);
+          nameNode, [numParameters]);
       return true;
     }
     // OK
     return false;
   }
 
   /**
    * This verifies if the passed setter parameter list have only one required parameter.
    *
    * This method assumes that the method declaration was tested to be a setter before being called.
    *
    * @param setterName the name of the setter to report problems on
    * @param parameterList the parameter list to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER].
    */
-  bool _checkForWrongNumberOfParametersForSetter(SimpleIdentifier setterName,
-      FormalParameterList parameterList) {
+  bool _checkForWrongNumberOfParametersForSetter(
+      SimpleIdentifier setterName, FormalParameterList parameterList) {
     if (setterName == null) {
       return false;
     }
     if (parameterList == null) {
       return false;
     }
     NodeList<FormalParameter> parameters = parameterList.parameters;
     if (parameters.length != 1 ||
         parameters[0].kind != ParameterKind.REQUIRED) {
       _errorReporter.reportErrorForNode(
           CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER,
           setterName);
       return true;
     }
     return false;
   }
 
   /**
    * Check for a type mis-match between the yielded type and the declared
    * return type of a generator function.
    *
    * This method should only be called in generator functions.
    */
-  bool _checkForYieldOfInvalidType(Expression yieldExpression,
-      bool isYieldEach) {
+  bool _checkForYieldOfInvalidType(
+      Expression yieldExpression, bool isYieldEach) {
     assert(_inGenerator);
     if (_enclosingFunction == null) {
       return false;
     }
     DartType declaredReturnType = _enclosingFunction.returnType;
     DartType staticYieldedType = getStaticType(yieldExpression);
     DartType impliedReturnType;
     if (isYieldEach) {
       impliedReturnType = staticYieldedType;
     } else if (_enclosingFunction.isAsynchronous) {
       impliedReturnType =
           _typeProvider.streamType.substitute4(<DartType>[staticYieldedType]);
     } else {
       impliedReturnType =
           _typeProvider.iterableType.substitute4(<DartType>[staticYieldedType]);
     }
     if (!impliedReturnType.isAssignableTo(declaredReturnType)) {
       _errorReporter.reportTypeErrorForNode(
-          StaticTypeWarningCode.YIELD_OF_INVALID_TYPE,
-          yieldExpression,
-          [impliedReturnType, declaredReturnType]);
+          StaticTypeWarningCode.YIELD_OF_INVALID_TYPE, yieldExpression, [
+        impliedReturnType,
+        declaredReturnType
+      ]);
       return true;
     }
     if (isYieldEach) {
       // Since the declared return type might have been "dynamic", we need to
       // also check that the implied return type is assignable to generic
       // Stream/Iterable.
       DartType requiredReturnType;
       if (_enclosingFunction.isAsynchronous) {
         requiredReturnType = _typeProvider.streamDynamicType;
       } else {
         requiredReturnType = _typeProvider.iterableDynamicType;
       }
       if (!impliedReturnType.isAssignableTo(requiredReturnType)) {
         _errorReporter.reportTypeErrorForNode(
-            StaticTypeWarningCode.YIELD_OF_INVALID_TYPE,
-            yieldExpression,
-            [impliedReturnType, requiredReturnType]);
+            StaticTypeWarningCode.YIELD_OF_INVALID_TYPE, yieldExpression, [
+          impliedReturnType,
+          requiredReturnType
+        ]);
         return true;
       }
     }
     return false;
   }
 
   /**
    * This verifies that if the given class declaration implements the class Function that it has a
    * concrete implementation of the call method.
    *
@@ skipping 16 matching lines @@
     if (classElement.getMethod(FunctionElement.NO_SUCH_METHOD_METHOD_NAME) !=
         null) {
       return false;
     }
     ExecutableElement callMethod =
         _inheritanceManager.lookupMember(classElement, "call");
     if (callMethod == null ||
         callMethod is! MethodElement ||
         (callMethod as MethodElement).isAbstract) {
       _errorReporter.reportErrorForNode(
-          StaticWarningCode.FUNCTION_WITHOUT_CALL,
-          node.name);
+          StaticWarningCode.FUNCTION_WITHOUT_CALL, node.name);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the given class declaration does not have the same class in the 'extends'
    * and 'implements' clauses.
    *
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.IMPLEMENTS_SUPER_CLASS].
    */
   bool _checkImplementsSuperClass(ClassDeclaration node) {
     // prepare super type
     InterfaceType superType = _enclosingClass.supertype;
     if (superType == null) {
       return false;
     }
     // prepare interfaces
     ImplementsClause implementsClause = node.implementsClause;
     if (implementsClause == null) {
       return false;
     }
     // check interfaces
     bool hasProblem = false;
     for (TypeName interfaceNode in implementsClause.interfaces) {
       if (interfaceNode.type == superType) {
         hasProblem = true;
         _errorReporter.reportErrorForNode(
-            CompileTimeErrorCode.IMPLEMENTS_SUPER_CLASS,
-            interfaceNode,
+            CompileTimeErrorCode.IMPLEMENTS_SUPER_CLASS, interfaceNode,
             [superType.displayName]);
       }
     }
     // done
     return hasProblem;
   }
 
   DartType _computeReturnTypeForMethod(Expression returnExpression) {
     // This method should never be called for generators, since generators are
     // never allowed to contain return statements with expressions.
     assert(!_inGenerator);
     if (returnExpression == null) {
       if (_enclosingFunction.isAsynchronous) {
         return _typeProvider.futureNullType;
       } else {
         return VoidTypeImpl.instance;
       }
     }
     DartType staticReturnType = getStaticType(returnExpression);
     if (staticReturnType != null && _enclosingFunction.isAsynchronous) {
-      return _typeProvider.futureType.substitute4(
-          <DartType>[StaticTypeAnalyzer.flattenFutures(_typeProvider, staticReturnType)]);
+      return _typeProvider.futureType.substitute4(<DartType>[
+        StaticTypeAnalyzer.flattenFutures(_typeProvider, staticReturnType)
+      ]);
     }
     return staticReturnType;
   }
 
   /**
    * Return the error code that should be used when the given class references itself directly.
    *
    * @param classElt the class that references itself
    * @return the error code that should be used
    */
   ErrorCode _getBaseCaseErrorCode(ClassElement classElt) {
     InterfaceType supertype = classElt.supertype;
     if (supertype != null && _enclosingClass == supertype.element) {
-      return
-          CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS;
+      return CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS;
     }
     List<InterfaceType> mixins = classElt.mixins;
     for (int i = 0; i < mixins.length; i++) {
       if (_enclosingClass == mixins[i].element) {
-        return
-            CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_WITH;
+        return CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_WITH;
       }
     }
-    return
-        CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS;
+    return CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS;
   }
 
   /**
    * Given an expression in a switch case whose value is expected to be an enum constant, return the
    * name of the constant.
    *
    * @param expression the expression from the switch case
    * @return the name of the constant referenced by the expression
    */
   String _getConstantName(Expression expression) {
@@ skipping 50 matching lines @@
    * See [CompileTimeErrorCode.SHARED_DEFERRED_PREFIX].
    */
   bool _hasDeferredPrefixCollision(List<ImportDirective> directives) {
     bool foundError = false;
     int count = directives.length;
     if (count > 1) {
       for (int i = 0; i < count; i++) {
         sc.Token deferredToken = directives[i].deferredKeyword;
         if (deferredToken != null) {
           _errorReporter.reportErrorForToken(
-              CompileTimeErrorCode.SHARED_DEFERRED_PREFIX,
-              deferredToken);
+              CompileTimeErrorCode.SHARED_DEFERRED_PREFIX, deferredToken);
           foundError = true;
         }
       }
     }
     return foundError;
   }
 
   /**
    * @return `true` if the given constructor redirects to itself, directly or indirectly
    */
@@ skipping 14 matching lines @@
   }
 
   /**
    * @return <code>true</code> if given [Element] has direct or indirect reference to itself
    *         from anywhere except [ClassElement] or type parameter bounds.
    */
   bool _hasTypedefSelfReference(Element target) {
     Set<Element> checked = new HashSet<Element>();
     List<Element> toCheck = new List<Element>();
     GeneralizingElementVisitor_ErrorVerifier_hasTypedefSelfReference elementVisitor =
-        new GeneralizingElementVisitor_ErrorVerifier_hasTypedefSelfReference(toCheck);
+        new GeneralizingElementVisitor_ErrorVerifier_hasTypedefSelfReference(
+            toCheck);
     toCheck.add(target);
     bool firstIteration = true;
     while (true) {
       Element current;
       // get next element
       while (true) {
         // may be no more elements to check
         if (toCheck.isEmpty) {
           return false;
         }
@@ skipping 36 matching lines @@
    * its' mixins that is concrete.
    *
    * By "match", only the name of the member is tested to match, it does not have to equal or be a
    * subtype of the passed executable element, this is due to the specific use where this method is
    * used in [checkForNonAbstractClassInheritsAbstractMember].
    *
    * @param executableElt the executable to search for in the passed class element
    * @param classElt the class method to search through the members of
    * @return `true` iff the passed member is found in the passed class element
    */
-  bool _isMemberInClassOrMixin(ExecutableElement executableElt,
-      ClassElement classElt) {
+  bool _isMemberInClassOrMixin(
+      ExecutableElement executableElt, ClassElement classElt) {
     ExecutableElement foundElt = null;
     String executableName = executableElt.name;
     if (executableElt is MethodElement) {
       foundElt = classElt.getMethod(executableName);
       if (foundElt != null && !(foundElt as MethodElement).isAbstract) {
         return true;
       }
       List<InterfaceType> mixins = classElt.mixins;
       for (int i = 0; i < mixins.length && foundElt == null; i++) {
         foundElt = mixins[i].getMethod(executableName);
@@ skipping 53 matching lines @@
   }
 
   /**
    * Return `true` if the given identifier is in a location where it is allowed to resolve to
    * a static member of a supertype.
    *
    * @param node the node being tested
    * @return `true` if the given identifier is in a location where it is allowed to resolve to
    *         a static member of a supertype
    */
-  bool
-      _isUnqualifiedReferenceToNonLocalStaticMemberAllowed(SimpleIdentifier node) {
+  bool _isUnqualifiedReferenceToNonLocalStaticMemberAllowed(
+      SimpleIdentifier node) {
     if (node.inDeclarationContext()) {
       return true;
     }
     AstNode parent = node.parent;
     if (parent is ConstructorName ||
         parent is MethodInvocation ||
         parent is PropertyAccess ||
         parent is SuperConstructorInvocation) {
       return true;
     }
     if (parent is PrefixedIdentifier && identical(parent.identifier, node)) {
       return true;
     }
     if (parent is Annotation && identical(parent.constructorName, node)) {
       return true;
     }
     if (parent is CommentReference) {
       CommentReference commentReference = parent;
       if (commentReference.newKeyword != null) {
         return true;
       }
     }
     return false;
   }
 
-  bool _isUserDefinedObject(EvaluationResultImpl result) =>
-      result == null || (result.value != null && result.value.isUserDefinedObject);
+  bool _isUserDefinedObject(EvaluationResultImpl result) => result == null ||
+      (result.value != null && result.value.isUserDefinedObject);
 
   /**
    * This checks the class declaration is not a superinterface to itself.
    *
    * @param classElt the class element to test
    * @param path a list containing the potentially cyclic implements path
    * @return `true` if and only if an error code is generated on the passed element
    * See [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE],
    * [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS],
    * [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS], and
    * [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_WITH].
    */
-  bool _safeCheckForRecursiveInterfaceInheritance(ClassElement classElt,
-      List<ClassElement> path) {
+  bool _safeCheckForRecursiveInterfaceInheritance(
+      ClassElement classElt, List<ClassElement> path) {
     // Detect error condition.
     int size = path.length;
     // If this is not the base case (size > 0), and the enclosing class is the
     // passed class element then an error an error.
     if (size > 0 && _enclosingClass == classElt) {
       String enclosingClassName = _enclosingClass.displayName;
       if (size > 1) {
         // Construct a string showing the cyclic implements path:
         // "A, B, C, D, A"
         String separator = ", ";
         StringBuffer buffer = new StringBuffer();
         for (int i = 0; i < size; i++) {
           buffer.write(path[i].displayName);
           buffer.write(separator);
         }
         buffer.write(classElt.displayName);
         _errorReporter.reportErrorForOffset(
             CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE,
-            _enclosingClass.nameOffset,
-            enclosingClassName.length,
-            [enclosingClassName, buffer.toString()]);
+            _enclosingClass.nameOffset, enclosingClassName.length, [
+          enclosingClassName,
+          buffer.toString()
+        ]);
         return true;
       } else {
         // RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS or
         // RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS or
         // RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_WITH
-        _errorReporter.reportErrorForOffset(
-            _getBaseCaseErrorCode(classElt),
-            _enclosingClass.nameOffset,
-            enclosingClassName.length,
-            [enclosingClassName]);
+        _errorReporter.reportErrorForOffset(_getBaseCaseErrorCode(classElt),
+            _enclosingClass.nameOffset, enclosingClassName.length, [
+          enclosingClassName
+        ]);
         return true;
       }
     }
     if (path.indexOf(classElt) > 0) {
       return false;
     }
     path.add(classElt);
     // n-case
     InterfaceType supertype = classElt.supertype;
     if (supertype != null &&
         _safeCheckForRecursiveInterfaceInheritance(supertype.element, path)) {
       return true;
     }
     List<InterfaceType> interfaceTypes = classElt.interfaces;
     for (InterfaceType interfaceType in interfaceTypes) {
       if (_safeCheckForRecursiveInterfaceInheritance(
-          interfaceType.element,
-          path)) {
+          interfaceType.element, path)) {
         return true;
       }
     }
     List<InterfaceType> mixinTypes = classElt.mixins;
     for (InterfaceType mixinType in mixinTypes) {
       if (_safeCheckForRecursiveInterfaceInheritance(mixinType.element, path)) {
         return true;
       }
     }
     path.removeAt(path.length - 1);
@@ skipping 26 matching lines @@
     if (expression is Identifier) {
       Element element = expression.staticElement;
       if (element is VariableElement) {
         return element;
       }
     }
     return null;
   }
 }
 
-class GeneralizingElementVisitor_ErrorVerifier_hasTypedefSelfReference extends
-    GeneralizingElementVisitor<Object> {
+class GeneralizingElementVisitor_ErrorVerifier_hasTypedefSelfReference
+    extends GeneralizingElementVisitor<Object> {
   List<Element> toCheck;
 
   GeneralizingElementVisitor_ErrorVerifier_hasTypedefSelfReference(this.toCheck)
       : super();
 
   @override
   Object visitClassElement(ClassElement element) {
     // Typedefs are allowed to reference themselves via classes.
     return null;
   }
@@ skipping 24 matching lines @@
     toCheck.add(type.element);
     // type arguments
     if (type is InterfaceType) {
       InterfaceType interfaceType = type;
       for (DartType typeArgument in interfaceType.typeArguments) {
         _addTypeToCheck(typeArgument);
       }
     }
   }
 }