Use ErrorReporter in many places.

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 analyzer.src.generated.resolver;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 7490 matching lines @@
    * The element for the library containing the compilation unit being visited.
    */
   final LibraryElement definingLibrary;
 
   /**
    * The source representing the compilation unit being visited.
    */
   final Source source;
 
   /**
-   * The error listener that will be informed of any errors that are found during resolution.
+   * The object used to access the types from the core library.
    */
-  final AnalysisErrorListener errorListener;
+  final TypeProvider typeProvider;
+
+  /**
+   * The error reporter that will be informed of any errors that are found
+   * during resolution.
+   */
+  final ErrorReporter errorReporter;
 
   /**
    * The scope used to resolve identifiers.
    */
   Scope nameScope;
 
   /**
-   * The object used to access the types from the core library.
-   */
-  final TypeProvider typeProvider;
-
-  /**
    * The scope used to resolve unlabeled `break` and `continue` statements.
    */
   ImplicitLabelScope _implicitLabelScope = ImplicitLabelScope.ROOT;
 
   /**
    * The scope used to resolve labels for `break` and `continue` statements, or
    * `null` if no labels have been defined in the current context.
    */
   LabelScope labelScope;
 
@@ skipping 11 matching lines @@
    * compilation unit being visited.
    * [source] is the source representing the compilation unit being visited.
    * [typeProvider] is the object used to access the types from the core
    * library.
    * [errorListener] is the error listener that will be informed of any errors
    * that are found during resolution.
    * [nameScope] is the scope used to resolve identifiers in the node that will
    * first be visited.  If `null` or unspecified, a new [LibraryScope] will be
    * created based on [definingLibrary] and [typeProvider].
    */
