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 751 matching lines @@
       cancel(node, 'function type parameters not supported');
     }
     currentDefinitions = node;
     Element element = definition.accept(this);
     currentDefinitions = null;
     return element;
   }
 
   Element visitIdentifier(Identifier node) {
     Element variables = new VariableListElement.node(currentDefinitions,
         ElementKind.VARIABLE_LIST, enclosingElement);

[ngeoffray, 2012/03/15 10:06:01]

Maybe add a helper method for creating the variables element. It is now being
created 3 times: lines 1430, 1455 and 1468.

[floitsch, 2012/03/15 14:11:04]

Only created twice now, and once as a VariableElement and once as a
FieldParameterElement. Code share would be minimal.

     return new VariableElement(node.source, variables,
         ElementKind.PARAMETER, enclosingElement, node: node);
   }
 
-  Element visitSend(Send node) {
-    Element element;
+  FieldParameterElement visitSend(Send node) {

[ngeoffray, 2012/03/15 10:06:01]

Please add a comment that the only valid Send you could find in a parameter list
is a field parameter: this.x.

[floitsch, 2012/03/15 14:11:04]

Done.

+    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);

[ngeoffray, 2012/03/15 10:06:01]

4 space

[floitsch, 2012/03/15 14:11:04]

Done.

+      element = new FieldParameterElement(node.selector.asIdentifier().source,
+        fieldElement, variables, enclosingElement, node: node);      

[ngeoffray, 2012/03/15 10:06:01]

ditto

[floitsch, 2012/03/15 14:11:04]

Done.

     }
-    // 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);
+      FieldParameterElement fieldParameterElement = visitSend(node);
+      Element fieldElement = fieldParameterElement.fieldElement;
+      Element variables = new VariableListElement.node(currentDefinitions,
+          ElementKind.VARIABLE_LIST, enclosingElement);

[ngeoffray, 2012/03/15 10:06:01]

Why do you need to create a new element? fieldParameterElement looks good enough
here.

[floitsch, 2012/03/15 14:11:04]

Done.

+      element = new FieldParameterElement(node.selector.asIdentifier().source,
+          fieldElement, variables, enclosingElement, node: 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);
     compiler.enqueue(new WorkItem.toCompile(element));
     return element;
   }
 
   Element visitFunctionExpression(FunctionExpression node) {
     // This is a function typed parameter.
     // TODO(ahe): Resolve the function type.
     return visit(node.name);
   }
 
   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";
   }
 }