Make sure a class is resolved before looking up its elements.

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 290 matching lines @@
       target = compiler.universe.find(opName);
     } else if (node.receiver === null) {
       target = context.lookup(name);
       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.lookupLocalElement(name);
+      target = receiverClass.resolve(compiler).lookupLocalElement(name);
       if (target == null) {
         error(node, MessageKind.METHOD_NOT_FOUND, [receiver, name]);
       } else if (target.isInstanceMember()) {
         error(node, MessageKind.MEMBER_NOT_STATIC, [receiver, name]);
       }
     }
     return target;
   }
 
   visitSend(Send node) {
@@ skipping 83 matching lines @@
   }
 
   visitNewExpression(NewExpression node) {
     visit(node.send.argumentsNode);
 
     ClassElement cls = visit(node.send.selector);
     Element constructor = null;
     if (cls !== null) {
       // TODO(ngeoffray): set constructor-name correctly.
       SourceString name = cls.name;
-      // TODO(ngeoffray): define what isResolved means. Also, pass the
-      // needed element to resolve?
-      if (!cls.isResolved) compiler.resolveType(cls);
-      constructor = cls.lookupLocalElement(name);
+      constructor = cls.resolve(compiler).lookupLocalElement(name);
       if (name == cls.name
           && constructor === null
           && node.send.argumentsNode.isEmpty()) {
         constructor = cls.getSynthesizedConstructor();
       }
       if (constructor === null) {
         error(node, MessageKind.CANNOT_FIND_CONSTRUCTOR, [node]);
       }
     }
 
@@ skipping 126 matching lines @@
     return resolver.mapping[node.definitions.nodes.head];
   }
 
   visit(Node node) => node.accept(this);
 }
 
 class Scope {
   final Element element;
   final Scope parent;
 
-  Map<SourceString, Element> get elements() => const {};
-
   Scope(this.parent, this.element);
   abstract Element add(Element element);
   abstract Element lookup(Element element);
 }
 
 class MethodScope extends Scope {
   final Map<SourceString, Element> elements;
 
   MethodScope(Scope parent, Element element)
     : super(parent, element), this.elements = {};
@@ skipping 39 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";
   }
 }