Don't suppress error/warning output for package being analyzed.

pkg/analyzer/lib/src/analyzer_impl.dart

 // Copyright (c) 2013, 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_impl;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:io';
 
@@ skipping 43 matching lines @@
   /// All [Source]s references by the analyzed library.
   final Set<Source> sources = new Set<Source>();
 
   /// All [AnalysisErrorInfo]s in the analyzed library.
   final List<AnalysisErrorInfo> errorInfos = new List<AnalysisErrorInfo>();
 
   /// [HashMap] between sources and analysis error infos.
   final HashMap<Source, AnalysisErrorInfo> sourceErrorsMap =
       new HashMap<Source, AnalysisErrorInfo>();
 
+  /**
+   * If the file specified on the command line is part of a package, the name
+   * of that package.  Otherwise `null`.  This allows us to analyze the file
+   * specified on the command line as though it is reached via a "package:"
+   * URI, but avoid suppressing its output in the event that the user has not
+   * specified the "--package-warnings" option.
+   */
+  String _selfPackageName;
+
   AnalyzerImpl(String sourcePath, this.options, this.startTime, this.isBatch)
       : sourcePath = _normalizeSourcePath(sourcePath) {
     if (sdk == null) {
       sdk = new DirectoryBasedDartSdk(new JavaFile(options.dartSdkPath));
     }
   }
 
   /// Returns the maximal [ErrorSeverity] of the recorded errors.
   ErrorSeverity get maxErrorSeverity {
     var status = ErrorSeverity.NONE;
@@ skipping 20 matching lines @@
 
   void addLibrarySources(LibraryElement library, Set<LibraryElement> libraries,
       Set<CompilationUnitElement> units) {
     if (library == null || !libraries.add(library)) {
       return;
     }
     // may be skip library
     {
       UriKind uriKind = library.source.uriKind;
       // Optionally skip package: libraries.
-      if (!options.showPackageWarnings && uriKind == UriKind.PACKAGE_URI) {
+      if (!options.showPackageWarnings && _isOtherPackage(library.source.uri)) {
         return;
       }
       // Optionally skip SDK libraries.
       if (!options.showSdkWarnings && uriKind == UriKind.DART_URI) {
         return;
       }
     }
     // add compilation units
     addCompilationUnitSource(library.definingCompilationUnit, libraries, units);
     for (CompilationUnitElement child in library.parts) {
@@ skipping 88 matching lines @@
     contextOptions.cacheSize = _MAX_CACHE_SIZE;
     contextOptions.hint = !options.disableHints;
     contextOptions.analyzeFunctionBodiesPredicate =
         _analyzeFunctionBodiesPredicate;
     contextOptions.generateImplicitErrors = options.showPackageWarnings;
     contextOptions.generateSdkErrors = options.showSdkWarnings;
     context.analysisOptions = contextOptions;
 
     librarySource = computeLibrarySource();
 
+    Uri libraryUri = librarySource.uri;
+    if (libraryUri.scheme == 'package' && libraryUri.pathSegments.length > 0) {
+      _selfPackageName = libraryUri.pathSegments[0];
+    }
+
     // Create and add a ChangeSet
     ChangeSet changeSet = new ChangeSet();
     changeSet.addedSource(librarySource);
     context.applyChanges(changeSet);
   }
 
   /// Fills [errorInfos] using [sources].
   void prepareErrors() {
     for (Source source in sources) {
       context.computeErrors(source);
@@ skipping 65 matching lines @@
     if (source.uri.scheme == 'dart') {
       if (isBatch) {
         // When running in batch mode, the SDK files are cached from one
         // analysis run to the next.  So we need to parse function bodies even
         // if the user hasn't asked for errors/warnings from the SDK, since
         // they might ask for errors/warnings from the SDK in the future.
         return true;
       }
       return options.showSdkWarnings;
     }
-    if (source.uri.scheme == 'package') {
+    if (_isOtherPackage(source.uri)) {
       return options.showPackageWarnings;
     }
     return true;
   }
 
   /// The sync version of analysis.
   ErrorSeverity _analyzeSync(int printMode) {
     // don't try to analyze parts
     if (context.computeKindOf(librarySource) == SourceKind.PART) {
       print("Only libraries can be analyzed.");
@@ skipping 26 matching lines @@
       return false;
     }
     if (computeSeverity(error, options.enableTypeChecks) ==
             ErrorSeverity.INFO &&
         options.disableHints) {
       return false;
     }
     return true;
   }
 
+  /**
+   * Determine whether the given URI refers to a package other than the package
+   * being analyzed.
+   */
+  bool _isOtherPackage(Uri uri) {
+    if (uri.scheme != 'package') {
+      return false;
+    }
+    if (_selfPackageName != null &&
+        uri.pathSegments.length > 0 &&
+        uri.pathSegments[0] == _selfPackageName) {
+      return false;
+    }
+    return true;
+  }
+
   _printColdPerf() {
     // print cold VM performance numbers
     int totalTime = JavaSystem.currentTimeMillis() - startTime;
     int otherTime = totalTime;
     for (PerformanceTag tag in PerformanceTag.all) {
       if (tag != PerformanceTag.UNKNOWN) {
         int tagTime = tag.elapsedMs;
         stdout.writeln('${tag.label}-cold:$tagTime');
         otherTime -= tagTime;
       }
@@ skipping 102 matching lines @@
     }
   }
 
   @override
   void logInformation2(String message, Object exception) {
     if (log) {
       stdout.writeln(message);
     }
   }
 }