First instantiations 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);
@@ skipping 87 matching lines @@
     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);
+  }
+
+  Link<Element> get parameters() => constructor.parameters;
+  FunctionExpression get node() => constructor.node;
+  Type get type() => constructor.type;
+  bool isStatic() => false;
+
+  FunctionType computeType(Compiler compiler, types) { unreachable(); }
+  Node parseNode(Canceler canceler, Logger logger) { unreachable(); }
+}
+
 class SynthesizedConstructorElement extends FunctionElement {
   SynthesizedConstructorElement(Element enclosing)
     : super(const SourceString(''), 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;
   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; 
   SynthesizedConstructorElement synthesizedConstructor;
 
-  ClassElement(SourceString name) : super(name, ElementKind.CLASS, null);
+  ClassElement(SourceString name)
+      : backendMembers = const EmptyLink(),
+        super(name, ElementKind.CLASS, null);
 
   Type computeType(compiler, types) {
     if (type === null) {
       type = new SimpleType(name, this);
     }
     return type;
   }
 
   void resolve(Compiler compiler) {
     if (isResolved) return;
@@ skipping 14 matching lines @@
   // TODO(ngeoffray): Implement these.
   bool canHaveDefaultConstructor() => true;
 
   SynthesizedConstructorElement getSynthesizedConstructor() {
     if (synthesizedConstructor === null && canHaveDefaultConstructor()) {
       synthesizedConstructor = new SynthesizedConstructorElement(this);
     }
     return synthesizedConstructor;
   }
 }