Second try for instantiation of objects.

frog/leg/elements/elements.dart

 // Copyright (c) 2011, 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.
 
 #library('elements');
 
 #import('../tree/tree.dart');
 #import('../scanner/scannerlib.dart');
 #import('../leg.dart');  // TODO(karlklose): we only need type.
 #import('../util/util.dart');
@@ skipping 12 matching lines @@
   final String id;
 
   const ElementKind(String this.id);
 
   static final ElementKind VARIABLE = const ElementKind('variable');
   static final ElementKind PARAMETER = const ElementKind('parameter');
   static final ElementKind FUNCTION = const ElementKind('function');
   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;
 }
 
 class Element implements Hashable {
   final SourceString name;
   final ElementKind kind;
   final Element enclosingElement;
   abstract Node parseNode(Canceler canceler, Logger logger);
   abstract Type computeType(Compiler compiler, Types types);
   bool isClassMember() =>
       enclosingElement !== null && enclosingElement.kind == ElementKind.CLASS;
   // TODO(ngeoffray): override in function element to check for modifiers.
-  bool isStatic() => !isClassMember();
+  bool isInstanceMember() => isClassMember();
 
   const Element(this.name, this.kind, this.enclosingElement);
 
   // TODO(kasperl): This is a very bad hash code for the element and
   // there's no reason why two elements with the same name should have
   // the same hash code. Replace this with a simple id in the element?
   int hashCode() => name.hashCode();
 
   toString() => '$name';
 }
@@ skipping 54 matching lines @@
   FunctionElement(SourceString name,
                   ElementKind kind,
                   Element enclosing)
     : super(name, kind, enclosing);
   FunctionElement.node(FunctionExpression node,
                        ElementKind kind,
                        Element enclosing)
     : super(node.name.asIdentifier().source, kind, enclosing),
       this.node = node;
 
+  bool isInstanceMember() {
+    // TODO(ngeoffray): use modifiers.
+    return super.isInstanceMember() && kind != ElementKind.CONSTRUCTOR;
+  }
+
   FunctionType computeType(Compiler compiler, types) {
     if (type != null) return type;
     if (parameters == null) compiler.resolveSignature(this);
     FunctionExpression node =
         compiler.parser.measure(() => parseNode(compiler, compiler));
     Type returnType = getType(node.returnType, compiler, types);
     if (returnType === null) compiler.cancel('unknown type ${node.returnType}');
 
     LinkBuilder<Type> parameterTypes = new LinkBuilder<Type>();
     for (Link<Element> link = parameters; !link.isEmpty(); link = link.tail) {
       parameterTypes.addLast(link.head.computeType(compiler, types));
     }
     type = new FunctionType(returnType, parameterTypes.toLink(), this);
     return type;
   }
 
   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);
+    this.parameters = constructor.parameters;
+    this.node = constructor.node;
+    this.type = constructor.type;
+  }
+
+  bool isInstanceMember() => true;
+
+  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) {
     parameters = const EmptyLink<Element>();
   }
 
   FunctionType computeType(Compiler compiler, types) {
     if (type != null) return type;
     type = new FunctionType(types.voidType, const EmptyLink<Type>(), this);
     return type;
   }
 
   Node parseNode(Canceler canceler, Logger logger) {
     if (node != null) return node;
     node = new FunctionExpression(
         new Identifier.synthetic(''),
         new NodeList.empty(),
         new Block(new NodeList.empty()));
     return node;
   }
 }
 
 class ClassElement extends Element {
   Type type;
   Type supertype;
   Link<Element> members = const EmptyLink<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);
 
   void addMember(Element element) {
     members = members.prepend(element);
   }
 
   Type computeType(compiler, types) {
     if (type === null) {
       type = new SimpleType(name, this);
     }
     return type;
   }
 
   void resolve(Compiler compiler) {
     if (isResolved) return;
     compiler.resolveType(this);
     isResolved = true;
   }
 
   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) {
       if (link.head.name == name) return link.head;
     }
     return null;
   }
 
   // TODO(ngeoffray): Implement these.
   bool canHaveDefaultConstructor() => true;
 
   SynthesizedConstructorElement getSynthesizedConstructor() {
     if (synthesizedConstructor === null && canHaveDefaultConstructor()) {
       synthesizedConstructor = new SynthesizedConstructorElement(this);
     }
     return synthesizedConstructor;
   }
 }