Start resolving classes and default 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(FunctionExpression tree) {
+  TreeElements resolve(FunctionElement element) {
     return measure(() {
-      ResolverVisitor visitor = new SignatureResolverVisitor(compiler);
+      FunctionExpression tree = element.node;
+      ResolverVisitor visitor = new SignatureResolverVisitor(compiler, element);
       visitor.visit(tree);
 
       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;
     });
   }
 
-  // Used for testing.
-  TreeElements resolveStatement(Node node) {
-    ResolverVisitor visitor = new FullResolverVisitor(compiler);
-    visitor.visit(node);
-
-    // Resolve the type annotations encountered in the code.
-    while (!toResolve.isEmpty()) {
-      toResolve.removeFirst().resolve(compiler);
-    }
-    return visitor.mapping;
-  }
-
-  void resolveType(ClassNode tree) {
+  void resolveType(ClassElement element) {
     measure(() {
+      ClassNode tree = element.node;
       ClassResolverVisitor visitor = new ClassResolverVisitor(compiler);
       visitor.visit(tree);
     });
   }
 
-  void resolveSignature(FunctionExpression node) {
+  void resolveSignature(FunctionElement element) {
     measure(() {
-      SignatureResolverVisitor visitor = new SignatureResolverVisitor(compiler);
+      FunctionExpression node = element.node;
+      SignatureResolverVisitor visitor =
+          new SignatureResolverVisitor(compiler, element);
       visitor.visitFunctionExpression(node);
     });
   }
 }
 
 class ResolverVisitor implements Visitor<Element> {
   final Compiler compiler;
   final TreeElements mapping;
   Scope context;
 
-  ResolverVisitor(Compiler compiler)
+  ResolverVisitor(Compiler compiler, Element element)
     : this.compiler = compiler,
-      mapping = new TreeElements(),
-      context = new Scope(new TopScope(compiler.universe));
+      this.mapping  = new TreeElements(),
+      this.context  = element.isClassMember()
+        ? new ClassScope(element.enclosingElement, compiler.universe)
+        : new TopScope(compiler.universe);
 
   ResolverVisitor.from(ResolverVisitor other)
     : compiler = other.compiler,
       mapping = other.mapping,
       context = other.context;
 
   error(Node node, MessageKind kind, [arguments = const []]) {
     ResolutionError error  = new ResolutionError(kind, arguments);
     compiler.reportError(node, error);
   }
@@ skipping 48 matching lines @@
 
   Element useElement(Node node, Element element) {
     if (element === null) return null;
     mapping[node] = element;
     // TODO(ngeoffray): frog does not like a return on an assignment.
     return element;
   }
 }
 
 class SignatureResolverVisitor extends ResolverVisitor {
+  FunctionElement element;
 
-  SignatureResolverVisitor(Compiler compiler) : super(compiler);
+  SignatureResolverVisitor(Compiler compiler, FunctionElement element)
+      : super(compiler, element), this.element = element;
 
   visitFunctionExpression(FunctionExpression node) {
-    FunctionElement enclosingElement = context.lookup(node.name.dynamic.source);
-    useElement(node, enclosingElement);
-    context = new Scope.enclosing(context, enclosingElement);
+    useElement(node, element);
+    context = new MethodScope(context, element);
 
-    if (enclosingElement.parameters == null) {
+    if (element.parameters == null) {
       ParametersVisitor visitor = new ParametersVisitor(this);
       visitor.visit(node.parameters);
-      enclosingElement.parameters = visitor.elements.toLink();
+      element.parameters = visitor.elements.toLink();
     } else {
       Link<Node> parameterNodes = node.parameters.nodes;
-      for (Link<Element> link = enclosingElement.parameters;
+      for (Link<Element> link = element.parameters;
            !link.isEmpty() && !parameterNodes.isEmpty();
            link = link.tail, parameterNodes = parameterNodes.tail) {
         defineElement(parameterNodes.head.definitions.nodes.head, link.head);
       }
     }
 
-    return enclosingElement;
+    return element;
   }
 }
 
 class FullResolverVisitor extends ResolverVisitor {
 
-  FullResolverVisitor(Compiler compiler) : super(compiler);
+  FullResolverVisitor(Compiler compiler, Element element)
+    : super(compiler, element);
   FullResolverVisitor.from(ResolverVisitor other) : super.from(other);
 
   Element visitClassNode(ClassNode node) {
     cancel(node, "shouldn't be called");
   }
 
   visitIn(Node node, Scope scope) {
     context = scope;
     Element element = visit(node);
     context = context.parent;
     return element;
   }
 
   visitBlock(Block node) {
-    visitIn(node.statements, new Scope(context));
+    visitIn(node.statements, new BlockScope(context));
   }
 
   visitDoWhile(DoWhile node) {
-    visitIn(node.body, new Scope(context));
+    visitIn(node.body, new BlockScope(context));
     visit(node.condition);
   }
 
   visitExpressionStatement(ExpressionStatement node) {
     visit(node.expression);
   }
 
   visitFor(For node) {
-    Scope scope = new Scope(context);
+    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);
-    FunctionElement enclosingElement =
-        new FunctionElement.node(node, context.enclosingElement);
+    FunctionElement enclosingElement = new FunctionElement.node(
+        node, ElementKind.FUNCTION, context.element);
     defineElement(node, enclosingElement);
-    context = new Scope.enclosing(context, enclosingElement);
+    context = new MethodScope(context, enclosingElement);
 
     ParametersVisitor visitor = new ParametersVisitor(this);
     visitor.visit(node.parameters);
     enclosingElement.parameters = visitor.elements.toLink();
 
     visit(node.body);
     context = context.parent;
     return enclosingElement;
   }
 
@@ skipping 149 matching lines @@
 
   visitVariableDefinitions(VariableDefinitions node) {
     visit(node.type);
     VariableDefinitionsVisitor visitor =
         new VariableDefinitionsVisitor(node, this, ElementKind.VARIABLE);
     visitor.visit(node.definitions);
   }
 
   visitWhile(While node) {
     visit(node.condition);
-    visitIn(node.body, new Scope(context));
+    visitIn(node.body, new BlockScope(context));
   }
 
   visitParenthesizedExpression(ParenthesizedExpression node) {
     visit(node.expression);
   }
 
   visitNewExpression(NewExpression node) {
-    cancel(node, "Unimplemented");
+    visit(node.send.argumentsNode);
+
+    ClassElement cls = visit(node.send.selector);
+    SourceString name = const SourceString("");
+    Element constructor = null;
+    if (cls !== null) {
+      // TODO(ngeoffray): define what isResolved means. Also, pass the
+      // needed element to resolve?
+      if (!cls.isResolved) compiler.resolveType(cls);
+      constructor = cls.lookupLocalElement(name);
+      if (name.stringValue === ''
+          && constructor === null
+          && node.send.argumentsNode.isEmpty()
+          && cls.canHaveDefaultConstructor()) {
+        constructor = new SynthesizedConstructorElement(cls);
+        cls.addConstructor(constructor);
+      }
+      if (constructor === null) {
+        error(node, MessageKind.CANNOT_FIND_CONSTRUCTOR, [node]);
+      }
+    }
+
+    return useElement(node, constructor);
   }
 
   visitLiteralList(LiteralList node) {
     visit(node.elements);
   }
 }
 
 class ClassResolverVisitor extends AbstractVisitor<Type> {
   Compiler compiler;
   Scope context;
@@ skipping 59 matching lines @@
 
     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(link.head, definitions.type,
-          kind, name, resolver.context.enclosingElement);
+          kind, name, resolver.context.element);
       resolver.defineElement(link.head, element);
     }
   }
 
   visit(Node node) => node.accept(this);
 }
 
 class ParametersVisitor extends AbstractVisitor<Element> {
   ResolverVisitor resolver;
   LinkBuilder<Element> elements;
@@ skipping 10 matching lines @@
     VariableDefinitionsVisitor visitor =
         new VariableDefinitionsVisitor(node, resolver, ElementKind.PARAMETER);
     visitor.visit(node.definitions);
     return resolver.mapping[node.definitions.nodes.head];
   }
 
   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);
