Rewrite how we handle synthesized constructors in the compiler. This was motivated by issue https:/…

sdk/lib/_internal/compiler/implementation/ssa/builder.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.
 
 part of ssa;
 
 /**
  * A special element for the extra parameter taken by intercepted
  * methods. We need to override [Element.computeType] because our
  * optimizers may look at its declared type.
@@ skipping 194 matching lines @@
     }
     updateLocal(boxElement, newBox);
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [function] must be an implementation element.
    */
   void startFunction(Element element, Expression node) {
-    assert(invariant(node, element.isImplementation));
+    assert(invariant(element, element.isImplementation));
     Compiler compiler = builder.compiler;
     closureData = compiler.closureToClassMapper.computeClosureToClassMapping(
             element, node, builder.elements);
 
     if (element is FunctionElement) {
       FunctionElement functionElement = element;
       FunctionSignature params = functionElement.computeSignature(compiler);
       params.orderedForEachParameter((Element parameterElement) {
         if (element.isGenerativeConstructorBody()) {
           ClosureScope scopeData = closureData.capturingScopes[node];
@@ skipping 1038 matching lines @@
 
       return true;
     }
 
     bool heuristicSayGoodToGo(FunctionExpression functionExpression) {
       // Don't inline recursivly
       if (inliningStack.any((entry) => entry.function == function)) {
         return false;
       }
 
+      if (element.isSynthesized) return true;
+
       if (cachedCanBeInlined == true) return cachedCanBeInlined;
 
       int numParameters = function.functionSignature.parameterCount;
       int maxInliningNodes;
       if (insideLoop) {
         maxInliningNodes = InlineWeeder.INLINING_NODES_INSIDE_LOOP +
             InlineWeeder.INLINING_NODES_INSIDE_LOOP_ARG_FACTOR * numParameters;
       } else {
         maxInliningNodes = InlineWeeder.INLINING_NODES_OUTSIDE_LOOP +
             InlineWeeder.INLINING_NODES_OUTSIDE_LOOP_ARG_FACTOR * numParameters;
@@ skipping 55 matching lines @@
       sourceElementStack.removeLast();
       return result;
     });
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [constructors] must contain only implementation elements.
    */
-  void inlineSuperOrRedirect(FunctionElement constructor,
-                             Selector selector,
-                             Link<Node> arguments,
+  void inlineSuperOrRedirect(FunctionElement callee,
+                             List<HInstruction> compiledArguments,
                              List<FunctionElement> constructors,
                              Map<Element, HInstruction> fieldValues,
-                             FunctionElement inlinedFromElement,
-                             Node callNode) {
-    constructor = constructor.implementation;
-    compiler.withCurrentElement(constructor, () {
-      constructors.add(constructor);
-
-      List<HInstruction> compiledArguments = new List<HInstruction>();
-      bool succeeded =
-          inlinedFrom(inlinedFromElement,
-                       () => addStaticSendArgumentsToList(selector,
-                                                          arguments,
-                                                          constructor,
-                                                          compiledArguments));
-      if (!succeeded) {
-        // Non-matching super and redirects are compile-time errors and thus
-        // checked by the resolver.
-        compiler.internalError(
-            "Parameters and arguments didn't match for super/redirect call",
-            element: constructor);
-      }
-
-      ClassElement enclosingClass = constructor.getEnclosingClass();
+                             FunctionElement caller) {
+    callee = callee.implementation;
+    compiler.withCurrentElement(callee, () {
+      constructors.add(callee);
+      ClassElement enclosingClass = callee.getEnclosingClass();
       if (backend.classNeedsRti(enclosingClass)) {
         // If [enclosingClass] needs RTI, we have to give a value to its
         // type parameters.
-        ClassElement currentClass = inlinedFromElement.getEnclosingClass();
+        ClassElement currentClass = caller.getEnclosingClass();
         // For a super constructor call, the type is the supertype of
         // [currentClass]. For a redirecting constructor, the type is
         // the current type. [InterfaceType.asInstanceOf] takes care
         // of both.
         InterfaceType type = currentClass.thisType.asInstanceOf(enclosingClass);
         Link<DartType> typeVariables = enclosingClass.typeVariables;
         type.typeArguments.forEach((DartType argument) {
-          localsHandler.updateLocal(typeVariables.head.element,
-              analyzeTypeArgument(argument, callNode));
+          localsHandler.updateLocal(
+              typeVariables.head.element,
+              analyzeTypeArgument(argument));
           typeVariables = typeVariables.tail;
         });
         // If the supertype is a raw type, we need to set to null the
         // type variables.
         assert(typeVariables.isEmpty
                || enclosingClass.typeVariables == typeVariables);
         while (!typeVariables.isEmpty) {
           localsHandler.updateLocal(typeVariables.head.element,
               graph.addConstantNull(compiler));
           typeVariables = typeVariables.tail;
         }
       }
 
-      inlinedFrom(constructor, () {
-        buildFieldInitializers(constructor.enclosingElement.implementation,
+      inlinedFrom(callee, () {
+        buildFieldInitializers(callee.enclosingElement.implementation,
                                fieldValues);
       });
 
       int index = 0;
-      FunctionSignature params = constructor.computeSignature(compiler);
+      FunctionSignature params = callee.computeSignature(compiler);
       params.orderedForEachParameter((Element parameter) {
         HInstruction argument = compiledArguments[index++];
         // Because we are inlining the initializer, we must update
         // what was given as parameter. This will be used in case
         // there is a parameter check expression in the initializer.
         parameters[parameter] = argument;
         localsHandler.updateLocal(parameter, argument);
         // Don't forget to update the field, if the parameter is of the
         // form [:this.x:].
         if (parameter.kind == ElementKind.FIELD_PARAMETER) {
           FieldParameterElement fieldParameterElement = parameter;
           fieldValues[fieldParameterElement.fieldElement] = argument;
         }
       });
 
       // Build the initializers in the context of the new constructor.
       TreeElements oldElements = elements;
-      if (constructor.isForwardingConstructor) {
-        constructor = constructor.targetConstructor;
-      }
-      elements =
-          compiler.enqueuer.resolution.getCachedElements(constructor);
+      elements = compiler.enqueuer.resolution.getCachedElements(callee);
       ClosureClassMap oldClosureData = localsHandler.closureData;
-      Node node = constructor.parseNode(compiler);
+      Node node = callee.parseNode(compiler);
       ClosureClassMap newClosureData =
           compiler.closureToClassMapper.computeClosureToClassMapping(
-              constructor, node, elements);
+              callee, node, elements);
       localsHandler.closureData = newClosureData;
-      localsHandler.enterScope(node, constructor);
-      buildInitializers(constructor, constructors, fieldValues);
+      localsHandler.enterScope(node, callee);
+      buildInitializers(callee, constructors, fieldValues);
       localsHandler.closureData = oldClosureData;
       elements = oldElements;
     });
   }
 
   /**
    * Run through the initializers and inline all field initializers. Recursively
    * inlines super initializers.
    *
    * The constructors of the inlined initializers is added to [constructors]
    * with sub constructors having a lower index than super constructors.
    *
    * Invariant: The [constructor] and elements in [constructors] must all be
    * implementation elements.
    */
   void buildInitializers(FunctionElement constructor,
                          List<FunctionElement> constructors,
                          Map<Element, HInstruction> fieldValues) {
     assert(invariant(constructor, constructor.isImplementation));
+    if (constructor.isSynthesized) {
+      List<HInstruction> arguments = <HInstruction>[];
+      HInstruction compileArgument(Element element) {
+        return localsHandler.readLocal(element);
+      }
+
+      Element target = constructor.targetConstructor.implementation;
+      Selector.addForwardingElementArgumentsToList(
+          constructor, 
+          arguments,
+          target,
+          compileArgument,
+          handleConstantForOptionalParameter,
+          compiler);
+      inlineSuperOrRedirect(
+          target,
+          arguments,
+          constructors,
+          fieldValues,
+          constructor);
+      return;
+    }
     FunctionExpression functionNode = constructor.parseNode(compiler);
 
     bool foundSuperOrRedirect = false;
-
     if (functionNode.initializers != null) {
       Link<Node> initializers = functionNode.initializers.nodes;
       for (Link<Node> link = initializers; !link.isEmpty; link = link.tail) {
         assert(link.head is Send);
         if (link.head is !SendSet) {
           // A super initializer or constructor redirection.
+          foundSuperOrRedirect = true;
           Send call = link.head;
           assert(Initializers.isSuperConstructorCall(call) ||
                  Initializers.isConstructorRedirect(call));
-          FunctionElement target = elements[call];
+          FunctionElement target = elements[call].implementation;
           Selector selector = elements.getSelector(call);
           Link<Node> arguments = call.arguments;
+          List<HInstruction> compiledArguments = new List<HInstruction>();
+          inlinedFrom(constructor, () {
+            addStaticSendArgumentsToList(selector,
+                                         arguments,
+                                         target,
+                                         compiledArguments);
+          });
           inlineSuperOrRedirect(target,
-                                selector,
-                                arguments,
+                                compiledArguments,
                                 constructors,
                                 fieldValues,
-                                constructor,
-                                call);
-          foundSuperOrRedirect = true;
+                                constructor);
         } else {
           // A field initializer.
           SendSet init = link.head;
           Link<Node> arguments = init.arguments;
           assert(!arguments.isEmpty && arguments.tail.isEmpty);
           inlinedFrom(constructor, () {
             visit(arguments.head);
           });
           fieldValues[elements[init]] = pop();
         }
       }
     }
 
     if (!foundSuperOrRedirect) {
       // No super initializer found. Try to find the default constructor if
       // the class is not Object.
       ClassElement enclosingClass = constructor.getEnclosingClass();
       ClassElement superClass = enclosingClass.superclass;
       if (!enclosingClass.isObject(compiler)) {
         assert(superClass != null);
         assert(superClass.resolutionState == STATE_DONE);
         Selector selector =
             new Selector.callDefaultConstructor(enclosingClass.getLibrary());
         // TODO(johnniwinther): Should we find injected constructors as well?
         FunctionElement target = superClass.lookupConstructor(selector);
         if (target == null) {
           compiler.internalError("no default constructor available");
         }
+        List<HInstruction> arguments = <HInstruction>[];
+        selector.addArgumentsToList(const Link<Node>(),
+                                    arguments,
+                                    target.implementation,
+                                    null,
+                                    handleConstantForOptionalParameter,
+                                    compiler);
         inlineSuperOrRedirect(target,
-                              selector,
-                              const Link<Node>(),
+                              arguments,
                               constructors,
                               fieldValues,
-                              constructor,
-                              functionNode);
+                              constructor);
       }
     }
   }
 
   /**
    * Run through the fields of [cls] and add their potential
    * initializers.
    *
    * Invariant: [classElement] must be an implementation element.
    */
@@ skipping 1380 matching lines @@
                                     Link<Node> arguments,
                                     FunctionElement element,
                                     List<HInstruction> list) {
     assert(invariant(element, element.isImplementation));
 
     HInstruction compileArgument(Node argument) {
       visit(argument);
       return pop();
     }
 
-    if (element.isForwardingConstructor) {
-      element = element.targetConstructor;
-    }
-
     return selector.addArgumentsToList(arguments,
                                        list,
                                        element,
                                        compileArgument,
                                        handleConstantForOptionalParameter,
                                        compiler);
   }
 
   void addGenericSendArgumentsToList(Link<Node> link, List<HInstruction> list) {
     for (; !link.isEmpty; link = link.tail) {
@@ skipping 433 matching lines @@
       compiler.cancel('Unimplemented unresolved type variable',
                       element: type.element);
     }
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [argument] must not be malformed in checked mode.
    */
-  HInstruction analyzeTypeArgument(DartType argument, Node currentNode) {
-    assert(invariant(currentNode,
+  HInstruction analyzeTypeArgument(DartType argument) {
+    assert(invariant(currentElement,
                      !compiler.enableTypeAssertions || !argument.isMalformed,
                      message: '$argument is malformed in checked mode'));
     if (argument == compiler.types.dynamicType || argument.isMalformed) {
       // Represent [dynamic] as [null].
       return graph.addConstantNull(compiler);
     }
 
     List<HInstruction> inputs = <HInstruction>[];
 
     String template = rti.getTypeRepresentation(argument, (variable) {
       inputs.add(addTypeVariableReference(variable));
     });
 
     HInstruction result = createForeign(template, backend.stringType, inputs);
     add(result);
     return result;
   }
 
   void handleListConstructor(InterfaceType type,
                              Node currentNode,
                              HInstruction newObject) {
     if (!backend.classNeedsRti(type.element)) return;
     if (!type.isRaw) {
       List<HInstruction> inputs = <HInstruction>[];
       type.typeArguments.forEach((DartType argument) {
-        inputs.add(analyzeTypeArgument(argument, currentNode));
+        inputs.add(analyzeTypeArgument(argument));
       });
       callSetRuntimeTypeInfo(type.element, inputs, newObject);
     }
   }
 
   void callSetRuntimeTypeInfo(ClassElement element,
                               List<HInstruction> rtiInputs,
                               HInstruction newObject) {
     if (!backend.classNeedsRti(element) || element.typeVariables.isEmpty) {
       return;
@@ skipping 42 matching lines @@
         ClassElement cls = element.getEnclosingClass();
         return new HType.nonNullExact(cls.thisType, compiler);
       } else {
         return new HType.inferredReturnTypeForElement(
             originalElement, compiler);
       }
     }
 
     Element constructor = elements[send];
     Selector selector = elements.getSelector(send);
-    if (constructor.isForwardingConstructor) {
-      compiler.unimplemented('forwarded constructor in named mixin application',
-                             element: constructor.getEnclosingClass());
-    }
-    if (compiler.enqueuer.resolution.getCachedElements(constructor) == null) {
-      compiler.internalError("Unresolved element: $constructor", node: send);
-    }
     FunctionElement functionElement = constructor;
     constructor = functionElement.redirectionTarget;
 
     final bool isSymbolConstructor =
         functionElement == compiler.symbolConstructor;
 
     if (isSymbolConstructor) {
       constructor = compiler.symbolValidatedConstructor;
       assert(invariant(send, constructor != null,
                        message: 'Constructor Symbol.validated is missing'));
@@ skipping 20 matching lines @@
     }
 
     ClassElement cls = constructor.getEnclosingClass();
     if (cls.isAbstract(compiler) && constructor.isGenerativeConstructor()) {
       generateAbstractClassInstantiationError(send, cls.name.slowToString());
       return;
     }
     if (backend.classNeedsRti(cls)) {
       Link<DartType> typeVariable = cls.typeVariables;
       type.typeArguments.forEach((DartType argument) {
-        inputs.add(analyzeTypeArgument(argument, send));
+        inputs.add(analyzeTypeArgument(argument));
         typeVariable = typeVariable.tail;
       });
       // Also add null to non-provided type variables to call the
       // constructor with the right number of arguments.
       while (!typeVariable.isEmpty) {
         inputs.add(graph.addConstantNull(compiler));
         typeVariable = typeVariable.tail;
       }
     }
 
@@ skipping 1958 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }