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;
     });
   }
 
+  bool isInitializer(SendSet node) {
+    if (node.selector.asIdentifier() == null) return false;
+    if (node.receiver == null) return true;
+    if (node.receiver.asIdentifier() == null) return false;
+    return node.receiver.asIdentifier().isThis();
+  }
+
+  SourceString getInitializerFieldName(SendSet node, onError(node)) {
+    if (!isInitializer(node)) onError(node);
+    return node.selector.asIdentifier().source;
+  }
+
+  void resolveInitializers(Element element, FunctionExpression node,
+                           ResolverVisitor visitor) {
+    void onError(node) {
+      visitor.error(node, MessageKind.INVALID_RECEIVER_IN_INITIALIZER);
+    }
+    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 = getInitializerFieldName(init, onError);

[ngeoffray, 2011/12/21 16:44:08]

If it's not an identifier, what do you get as a name? I think you can get rid of
getInitializerFieldName, and handle the problem here.

+        ClassElement classElement = element.enclosingElement;
+        Element target = classElement.lookupLocalElement(name);

[ngeoffray, 2011/12/21 16:44:08]

lookupLocalElement -> lookupLocalMember (after merging with my changes)

+        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.error(init, MessageKind.DUPLICATE_INITIALIZER, [name]);
+          visitor.warning(initialized[name], MessageKind.ALREADY_INITIALIZED,
+                          [name]);

[ngeoffray, 2011/12/21 16:44:08]

@ahe: not sure, but splitting the warning in two, is that ok for the IDE?

+        }
+        initialized[name] = init;
+        Node value = init.arguments.head;
+        visitor.visitInStaticContext(value);
+      } else if (link.head.asSend() !== null) {
+        // TODO(karlklose): super(...), this(...).
+        compiler.cancel('uniplemented', node:link.head);

[ngeoffray, 2011/12/21 16:44:08]

uniMplemented

+      } else {
+        compiler.cancel('internal error: invalid initializer',
+                        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(() {
@@ skipping 34 matching lines @@
 
   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 (!inInstanceContext && result != null && result.isInstanceMember()) {
+      error(node, MessageKind.NOT_STATIC, [node]);
+    }
+    return result;
+  }
+
+  visitInStaticContext(Node node) {
+    bool wasInstanceContext = inInstanceContext;
+    inInstanceContext = false;
+    visit(node);
+    inInstanceContext = wasInstanceContext;
+  }
+
   visit(Node node) {
     if (node == null) return null;
     return node.accept(this);
   }
 
   visitIdentifier(Identifier node) {
     if (node.isThis()) {
       if (!inInstanceContext) error(node, MessageKind.NO_THIS_IN_STATIC);
       return null;
     } else {
-      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;
@@ skipping 30 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 134 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 = visit(node);
       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.resolve(compiler).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 = visit(node);
       }
       useElement(node.selector, getter);
     }
     if (node.isIndex) {
       assert(target.name.stringValue === 'index');
       target = compiler.universe.find(const SourceString('indexSet'));
     }
     return useElement(node, target);
   }
 
@@ skipping 196 matching lines @@
 
   visit(Node node) => node.accept(this);
 }
 
 class Scope {
   final Element element;
   final Scope parent;
 
   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";
   }
 }