Mock up all remaining core library implementation classes.

dart/frog/leg/resolver.dart

 // Copyright (c) 2012, 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.
 
 interface TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
 }
 
 class TreeElementMapping implements TreeElements {
@@ skipping 57 matching lines @@
       if (isConstructor) {
         resolveConstructorImplementation(element, tree);
       }
       ResolverVisitor visitor = new ResolverVisitor(compiler, element);
       visitor.useElement(tree, element);
       visitor.setupFunction(tree, element);
 
       if (tree.initializers != null) {
         new InitializerResolver(visitor, element).resolveInitializers(tree);
       }
+      if (isConstructor) {
+        visitor.inInstanceContext = true;

[kasperl, 2012/02/17 06:03:31]

Do you want to reset the flag to what ever it was after the call to
visitor.visit(tree.body)? If so you might want to have a
visitor.visitInInstanceContext(tree.body) helper.

[ahe, 2012/02/17 07:40:47]

I think this is more broken than it lets out. Later on, the SSA builder fudges
up a ConstructorBodyElement which is a much cleaner solution had it been applied
here.

This brings me back to needing to communicate a few high-level principles on how
to use elements and maintain a semantic model.

[ngeoffray, 2012/02/17 10:03:50]

It wasn't intended to be a solution for the resolver. The only reason the
backend needs a ConstructorBodyElement is because it creates two SSA methods,
and it cannot do that with one element. So it creates another one and inserts it
into the pipeline.

We could have decided to just generate one SSA method for a constructor, and we
would have then not introduced the ConstructorBodyElement.

[ngeoffray, 2012/02/17 10:03:50]

I don't think you need to set the flag. It's already set line 458 by checking
isGenerativeConstructor.

[ahe, 2012/02/17 16:26:46]

Done.

+      }
       visitor.visit(tree.body);
 
       // Resolve the type annotations encountered in the method.
       Link<ClassElement> newResolvedClasses = const EmptyLink<ClassElement>();
       while (!toResolve.isEmpty()) {
         ClassElement classElement = toResolve.removeFirst();
         if (!classElement.isResolved) {
           classElement.resolve(compiler);
         }
         newResolvedClasses = newResolvedClasses.prepend(classElement);
@@ skipping 28 matching lines @@
       name = name.replaceFirst(cls.name.toString(),
                                defaultClass.name.toString());
       constructor.implementation =
         defaultClass.lookupConstructor(new SourceString(name));
 
       if (constructor.implementation === null
           && new SourceString(name) == defaultClass.name
           && constructor.functionParameters.parameterCount === 0) {
         constructor.implementation = defaultClass.getSynthesizedConstructor();
       }
-    }
-    if (constructor === null) {
-      error(node.send, MessageKind.CANNOT_FIND_CONSTRUCTOR, [node.send]);
-      return null;
-    }
 
-    if (constructor.implementation === null) {
-      error(node, MessageKind.CANNOT_FIND_CONSTRUCTOR, [name]);
+      if (constructor.implementation === null) {
+        error(node, MessageKind.CANNOT_FIND_CONSTRUCTOR, [name]);
+      }
     }
   }
 
   TreeElements resolveVariableElement(Element element) {
     Node tree = element.parseNode(compiler);
     ResolverVisitor visitor = new ResolverVisitor(compiler, element);
     if (tree is SendSet) {
       SendSet send = tree;
       visitor.visit(send.arguments.head);
     }
@@ skipping 510 matching lines @@
     Element target = null;
     if (node.selector.asIdentifier() === null) {
       // We are calling a closure returned from an expression.
       assert(node.selector.asExpression() !== null);
       assert(resolvedReceiver === null);
       visit(node.selector);
     } else {
       SourceString name = node.selector.asIdentifier().source;
       if (node.receiver === null) {
         target = lookup(node, name);
-        if (target === null && !enclosingElement.isInstanceMember()) {
+        if (target === null && !inInstanceContext) {
           error(node, MessageKind.CANNOT_RESOLVE, [name]);
         }
       } else if (node.isSuperCall) {
         if (currentClass !== null) {
           ClassElement superElement = currentClass.superclass;
           if (superElement !== null) {
             // TODO(ngeoffray): The lookup should continue on super
             // classes.
             target = superElement.lookupLocalMember(name);
           }
@@ skipping 552 matching lines @@
       element = new VariableElement(node.selector.asIdentifier().source,
           variables, ElementKind.PARAMETER, enclosingElement, node: node);
     }
     // Visit the value. The compile time constant handler will
     // make sure it's a compile time constant.
     resolveExpression(node.arguments.head);
     compiler.enqueue(new WorkItem.toCompile(element));
     return element;
   }
 
+  Element visitFunctionExpression(FunctionExpression node) {
+    // This is a function typed parameter.
+    // TODO(ahe): Resolve the function type.
+    return visit(node.name);
+  }
+
   LinkBuilder<Element> analyzeNodes(Link<Node> link) {
     LinkBuilder<Element> elements = new LinkBuilder<Element>();
     for (; !link.isEmpty(); link = link.tail) {
       Element element = link.head.accept(this);
       if (element != null) {
         elements.addLast(element);
       } else {
         // If parameter is null, the current node should be the last,
         // and a list of optional named parameters.
         if (!link.tail.isEmpty() || (link.head is !NodeList)) {
@@ skipping 89 matching lines @@
 class TopScope extends Scope {
   LibraryElement get library() => element;
 
   TopScope(LibraryElement library) : super(null, library);
   Element lookup(SourceString name) => library.find(name);
 
   Element add(Element element) {
     throw "Cannot add an element in the top scope";
   }
 }