Revert "Extract CallStructure from Selector."

pkg/compiler/lib/src/constants/expressions.dart

 // Copyright (c) 2014, 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.constants.expressions;
 
 import '../dart2jslib.dart' show assertDebugMode;
 import '../dart_types.dart';
 import '../elements/elements.dart' show
     Element,
     FunctionElement,
     VariableElement;
-import '../universe/universe.dart' show CallStructure;
+import '../universe/universe.dart' show Selector;
 import 'values.dart';
 
 /// An expression that is a compile-time constant.
 ///
 /// Whereas [ConstantValue] represent a compile-time value, a
 /// [ConstantExpression] represents an expression for creating a constant.
 ///
 /// There is no one-to-one mapping between [ConstantExpression] and
 /// [ConstantValue], because different expressions can denote the same constant.
 /// For instance, multiple `const` constructors may be used to create the same
@@ skipping 70 matching lines @@
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitMap(this, context);
   }
 }
 
 /// Invocation of a const constructor.
 class ConstructedConstantExpression extends ConstantExpression {
   final ConstantValue value;
   final InterfaceType type;
   final FunctionElement target;
-  final CallStructure callStructure;
+  final Selector selector;
   final List<ConstantExpression> arguments;
 
-  ConstructedConstantExpression(
-      this.value,
-      this.type,
-      this.target,
-      this.callStructure,
-      this.arguments) {
+  ConstructedConstantExpression(this.value,
+                      this.type,
+                      this.target,
+                      this.selector,
+                      this.arguments) {
     assert(type.element == target.enclosingClass);
   }
 
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitConstructed(this, context);
   }
 }
 
 /// String literal with juxtaposition and/or interpolations.
 // TODO(johnniwinther): Do we need this?
@@ skipping 249 matching lines @@
     sb.write('const ');
     sb.write(exp.target.enclosingClass.name);
     if (exp.target.name != '') {
       sb.write('.');
       sb.write(exp.target.name);
     }
     writeTypeArguments(exp.type);
     sb.write('(');
     bool needsComma = false;
 
-    int namedOffset = exp.callStructure.positionalArgumentCount;
+    int namedOffset = exp.selector.positionalArgumentCount;
     for (int index = 0; index < namedOffset; index++) {
       if (needsComma) {
         sb.write(', ');
       }
       visit(exp.arguments[index]);
       needsComma = true;
     }
-    for (int index = 0; index < exp.callStructure.namedArgumentCount; index++) {
+    for (int index = 0; index < exp.selector.namedArgumentCount; index++) {
       if (needsComma) {
         sb.write(', ');
       }
-      sb.write(exp.callStructure.namedArguments[index]);
+      sb.write(exp.selector.namedArguments[index]);
       sb.write(': ');
       visit(exp.arguments[namedOffset + index]);
       needsComma = true;
     }
     sb.write(')');
   }
 
   @override
   void visitConcatenate(ConcatenateConstantExpression exp, [_]) {
     sb.write(exp.value.unparse());
@@ skipping 55 matching lines @@
   void visitConditional(ConditionalConstantExpression exp, [_]) {
     write(exp, exp.condition, leftAssociative: false);
     sb.write(' ? ');
     write(exp, exp.trueExp);
     sb.write(' : ');
     write(exp, exp.falseExp);
   }
 
   String toString() => sb.toString();
 }