Process typedefs, referenced from the program.

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 BailoutException {
   final String reason;
 
   const BailoutException(this.reason);
 }
 
@@ skipping 52 matching lines @@
     final LIBS_TO_IGNORE = [
       compiler.jsHelperLibrary,
       compiler.interceptorsLibrary,
     ];
     bool shouldOutput(Element element) =>
       element.kind !== ElementKind.VOID &&
       LIBS_TO_IGNORE.indexOf(element.getLibrary()) == -1 &&
       !isDartCoreLib(compiler, element.getLibrary());
 
     try {
+      Set<TypedefElement> typedefs = new Set<TypedefElement>();
       PlaceholderCollector collector = new PlaceholderCollector(compiler);
       resolvedElements.forEach((element, treeElements) {
         if (!shouldOutput(element)) return;
+        if (element is AbstractFieldElement) return;
         collector.collect(element, treeElements);
+        new AdditionalElementCollector(
+            compiler,

[Roman, 2012/08/09 16:48:03]

style nazi: Can you please make it more compact? It does not look nice like
this, it is also easy to skip call to collect() while reading this.

[Anton Muhin, 2012/08/09 17:01:08]

Done.

+            element, treeElements,
+            typedefs)
+            .collect();
       });
 
       ConflictingRenamer renamer =
           new ConflictingRenamer(compiler, collector.placeholders);
       Emitter emitter = new Emitter(compiler, renamer);
       resolvedElements.forEach((element, treeElements) {
         if (!shouldOutput(element)) return;
         if (element.isMember()) {
           ClassElement enclosingClass = element.getEnclosingClass();
           assert(enclosingClass.isClass());
           assert(enclosingClass.isTopLevel());
           addMemberToClass(element, enclosingClass);
           return;
         }
         if (!element.isTopLevel()) {
           bailout('Cannot process non top-level $element');
         }
 
         emitter.outputElement(element);
       });
 
+      typedefs.forEach(emitter.outputElement);

[Roman, 2012/08/09 16:48:03]

I think we also want to traverse typedef nodes, because they can have references
to yet not used types.

PS I guess that's why the test failed. Not necessary task for this cl, just to
keep a note.

[Anton Muhin, 2012/08/09 17:01:09]

I believe we traverse those typedefs as a part of collector (it does
visitChildren).  But we just do not emit empty classes back.

On 2012/08/09 16:48:03, Roman wrote:

+
       // Now output resolved classes with inner elements we met before.
       resolvedClassMembers.forEach(emitter.outputClass);
       compiler.assembledCode = emitter.toString();
     } catch (BailoutException e) {
       compiler.assembledCode = '''
 main() {
   final bailout_reason = "${e.reason}";
 }
 ''';
     }
   }
 
   log(String message) => compiler.log('[DartBackend] $message');
 }
 
 /**
  * Checks if [:libraryElement:] is a core lib, that is a library
  * provided by the implementation like dart:core, dart:coreimpl, etc.
  */
 bool isDartCoreLib(Compiler compiler, LibraryElement libraryElement) {
   final libraries = compiler.libraries;
   for (final uri in libraries.getKeys()) {
     if (libraryElement === libraries[uri]) {
       if (uri.startsWith('dart:')) return true;
     }
   }
   return false;
 }
+
+class AdditionalElementCollector extends AbstractVisitor {

[Roman, 2012/08/09 16:48:03]

Please think about better name. What is "additional element" is unclear. We are
trying to collect all used types here, so maybe some name telling about type
collection?

[Anton Muhin, 2012/08/09 17:01:09]

Ok, is it any better?

On 2012/08/09 16:48:03, Roman wrote:

+  final Compiler compiler;
+  final Element element;
+  final TreeElements treeElements;
+  final Set<TypedefElement> typedefs;
+
+  AdditionalElementCollector(
+      this.compiler,
+      this.element, this.treeElements,
+      this.typedefs);
+
+  visitNode(Node node) { node.visitChildren(this); }
+
+  visitTypeAnnotation(TypeAnnotation typeAnnotation) {
+    Element element = treeElements[typeAnnotation];

[Roman, 2012/08/09 16:48:03]

I think canonically types should be resolved through treeElements.getType() . Is
there any difference if you try that?

[Anton Muhin, 2012/08/09 17:01:09]

Right now I don't want to resolve types, meaning I don't want get Type instance
back, at least for typedefs.  I might be forced to do that for classes though. 
Let's see.

On 2012/08/09 16:48:03, Roman wrote:

+    if (element !== null) {
+      if (element.isTypedef()) typedefs.add(element as TypedefElement);

[ahe, 2012/08/09 16:51:55]

The cast is unnecessary. Dart is a dynamically typed language with optional
types. Respect the dynamic nature :-)

[Anton Muhin, 2012/08/09 17:01:09]

Sure, I was just concerned if some tool will give me a warning here as a put
Element into Set<TypedefElement>.

On 2012/08/09 16:51:55, ahe wrote:

+    }
+    typeAnnotation.visitChildren(this);
+  }
+
+  void collect() {
+    element.parseNode(compiler).accept(this);
+  }
+}