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 DartBackend extends Backend {
   final List<CompilerTask> tasks;
   final UnparseValidator unparseValidator;
 
   Map<Element, TreeElements> get resolvedElements() =>
       compiler.enqueuer.resolution.resolvedElements;
@@ skipping 41 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());
 
     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(
-          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()) {
         compiler.cancel(reason: 'Cannot process $element', element: 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;
+      emitter.outputClass(classElement, emptySet);
+    });
 
     // Now output resolved classes with inner elements we met before.
     resolvedClassMembers.forEach(emitter.outputClass);
     compiler.assembledCode = emitter.toString();
   }
 
   log(String message) => compiler.log('[DartBackend] $message');
 }
 
 /**
@@ skipping 14 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) {
-      if (element.isTypedef()) typedefs.add(element);
-    }
+    final type = compiler.resolveTypeAnnotation(element, typeAnnotation);
+    Element typeElement = type.element;
+    if (typeElement.isTypedef()) typedefs.add(typeElement);
+    if (typeElement.isClass()) classes.add(typeElement);
     typeAnnotation.visitChildren(this);
   }
 
   void collect() {
     element.parseNode(compiler).accept(this);
   }
 }