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, List<Element>> resolvedClasses;

[Anton Muhin, 2012/07/10 09:50:12]

resolvedClasses doesn't sound correct.  That's rather classMembers, wdyt?

[Anton Muhin, 2012/07/10 09:50:12]

should it be List<Element> or Set<Element>?

[Roman, 2012/07/10 10:45:15]

renamed to resolvedClassMembers

[Roman, 2012/07/10 10:45:15]

Correct! Changed to set

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

I'd rather not see word resolved here.  It's used in resolvedElements because
it's just a shortcut to resolution enqueuer.  In your case, you're not resolving
stuff any more.

But up to you.

On 2012/07/10 10:45:15, Roman wrote:

 
   DartBackend(Compiler compiler, [bool validateUnparse = false])
       : tasks = <CompilerTask>[],
       unparseValidator = new UnparseValidator(compiler, validateUnparse),
       super(compiler) {
     tasks.add(unparseValidator);
+    resolvedClasses = new HashMap<ClassElement, List<Element>>();

[Anton Muhin, 2012/07/10 09:50:12]

no need to make default implementation explicit and it should go into intializer
list.

[Roman, 2012/07/10 10:45:15]

Done.

   }
 
   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
+   * collections.
+   */
+  void addResolvedElementForClass(Element element, ClassElement classElement) {
+    if (element.enclosingElement !== classElement) {

[Anton Muhin, 2012/07/10 09:50:12]

assert?

[Roman, 2012/07/10 10:45:15]

Done.

+      compiler.internalError(
+          '${element} should have ${classElement} as enclosing');
+    }
+    List<Element> resolvedElementsInClass = resolvedClasses[classElement];
+    if (resolvedElementsInClass == null) {

[Anton Muhin, 2012/07/10 09:50:12]

nit: there is putIfAbsent thing which may encode this pattern nicely.

[Roman, 2012/07/10 10:45:15]

Awesome thing, thanks!

+      resolvedElementsInClass = new List<Element>();
+      resolvedClasses[classElement] = resolvedElementsInClass;
+    }
+    resolvedElementsInClass.add(element);
+  }
+
+  /**
+   * Resolves enclosing class for given elements and adds to a collection of
+   * resolved classes, remembering the inner element.
+   */
+  void resolveClass(Element element) {
+    if (element.isTopLevel()) {

[Anton Muhin, 2012/07/10 09:50:12]

it rather should be an assert (see below regarding isMember())

[Roman, 2012/07/10 10:45:15]

Done.

+      compiler.internalError(
+          'We should not resolve classes for top-level elements');
+    }
+    var enclosingClass = element.enclosingElement;

[Anton Muhin, 2012/07/10 09:50:12]

it should probably be if (element.isMember())

[Roman, 2012/07/10 10:45:15]

what do you mean by 'it'? This is a check whether enclosing element is a class.
It may be another element kind in theory (another method maybe?), we can't
process this case yet.

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

Sorry.  If I was to write this code, I would do the following:

1) I'll drop resolveClass (now resolveMember) method altogether;
2) in assembleProgram instead of if (!element.isTopLevel()) I'd write:

if (element.isMember()) {
  addMemberToClass(element, element.enclodingElement);
  return;
}

where addMemberToClass is (IMHO of course) better name for
addResolvedElementForClass (which rather reads take unresolved class element,
resolve it and add somewhere).

On 2012/07/10 10:45:15, Roman wrote:

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

Removed processMember(), moved code to assembleProgram

+    if (!enclosingClass.isClass()) {
+      bailout('resolve $element with enclosing non-class element');
+    }
+    addResolvedElementForClass(element, enclosingClass);
+    if (!enclosingClass.isTopLevel()) {

[Anton Muhin, 2012/07/10 09:50:12]

I'd rather make it assert as classes must be top-level to my best knowledge.

[Roman, 2012/07/10 10:45:15]

Done.

+      bailout('resolve $element with enclosing non-top-level class');
+    }
+  }
+
+  /**
+   * 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.isTopLevel()) {
-          bailout('Cannot process non top-level $element');
+          resolveClass(element);

[Anton Muhin, 2012/07/10 09:50:12]

I would rather have something like:

if (element.isMember()) {
  processMember(element);
  return;
}

[Roman, 2012/07/10 10:45:15]

Done.

+          return;
         }
 
         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.
+      resolvedClasses.forEach((classElement, resolvedElements) {
+        outputClass(classElement, resolvedElements, sb);

[Anton Muhin, 2012/07/10 09:50:12]

if you made outputClass a closure, you can have nice:
resolvedClasses.forEach(outputClass);  or just inline it instead of adding a new
method.

[Roman, 2012/07/10 10:45:15]

I would prefer to leave it this way, if you don't mind. It looks more clear to
reader what's happening than closure.

+      });
       compiler.assembledCode = sb.toString();
     } catch (BailoutException e) {
       compiler.assembledCode = '''
 main() {
   final bailout_reason = "${e.reason}";
 }
 ''';
     }
   }
 
   log(String message) => compiler.log('[DartBackend] $message');
 }