Implement cycle-checking and code generation for redirecting constructors.

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 {
@@ skipping 39 matching lines @@
         case ElementKind.PARAMETER:
           return resolveVariableElement(element);
 
         default:
           compiler.unimplemented(
               "resolver", node: element.parseNode(compiler));
       }
     });
   }
 
+  SourceString getConstructorName(Send node) {
+    if (node.receiver !== null) {
+      return node.selector.asIdentifier().source;
+    } else {
+      return const SourceString('');
+    }
+  }
+
+  FunctionElement lookupConstructor(ClassElement classElement, Send send,
+                                    [noConstructor(Element)]) {
+    final SourceString constructorName = getConstructorName(send);
+    final SourceString className = classElement.name;
+    FunctionElement result = classElement.lookupConstructor(className,
+                                                            constructorName,
+                                                            noConstructor);
+    if (result === null && send.arguments.isEmpty()) {
+      result = classElement.getSynthesizedConstructor();
+    }
+    return result;
+  }
+
+  FunctionElement resolveConstructorRedirection(FunctionElement constructor) {
+    FunctionExpression node = constructor.parseNode(compiler);
+    // A synthetic constructor does not have a node.
+    if (node === null) return null;
+    if (node.initializers === null) return null;
+    Link<Node> initializers = node.initializers.nodes;
+    if (!initializers.isEmpty() &&
+        Initializers.isConstructorRedirect(initializers.head)) {
+      return lookupConstructor(constructor.enclosingElement, initializers.head);
+    }
+    return null;
+  }
+
+  void resolveRedirectingConstructor(InitializerResolver resolver,
+                                     Node node,
+                                     FunctionElement constructor,
+                                     FunctionElement redirection) {
+    Set<FunctionElement> seen = new Set<FunctionElement>();
+    seen.add(constructor);
+    while (redirection !== null) {
+      if (seen.contains(redirection)) {
+        resolver.visitor.error(node, MessageKind.REDIRECTING_CONSTRUCTOR_CYCLE);
+        return;
+      }
+      seen.add(redirection);
+      redirection = resolveConstructorRedirection(redirection);
+    }
+  }
+
   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);
+    if (element.kind !== ElementKind.GENERATIVE_CONSTRUCTOR_BODY &&
+        tree.initializers != null) {
+      if (element.kind !== ElementKind.GENERATIVE_CONSTRUCTOR) {
+        error(tree, MessageKind.FUNCTION_WITH_INITIALIZER);
+      }
+      InitializerResolver resolver = new InitializerResolver(visitor);
+      FunctionElement redirection = resolver.resolveInitializers(element, tree);
+      if (redirection !== null) {
+        resolveRedirectingConstructor(resolver, tree, element, redirection);
+      }
     }
     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);
       }
@@ skipping 51 matching lines @@
     // TODO(karlklose): check if type arguments match, if a classelement occurs
     //                  more than once in the supertypes.
     if (classElement.allSupertypes !== null) return;
     final Type supertype = classElement.supertype;
     if (seen.contains(classElement)) {
       error(classElement.parseNode(compiler),
             MessageKind.CYCLIC_CLASS_HIERARCHY,
             [classElement.name]);
       classElement.allSupertypes = const EmptyLink<Type>();
     } else if (supertype != null) {
-      Type supertype = classElement.supertype;
       seen.add(classElement);
       Link<Type> superSupertypes =
         getOrCalculateAllSupertypes(supertype.element, seen);
       Link<Type> supertypes = new Link<Type>(supertype, superSupertypes);
       for (Link<Type> interfaces = classElement.interfaces;
            !interfaces.isEmpty();
            interfaces = interfaces.tail) {
         Element element = interfaces.head.element;
         Link<Type> interfaceSupertypes =
             getOrCalculateAllSupertypes(element, seen);
         supertypes = supertypes.reversePrependAll(interfaceSupertypes);
       }
       seen.remove(classElement);
       classElement.allSupertypes = supertypes;
     } else {
       classElement.allSupertypes = const EmptyLink<Type>();
     }
   }
 
   error(Node node, MessageKind kind, [arguments = const []]) {
-    ResolutionError error = new ResolutionError(kind, arguments);
-    compiler.reportError(node, error);
+    ResolutionError message = new ResolutionError(kind, arguments);
+    compiler.reportError(node, message);
   }
 }
 
 class InitializerResolver {
   final ResolverVisitor visitor;
-  final FunctionElement constructor;
   final Map<SourceString, Node> initialized;
   Link<Node> initializers;
   bool hasSuper;
 
-  InitializerResolver(this.visitor, this.constructor)
+  InitializerResolver(this.visitor)
     : 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);
   }
 
   bool isFieldInitializer(SendSet node) {
     if (node.selector.asIdentifier() == null) return false;
     if (node.receiver == null) return true;
     if (node.receiver.asIdentifier() == null) return false;
     return node.receiver.asIdentifier().isThis();
   }
 
