Setup getter and setter elements.

dart/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 20 matching lines @@
   static final ElementKind FOREIGN = const ElementKind('foreign');
   static final ElementKind GENERATIVE_CONSTRUCTOR =
       const ElementKind('generative_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 GENERATIVE_CONSTRUCTOR_BODY =
       const ElementKind('generative_constructor_body');
   static final ElementKind COMPILATION_UNIT =
       const ElementKind('compilation_unit');
+  static final ElementKind GETTER = const ElementKind('getter');
+  static final ElementKind SETTER = const ElementKind('setter');
 
   toString() => id;
 }
 
 class Element implements Hashable {
   final SourceString name;
   final ElementKind kind;
   final Element enclosingElement;
   Modifiers get modifiers() => null;
 
@@ skipping 15 matching lines @@
   bool isCompilationUnit() => kind == ElementKind.COMPILATION_UNIT;
   bool isVariable() => kind == ElementKind.VARIABLE;
   bool isParameter() => kind == ElementKind.PARAMETER;
 
   bool isAssignable() {
     if (modifiers != null && modifiers.isFinal()) return false;
     if (isFunction() || isGenerativeConstructor()) return false;
     return true;
   }
 
+  Token position() => null;
+
   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() => '$kind($name)';
 }
 
@@ skipping 39 matching lines @@
 
   Type computeType(Compiler compiler) {
     return variables.computeType(compiler);
   }
 
   Type get type() => variables.type;
 
   bool isInstanceMember() {
     return isMember() && !modifiers.isStatic();
   }
+
+  Token position() {
+    return (cachedNode !== null)
+        ? cachedNode.getBeginToken() : variables.position();

[ngeoffray, 2012/01/25 08:36:05]

This will return different values in time. Is that what we want?

[ahe, 2012/01/25 08:56:24]

You're right.

I'll add a todo to record the Token instead of the SourceString. It isn't good
enough to try to extract the information from the name, as this might be a byte
offset, not a character offset.

+  }
 }
 
 // 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 cachedNode;
   Type type;
   final Modifiers modifiers;
@@ skipping 13 matching lines @@
   VariableDefinitions parseNode(Canceler canceler, Logger logger) {
     return cachedNode;
   }
 
   Type computeType(Compiler compiler) {
     if (type != null) return type;
     type = getType(parseNode(compiler, compiler).type, compiler,
                    compiler.types);
     return type;
   }
+
+  Token position() => cachedNode.getBeginToken();
 }
 
 class ForeignElement extends Element {
   ForeignElement(SourceString name) : super(name, ElementKind.FOREIGN, null);
 
   Type computeType(Compiler compiler) {
     return compiler.types.dynamicType;
   }
 
   parseNode(Canceler canceler, Logger logger) {
@@ skipping 76 matching lines @@
 
     LinkBuilder<Type> parameterTypes = new LinkBuilder<Type>();
     for (Link<Element> link = parameters; !link.isEmpty(); link = link.tail) {
       parameterTypes.addLast(link.head.computeType(compiler));
     }
     type = new FunctionType(returnType, parameterTypes.toLink(), this);
     return type;
   }
 
   Node parseNode(Canceler canceler, Logger logger) => cachedNode;
+
+  Token position() => cachedNode.getBeginToken();
 }
 
 class ConstructorBodyElement extends FunctionElement {
   FunctionElement constructor;
 
   ConstructorBodyElement(FunctionElement constructor)
       : this.constructor = constructor,
         super(constructor.name,
               ElementKind.GENERATIVE_CONSTRUCTOR_BODY,
               null,
               constructor.enclosingElement) {
     this.parameters = constructor.parameters;
   }
 
   bool isInstanceMember() => true;
 
   FunctionType computeType(Compiler compiler) { unreachable(); }
 
   Node parseNode(Canceler canceler, Logger logger) {
     if (cachedNode !== null) return cachedNode;
     cachedNode = constructor.parseNode(canceler, logger);
     assert(cachedNode !== null);
     return cachedNode;
   }
+
+  Token position() => constructor.position();
 }
 
 class SynthesizedConstructorElement extends FunctionElement {
   SynthesizedConstructorElement(Element enclosing)
     : super(enclosing.name, ElementKind.GENERATIVE_CONSTRUCTOR,
             null, enclosing) {
     parameters = const EmptyLink<Element>();
   }
 
   FunctionType computeType(Compiler compiler) {
     if (type != null) return type;
     Type returnType = compiler.types.voidType;
     type = new FunctionType(returnType, const EmptyLink<Type>(), this);
     return type;
   }
 
   Node parseNode(Canceler canceler, Logger logger) {
     if (cachedNode != null) return cachedNode;
     cachedNode = new FunctionExpression(
         new Identifier.synthetic(''),
         new NodeList.empty(),
         new Block(new NodeList.empty()),
         null, null, null);
     return cachedNode;
   }
+
+  Token position() => null;
 }
 
 class ClassElement extends Element {
   Type type;
   Type supertype;
   Link<Element> members = const EmptyLink<Element>();
   Map<SourceString, Element> localMembers;
   Map<SourceString, Element> constructors;
   Link<Type> interfaces = const EmptyLink<Type>();
   bool isResolved = false;
@@ skipping 98 matching lines @@
     if (send.isPropertyAccess) return false;
     if (send.receiver !== null) return false;
     Element element = elements[send];
     // (o)() or foo()().
     if (element === null && send.selector.asIdentifier() === null) return true;
     if (element === null) return false;
     // foo() with foo a local or a parameter.
     return element.isVariable() || element.isParameter();
   }
 }