dart2js: Implement frequency based naming.

pkg/compiler/lib/src/js_emitter/metadata_collector.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.
 
 part of dart2js.js_emitter;
 
 /// Represents an entry's position in one of the global metadata arrays.
 ///
 /// [_rc] is used to count the number of references of the token in the
 /// ast for a program.
 /// [value] is the actual position, once they have been finalized.
 abstract class _MetadataEntry extends jsAst.DeferredNumber
-    implements Comparable {
+    implements Comparable, jsAst.ReferenceCountedAstNode {
   jsAst.Expression get entry;
   int get value;
   int get _rc;
 
   // Mark this entry as seen. On the first time this is seen, the visitor
   // will be applied to the [entry] to also mark potential [_MetadataEntry]
   // instances in the [entry] as seen.
-  markSeen(jsAst.BaseVisitor visitor);
+  markSeen(jsAst.TokenCounter visitor);
 }
 
 class _BoundMetadataEntry extends _MetadataEntry {
   int _value = -1;
   int _rc = 0;
   final jsAst.Expression entry;
 
   _BoundMetadataEntry(this.entry);
 
   bool get isFinalized => _value != -1;
@@ skipping 68 matching lines @@
   }
 
   jsAst.Expression get value {
     assert(_value != null);
     return _value;
   }
 
   int get precedenceLevel => js_precedence.PRIMARY;
 }
 
-class MetadataCollector implements TokenFinalizer {
+class MetadataCollector implements jsAst.TokenFinalizer {
   final Compiler _compiler;
   final Emitter _emitter;
 
   /// A token for a list of expressions that represent metadata, parameter names
   /// and type variable types.
   final _MetadataList _globalMetadata = new _MetadataList();
   jsAst.Expression get globalMetadata => _globalMetadata;
 
   /// A map used to canonicalize the entries of globalMetadata.
   Map<String, _BoundMetadataEntry> _globalMetadataMap;
@@ skipping 104 matching lines @@
 
   jsAst.Expression reifyExpression(jsAst.Expression expression) {
     return _addGlobalMetadata(expression);
   }
 
   Placeholder getMetadataPlaceholder([debug]) {
     return new _ForwardingMetadataEntry(debug);
   }
 
   _MetadataEntry _addGlobalMetadata(jsAst.Node node) {
-    String printed = jsAst.prettyPrint(node, _compiler).getText();
+    String nameToHashCode(jsAst.Name name) => "${name.hashCode}";

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

Q1. Are you guaranteeing somewhere that each unique name in the program has only
one instance of a jsAst.Name? That would make sense for refcounting.

Q2. What if the hashCodes are not unique?
At least document a TODO to investigate.
Maybe _NamerName should implement a hashString() method that returns a
structurally unique string for this purpose.

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

Yes. freshName (which hands out jsAst.Name) produces a fresh, unique name. The
Namer makes sure that consecutive calls with the same element or entity that
needs naming will result in the same name.

However, if the same name is constructed in different ways (like a literal
string gx and a getter with x) this does not hold. That is documented in the
namer and if that is violated, reference counting is the smallest issue.
True. I will add a TODO and implement unique keys in a follow-up.

+    String printed = jsAst.prettyPrint(node, _compiler,
+                                       renamerForNames: nameToHashCode)
+                          .getText();
     return _globalMetadataMap.putIfAbsent(printed, () {
       _BoundMetadataEntry result = new _BoundMetadataEntry(node);
       if (_compiler.hasIncrementalSupport) {
         result.finalize(_globalMetadataCounter++);
       }
       return result;
     });
   }
 
   jsAst.Expression _computeTypeRepresentation(DartType type,
@@ skipping 45 matching lines @@
       if (link != null) {
         for (; !link.isEmpty; link = link.tail) {
           metadata.add(reifyMetadata(link.head));
         }
       }
       return metadata;
     });
   }
 
   @override
-  void countTokensInAst(jsAst.Node ast) {
-    TokenCounter visitor = new TokenCounter();
-    visitor.countTokens(ast);
-  }
-
-  @override
   void finalizeTokens() {
     bool checkTokensInTypes(OutputUnit outputUnit, entries) {
       UnBoundDebugger debugger = new UnBoundDebugger(outputUnit);
       for (_BoundMetadataEntry entry in entries) {
         if (!entry.isUsed) continue;
         if (debugger.findUnboundPlaceholders(entry.entry)) {
           return false;
         }
       }
       return true;
     }
     void countTokensInTypes(Iterable<_BoundMetadataEntry> entries) {
-      TokenCounter counter = new TokenCounter();
+      jsAst.TokenCounter counter = new jsAst.TokenCounter();
       entries.where((_BoundMetadataEntry e) => e._rc > 0)
              .map((_BoundMetadataEntry e) => e.entry)
              .forEach(counter.countTokens);
     }
 
     jsAst.ArrayInitializer finalizeMap(Map<dynamic, _BoundMetadataEntry> map) {
       // When in incremental mode, we allocate entries eagerly.
       if (_compiler.hasIncrementalSupport) {
         return new jsAst.ArrayInitializer(map.values.toList());
       }
@@ skipping 23 matching lines @@
         assert(checkTokensInTypes(outputUnit, typesMap.values));
         countTokensInTypes(typesMap.values);
         token.setExpression(finalizeMap(typesMap));
       } else {
         token.setExpression(new jsAst.ArrayInitializer([]));
       }
     });
   }
 }
 
-/// Interface for ast nodes that encapsulate an ast that needs to be
-/// traversed when counting tokens.
-///
-/// TODO(herhut): Find a shared place once namer also uses tokens.
-abstract class AstContainer implements jsAst.Node {
-  jsAst.Node get ast;
-}
-
-abstract class TokenFinalizer {
-  void countTokensInAst(jsAst.Node ast);
-  void finalizeTokens();
-}
-
-class TokenCounter extends jsAst.BaseVisitor {
-  @override
-  visitNode(jsAst.Node node) {
-    if (node is AstContainer) {
-      node.ast.accept(this);
-    } else {
-      super.visitNode(node);
-    }
-  }
-
-  @override
-  visitDeferredNumber(jsAst.DeferredNumber token) {
-    if (token is _MetadataEntry) {
-      token.markSeen(this);
-    }
-  }
-
-  void countTokens(jsAst.Node node) => node.accept(this);
-}
-
 class UnBoundDebugger extends jsAst.BaseVisitor {
   OutputUnit outputUnit;
   bool _foundUnboundToken = false;
 
   UnBoundDebugger(this.outputUnit);
 
   @override
   visitDeferredNumber(jsAst.DeferredNumber token) {
     if (token is _ForwardingMetadataEntry && !token.isBound) {
       _foundUnboundToken = true;
     }
   }
 
   bool findUnboundPlaceholders(jsAst.Node node) {
     node.accept(this);
     return _foundUnboundToken;
   }
 }