Create fewer unnecessary lists

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:collection';
 import "dart:math" as math;
 
 import 'java_engine.dart';
@@ skipping 323 matching lines @@
       _checkForInvalidCompoundAssignment(node, lhs, rhs);
       _checkForArgumentTypeNotAssignableForArgument(rhs);
     }
     _checkForAssignmentToFinal(lhs);
     return super.visitAssignmentExpression(node);
   }
 
   @override
   Object visitAwaitExpression(AwaitExpression node) {
     if (!_inAsync) {
-      _errorReporter.reportErrorForToken(CompileTimeErrorCode.AWAIT_IN_WRONG_CONTEXT, node.awaitKeyword, []);
+      _errorReporter.reportErrorForToken(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;
@@ skipping 29 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, []);
+        _errorReporter.reportErrorForNode(ResolverErrorCode.BREAK_LABEL_ON_SWITCH_MEMBER, labelNode);
       }
     }
     return null;
   }
 
   @override
   Object visitCatchClause(CatchClause node) {
     bool previousIsInCatchClause = _isInCatchClause;
     try {
       _isInCatchClause = true;
@@ skipping 140 matching lines @@
       _isInConstructorInitializer = false;
     }
   }
 
   @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, []);
+        _errorReporter.reportErrorForNode(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 34 matching lines @@
     }
   }
 
   @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, []);
+        _errorReporter.reportErrorForToken(CompileTimeErrorCode.CONST_INSTANCE_FIELD, variables.keyword);
       }
     }
     try {
       _checkForAllInvalidOverrideErrorCodesForField(node);
       return super.visitFieldDeclaration(node);
     } finally {
       _isInStaticVariableDeclaration = false;
       _isInInstanceVariableDeclaration = false;
     }
   }
@@ skipping 54 matching lines @@
     } else {
       return super.visitFunctionExpression(node);
     }
   }
 
   @override
   Object visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     Expression functionExpression = node.function;
     DartType expressionType = functionExpression.staticType;
     if (!_isFunctionType(expressionType)) {
-      _errorReporter.reportErrorForNode(StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION_EXPRESSION, functionExpression, []);
+      _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);
     _checkForDefaultValueInFunctionTypeAlias(node);
     _checkForTypeAliasCannotReferenceItself_function(node);
     return super.visitFunctionTypeAlias(node);
@@ skipping 148 matching lines @@
     } else {
       _checkForUnqualifiedReferenceToNonLocalStaticMember(methodName);
     }
     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, []);
+      _errorReporter.reportErrorForNode(ParserErrorCode.NATIVE_CLAUSE_IN_NON_SDK_CODE, node);
     }
     return super.visitNativeClause(node);
   }
 
   @override
   Object visitNativeFunctionBody(NativeFunctionBody node) {
     _checkForNativeFunctionBodyInNonSDKCode(node);
     return super.visitNativeFunctionBody(node);
   }
 
