Implement super calls.

frog/tests/leg/src/ResolverTest.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.
 
 #import("../../../leg/leg.dart");
 #import("../../../leg/elements/elements.dart");
 #import("../../../leg/tree/tree.dart");
 #import("../../../leg/util/util.dart");
 #import("mock_compiler.dart");
 #import("parser_helper.dart");
@@ skipping 48 matching lines @@
   testTypeAnnotation();
   testSuperclass();
   // testVarSuperclass(); // The parser crashes with 'class Foo extends var'.
   // testOneInterface(); // The parser does not handle interfaces.
   // testTwoInterfaces(); // The parser does not handle interfaces.
   testFunctionExpression();
   testNewExpression();
   testTopLevelFields();
   testInitializers();
   testThis();
+  testSuperCalls();
+}
+
+testSuperCalls() {
+  MockCompiler compiler = new MockCompiler();
+  Universe universe = compiler.universe;
+  String script = """class A { foo() {} }
+                     class B extends A { foo() => super.foo(); }""";
+  compiler.parseScript(script);
+  compiler.resolveStatement("B b;");
+
+  ClassElement classB = compiler.universe.find(buildSourceString("B"));
+  FunctionElement fooB = classB.lookupLocalMember(buildSourceString("foo"));
+  ClassElement classA = compiler.universe.find(buildSourceString("A"));
+  FunctionElement fooA = classA.lookupLocalMember(buildSourceString("foo"));
+
+  FullResolverVisitor visitor = new FullResolverVisitor(compiler, fooB);
+  FunctionExpression node = fooB.parseNode(compiler, compiler);
+  visitor.visit(node.body);
+  Map mapping = visitor.mapping.map;
+
+  Send superCall = node.body.asReturn().expression;
+  FunctionElement called = mapping[superCall];
+  Expect.isTrue(called !== null);
+  Expect.equals(fooA, called);
 }
 
 testThis() {
   MockCompiler compiler = new MockCompiler();
   Universe universe = compiler.universe;
   compiler.parseScript("class Foo { foo() { return this; } }");
   compiler.resolveStatement("Foo foo;");
   ClassElement fooElement = universe.find(buildSourceString("Foo"));
   FunctionElement funElement =
       fooElement.lookupLocalMember(buildSourceString("foo"));
@@ skipping 316 matching lines @@
   Expect.equals(ElementKind.GENERATIVE_CONSTRUCTOR, element.kind);
   Expect.isTrue(element is SynthesizedConstructorElement);
 }
 
 testTopLevelFields() {
   MockCompiler compiler = new MockCompiler();
   compiler.parseScript("int a;");
   Element element = compiler.universe.find(buildSourceString("a"));
   Expect.equals(ElementKind.FIELD, element.kind);
   VariableDefinitions node = element.variables.parseNode(compiler, compiler);
-  Expect.equals(node.type.typeName.source.stringValue, 'int');
+  Expect.equals(node.type.typeName.asIdentifier().source.stringValue, 'int');
 
   compiler.parseScript("var b, c;");
   Element bElement = compiler.universe.find(buildSourceString("b"));
   Element cElement = compiler.universe.find(buildSourceString("c"));
   Expect.equals(ElementKind.FIELD, bElement.kind);
   Expect.equals(ElementKind.FIELD, cElement.kind);
   Expect.isTrue(bElement != cElement);
 
   VariableDefinitions bNode = bElement.variables.parseNode(compiler, compiler);
   VariableDefinitions cNode = cElement.variables.parseNode(compiler, compiler);
@@ skipping 56 matching lines @@
                 int bar;
                 A() : this.foo = bar;
               }""";
   resolveConstructor(script, "A a = new A();", "A", "A", 2,
                      [], [MessageKind.NOT_STATIC]);
 }
 
 length(Link link) => link.isEmpty() ? 0 : length(link.tail) + 1;
 
 at(Link link, int index) => (index == 0) ? link.head : at(link.tail, index - 1);