-  void resolveFieldInitializer(SendSet init) {
+  void resolveFieldInitializer(FunctionElement constructor, SendSet init) {
     // init is of the form [this.]field = value.
     final Node selector = init.selector;
     final SourceString name = selector.asIdentifier().source;
     // Lookup target field.
     Element target;
     if (isFieldInitializer(init)) {
       final ClassElement classElement = constructor.enclosingElement;
       target = classElement.lookupLocalMember(name);
       if (target === null) {
         error(selector, MessageKind.CANNOT_RESOLVE, [name]);
       } else if (target.kind != ElementKind.FIELD) {
         error(selector, MessageKind.NOT_A_FIELD, [name]);
       } else if (!target.isInstanceMember()) {
         error(selector, MessageKind.INIT_STATIC_FIELD, [name]);
       }
     } else {
       error(init, MessageKind.INVALID_RECEIVER_IN_INITIALIZER);
     }
     visitor.useElement(init, target);
     // Check for duplicate initializers.
     if (initialized.containsKey(name)) {
       error(init, MessageKind.DUPLICATE_INITIALIZER, [name]);
       warning(initialized[name], MessageKind.ALREADY_INITIALIZED, [name]);
     }
     initialized[name] = init;
     // Resolve initializing value.
     visitor.visitInStaticContext(init.arguments.head);
   }
 
-  SourceString getConstructorName(Send node) {
-    if (node.receiver !== null) {
-      return node.selector.asIdentifier().source;
-    } else {
-      return const SourceString('');
-    }
-  }
-
-  void resolveSuperOrThis(Send call) {
+  Element resolveSuperOrThis(FunctionElement constructor,
+                             FunctionExpression functionNode,
+                             Send call) {
     noConstructor(e) {
       if (e !== null) error(call, MessageKind.NO_CONSTRUCTOR, [e.name, e.kind]);
     }
 
     ClassElement lookupTarget = constructor.enclosingElement;
     bool validTarget = true;
+    FunctionElement result;
     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 (Initializers.isConstructorRedirect(call)) {
+      // Check that there is no body (Language specification 7.5.1).
+      if (functionNode.hasBody()) {
+        error(functionNode, MessageKind.REDIRECTING_CONSTRUCTOR_HAS_BODY);
+      }
       // Check that there are no other initializers.
       if (!initializers.tail.isEmpty()) {
-        error(call, MessageKind.REDIRECTING_CTOR_HAS_INITIALIZER);
+        error(call, MessageKind.REDIRECTING_CONSTRUCTOR_HAS_INITIALIZER);
       }
     } else {
       visitor.error(call, MessageKind.CONSTRUCTOR_CALL_EXPECTED);
       validTarget = false;
     }
 
     if (validTarget) {
-      final SourceString className = lookupTarget.name;
-      final SourceString constructorName = getConstructorName(call);
-      FunctionElement target =
-          lookupTarget.lookupConstructor(className, constructorName,
-                                         noConstructor);
-      if (target === null && call.arguments.isEmpty()) {
-        target = lookupTarget.getSynthesizedConstructor();
-      }
-      if (target === null) {
+      ResolverTask resolver = visitor.compiler.resolver;
+      result = resolver.lookupConstructor(lookupTarget, call);
+      if (result === null) {
+        SourceString constructorName = resolver.getConstructorName(call);
+        SourceString className = lookupTarget.name;
         String name = (constructorName === const SourceString(''))
                           ? className.stringValue
                           : "$className.$constructorName";
         error(call, MessageKind.CANNOT_RESOLVE_CONSTRUCTOR, [name]);
       } else {
         final Compiler compiler = visitor.compiler;
         // TODO(karlklose): support optional arguments.
-        if (target.parameterCount(compiler) != call.argumentCount()) {
+        if (result.parameterCount(compiler) != call.argumentCount()) {
           error(call, MessageKind.NO_MATCHING_CONSTRUCTOR);
         }
       }
-      visitor.useElement(call, target);
+      visitor.useElement(call, result);
     }
     // Resolve the arguments of the call.
     for (Link<Node> arguments = call.arguments;
          !arguments.isEmpty();
          arguments = arguments.tail) {
       visitor.visitInStaticContext(arguments.head);
     }
+    return result;
   }
 
-  void resolveInitializers(FunctionExpression node) {
-    if (node.initializers === null) return;
-    initializers = node.initializers.nodes;
-    Compiler compiler = visitor.compiler;
+  FunctionElement resolveRedirection(FunctionElement constructor,
+                                     FunctionExpression functionNode) {
+    if (functionNode.initializers === null) return null;
+    Link<Node> link = functionNode.initializers.nodes;
+    if (!link.isEmpty() && Initializers.isConstructorRedirect(link.head)) {
+      return resolveSuperOrThis(constructor, functionNode, link.head);
+    }
+    return null;
+  }
+
+  /**
+   * Resolve all initializers of this constructor. In the case of a redirecting
+   * constructor, the resolved constructor's function element is returned.
+   */
+  FunctionElement resolveInitializers(FunctionElement constructor,
+                                      FunctionExpression functionNode) {
+    if (functionNode.initializers === null) return null;
+    initializers = functionNode.initializers.nodes;
+    FunctionElement result;
     for (Link<Node> link = initializers;
          !link.isEmpty();
          link = link.tail) {
       if (link.head.asSendSet() != null) {
         final SendSet init = link.head.asSendSet();
-        resolveFieldInitializer(init);
+        resolveFieldInitializer(constructor, init);
       } else if (link.head.asSend() !== null) {
         final Send call = link.head.asSend();
-        resolveSuperOrThis(call);
+        result = resolveSuperOrThis(constructor, functionNode, call);
       } else {
-        visitor.compiler.cancel('internal error: invalid initializer',
-                                node: link.head);
+        error(link.head, MessageKind.INVALID_INITIALIZER);
       }
     }
+    return result;
   }
 }
 
-class CommonResolverVisitor<R> extends AbstractVisitor<Element> {
+class CommonResolverVisitor<R> extends AbstractVisitor<R> {
   final Compiler compiler;
 
   CommonResolverVisitor(Compiler this.compiler);
 
   R visitNode(Node node) {
     cancel(node, 'internal error');
   }
 
   /** Convenience method for visiting nodes that may be null. */
   R visit(Node node) => (node == null) ? null : node.accept(this);
 
   void error(Node node, MessageKind kind, [arguments = const []]) {
-    ResolutionError error  = new ResolutionError(kind, arguments);
-    compiler.reportError(node, error);
+    ResolutionError message  = new ResolutionError(kind, arguments);
+    compiler.reportError(node, message);
   }
 
   void warning(Node node, MessageKind kind, [arguments = const []]) {
-    ResolutionWarning warning  = new ResolutionWarning(kind, arguments);
-    compiler.reportWarning(node, warning);
+    ResolutionWarning message  = new ResolutionWarning(kind, arguments);
+    compiler.reportWarning(node, message);
   }
 
   void cancel(Node node, String message) {
     compiler.cancel(message, node: node);
   }
 
   void internalError(Node node, String message) {
     compiler.internalError(message, node: node);
   }
 
@@ skipping 948 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";
   }
 }