Resolve initializers in constructors.

frog/leg/resolver.dart

Index: frog/leg/resolver.dart
diff --git a/frog/leg/resolver.dart b/frog/leg/resolver.dart
index 6a37626531eabdbbdd8a13c25f8fa34068d4fbb9..c094cb1b5daa9d58ca6427986286c770c26b5d61 100644
--- a/frog/leg/resolver.dart
+++ b/frog/leg/resolver.dart
@@ -20,13 +20,20 @@ class ResolverTask extends CompilerTask {
   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);
 
@@ -143,7 +150,6 @@ class SignatureResolverVisitor extends ResolverVisitor {
   visitFunctionExpression(FunctionExpression node) {
     useElement(node, element);
     context = new MethodScope(context, element);
-
     if (element.parameters == null) {
       ParametersVisitor visitor = new ParametersVisitor(this);
       visitor.visit(node.parameters);
@@ -157,6 +163,37 @@ class SignatureResolverVisitor extends ResolverVisitor {
       }
     }
 
+    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;
   }
 }
@@ -555,7 +592,7 @@ class Scope {
 
   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 {
@@ -600,6 +637,17 @@ class ClassScope extends 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 {