Add --hide-package-warnings option.

sdk/lib/_internal/compiler/implementation/compiler.dart

 // Copyright (c) 2012, 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.
 
 part of dart2js;
 
 /**
  * If true, print a warning for each method that was resolved, but not
  * compiled.
  */
@@ skipping 375 matching lines @@
 
   /**
    * URI of the main source map if the compiler is generating source
    * maps.
    */
   final Uri sourceMapUri;
 
   /// Emit terse diagnostics without howToFix.
   final bool terseDiagnostics;
 
+  /// If `true`, warnings and hints not from user code are not reported.
+  final bool hidePackageWarnings;
+
+  /// `true` if the last diagnostic was filtered, in which case the
+  /// accompanying info message should be filtered as well.
+  bool lastDiagnosticWasFiltered = false;
+
   final api.CompilerOutputProvider outputProvider;
 
   bool disableInlining = false;
 
   List<Uri> librariesToAnalyzeWhenRun;
 
   final Tracer tracer;
 
   CompilerTask measuredTask;
   Element _currentElement;
@@ skipping 202 matching lines @@
             bool generateSourceMap: true,
             this.analyzeAllFlag: false,
             bool analyzeOnly: false,
             bool analyzeSignaturesOnly: false,
             this.preserveComments: false,
             this.verbose: false,
             this.sourceMapUri: null,
             this.buildId: UNDETERMINED_BUILD_ID,
             this.terseDiagnostics: false,
             this.dumpInfo: false,
+            this.hidePackageWarnings: false,
             outputProvider,
             List<String> strips: const []})
       : this.analyzeOnly = analyzeOnly || analyzeSignaturesOnly,
         this.analyzeSignaturesOnly = analyzeSignaturesOnly,
         this.outputProvider = (outputProvider == null)
             ? NullSink.outputProvider
             : outputProvider {
     world = new World(this);
 
     closureMapping.ClosureNamer closureNamer;
@@ skipping 113 matching lines @@
       return spanFromElement(node);
     } else if (node is MetadataAnnotation) {
       MetadataAnnotation annotation = node;
       Uri uri = annotation.annotatedElement.getCompilationUnit().script.uri;
       return spanFromTokens(annotation.beginToken, annotation.endToken, uri);
     } else {
       throw 'No error location.';
     }
   }
 
