dart2dart support for instantiatin simple top-level class:

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);
 }
 
 class DartBackend extends Backend {
   final List<CompilerTask> tasks;
   final UnparseValidator unparseValidator;
 
   Map<Element, TreeElements> get resolvedElements() =>
       compiler.enqueuer.resolution.resolvedElements;
+  Map<ClassElement, Set<Element>> resolvedClassMembers;
 
   DartBackend(Compiler compiler, [bool validateUnparse = false])
       : tasks = <CompilerTask>[],
       unparseValidator = new UnparseValidator(compiler, validateUnparse),
+      resolvedClassMembers = new Map<ClassElement, Set<Element>>(),
       super(compiler) {
     tasks.add(unparseValidator);
   }
 
   void enqueueHelpers(Enqueuer world) {
     // TODO(antonm): Implement this method, if needed.
   }
 
   CodeBlock codegen(WorkItem work) { return new CodeBlock(null, null); }
 
   void processNativeClasses(Enqueuer world,
                             Collection<LibraryElement> libraries) {
   }
 
+  /**
+   * Adds given class element with its inner element to resolved classes

[Anton Muhin, 2012/07/10 11:31:40]

inner should probably be something like member, it's not obvious what inner
means in this context.

[Roman, 2012/07/10 11:53:40]

Done.

+   * collections.
+   */
+  void addResolvedElementForClass(Element element, ClassElement classElement) {
+    // ${element} should have ${classElement} as enclosing.
+    assert(element.enclosingElement == classElement);
+    List<Element> resolvedElementsInClass = resolvedClassMembers.putIfAbsent(

[Anton Muhin, 2012/07/10 11:31:40]

nit: even as

rCM.putIfAbsent(classElement, () => <Element>[] /* no need in new...
*/).add(element)

[Roman, 2012/07/10 11:53:40]

Done.

+        classElement, () => new List<Element>());
+    resolvedElementsInClass.add(element);
+  }
+
+  /**
+   * Resolves enclosing class for given element and adds to a collection of
+   * resolved class members.
+   */
+  void resolveMember(Element element) {

[Anton Muhin, 2012/07/10 11:31:40]

again, it's not resolving.  If anything, it's processing.

[Roman, 2012/07/10 11:53:40]

Done.

+    // We should not resolve classes for top-level elements.
+    assert(!element.isTopLevel());
+    assert(element.isMember());

[Anton Muhin, 2012/07/10 11:31:40]

I don't think you may have element.isMember() && element.isTopLevel(), so one of
those asserts is bogus. 

[Roman, 2012/07/10 11:53:40]

removed isTopLevel() assert

+    var enclosingClass = element.enclosingElement;
+    assert(enclosingClass.isTopLevel());
+    addResolvedElementForClass(element, enclosingClass);
+  }
+
+  /**
+   * Outputs given class element with given inner elements to a string buffer.
+   */
+  void outputClass(ClassElement classElement, List<Element> innerElements,
+      StringBuffer sb) {
+    // TODO(smok): Very soon properly print out correct class declaration with
+    // extends, implements, etc.
+    sb.add('class ');
+    sb.add(classElement.name.slowToString());
+    sb.add('{');
+    innerElements.forEach((element) {
+      // TODO(smok): Filter out default constructors here.
+      sb.add(element.parseNode(compiler).unparse());
+    });
+    sb.add('}');
+  }
+
   void assembleProgram() {
     resolvedElements.forEach((element, treeElements) {
       unparseValidator.check(element);
     });
 
     // TODO(antonm): Eventually bailouts will be proper errors.
     void bailout(String reason) {
       throw new BailoutException(reason);
     }
 
     /**
      * Tells whether we should output given element. Corelib classes like
      * Object should not be in the resulting code.
      */
     bool shouldOutput(Element element) {
       return element.kind !== ElementKind.VOID
           && element.getLibrary() !== compiler.coreLibrary;
     }
 
     try {
       StringBuffer sb = new StringBuffer();
       resolvedElements.forEach((element, treeElements) {
         if (!shouldOutput(element)) return;
+        if (element.isMember()) {
+          resolveMember(element);
+          return;
+        }
         if (!element.isTopLevel()) {
           bailout('Cannot process non top-level $element');
         }
 
         if (element.isField()) {
           // Add modifiers first.
           sb.add(element.modifiers.toString());
           sb.add(' ');
           // Figure out type.
           if (element is VariableElement) {
             VariableListElement variables = element.variables;
             if (variables.type !== null) {
               sb.add(variables.type);
               sb.add(' ');
             }
           }
           // TODO(smok): Maybe not rely on node unparsing,
           // but unparse initializer manually.
           sb.add(element.parseNode(compiler).unparse());
           sb.add(';');
         } else {
           sb.add(element.parseNode(compiler).unparse());
         }
       });
+
+      // Now output resolved classes with inner elements we met before.
+      resolvedClassMembers.forEach((classElement, resolvedElements) {
+        outputClass(classElement, resolvedElements, sb);
+      });
       compiler.assembledCode = sb.toString();
     } catch (BailoutException e) {
       compiler.assembledCode = '''
 main() {
   final bailout_reason = "${e.reason}";
 }
 ''';
     }
   }
 
   log(String message) => compiler.log('[DartBackend] $message');
 }