Capture more errors and improve duplicate error removal

pkg/analyzer/lib/src/task/dart.dart

 // Copyright (c) 2015, 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.task.dart;
 
 import 'dart:collection';
 import 'dart:math' as math;
 
 import 'package:analyzer/src/context/cache.dart';
@@ skipping 387 matching lines @@
         cachingPolicy: ELEMENT_CACHING_POLICY);
 
 /**
  * The [UsedLocalElements] of a [LibrarySpecificUnit].
  */
 final ResultDescriptor<UsedLocalElements> USED_LOCAL_ELEMENTS =
     new ResultDescriptor<UsedLocalElements>('USED_LOCAL_ELEMENTS', null,
         cachingPolicy: ELEMENT_CACHING_POLICY);
 
 /**
+ * The errors produced while resolving variable references in a compilation unit.
+ *
+ * The list will be empty if there were no errors, but will not be `null`.
+ *
+ * The result is only available for [LibrarySpecificUnit]s.
+ */
+final ListResultDescriptor<AnalysisError> VARIABLE_REFERENCE_ERRORS =
+    new ListResultDescriptor<AnalysisError>(
+        'VARIABLE_REFERENCE_ERRORS', AnalysisError.NO_ERRORS);
+
+/**
  * The errors produced while verifying a compilation unit.
  *
  * The list will be empty if there were no errors, but will not be `null`.
  *
  * The result is only available for [LibrarySpecificUnit]s.
  */
 final ListResultDescriptor<AnalysisError> VERIFY_ERRORS =
     new ListResultDescriptor<AnalysisError>(
         'VERIFY_ERRORS', AnalysisError.NO_ERRORS);
 
 /**
- * Remove [CompileTimeErrorCode.DUPLICATE_DEFINITION] errors from the given
- * [errors] list.
+ * Return a list of errors containing the errors from the given [errors] list
+ * but with duplications removed.
  */
