Revert "Extract CallStructure from Selector."

pkg/compiler/lib/src/compile_time_constants.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 dart2js;
 
 /// A [ConstantEnvironment] provides access for constants compiled for variable
 /// initializers.
 abstract class ConstantEnvironment {
   /// Returns the constant for the initializer of [element].
@@ skipping 426 matching lines @@
 
   AstConstant visitLiteralSymbol(LiteralSymbol node) {
     InterfaceType type = compiler.symbolClass.rawType;
     String text = node.slowNameString;
     List<AstConstant> arguments =
         <AstConstant>[new AstConstant(context, node,
           new PrimitiveConstantExpression(constantSystem.createString(
               new DartString.literal(text))))];
     AstConstant constant = makeConstructedConstant(
         compiler, handler, context, node, type, compiler.symbolConstructor,
-        CallStructure.ONE_ARG,
+        new Selector.callConstructor('', null, 1),
         arguments, arguments);
     return new AstConstant(
         context, node, new SymbolConstantExpression(constant.value, text));
   }
 
   AstConstant makeTypeConstant(Node node, DartType elementType) {
     DartType constantType =
         compiler.backend.typeImplementation.computeType(compiler);
     return new AstConstant(
         context, node, new TypeConstantExpression(
@@ skipping 187 matching lines @@
 
   /**
    * Returns the normalized list of constant arguments that are passed to the
    * constructor including both the concrete arguments and default values for
    * omitted optional arguments.
    *
    * Invariant: [target] must be an implementation element.
    */
   List<AstConstant> evaluateArgumentsToConstructor(
       Node node,
-      CallStructure callStructure,
+      Selector selector,
       Link<Node> arguments,
       FunctionElement target,
       {AstConstant compileArgument(Node node)}) {
     assert(invariant(node, target.isImplementation));
 
     AstConstant compileDefaultValue(VariableElement element) {
       ConstantExpression constant = handler.compileConstant(element);
       return new AstConstant.fromDefaultValue(element, constant);
     }
     target.computeSignature(compiler);
 
-    if (!callStructure.signatureApplies(target)) {
+    if (!selector.applies(target, compiler.world)) {
       String name = Elements.constructorNameForDiagnostics(
           target.enclosingClass.name, target.name);
       compiler.reportError(
           node,
           MessageKind.INVALID_CONSTRUCTOR_ARGUMENTS,
           {'constructorName': name});
 
       return new List<AstConstant>.filled(
           target.functionSignature.parameterCount,
           new ErroneousAstConstant(context, node));
     }
-    return callStructure.makeArgumentsList(
-        arguments,
-        target,
-        compileArgument,
-        compileDefaultValue);
+    return selector.makeArgumentsList(arguments,
+                                      target,
+                                      compileArgument,
+                                      compileDefaultValue);
   }
 
   AstConstant visitNewExpression(NewExpression node) {
     if (!node.isConst) {
       return signalNotCompileTimeConstant(node);
     }
 
     Send send = node.send;
     FunctionElement constructor = elements[send];
     if (Elements.isUnresolved(constructor)) {
       return signalNotCompileTimeConstant(node);
     }
 
     // Deferred types can not be used in const instance creation expressions.
     // Check if the constructor comes from a deferred library.
     if (isDeferredUse(node.send.selector.asSend())) {
       return signalNotCompileTimeConstant(node,
           message: MessageKind.DEFERRED_COMPILE_TIME_CONSTANT_CONSTRUCTION);
     }
 
     // TODO(ahe): This is nasty: we must eagerly analyze the
     // constructor to ensure the redirectionTarget has been computed
     // correctly.  Find a way to avoid this.
     compiler.analyzeElement(constructor.declaration);
 
     InterfaceType type = elements.getType(node);
-    CallStructure callStructure = elements.getSelector(send).callStructure;
+    Selector selector = elements.getSelector(send);
 
     Map<Node, AstConstant> concreteArgumentMap =
         <Node, AstConstant>{};
     for (Link<Node> link = send.arguments; !link.isEmpty; link = link.tail) {
       Node argument = link.head;
       NamedArgument namedArgument = argument.asNamedArgument();
       if (namedArgument != null) {
         argument = namedArgument.expression;
       }
       concreteArgumentMap[argument] = evaluateConstant(argument);
     }
 
     List<AstConstant> normalizedArguments =
         evaluateArgumentsToConstructor(
-          node, callStructure, send.arguments, constructor.implementation,
+          node, selector, send.arguments, constructor.implementation,
           compileArgument: (node) => concreteArgumentMap[node]);
     List<AstConstant> concreteArguments =
         concreteArgumentMap.values.toList();
 
     if (constructor == compiler.intEnvironment ||
         constructor == compiler.boolEnvironment ||
         constructor == compiler.stringEnvironment) {
 
       AstConstant createEvaluatedConstant(ConstantValue value) {
         return new AstConstant(
             context, node, new ConstructedConstantExpression(
                 value,
                 type,
                 constructor,
-                elements.getSelector(send).callStructure,
+                elements.getSelector(send),
                 concreteArguments.map((e) => e.expression).toList()));
       }
 
       var firstArgument = normalizedArguments[0].value;
       ConstantValue defaultValue = normalizedArguments[1].value;
 
       if (firstArgument.isNull) {
         compiler.reportError(
             send.arguments.head, MessageKind.NULL_NOT_ALLOWED);
         return null;
@@ skipping 54 matching lines @@
           return createEvaluatedConstant(defaultValue);
         }
       } else {
         assert(constructor == compiler.stringEnvironment);
         return createEvaluatedConstant(
             constantSystem.createString(new DartString.literal(value)));
       }
     } else {
       return makeConstructedConstant(
           compiler, handler, context,
-          node, type, constructor, callStructure,
+          node, type, constructor, selector,
           concreteArguments, normalizedArguments);
     }
   }
 
   static AstConstant makeConstructedConstant(
       Compiler compiler,
       ConstantCompilerBase handler,
       Element context,
       Node node,
       InterfaceType type,
       ConstructorElement constructor,
-      CallStructure callStructure,
+      Selector selector,
       List<AstConstant> concreteArguments,
       List<AstConstant> normalizedArguments) {
-    assert(invariant(node, callStructure.signatureApplies(constructor) ||
+    assert(invariant(node, selector.applies(constructor, compiler.world) ||
                      compiler.compilationFailed,
-        message: "Call structure $callStructure does not apply to constructor "
+        message: "Selector $selector does not apply to constructor "
                  "$constructor."));
 
     // The redirection chain of this element may not have been resolved through
     // a post-process action, so we have to make sure it is done here.
     compiler.resolver.resolveRedirectionChain(constructor, node);
     InterfaceType constructedType =
         constructor.computeEffectiveTargetType(type);
     ConstructorElement target = constructor.effectiveTarget;
     ClassElement classElement = target.enclosingClass;
     // The constructor must be an implementation to ensure that field
     // initializers are handled correctly.
     target = target.implementation;
     assert(invariant(node, target.isImplementation));
 
     ConstructorEvaluator evaluator = new ConstructorEvaluator(
         constructedType, target, handler, compiler);
     evaluator.evaluateConstructorFieldValues(normalizedArguments);
     List<AstConstant> fieldConstants =
         evaluator.buildFieldConstants(classElement);
 
     return new AstConstant(
         context, node, new ConstructedConstantExpression(
             new ConstructedConstantValue(
                 constructedType,
                 fieldConstants.map((e) => e.value).toList()),
             type,
             constructor,
-            callStructure,
+            selector,
             concreteArguments.map((e) => e.expression).toList()));
   }
 
   AstConstant visitParenthesizedExpression(ParenthesizedExpression node) {
     return node.expression.accept(this);
   }
 
   error(Node node, MessageKind message) {
     // TODO(floitsch): get the list of constants that are currently compiled
     // and present some kind of stack-trace.
@@ skipping 117 matching lines @@
    * Runs through the initializers of the given [constructor] and updates
    * the [fieldValues] map.
    */
   void evaluateConstructorInitializers() {
     if (constructor.isSynthesized) {
       List<AstConstant> compiledArguments = <AstConstant>[];
 
       Function compileArgument = (element) => definitions[element];
       Function compileConstant = handler.compileConstant;
       FunctionElement target = constructor.definingConstructor.implementation;
-      CallStructure.addForwardingElementArgumentsToList(
-          constructor,
-          compiledArguments,
-          target,
-          compileArgument,
-          compileConstant);
+      Selector.addForwardingElementArgumentsToList(constructor,
+                                                   compiledArguments,
+                                                   target,
+                                                   compileArgument,
+                                                   compileConstant,
+                                                   compiler.world);
       evaluateSuperOrRedirectSend(compiledArguments, target);
       return;
     }
     FunctionExpression functionNode = constructor.node;
     NodeList initializerList = functionNode.initializers;
 
     bool foundSuperOrRedirect = false;
 
     if (initializerList != null) {
       for (Link<Node> link = initializerList.nodes;
            !link.isEmpty;
            link = link.tail) {
         assert(link.head is Send);
         if (link.head is !SendSet) {
           // A super initializer or constructor redirection.
           Send call = link.head;
           FunctionElement target = elements[call];
           List<AstConstant> compiledArguments =
               evaluateArgumentsToConstructor(
-                  call, elements.getSelector(call).callStructure,
-                  call.arguments, target,
+                  call, elements.getSelector(call), call.arguments, target,
                   compileArgument: evaluateConstant);
           evaluateSuperOrRedirectSend(compiledArguments, target);
           foundSuperOrRedirect = true;
         } else {
           // A field initializer.
           SendSet init = link.head;
           Link<Node> initArguments = init.arguments;
           assert(!initArguments.isEmpty && initArguments.tail.isEmpty);
           AstConstant fieldValue = evaluate(initArguments.head);
           updateFieldValue(init, elements[init], fieldValue);
         }
       }
     }
 
     if (!foundSuperOrRedirect) {
       // No super initializer found. Try to find the default constructor if
       // the class is not Object.
       ClassElement enclosingClass = constructor.enclosingClass;
       ClassElement superClass = enclosingClass.superclass;
       if (enclosingClass != compiler.objectClass) {
         assert(superClass != null);
         assert(superClass.resolutionState == STATE_DONE);
 
         FunctionElement targetConstructor =
             superClass.lookupDefaultConstructor();
         // If we do not find a default constructor, an error was reported
         // already and compilation will fail anyway. So just ignore that case.
         if (targetConstructor != null) {
+          Selector selector = new Selector.callDefaultConstructor();
           List<AstConstant> compiledArguments = evaluateArgumentsToConstructor(
-              functionNode, CallStructure.NO_ARGS,
-              const Link<Node>(), targetConstructor);
+              functionNode, selector, const Link<Node>(), targetConstructor);
           evaluateSuperOrRedirectSend(compiledArguments, targetConstructor);
         }
       }
     }
   }
 
   /**
    * Simulates the execution of the [constructor] with the given
    * [arguments] to obtain the field values that need to be passed to the
    * native JavaScript constructor.
@@ skipping 53 matching lines @@
   ConstantValue get value => expression.value;
 
   String toString() => expression.toString();
 }
 
 /// A synthetic constant used to recover from errors.
 class ErroneousAstConstant extends AstConstant {
   ErroneousAstConstant(Element element, Node node)
       : super(element, node, new ErroneousConstantExpression());
 }