Also create abstract fields for top-level getters and setters.

frog/leg/elements/elements.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.
 
 #library('elements');
 
 #import('../tree/tree.dart');
 #import('../scanner/scannerlib.dart');
 #import('../leg.dart');  // TODO(karlklose): we only need type.
 #import('../util/util.dart');
@@ skipping 48 matching lines @@
   static final ElementKind VARIABLE_LIST =
     const ElementKind('variable_list', ElementCategory.NONE);
   static final ElementKind FIELD_LIST =
     const ElementKind('field_list', ElementCategory.NONE);
   static final ElementKind GENERATIVE_CONSTRUCTOR_BODY =
       const ElementKind('generative_constructor_body', ElementCategory.NONE);
   static final ElementKind COMPILATION_UNIT =
       const ElementKind('compilation_unit', ElementCategory.NONE);
   static final ElementKind GETTER =
     const ElementKind('getter',
                       ElementCategory.VARIABLE); // TODO(ahe): Sb. NONE.

[ahe, 2012/03/09 10:22:09]

I think this can be NONE now.

[ngeoffray, 2012/03/09 13:05:56]

Done.

   static final ElementKind SETTER =
     const ElementKind('setter',
                       ElementCategory.VARIABLE); // TODO(ahe): Sb. NONE.

[ahe, 2012/03/09 10:22:09]

Ditto.

[ngeoffray, 2012/03/09 13:05:56]

Done.

   static final ElementKind ABSTRACT_FIELD =
     const ElementKind('abstract_field', ElementCategory.VARIABLE);
   static final ElementKind LIBRARY =
     const ElementKind('library', ElementCategory.NONE);
   static final ElementKind PREFIX =
     const ElementKind('prefix', ElementCategory.PREFIX);
   static final ElementKind TYPEDEF =
     const ElementKind('typedef', ElementCategory.ALIAS);
 
   static final ElementKind STATEMENT =
