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 98 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.receiver !== null
+        && node.receiver.asIdentifier() !== null
+        && node.receiver.asIdentifier().isSuper()) {
+      SourceString superName = const SourceString('');
+print(currentClass);

[ngeoffray, 2012/01/11 13:00:48]

Remove debugging code

[karlklose, 2012/01/11 13:46:12]

Done.

+      if (currentClass !== null) {
+        ClassElement superElement = currentClass.superClass;
+        if (superElement !== null) {
+          target = superElement.lookupLocalMember(name);
+          superName = superElement.name;
+        } else {
+          superName = compiler.types.OBJECT;
+        }
+      }
+      if (target == null) {
+        error(node, MessageKind.METHOD_NOT_FOUND, [superName, name]);

[ngeoffray, 2012/01/11 13:00:48]

I think I'd prefer two kinds of errors, one for the case of currentClass is null
and for the one where it is not null. For the one that is null, we already had
an error message. So I'm not sure what kind of error messages we can provide
again.

[karlklose, 2012/01/11 13:46:12]

Yes we already report an error if we encounter super in a non-instance context.

+      }
+    } 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 175 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";
   }
 }