First implementation of top-level fields without initializers.

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 FIELD = const ElementKind('field');
+  static final ElementKind VARIABLE_LIST = const ElementKind('variable_list');
+  static final ElementKind FIELD_LIST = const ElementKind('field_list');
   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 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';
 }
 
 class VariableElement extends Element {
-  final Node node;
-  final TypeAnnotation typeAnnotation;
+  final VariableListElement variables;
+
+  VariableElement(SourceString name, VariableListElement this.variables,
+                  ElementKind kind, [Element enclosing = null])
+    : super(name, kind, enclosing);
+
+  Node parseNode(Canceler canceler, Logger logger) {
+    return variables.parseNode(canceler, logger);
+  }
+
+  Type computeType(Compiler compiler, types) {
+    return variables.computeType(compiler, types);
+  }
+
+  Type get type() => variables.type;
+}
+
+// This element represents a list of variable or field declaration.
+// It contains the node, and the type. A [VariableElement] always
+// references its [VariableListElement]. It forwards its
+// [computeType] and [parseNode] methods to this element.
+class VariableListElement extends Element {
+  VariableDefinitions node;
   Type type;
 
-  VariableElement(Node this.node, TypeAnnotation this.typeAnnotation,
-                  ElementKind kind, SourceString name, Element enclosingElement)
-    : super(name, kind, enclosingElement);
+  VariableListElement(ElementKind kind, [Element enclosing = null])
+    : super(null, kind, enclosing);
+
+  VariableListElement.node(VariableDefinitions node,
+                           ElementKind kind,
+                           [Element enclosing = null])
+    : super(null, kind, enclosing),
+      this.node = node;
 
   Node parseNode(Canceler canceler, Logger logger) {

[karlklose, 2011/12/12 17:02:09]

Node -> VariableDefinitions.

[ngeoffray, 2011/12/12 17:18:04]

Done.

     return node;
   }
 
-  Type computeType(Compiler compiler, Types types) {
-    if (type !== null) return type;
-    type = getType(typeAnnotation, compiler, types);
+  Type computeType(Compiler compiler, types) {
+    if (type != null) return type;
+    type = getType(parseNode(compiler, compiler).type, compiler, types);
     return type;
   }
 }
 
 class ForeignElement extends Element {
   ForeignElement(SourceString name) : super(name, ElementKind.FOREIGN, null);
 
-  Type computeType(Compiler compiler, Types types) {
+  Type computeType(Compiler compiler, types) {
     return types.dynamicType;
   }
 }
 
 /**
  * TODO(ngeoffray): Remove this method in favor of using the universe.
  *
  * Return the type referred to by the type annotation. This method
  * accepts annotations with 'typeName == null' to indicate a missing
  * annotation.
@@ skipping 94 matching lines @@
 
 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>(); 
+  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) {
@@ skipping 21 matching lines @@
   // TODO(ngeoffray): Implement these.
   bool canHaveDefaultConstructor() => true;
 
   SynthesizedConstructorElement getSynthesizedConstructor() {
     if (synthesizedConstructor === null && canHaveDefaultConstructor()) {
       synthesizedConstructor = new SynthesizedConstructorElement(this);
     }
     return synthesizedConstructor;
   }
 }