Extract CallStructure from Selector.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.dart

 // Copyright (c) 2013, 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.
 
 library dart2js.ir_builder_task;
 
 import '../closure.dart' as closurelib;
 import '../closure.dart' hide ClosureScope;
 import '../constants/expressions.dart';
 import '../dart_types.dart';
 import '../dart2jslib.dart';
 import '../elements/elements.dart';
 import '../elements/modelx.dart' show SynthesizedConstructorElementX,
     ConstructorBodyElementX, FunctionSignatureX;
 import '../io/source_file.dart';
 import '../io/source_information.dart';
 import '../js_backend/js_backend.dart' show JavaScriptBackend;
 import '../resolution/semantic_visitor.dart';
 import '../resolution/operators.dart' as op;
 import '../scanner/scannerlib.dart' show Token, isUserDefinableOperator;
 import '../tree/tree.dart' as ast;
-import '../universe/universe.dart' show SelectorKind;
+import '../universe/universe.dart' show SelectorKind, CallStructure;
 import 'cps_ir_nodes.dart' as ir;
 import 'cps_ir_builder.dart';
 
 /**
  * This task iterates through all resolved elements and builds [ir.Node]s. The
  * nodes are stored in the [nodes] map and accessible through [hasIr] and
  * [getIr].
  *
  * The functionality of the IrNodes is added gradually, therefore elements might
  * have an IR or not, depending on the language features that are used. For
@@ skipping 147 matching lines @@
   ClosureEnvironment getClosureEnvironment();
 
   /// Normalizes the argument list to a static invocation (i.e. where the target
   /// element is known).
   ///
   /// For the JS backend, inserts default arguments and normalizes order of
   /// named arguments.
   ///
   /// For the Dart backend, returns [arguments].
   List<ir.Primitive> normalizeStaticArguments(
-      Selector selector,
+      CallStructure callStructure,
       FunctionElement target,
       List<ir.Primitive> arguments);
 
   /// Normalizes the argument list of a dynamic invocation (i.e. where the
   /// target element is unknown).
   ///
   /// For the JS backend, normalizes order of named arguments.
   ///
   /// For the Dart backend, returns [arguments].
   List<ir.Primitive> normalizeDynamicArguments(
@@ skipping 716 matching lines @@
       ast.Node argument,
       _) {
     return irBuilder.buildNegation(
         translateSuperBinary(function, op.BinaryOperator.NOT_EQ, argument));
   }
 
   @override
   ir.Primitive visitUnary(ast.Send node,
                           op.UnaryOperator operator, ast.Node expression, _) {
     // TODO(johnniwinther): Clean up the creation of selectors.
-    Selector selector =
-        new Selector(SelectorKind.OPERATOR, operator.selectorName, null, 0);
+    Selector selector = new Selector(
+        SelectorKind.OPERATOR,
+        new PublicName(operator.selectorName),
+        CallStructure.NO_ARGS);
     ir.Primitive receiver = translateReceiver(expression);
     return irBuilder.buildDynamicInvocation(receiver, selector, const []);
   }
 
   @override
   ir.Primitive visitSuperUnary(
       ast.Send node,
       op.UnaryOperator operator,
       FunctionElement function,
       _) {
     // TODO(johnniwinther): Clean up the creation of selectors.
-    Selector selector =
-        new Selector(SelectorKind.OPERATOR, operator.selectorName, null, 0);
+    Selector selector = new Selector(
+        SelectorKind.OPERATOR,
+        new PublicName(operator.selectorName),
+        CallStructure.NO_ARGS);
     return irBuilder.buildSuperInvocation(function, selector, const []);
   }
 
   // TODO(johnniwinther): Handle this in the [IrBuilder] to ensure the correct
   // semantic correlation between arguments and invocation.
   List<ir.Primitive> translateDynamicArguments(ast.NodeList nodeList,
                                                Selector selector) {
     List<ir.Primitive> arguments = nodeList.nodes.mapToList(visit);
     return normalizeDynamicArguments(selector, arguments);
   }
 
   // TODO(johnniwinther): Handle this in the [IrBuilder] to ensure the correct
   // semantic correlation between arguments and invocation.
   List<ir.Primitive> translateStaticArguments(ast.NodeList nodeList,
                                               Element element,
-                                              Selector selector) {
+                                              CallStructure callStructure) {
     List<ir.Primitive> arguments = nodeList.nodes.mapToList(visit);
-    return normalizeStaticArguments(selector, element, arguments);
+    return normalizeStaticArguments(callStructure, element, arguments);
   }
 
   ir.Primitive translateCallInvoke(ir.Primitive target,
                                    ast.NodeList arguments,
                                    Selector selector) {
 
     return irBuilder.buildCallInvocation(target, selector,
         translateDynamicArguments(arguments, selector));
   }
 
@@ skipping 55 matching lines @@
       ast.Send node,
       MethodElement function,
       ast.NodeList arguments,
       Selector selector,
       _) {
     // TODO(karlklose): support foreign functions.
     if (function.isForeign(compiler.backend)) {
       return giveup(node, 'handleStaticFunctionInvoke: foreign: $function');
     }
     return irBuilder.buildStaticInvocation(function, selector,
-        translateStaticArguments(arguments, function, selector),
+        translateStaticArguments(arguments, function, selector.callStructure),
         sourceInformation: sourceInformationBuilder.buildCall(node));
   }
 
   @override
   ir.Primitive handleStaticGetterInvoke(
       ast.Send node,
       FunctionElement getter,
       ast.NodeList arguments,
       Selector selector,
       _) {
@@ skipping 661 matching lines @@
 
   @override
   ir.Primitive handleConstructorInvoke(
       ast.NewExpression node,
       ConstructorElement constructor,
       DartType type,
       ast.NodeList arguments,
       Selector selector, _) {
     List<ir.Primitive> arguments =
         node.send.arguments.mapToList(visit, growable:false);
-    arguments = normalizeStaticArguments(selector, constructor, arguments);
+    arguments = normalizeStaticArguments(
+        selector.callStructure, constructor, arguments);
     return irBuilder.buildConstructorInvocation(
         constructor, selector, type, arguments);
   }
 
   ir.Primitive visitStringJuxtaposition(ast.StringJuxtaposition node) {
     assert(irBuilder.isOpen);
     ir.Primitive first = visit(node.first);
     ir.Primitive second = visit(node.second);
     return irBuilder.buildStringConcatenation([first, second]);
   }
@@ skipping 279 matching lines @@
         giveup(null, 'cannot handle synthetic forwarding constructors');
       }
     }
 
     IrBuilder builder = makeIRBuilder(node, element);
 
     return withBuilder(builder, () => _makeFunctionBody(element, node));
   }
 
   List<ir.Primitive> normalizeStaticArguments(
-      Selector selector,
+      CallStructure callStructure,
       FunctionElement target,
       List<ir.Primitive> arguments) {
     return arguments;
   }
 
   List<ir.Primitive> normalizeDynamicArguments(
       Selector selector,
       List<ir.Primitive> arguments) {
     return arguments;
   }
@@ skipping 510 matching lines @@
   ir.Primitive translateDefaultValue(ParameterElement parameter) {
     if (parameter.initializer == null) {
       return irBuilder.buildNullLiteral();
     } else {
       return inlineConstant(parameter.executableContext, parameter.initializer);
     }
   }
 
   /// Inserts default arguments and normalizes order of named arguments.
   List<ir.Primitive> normalizeStaticArguments(
-      Selector selector,
+      CallStructure callStructure,
       FunctionElement target,
       List<ir.Primitive> arguments) {
     target = target.implementation;
     FunctionSignature signature = target.functionSignature;
     if (!signature.optionalParametersAreNamed &&
         signature.parameterCount == arguments.length) {
       // Optimization: don't copy the argument list for trivial cases.
       return arguments;
     }
 
@@ skipping 12 matching lines @@
         } else {
           result.add(translateDefaultValue(element));
         }
       });
     } else {
       int offset = i;
       // Iterate over the optional parameters of the signature, and try to
       // find them in [compiledNamedArguments]. If found, we use the
       // value in the temporary list, otherwise the default value.
       signature.orderedOptionalParameters.forEach((ParameterElement element) {
-        int nameIndex = selector.namedArguments.indexOf(element.name);
+        int nameIndex = callStructure.namedArguments.indexOf(element.name);
         if (nameIndex != -1) {
           int translatedIndex = offset + nameIndex;
           result.add(arguments[translatedIndex]);
         } else {
           result.add(translateDefaultValue(element));
         }
       });
     }
     return result;
   }
 
   /// Normalizes order of named arguments.
   List<ir.Primitive> normalizeDynamicArguments(
       Selector selector,
       List<ir.Primitive> arguments) {
-    assert(arguments.length == selector.argumentCount);
+    CallStructure callStructure = selector.callStructure;
+    assert(arguments.length == callStructure.argumentCount);
     // Optimization: don't copy the argument list for trivial cases.
-    if (selector.namedArguments.isEmpty) return arguments;
+    if (callStructure.namedArguments.isEmpty) return arguments;
     List<ir.Primitive> result = <ir.Primitive>[];
-    for (int i=0; i < selector.positionalArgumentCount; i++) {
+    for (int i=0; i < callStructure.positionalArgumentCount; i++) {
       result.add(arguments[i]);
     }
-    for (String argName in selector.getOrderedNamedArguments()) {
-      int nameIndex = selector.namedArguments.indexOf(argName);
-      int translatedIndex = selector.positionalArgumentCount + nameIndex;
+    for (String argName in callStructure.getOrderedNamedArguments()) {
+      int nameIndex = callStructure.namedArguments.indexOf(argName);
+      int translatedIndex = callStructure.positionalArgumentCount + nameIndex;
       result.add(arguments[translatedIndex]);
     }
     return result;
   }
 
   @override
   ir.Primitive buildReifyTypeVariable(ir.Primitive target,
                                       TypeVariableType variable) {
     ir.Primitive typeArgument =
         irBuilder.buildTypeVariableAccess(target, variable);
@@ skipping 37 matching lines @@
   SourceInformation buildCall(ast.Node node) {
     return new PositionSourceInformation(
         new TokenSourceLocation(sourceFile, node.getBeginToken(), name));
   }
 
   @override
   SourceInformationBuilder forContext(AstElement element) {
     return new PositionSourceInformationBuilder(element);
   }
 }