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 47 matching lines @@
     const ElementKind('field', ElementCategory.VARIABLE);
   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.
+    const ElementKind('getter', ElementCategory.NONE);
   static final ElementKind SETTER =
-    const ElementKind('setter',
-                      ElementCategory.VARIABLE); // TODO(ahe): Sb. NONE.
+    const ElementKind('setter', ElementCategory.NONE);
   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 addGetterOrSetter(Element element,
+                         Element existing,
+                         DiagnosticListener listener) {
+    void reportError(Element other) {
+      listener.cancel('duplicate definition of ${element.name.slowToString()}',
+                      element: element);
+      listener.cancel('existing definition', element: other);
+    }
+
+    if (existing != null) {
+      if (existing.kind !== ElementKind.ABSTRACT_FIELD) {
+        reportError(existing);
+      } else {
+        AbstractFieldElement field = existing;
+        if (element.kind == ElementKind.GETTER) {
+          if (field.getter != null && field.getter != element) {
+            reportError(field.getter);
+          }
+          field.getter = element;
+        } else {
+          if (field.setter != null && field.setter != element) {
+            reportError(field.setter);
+          }
+          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) {
+      addGetterOrSetter(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 228 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;
-        }
-      }
+      addGetterOrSetter(element, localMembers[element.name], listener);
     } else {
       localMembers[element.name] = element;
     }
   }
 
   Type computeType(compiler) {
     if (type === null) {
       type = new SimpleType(name, this);
     }
     return type;
@@ skipping 209 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;
 }