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

frog/leg/elements/elements.dart

Index: frog/leg/elements/elements.dart
===================================================================
--- frog/leg/elements/elements.dart	(revision 5225)
+++ frog/leg/elements/elements.dart	(working copy)
@@ -158,6 +158,46 @@
     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 {
@@ -219,10 +259,15 @@
   }
 
   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());
+      }
     }
   }
 
@@ -354,8 +399,11 @@
 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";
@@ -603,42 +651,7 @@
       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;
     }