Revert "Extract CallStructure from Selector."

pkg/compiler/lib/src/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;
 
 class SsaFunctionCompiler implements FunctionCompiler {
   SsaCodeGeneratorTask generator;
   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
@@ skipping 1226 matching lines @@
        *   void foo(a, {b, d, c})
        *   foo(0, d = 1, b = 2)
        *
        * providedArguments = [0, 2, 1]
        * selectorArgumentNames = [b, d]
        * signature.orderedOptionalParameters = [b, c, d]
        *
        * For each parameter name in the signature, if the argument name matches
        * we use the next provided argument, otherwise we get the default.
        */
-      List<String> selectorArgumentNames =
-          selector.callStructure.getOrderedNamedArguments();
+      List<String> selectorArgumentNames = selector.getOrderedNamedArguments();
       int namedArgumentIndex = 0;
       int firstProvidedNamedArgument = index;
       signature.orderedOptionalParameters.forEach((element) {
         if (namedArgumentIndex < selectorArgumentNames.length &&
             element.name == selectorArgumentNames[namedArgumentIndex]) {
           // The named argument was provided in the function invocation.
           compiledArguments[index] = providedArguments[
               firstProvidedNamedArgument + namedArgumentIndex++];
         } else {
           compiledArguments[index] =
@@ skipping 628 matching lines @@
                          List<FunctionElement> constructors,
                          Map<Element, HInstruction> fieldValues) {
     assert(invariant(constructor, constructor.isImplementation));
     if (constructor.isSynthesized) {
       List<HInstruction> arguments = <HInstruction>[];
       HInstruction compileArgument(ParameterElement parameter) {
         return localsHandler.readLocal(parameter);
       }
 
       Element target = constructor.definingConstructor.implementation;
-      bool match = CallStructure.addForwardingElementArgumentsToList(
+      bool match = Selector.addForwardingElementArgumentsToList(
           constructor,
           arguments,
           target,
           compileArgument,
-          handleConstantForOptionalParameter);
+          handleConstantForOptionalParameter,
+          compiler.world);
       if (!match) {
         if (compiler.elementHasCompileTimeError(constructor)) {
           return;
         }
         // If this fails, the selector we constructed for the call to a
         // forwarding constructor in a mixin application did not match the
         // constructor (which, for example, may happen when the libraries are
         // not compatible for private names, see issue 20394).
         compiler.internalError(constructor,
                                'forwarding constructor call does not match');
@@ skipping 13 matching lines @@
       Link<ast.Node> initializers = functionNode.initializers.nodes;
       for (Link<ast.Node> link = initializers; !link.isEmpty; link = link.tail) {
         assert(link.head is ast.Send);
         if (link.head is !ast.SendSet) {
           // A super initializer or constructor redirection.
           foundSuperOrRedirect = true;
           ast.Send call = link.head;
           assert(ast.Initializers.isSuperConstructorCall(call) ||
                  ast.Initializers.isConstructorRedirect(call));
           FunctionElement target = elements[call].implementation;
-          CallStructure callStructure =
-              elements.getSelector(call).callStructure;
+          Selector selector = elements.getSelector(call);
           Link<ast.Node> arguments = call.arguments;
           List<HInstruction> compiledArguments;
           inlinedFrom(constructor, () {
             compiledArguments =
-                makeStaticArgumentList(callStructure, arguments, target);
+                makeStaticArgumentList(selector, arguments, target);
           });
           inlineSuperOrRedirect(target,
                                 compiledArguments,
                                 constructors,
                                 fieldValues,
                                 constructor);
         } else {
           // A field initializer.
           ast.SendSet init = link.head;
           Link<ast.Node> arguments = init.arguments;
@@ skipping 13 matching lines @@
       ClassElement superClass = enclosingClass.superclass;
       if (!enclosingClass.isObject) {
         assert(superClass != null);
         assert(superClass.resolutionState == STATE_DONE);
         // TODO(johnniwinther): Should we find injected constructors as well?
         FunctionElement target = superClass.lookupDefaultConstructor();
         if (target == null) {
           compiler.internalError(superClass,
               "No default constructor available.");
         }
+        Selector selector = new Selector.callDefaultConstructor();
         List<HInstruction> arguments =
-            CallStructure.NO_ARGS.makeArgumentsList(
-                const Link<ast.Node>(),
-                target.implementation,
-                null,
-                handleConstantForOptionalParameter);
+            selector.makeArgumentsList(const Link<ast.Node>(),
+                                       target.implementation,
+                                       null,
+                                       handleConstantForOptionalParameter);
         inlineSuperOrRedirect(target,
                               arguments,
                               constructors,
                               fieldValues,
                               constructor);
       }
     }
   }
 
   /**
@@ skipping 1524 matching lines @@
           type, expression, invokeInterceptor(expression), backend.boolType);
     }
   }
 
   HInstruction buildFunctionType(FunctionType type) {
     type.accept(new TypeBuilder(compiler.world), this);
     return pop();
   }
 
   void addDynamicSendArgumentsToList(ast.Send node, List<HInstruction> list) {
-    CallStructure callStructure = elements.getSelector(node).callStructure;
-    if (callStructure.namedArgumentCount == 0) {
+    Selector selector = elements.getSelector(node);
+    if (selector.namedArgumentCount == 0) {
       addGenericSendArgumentsToList(node.arguments, list);
     } else {
       // Visit positional arguments and add them to the list.
       Link<ast.Node> arguments = node.arguments;
-      int positionalArgumentCount = callStructure.positionalArgumentCount;
+      int positionalArgumentCount = selector.positionalArgumentCount;
       for (int i = 0;
            i < positionalArgumentCount;
            arguments = arguments.tail, i++) {
         visit(arguments.head);
         list.add(pop());
       }
 
       // Visit named arguments and add them into a temporary map.
       Map<String, HInstruction> instructions =
           new Map<String, HInstruction>();
-      List<String> namedArguments = callStructure.namedArguments;
+      List<String> namedArguments = selector.namedArguments;
       int nameIndex = 0;
       for (; !arguments.isEmpty; arguments = arguments.tail) {
         visit(arguments.head);
         instructions[namedArguments[nameIndex++]] = pop();
       }
 
       // Iterate through the named arguments to add them to the list
       // of instructions, in an order that can be shared with
       // selectors with the same named arguments.
-      List<String> orderedNames = callStructure.getOrderedNamedArguments();
+      List<String> orderedNames = selector.getOrderedNamedArguments();
       for (String name in orderedNames) {
         list.add(instructions[name]);
       }
     }
   }
 
   /**
    * Returns a list with the evaluated [arguments] in the normalized order.
    *
    * Precondition: `this.applies(element, world)`.
    * Invariant: [element] must be an implementation element.
    */
-  List<HInstruction> makeStaticArgumentList(CallStructure callStructure,
+  List<HInstruction> makeStaticArgumentList(Selector selector,
                                             Link<ast.Node> arguments,
                                             FunctionElement element) {
     assert(invariant(element, element.isImplementation));
 
     HInstruction compileArgument(ast.Node argument) {
       visit(argument);
       return pop();
     }
 
-    return callStructure.makeArgumentsList(
-        arguments,
-        element,
-        compileArgument,
-        handleConstantForOptionalParameter);
+    return selector.makeArgumentsList(arguments,
+                                      element,
+                                      compileArgument,
+                                      handleConstantForOptionalParameter);
   }
 
   void addGenericSendArgumentsToList(Link<ast.Node> link, List<HInstruction> list) {
     for (; !link.isEmpty; link = link.tail) {
       visit(link.head);
       list.add(pop());
     }
   }
 
   visitDynamicSend(ast.Send node) {
@@ skipping 507 matching lines @@
     }
     List<HInstruction> inputs = <HInstruction>[];
     if (node.isPropertyAccess) {
       push(buildInvokeSuper(selector, element, inputs));
     } else if (element.isFunction || element.isGenerativeConstructor) {
       if (selector.applies(element, compiler.world)) {
         // TODO(5347): Try to avoid the need for calling [implementation] before
         // calling [makeStaticArgumentList].
         FunctionElement function = element.implementation;
         assert(selector.applies(function, compiler.world));
-        inputs = makeStaticArgumentList(selector.callStructure,
+        inputs = makeStaticArgumentList(selector,
                                         node.arguments,
                                         function);
         push(buildInvokeSuper(selector, element, inputs));
       } else if (element.isGenerativeConstructor) {
         generateWrongArgumentCountError(node, element, node.arguments);
       } else {
         addGenericSendArgumentsToList(node.arguments, inputs);
         generateSuperNoSuchMethodSend(node, selector, inputs);
       }
     } else {
@@ skipping 223 matching lines @@
       } else if (element.isGenerativeConstructor) {
         ClassElement cls = element.enclosingClass;
         return new TypeMask.nonNullExact(cls.thisType.element, compiler.world);
       } else {
         return TypeMaskFactory.inferredReturnTypeForElement(
             originalElement, compiler);
       }
     }
 
     Element constructor = elements[send];
-    CallStructure callStructure = elements.getSelector(send).callStructure;
+    Selector selector = elements.getSelector(send);
     ConstructorElement constructorDeclaration = constructor;
     ConstructorElement constructorImplementation = constructor.implementation;
     constructor = constructorImplementation.effectiveTarget;
 
     final bool isSymbolConstructor =
         constructorDeclaration == compiler.symbolConstructor;
     final bool isJSArrayTypedConstructor =
         constructorDeclaration == backend.jsArrayTypedConstructor;
 
     if (isSymbolConstructor) {
       constructor = compiler.symbolValidatedConstructor;
       assert(invariant(send, constructor != null,
                        message: 'Constructor Symbol.validated is missing'));
-      callStructure = compiler.symbolValidatedConstructorSelector.callStructure;
-      assert(invariant(send, callStructure != null,
+      selector = compiler.symbolValidatedConstructorSelector;
+      assert(invariant(send, selector != null,
                        message: 'Constructor Symbol.validated is missing'));
     }
 
     bool isRedirected = constructorDeclaration.isRedirectingFactory;
     InterfaceType type = elements.getType(node);
     InterfaceType expectedType =
         constructorDeclaration.computeEffectiveTargetType(type);
     expectedType = localsHandler.substInContext(expectedType);
 
     if (compiler.elementHasCompileTimeError(constructor)) {
       // TODO(ahe): Do something like [generateWrongArgumentCountError].
       stack.add(graph.addConstantNull(compiler));
       return;
     }
     if (checkTypeVariableBounds(node, type)) return;
 
     var inputs = <HInstruction>[];
     if (constructor.isGenerativeConstructor &&
         Elements.isNativeOrExtendsNative(constructor.enclosingClass)) {
       // Native class generative constructors take a pre-constructed object.
       inputs.add(graph.addConstantNull(compiler));
     }
     // TODO(5347): Try to avoid the need for calling [implementation] before
     // calling [makeStaticArgumentList].
-    if (!callStructure.signatureApplies(constructor.implementation)) {
+    if (!selector.applies(constructor.implementation, compiler.world)) {
       generateWrongArgumentCountError(send, constructor, send.arguments);
       return;
     }
-    inputs.addAll(makeStaticArgumentList(callStructure,
+    inputs.addAll(makeStaticArgumentList(selector,
                                          send.arguments,
                                          constructor.implementation));
 
     TypeMask elementType = computeType(constructor);
     if (isFixedListConstructorCall) {
       if (!inputs[0].isNumber(compiler)) {
         HTypeConversion conversion = new HTypeConversion(
           null, HTypeConversion.ARGUMENT_TYPE_CHECK, backend.numType,
           inputs[0], null);
         add(conversion);
@@ skipping 138 matching lines @@
       return;
     }
     // TODO(johnniwinther): Don't handle assert like a regular static call.
     // It breaks the selector name check since the assert helper method cannot
     // be called `assert` and therefore does not match the selector like a
     // regular method.
     visitStaticSend(node);
   }
 
   visitStaticSend(ast.Send node) {
-    CallStructure callStructure = elements.getSelector(node).callStructure;
+    Selector selector = elements.getSelector(node);
     Element element = elements[node];
     if (elements.isAssert(node)) {
       element = backend.assertMethod;
     }
     if (element.isForeign(backend) && element.isFunction) {
       visitForeignSend(node);
       return;
     }
     if (element.isErroneous) {
       if (element is ErroneousElement) {
         // An erroneous element indicates that the funciton could not be
         // resolved (a warning has been issued).
         generateThrowNoSuchMethod(node,
                                   noSuchMethodTargetSymbolString(element),
                                   argumentNodes: node.arguments);
       } else {
         // TODO(ahe): Do something like [generateWrongArgumentCountError].
         stack.add(graph.addConstantNull(compiler));
       }
       return;
     }
     invariant(element, !element.isGenerativeConstructor);
     generateIsDeferredLoadedCheckIfNeeded(node);
     if (element.isFunction) {
       // TODO(5347): Try to avoid the need for calling [implementation] before
       // calling [makeStaticArgumentList].
-      if (!callStructure.signatureApplies(element.implementation)) {
+      if (!selector.applies(element.implementation, compiler.world)) {
         generateWrongArgumentCountError(node, element, node.arguments);
         return;
       }
 
       List<HInstruction> inputs =
-          makeStaticArgumentList(callStructure,
+          makeStaticArgumentList(selector,
                                  node.arguments,
                                  element.implementation);
 
       if (element == compiler.identicalFunction) {
         pushWithPosition(
             new HIdentity(inputs[0], inputs[1], null, backend.boolType), node);
         return;
       }
 
       pushInvokeStatic(node, element, inputs);
     } else {
       generateGetter(node, element);
       List<HInstruction> inputs = <HInstruction>[pop()];
       addDynamicSendArgumentsToList(node, inputs);
-      Selector closureSelector = callStructure.callSelector;
+      Selector closureSelector = new Selector.callClosureFrom(selector);
       pushWithPosition(
           new HInvokeClosure(closureSelector, inputs, backend.dynamicType),
           node);
     }
   }
 
   HConstant addConstantString(String string) {
     ast.DartString dartString = new ast.DartString.literal(string);
     ConstantValue constant = constantSystem.createString(dartString);
     return graph.addConstant(constant, compiler);
@@ skipping 2335 matching lines @@
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
     ClassElement cls = backend.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls, classWorld)));
   }
 }