dart2js: Support frequency based metadata indices in new emitter.

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.
@@ skipping 89 matching lines @@
   }
 
   jsAst.Expression get value {
     assert(_value != null);
     return _value;
   }
 
   int get precedenceLevel => js_precedence.PRIMARY;
 }
 
-class MetadataCollector {
+class MetadataCollector implements 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 169 matching lines @@
       // TODO(ahe): Why is metadata sometimes null?
       if (link != null) {
         for (; !link.isEmpty; link = link.tail) {
           metadata.add(reifyMetadata(link.head));
         }
       }
       return metadata;
     });
   }
 
-  void countTokensInProgram(jsAst.Program program) {
+  @override
+  void countTokensInAst(jsAst.Node ast) {
     TokenCounter visitor = new TokenCounter();
-    visitor.countTokens(program);
+    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;
@@ skipping 36 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;
   }
 }