Implement super initializers.

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 {
   Map<Node, Element> map;
   Map<Send, Selector> selectors;
   TreeElementMapping()
     : map = new LinkedHashMap<Node, Element>(),
       selectors = new LinkedHashMap<Send, Selector>();
 
   operator []=(Node node, Element element) => map[node] = element;
   operator [](Node node) => map[node];
 
   void setSelector(Send send, Selector selector) {
     selectors[send] = selector;
   }
 
   Selector getSelector(Send send) => selectors[send];
 }
 
 class ResolverTask extends CompilerTask {
   Queue<ClassElement> toResolve;
 
+  // Caches the elements of analyzed constructors to make them available
+  // for inlining in later tasks.
+  Map<FunctionElement, TreeElements> constructorElements;
+
   ResolverTask(Compiler compiler)
-    : super(compiler), toResolve = new Queue<ClassElement>();
+    : super(compiler), toResolve = new Queue<ClassElement>(),
+      constructorElements = new Map<FunctionElement, TreeElements>();
 
   String get name() => 'Resolver';
 
   TreeElements resolve(Element element) {
     return measure(() {
       switch (element.kind) {
         case ElementKind.GENERATIVE_CONSTRUCTOR:
         case ElementKind.FUNCTION:
         case ElementKind.GETTER:
         case ElementKind.SETTER:
           return resolveMethodElement(element);
 
         case ElementKind.FIELD:
         case ElementKind.PARAMETER:
           return resolveVariableElement(element);
 
         default:
           compiler.unimplemented(
               "resolver", node: element.parseNode(compiler));
       }
     });
   }
 
   TreeElements resolveMethodElement(FunctionElement element) {
+    if (element.kind === ElementKind.GENERATIVE_CONSTRUCTOR &&
+        constructorElements[element] !== null) {
+      return constructorElements[element];
+    }
     FunctionExpression tree = element.parseNode(compiler);
     ResolverVisitor visitor = new ResolverVisitor(compiler, element);
     visitor.useElement(tree, element);
     visitor.setupFunction(tree, element);
 
     if (tree.initializers != null) {
       new InitializerResolver(visitor, element).resolveInitializers(tree);
     }
     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);
     }
     checkClassHierarchy(newResolvedClasses);
+    if (element.kind === ElementKind.GENERATIVE_CONSTRUCTOR) {
+      constructorElements[element] = visitor.mapping;
+    }
     return visitor.mapping;
   }
 
   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 68 matching lines @@
   }
 }
 
 class InitializerResolver {
   final ResolverVisitor visitor;
   final FunctionElement constructor;
   final Map<SourceString, Node> initialized;
   Link<Node> initializers;
   bool hasSuper;
 
-  bool isSuperConstructorCall(Send node) {
-    return (node.receiver === null &&
-            node.selector.asIdentifier() !== null &&
-            node.selector.asIdentifier().isSuper()) ||
-           (node.receiver !== null &&
-            node.receiver.asIdentifier() !== null &&
-            node.receiver.asIdentifier().isSuper() &&
-            node.selector.asIdentifier() !== null);
-  }
-
-  bool isConstructorRedirect(Send node) {
-    return (node.receiver === null &&
-            node.selector.asIdentifier() !== null &&
-            node.selector.asIdentifier().isThis()) ||
-           (node.receiver !== null &&
-            node.receiver.asIdentifier() !== null &&
-            node.receiver.asIdentifier().isThis() &&
-            node.selector.asIdentifier() !== null);
-  }
-
   InitializerResolver(this.visitor, this.constructor)
     : initialized = new Map<SourceString, Node>(), hasSuper = false;
 
   error(Node node, MessageKind kind, [arguments = const []]) {
     visitor.error(node, kind, arguments);
   }
 
   warning(Node node, MessageKind kind, [arguments = const []]) {
     visitor.warning(node, kind, arguments);
   }
@@ skipping 43 matching lines @@
     }
   }
 
   void resolveSuperOrThis(Send call) {
     noConstructor(e) {
       if (e !== null) error(call, MessageKind.NO_CONSTRUCTOR, [e.name, e.kind]);
     }
 
     ClassElement lookupTarget = constructor.enclosingElement;
     bool validTarget = true;
-    if (isSuperConstructorCall(call)) {
+    if (Initializers.isSuperConstructorCall(call)) {
       // Check for invalid initializers.
       if (hasSuper) {
         error(call, MessageKind.DUPLICATE_SUPER_INITIALIZER);
       }
       hasSuper = true;
       // Calculate correct lookup target and constructor name.
       if (lookupTarget.name == Types.OBJECT) {
         error(call, MessageKind.SUPER_INITIALIZER_IN_OBJECT);
       } else {
         lookupTarget = lookupTarget.supertype.element;
       }
-    } else if (isConstructorRedirect(call)) {
+    } else if (Initializers.isConstructorRedirect(call)) {
       // Check that there are no other initializers.
       if (!initializers.tail.isEmpty()) {
         error(call, MessageKind.REDIRECTING_CTOR_HAS_INITIALIZER);
       }
     } else {
       visitor.error(call, MessageKind.CONSTRUCTOR_CALL_EXPECTED);
       validTarget = false;
     }
 
     if (validTarget) {
@@ skipping 894 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";
   }
 }