-  ScopedVisitor(
-      this.definingLibrary, this.source, this.typeProvider, this.errorListener,
-      {Scope nameScope}) {
+  ScopedVisitor(this.definingLibrary, Source source, this.typeProvider,
+      AnalysisErrorListener errorListener,
+      {Scope nameScope})
+      : source = source,
+        errorReporter = new ErrorReporter(errorListener, source) {
     if (nameScope == null) {
       this.nameScope = new LibraryScope(definingLibrary, errorListener);
     } else {
       this.nameScope = nameScope;
     }
   }
 
   /**
    * Return the implicit label scope in which the current node is being
    * resolved.
@@ skipping 14 matching lines @@
    * Pushes a new [Scope] into the visitor.
    *
    * @return the new [Scope].
    */
   Scope pushNameScope() {
     Scope newScope = new EnclosedScope(nameScope);
     nameScope = newScope;
     return 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]) {
-    errorListener.onError(new AnalysisError(
-        source, node.offset, node.length, errorCode, arguments));
-  }
-
-  /**
-   * Report an error with the given error code and arguments.
-   *
-   * @param errorCode the error code of the error to be reported
-   * @param offset the offset of the location of the error
-   * @param length the length of the location of the error
-   * @param arguments the arguments to the error, used to compose the error message
-   */
-  void reportErrorForOffset(ErrorCode errorCode, int offset, int length,
-      [List<Object> arguments]) {
-    errorListener.onError(
-        new AnalysisError(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, Token token,
-      [List<Object> arguments]) {
-    errorListener.onError(new AnalysisError(
-        source, token.offset, token.length, errorCode, arguments));
-  }
-
   @override
   Object visitBlock(Block node) {
     Scope outerScope = nameScope;
     try {
       EnclosedScope enclosedScope = new EnclosedScope(nameScope);
       _hideNamesDefinedInBlock(enclosedScope, node);
       nameScope = enclosedScope;
       super.visitBlock(node);
     } finally {
       nameScope = outerScope;
@@ skipping 762 matching lines @@
 /**
  * Helper for resolving [TypeName]s.
  *
  * The client must set [nameScope] before calling [resolveTypeName].
  */
 class TypeNameResolver {
   final TypeSystem typeSystem;
   final DartType dynamicType;
   final DartType undefinedType;
   final LibraryElement definingLibrary;
-  final Source source;
-  final AnalysisErrorListener errorListener;
+  final ErrorReporter errorReporter;
 
   Scope nameScope;
 
   TypeNameResolver(this.typeSystem, TypeProvider typeProvider,
-      this.definingLibrary, this.source, this.errorListener)
+      this.definingLibrary, this.errorReporter)
       : dynamicType = typeProvider.dynamicType,
         undefinedType = typeProvider.undefinedType;
 
   /**
-   * Report an error with the given error code and arguments.
-   *
-   * @param errorCode the error code of the error to be reported
-   * @param node the node specifying the location of the error
-   * @param arguments the arguments to the error, used to compose the error message
-   */
-  void reportErrorForNode(ErrorCode errorCode, AstNode node,
-      [List<Object> arguments]) {
-    errorListener.onError(new AnalysisError(
-        source, node.offset, node.length, errorCode, arguments));
-  }
-
-  /**
    * Resolve the given [TypeName] - set its element and static type. Only the
    * given [node] is resolved, all its children must be already resolved.
    *
    * The client must set [nameScope] before calling [resolveTypeName].
    */
   void resolveTypeName(TypeName node) {
     Identifier typeName = node.name;
     _setElement(typeName, null); // Clear old Elements from previous run.
     TypeArgumentList argumentList = node.typeArguments;
     Element element = nameScope.lookup(typeName, definingLibrary);
@@ skipping 38 matching lines @@
           PrefixedIdentifier prefixedIdentifier =
               typeName as PrefixedIdentifier;
           SimpleIdentifier prefix = prefixedIdentifier.prefix;
           element = nameScope.lookup(prefix, definingLibrary);
           if (element is PrefixElement) {
             AstNode grandParent = parent.parent;
             if (grandParent is InstanceCreationExpression &&
                 grandParent.isConst) {
               // If, if this is a const expression, then generate a
               // CompileTimeErrorCode.CONST_WITH_NON_TYPE error.
-              reportErrorForNode(
+              errorReporter.reportErrorForNode(
                   CompileTimeErrorCode.CONST_WITH_NON_TYPE,
                   prefixedIdentifier.identifier,
                   [prefixedIdentifier.identifier.name]);
             } else {
               // Else, if this expression is a new expression, report a
               // NEW_WITH_NON_TYPE warning.
-              reportErrorForNode(
+              errorReporter.reportErrorForNode(
                   StaticWarningCode.NEW_WITH_NON_TYPE,
                   prefixedIdentifier.identifier,
                   [prefixedIdentifier.identifier.name]);
             }
             _setElement(prefix, element);
             return;
           } else if (element != null) {
             //
             // Rewrite the constructor name. The parser, when it sees a
             // constructor named "a.b", cannot tell whether "a" is a prefix and
@@ skipping 12 matching lines @@
     // check element
     bool elementValid = element is! MultiplyDefinedElement;
     if (elementValid &&
         element is! ClassElement &&
         _isTypeNameInInstanceCreationExpression(node)) {
       SimpleIdentifier typeNameSimple = _getTypeSimpleIdentifier(typeName);
       InstanceCreationExpression creation =
           node.parent.parent as InstanceCreationExpression;
       if (creation.isConst) {
         if (element == null) {
-          reportErrorForNode(
+          errorReporter.reportErrorForNode(
               CompileTimeErrorCode.UNDEFINED_CLASS, typeNameSimple, [typeName]);
         } else {
-          reportErrorForNode(CompileTimeErrorCode.CONST_WITH_NON_TYPE,
-              typeNameSimple, [typeName]);
+          errorReporter.reportErrorForNode(
+              CompileTimeErrorCode.CONST_WITH_NON_TYPE,
+              typeNameSimple,
+              [typeName]);
         }
         elementValid = false;
       } else {
         if (element != null) {
-          reportErrorForNode(
+          errorReporter.reportErrorForNode(
               StaticWarningCode.NEW_WITH_NON_TYPE, typeNameSimple, [typeName]);
           elementValid = false;
         }
       }
     }
     if (elementValid && element == null) {
       // We couldn't resolve the type name.
       // TODO(jwren) Consider moving the check for
       // CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE from the
       // ErrorVerifier, so that we don't have two errors on a built in
       // identifier being used as a class name.
       // See CompileTimeErrorCodeTest.test_builtInIdentifierAsType().
       SimpleIdentifier typeNameSimple = _getTypeSimpleIdentifier(typeName);
       RedirectingConstructorKind redirectingConstructorKind;
       if (_isBuiltInIdentifier(node) && _isTypeAnnotation(node)) {
-        reportErrorForNode(CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE,
-            typeName, [typeName.name]);
+        errorReporter.reportErrorForNode(
+            CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE,
+            typeName,
+            [typeName.name]);
       } else if (typeNameSimple.name == "boolean") {
-        reportErrorForNode(
+        errorReporter.reportErrorForNode(
             StaticWarningCode.UNDEFINED_CLASS_BOOLEAN, typeNameSimple, []);
       } else if (_isTypeNameInCatchClause(node)) {
-        reportErrorForNode(StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE, typeName,
+        errorReporter.reportErrorForNode(
+            StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE,
+            typeName,
             [typeName.name]);
       } else if (_isTypeNameInAsExpression(node)) {
-        reportErrorForNode(
+        errorReporter.reportErrorForNode(
             StaticWarningCode.CAST_TO_NON_TYPE, typeName, [typeName.name]);
       } else if (_isTypeNameInIsExpression(node)) {
-        reportErrorForNode(StaticWarningCode.TYPE_TEST_WITH_UNDEFINED_NAME,
-            typeName, [typeName.name]);
+        errorReporter.reportErrorForNode(
+            StaticWarningCode.TYPE_TEST_WITH_UNDEFINED_NAME,
+            typeName,
+            [typeName.name]);
       } else if ((redirectingConstructorKind =
               _getRedirectingConstructorKind(node)) !=
           null) {
         ErrorCode errorCode =
             (redirectingConstructorKind == RedirectingConstructorKind.CONST
                 ? CompileTimeErrorCode.REDIRECT_TO_NON_CLASS
                 : StaticWarningCode.REDIRECT_TO_NON_CLASS);
-        reportErrorForNode(errorCode, typeName, [typeName.name]);
+        errorReporter.reportErrorForNode(errorCode, typeName, [typeName.name]);
       } else if (_isTypeNameInTypeArgumentList(node)) {
-        reportErrorForNode(StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT,
-            typeName, [typeName.name]);
+        errorReporter.reportErrorForNode(
+            StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT,
+            typeName,
+            [typeName.name]);
       } else {
-        reportErrorForNode(
+        errorReporter.reportErrorForNode(
             StaticWarningCode.UNDEFINED_CLASS, typeName, [typeName.name]);
       }
       elementValid = false;
     }
     if (!elementValid) {
       if (element is MultiplyDefinedElement) {
         _setElement(typeName, element);
       }
       typeName.staticType = undefinedType;
       node.type = undefinedType;
@@ skipping 17 matching lines @@
     } else if (element is MultiplyDefinedElement) {
       List<Element> elements = element.conflictingElements;
       type = _getTypeWhenMultiplyDefined(elements);
       if (type != null) {
         node.type = type;
       }
     } else {
       // The name does not represent a type.
       RedirectingConstructorKind redirectingConstructorKind;
       if (_isTypeNameInCatchClause(node)) {
-        reportErrorForNode(StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE, typeName,
+        errorReporter.reportErrorForNode(
+            StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE,
+            typeName,
             [typeName.name]);
       } else if (_isTypeNameInAsExpression(node)) {
-        reportErrorForNode(
+        errorReporter.reportErrorForNode(
             StaticWarningCode.CAST_TO_NON_TYPE, typeName, [typeName.name]);
       } else if (_isTypeNameInIsExpression(node)) {
-        reportErrorForNode(StaticWarningCode.TYPE_TEST_WITH_NON_TYPE, typeName,
+        errorReporter.reportErrorForNode(
+            StaticWarningCode.TYPE_TEST_WITH_NON_TYPE,
+            typeName,
             [typeName.name]);
       } else if ((redirectingConstructorKind =
               _getRedirectingConstructorKind(node)) !=
           null) {
         ErrorCode errorCode =
             (redirectingConstructorKind == RedirectingConstructorKind.CONST
                 ? CompileTimeErrorCode.REDIRECT_TO_NON_CLASS
                 : StaticWarningCode.REDIRECT_TO_NON_CLASS);
-        reportErrorForNode(errorCode, typeName, [typeName.name]);
+        errorReporter.reportErrorForNode(errorCode, typeName, [typeName.name]);
       } else if (_isTypeNameInTypeArgumentList(node)) {
-        reportErrorForNode(StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT,
-            typeName, [typeName.name]);
+        errorReporter.reportErrorForNode(
+            StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT,
+            typeName,
+            [typeName.name]);
       } else {
         AstNode parent = typeName.parent;
         while (parent is TypeName) {
           parent = parent.parent;
         }
         if (parent is ExtendsClause ||
             parent is ImplementsClause ||
             parent is WithClause ||
             parent is ClassTypeAlias) {
           // Ignored. The error will be reported elsewhere.
         } else {
-          reportErrorForNode(
+          errorReporter.reportErrorForNode(
               StaticWarningCode.NOT_A_TYPE, typeName, [typeName.name]);
         }
       }
       typeName.staticType = dynamicType;
       node.type = dynamicType;
       return;
     }
     if (argumentList != null) {
       NodeList<TypeName> arguments = argumentList.arguments;
       int argumentCount = arguments.length;
       List<DartType> parameters = typeSystem.typeFormalsAsTypes(type);
       int parameterCount = parameters.length;
       List<DartType> typeArguments = new List<DartType>(parameterCount);
       if (argumentCount == parameterCount) {
         for (int i = 0; i < parameterCount; i++) {
           TypeName argumentTypeName = arguments[i];
           DartType argumentType = _getType(argumentTypeName);
           if (argumentType == null) {
             argumentType = dynamicType;
           }
           typeArguments[i] = argumentType;
         }
       } else {
-        reportErrorForNode(_getInvalidTypeParametersErrorCode(node), node,
+        errorReporter.reportErrorForNode(
+            _getInvalidTypeParametersErrorCode(node),
+            node,
             [typeName.name, parameterCount, argumentCount]);
         for (int i = 0; i < parameterCount; i++) {
           typeArguments[i] = dynamicType;
         }
       }
       type = typeSystem.instantiateType(type, typeArguments);
     } else {
       type = typeSystem.instantiateToBounds(type);
     }
     typeName.staticType = type;
@@ skipping 1048 matching lines @@
    */
   TypeResolverVisitor(LibraryElement definingLibrary, Source source,
       TypeProvider typeProvider, AnalysisErrorListener errorListener,
       {Scope nameScope})
       : super(definingLibrary, source, typeProvider, errorListener,
             nameScope: nameScope) {
     _dynamicType = typeProvider.dynamicType;
     _undefinedType = typeProvider.undefinedType;
     _strongMode = definingLibrary.context.analysisOptions.strongMode;
     _typeSystem = TypeSystem.create(definingLibrary.context);
-    _typeNameResolver = new TypeNameResolver(
-        _typeSystem, typeProvider, definingLibrary, source, errorListener);
+    _typeNameResolver = new TypeNameResolver(_typeSystem, typeProvider,
+        definingLibrary, new ErrorReporter(errorListener, source));
   }
 
   @override
   Object visitAnnotation(Annotation node) {
     //
     // Visit annotations, if the annotation is @proxy, on a class, and "proxy"
     // resolves to the proxy annotation in dart.core, then resolve the
     // ElementAnnotation.
     //
     // Element resolution is done in the ElementResolver, and this work will be
@@ skipping 503 matching lines @@
         TypeName typeName = interfaces[i];
         if (!detectedRepeatOnIndex[i]) {
           Element element = typeName.name.staticElement;
           for (int j = i + 1; j < count; j++) {
             TypeName typeName2 = interfaces[j];
             Identifier identifier2 = typeName2.name;
             String name2 = identifier2.name;
             Element element2 = identifier2.staticElement;
             if (element != null && element == element2) {
               detectedRepeatOnIndex[j] = true;
-              reportErrorForNode(
+              errorReporter.reportErrorForNode(
                   CompileTimeErrorCode.IMPLEMENTS_REPEATED, typeName2, [name2]);
             }
           }
         }
       }
     }
   }
 
   /**
    * Return the type specified by the given name.
    *
    * @param typeName the type name specifying the type to be returned
    * @param nonTypeError the error to produce if the type name is defined to be something other than
    *          a type
    * @param enumTypeError the error to produce if the type name is defined to be an enum
    * @param dynamicTypeError the error to produce if the type name is "dynamic"
    * @return 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);
+        errorReporter.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 == Keyword.DYNAMIC.syntax) {
-      reportErrorForNode(dynamicTypeError, name, [name.name]);
+      errorReporter.reportErrorForNode(dynamicTypeError, name, [name.name]);
     } else {
-      reportErrorForNode(nonTypeError, name, [name.name]);
+      errorReporter.reportErrorForNode(nonTypeError, name, [name.name]);
     }
     return null;
   }
 
   /**
    * Resolve the types in the given list of type names.
    *
    * @param typeNames the type names to be resolved
    * @param nonTypeError the error to produce if the type name is defined to be something other than
    *          a type
@@ skipping 573 matching lines @@
       return null;
     }
     if (identical(node.staticElement, variable)) {
       if (node.inSetterContext()) {
         result = true;
       }
     }
     return null;
   }
 }