Second try for instantiation of objects.

frog/leg/elements/elements.dart

Index: frog/leg/elements/elements.dart
diff --git a/frog/leg/elements/elements.dart b/frog/leg/elements/elements.dart
index 85deb2d5583c50dbdfbb475b40092521363a81b2..1607ed91c30f6eeb56d6c1cf506905446d4e4f21 100644
--- a/frog/leg/elements/elements.dart
+++ b/frog/leg/elements/elements.dart
@@ -30,6 +30,8 @@ class ElementKind {
   static final ElementKind CLASS = const ElementKind('class');
   static final ElementKind FOREIGN = const ElementKind('foreign');
   static final ElementKind CONSTRUCTOR = const ElementKind('constructor');
+  static final ElementKind CONSTRUCTOR_BODY =
+      const ElementKind('constructor_body');
 
   toString() => id;
 }
@@ -118,6 +120,11 @@ class FunctionElement extends Element {
     : super(node.name.asIdentifier().source, kind, enclosing),
       this.node = node;
 
+  bool isStatic() {

[ngeoffray, 2011/12/09 14:27:44]

As discussed, I *strongly* prefer something like isInstanceMember. We could even
drop the isStatic to a hasThis method.

[floitsch, 2011/12/09 15:24:57]

Done.

+    // TODO(ngeoffray): use modifiers.
+    return super.isStatic() || kind == ElementKind.CONSTRUCTOR;
+  }
+
   FunctionType computeType(Compiler compiler, types) {
     if (type != null) return type;
     if (parameters == null) compiler.resolveSignature(this);
@@ -137,6 +144,26 @@ class FunctionElement extends Element {
   Node parseNode(Canceler canceler, Logger logger) => node;
 }
 
+class ConstructorBodyElement extends FunctionElement {
+  FunctionElement constructor;
+
+  ConstructorBodyElement(FunctionElement constructor)
+      : this.constructor = constructor,
+        super(constructor.name,
+              ElementKind.CONSTRUCTOR_BODY,
+              constructor.enclosingElement) {
+    assert(constructor.node !== null);
+  }
+
+  Link<Element> get parameters() => constructor.parameters;
+  FunctionExpression get node() => constructor.node;
+  Type get type() => constructor.type;

[ngeoffray, 2011/12/09 14:27:44]

Not really fund of these getters, since we have the fields. I'd assign the
fields in the constructor. But your approach does have the advantage of
enforcing consistency between type, node, parameters and constructor.

Maybe ConsutrctorBodyElement should just extend Element? Then the getters would
work OK for me.

[floitsch, 2011/12/09 15:24:57]

Needs to be a FunctionElement. Copied over the fields.

+  bool isStatic() => false;
+
+  FunctionType computeType(Compiler compiler, types) { unreachable(); }
+  Node parseNode(Canceler canceler, Logger logger) { unreachable(); }
+}
+
 class SynthesizedConstructorElement extends FunctionElement {
   SynthesizedConstructorElement(Element enclosing)
     : super(enclosing.name, ElementKind.CONSTRUCTOR, enclosing) {
@@ -166,6 +193,9 @@ class ClassElement extends Element {
   Link<Type> interfaces = const EmptyLink<Type>();
   bool isResolved = false;
   ClassNode node;
+  // backendMembers are members that have been added by the backend to simplify
+  // compilation. They don't have any user-side counter-part.
+  Link<Element> backendMembers = const EmptyLink<Element>(); 
   SynthesizedConstructorElement synthesizedConstructor;
 
   ClassElement(SourceString name) : super(name, ElementKind.CLASS, null);
@@ -188,7 +218,7 @@ class ClassElement extends Element {
   }
 
   Element lookupLocalElement(SourceString name) {
-    // TODO(karlklose): replace with more eficient solution.
+    // TODO(karlklose): replace with more efficient solution.
     for (Link<Element> link = members;
          link !== null && !link.isEmpty();
          link = link.tail) {