Support some usages of empty classes.

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 53 matching lines @@
       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>();
+      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();
       });
 
       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);
+      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);
       compiler.assembledCode = emitter.toString();
     } catch (BailoutException e) {
       compiler.assembledCode = '''
 main() {
   final bailout_reason = "${e.reason}";
 }
 ''';
@@ skipping 21 matching lines @@
  * Some elements are not recorded by resolver now,
  * for example, typedefs or classes which are only
  * used in signatures, as/is operators or in super clauses
  * (just to name a few).  Retraverse AST to pick those up.
  */
 class ReferencedElementCollector extends AbstractVisitor {
   final Compiler compiler;
   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);
   }
 }