Add helpers library to dart2js.

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 1354 matching lines @@
   void reportInfo(Spannable node, MessageKind messageKind,
                   [Map arguments = const {}]) {
     reportDiagnosticInternal(node, messageKind, arguments, api.Diagnostic.INFO);
   }
 
   void reportHint(Spannable node, MessageKind messageKind,
                   [Map arguments = const {}]) {
     reportDiagnosticInternal(node, messageKind, arguments, api.Diagnostic.HINT);
   }
 
-  /// For debugging only, print a message with a source location.
-  void reportHere(Spannable node, String debugMessage) {

[ahe, 2014/04/10 11:06:32]

Is there an alternative to this?

[Johnni Winther, 2014/04/10 11:11:45]

It is moved to helpers/helpers.dart to ensure that production code does not use
it (checked by analyze_used_dart2js_test).

[ahe, 2014/04/10 11:43:46]

That means I have to import helpers/helpers.dart. That makes it virtually
useless, as the method only serves a purpose when it is *easier* to use than
writing the code below inline. I think there are better ways to ensure that
"reportHere" is never called. For example, by running analyze-only on
dart2js.dart, and checking that the method wasn't enqueued.

I would argue that I'm now more likely to accidentally include
MessageKind.GENERIC in production code, because I'm not going to import a helper
library.

[Johnni Winther, 2014/04/10 12:04:21]

Why is it a problem to import 'helpers/helpers.dart'?

If MessageKind.GENERIC shouldn't be used in production code (which it is) we
should enforce and check it.

-    reportInfo(node, MessageKind.GENERIC, {'text': 'HERE: $debugMessage'});
-  }
-
   void reportDiagnosticInternal(Spannable node,
                                 MessageKind messageKind,
                                 Map arguments,
                                 api.Diagnostic kind) {
     if (!showPackageWarnings) {
       switch (kind) {
       case api.Diagnostic.WARNING:
       case api.Diagnostic.HINT:
         Element element = elementFromSpannable(node);
-        if (!inUserCode(element)) {
+        if (!inUserCode(element, assumeInUserCode: true)) {
           Uri uri = getCanonicalUri(element);
           SuppressionInfo info =
               suppressedWarnings.putIfAbsent(uri, () => new SuppressionInfo());
           if (kind == api.Diagnostic.WARNING) {
             info.warnings++;
           } else {
             info.hints++;
           }
           lastDiagnosticWasFiltered = true;
           return;
@@ skipping 143 matching lines @@
       currentToken = currentToken.next;
     }
     return firstToken;
   }
 
   void reportUnusedCode() {
     void checkLive(member) {
       if (member.isFunction()) {
         if (!enqueuer.resolution.isLive(member)) {
           reportHint(member, MessageKind.UNUSED_METHOD,
-                     {'method_name': member.name});
+                     {'name': member.name});
         }
-      } else if (member.isClass() && !member.isMixinApplication) {
-        member.forEachLocalMember(checkLive);
+      } else if (member.isClass()) {
+        if (!member.isResolved) {
+          reportHint(member, MessageKind.UNUSED_CLASS,
+                     {'name': member.name});
+        } else {
+          member.forEachLocalMember(checkLive);
+        }
+      } else if (member.isTypedef()) {
+        if (!member.isResolved) {
+          reportHint(member, MessageKind.UNUSED_TYPEDEF,
+                     {'name': member.name});
+        }
       }
     }
     libraries.forEach((_, library) {
       // 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);
       });
@@ skipping 15 matching lines @@
   ///
   /// 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
   /// with that scheme is in user code. For instance, an entry point URI is
   /// 'file:///foo.dart' then every library whose canonical URI scheme is
   /// 'file' is in user code.
-  bool inUserCode(Element element) {
+  ///
+  /// If [assumeInUserCode] is `true`, [element] is assumed to be in user code
+  /// if no entrypoints have been set.
+  bool inUserCode(Element element, {bool assumeInUserCode: false}) {
     List<Uri> entrypoints = <Uri>[];
     if (mainApp != null) {
       entrypoints.add(mainApp.canonicalUri);
     }
     if (librariesToAnalyzeWhenRun != null) {
       entrypoints.addAll(librariesToAnalyzeWhenRun);
     }
-    if (entrypoints.isEmpty) {
+    if (entrypoints.isEmpty && assumeInUserCode) {
       // Assume in user code since [mainApp] has not been set yet.
       return true;
     }
     if (element == null) return false;
     Uri libraryUri = element.getLibrary().canonicalUri;
     if (libraryUri.scheme == 'package') {
       for (Uri uri in entrypoints) {
         if (uri.scheme != 'package') continue;
         int slashPos = libraryUri.path.indexOf('/');
         if (slashPos != -1) {
@@ skipping 170 matching lines @@
   static NullSink outputProvider(String name, String extension) {
     return new NullSink('$name.$extension');
   }
 }
 
 /// Information about suppressed warnings and hints for a given library.
 class SuppressionInfo {
   int warnings = 0;
   int hints = 0;
 }