@@ skipping 186 matching lines @@
 
   @override
   Object visitYieldStatement(YieldStatement node) {
     if (!_inGenerator) {
       CompileTimeErrorCode errorCode;
       if (node.star != null) {
         errorCode = CompileTimeErrorCode.YIELD_EACH_IN_NON_GENERATOR;
       } else {
         errorCode = CompileTimeErrorCode.YIELD_IN_NON_GENERATOR;
       }
-      _errorReporter.reportErrorForNode(errorCode, node, []);
+      _errorReporter.reportErrorForNode(errorCode, node);
     }
     return super.visitYieldStatement(node);
   }
 
   /**
    * This verifies if the passed map literal has type arguments then there is exactly two.
    *
    * @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_TWO_MAP_TYPE_ARGUMENTS].
@@ skipping 64 matching lines @@
         ConstructorFieldInitializer constructorFieldInitializer = constructorInitializer;
         SimpleIdentifier fieldName = constructorFieldInitializer.fieldName;
         Element element = fieldName.staticElement;
         if (element is FieldElement) {
           FieldElement fieldElement = element;
           INIT_STATE state = fieldElementsMap[fieldElement];
           if (state == INIT_STATE.NOT_INIT) {
             fieldElementsMap[fieldElement] = INIT_STATE.INIT_IN_INITIALIZERS;
           } else if (state == INIT_STATE.INIT_IN_DECLARATION) {
             if (fieldElement.isFinal || fieldElement.isConst) {
-              _errorReporter.reportErrorForNode(StaticWarningCode.FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION, fieldName, []);
+              _errorReporter.reportErrorForNode(StaticWarningCode.FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION, fieldName);
               foundError = true;
             }
           } else if (state == INIT_STATE.INIT_IN_FIELD_FORMAL) {
-            _errorReporter.reportErrorForNode(CompileTimeErrorCode.FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZER, fieldName, []);
+            _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]);
             foundError = true;
           }
         }
       }
     }
     // Visit all of the states in the map to ensure that none were never
     // initialized.
@@ skipping 472 matching lines @@
   bool _checkForAllReturnStatementErrorCodes(ReturnStatement node) {
     FunctionType functionType = _enclosingFunction == null ? null : _enclosingFunction.type;
     DartType expectedReturnType = functionType == null ? DynamicTypeImpl.instance : functionType.returnType;
     Expression returnExpression = node.expression;
     // RETURN_IN_GENERATIVE_CONSTRUCTOR
     bool isGenerativeConstructor = _enclosingFunction is ConstructorElement && !(_enclosingFunction as ConstructorElement).isFactory;
     if (isGenerativeConstructor) {
       if (returnExpression == null) {
         return false;
       }
-      _errorReporter.reportErrorForNode(CompileTimeErrorCode.RETURN_IN_GENERATIVE_CONSTRUCTOR, returnExpression, []);
+      _errorReporter.reportErrorForNode(CompileTimeErrorCode.RETURN_IN_GENERATIVE_CONSTRUCTOR, returnExpression);
       return true;
     }
     // RETURN_WITHOUT_VALUE
     if (returnExpression == null) {
       if (VoidTypeImpl.instance.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
@@ skipping 168 matching lines @@
       highlightedNode = propertyAccess.propertyName;
     }
     // 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, []);
+        _errorReporter.reportErrorForNode(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, [variable.name, variable.enclosingElement.displayName]);
           return true;
         }
         _errorReporter.reportErrorForNode(StaticWarningCode.ASSIGNMENT_TO_FINAL, highlightedNode, [variable.name]);
         return true;
       }
       return false;
     }
     if (element is FunctionElement) {
-      _errorReporter.reportErrorForNode(StaticWarningCode.ASSIGNMENT_TO_FUNCTION, expression, []);
+      _errorReporter.reportErrorForNode(StaticWarningCode.ASSIGNMENT_TO_FUNCTION, expression);
       return true;
     }
     if (element is MethodElement) {
-      _errorReporter.reportErrorForNode(StaticWarningCode.ASSIGNMENT_TO_METHOD, expression, []);
+      _errorReporter.reportErrorForNode(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
@@ skipping 46 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, []);
+    _errorReporter.reportErrorForToken(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 56 matching lines @@
     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, []);
+          _errorReporter.reportErrorForNode(CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_DEFAULT, node);
         } else {
           _errorReporter.reportErrorForNode(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);
@@ skipping 328 matching lines @@
   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, []);
+      _errorReporter.reportErrorForNode(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;
         }
@@ skipping 33 matching lines @@
   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, []);
+    _errorReporter.reportErrorForNode(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`
@@ skipping 11 matching lines @@
   /**
    * 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, []);
+      _errorReporter.reportErrorForNode(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, []);
+      _errorReporter.reportErrorForNode(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) {
     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, []);
+          _errorReporter.reportErrorForNode(StaticWarningCode.CONST_WITH_ABSTRACT_CLASS, typeName);
         } else {
-          _errorReporter.reportErrorForNode(StaticWarningCode.NEW_WITH_ABSTRACT_CLASS, typeName, []);
+          _errorReporter.reportErrorForNode(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) {
     if (type.element.isEnum) {
-      _errorReporter.reportErrorForNode(CompileTimeErrorCode.INSTANTIATE_ENUM, typeName, []);
+      _errorReporter.reportErrorForNode(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, []);
+      _errorReporter.reportErrorForNode(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, []);
+      _errorReporter.reportErrorForNode(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 48 matching lines @@
    * 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, []);
+          _errorReporter.reportErrorForNode(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) {
     // 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, []);
+    _errorReporter.reportErrorForNode(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 375 matching lines @@
   /**
    * 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) {
     ConstructorDeclaration constructor = node.getAncestor((node) => node is ConstructorDeclaration);
     if (constructor == null) {
-      _errorReporter.reportErrorForNode(CompileTimeErrorCode.FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR, node, []);
+      _errorReporter.reportErrorForNode(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, []);
+      _errorReporter.reportErrorForNode(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, []);
+        _errorReporter.reportErrorForNode(CompileTimeErrorCode.FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR, node);
         return true;
       }
     }
     // OK
     return false;
   }
 
   /**
    * This verifies that the passed variable declaration list has only initialized variables if the
    * list is final or const. This method is called by
@@ skipping 148 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, []);
+      _errorReporter.reportErrorForNode(CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_STATIC, node);
     } else if (_isInFactory) {
-      _errorReporter.reportErrorForNode(CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_FACTORY, node, []);
+      _errorReporter.reportErrorForNode(CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_FACTORY, node);
     } else {
-      _errorReporter.reportErrorForNode(CompileTimeErrorCode.IMPLICIT_THIS_REFERENCE_IN_INITIALIZER, node, []);
+      _errorReporter.reportErrorForNode(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
@@ skipping 209 matching lines @@
    * 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) {
     Identifier nameIdentifier = node.name;
     if (nameIdentifier is PrefixedIdentifier) {
       if (nameIdentifier.isDeferred) {
-        _errorReporter.reportErrorForNode(CompileTimeErrorCode.INVALID_ANNOTATION_FROM_DEFERRED_LIBRARY, node.name, []);
+        _errorReporter.reportErrorForNode(CompileTimeErrorCode.INVALID_ANNOTATION_FROM_DEFERRED_LIBRARY, node.name);
         return true;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed left hand side and right hand side represent a valid assignment.
    *
    * @param lhs the left hand side expression
@@ skipping 87 matching lines @@
 
   /**
    * 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, []);
+      _errorReporter.reportErrorForNode(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
@@ skipping 122 matching lines @@
       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, className.length, []);
+        _errorReporter.reportErrorForOffset(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
@@ skipping 135 matching lines @@
    * 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, _returnsWith[i].keyword, []);
+        _errorReporter.reportErrorForToken(StaticWarningCode.MIXED_RETURN_TYPES, _returnsWith[i].keyword);
       }
       for (int i = 0; i < withoutCount; i++) {
-        _errorReporter.reportErrorForToken(StaticWarningCode.MIXED_RETURN_TYPES, _returnsWithout[i].keyword, []);
+        _errorReporter.reportErrorForToken(StaticWarningCode.MIXED_RETURN_TYPES, _returnsWithout[i].keyword);
       }
       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
@@ skipping 51 matching lines @@
    * @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, []);
+          _errorReporter.reportErrorForNode(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, []);
+      _errorReporter.reportErrorForNode(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 211 matching lines @@
    * 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, []);
+      _errorReporter.reportErrorForNode(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, []);
+        _errorReporter.reportErrorForNode(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, []);
+        _errorReporter.reportErrorForNode(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, []);
+      _errorReporter.reportErrorForNode(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 14 matching lines @@
     // prepare statement
     Statement statement = 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, []);
+    _errorReporter.reportErrorForNode(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, []);
+        _errorReporter.reportErrorForNode(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, []);
+        _errorReporter.reportErrorForNode(StaticWarningCode.NON_VOID_RETURN_FOR_SETTER, typeName);
       }
     }
     return false;
   }
 
   /**
    * This verifies the passed operator-method declaration, does not have an optional parameter.
    *
    * This method assumes that the method declaration was tested to be an operator declaration before
    * being called.
    *
    * @param node the method declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.OPTIONAL_PARAMETER_IN_OPERATOR].
    */
   bool _checkForOptionalParameterInOperator(MethodDeclaration node) {
     FormalParameterList parameterList = node.parameters;
     if (parameterList == null) {
       return false;
     }
     bool foundError = false;
     NodeList<FormalParameter> formalParameters = parameterList.parameters;
     for (FormalParameter formalParameter in formalParameters) {
       if (formalParameter.kind.isOptional) {
-        _errorReporter.reportErrorForNode(CompileTimeErrorCode.OPTIONAL_PARAMETER_IN_OPERATOR, formalParameter, []);
+        _errorReporter.reportErrorForNode(CompileTimeErrorCode.OPTIONAL_PARAMETER_IN_OPERATOR, formalParameter);
         foundError = true;
       }
     }
     return foundError;
   }
 
   /**
    * This checks for named optional parameters that begin with '_'.
    *
    * @param node the default formal parameter to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.PRIVATE_OPTIONAL_PARAMETER].
    */
   bool _checkForPrivateOptionalParameter(FormalParameter node) {
     // should be named parameter
     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, []);
