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(FunctionExpression tree, FunctionElement element) {
     return measure(() {
-      ResolverVisitor visitor = new SignatureResolverVisitor(compiler);
+      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(ClassNode tree, Element element) {
     measure(() {
       ClassResolverVisitor visitor = new ClassResolverVisitor(compiler);
       visitor.visit(tree);
     });
   }
 
-  void resolveSignature(FunctionExpression node) {
+  void resolveSignature(FunctionExpression node, FunctionElement element) {
     measure(() {
-      SignatureResolverVisitor visitor = new SignatureResolverVisitor(compiler);
+      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,

[karlklose, 2011/12/05 14:54:55]

Extra space in the following two lines.

-      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 Scope.enclosing(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;
@@ skipping 16 matching lines @@
   visitFor(For node) {
     Scope scope = new Scope(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.enclosingElement);
     defineElement(node, enclosingElement);
     context = new Scope.enclosing(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 159 matching lines @@
   visitWhile(While node) {
     visit(node.condition);
     visitIn(node.body, new Scope(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) {
+      Element 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);
   }
 }
 
 class ClassResolverVisitor extends AbstractVisitor<Type> {
   Compiler compiler;
   Scope context;
 
   ClassResolverVisitor(Compiler compiler)
     : this.compiler = compiler, context = new TopScope(compiler.universe);
 
@@ skipping 111 matching lines @@
     return parent.lookup(name);
   }
 
   Element add(Element element) {
     if (elements.containsKey(element.name)) return elements[element.name];
     elements[element.name] = element;
     return element;
   }
 }
 
+class ClassScope extends Scope {
+  ClassScope(ClassElement element, Universe universe)
+    : super.enclosing(new TopScope(universe), element);
+
+  Element lookup(SourceString name) {
+    ClassElement cls = enclosingElement;

[ahe, 2011/12/02 11:27:41]

The word "enclosingElement" seems wrong in this context.

[ngeoffray, 2011/12/02 14:44:54]

Changed to '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.
 class TopScope extends Scope {
   Universe universe;
 
   TopScope(Universe this.universe) : super.top();
   Element lookup(SourceString name) => universe.find(name);
 
   Element add(Element element) {
     throw "Cannot add an element in the top scope";
   }
 }