Support some usages of empty classes.

lib/compiler/implementation/dart_backend/backend.dart

Index: lib/compiler/implementation/dart_backend/backend.dart
diff --git a/lib/compiler/implementation/dart_backend/backend.dart b/lib/compiler/implementation/dart_backend/backend.dart
index 24d77a7b073d6b532c7faba2a1e612ca573e54d4..d01b4ce979af2d671a6568ea3d85b8a03782d696 100644
--- a/lib/compiler/implementation/dart_backend/backend.dart
+++ b/lib/compiler/implementation/dart_backend/backend.dart
@@ -71,13 +71,14 @@ class DartBackend extends Backend {
 
     try {
       Set<TypedefElement> typedefs = new Set<TypedefElement>();
+      Set<ClassElement> classes = new Set<ClassElement>();
       PlaceholderCollector collector = new PlaceholderCollector(compiler);
       resolvedElements.forEach((element, treeElements) {
         if (!shouldOutput(element)) return;
         if (element is AbstractFieldElement) return;
         collector.collect(element, treeElements);
         new ReferencedElementCollector(

[Roman, 2012/08/10 07:27:40]

This is probably controversial, but I think "typedefs" and "classes" should not
be passed to constructor, better after collect() take them out of
ReferencedElementCollector. Otherwise here it is not clear what you pass to
ReferencedElementCollector as "input" element (like compiler, element and
treeElements) and what - as "output" (typedefs, classes).

[Anton Muhin, 2012/08/10 08:33:37]

Indeed.  For example, I really don't like that you set all those
currentElement/treeElements when entering collect method---I personally prefer
immutability of references/state.

On 2012/08/10 07:27:40, Roman wrote:

-            compiler, element, treeElements, typedefs)
+            compiler, element, treeElements, typedefs, classes)
         .collect();
       });
 
@@ -101,6 +102,12 @@ class DartBackend extends Backend {
       });
 
       typedefs.forEach(emitter.outputElement);
+      final emptySet = new Set<Element>();
+      classes.forEach((classElement) {
+        if (!shouldOutput(classElement)) return;
+        if (resolvedClassMembers.containsKey(classElement)) return;

[Roman, 2012/08/10 07:27:40]

Why not unify "classes" collection and "resolvedClassMembers"? The latter may be
renamed to "resolvedClasses". If referenced class does not have any members we
care about, the set it maps to will just be null. That's one less forEach here.

[Anton Muhin, 2012/08/10 08:33:37]

I am considering this too.  But for now I'd prefer to have minimal coupling
between components: this code just collects additional stuff and knows nothing
about the rest of system.  That usually pays off.

On 2012/08/10 07:27:40, Roman wrote:

[Roman, 2012/08/10 08:46:01]

"Not knowing about the rest of system" is not quite true. Here you utput
elements from "classes" you check another contatiner "resolvedClassMembers", so
here is coupling.

Populating one container from different sources (collectors) does not add
anything to coupling, one collector does not know anything about the other. but
if you unify them it would tell that we actually collecting the same kind of
objects - classes that we use. And we even process them in the same way - with
outputClass.

The downsides of current approach:
1) you have to check that you don't accidentally output the same element twice,
hence the check that classElement is not in resolvedClassMembers.
2) duplicating code that outputs the classes: from "classes" and from
"resolvedClassMembers".

[Anton Muhin, 2012/08/10 08:56:48]

I meant pretty simple thing: ReferencedElementCollector knows nothing about the
rest of the system.

I am seriously considering provide callbacks instead of collections, but I'ld
like to see how this part of system grows to take the ultimate decision.

On 2012/08/10 08:46:01, Roman wrote:

+        emitter.outputClass(classElement, emptySet);
+      });
 
       // Now output resolved classes with inner elements we met before.
       resolvedClassMembers.forEach(emitter.outputClass);
@@ -142,22 +149,31 @@ class ReferencedElementCollector extends AbstractVisitor {
   final Element element;
   final TreeElements treeElements;
   final Set<TypedefElement> typedefs;
+  final Set<ClassElement> classes;
 
   ReferencedElementCollector(
       this.compiler,
       this.element, this.treeElements,
-      this.typedefs);
+      this.typedefs, this.classes);
 
   visitNode(Node node) { node.visitChildren(this); }
 
   visitTypeAnnotation(TypeAnnotation typeAnnotation) {
     Element element = treeElements[typeAnnotation];
     if (element !== null) {

[Roman, 2012/08/10 07:27:40]

This IF may be changed to just "compiler.resolveTypeAnnotation()" and then
addElement(type.element).

[Anton Muhin, 2012/08/10 08:33:37]

Good point, done.

On 2012/08/10 07:27:40, Roman wrote:

-      if (element.isTypedef()) typedefs.add(element);
+      addElement(element);
+    } else {
+      final type = compiler.resolveTypeAnnotation(this.element, typeAnnotation);
+      addElement(type.element);
     }
     typeAnnotation.visitChildren(this);
   }
 
+  addElement(Element element) {
+    if (element.isTypedef()) typedefs.add(element);
+    if (element.isClass()) classes.add(element);
+  }
+
   void collect() {
     element.parseNode(compiler).accept(this);
   }