+  /// Finds the approximate [Element] for [node]. [currentElement] is used as
+  /// the default value.
+  Element elementFromSpannable(Spannable node) {
+    Element element;
+    if (node is Element) {
+      element = node;
+    } else if (node is HInstruction) {
+      element = node.sourceElement;
+    } else if (node is MetadataAnnotation) {
+      MetadataAnnotation annotation = node;

[floitsch, 2014/02/20 19:24:32]

This should not be necessary anymore. The is-check should statically make 'node'
a MetadataAnnotation within the if-body.

[Johnni Winther, 2014/02/21 08:32:14]

Done.

+      element = annotation.annotatedElement;
+    }
+    return element != null ? element : currentElement;
+  }
+
   void log(message) {
     reportDiagnostic(null,
         MessageKind.GENERIC.error({'text': '$message'}),
         api.Diagnostic.VERBOSE_INFO);
   }
 
   Future<bool> run(Uri uri) {
     totalCompileTime.start();
 
     return new Future.sync(() => runCompiler(uri)).catchError((error) {
@@ skipping 558 matching lines @@
 
   FunctionType computeFunctionType(Element element,
                                    FunctionSignature signature) {
     return withCurrentElement(element,
         () => resolver.computeFunctionType(element, signature));
   }
 
   void reportError(Spannable node,
                    MessageKind errorCode,
                    [Map arguments = const {}]) {
-    reportDiagnostic(node,
-                     errorCode.error(arguments, terseDiagnostics),
-                     api.Diagnostic.ERROR);
+    reportDiagnosticInternal(node, errorCode, arguments, api.Diagnostic.ERROR);
   }
 
   void reportFatalError(Spannable node, MessageKind errorCode,
                         [Map arguments = const {}]) {
     reportError(node, errorCode, arguments);
     // TODO(ahe): Make this only abort the current method.
     throw new CompilerCancelledException(
         'Error: Cannot continue due to previous error.');
   }
 
   void reportWarning(Spannable node, MessageKind errorCode,
                      [Map arguments = const {}]) {
     // TODO(ahe): Don't suppress these warning when the type checker
     // is more complete.
     if (errorCode == MessageKind.MISSING_RETURN) return;
     if (errorCode == MessageKind.MAYBE_MISSING_RETURN) return;
-    reportDiagnostic(node,
-                  errorCode.error(arguments, terseDiagnostics),
-                  api.Diagnostic.WARNING);
+    reportDiagnosticInternal(
+        node, errorCode, arguments, api.Diagnostic.WARNING);
   }
 
   void reportInfo(Spannable node, MessageKind errorCode,
                   [Map arguments = const {}]) {
-    reportDiagnostic(node,
-                     errorCode.error(arguments, terseDiagnostics),
-                     api.Diagnostic.INFO);
+    reportDiagnosticInternal(node, errorCode, arguments, api.Diagnostic.INFO);
   }
 
   void reportHint(Spannable node, MessageKind errorCode,
                   [Map arguments = const {}]) {
-    reportDiagnostic(node,
-                     errorCode.error(arguments, terseDiagnostics),
-                     api.Diagnostic.HINT);
+    reportDiagnosticInternal(node, errorCode, arguments, api.Diagnostic.HINT);
   }
 
   /// For debugging only, print a message with a source location.
   void reportHere(Spannable node, String debugMessage) {
     reportInfo(node, MessageKind.GENERIC, {'text': 'HERE: $debugMessage'});
   }
 
   void reportInternalError(Spannable node, String message) {
     reportError(
         node, MessageKind.GENERIC, {'text': 'Internal Error: $message'});
   }
 
+  void reportDiagnosticInternal(Spannable node,
+                                MessageKind errorCode,
+                                Map arguments,
+                                api.Diagnostic kind) {
+    if (hidePackageWarnings) {
+      switch (kind) {
+      case api.Diagnostic.WARNING:
+      case api.Diagnostic.HINT:
+        if (!inUserCode(elementFromSpannable(node))) {
+          lastDiagnosticWasFiltered = true;
+          return;
+        }
+        break;
+      case api.Diagnostic.INFO:
+        if (lastDiagnosticWasFiltered) {
+          return;
+        }
+        break;
+      }
+    }
+    lastDiagnosticWasFiltered = false;
+    reportDiagnostic(node, errorCode.error(arguments, terseDiagnostics), kind);
+  }
+
   // TODO(ahe): The names Diagnostic and api.Diagnostic are in conflict. Fix it.
   void reportDiagnostic(Spannable span,
                         Diagnostic message,
                         api.Diagnostic kind);
 
   void reportAssertionFailure(SpannableAssertionFailure ex) {
     String message = (ex.message != null) ? tryToString(ex.message)
                                           : tryToString(ex);
     SourceSpan span = spanFromSpannable(ex.node);
     reportError(ex.node, MessageKind.GENERIC, {'text': message});
@@ skipping 141 matching lines @@
       // TODO(ahe): Implement better heuristics to discover entry points of
       // packages and use that to discover unused implementation details in
       // packages.
       if (library.isPlatformLibrary || library.isPackageLibrary) return;
       library.compilationUnits.forEach((unit) {
         unit.forEachLocalMember(checkLive);
       });
     });
   }
 
-  /// Debugging helper for determining whether the current element is declared
-  /// within 'user code'.
+  /// Helper for determining whether the current element is declared within
+  /// 'user code'.
   ///
   /// See [inUserCode] for what defines 'user code'.
   bool currentlyInUserCode() {
     return inUserCode(currentElement);
   }
 
-  /// Debugging helper for determining whether [element] is declared within
-  /// 'user code'.
+  /// Helper for determining whether [element] is declared within 'user code'.
   ///
   /// What constitutes 'user code' is defined by the URI(s) provided by the
   /// entry point(s) of compilation or analysis:
   ///
   /// If an entrypoint URI uses the 'package' scheme then every library from
   /// that same package is considered to be in user code. For instance, if
   /// an entry point URI is 'package:foo/bar.dart' then every library whose
   /// canonical URI starts with 'package:foo/' is in user code.
   ///
   /// If an entrypoint URI uses another scheme than 'package' then every library
@@ skipping 164 matching lines @@
 
   void close() {}
 
   toString() => name;
 
   /// Convenience method for getting an [api.CompilerOutputProvider].
   static NullSink outputProvider(String name, String extension) {
     return new NullSink('$name.$extension');
   }
 }