Disable computing errors for .pub-cache sources.

pkg/analyzer_cli/lib/src/analyzer_impl.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_cli.src.analyzer_impl;
 
 import 'dart:collection';
 import 'dart:io';
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/source/error_processor.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/java_io.dart';
 import 'package:analyzer/src/generated/sdk_io.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/generated/utilities_general.dart';
 import 'package:analyzer_cli/src/driver.dart';
 import 'package:analyzer_cli/src/error_formatter.dart';
 import 'package:analyzer_cli/src/options.dart';
+import 'package:path/path.dart' as pathos;
 
 /// The maximum number of sources for which AST structures should be kept in the cache.
 const int _maxCacheSize = 512;
 
 DirectoryBasedDartSdk sdk;
 
 int currentTimeMillis() => new DateTime.now().millisecondsSinceEpoch;
 
 /// Analyzes single library [File].
 class AnalyzerImpl {
@@ skipping 139 matching lines @@
     // Compute max severity and set exitCode.
     ErrorSeverity status = maxErrorSeverity;
     if (status == ErrorSeverity.WARNING && options.warningsAreFatal) {
       status = ErrorSeverity.ERROR;
     }
     return status;
   }
 
   /// Returns true if we want to report diagnostics for this library.
   bool _isAnalyzedLibrary(LibraryElement library) {
-    switch (library.source.uriKind) {
+    Source source = library.source;
+    switch (source.uriKind) {
       case UriKind.DART_URI:
         return options.showSdkWarnings;
       case UriKind.PACKAGE_URI:
-        return _isAnalyzedPackage(library.source.uri);
+        if (_isPathInPubCache(source.fullName)) {
+          return false;
+        }
+        return _isAnalyzedPackage(source.uri);
       default:
         return true;
     }
   }
 
   /// Determine whether the given URI refers to a package being analyzed.
   bool _isAnalyzedPackage(Uri uri) {
     if (uri.scheme != 'package' || uri.pathSegments.isEmpty) {
       return false;
     }
-
     String packageName = uri.pathSegments.first;
     if (packageName == _selfPackageName) {
       return true;
     } else if (!options.showPackageWarnings) {
       return false;
     } else if (options.showPackageWarningsPrefix == null) {
       return true;
     } else {
       return packageName.startsWith(options.showPackageWarningsPrefix);
     }
@@ skipping 113 matching lines @@
     // If not overridden, some "natural" severities get globally filtered.
     if (!isOverridden) {
       // Check for global hint filtering.
       if (severity == ErrorSeverity.INFO && options.disableHints) {
         return null;
       }
     }
 
     return new ProcessedSeverity(severity, isOverridden);
   }
+
+  /// Return `true` if the given [path] is in the Pub cache.
+  static bool _isPathInPubCache(String path) {
+    List<String> parts = pathos.split(path);
+    if (parts.contains('.pub-cache')) {
+      return true;
+    }
+    for (int i = 0; i < parts.length - 2; i++) {
+      if (parts[i] == 'Pub' && parts[i + 1] == 'Cache') {
+        return true;
+      }
+    }
+    return false;
+  }
 }
 
 /// This [Logger] prints out information comments to [outSink] and error messages
 /// to [errorSink].
 class StdLogger extends Logger {
   StdLogger();
 
   @override
   void logError(String message, [CaughtException exception]) {
     errorSink.writeln(message);
     if (exception != null) {
       errorSink.writeln(exception);
     }
   }
 
   @override
   void logInformation(String message, [CaughtException exception]) {
     outSink.writeln(message);
     if (exception != null) {
       outSink.writeln(exception);
     }
   }
 }