Track initializers already seen (fixes #21439)

pkg/polymer/lib/src/build/script_compactor.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.
 
 /// Transfomer that combines multiple dart script tags into a single one.
 library polymer.src.build.script_compactor;
 
 import 'dart:async';
 import 'dart:convert';
 
@@ skipping 231 matching lines @@
     new _HtmlExtractor(logger, generator, publishedAttributes,
         expressionVisitor).visit(document);
 
     // Create a recorder that uses analyzer data to feed data to [generator].
     var recorder = new Recorder(generator,
         (lib) => resolver.getImportUri(lib, from: bootstrapId).toString());
 
     // Process all classes and top-level functions to include initializers,
     // register custom elements, and include special fields and methods in
     // custom element classes.
+    var functionsSeen = new Set<FunctionElement>();
+    var classesSeen = new Set<ClassElement>();
     for (var id in entryLibraries) {
       var lib = resolver.getLibrary(id);
-      for (var fun in _visibleTopLevelMethodsOf(lib)) {
+      for (var fun in _visibleTopLevelMethodsOf(lib, functionsSeen)) {
         _processFunction(fun, id);
       }
 
-      for (var cls in _visibleClassesOf(lib)) {
+      for (var cls in _visibleClassesOf(lib, classesSeen)) {
         _processClass(cls, id, recorder);
       }
     }
   }
 
   /// Process a class ([cls]). If it contains an appropriate [CustomTag]
   /// annotation, we include an initializer to register this class, and make
   /// sure to include everything that might be accessed or queried from them
   /// using the smoke package. In particular, polymer uses smoke for the
   /// following:
@@ skipping 531 matching lines @@
   }
 
   static _definitionError(name) {
     throw new StateError("Internal error in polymer-builder: couldn't find "
         "definition of $name.");
   }
 }
 
 /// Retrieves all classses that are visible if you were to import [lib]. This
 /// includes exported classes from other libraries.
-List<ClassElement> _visibleClassesOf(LibraryElement lib) {
+List<ClassElement> _visibleClassesOf(LibraryElement lib,
+    Set<ClassElement> seen) {
   var result = [];
-  result.addAll(lib.units.expand((u) => u.types));
+  addAllNew(list) => list.forEach((e) {
+    if (!seen.contains(e)) result.add(e);
+  });
+  addAllNew(lib.units.expand((u) => u.types));
   for (var e in lib.exports) {
-    var exported = e.exportedLibrary.units.expand((u) => u.types).toList();
+    var exportedLibrary = e.exportedLibrary;
+    if (seen.contains(exportedLibrary)) continue;
+    var exported = exportedLibrary.units.expand((u) => u.types).toList();
     _filter(exported, e.combinators);
-    result.addAll(exported);
+    addAllNew(exported);
   }
+  seen.addAll(result);
   return result;
 }
 
 /// Retrieves all top-level methods that are visible if you were to import
 /// [lib]. This includes exported methods from other libraries too.
-List<FunctionElement> _visibleTopLevelMethodsOf(LibraryElement lib) {
+List<FunctionElement> _visibleTopLevelMethodsOf(
+    LibraryElement lib, Set<FunctionElement> seen) {
   var result = [];
-  result.addAll(lib.units.expand((u) => u.functions));
+  addAllNew(list) => list.forEach((e) {

[jakemac, 2014/11/04 17:45:54]

I would probably break this out into a function that takes a set and a list as
inputs and returns the new list since its the same as above.

Iterable getAllNew(Iterable existing, Iterable new) {
  return new.where((e) => !existing.contains(e));
}

[Siggi Cherem (dart-lang), 2014/11/04 17:55:08]

good point - this made me realize that I could just do the filtering above
without passing the set argument on these functions at all. It's much simpler
now. Thanks!

+    if (!seen.contains(e)) result.add(e);
+  });
+  addAllNew(lib.units.expand((u) => u.functions));
   for (var e in lib.exports) {
-    var exported = e.exportedLibrary.units
-        .expand((u) => u.functions).toList();
+    var exportedLibrary = e.exportedLibrary;
+    if (seen.contains(exportedLibrary)) continue;
+    var exported = exportedLibrary.units.expand((u) => u.functions).toList();
     _filter(exported, e.combinators);
-    result.addAll(exported);
+    addAllNew(exported);
   }
+  seen.addAll(result);
   return result;
 }
 
 /// Filters [elements] that come from an export, according to its show/hide
 /// combinators. This modifies [elements] in place.
 void _filter(List<analyzer.Element> elements,
     List<NamespaceCombinator> combinators) {
   for (var c in combinators) {
     if (c is ShowElementCombinator) {
       var show = c.shownNames.toSet();
       elements.retainWhere((e) => show.contains(e.displayName));
     } else if (c is HideElementCombinator) {
       var hide = c.hiddenNames.toSet();
       elements.removeWhere((e) => hide.contains(e.displayName));
     }
   }
 }