dart2js: Implement frequency based naming.

pkg/compiler/lib/src/js/js.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 js;
 
 import 'package:js_ast/js_ast.dart';
 export 'package:js_ast/js_ast.dart';
 
 import '../io/code_output.dart' show CodeBuffer;
 import '../io/source_information.dart' show SourceInformation;
 import '../js_emitter/js_emitter.dart' show USE_NEW_EMITTER;
 import '../dart2jslib.dart' as leg;
 import '../util/util.dart' show NO_LOCATION_SPANNABLE;
 import '../dump_info.dart' show DumpInfoTask;
 
 CodeBuffer prettyPrint(Node node, leg.Compiler compiler,
                        {DumpInfoTask monitor,
-                        bool allowVariableMinification: true}) {
+                        bool allowVariableMinification: true,
+                        Renamer renamerForNames:
+                            JavaScriptPrintingOptions.identityRenamer}) {
   JavaScriptPrintingOptions options = new JavaScriptPrintingOptions(
       shouldCompressOutput: compiler.enableMinification,
       minifyLocalVariables: allowVariableMinification,
-      preferSemicolonToNewlineInMinifiedOutput: USE_NEW_EMITTER);
+      preferSemicolonToNewlineInMinifiedOutput: USE_NEW_EMITTER,
+      renamerForNames: renamerForNames);
   Dart2JSJavaScriptPrintingContext context =
       new Dart2JSJavaScriptPrintingContext(compiler, monitor);
   Printer printer = new Printer(options, context);
   printer.visit(node);
   return context.outBuffer;
 }
 
 class Dart2JSJavaScriptPrintingContext implements JavaScriptPrintingContext {
   final leg.Compiler compiler;
   final DumpInfoTask monitor;
@@ skipping 44 matching lines @@
       if (rootNode == node) {
         outBuffer.addSourceLocation(endPosition, null);
         rootNode = null;
       }
     }
     if (monitor != null) {
       monitor.recordAstSize(node, endPosition - startPosition);
     }
   }
 }
+
+/// Interface for ast nodes that encapsulate an ast that needs to be
+/// traversed when counting tokens.
+abstract class AstContainer implements Node {
+  Iterable<Node> get containedNodes;
+}
+
+/// Interface for tasks in the compiler that need to finalize tokens after
+/// counting them.
+abstract class TokenFinalizer {
+  void finalizeTokens();
+}
+
+/// Implements reference counting for instances of [ReferenceCountedAstNode]
+class TokenCounter extends BaseVisitor {
+  @override
+  visitNode(Node node) {
+    if (node is AstContainer) {
+      for (Node element in node.containedNodes) {
+        element.accept(this);
+      }
+    } else if (node is ReferenceCountedAstNode) {
+      node.markSeen(this);
+    } else {
+      super.visitNode(node);
+    }
+  }
+
+  void countTokens(Node node) => node.accept(this);
+}
+
+abstract class ReferenceCountedAstNode implements Node {
+  markSeen(TokenCounter visitor);
+}
+
+/// Represents the LiteralString resulting from unparsing [expression]. The
+/// actual unparsing is done on demand when requesting the [value] of this
+/// node.

[sra1, 2015/07/01 04:11:09]

Perhaps say here why you might want such a strange node?

[herhut, 2015/07/02 08:54:51]

Done.

+class UnparsedNode extends DeferredString
+                   implements AstContainer {
+  @override
+  final Node tree;
+  final leg.Compiler _compiler;
+  final bool _protectForEval;
+  LiteralString _cachedLiteral;
+
+  Iterable<Node> get containedNodes => [tree];
+
+  /// A [js.Literal] that represents the string result of unparsing [ast].
+  ///
+  /// When its string [value] is requested, the node pretty-prints the given
+  /// [ast] and, if [protectForEval] is true, wraps the resulting
+  /// string in parenthesis. The result is also escaped.
+  UnparsedNode(this.tree, this._compiler, this._protectForEval);
+
+  LiteralString get _literal {
+    if (_cachedLiteral == null) {
+      String text = prettyPrint(tree, _compiler).getText();
+      if (_protectForEval) {
+        if (tree is Fun) text = '($text)';
+        if (tree is LiteralExpression) {
+          LiteralExpression literalExpression = tree;
+          String template = literalExpression.template;
+          if (template.startsWith("function ") ||
+          template.startsWith("{")) {
+            text = '($text)';
+          }
+        }
+      }
+      _cachedLiteral = js.escapedString(text);
+    }
+    return _cachedLiteral;
+  }
+
+  @override
+  String get value => _literal.value;
+}