Split collecting and traversing.

lib/compiler/implementation/dart_backend/backend.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.
 
 class DartBackend extends Backend {
   final List<CompilerTask> tasks;
   final UnparseValidator unparseValidator;
 
   Map<Element, TreeElements> get resolvedElements() =>
       compiler.enqueuer.resolution.resolvedElements;
@@ skipping 33 matching lines @@
       LIBS_TO_IGNORE.indexOf(element.getLibrary()) == -1 &&
       !isDartCoreLib(compiler, element.getLibrary()) &&
       element is !AbstractFieldElement;
 
     final emptyTreeElements = new TreeElementMapping();
 
     Set<Element> topLevelElements = new Set<Element>();
     Map<ClassElement, Set<Element>> classMembers =
         new Map<ClassElement, Set<Element>>();
 
-    PlaceholderCollector collector = new PlaceholderCollector(compiler);
+    // Build all top level elements to emit and necessary class members.
     var newTypedefElementCallback, newClassElementCallback;
 
     processElement(element, treeElements) {
-      collector.collect(element, treeElements);
       new ReferencedElementCollector(
           compiler,
           element, treeElements,
           newTypedefElementCallback, newClassElementCallback).collect();
     }
 
     addTopLevel(element, treeElements) {
       if (topLevelElements.contains(element)) return;
       topLevelElements.add(element);
       processElement(element, treeElements);
@@ skipping 24 matching lines @@
         classMembers[enclosingClass].add(element);
         processElement(element, treeElements);
       } else {
         if (!element.isTopLevel()) {
           compiler.cancel(reason: 'Cannot process $element', element: element);
         }
         addTopLevel(element, treeElements);
       }
     });
 
+    // Create all necessary placeholders.
+    PlaceholderCollector collector = new PlaceholderCollector(compiler);
+    makePlaceholders(element) {
+      TreeElements treeElements = resolvedElements[element];
+      if (treeElements === null) treeElements = emptyTreeElements;
+      collector.collect(element, treeElements);
+      if (element is ClassElement) {

[Roman, 2012/08/17 08:22:28]

I would prefer that class members are explicitly collected below, after we
collect top level elements, like:
classMembers.getValues().forEach(makePlaceholders);

I think it's cleaner.

[Anton Muhin, 2012/08/17 08:32:41]

I actually started that way, but decided eventually against it.  The idea is in
contrast to the previous approach, classElement to members mapping is now not
that important, the key data is a collection of top level.

As an experiment (it might be worth experimenting): we can probably omit
classMemebers altogether with the following trick: when emitting class, for each
member to be emitted, check if it got into resolvedElements.

On 2012/08/17 08:22:28, Roman wrote:

[Roman, 2012/08/17 08:34:24]

Probably I'm wrong, but I think that some element gets into class's members only
when it is used, e.g. resolved.

[Anton Muhin, 2012/08/17 08:38:04]

Yes.

Now we go over all the member elements and put them in the map.

We could have done differently: when class is used, go over all its members and
check if they are resolved i.e. used.

On 2012/08/17 08:34:24, Roman wrote:

+        classMembers[element].forEach(makePlaceholders);
+      }
+    }
+    topLevelElements.forEach(makePlaceholders);
+
+    // Create renames.
     Map<Node, String> renames = new Map<Node, String>();
     Map<LibraryElement, String> imports = new Map<LibraryElement, String>();
     renamePlaceholders(compiler, collector, renames, imports);
 
     // Sort elements.
     compareElements(e0, e1) {
       compareBy(x, y, f) => f(x).compareTo(f(y));
       int result = compareBy(e0, e1, (e) => e.getLibrary().uri.toString());
       if (result != 0) return result;
       return compareBy(e0, e1, (e) => e.position().charOffset);
@@ skipping 72 matching lines @@
     if (typeElement.isClass()) newClassElementCallback(typeElement);
     typeAnnotation.visitChildren(this);
   }
 
   void collect() {
     compiler.withCurrentElement(rootElement, () {
       rootElement.parseNode(compiler).accept(this);
     });
   }
 }