Resolve initializers in 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.
 
 class TreeElements {
   Map<Node, Element> map;
   TreeElements() : map = new LinkedHashMap<Node, Element>();
   operator []=(Node node, Element element) => map[node] = element;
   operator [](Node node) => map[node];
 }
 
 class ResolverTask extends CompilerTask {
   Queue<ClassElement> toResolve;
 
   ResolverTask(Compiler compiler)
     : super(compiler), toResolve = new Queue<ClassElement>();
 
   String get name() => 'Resolver';
 
   TreeElements resolve(FunctionElement element) {
     return measure(() {
       FunctionExpression tree = element.parseNode(compiler, compiler);
-      if (tree.initializers !== null) {
-        compiler.cancel('initializers are not implemented',
-                        node: tree.initializers);
-      }
       ResolverVisitor visitor = new SignatureResolverVisitor(compiler, element);
       visitor.visit(tree);
 
+      if (tree.initializers != null) {
+        visitor = new FullResolverVisitor.from(visitor);
+        for (Link<Node> link = tree.initializers.nodes;
+             !link.isEmpty();
+             link = link.tail) {
+          SendSet init = link.head;

[floitsch, 2011/12/19 17:25:29]

How can you be sure that this is a SendSet?
What about super calls?
what if the user entered something completely wrong?

[karlklose, 2011/12/21 10:19:44]

Done, added a test.

+          Node value = init.arguments.head;
+          visitor.visitIn(value, new StaticScope(visitor.context));
+        }
+      }
+
       visitor = new FullResolverVisitor.from(visitor);
       visitor.visit(tree.body);
 
       // Resolve the type annotations encountered in the method.
       while (!toResolve.isEmpty()) {
         toResolve.removeFirst().resolve(compiler);
       }
       return visitor.mapping;
     });
   }
@@ skipping 96 matching lines @@
 
 class SignatureResolverVisitor extends ResolverVisitor {
   FunctionElement element;
 
   SignatureResolverVisitor(Compiler compiler, FunctionElement element)
       : super(compiler, element), this.element = element;
 
   visitFunctionExpression(FunctionExpression node) {
     useElement(node, element);
     context = new MethodScope(context, element);
-
     if (element.parameters == null) {
       ParametersVisitor visitor = new ParametersVisitor(this);
       visitor.visit(node.parameters);
       element.parameters = visitor.elements.toLink();
     } else {
       Link<Node> parameterNodes = node.parameters.nodes;
       for (Link<Element> link = element.parameters;
            !link.isEmpty() && !parameterNodes.isEmpty();
            link = link.tail, parameterNodes = parameterNodes.tail) {
         defineElement(parameterNodes.head.definitions.nodes.head, link.head);
       }
     }
 
+    if (node.initializers !== null) {

[ngeoffray, 2011/12/20 15:09:51]

As discussed, I don't think this is the right place to (partially) analyze the
initializers. This code should be close to the code line 26.

[karlklose, 2011/12/21 10:19:44]

Done.

+      Set<SourceString> initializedNames = new Set<SourceString>();
+      for (Link<Node> link = node.initializers.nodes;
+           !link.isEmpty();
+           link = link.tail) {
+        SendSet init = link.head.asSendSet();
+        if (init == null

[floitsch, 2011/12/19 17:25:29]

super call is missing.
Add TODO?

[ahe, 2011/12/19 18:07:26]

In addition, there might be a this(...) send.

[karlklose, 2011/12/21 10:19:44]

Done, added a todo for super(...) and this(...).

+            || init.assignmentOperator.token.stringValue != '=') {
+          compiler.cancel('internal error: invalid initializer',
+                          node: node.initializers);

[ahe, 2011/12/19 18:07:26]

"node.initializers" should be "link.head".

[karlklose, 2011/12/21 10:19:44]

Done.

+        } else {
+          if (init.receiver != null &&
+              (init.receiver.asIdentifier() == null
+              || init.receiver.asIdentifier().source.stringValue != 'this')) {
+            error(init, MessageKind.INVALID_RECEIVER_IN_INITIALIZER);
+          }
+          SourceString name = init.selector.asIdentifier().source;

[ahe, 2011/12/19 18:07:26]

The above code looks a bit brittle and seems to rely on various assumptions that
may not hold. How about creating a few helper methods that return the expected
thing or report an error if it isn't.

[karlklose, 2011/12/21 10:19:44]

Done.

+          ClassElement classElement = element.enclosingElement;
+          Element target = classElement.lookupLocalElement(name);
+          if (target == null) {
+            error(init, MessageKind.CANNOT_RESOLVE, [name]);
+          }
+          if (initializedNames.contains(name)) {
+            warning(init, MessageKind.DUPLICATION_INITIALIZATION, [name]);
+          }
+          initializedNames.add(name);
+          useElement(init.selector, target);

[floitsch, 2011/12/20 14:18:27]

This should be useElement(init, target);

[karlklose, 2011/12/21 10:19:44]

Done.

+        }
+      }
+    }
+
     return element;
   }
 }
 
 class FullResolverVisitor extends ResolverVisitor {
 
   FullResolverVisitor(Compiler compiler, Element element)
     : super(compiler, element);
   FullResolverVisitor.from(ResolverVisitor other) : super.from(other);
 
@@ skipping 378 matching lines @@
 }
 
 class Scope {
   final Element element;
   final Scope parent;
 
   Map<SourceString, Element> get elements() => const {};
 
   Scope(this.parent, this.element);
   abstract Element add(Element element);
-  abstract Element lookup(Element element);
+  abstract Element lookup(SourceString name);

[ngeoffray, 2011/12/20 15:09:51]

Thanks!

 }
 
 class MethodScope extends Scope {
   final Map<SourceString, Element> elements;
 
   MethodScope(Scope parent, Element element)
     : super(parent, element), this.elements = {};
 
   Element lookup(SourceString name) {
     Element element = elements[name];
@@ skipping 24 matching lines @@
     if (element != null) return element;
     // TODO(ngeoffray): Lookup in the super class.
     return null;
   }
 
   Element add(Element element) {
     throw "Cannot add an element in a class scope";
   }
 }
 
+class StaticScope extends Scope {
+  StaticScope(Scope parent) : super(parent, null);
+
+  Element lookup(SourceString name) {

[ahe, 2011/12/19 18:07:26]

This concerns me as it seems to create an extra name space for statics. Also,
instead of reporting "hey, foo isn't static", you report "hey, foo cannot be
resolved".

From an IDE perspective, I'd still want to be able to jump to the declaration of
whatever isn't static so I can make it static.

[ngeoffray, 2011/12/20 15:09:51]

Two suggestions to address this problem.
1) Create a 'mode' in FullResolverVisitor:
- when doing normal resolution
- when doing resolution of the RHS of an initializer.

2) Have this StaticScope warn about finding an instance member. It should also
deal with 'this' and 'super'. Not sure how that would fit in. Solution 1 does
easily solve the 'this' and 'super'.

+    Element result = parent.lookup(name);
+    return (result != null && !result.isInstanceMember()) ? result : null;
+  }
+
+  Element add(Element element) => parent.add(element);

[ngeoffray, 2011/12/20 15:09:51]

Do we expect to add to this scope?

+}
+
 // TODO(ngeoffray): this top scope should have libraryElement as
 // element.
 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";
   }
 }