Implement super calls.

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 124 matching lines @@
   }
 }
 
 // TODO(ahe): Frog cannot handle generic types.
 class ResolverVisitor extends AbstractVisitor/*<Element>*/ {
   final Compiler compiler;
   final TreeElements mapping;
   final Element enclosingElement;
   bool inInstanceContext;
   Scope context;
+  ClassElement currentClass;
 
   ResolverVisitor(Compiler compiler, Element element)
     : this.compiler = compiler,
       this.mapping  = new TreeElements(),
       this.enclosingElement = element,
       inInstanceContext = element.isInstanceMember()
           || element.isGenerativeConstructor(),
       this.context  = element.isMember()
         ? new ClassScope(element.enclosingElement, compiler.universe)
-        : new TopScope(compiler.universe);
+        : new TopScope(compiler.universe),
+      this.currentClass = element.isMember() ? element.enclosingElement : null;
 
   ResolverVisitor.from(ResolverVisitor other)
     : compiler = other.compiler,
       mapping = other.mapping,
       enclosingElement = other.enclosingElement,
       inInstanceContext = other.inInstanceContext,
-      context = other.context;
+      context = other.context,
+      currentClass = other.currentClass;
 
   error(Node node, MessageKind kind, [arguments = const []]) {
     ResolutionError error  = new ResolutionError(kind, arguments);
     compiler.reportError(node, error);
   }
 
   warning(Node node, MessageKind kind, [arguments = const []]) {
     ResolutionWarning warning  = new ResolutionWarning(kind, arguments);
     compiler.reportWarning(node, warning);
   }
@@ skipping 19 matching lines @@
 
   visit(Node node) {
     if (node == null) return null;
     return node.accept(this);
   }
 
   visitIdentifier(Identifier node) {
     if (node.isThis()) {
       if (!inInstanceContext) error(node, MessageKind.NO_THIS_IN_STATIC);
       return null;
+    } else if (node.isSuper()) {
+      if (!inInstanceContext) error(node, MessageKind.NO_SUPER_IN_STATIC);
+      return null;
     } else {
       Element element = lookup(node, node.source);
       if (element == null) {
         error(node, MessageKind.CANNOT_RESOLVE, [node]);
       }
       return useElement(node, element);
     }
   }
 
   visitTypeAnnotation(TypeAnnotation node) {
@@ skipping 139 matching lines @@
       assert(receiver === null);
       visit(node.selector);
       return null;
     }
 
     SourceString name = selector.source;
     // No need to assign an element for a logical operation.
     if (isLogicalOperator(selector)) return null;
 
     Element target = null;
-    if (node.isOperator) {
+    if (node.isSuperCall) {
+      if (currentClass !== null) {
+        ClassElement superElement = currentClass.superClass;

[ahe, 2012/01/11 13:55:58]

It is called "superclass", but an element should not have a superclass. It has a
supertype.

+        if (superElement !== null) {
+          target = superElement.lookupLocalMember(name);
+        }
+        if (target == null) {
+          error(node, MessageKind.METHOD_NOT_FOUND, [superElement.name, name]);
+        }
+      }
+    } else if (node.isOperator) {
       return null;
     } else if (node.receiver === null) {
       target = lookup(node, 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.resolve(compiler).lookupLocalMember(name);
       if (target == null) {
-        error(node, MessageKind.METHOD_NOT_FOUND, [receiver, name]);
+        error(node, MessageKind.METHOD_NOT_FOUND, [receiver.name, name]);
       } else if (target.isInstanceMember()) {
-        error(node, MessageKind.MEMBER_NOT_STATIC, [receiver, name]);
+        error(node, MessageKind.MEMBER_NOT_STATIC, [receiver.name, name]);
       }
     }
     return target;
   }
 
   visitSend(Send node) {
     Element target = resolveSend(node);
     // TODO(ngeoffray): If target is a field, check that there's a
     // getter.
     return useElement(node, target);
@@ skipping 187 matching lines @@
   Scope context;
 
   ClassResolverVisitor(Compiler compiler)
     : this.compiler = compiler, context = new TopScope(compiler.universe);
 
   Type visitClassNode(ClassNode node) {
     ClassElement element = context.lookup(node.name.source);
     compiler.ensure(element !== null);
     compiler.ensure(!element.isResolved);
     element.supertype = visit(node.superclass);
+    if (element.name != Types.OBJECT && element.supertype === null) {
+      ClassElement objectElement = context.lookup(Types.OBJECT);
+      if (objectElement !== null && !objectElement.isResolved) {
+        compiler.resolver.toResolve.add(objectElement);
+      } else if (objectElement === null){
+        compiler.reportError(node,
+            new ResolutionError(MessageKind.CANNOT_RESOLVE_TYPE,
+                                [Types.OBJECT]));
+      }
+      element.supertype = new SimpleType(Types.OBJECT,
+                                         objectElement);
+    }
     for (Link<Node> link = node.interfaces.nodes;
          !link.isEmpty();
          link = link.tail) {
       element.interfaces = element.interfaces.prepend(visit(link.head));
     }
     return element.computeType(compiler);
   }
 
   Type visitTypeAnnotation(TypeAnnotation node) {
     Identifier name = node.typeName;
@@ skipping 159 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";
   }
 }