Filter out ignored errors without tasks.

pkg/analyzer/lib/src/dart/analysis/analysis_impl.dart

 // Copyright (c) 2017, 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.
 
 import 'package:analyzer/context/declared_variables.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/error/listener.dart';
@@ skipping 28 matching lines @@
   final SourceFactory _sourceFactory;
   final FileSystemState _fsState;
   final SummaryDataStore _store;
   final FileState _library;
 
   TypeProvider _typeProvider;
   AnalysisContextImpl _context;
   StoreBasedSummaryResynthesizer _resynthesizer;
   LibraryElement _libraryElement;
 
+  final Map<FileState, LineInfo> _fileToLineInfo = {};
+  final Map<FileState, IgnoreInfo> _fileToIgnoreInfo = {};
+
   final Map<FileState, RecordingErrorListener> _errorListeners = {};
   final Map<FileState, ErrorReporter> _errorReporters = {};
   final List<UsedImportedElements> _usedImportedElementsList = [];
   final List<UsedLocalElements> _usedLocalElementsList = [];
   final List<ConstantEvaluationTarget> _constants = [];
 
   AnalyzerImpl(this._analysisOptions, this._declaredVariables,
       this._sourceFactory, this._fsState, this._store, this._library);
 
   /**
@@ skipping 48 matching lines @@
         _computeVerifyErrorsAndHints(file, unit);
       });
     } finally {
       _context.dispose();
     }
 
     // Return full results.
     Map<FileState, UnitAnalysisResult> results = {};
     units.forEach((file, unit) {
       List<AnalysisError> errors = _getErrorListener(file).errors;
+      errors = _filterIgnoredErrors(file, errors);
       results[file] = new UnitAnalysisResult(file, unit, errors);
     });
     return results;
   }
 
   /**
    * Compute [_constants] in all units.
    */
   void _computeConstants() {
     ConstantEvaluationEngine evaluationEngine = new ConstantEvaluationEngine(
@@ skipping 129 matching lines @@
   void _createAnalysisContext() {
     AnalysisContextImpl analysisContext =
         AnalysisEngine.instance.createAnalysisContext();
     analysisContext.analysisOptions = _analysisOptions;
     analysisContext.declaredVariables.addAll(_declaredVariables);
     analysisContext.sourceFactory = _sourceFactory.clone();
     analysisContext.contentCache = new _ContentCacheWrapper(_fsState);
     this._context = analysisContext;
   }
 
+  /**
+   * Return a subset of the given [errors] that are not marked as ignored in
+   * the [file].
+   */
+  List<AnalysisError> _filterIgnoredErrors(
+      FileState file, List<AnalysisError> errors) {
+    if (errors.isEmpty) {
+      return errors;
+    }
+
+    IgnoreInfo ignoreInfo = _fileToIgnoreInfo[file];
+    if (!ignoreInfo.hasIgnores) {
+      return errors;
+    }
+
+    LineInfo lineInfo = _fileToLineInfo[file];
+
+    bool isIgnored(AnalysisError error) {
+      int errorLine = lineInfo.getLocation(error.offset).lineNumber;
+      String errorCode = error.errorCode.name.toLowerCase();
+      // Ignores can be on the line or just preceding the error.
+      return ignoreInfo.ignoredAt(errorCode, errorLine) ||
+          ignoreInfo.ignoredAt(errorCode, errorLine - 1);
+    }
+
+    return errors.where((AnalysisError e) => !isIgnored(e)).toList();
+  }
+
   RecordingErrorListener _getErrorListener(FileState file) =>
       _errorListeners.putIfAbsent(file, () => new RecordingErrorListener());
 
   ErrorReporter _getErrorReporter(FileState file) {
     return _errorReporters.putIfAbsent(file, () {
       RecordingErrorListener listener = _getErrorListener(file);
       return new ErrorReporter(listener, file.source);
     });
   }
 
@@ skipping 21 matching lines @@
     }
     return null;
   }
 
   /**
    * Return a new parsed unresolved [CompilationUnit].
    */
   CompilationUnit _parse(FileState file) {
     RecordingErrorListener errorListener = _getErrorListener(file);
 
-    CharSequenceReader reader = new CharSequenceReader(file.content);
+    String content = file.content;
+
+    CharSequenceReader reader = new CharSequenceReader(content);
     Scanner scanner = new Scanner(file.source, reader, errorListener);
     scanner.scanGenericMethodComments = _analysisOptions.strongMode;
     Token token = scanner.tokenize();
     LineInfo lineInfo = new LineInfo(scanner.lineStarts);
 
+    _fileToLineInfo[file] = lineInfo;
+    _fileToIgnoreInfo[file] = IgnoreInfo.calculateIgnores(content, lineInfo);
+
     Parser parser = new Parser(file.source, errorListener);
     parser.parseGenericMethodComments = _analysisOptions.strongMode;
     parser.enableUriInPartOf = _analysisOptions.enableUriInPartOf;
     CompilationUnit unit = parser.parseCompilationUnit(token);
     unit.lineInfo = lineInfo;
     return unit;
   }
 
   void _resolveDirectives(Map<FileState, CompilationUnit> units) {
     CompilationUnit definingCompilationUnit = units[_library];
@@ skipping 354 matching lines @@
 }
 
 /**
  * Either the name or the source associated with a part-of directive.
  */
 class _NameOrSource {
   final String name;
   final Source source;
   _NameOrSource(this.name, this.source);
 }