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);
 
       visitor = new FullResolverVisitor.from(visitor);
+      if (tree.initializers != null) {
+        resolveInitializers(element, tree, visitor);
+      }
       visitor.visit(tree.body);
 
       // Resolve the type annotations encountered in the method.
       while (!toResolve.isEmpty()) {
         toResolve.removeFirst().resolve(compiler);
       }
       return visitor.mapping;
     });
   }
 
+  void resolveInitializers(element, node, visitor) {

[ngeoffray, 2011/12/21 11:52:11]

Types on parameters?

[ahe, 2011/12/21 12:01:58]

I'd like a type on node.

[karlklose, 2011/12/21 16:33:46]

Done.

[karlklose, 2011/12/21 16:33:46]

Done.

+    Map<SourceString, Node> initialized = new Map<SourceString, Node>();
+    for (Link<Node> link = node.initializers.nodes;
+         !link.isEmpty();
+         link = link.tail) {
+      if (link.head.asSendSet() != null) {
+        SendSet init = link.head;
+        SourceString name = init.getInitializerFieldName(
+          () => visitor.error(init,
+                              MessageKind.INVALID_RECEIVER_IN_INITIALIZER));
+        ClassElement classElement = element.enclosingElement;
+        Element target = classElement.lookupLocalElement(name);
+        Node selector = init.selector;
+        if (target == null) {
+          visitor.error(selector, MessageKind.CANNOT_RESOLVE, [name]);
+        } else if (target.kind != ElementKind.FIELD) {
+          visitor.error(selector, MessageKind.NOT_A_FIELD, [name]);
+        } else if (!target.isInstanceMember()) {
+          visitor.error(selector, MessageKind.INIT_STATIC_FIELD, [name]);
+        }
+        visitor.useElement(init, target);
+        if (initialized.containsKey(name)) {
+          visitor.warning(init, MessageKind.DUPLICATE_INITIALIZER,

[ngeoffray, 2011/12/21 11:52:11]

The spec says it's a compile time error, so should that be a visitor.error?

[karlklose, 2011/12/21 16:33:46]

Done.

+                          [name, initialized[name]]);
+        }
+        initialized[name] = init;
+        Node value = init.arguments.head;
+        visitor.visitInStaticContext(value);
+      } else {
+        // TODO(karlklose): super(...), this(...).
+        compiler.cancel('internal error: invalid initializer',

[ngeoffray, 2011/12/21 11:52:11]

invalid -> unimplemented

[ahe, 2011/12/21 12:01:58]

This is not an internal error, and the initializer is not invalid. I would just
say "unimplemented".

[karlklose, 2011/12/21 16:33:46]

Done.

[karlklose, 2011/12/21 16:33:46]

Done.

+                        node: link.head);
+      }
+    }
+  }
+
   void resolveType(ClassElement element) {
     measure(() {
       ClassNode tree = element.node;
       ClassResolverVisitor visitor = new ClassResolverVisitor(compiler);
       visitor.visit(tree);
     });
   }
 
   void resolveSignature(FunctionElement element) {
     measure(() {
       FunctionExpression node = element.node;
       SignatureResolverVisitor visitor =
           new SignatureResolverVisitor(compiler, element);
       visitor.visitFunctionExpression(node);
     });
   }
 }
 
 class ResolverVisitor implements Visitor<Element> {
   final Compiler compiler;
   final TreeElements mapping;
   final Element enclosingElement;
   Scope context;
+  bool isStaticContext;

[ngeoffray, 2011/12/21 11:52:11]

isStaticContext always looks weird to me (is it a static method, meaning does it
have the static modifier?). I'd rather have a 'inInstanceContext'. This field
should be set during construction of the visitor:

inInstanceContext = element.isInstanceMember().

We could then use it for closures.

[karlklose, 2011/12/21 16:33:46]

Done.

 
   ResolverVisitor(Compiler compiler, Element element)
     : this.compiler = compiler,
       this.mapping  = new TreeElements(),
       this.enclosingElement = element,
       this.context  = element.isMember()
         ? new ClassScope(element.enclosingElement, compiler.universe)
-        : new TopScope(compiler.universe);
+        : new TopScope(compiler.universe),
+      this.isStaticContext = false;
 
   ResolverVisitor.from(ResolverVisitor other)
     : compiler = other.compiler,
       mapping = other.mapping,
       enclosingElement = other.enclosingElement,
       context = other.context;
 
   error(Node node, MessageKind kind, [arguments = const []]) {
     ResolutionError error  = new ResolutionError(kind, arguments);
     compiler.reportError(node, error);
   }
 
   warning(Node node, MessageKind kind, [arguments = const []]) {
     ResolutionWarning warning  = new ResolutionWarning(kind, arguments);
     compiler.reportWarning(node, warning);
   }
 
   cancel(Node node, String message) {
     compiler.cancel(message);
   }
 
+  Element lookup(Node node, SourceString name) {
+    Element result = context.lookup(name);
+    if (isStaticContext && result != null && result.isInstanceMember()) {
+      error(node, MessageKind.NOT_STATIC, [node]);
+    }
+    return result;
+  }
+
+  visitInStaticContext(Node node) {
+    bool wasStaticContext = isStaticContext;
+    isStaticContext = true;
+    visit(node);
+    isStaticContext = wasStaticContext;
+  }
+
   visit(Node node) {
     if (node == null) return null;
     return node.accept(this);
   }
 
   visitIdentifier(Identifier node) {
-    Element element = context.lookup(node.source);
+    Element element = lookup(node, node.source);
     if (element == null) {
       error(node, MessageKind.CANNOT_RESOLVE, [node]);
     }
     return useElement(node, element);
   }
 
   visitTypeAnnotation(TypeAnnotation node) {
     Identifier name = node.typeName;
     if (name.source == const SourceString('var')) return null;
     if (name.source == const SourceString('void')) return null;
@@ skipping 29 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);
@@ skipping 133 matching lines @@
     Identifier selector = node.selector;
     SourceString name = selector.source;
     // No need to assign an element for a logical operation.
     if (isLogicalOperator(selector)) return null;
 
     Element target = null;
     if (node.isOperator) {
       SourceString opName = mapOperatorToMethodName(name, node.isPrefix);
       target = compiler.universe.find(opName);
     } else if (node.receiver === null) {
-      target = context.lookup(name);
+      target = lookup(node, name);

[ngeoffray, 2011/12/21 11:52:11]

I think this should be changed to target = visit(node.selector);

[karlklose, 2011/12/21 16:33:46]

Done.

       if (target == null && !enclosingElement.isInstanceMember()) {
         error(node, MessageKind.CANNOT_RESOLVE, [name]);
       }
     } else if (receiver === null) {
       return null;
     } else if (receiver.kind === ElementKind.CLASS) {
       ClassElement receiverClass = receiver;
       target = receiverClass.lookupLocalElement(name);
       if (target == null) {
         error(node, MessageKind.METHOD_NOT_FOUND, [receiver, name]);
@@ skipping 23 matching lines @@
       SourceString name = mapAssignmentOperatorToMethodName(op.source);
       Element operatorElement = compiler.universe.find(name);
       useElement(op, operatorElement);
       // Resolve the getter for the lhs (receiver+selector).
       // Currently this is the same as the setter.
       // TODO(ngeoffray): Adapt for fields.
       Element getter;
       if (node.isIndex) {
         getter = target;
       } else {
-        getter = context.lookup(node.selector.asIdentifier().source);
+        getter = lookup(node, node.selector.asIdentifier().source);

[ngeoffray, 2011/12/21 11:52:11]

ditto.

[karlklose, 2011/12/21 16:33:46]

Done.

       }
       useElement(node.selector, getter);
     }
     if (node.isIndex) {
       assert(target.name.stringValue === 'index');
       target = compiler.universe.find(const SourceString('indexSet'));
     }
     return useElement(node, target);
   }
 
@@ skipping 201 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);
 }
 
 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 36 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";
   }
 }