Resolve implicit super calls.

lib/compiler/implementation/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 51 matching lines @@
   }
 
   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;
-    return classElement.lookupConstructor(className,
-                                          constructorName,
-                                          noConstructor);
-  }
-
   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);
+      final ClassElement classElement = constructor.enclosingElement;

[floitsch, 2012/04/13 18:08:47]

I inlined the code from above here.
I can undo this, but for me it was more confusing than having it here.

[karlklose, 2012/04/16 13:01:51]

I am fine with inlining the code here.

+      final SourceString constructorName =
+          getConstructorName(initializers.head);
+      final SourceString className = classElement.name;
+      return classElement.lookupConstructor(className, constructorName);
     }
     return null;
   }
 
   void resolveRedirectingConstructor(InitializerResolver resolver,
                                      Node node,
                                      FunctionElement constructor,
                                      FunctionElement redirection) {
     Set<FunctionElement> seen = new Set<FunctionElement>();
     seen.add(constructor);
@@ skipping 16 matching lines @@
         if (elements !== null) return elements;
       }
       FunctionExpression tree = element.parseNode(compiler);
       if (isConstructor) {
         resolveConstructorImplementation(element, tree);
       }
       ResolverVisitor visitor = new ResolverVisitor(compiler, element);
       visitor.useElement(tree, element);
       visitor.setupFunction(tree, element);
 