+    _errorReporter.reportErrorForNode(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) {
     // 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, []);
+        _errorReporter.reportErrorForNode(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) {
     // prepare redirected constructor
     ConstructorName redirectedConstructorNode = node.redirectedConstructor;
     if (redirectedConstructorNode == null) {
       return false;
     }
     // OK if no cycle
     if (!_hasRedirectingFactoryConstructorCycle(constructorElement)) {
       return false;
     }
     // report error
-    _errorReporter.reportErrorForNode(CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT, redirectedConstructorNode, []);
+    _errorReporter.reportErrorForNode(CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT, redirectedConstructorNode);
     return true;
   }
 
   /**
    * This checks the class declaration is not a superinterface to itself.
    *
    * @param classElt the class element to test
    * @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
@@ skipping 20 matching lines @@
    */
   bool _checkForRedirectingConstructorErrorCodes(ConstructorDeclaration node) {
     bool errorReported = false;
     //
     // Check for default values in the parameters
     //
     ConstructorName redirectedConstructor = node.redirectedConstructor;
     if (redirectedConstructor != null) {
       for (FormalParameter parameter in node.parameters.parameters) {
         if (parameter is DefaultFormalParameter && parameter.defaultValue != null) {
-          _errorReporter.reportErrorForNode(CompileTimeErrorCode.DEFAULT_VALUE_IN_REDIRECTING_FACTORY_CONSTRUCTOR, parameter.identifier, []);
+          _errorReporter.reportErrorForNode(CompileTimeErrorCode.DEFAULT_VALUE_IN_REDIRECTING_FACTORY_CONSTRUCTOR, parameter.identifier);
           errorReported = true;
         }
       }
     }
     // check if there are redirected invocations
     int numRedirections = 0;
     for (ConstructorInitializer initializer in node.initializers) {
       if (initializer is RedirectingConstructorInvocation) {
         if (numRedirections > 0) {
-          _errorReporter.reportErrorForNode(CompileTimeErrorCode.MULTIPLE_REDIRECTING_CONSTRUCTOR_INVOCATIONS, initializer, []);
+          _errorReporter.reportErrorForNode(CompileTimeErrorCode.MULTIPLE_REDIRECTING_CONSTRUCTOR_INVOCATIONS, initializer);
           errorReported = true;
         }
         if (node.factoryKeyword == null) {
           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]);
           } else {
             if (redirectingElement.isFactory) {
-              _errorReporter.reportErrorForNode(CompileTimeErrorCode.REDIRECT_GENERATIVE_TO_NON_GENERATIVE_CONSTRUCTOR, initializer, []);
+              _errorReporter.reportErrorForNode(CompileTimeErrorCode.REDIRECT_GENERATIVE_TO_NON_GENERATIVE_CONSTRUCTOR, initializer);
             }
           }
         }
         numRedirections++;
       }
     }
     // check for other initializers
     if (numRedirections > 0) {
       for (ConstructorInitializer initializer in node.initializers) {
         if (initializer is SuperConstructorInvocation) {
-          _errorReporter.reportErrorForNode(CompileTimeErrorCode.SUPER_IN_REDIRECTING_CONSTRUCTOR, initializer, []);
+          _errorReporter.reportErrorForNode(CompileTimeErrorCode.SUPER_IN_REDIRECTING_CONSTRUCTOR, initializer);
           errorReported = true;
         }
         if (initializer is ConstructorFieldInitializer) {
-          _errorReporter.reportErrorForNode(CompileTimeErrorCode.FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR, initializer, []);
+          _errorReporter.reportErrorForNode(CompileTimeErrorCode.FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR, initializer);
           errorReported = true;
         }
       }
     }
     // done
     return errorReported;
   }
 
   /**
    * This checks if the passed constructor declaration has redirected constructor and references
@@ skipping 21 matching lines @@
     // prepare redirected constructor
     ConstructorElement redirectedConstructor = constructorElement.redirectedConstructor;
     if (redirectedConstructor == null) {
       return false;
     }
     // OK, it is also 'const'
     if (redirectedConstructor.isConst) {
       return false;
     }
     // report error
-    _errorReporter.reportErrorForNode(CompileTimeErrorCode.REDIRECT_TO_NON_CONST_CONSTRUCTOR, redirectedConstructorNode, []);
+    _errorReporter.reportErrorForNode(CompileTimeErrorCode.REDIRECT_TO_NON_CONST_CONSTRUCTOR, redirectedConstructorNode);
     return true;
   }
 
   /**
    * 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, []);
+      _errorReporter.reportErrorForNode(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, []);
+    _errorReporter.reportErrorForNode(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].
    *
@@ skipping 128 matching lines @@
    *
    * @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) {
     FunctionTypeAliasElement element = node.element;
     if (!_hasTypedefSelfReference(element)) {
       return false;
     }
-    _errorReporter.reportErrorForNode(CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF, node, []);
+    _errorReporter.reportErrorForNode(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].
    */
