Introduce FieldParameterElement.

frog/leg/resolver.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.
 
 interface TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
 }
 
 class TreeElementMapping implements TreeElements {
@@ skipping 31 matching lines @@
     return measure(() {
       switch (element.kind) {
         case ElementKind.GENERATIVE_CONSTRUCTOR:
         case ElementKind.FUNCTION:
         case ElementKind.GETTER:
         case ElementKind.SETTER:
           return resolveMethodElement(element);
 
         case ElementKind.FIELD:
         case ElementKind.PARAMETER:
+        case ElementKind.FIELD_PARAMETER:
           return resolveVariableElement(element);
 
         default:
           compiler.unimplemented(
               "resolver", node: element.parseNode(compiler));
       }
     });
   }
 
   SourceString getConstructorName(Send node) {
@@ skipping 579 matching lines @@
     // Put the parameters in scope.
     FunctionParameters functionParameters =
         function.computeParameters(compiler);
     Link<Node> parameterNodes = node.parameters.nodes;
     functionParameters.forEachParameter((Element element) {
       if (element == functionParameters.optionalParameters.head) {
         NodeList nodes = parameterNodes.head;
         parameterNodes = nodes.nodes;
       }
       VariableDefinitions variableDefinitions = parameterNodes.head;
-      defineElement(variableDefinitions.definitions.nodes.head, element);
+      Node parameterNode = variableDefinitions.definitions.nodes.head;
+      // Field parameters (this.x) are not visible inside the constructor. The
+      // fields they reference are visible, but must be resolved independently.
+      if (element.kind == ElementKind.FIELD_PARAMETER) {
+        useElement(parameterNode, element);
+      } else {
+        defineElement(variableDefinitions.definitions.nodes.head, element);        
+      }
       parameterNodes = parameterNodes.tail;
     });
   }
 
   Element visitClassNode(ClassNode node) {
     cancel(node, "shouldn't be called");
   }
 
   visitIn(Node node, Scope scope) {
     context = scope;
@@ skipping 756 matching lines @@
     return element;
   }
 
   Element visitIdentifier(Identifier node) {
     Element variables = new VariableListElement.node(currentDefinitions,
         ElementKind.VARIABLE_LIST, enclosingElement);
     return new VariableElement(node.source, variables,
         ElementKind.PARAMETER, enclosingElement, node: node);
   }
 
-  Element visitSend(Send node) {
-    Element element;
+  // The only valid [Send] can be in constructors and must be of the form
+  // [:this.x:] (where [:x:] represents an instance field).
+  FieldParameterElement visitSend(Send node) {
+    FieldParameterElement element;
     if (node.receiver.asIdentifier() === null ||
         !node.receiver.asIdentifier().isThis()) {
       error(node, MessageKind.INVALID_PARAMETER, []);
     } else if (enclosingElement.kind !== ElementKind.GENERATIVE_CONSTRUCTOR) {
       error(node, MessageKind.FIELD_PARAMETER_NOT_ALLOWED, []);
     } else {
       if (node.selector.asIdentifier() == null) {
         cancel(node,
                'internal error: unimplemented receiver on parameter send');
       }
       SourceString name = node.selector.asIdentifier().source;
-      element = currentClass.lookupLocalMember(name);
-      if (element.kind !== ElementKind.FIELD) {
+      Element fieldElement = currentClass.lookupLocalMember(name);
+      if (fieldElement === null || fieldElement.kind !== ElementKind.FIELD) {
         error(node, MessageKind.NOT_A_FIELD, [name]);
-      } else if (!element.isInstanceMember()) {
+      } else if (!fieldElement.isInstanceMember()) {
         error(node, MessageKind.NOT_INSTANCE_FIELD, [name]);
       }
+      Element variables = new VariableListElement.node(currentDefinitions,
+          ElementKind.VARIABLE_LIST, enclosingElement);
+      element = new FieldParameterElement(node.selector.asIdentifier().source,
+          fieldElement, variables, enclosingElement, node);      
     }
-    // TODO(ngeoffray): it's not right to put the field element in
-    // the parameters element. Create another element instead.
     return element;
   }
 
   Element visitSendSet(SendSet node) {
     Element element;
     if (node.receiver != null) {
-      // TODO(ngeoffray): it's not right to put the field element in
-      // the parameters element. Create another element instead.
       element = visitSend(node);
     } else if (node.selector.asIdentifier() != null) {
       Element variables = new VariableListElement.node(currentDefinitions,
           ElementKind.VARIABLE_LIST, enclosingElement);
       element = new VariableElement(node.selector.asIdentifier().source,
           variables, ElementKind.PARAMETER, enclosingElement, node: node);
     }
     // Visit the value. The compile time constant handler will
     // make sure it's a compile time constant.
     resolveExpression(node.arguments.head);
@@ skipping 10 matching lines @@
   LinkBuilder<Element> analyzeNodes(Link<Node> link) {
     LinkBuilder<Element> elements = new LinkBuilder<Element>();
     for (; !link.isEmpty(); link = link.tail) {
       Element element = link.head.accept(this);
       if (element != null) {
         elements.addLast(element);
       } else {
         // If parameter is null, the current node should be the last,
         // and a list of optional named parameters.
         if (!link.tail.isEmpty() || (link.head is !NodeList)) {
-          internalError(link.head, "expected expected optional parameters");
+          internalError(link.head, "expected optional parameters");
         }
       }
     }
     return elements;
   }
 
   static FunctionParameters analyze(Compiler compiler,
                                     FunctionElement element) {
     FunctionExpression node = element.parseNode(compiler);
     SignatureResolver visitor = new SignatureResolver(compiler, element);
@@ skipping 157 matching lines @@
 class TopScope extends Scope {
   LibraryElement get library() => element;
 
   TopScope(LibraryElement library) : super(null, library);
   Element lookup(SourceString name) => library.find(name);
 
   Element add(Element element) {
     throw "Cannot add an element in the top scope";
   }
 }