Implement field parameter for generative constructors.

frog/leg/resolver.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.
 
 interface TreeElements {
   Element operator[](Node node);
 }
 
 class TreeElementMapping implements TreeElements {
   Map<Node, Element> map;
@@ skipping 618 matching lines @@
     visit(node.condition);
     visitIn(node.body, new BlockScope(context));
   }
 
   visitParenthesizedExpression(ParenthesizedExpression node) {
     visit(node.expression);
   }
 
   visitNewExpression(NewExpression node) {
     if (node.isConst()) cancel(node, 'const expressions are not implemented');
+    if (node.send.selector.asTypeAnnotation() === null) {
+      cancel(
+          node, 'named constructors with type parameters are not implemented');

[ahe, 2012/01/24 14:28:44]

parameters -> arguments.

[ngeoffray, 2012/01/24 14:57:04]

Done.

+    }
 
     visit(node.send.argumentsNode);
 
     SourceString constructorName;
     Node typeName = node.send.selector.asTypeAnnotation().typeName;
     if (typeName.asSend() !== null) {
       Identifier receiver = typeName.asSend().receiver.asIdentifier();
       Identifier selector = typeName.asSend().selector.asIdentifier();
       SourceString className = receiver.source;
       SourceString name = selector.source;
@@ skipping 201 matching lines @@
     }
     resolver.visit(node.arguments.head);
     return visit(node.selector);
   }
 
   SourceString visitIdentifier(Identifier node) => node.source;
 
   visitNodeList(NodeList node) {
     for (Link<Node> link = node.nodes; !link.isEmpty(); link = link.tail) {
       SourceString name = visit(link.head);
-      VariableElement element = new VariableElement(
-          name, variables, kind, resolver.context.element, node: link.head);
-      resolver.defineElement(link.head, element);
+      if (name !== null) {
+        VariableElement element = new VariableElement(
+            name, variables, kind, resolver.context.element, node: link.head);
+        resolver.defineElement(link.head, element);
+      }
     }
   }
 
   visit(Node node) => node.accept(this);
 
+  visitSend(Node node) {
+    // The lhs is a property access. The parser never accepts this
+    // code right now if it's not a field initializer.
+    if (kind !== ElementKind.PARAMETER || node.receiver === null) {
+      resolver.cancel('internal error');
+    }
+
+    if (resolver.element.kind !== ElementKind.GENERATIVE_CONSTRUCTOR) {
+      resolver.error(node, MessageKind.FIELD_PARAMETER_NOT_ALLOWED, []);
+    } else if (node.receiver.asIdentifier() === null ||
+               !node.receiver.asIdentifier().isThis()) {
+      resolver.error(node, MessageKind.INVALID_FIELD_PARAMETER, []);
+    } else {
+      SourceString name = node.selector.asIdentifier().source;
+      Element field = resolver.currentClass.lookupLocalMember(name);
+      if (field.kind !== ElementKind.FIELD) {
+        resolver.error(node, MessageKind.NOT_A_FIELD, [name]);
+      } else if (!field.isInstanceMember()) {
+        resolver.error(node, MessageKind.NOT_INSTANCE_FIELD, [name]);
+      } else {
+        resolver.defineElement(node, field);

[ahe, 2012/01/24 14:28:44]

I think we should define the element regardlessly.

Also, don't you need to check that the enclosing element of the field is the
current class?

[ngeoffray, 2012/01/24 14:57:04]

Defining it.
No, I'm doing a lookup in the current class, and it only looks at its members.

+      }
+    }
+    return null;
+  }
+
   visitNode(Node node) {
     resolver.cancel(node, 'not implemented');
   }
 }
 
 // TODO(ahe): Frog cannot handle generic types.
 class ParametersVisitor extends AbstractVisitor/*<Element>*/ {
   ResolverVisitor resolver;
   LinkBuilder<Element> elements;
   ParametersVisitor(this.resolver) : elements = new LinkBuilder<Element>();
@@ skipping 89 matching lines @@
 class TopScope extends Scope {
   Universe universe;
 
   TopScope(Universe this.universe) : super(null, null);
   Element lookup(SourceString name) => universe.find(name);
 
   Element add(Element element) {
     throw "Cannot add an element in the top scope";
   }
 }