Create fewer unnecessary lists

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

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library engine.resolver;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'java_core.dart';
@@ skipping 363 matching lines @@
     // publishAs
     String name = null;
     int nameOffset = -1;
     if (_hasStringArgument(_PUBLISH_AS)) {
       name = _getStringArgument(_PUBLISH_AS);
       nameOffset = _getStringArgumentOffset(_PUBLISH_AS);
     }
     // selector
     AngularSelectorElement selector = null;
     if (!_hasStringArgument(_SELECTOR)) {
-      _reportErrorForAnnotation(AngularCode.MISSING_SELECTOR, []);
+      _reportErrorForAnnotation(AngularCode.MISSING_SELECTOR);
       isValid = false;
     } else {
       SimpleStringLiteral selectorLiteral = _getStringLiteral(_SELECTOR);
       selector = _parseSelectorFromString(selectorLiteral);
       if (selector == null) {
         _reportErrorForArgument(_SELECTOR, AngularCode.CANNOT_PARSE_SELECTOR, [selectorLiteral]);
         isValid = false;
       }
     }
     // templateUrl
@@ skipping 76 matching lines @@
    * Parses [AngularPropertyElement]s from [annotation].
    */
   void _parseComponentProperties_fromMap(List<AngularPropertyElement> properties) {
     Expression mapExpression = _getArgument("map");
     // may be not properties
     if (mapExpression == null) {
       return;
     }
     // prepare map literal
     if (mapExpression is! MapLiteral) {
-      _reportErrorForNode(AngularCode.INVALID_PROPERTY_MAP, mapExpression, []);
+      _reportErrorForNode(AngularCode.INVALID_PROPERTY_MAP, mapExpression);
       return;
     }
     MapLiteral mapLiteral = mapExpression as MapLiteral;
     // analyze map entries
     for (MapLiteralEntry entry in mapLiteral.entries) {
       // prepare property name
       Expression nameExpression = entry.key;
       if (nameExpression is! SimpleStringLiteral) {
-        _reportErrorForNode(AngularCode.INVALID_PROPERTY_NAME, nameExpression, []);
+        _reportErrorForNode(AngularCode.INVALID_PROPERTY_NAME, nameExpression);
         continue;
       }
       SimpleStringLiteral nameLiteral = nameExpression as SimpleStringLiteral;
       String name = nameLiteral.value;
       int nameOffset = nameLiteral.contentsOffset;
       // prepare field specification
       Expression specExpression = entry.value;
       if (specExpression is! SimpleStringLiteral) {
-        _reportErrorForNode(AngularCode.INVALID_PROPERTY_SPEC, specExpression, []);
+        _reportErrorForNode(AngularCode.INVALID_PROPERTY_SPEC, specExpression);
         continue;
       }
       SimpleStringLiteral specLiteral = specExpression as SimpleStringLiteral;
       String spec = specLiteral.value;
       // parse binding kind and field name
       AngularPropertyKind kind;
       int fieldNameOffset;
       if (StringUtilities.startsWithChar(spec, 0x40)) {
         kind = AngularPropertyKind.ATTR;
         fieldNameOffset = 1;
@@ skipping 28 matching lines @@
       property.propertyKind = kind;
       property.fieldNameOffset = fieldNameOffset;
       properties.add(property);
     }
   }
 
   void _parseController() {
     bool isValid = true;
     // publishAs
     if (!_hasStringArgument(_PUBLISH_AS)) {
-      _reportErrorForAnnotation(AngularCode.MISSING_PUBLISH_AS, []);
+      _reportErrorForAnnotation(AngularCode.MISSING_PUBLISH_AS);
       isValid = false;
     }
     // selector
     AngularSelectorElement selector = null;
     if (!_hasStringArgument(_SELECTOR)) {
-      _reportErrorForAnnotation(AngularCode.MISSING_SELECTOR, []);
+      _reportErrorForAnnotation(AngularCode.MISSING_SELECTOR);
       isValid = false;
     } else {
       SimpleStringLiteral selectorLiteral = _getStringLiteral(_SELECTOR);
       selector = _parseSelectorFromString(selectorLiteral);
       if (selector == null) {
         _reportErrorForArgument(_SELECTOR, AngularCode.CANNOT_PARSE_SELECTOR, [selectorLiteral]);
         isValid = false;
       }
     }
     // create
     if (isValid) {
       String name = _getStringArgument(_PUBLISH_AS);
       int nameOffset = _getStringArgumentOffset(_PUBLISH_AS);
       AngularControllerElementImpl element = new AngularControllerElementImpl(name, nameOffset);
       element.selector = selector;
       _classElement.addToolkitObjects(element);
     }
   }
 
   void _parseDecorator() {
     bool isValid = true;
     // selector
     AngularSelectorElement selector = null;
     if (!_hasStringArgument(_SELECTOR)) {
-      _reportErrorForAnnotation(AngularCode.MISSING_SELECTOR, []);
+      _reportErrorForAnnotation(AngularCode.MISSING_SELECTOR);
       isValid = false;
     } else {
       SimpleStringLiteral selectorLiteral = _getStringLiteral(_SELECTOR);
       selector = _parseSelectorFromString(selectorLiteral);
       if (selector == null) {
         _reportErrorForArgument(_SELECTOR, AngularCode.CANNOT_PARSE_SELECTOR, [selectorLiteral]);
         isValid = false;
       }
     }
     // create
     if (isValid) {
       int offset = _annotation.offset;
       AngularDecoratorElementImpl element = new AngularDecoratorElementImpl(offset);
       element.selector = selector;
       element.properties = _parseComponentProperties();
       _classElement.addToolkitObjects(element);
     }
   }
 
   void _parseFormatter() {
     bool isValid = true;
     // name
     if (!_hasStringArgument(_NAME)) {
-      _reportErrorForAnnotation(AngularCode.MISSING_NAME, []);
+      _reportErrorForAnnotation(AngularCode.MISSING_NAME);
       isValid = false;
     }
     // create
     if (isValid) {
       String name = _getStringArgument(_NAME);
       int nameOffset = _getStringArgumentOffset(_NAME);
       _classElement.addToolkitObjects(new AngularFormatterElementImpl(name, nameOffset));
     }
   }
 
   List<AngularScopePropertyElement> _parseScopeProperties() {
     List<AngularScopePropertyElement> properties = <AngularScopePropertyElement>[];
     _classDeclaration.accept(new RecursiveAstVisitor_AngularCompilationUnitBuilder_parseScopeProperties(properties));
     return properties;
   }
 
   /**
    * Create [AngularViewElement] for each valid <code>view('template.html')</code> invocation,
    * where <code>view</code> is <code>ViewFactory</code>.
    */
   void _parseViews() {
     List<AngularViewElement> views = <AngularViewElement>[];
     _unit.accept(new RecursiveAstVisitor_AngularCompilationUnitBuilder_parseViews(views));
     if (!views.isEmpty) {
       List<AngularViewElement> viewArray = views;
       (_unit.element as CompilationUnitElementImpl).angularViews = viewArray;
     }
   }
 
-  void _reportErrorForAnnotation(ErrorCode errorCode, List<Object> arguments) {
+  void _reportErrorForAnnotation(ErrorCode errorCode, [List<Object> arguments]) {
     _reportErrorForNode(errorCode, _annotation, arguments);
   }
 
-  void _reportErrorForArgument(String argumentName, ErrorCode errorCode, List<Object> arguments) {
+  void _reportErrorForArgument(String argumentName, ErrorCode errorCode, [List<Object> arguments]) {
     Expression argument = _getArgument(argumentName);
     _reportErrorForNode(errorCode, argument, arguments);
   }
 
-  void _reportErrorForNode(ErrorCode errorCode, AstNode node, List<Object> arguments) {
+  void _reportErrorForNode(ErrorCode errorCode, AstNode node, [List<Object> arguments]) {
     int offset = node.offset;
     int length = node.length;
     _reportErrorForOffset(errorCode, offset, length, arguments);
   }
 
-  void _reportErrorForOffset(ErrorCode errorCode, int offset, int length, List<Object> arguments) {
+  void _reportErrorForOffset(ErrorCode errorCode, int offset, int length, [List<Object> arguments]) {
     _errorListener.onError(new AnalysisError.con2(_source, offset, length, errorCode, arguments));
   }
 }
 
 /**
  * Instances of the class `BestPracticesVerifier` traverse an AST structure looking for
  * violations of Dart best practices.
  */
 class BestPracticesVerifier extends RecursiveAstVisitor<Object> {
   static String _HASHCODE_GETTER_NAME = "hashCode";
@@ skipping 185 matching lines @@
     DartType lhsType = expression.staticType;
     DartType rhsType = typeName.type;
     if (lhsType == null || rhsType == null) {
       return false;
     }
     String rhsNameStr = typeName.name.name;
     // if x is dynamic
     if (rhsType.isDynamic && rhsNameStr == sc.Keyword.DYNAMIC.syntax) {
       if (node.notOperator == null) {
         // the is case
-        _errorReporter.reportErrorForNode(HintCode.UNNECESSARY_TYPE_CHECK_TRUE, node, []);
+        _errorReporter.reportErrorForNode(HintCode.UNNECESSARY_TYPE_CHECK_TRUE, node);
       } else {
         // the is not case
-        _errorReporter.reportErrorForNode(HintCode.UNNECESSARY_TYPE_CHECK_FALSE, node, []);
+        _errorReporter.reportErrorForNode(HintCode.UNNECESSARY_TYPE_CHECK_FALSE, node);
       }
       return true;
     }
     Element rhsElement = rhsType.element;
     LibraryElement libraryElement = rhsElement != null ? rhsElement.library : null;
     if (libraryElement != null && libraryElement.isDartCore) {
       // if x is Object or null is Null
       if (rhsType.isObject || (expression is NullLiteral && rhsNameStr == _NULL_TYPE_NAME)) {
         if (node.notOperator == null) {
           // the is case
-          _errorReporter.reportErrorForNode(HintCode.UNNECESSARY_TYPE_CHECK_TRUE, node, []);
+          _errorReporter.reportErrorForNode(HintCode.UNNECESSARY_TYPE_CHECK_TRUE, node);
         } else {
           // the is not case
-          _errorReporter.reportErrorForNode(HintCode.UNNECESSARY_TYPE_CHECK_FALSE, node, []);
+          _errorReporter.reportErrorForNode(HintCode.UNNECESSARY_TYPE_CHECK_FALSE, node);
         }
         return true;
       } else if (rhsNameStr == _NULL_TYPE_NAME) {
         if (node.notOperator == null) {
           // the is case
-          _errorReporter.reportErrorForNode(HintCode.TYPE_CHECK_IS_NULL, node, []);
+          _errorReporter.reportErrorForNode(HintCode.TYPE_CHECK_IS_NULL, node);
         } else {
           // the is not case
-          _errorReporter.reportErrorForNode(HintCode.TYPE_CHECK_IS_NOT_NULL, node, []);
+          _errorReporter.reportErrorForNode(HintCode.TYPE_CHECK_IS_NOT_NULL, node);
         }
         return true;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed expression can be assigned to its corresponding parameters.
    *
@@ skipping 164 matching lines @@
     LibraryElement libraryElement = methodElement.library;
     if (libraryElement != null && !libraryElement.isDartCore) {
       return false;
     }
     // Report error if the (x/y) has toInt() invoked on it
     if (node.parent is ParenthesizedExpression) {
       ParenthesizedExpression parenthesizedExpression = _wrapParenthesizedExpression(node.parent as ParenthesizedExpression);
       if (parenthesizedExpression.parent is MethodInvocation) {
         MethodInvocation methodInvocation = parenthesizedExpression.parent as MethodInvocation;
         if (_TO_INT_METHOD_NAME == methodInvocation.methodName.name && methodInvocation.argumentList.arguments.isEmpty) {
-          _errorReporter.reportErrorForNode(HintCode.DIVISION_OPTIMIZATION, methodInvocation, []);
+          _errorReporter.reportErrorForNode(HintCode.DIVISION_OPTIMIZATION, methodInvocation);
           return true;
         }
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed left hand side and right hand side represent a valid assignment.
    *
@@ skipping 112 matching lines @@
    * See [HintCode.UNNECESSARY_CAST].
    */
   bool _checkForUnnecessaryCast(AsExpression node) {
     Expression expression = node.expression;
     TypeName typeName = node.type;
     DartType lhsType = expression.staticType;
     DartType rhsType = typeName.type;
     // TODO(jwren) After dartbug.com/13732, revisit this, we should be able to remove the
     // !(x instanceof TypeParameterType) checks.
     if (lhsType != null && rhsType != null && !lhsType.isDynamic && !rhsType.isDynamic && lhsType is! TypeParameterType && rhsType is! TypeParameterType && lhsType.isMoreSpecificThan(rhsType)) {
-      _errorReporter.reportErrorForNode(HintCode.UNNECESSARY_CAST, node, []);
+      _errorReporter.reportErrorForNode(HintCode.UNNECESSARY_CAST, node);
       return true;
     }
     return false;
   }
 
   /**
    * Check for situations where the result of a method or function is used, when it returns 'void'.
    *
    * TODO(jwren) Many other situations of use could be covered. We currently cover the cases var x =
    * m() and x = m(), but we could also cover cases such as m().x, m()[k], a + m(), f(m()), return
@@ skipping 152 matching lines @@
 
   @override
   Object visitAnnotation(Annotation node) {
     super.visitAnnotation(node);
     // check annotation creation
     Element element = node.element;
     if (element is ConstructorElement) {
       ConstructorElement constructorElement = element;
       // should 'const' constructor
       if (!constructorElement.isConst) {
-        _errorReporter.reportErrorForNode(CompileTimeErrorCode.NON_CONSTANT_ANNOTATION_CONSTRUCTOR, node, []);
+        _errorReporter.reportErrorForNode(CompileTimeErrorCode.NON_CONSTANT_ANNOTATION_CONSTRUCTOR, node);
         return null;
       }
       // should have arguments
       ArgumentList argumentList = node.arguments;
       if (argumentList == null) {
-        _errorReporter.reportErrorForNode(CompileTimeErrorCode.NO_ANNOTATION_CONSTRUCTOR_ARGUMENTS, node, []);
+        _errorReporter.reportErrorForNode(CompileTimeErrorCode.NO_ANNOTATION_CONSTRUCTOR_ARGUMENTS, node);
         return null;
       }
       // arguments should be constants
       _validateConstantArguments(argumentList);
     }
     return null;
   }
 
   @override
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
@@ skipping 79 matching lines @@
           } else {
             keys.add(result);
           }
         } else {
           reportEqualKeys = false;
         }
       }
     }
     if (reportEqualKeys) {
       for (Expression key in invalidKeys) {
-        _errorReporter.reportErrorForNode(StaticWarningCode.EQUAL_KEYS_IN_MAP, key, []);
+        _errorReporter.reportErrorForNode(StaticWarningCode.EQUAL_KEYS_IN_MAP, key);
       }
     }
     return null;
   }
 
   @override
   Object visitMethodDeclaration(MethodDeclaration node) {
     super.visitMethodDeclaration(node);
     _validateDefaultValues(node.parameters);
     return null;
@@ skipping 105 matching lines @@
    * the node if its' value consists of information from a deferred library.
    *
    * @param expression the expression to be tested for a deferred library reference
    * @param errorCode the error code to be used if the expression is or consists of a reference to a
    *          deferred library
    */
   void _reportErrorIfFromDeferredLibrary(Expression expression, ErrorCode errorCode) {
     DeferredLibraryReferenceDetector referenceDetector = new DeferredLibraryReferenceDetector();
     expression.accept(referenceDetector);
     if (referenceDetector.result) {
-      _errorReporter.reportErrorForNode(errorCode, expression, []);
+      _errorReporter.reportErrorForNode(errorCode, expression);
     }
   }
 
   /**
    * Report any errors in the given list. Except for special cases, use the given error code rather
    * than the one reported in the error.
    *
    * @param errors the errors that need to be reported
    * @param errorCode the error code to be used
    */
   void _reportErrors(List<AnalysisError> errors, ErrorCode errorCode) {
     for (AnalysisError data in errors) {
       ErrorCode dataErrorCode = data.errorCode;
       if (identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION) ||
           identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_THROWS_IDBZE) ||
           identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL_NUM_STRING) ||
           identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL) ||
           identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_TYPE_INT) ||
           identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM) ||
           identical(dataErrorCode, CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_FIELD_TYPE_MISMATCH) ||
           identical(dataErrorCode, CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH) ||
           identical(dataErrorCode, CheckedModeCompileTimeErrorCode.VARIABLE_TYPE_MISMATCH)) {
         _errorReporter.reportError(data);
       } else if (errorCode != null) {
-        _errorReporter.reportError(new AnalysisError.con2(data.source, data.offset, data.length, errorCode, []));
+        _errorReporter.reportError(new AnalysisError.con2(data.source, data.offset, data.length, errorCode));
       }
     }
   }
 
   /**
    * Validate that the given expression is a compile time constant. Return the value of the compile
    * time constant, or `null` if the expression is not a compile time constant.
    *
    * @param expression the expression to be validated
    * @param errorCode the error code to be used if the expression is not a compile time constant
@@ skipping 251 matching lines @@
       //          && libraryElement.isDartCore()) {
       //        if (node.getNotOperator() == null) {
       //          errorReporter.reportError(HintCode.IS_INT, node);
       //        } else {
       //          errorReporter.reportError(HintCode.IS_NOT_INT, node);
       //        }
       //        return true;
       //      } else
       if (typeNameStr == _DOUBLE_TYPE_NAME && libraryElement != null && libraryElement.isDartCore) {
         if (node.notOperator == null) {
-          _errorReporter.reportErrorForNode(HintCode.IS_DOUBLE, node, []);
+          _errorReporter.reportErrorForNode(HintCode.IS_DOUBLE, node);
         } else {
-          _errorReporter.reportErrorForNode(HintCode.IS_NOT_DOUBLE, node, []);
+          _errorReporter.reportErrorForNode(HintCode.IS_NOT_DOUBLE, node);
         }
         return true;
       }
     }
     return false;
   }
 }
 
 /**
  * Instances of the class [UnusedLocalVariableVerifier] traverse an element
@@ skipping 43 matching lines @@
     sc.Token operator = node.operator;
     bool isAmpAmp = operator.type == sc.TokenType.AMPERSAND_AMPERSAND;
     bool isBarBar = operator.type == sc.TokenType.BAR_BAR;
     if (isAmpAmp || isBarBar) {
       Expression lhsCondition = node.leftOperand;
       if (!_isDebugConstant(lhsCondition)) {
         EvaluationResultImpl lhsResult = _getConstantBooleanValue(lhsCondition);
         if (lhsResult != null) {
           if (lhsResult.value.isTrue && isBarBar) {
             // report error on else block: true || !e!
-            _errorReporter.reportErrorForNode(HintCode.DEAD_CODE, node.rightOperand, []);
+            _errorReporter.reportErrorForNode(HintCode.DEAD_CODE, node.rightOperand);
             // only visit the LHS:
             _safelyVisit(lhsCondition);
             return null;
           } else if (lhsResult.value.isFalse && isAmpAmp) {
             // report error on if block: false && !e!
-            _errorReporter.reportErrorForNode(HintCode.DEAD_CODE, node.rightOperand, []);
+            _errorReporter.reportErrorForNode(HintCode.DEAD_CODE, node.rightOperand);
             // only visit the LHS:
             _safelyVisit(lhsCondition);
             return null;
           }
         }
       }
       // How do we want to handle the RHS? It isn't dead code, but "pointless" or "obscure"...
       //      Expression rhsCondition = node.getRightOperand();
       //      ValidResult rhsResult = getConstantBooleanValue(rhsCondition);
       //      if (rhsResult != null) {
@@ skipping 30 matching lines @@
 
   @override
   Object visitConditionalExpression(ConditionalExpression node) {
     Expression conditionExpression = node.condition;
     _safelyVisit(conditionExpression);
     if (!_isDebugConstant(conditionExpression)) {
       EvaluationResultImpl result = _getConstantBooleanValue(conditionExpression);
       if (result != null) {
         if (result.value.isTrue) {
           // report error on else block: true ? 1 : !2!
-          _errorReporter.reportErrorForNode(HintCode.DEAD_CODE, node.elseExpression, []);
+          _errorReporter.reportErrorForNode(HintCode.DEAD_CODE, node.elseExpression);
           _safelyVisit(node.thenExpression);
           return null;
         } else {
           // report error on if block: false ? !1! : 2
-          _errorReporter.reportErrorForNode(HintCode.DEAD_CODE, node.thenExpression, []);
+          _errorReporter.reportErrorForNode(HintCode.DEAD_CODE, node.thenExpression);
           _safelyVisit(node.elseExpression);
           return null;
         }
       }
     }
     return super.visitConditionalExpression(node);
   }
 
   @override
   Object visitIfStatement(IfStatement node) {
     Expression conditionExpression = node.condition;
     _safelyVisit(conditionExpression);
     if (!_isDebugConstant(conditionExpression)) {
       EvaluationResultImpl result = _getConstantBooleanValue(conditionExpression);
       if (result != null) {
         if (result.value.isTrue) {
           // report error on else block: if(true) {} else {!}
           Statement elseStatement = node.elseStatement;
           if (elseStatement != null) {
-            _errorReporter.reportErrorForNode(HintCode.DEAD_CODE, elseStatement, []);
+            _errorReporter.reportErrorForNode(HintCode.DEAD_CODE, elseStatement);
             _safelyVisit(node.thenStatement);
             return null;
           }
         } else {
           // report error on if block: if (false) {!} else {}
-          _errorReporter.reportErrorForNode(HintCode.DEAD_CODE, node.thenStatement, []);
+          _errorReporter.reportErrorForNode(HintCode.DEAD_CODE, node.thenStatement);
           _safelyVisit(node.elseStatement);
           return null;
         }
       }
     }
     return super.visitIfStatement(node);
   }
 
   @override
   Object visitSwitchCase(SwitchCase node) {
@@ skipping 26 matching lines @@
             // Found catch clause clause that has Object as an exception type, this is equivalent to
             // having a catch clause that doesn't have an exception type, visit the block, but
              // generate an error on any following catch clauses (and don't visit them).
             _safelyVisit(catchClause);
             if (i + 1 != numOfCatchClauses) {
                // this catch clause is not the last in the try statement
               CatchClause nextCatchClause = catchClauses[i + 1];
               CatchClause lastCatchClause = catchClauses[numOfCatchClauses - 1];
               int offset = nextCatchClause.offset;
               int length = lastCatchClause.end - offset;
-              _errorReporter.reportErrorForOffset(HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH, offset, length, []);
+              _errorReporter.reportErrorForOffset(HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH, offset, length);
               return null;
             }
           }
           for (DartType type in visitedTypes) {
             if (currentType.isSubtypeOf(type)) {
               CatchClause lastCatchClause = catchClauses[numOfCatchClauses - 1];
               int offset = catchClause.offset;
               int length = lastCatchClause.end - offset;
               _errorReporter.reportErrorForOffset(HintCode.DEAD_CODE_ON_CATCH_SUBTYPE, offset, length, [currentType.displayName, type.displayName]);
               return null;
             }
           }
           visitedTypes.add(currentType);
         }
         _safelyVisit(catchClause);
       } else {
          // Found catch clause clause that doesn't have an exception type, visit the block, but
         // generate an error on any following catch clauses (and don't visit them).
         _safelyVisit(catchClause);
         if (i + 1 != numOfCatchClauses) {
           // this catch clause is not the last in the try statement
           CatchClause nextCatchClause = catchClauses[i + 1];
           CatchClause lastCatchClause = catchClauses[numOfCatchClauses - 1];
           int offset = nextCatchClause.offset;
           int length = lastCatchClause.end - offset;
-          _errorReporter.reportErrorForOffset(HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH, offset, length, []);
+          _errorReporter.reportErrorForOffset(HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH, offset, length);
           return null;
         }
       }
     }
     return null;
   }
 
   @override
   Object visitWhileStatement(WhileStatement node) {
     Expression conditionExpression = node.condition;
     _safelyVisit(conditionExpression);
     if (!_isDebugConstant(conditionExpression)) {
       EvaluationResultImpl result = _getConstantBooleanValue(conditionExpression);
       if (result != null) {
         if (result.value.isFalse) {
           // report error on if block: while (false) {!}
-          _errorReporter.reportErrorForNode(HintCode.DEAD_CODE, node.body, []);
+          _errorReporter.reportErrorForNode(HintCode.DEAD_CODE, node.body);
           return null;
         }
       }
     }
     _safelyVisit(node.body);
     return null;
   }
 
   /**
    * Given some [NodeList] of [Statement]s, from either a [Block] or
    * [SwitchMember], this loops through the list in reverse order searching for statements
    * after a return, unlabeled break or unlabeled continue statement to mark them as dead code.
    *
    * @param statements some ordered list of statements in a [Block] or [SwitchMember]
    */
   void _checkForDeadStatementsInNodeList(NodeList<Statement> statements) {
     int size = statements.length;
     for (int i = 0; i < size; i++) {
       Statement currentStatement = statements[i];
       _safelyVisit(currentStatement);
       bool returnOrBreakingStatement = currentStatement is ReturnStatement || (currentStatement is BreakStatement && currentStatement.label == null) || (currentStatement is ContinueStatement && currentStatement.label == null);
       if (returnOrBreakingStatement && i != size - 1) {
         Statement nextStatement = statements[i + 1];
         Statement lastStatement = statements[size - 1];
         int offset = nextStatement.offset;
         int length = lastStatement.end - offset;
-        _errorReporter.reportErrorForOffset(HintCode.DEAD_CODE, offset, length, []);
+        _errorReporter.reportErrorForOffset(HintCode.DEAD_CODE, offset, length);
         return;
       }
     }
   }
 
   /**
    * Given some [Expression], this method returns [ValidResult.RESULT_TRUE] if it is
    * `true`, [ValidResult.RESULT_FALSE] if it is `false`, or `null` if the
    * expression is not a constant boolean value.
    *
    * @param expression the expression to evaluate
    * @return [ValidResult.RESULT_TRUE] if it is `true`, [ValidResult.RESULT_FALSE]
    *         if it is `false`, or `null` if the expression is not a constant boolean
    *         value
    */
   EvaluationResultImpl _getConstantBooleanValue(Expression expression) {
     if (expression is BooleanLiteral) {
       if (expression.value) {
         return new EvaluationResultImpl.con1(new DartObjectImpl(null, BoolState.from(true)));
       } else {
         return new EvaluationResultImpl.con1(new DartObjectImpl(null, BoolState.from(false)));
       }
     }
-    // Don't consider situations where we could evaluate to a constant boolean expression with the
-    // ConstantVisitor
-//
+    // Don't consider situations where we could evaluate to a constant boolean
+    // expression with the ConstantVisitor
        // else {
-//
          // EvaluationResultImpl result = expression.accept(new ConstantVisitor());
-//
          // if (result == ValidResult.RESULT_TRUE) {
-//
            // return ValidResult.RESULT_TRUE;
-//
          // } else if (result == ValidResult.RESULT_FALSE) {
-//
            // return ValidResult.RESULT_FALSE;
-//
          // }
-//
          // return null;
-//
        // }
     return null;
   }
 
   /**
    * Return `true` if and only if the passed expression is resolved to a constant variable.
    *
    * @param expression some conditional expression
    * @return `true` if and only if the passed expression is resolved to a constant variable
    */
@@ skipping 3701 matching lines @@
   /**
    * Any time after the defining compilation unit has been visited by this visitor, this method can
    * be called to report an [HintCode.DUPLICATE_IMPORT] hint for each of the import directives
    * in the [duplicateImports] list.
    *
    * @param errorReporter the error reporter to report the set of [HintCode.DUPLICATE_IMPORT]
    *          hints to
    */
   void generateDuplicateImportHints(ErrorReporter errorReporter) {
     for (ImportDirective duplicateImport in _duplicateImports) {
-      errorReporter.reportErrorForNode(HintCode.DUPLICATE_IMPORT, duplicateImport.uri, []);
+      errorReporter.reportErrorForNode(HintCode.DUPLICATE_IMPORT, duplicateImport.uri);
     }
   }
 
   /**
    * After all of the compilation units have been visited by this visitor, this method can be called
    * to report an [HintCode.UNUSED_IMPORT] hint for each of the import directives in the
    * [unusedImports] list.
    *
    * @param errorReporter the error reporter to report the set of [HintCode.UNUSED_IMPORT]
    *          hints to
    */
   void generateUnusedImportHints(ErrorReporter errorReporter) {
     for (ImportDirective unusedImport in _unusedImports) {
       // Check that the import isn't dart:core
       ImportElement importElement = unusedImport.element;
       if (importElement != null) {
         LibraryElement libraryElement = importElement.importedLibrary;
         if (libraryElement != null && libraryElement.isDartCore) {
           continue;
         }
       }
-      errorReporter.reportErrorForNode(HintCode.UNUSED_IMPORT, unusedImport.uri, []);
+      errorReporter.reportErrorForNode(HintCode.UNUSED_IMPORT, unusedImport.uri);
     }
   }
 
   @override
   Object visitCompilationUnit(CompilationUnit node) {
     if (_inDefiningCompilationUnit) {
       NodeList<Directive> directives = node.directives;
       for (Directive directive in directives) {
         if (directive is ImportDirective) {
           ImportDirective importDirective = directive;
@@ skipping 1579 matching lines @@
   /**
    * Return the result of resolving the URI of the given URI-based directive against the URI of the
    * library, or `null` if the URI is not valid. If the URI is not valid, report the error.
    *
    * @param directive the directive which URI should be resolved
    * @return the result of resolving the URI against the URI of the library
    */
   Source getSource(UriBasedDirective directive) {
     StringLiteral uriLiteral = directive.uri;
     if (uriLiteral is StringInterpolation) {
-      _errorListener.onError(new AnalysisError.con2(librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.URI_WITH_INTERPOLATION, []));
+      _errorListener.onError(new AnalysisError.con2(librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.URI_WITH_INTERPOLATION));
       return null;
     }
     String uriContent = uriLiteral.stringValue.trim();
     _directiveUris[directive] = uriContent;
     uriContent = Uri.encodeFull(uriContent);
     if (directive is ImportDirective && uriContent.startsWith(_DART_EXT_SCHEME)) {
       _libraryElement.hasExtUri = true;
       return null;
     }
     try {
@@ skipping 142 matching lines @@
           }
           if (entryPoint == null) {
             entryPoint = _findEntryPoint(part);
           }
           directive.element = part;
           sourcedCompilationUnits.add(part);
         }
       }
     }
     if (hasPartDirective && libraryNameNode == null) {
-      _errorListener.onError(new AnalysisError.con1(librarySource, ResolverErrorCode.MISSING_LIBRARY_DIRECTIVE_WITH_PART, []));
+      _errorListener.onError(new AnalysisError.con1(librarySource, ResolverErrorCode.MISSING_LIBRARY_DIRECTIVE_WITH_PART));
     }
     //
     // Create and populate the library element.
     //
     LibraryElementImpl libraryElement = new LibraryElementImpl.forNode(_analysisContext.getContextFor(librarySource), libraryNameNode);
     libraryElement.definingCompilationUnit = definingCompilationUnitElement;
     if (entryPoint != null) {
       libraryElement.entryPoint = entryPoint;
     }
     int sourcedUnitCount = sourcedCompilationUnits.length;
@@ skipping 67 matching lines @@
             if (entryPoint == null) {
               entryPoint = _findEntryPoint(part);
             }
             directive.element = part;
             sourcedCompilationUnits.add(part);
           }
         }
       }
     }
     if (hasPartDirective && libraryNameNode == null) {
-      _errorListener.onError(new AnalysisError.con1(librarySource, ResolverErrorCode.MISSING_LIBRARY_DIRECTIVE_WITH_PART, []));
+      _errorListener.onError(new AnalysisError.con1(librarySource, ResolverErrorCode.MISSING_LIBRARY_DIRECTIVE_WITH_PART));
     }
     //
     // Create and populate the library element.
     //
     LibraryElementImpl libraryElement = new LibraryElementImpl.forNode(_analysisContext.getContextFor(librarySource), libraryNameNode);
     libraryElement.definingCompilationUnit = definingCompilationUnitElement;
     if (entryPoint != null) {
       libraryElement.entryPoint = entryPoint;
     }
     int sourcedUnitCount = sourcedCompilationUnits.length;
@@ skipping 2189 matching lines @@
    * @param errorReporter the error reporter used to report errors
    */
   OverrideVerifier(this._manager, this._errorReporter);
 
   @override
   Object visitMethodDeclaration(MethodDeclaration node) {
     ExecutableElement element = node.element;
     if (_isOverride(element)) {
       if (_getOverriddenMember(element) == null) {
         if (element is MethodElement) {
-          _errorReporter.reportErrorForNode(HintCode.OVERRIDE_ON_NON_OVERRIDING_METHOD, node.name, []);
+          _errorReporter.reportErrorForNode(HintCode.OVERRIDE_ON_NON_OVERRIDING_METHOD, node.name);
         } else if (element is PropertyAccessorElement) {
           if (element.isGetter) {
-            _errorReporter.reportErrorForNode(HintCode.OVERRIDE_ON_NON_OVERRIDING_GETTER, node.name, []);
+            _errorReporter.reportErrorForNode(HintCode.OVERRIDE_ON_NON_OVERRIDING_GETTER, node.name);
           } else {
-            _errorReporter.reportErrorForNode(HintCode.OVERRIDE_ON_NON_OVERRIDING_SETTER, node.name, []);
+            _errorReporter.reportErrorForNode(HintCode.OVERRIDE_ON_NON_OVERRIDING_SETTER, node.name);
           }
         }
       }
     }
     return super.visitMethodDeclaration(node);
   }
 
   /**
    * Return the member that overrides the given member.
    *
@@ skipping 171 matching lines @@
         fullNameIndex = JavaString.lastIndexOf(fullName, '/', fullNameIndex);
         if (fullNameIndex < 4) {
           return false;
         }
         // Check for "/lib" at a specified place in the fullName
         if (StringUtilities.startsWith4(fullName, fullNameIndex - 4, 0x2F, 0x6C, 0x69, 0x62)) {
           String relativePubspecPath = path.substring(0, pathIndex + 3) + _PUBSPEC_YAML;
           Source pubspecSource = _context.sourceFactory.resolveUri(source, relativePubspecPath);
           if (_context.exists(pubspecSource)) {
             // Files inside the lib directory hierarchy should not reference files outside
-            _errorReporter.reportErrorForNode(HintCode.FILE_IMPORT_INSIDE_LIB_REFERENCES_FILE_OUTSIDE, uriLiteral, []);
+            _errorReporter.reportErrorForNode(HintCode.FILE_IMPORT_INSIDE_LIB_REFERENCES_FILE_OUTSIDE, uriLiteral);
           }
           return true;
         }
         pathIndex += 3;
       }
     }
     return false;
   }
 
   /**
@@ skipping 27 matching lines @@
     String relativePubspecPath = path.substring(0, pathIndex) + _PUBSPEC_YAML;
     Source pubspecSource = _context.sourceFactory.resolveUri(source, relativePubspecPath);
     if (!_context.exists(pubspecSource)) {
       return false;
     }
     String fullName = _getSourceFullName(source);
     if (fullName != null) {
       if (StringUtilities.indexOf5(fullName, 0, 0x2F, 0x6C, 0x69, 0x62, 0x2F) < 0) {
         // Files outside the lib directory hierarchy should not reference files inside
         // ... use package: url instead
-        _errorReporter.reportErrorForNode(HintCode.FILE_IMPORT_OUTSIDE_LIB_REFERENCES_FILE_INSIDE, uriLiteral, []);
+        _errorReporter.reportErrorForNode(HintCode.FILE_IMPORT_OUTSIDE_LIB_REFERENCES_FILE_INSIDE, uriLiteral);
         return true;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed package import directive does not contain ".."
    *
    * @param uriLiteral the import URL (not `null`)
    * @param path the path to be validated (not `null`)
    * @return `true` if and only if an error code is generated on the passed node
    * See [PubSuggestionCode.PACKAGE_IMPORT_CONTAINS_DOT_DOT].
    */
   bool _checkForPackageImportContainsDotDot(StringLiteral uriLiteral, String path) {
     if (StringUtilities.startsWith3(path, 0, 0x2E, 0x2E, 0x2F) || StringUtilities.indexOf4(path, 0, 0x2F, 0x2E, 0x2E, 0x2F) >= 0) {
       // Package import should not to contain ".."
-      _errorReporter.reportErrorForNode(HintCode.PACKAGE_IMPORT_CONTAINS_DOT_DOT, uriLiteral, []);
+      _errorReporter.reportErrorForNode(HintCode.PACKAGE_IMPORT_CONTAINS_DOT_DOT, uriLiteral);
       return true;
     }
     return false;
   }
 
   /**
    * Answer the source associated with the compilation unit containing the given AST node.
    *
    * @param node the node (not `null`)
    * @return the source or `null` if it could not be determined
@@ skipping 2638 matching lines @@
    */
   Scope get nameScope => _nameScope;
 
   /**
    * Report an error with the given error code and arguments.
    *
    * @param errorCode the error code of the error to be reported
    * @param node the node specifying the location of the error
    * @param arguments the arguments to the error, used to compose the error message
    */
-  void reportErrorForNode(ErrorCode errorCode, AstNode node, List<Object> arguments) {
+  void reportErrorForNode(ErrorCode errorCode, AstNode node, [List<Object> arguments]) {
     _errorListener.onError(new AnalysisError.con2(source, node.offset, node.length, errorCode, arguments));
   }
 
   /**
    * Report an error with the given error code and arguments.
    *
    * @param errorCode the error code of the error to be reported
    * @param offset the offset of the location of the error
    * @param length the length of the location of the error
    * @param arguments the arguments to the error, used to compose the error message
    */
-  void reportErrorForOffset(ErrorCode errorCode, int offset, int length, List<Object> arguments) {
+  void reportErrorForOffset(ErrorCode errorCode, int offset, int length, [List<Object> arguments]) {
     _errorListener.onError(new AnalysisError.con2(source, offset, length, errorCode, arguments));
   }
 
   /**
    * Report an error with the given error code and arguments.
    *
    * @param errorCode the error code of the error to be reported
    * @param token the token specifying the location of the error
    * @param arguments the arguments to the error, used to compose the error message
    */
-  void reportErrorForToken(ErrorCode errorCode, sc.Token token, List<Object> arguments) {
+  void reportErrorForToken(ErrorCode errorCode, sc.Token token, [List<Object> arguments]) {
     _errorListener.onError(new AnalysisError.con2(source, token.offset, token.length, errorCode, arguments));
   }
 
   /**
    * Visit the given AST node if it is not null.
    *
    * @param node the node to be visited
    */
   void safelyVisit(AstNode node) {
     if (node != null) {
@@ skipping 2073 matching lines @@
    *          a type
    * @param enumTypeError the error to produce if the type name is defined to be an enum
    * @param dynamicTypeError the error to produce if the type name is "dynamic"
    * @return the type specified by the type name
    */
   InterfaceType _resolveType(TypeName typeName, ErrorCode nonTypeError, ErrorCode enumTypeError, ErrorCode dynamicTypeError) {
     DartType type = typeName.type;
     if (type is InterfaceType) {
       ClassElement element = type.element;
       if (element != null && element.isEnum) {
-        reportErrorForNode(enumTypeError, typeName, []);
+        reportErrorForNode(enumTypeError, typeName);
         return null;
       }
       return type;
     }
     // If the type is not an InterfaceType, then visitTypeName() sets the type to be a DynamicTypeImpl
     Identifier name = typeName.name;
     if (name.name == sc.Keyword.DYNAMIC.syntax) {
       reportErrorForNode(dynamicTypeError, name, [name.name]);
     } else {
       reportErrorForNode(nonTypeError, name, [name.name]);
@@ skipping 463 matching lines @@
   /**
    * Return the tag that has the given identifier, or {@code null} if there is no such tag (the
    * identifier is not defined).
    *
    * @return the tag that has the given identifier
    */
   String getTagWithId(String identifier) {
     return idToTagMap[identifier];
   }
 }