@@ skipping 62 matching lines @@
    * 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, []);
+        _errorReporter.reportErrorForNode(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
@@ skipping 143 matching lines @@
    *
    * @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, []);
+    _errorReporter.reportErrorForNode(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 47 matching lines @@
    */
   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, []);
+      _errorReporter.reportErrorForNode(CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER, setterName);
       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.
    *
    * @return `true` if and only if an error code is generated on the passed node
    * See [StaticWarningCode.FUNCTION_WITHOUT_CALL].
    */
   bool _checkImplementsFunctionWithoutCall(ClassDeclaration node) {
     if (node.isAbstract) {
       return false;
     }
     ClassElement classElement = node.element;
     if (classElement == null) {
       return false;
     }
     if (!classElement.type.isSubtypeOf(_typeProvider.functionType)) {
       return false;
     }
     // If there is a noSuchMethod method, then don't report the warning, see dartbug.com/16078
     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, []);
+      _errorReporter.reportErrorForNode(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
@@ skipping 100 matching lines @@
    * @return `true` if an error was generated
    * 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].deferredToken;
         if (deferredToken != null) {
-          _errorReporter.reportErrorForToken(CompileTimeErrorCode.SHARED_DEFERRED_PREFIX, deferredToken, []);
+          _errorReporter.reportErrorForToken(CompileTimeErrorCode.SHARED_DEFERRED_PREFIX, deferredToken);
           foundError = true;
         }
       }
     }
     return foundError;
   }
 
   /**
    * @return `true` if the given constructor redirects to itself, directly or indirectly
    */
@@ skipping 299 matching lines @@
     toCheck.add(type.element);
     // type arguments
     if (type is InterfaceType) {
       InterfaceType interfaceType = type;
       for (DartType typeArgument in interfaceType.typeArguments) {
         _addTypeToCheck(typeArgument);
       }
     }
   }
 }