-void removeDuplicateDefinitionErrors(List<AnalysisError> errors) {
-  if (errors.isNotEmpty) {
-    errors.removeWhere((error) {
-      ErrorCode errorCode = error.errorCode;
-      return errorCode == CompileTimeErrorCode.DUPLICATE_DEFINITION ||
-          errorCode == CompileTimeErrorCode.GETTER_AND_METHOD_WITH_SAME_NAME ||
-          errorCode == CompileTimeErrorCode.METHOD_AND_GETTER_WITH_SAME_NAME ||
-          errorCode ==
-              CompileTimeErrorCode.PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER;
-    });
+List<AnalysisError> removeDuplicateErrors(List<AnalysisError> errors) {
+  if (errors.isEmpty) {
+    return errors;
   }
+  return errors.toSet().toList();
 }
 
 /**
  * A task that builds implicit constructors for a [ClassElement], or keeps
  * the existing explicit constructors if the class has them.
  */
 class BuildClassConstructorsTask extends SourceBasedAnalysisTask {
   /**
    * The name of the [CONSTRUCTORS] input for the superclass.
    */
@@ skipping 729 matching lines @@
     // Resolve FunctionTypeAlias declarations.
     //
     TypeResolverVisitor visitor = new TypeResolverVisitor.con2(
         libraryElement, source, typeProvider, errorListener);
     for (CompilationUnitMember member in unit.declarations) {
       if (member is FunctionTypeAlias) {
         member.accept(visitor);
       }
     }
     //
-    // Prepare errors.
-    //
-    List<AnalysisError> errors = errorListener.errors;
-    removeDuplicateDefinitionErrors(errors);
-    //
     // Record outputs.
     //
-    outputs[BUILD_FUNCTION_TYPE_ALIASES_ERRORS] = errors;
+    outputs[BUILD_FUNCTION_TYPE_ALIASES_ERRORS] =
+        removeDuplicateErrors(errorListener.errors);
     outputs[RESOLVED_UNIT3] = unit;
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the
    * given [target].
    */
   static Map<String, TaskInput> buildInputs(LibrarySpecificUnit target) {
     return <String, TaskInput>{
@@ skipping 1344 matching lines @@
   static const String RESOLVE_REFERENCES_ERRORS_INPUT =
       'RESOLVE_REFERENCES_ERRORS';
 
   /**
    * The name of the [RESOLVE_TYPE_NAMES_ERRORS] input.
    */
   static const String RESOLVE_TYPE_NAMES_ERRORS_INPUT =
       'RESOLVE_TYPE_NAMES_ERRORS';
 
   /**
+   * The name of the [VARIABLE_REFERENCE_ERRORS] input.
+   */
+  static const String VARIABLE_REFERENCE_ERRORS_INPUT =
+      'VARIABLE_REFERENCE_ERRORS';
+
+  /**
    * The name of the [VERIFY_ERRORS] input.
    */
   static const String VERIFY_ERRORS_INPUT = 'VERIFY_ERRORS';
 
   /**
    * The name of the [CONSTRUCTORS_ERRORS] input.
    */
   static const String CONSTRUCTORS_ERRORS_INPUT = 'CONSTRUCTORS_ERRORS';
 
   /**
@@ skipping 13 matching lines @@
   void internalPerform() {
     //
     // Prepare inputs.
     //
     List<List<AnalysisError>> errorLists = <List<AnalysisError>>[];
     errorLists.add(getRequiredInput(BUILD_FUNCTION_TYPE_ALIASES_ERRORS_INPUT));
     errorLists.addAll(getRequiredInput(CONSTRUCTORS_ERRORS_INPUT));
     errorLists.add(getRequiredInput(HINTS_INPUT));
     errorLists.add(getRequiredInput(RESOLVE_REFERENCES_ERRORS_INPUT));
     errorLists.add(getRequiredInput(RESOLVE_TYPE_NAMES_ERRORS_INPUT));
+    errorLists.add(getRequiredInput(VARIABLE_REFERENCE_ERRORS_INPUT));
     errorLists.add(getRequiredInput(VERIFY_ERRORS_INPUT));
     //
     // Record outputs.
     //
     outputs[LIBRARY_UNIT_ERRORS] = AnalysisError.mergeLists(errorLists);
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the
    * given [unit].
    */
   static Map<String, TaskInput> buildInputs(LibrarySpecificUnit unit) {
     return <String, TaskInput>{
       BUILD_FUNCTION_TYPE_ALIASES_ERRORS_INPUT:
           BUILD_FUNCTION_TYPE_ALIASES_ERRORS.of(unit),
       CONSTRUCTORS_ERRORS_INPUT: COMPILATION_UNIT_ELEMENT
           .of(unit)
           .mappedToList((CompilationUnitElement element) => element.types)
           .toListOf(CONSTRUCTORS_ERRORS),
       HINTS_INPUT: HINTS.of(unit),
       RESOLVE_REFERENCES_ERRORS_INPUT: RESOLVE_REFERENCES_ERRORS.of(unit),
       RESOLVE_TYPE_NAMES_ERRORS_INPUT: RESOLVE_TYPE_NAMES_ERRORS.of(unit),
+      VARIABLE_REFERENCE_ERRORS_INPUT: VARIABLE_REFERENCE_ERRORS.of(unit),
       VERIFY_ERRORS_INPUT: VERIFY_ERRORS.of(unit)
     };
   }
 
   /**
    * Create a [LibraryUnitErrorsTask] based on the given [target] in the given
    * [context].
    */
   static LibraryUnitErrorsTask createTask(
       AnalysisContext context, AnalysisTarget target) {
@@ skipping 108 matching lines @@
       sourceKind = SourceKind.PART;
     }
     //
     // Record outputs.
     //
     List<Source> explicitlyImportedSources =
         explicitlyImportedSourceSet.toList();
     List<Source> exportedSources = exportedSourceSet.toList();
     List<Source> importedSources = importedSourceSet.toList();
     List<Source> includedSources = includedSourceSet.toList();
-    List<AnalysisError> parseErrors = errorListener.errors;
+    List<AnalysisError> parseErrors =
+        removeDuplicateErrors(errorListener.errors);
     List<Source> unitSources = <Source>[source]..addAll(includedSourceSet);
     outputs[EXPLICITLY_IMPORTED_LIBRARIES] = explicitlyImportedSources;
     outputs[EXPORTED_LIBRARIES] = exportedSources;
     outputs[IMPORTED_LIBRARIES] = importedSources;
     outputs[INCLUDED_PARTS] = includedSources;
     outputs[PARSE_ERRORS] = parseErrors;
     outputs[PARSED_UNIT] = unit;
     outputs[SOURCE_KIND] = sourceKind;
     outputs[UNITS] = unitSources;
   }
@@ skipping 203 matching lines @@
     // Resolve references.
     //
     InheritanceManager inheritanceManager =
         new InheritanceManager(libraryElement);
     AstVisitor visitor = new ResolverVisitor.con2(libraryElement,
         unitElement.source, typeProvider, inheritanceManager, errorListener);
     unit.accept(visitor);
     //
     // Record outputs.
     //
-    outputs[RESOLVE_REFERENCES_ERRORS] = errorListener.errors;
+    outputs[RESOLVE_REFERENCES_ERRORS] =
+        removeDuplicateErrors(errorListener.errors);
     outputs[RESOLVED_UNIT6] = unit;
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the
    * given [target].
    */
   static Map<String, TaskInput> buildInputs(LibrarySpecificUnit target) {
     return <String, TaskInput>{
@@ skipping 58 matching lines @@
     CompilationUnit unit = getRequiredInput(UNIT_INPUT);
     CompilationUnitElement unitElement = unit.element;
     TypeProvider typeProvider = getRequiredInput(TYPE_PROVIDER_INPUT);
     //
     // Resolve TypeName nodes.
     //
     TypeResolverVisitor visitor = new TypeResolverVisitor.con2(
         library, unitElement.source, typeProvider, errorListener);
     unit.accept(visitor);
     //
-    // Prepare errors.
-    //
-    List<AnalysisError> errors = errorListener.errors;
-    removeDuplicateDefinitionErrors(errors);
-    //
     // Record outputs.
     //
-    outputs[RESOLVE_TYPE_NAMES_ERRORS] = errors;
+    outputs[RESOLVE_TYPE_NAMES_ERRORS] =
+        removeDuplicateErrors(errorListener.errors);
     outputs[RESOLVED_UNIT4] = unit;
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the
    * given [target].
    */
   static Map<String, TaskInput> buildInputs(LibrarySpecificUnit target) {
     return <String, TaskInput>{
@@ skipping 30 matching lines @@
   /**
    * The name of the [TYPE_PROVIDER] input.
    */
   static const String TYPE_PROVIDER_INPUT = 'TYPE_PROVIDER_INPUT';
 
   /**
    * The task descriptor describing this kind of task.
    */
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'ResolveVariableReferencesTask', createTask, buildInputs,
-      <ResultDescriptor>[RESOLVED_UNIT5]);
+      <ResultDescriptor>[RESOLVED_UNIT5, VARIABLE_REFERENCE_ERRORS]);
 
   ResolveVariableReferencesTask(
       InternalAnalysisContext context, AnalysisTarget target)
       : super(context, target);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   void internalPerform() {
     RecordingErrorListener errorListener = new RecordingErrorListener();
     //
     // Prepare inputs.
     //
     LibraryElement libraryElement = getRequiredInput(LIBRARY_INPUT);
     CompilationUnit unit = getRequiredInput(UNIT_INPUT);
     CompilationUnitElement unitElement = unit.element;
     //
     // Resolve local variables.
     //
     TypeProvider typeProvider = getRequiredInput(TYPE_PROVIDER_INPUT);
     Scope nameScope = new LibraryScope(libraryElement, errorListener);
     AstVisitor visitor = new VariableResolverVisitor.con2(libraryElement,
         unitElement.source, typeProvider, nameScope, errorListener);
     unit.accept(visitor);
     //
     // Record outputs.
     //
     outputs[RESOLVED_UNIT5] = unit;
+    outputs[VARIABLE_REFERENCE_ERRORS] =
+        removeDuplicateErrors(errorListener.errors);
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the
    * given [target].
    */
   static Map<String, TaskInput> buildInputs(LibrarySpecificUnit target) {
     return <String, TaskInput>{
       'fullyBuiltLibraryElements': IMPORT_EXPORT_SOURCE_CLOSURE
@@ skipping 49 matching lines @@
     Source source = getRequiredSource();
     String content = getRequiredInput(CONTENT_INPUT_NAME);
 
     RecordingErrorListener errorListener = new RecordingErrorListener();
     Scanner scanner =
         new Scanner(source, new CharSequenceReader(content), errorListener);
     scanner.preserveComments = context.analysisOptions.preserveComments;
     scanner.enableNullAwareOperators =
         context.analysisOptions.enableNullAwareOperators;
 
-    Token tokenStream = scanner.tokenize();
-    LineInfo lineInfo = new LineInfo(scanner.lineStarts);
-    List<AnalysisError> errors = errorListener.errors;
-    outputs[TOKEN_STREAM] = tokenStream;
-    outputs[LINE_INFO] = lineInfo;
-    outputs[SCAN_ERRORS] = errors;
+    outputs[TOKEN_STREAM] = scanner.tokenize();
+    outputs[LINE_INFO] = new LineInfo(scanner.lineStarts);
+    outputs[SCAN_ERRORS] = removeDuplicateErrors(errorListener.errors);
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the given
    * [source].
    */
   static Map<String, TaskInput> buildInputs(Source source) {
     return <String, TaskInput>{CONTENT_INPUT_NAME: CONTENT.of(source)};
   }
@@ skipping 62 matching lines @@
     unit.accept(errorVerifier);
     //
     // Use the ConstantVerifier to compute errors.
     //
     ConstantVerifier constantVerifier = new ConstantVerifier(
         errorReporter, libraryElement, typeProvider, context.declaredVariables);
     unit.accept(constantVerifier);
     //
     // Record outputs.
     //
-    outputs[VERIFY_ERRORS] = errorListener.errors;
+    outputs[VERIFY_ERRORS] = removeDuplicateErrors(errorListener.errors);
   }
 
   /**
    * Check each directive in the given [unit] to see if the referenced source
    * exists and report an error if it does not.
    */
   void validateDirectives(CompilationUnit unit) {
     for (Directive directive in unit.directives) {
       if (directive is UriBasedDirective) {
         validateReferencedSource(directive);
@@ skipping 144 matching lines @@
   @override
   bool moveNext() {
     if (_newSources.isEmpty) {
       return false;
     }
     currentTarget = _newSources.first;
     _newSources.remove(currentTarget);
     return true;
   }
 }