+}
+
+class MethodScope extends Scope {
   final Map<SourceString, Element> elements;
-  final Element enclosingElement;
 
-  Scope(Scope parent)
-    : this.enclosing(parent, parent.enclosingElement);
-
-  Scope.enclosing(Scope this.parent, this.enclosingElement)
-    : this.elements = {};
-
-  Scope.top() : parent = null, elements = const {}, enclosingElement = null;
+  MethodScope(Scope parent, Element element)
+    : super(parent, element), this.elements = {};
 
   Element lookup(SourceString name) {
     Element element = elements[name];
     if (element !== null) return element;
     return parent.lookup(name);
   }
 
   Element add(Element element) {
     if (elements.containsKey(element.name)) return elements[element.name];
     elements[element.name] = element;
     return element;
   }
 }
 
+class BlockScope extends MethodScope {
+  BlockScope(Scope parent) : super(parent, parent.element);
+}
+
+class ClassScope extends Scope {
+  ClassScope(ClassElement element, Universe universe)
+    : super(new TopScope(universe), element);
+
+  Element lookup(SourceString name) {
+    ClassElement cls = element;
+    Element element = cls.lookupLocalElement(name);
+    if (element != null) return element;
+    element = parent.lookup(name);
+    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";
+  }
+}
+
 // TODO(ngeoffray): this top scope should have libraryElement as
-// enclosingElement.
+// element.
 class TopScope extends Scope {
   Universe universe;
 
-  TopScope(Universe this.universe) : super.top();
+  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";
   }
 }