-      if (tree.initializers != null) {
-        if (!isConstructor) {
-          error(tree, MessageKind.FUNCTION_WITH_INITIALIZER);
-        }
+      if (isConstructor) {
+        // Even if there is no initializer list we still have to do the
+        // resolution in case there is an implicit super constructor call.
         InitializerResolver resolver = new InitializerResolver(visitor);
         FunctionElement redirection =
             resolver.resolveInitializers(element, tree);
         if (redirection !== null) {
           resolveRedirectingConstructor(resolver, tree, element, redirection);
         }
+      } else if (tree.initializers != null) {
+        error(tree, MessageKind.FUNCTION_WITH_INITIALIZER);        
       }
       visitor.visit(tree.body);
 
       // Resolve the type annotations encountered in the method.
       while (!toResolve.isEmpty()) {
         ClassElement classElement = toResolve.removeFirst();
         classElement.ensureResolved(compiler);
       }
       if (isConstructor) {
         constructorElements[element] = visitor.mapping;
@@ skipping 128 matching lines @@
     // 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);
   }
 
+  Element resolveSuperOrThisForSend(FunctionElement constructor,
+                                    FunctionExpression functionNode,
+                                    Send call) {
+    // Resolve the arguments, and make sure the call gets a selector
+    // by calling handleArguments.
+    ResolverTask resolver = visitor.compiler.resolver;
+    visitor.inStaticContext( () => visitor.handleArguments(call) );
+    Selector selector = visitor.mapping.getSelector(call);
+    bool isSuperCall = Initializers.isSuperConstructorCall(call);
+    SourceString constructorName = resolver.getConstructorName(call);
+    Element result = resolveSuperOrThis(
+        constructor, isSuperCall, false, constructorName, selector, call);
+    visitor.useElement(call, result);
+    return result;
+  }
+
+  void resolveImplicitSuperConstructorSend(FunctionElement constructor,
+                                           FunctionExpression functionNode) {
+    // If the class has a super resolve the implicit super call.
+    ClassElement classElement = constructor.enclosingElement;
+    ClassElement superClass = classElement.superclass;
+    if (classElement != visitor.compiler.objectClass) {
+      assert(superClass !== null);
+      assert(superClass.isResolved);
+      resolveSuperOrThis(constructor, true, true, const SourceString(''),
+                         Selector.INVOCATION_0, functionNode);
+    }
+  }
+
   Element resolveSuperOrThis(FunctionElement constructor,
-                             FunctionExpression functionNode,
-                             Send call) {
-    noConstructor(e) {
-      if (e !== null) error(call, MessageKind.NO_CONSTRUCTOR, [e.name, e.kind]);
-    }
-
+                             bool isSuperCall,
+                             bool isImplicitSuperCall,
+                             SourceString constructorName,
+                             Selector selector,
+                             Node diagnosticNode) {
     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;
+    if (isSuperCall) {
       // Calculate correct lookup target and constructor name.
       if (lookupTarget.name == Types.OBJECT) {
-        error(call, MessageKind.SUPER_INITIALIZER_IN_OBJECT);
+        error(diagnosticNode, 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_CONSTRUCTOR_HAS_INITIALIZER);
-      }
-    } else {
-      visitor.error(call, MessageKind.CONSTRUCTOR_CALL_EXPECTED);
-      validTarget = false;
     }
 
-    if (validTarget) {
-      // Resolve the arguments, and make sure the call gets a selector
-      // by calling handleArguments.
-      visitor.inStaticContext( () => visitor.handleArguments(call) );
-      // Lookup constructor and try to match it to the selector.
-      ResolverTask resolver = visitor.compiler.resolver;
-      result = resolver.lookupConstructor(lookupTarget, call);
-      if (result === null) {
-        SourceString constructorName = resolver.getConstructorName(call);
-        String className = lookupTarget.name.slowToString();
-        String name = (constructorName === const SourceString(''))
-                          ? className
-                          : "$className.${constructorName.slowToString()}";
-        error(call, MessageKind.CANNOT_RESOLVE_CONSTRUCTOR, [name]);
-      } else {
-        final Compiler compiler = visitor.compiler;
-        Selector selector = visitor.mapping.getSelector(call);
-        FunctionParameters parameters = result.computeParameters(compiler);
-        // TODO(karlklose): support optional arguments.
-        if (!selector.applies(parameters)) {
-          error(call, MessageKind.NO_MATCHING_CONSTRUCTOR);
-        }
+    // Lookup constructor and try to match it to the selector.
+    ResolverTask resolver = visitor.compiler.resolver;
+    final SourceString className = lookupTarget.name;
+    result = lookupTarget.lookupConstructor(className, constructorName);
+    if (result === null) {
+      String classNameString = className.slowToString();
+      String constructorNameString = constructorName.slowToString();
+      String name = (constructorName === const SourceString(''))
+                        ? classNameString
+                        : "$classNameString.$constructorNameString";
+      MessageKind kind = isImplicitSuperCall
+                         ? MessageKind.CANNOT_RESOLVE_CONSTRUCTOR_FOR_IMPLICIT
+                         : MessageKind.CANNOT_RESOLVE_CONSTRUCTOR;
+      error(diagnosticNode, kind, [name]);
+    } else {
+      final Compiler compiler = visitor.compiler;
+      FunctionParameters parameters = result.computeParameters(compiler);
+      if (!selector.applies(parameters)) {
+        MessageKind kind = isImplicitSuperCall
+                           ? MessageKind.NO_MATCHING_CONSTRUCTOR_FOR_IMPLICIT
+                           : MessageKind.NO_MATCHING_CONSTRUCTOR;
+        error(diagnosticNode, kind);
       }
-      visitor.useElement(call, result);
     }
     return result;
   }
 
   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 resolveSuperOrThisForSend(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;
+    if (functionNode.initializers === null) {
+      initializers = const EmptyLink<Node>();
+    } else {
+      initializers = functionNode.initializers.nodes;
+    }
     FunctionElement result;
+    bool resolvedSuper = false;
     for (Link<Node> link = initializers;
          !link.isEmpty();
          link = link.tail) {
       if (link.head.asSendSet() != null) {
         final SendSet init = link.head.asSendSet();
         resolveFieldInitializer(constructor, init);
       } else if (link.head.asSend() !== null) {
         final Send call = link.head.asSend();
-        result = resolveSuperOrThis(constructor, functionNode, call);
+        if (Initializers.isSuperConstructorCall(call)) {
+          if (resolvedSuper) {
+            error(call, MessageKind.DUPLICATE_SUPER_INITIALIZER);          
+          }
+          resolveSuperOrThisForSend(constructor, functionNode, call);
+          resolvedSuper = true;
+        } 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_CONSTRUCTOR_HAS_INITIALIZER);
+          }
+          return resolveSuperOrThisForSend(constructor, functionNode, call);
+        } else {
+          visitor.error(call, MessageKind.CONSTRUCTOR_CALL_EXPECTED);
+          return null;
+        }
       } else {
         error(link.head, MessageKind.INVALID_INITIALIZER);
       }
     }
-    return result;
+    if (!resolvedSuper) {
+      resolveImplicitSuperConstructorSend(constructor, functionNode);
+    }
+    return null;  // Super initializers always return null.
   }
 }
 
 class CommonResolverVisitor<R> extends AbstractVisitor<R> {
   final Compiler compiler;
 
   CommonResolverVisitor(Compiler this.compiler);
 
   R visitNode(Node node) {
     cancel(node, 'internal error');
@@ skipping 770 matching lines @@
         } else {
           // It's only a warning if it shadows another label.
           existingElement = statementScope.lookupLabel(labelName);
           if (existingElement !== null) {
             warning(labelIdentifier, MessageKind.DUPLICATE_LABEL, [labelName]);
             warning(existingElement.label,
                     MessageKind.EXISTING_LABEL, [labelName]);
           }
         }
 
-        TargetElement TargetElement =
+        TargetElement targetElement =
             new TargetElement(switchCase,
                                  statementScope.nestingLevel,
                                  enclosingElement);
-        mapping[switchCase] = TargetElement;
+        mapping[switchCase] = targetElement;
 
         LabelElement label =
             new LabelElement(labelIdentifier, labelName,
-                             TargetElement, enclosingElement);
+                             targetElement, enclosingElement);
         mapping[labelIdentifier] = label;
         continueLabels[labelName] = label;
       }
       cases = cases.tail;
       if (switchCase.defaultKeyword !== null && !cases.isEmpty()) {
         error(switchCase, MessageKind.INVALID_CASE_DEFAULT);
       }
     }
     statementScope.enterSwitch(breakElement, continueLabels);
     node.cases.accept(this);
     statementScope.exitSwitch();
 
     // Clean-up unused labels
     continueLabels.forEach((String key, LabelElement label) {
-      TargetElement TargetElement = label.target;
-      SwitchCase switchCase = TargetElement.statement;
+      TargetElement targetElement = label.target;
+      SwitchCase switchCase = targetElement.statement;
       if (!label.isContinueTarget) {
         mapping.remove(switchCase);
         mapping.remove(label.label);
       }
     });
   }
 
   visitSwitchCase(SwitchCase node) {
     // The label was handled in [visitSwitchStatement(SwitchStatement)].
     node.expressions.accept(this);
@@ skipping 588 matching lines @@
 
   TopScope(LibraryElement library) : super(null, library);
   Element lookup(SourceString name) {
     return library.find(name);
   }
 
   Element add(Element element) {
     throw "Cannot add an element in the top scope";
   }
 }