Generate AST nodes for field initializers.

dart/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];
 }
@@ skipping 197 matching lines @@
     } else {
       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;
+    Identifier name = node.typeName.asIdentifier();
+    if (name === null) {
+      // TODO(karlklose): In progress.
+      cancel(node.typeName, "not implemented");
+    }
     if (name.source == const SourceString('var')) return null;
     if (name.source == const SourceString('void')) return null;
     Element element = context.lookup(name.source);
     if (element === null) {
       if (typeRequired) {
         error(node, MessageKind.CANNOT_RESOLVE_TYPE, [name]);
       } else {
         warning(node, MessageKind.CANNOT_RESOLVE_TYPE, [name]);
       }
     } else if (element.kind !== ElementKind.CLASS) {
@@ skipping 94 matching lines @@
   visitFor(For node) {
     Scope scope = new BlockScope(context);
     visitIn(node.initializer, scope);
     visitIn(node.condition, scope);
     visitIn(node.update, scope);
     visitIn(node.body, scope);
   }
 
   visitFunctionExpression(FunctionExpression node) {
     visit(node.returnType);
+    if (node.name === null) {
+      cancel(node, "anonymous functions are not implemented");
+    }
+    if (node.name.asIdentifier() === null) {
+      cancel(node.name, "named constructors are not implemented");
+    }
     FunctionElement enclosingElement = new FunctionElement.node(
         node, ElementKind.FUNCTION, null, context.element);
     defineElement(node, enclosingElement);
     context = new MethodScope(context, enclosingElement);
 
     // TODO(ahe): Can this be cleaned up to use resolveSignature?
     ParametersVisitor visitor = new ParametersVisitor(this);
     visitor.visit(node.parameters);
     enclosingElement.parameters = visitor.elements.toLink();
 
@@ skipping 357 matching lines @@
     }
     resolver.visit(node.arguments.head);
     return visit(node.selector);
   }
 
   SourceString visitIdentifier(Identifier node) => node.source;
 
   visitNodeList(NodeList node) {
     for (Link<Node> link = node.nodes; !link.isEmpty(); link = link.tail) {
       SourceString name = visit(link.head);
-      Element element = new VariableElement(
-          name, node, variables, kind, resolver.context.element);
+      VariableElement element = new VariableElement(
+          name, variables, kind, resolver.context.element);
+      element.node = link.head;
       resolver.defineElement(link.head, element);
     }
   }
 
   visit(Node node) => node.accept(this);
 
   visitNode(Node node) {
     resolver.cancel(node, 'not implemented');
   }
 }
@@ skipping 95 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";
   }
 }