RFC: Resolution based tree-shaking.

dart/lib/compiler/implementation/compiler.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 WorkItem {
   final Element element;
   TreeElements resolutionTree;
   bool allowSpeculativeOptimization = true;
   List<HTypeGuard> guards = const <HTypeGuard>[];
 
   WorkItem(this.element, this.resolutionTree);
 
   bool isAnalyzed() => resolutionTree !== null;
 
   String run(Compiler compiler, Enqueuer world) {
     String code = world.universe.generatedCode[element];
     if (code !== null) return code;
-    if (!isAnalyzed()) compiler.analyze(this);
+    if (!isAnalyzed()) {
+      resolutionTree = world.getCachedElements(element);

[kasperl, 2012/06/12 05:50:12]

So getCachedElements has the side-effect that this work item might turn
analyzed?

[ahe, 2012/06/12 06:22:48]

getCachedElements does not have side-effects. Assigning to treeElements has the
effect that this work item may "become" analyzed. 

+      if (!isAnalyzed()) compiler.analyze(this);
+    }
+    if (world.isFirstQueue) {
+      world.resolvedElements[element] = resolutionTree;
+      return null;
+    }
+    if (resolutionTree === null) {
+      compiler.internalError('Error: unresolved element', element: element);
+    }
     return compiler.codegen(this);
   }
 }
 
 class Backend {
   final Compiler compiler;
 
   Backend(this.compiler);
 
   abstract String codegen(WorkItem work);
@@ skipping 330 matching lines @@
       FunctionSignature parameters = mainMethod.computeSignature(this);
       parameters.forEachParameter((Element parameter) {
         reportFatalError('main cannot have parameters', parameter);
       });
     }
 
     // TODO(ahe): Remove this line. Eventually, enqueuer.resolution
     // should know this.
     world.populate(this, libraries.getValues());
 
-    // Not yet ready to process the enqueuer.resolution queue...
-    // processQueue(enqueuer.resolution);
+    log('Resolving');
+    processQueue(enqueuer.resolution, main);
+    log('Resolved ${enqueuer.resolution.resolvedElements.length} elements.');
+
+    log('Compiling');
     processQueue(enqueuer.codegen, main);
 
     backend.assembleProgram();
-    if (!enqueuer.codegen.queue.isEmpty()) {
-      internalErrorOnElement(enqueuer.codegen.queue.first().element,
-                             "work list is not empty");
-    }
+    enqueuer.codegen.forEach((WorkItem work) {
+      internalErrorOnElement(work.element, "work list is not empty");
+    });
   }
 
   processQueue(Enqueuer world, Element main) {
     backend.processNativeClasses(world, libraries.getValues());
     world.addToWorkList(main);
     codegenProgress.reset();
-    while (!world.queue.isEmpty()) {
-      WorkItem work = world.queue.removeLast();
+    world.forEach((WorkItem work) {
       withCurrentElement(work.element, () => work.run(this, world));
-    }
+    });
     world.queueIsClosed = true;
     assert(world.checkNoEnqueuedInvokedInstanceMethods());
     world.registerFieldClosureInvocations();
   }
 
   TreeElements analyzeElement(Element element) {
+    if (element is AbstractFieldElement) {
+      return null;
+    }
+    final int allowed = ElementCategory.VARIABLE | ElementCategory.FUNCTION
+                        | ElementCategory.FACTORY;
+    if (!element.isAccessor() && (element.kind.category & allowed) == 0) {
+      return null;
+    }
     assert(parser !== null);
     Node tree = parser.parse(element);
     validator.validate(tree);
     unparseValidator.check(element);
     TreeElements elements = resolver.resolve(element);
     checker.check(tree, elements);
     return elements;
   }
 
   TreeElements analyze(WorkItem work) {
@@ skipping 98 matching lines @@
       // not a good error location, but cancel really is "internal
       // error" or "not implemented yet", so the vicinity is good
       // enough for now.
       element = element.enclosingElement;
       // TODO(ahe): I plan to overhaul this infrastructure anyways.
     }
     if (element === null) {
       element = currentElement;
     }
     Token position = element.position();
+    Uri uri = element.getCompilationUnit().script.uri;
     if (position === null) {
-      Uri uri = element.getCompilationUnit().script.uri;
       return new SourceSpan(uri, 0, 0);
+    } else {
+      return SourceSpan.withOffsets(
+          position, position,
+          (beginOffset, endOffset) {
+            return new SourceSpan(uri, beginOffset, endOffset);
+          });
     }
-    return spanFromTokens(position, position);
   }
 
   Script readScript(Uri uri, [ScriptTag node]) {
     unimplemented('Compiler.readScript');
   }
 
   String get legDirectory() {
     unimplemented('Compiler.legDirectory');
   }
 
@@ skipping 68 matching lines @@
     // invariant that endOffset > beginOffset, but for EOF the
     // charoffset of the next token may be [beginOffset]. This can
     // also happen for synthetized tokens that are produced during
     // error handling.
     final endOffset =
       Math.max((end.next !== null) ? end.next.charOffset : 0, beginOffset + 1);
     assert(endOffset > beginOffset);
     return f(beginOffset, endOffset);
   }
 }