@@ skipping 68 matching lines @@
   }
 
   toString() => '$kind(${name.slowToString()})';
 }
 
 class ContainerElement extends Element {
   ContainerElement(name, kind, enclosingElement) :
     super(name, kind, enclosingElement);
 
   abstract void addMember(Element element, DiagnosticListener listener);
+
+  void handleGetterOrSetter(Element element,

[karlklose, 2012/03/09 10:20:54]

Call it addGetterOrSetter instead?

[ngeoffray, 2012/03/09 13:05:56]

Done.

+                            Element existing,
+                            DiagnosticListener listener) {
+    if (existing != null) {
+      if (existing.kind !== ElementKind.ABSTRACT_FIELD) {
+        listener.cancel('duplicate definition of ${name.slowToString()}',

[karlklose, 2012/03/09 10:20:54]

You could extract the error reporting to a local function.

[ngeoffray, 2012/03/09 13:05:56]

Done.

+                        element: element);
+        listener.cancel('existing definition', element: existing);
+      } else {
+        AbstractFieldElement field = existing;
+        if (element.kind == ElementKind.GETTER) {
+          if (field.getter != null) {
+            listener.cancel('duplicate definition of getter ${element.name}',
+                            element: element);
+            listener.cancel('existing definition', element: field.getter);
+          } else {
+            field.getter = element;
+          }
+        } else {
+          if (field.setter != null) {
+            listener.cancel('duplicate definition of setter ${element.name}',
+                            element: element);
+            listener.cancel('existing definition', element: field.setter);
+          } else {
+            field.setter = element;
+          }
+        }
+      }
+    } else {
+      AbstractFieldElement field =
+          new AbstractFieldElement(element.name, this);
+      addMember(field, listener);
+      if (element.kind == ElementKind.GETTER) {
+        field.getter = element;
+      } else {
+        field.setter = element;
+      }
+    }
+  }
 }
 
 class CompilationUnitElement extends ContainerElement {
   final Script script;
   Link<Element> topLevelElements = const EmptyLink<Element>();
 
   CompilationUnitElement(Script script, Element enclosing)
     : this.script = script,
       super(new SourceString(script.name),
             ElementKind.COMPILATION_UNIT,
@@ skipping 41 matching lines @@
   void addTag(ScriptTag tag, DiagnosticListener listener) {
     tags = tags.prepend(tag);
   }
 
   void addMember(Element element, DiagnosticListener listener) {
     topLevelElements = topLevelElements.prepend(element);
     define(element, listener);
   }
 
   void define(Element element, DiagnosticListener listener) {
-    Element existing = elements.putIfAbsent(element.name, () => element);
-    if (existing !== element) {
-      listener.cancel('duplicate definition', token: element.position());
-      listener.cancel('existing definition', token: existing.position());
+    if (element.kind == ElementKind.GETTER
+        || element.kind == ElementKind.SETTER) {
+      handleGetterOrSetter(element, elements[element.name], listener);
+    } else {
+      Element existing = elements.putIfAbsent(element.name, () => element);
+      if (existing !== element) {
+        listener.cancel('duplicate definition', token: element.position());
+        listener.cancel('existing definition', token: existing.position());
+      }
     }
   }
 
   Element find(SourceString name) {
     return elements[name];
   }
 
   Element lookupLocalMember(SourceString name) {
     Element element = find(name);
     if (element === null) return null;
@@ skipping 111 matching lines @@
   }
 
   parseNode(DiagnosticListener listener) {
     throw "internal error: ForeignElement has no node";
   }
 }
 
 class AbstractFieldElement extends Element {
   FunctionElement getter;
   FunctionElement setter;
+  Modifiers modifiers;
+
   AbstractFieldElement(SourceString name, Element enclosing)
-      : super(name, ElementKind.ABSTRACT_FIELD, enclosing);
+      : super(name, ElementKind.ABSTRACT_FIELD, enclosing),
+        modifiers = new Modifiers.empty();
 
   Type computeType(Compiler compiler) {
     throw "internal error: AbstractFieldElement has no type";
   }
 
   Node parseNode(DiagnosticListener listener) {
     throw "internal error: AbstractFieldElement has no node";
   }
 }
 
@@ skipping 227 matching lines @@
       constructors = new Map<SourceString, Element>(),
       super(name, ElementKind.CLASS, enclosing);
 
   void addMember(Element element, DiagnosticListener listener) {
     members = members.prepend(element);
     if (element.kind == ElementKind.GENERATIVE_CONSTRUCTOR ||
         element.modifiers.isFactory()) {
       constructors[element.name] = element;
     } else if (element.kind == ElementKind.GETTER
                || element.kind == ElementKind.SETTER) {
-      Element existing = localMembers[element.name];
-      if (existing != null) {
-        if (existing.kind !== ElementKind.ABSTRACT_FIELD) {
-          listener.cancel('duplicate definition of ${name.slowToString()}',
-                          element: element);
-          listener.cancel('existing definition', element: existing);
-        } else {
-          AbstractFieldElement field = existing;
-          if (element.kind == ElementKind.GETTER) {
-            if (field.getter != null) {
-              listener.cancel('duplicate definition of getter ${element.name}',
-                              element: element);
-              listener.cancel('existing definition', element: field.getter);
-            } else {
-              field.getter = element;
-            }
-          } else {
-            if (field.setter != null) {
-              listener.cancel('duplicate definition of setter ${element.name}',
-                              element: element);
-              listener.cancel('existing definition', element: field.setter);
-            } else {
-              field.setter = element;
-            }
-          }
-        }
-      } else {
-        AbstractFieldElement field =
-            new AbstractFieldElement(element.name, this);
-        localMembers[element.name] = field;
-        if (element.kind == ElementKind.GETTER) {
-          field.getter = element;
-        } else {
-          field.setter = element;
-        }
-      }
+      handleGetterOrSetter(element, localMembers[element.name], listener);
     } else {
       localMembers[element.name] = element;
     }
   }
 
   Type computeType(compiler) {
     if (type === null) {
       type = new SimpleType(name, this);
     }
     return type;
@@ skipping 204 matching lines @@
 
   LabelElement addLabel(Identifier label, String labelName) {
     LabelElement result = new LabelElement(label, labelName, this,
                                            enclosingElement);
     labels = labels.prepend(result);
     return result;
   }
 
   Node parseNode(DiagnosticListener l) => statement;
 }