Move common identifiers, names and selectors to a separate library.

pkg/compiler/lib/src/cps_ir/cps_ir_builder.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;
 
+import '../common/names.dart' show
+    Names;
 import '../compile_time_constants.dart' show
     BackendConstantEnvironment;
 import '../constants/constant_system.dart';
 import '../constants/values.dart' show
     ConstantValue,
     PrimitiveConstantValue;
 import '../dart_types.dart';
 import '../diagnostics/invariant.dart' show
     invariant;
 import '../elements/elements.dart';
@@ skipping 805 matching lines @@
     return _buildInvokeSuper(method, selector, arguments, sourceInformation);
   }
 
   /// Create a read access of the [method] on the super class, i.e. a
   /// closurization of [method].
   ir.Primitive buildSuperMethodGet(MethodElement method,
                                    {SourceInformation sourceInformation}) {
     // TODO(johnniwinther): This should have its own ir node.
     return _buildInvokeSuper(
         method,
-        new Selector.getter(method.name, method.library),
+        new Selector.getter(method.memberName),
         const <ir.Primitive>[],
         sourceInformation);
   }
 
   /// Create a getter invocation of the [getter] on the super class.
   ir.Primitive buildSuperGetterGet(MethodElement getter,
                                    SourceInformation sourceInformation) {
     // TODO(johnniwinther): This should have its own ir node.
     return _buildInvokeSuper(
         getter,
-        new Selector.getter(getter.name, getter.library),
+        new Selector.getter(getter.memberName),
         const <ir.Primitive>[],
         sourceInformation);
   }
 
   /// Create an setter invocation of the [setter] on the super class with
   /// [value].
   ir.Primitive buildSuperSetterSet(MethodElement setter,
                                    ir.Primitive value,
                                    {SourceInformation sourceInformation}) {
     // TODO(johnniwinther): This should have its own ir node.
     _buildInvokeSuper(
         setter,
-        new Selector.setter(setter.name, setter.library),
+        new Selector.setter(setter.memberName),
         <ir.Primitive>[value],
         sourceInformation);
     return value;
   }
 
   /// Create an invocation of the index [method] on the super class with
   /// the provided [index].
   ir.Primitive buildSuperIndex(MethodElement method,
                                ir.Primitive index,
                                {SourceInformation sourceInformation}) {
@@ skipping 140 matching lines @@
   /// initialized yet.
   ir.Primitive buildStaticFieldLazyGet(FieldElement field,
                                        SourceInformation sourceInformation) {
     return _continueWithExpression(
         (k) => new ir.GetLazyStatic(field, k, sourceInformation));
   }
 
   /// Create a getter invocation of the static [getter].
   ir.Primitive buildStaticGetterGet(MethodElement getter,
                                     SourceInformation sourceInformation) {
-    Selector selector = new Selector.getter(getter.name, getter.library);
+    Selector selector = new Selector.getter(getter.memberName);
     return _buildInvokeStatic(
         getter, selector, const <ir.Primitive>[], sourceInformation);
   }
 
   /// Create a read access of the static [function], i.e. a closurization of
   /// [function].
   ir.Primitive buildStaticFunctionGet(MethodElement function,
                                       {SourceInformation sourceInformation}) {
     return addPrimitive(new ir.GetStatic(function, sourceInformation));
   }
 
   /// Create a write access to the static [field] with the [value].
   ir.Primitive buildStaticFieldSet(FieldElement field,
                                    ir.Primitive value,
                                    [SourceInformation sourceInformation]) {
     addPrimitive(new ir.SetStatic(field, value, sourceInformation));
     return value;
   }
 
   /// Create a setter invocation of the static [setter] with the [value].
   ir.Primitive buildStaticSetterSet(MethodElement setter,
                                     ir.Primitive value,
                                     {SourceInformation sourceInformation}) {
-    Selector selector = new Selector.setter(setter.name, setter.library);
+    Selector selector = new Selector.setter(setter.memberName);
     _buildInvokeStatic(
         setter, selector, <ir.Primitive>[value], sourceInformation);
     return value;
   }
 
   /// Create an erroneous invocation where argument structure is defined by
   /// [selector] and the argument values are defined by [arguments].
   // TODO(johnniwinther): Make this more fine-grained.
   ir.Primitive buildErroneousInvocation(
       Element element,
@@ skipping 297 matching lines @@
     // let prim expressionReceiver = [[e]] in
     // let cont iteratorInvoked(iterator) =
     //     [ ]
     // in expressionReceiver.iterator () iteratorInvoked
     ir.Primitive expressionReceiver = buildExpression(this);
     List<ir.Primitive> emptyArguments = <ir.Primitive>[];
     ir.Parameter iterator = new ir.Parameter(null);
     ir.Continuation iteratorInvoked = new ir.Continuation([iterator]);
     add(new ir.LetCont(iteratorInvoked,
         new ir.InvokeMethod(expressionReceiver,
-            new Selector.getter("iterator", null),
+            new Selector.getter(const PublicName("iterator")),
             iteratorMask,
             emptyArguments,
             iteratorInvoked)));
 
     // Fill with:
     // let cont loop(x, ...) =
     //     let cont moveNextInvoked(condition) =
     //         [ ]
     //     in iterator.moveNext () moveNextInvoked
     // in loop(v, ...)
     JumpCollector loop = new BackwardJumpCollector(environment, target: target);
     addRecursiveContinuation(loop);
     ir.Parameter condition = new ir.Parameter(null);
     ir.Continuation moveNextInvoked = new ir.Continuation([condition]);
     add(new ir.LetCont(moveNextInvoked,
         new ir.InvokeMethod(iterator,
-            new Selector.call("moveNext", null, 0),
+            new Selector.call(Names.moveNext, 0),
             moveNextMask,
             emptyArguments,
             moveNextInvoked)));
 
     // As a delimited term, build:
     // <<BODY>> =
     //   _enterScope();
     //   [[variableDeclaration]]
     //   let cont currentInvoked(currentValue) =
     //       [[a = currentValue]];
     //       [ ]
     //   in iterator.current () currentInvoked
     IrBuilder bodyBuilder = makeDelimitedBuilder();
     bodyBuilder._enterScope(closureScope);
     if (buildVariableDeclaration != null) {
       buildVariableDeclaration(bodyBuilder);
     }
     ir.Parameter currentValue = new ir.Parameter(null);
     ir.Continuation currentInvoked = new ir.Continuation([currentValue]);
     bodyBuilder.add(new ir.LetCont(currentInvoked,
         new ir.InvokeMethod(
             iterator,
-            new Selector.getter("current", null),
+            new Selector.getter(Names.current),
             currentMask,
             emptyArguments, currentInvoked)));
     // TODO(sra): Does this cover all cases? The general setter case include
     // super.
     // TODO(johnniwinther): Extract this as a provided strategy.
     if (Elements.isLocal(variableElement)) {
       bodyBuilder.buildLocalVariableSet(variableElement, currentValue);
     } else if (Elements.isErroneous(variableElement)) {
       bodyBuilder.buildErroneousInvocation(variableElement,
-          new Selector.setter(variableElement.name, variableElement.library),
+          new Selector.setter(
+              new Name(variableElement.name, variableElement.library)),
           <ir.Primitive>[currentValue]);
     } else if (Elements.isStaticOrTopLevel(variableElement)) {
       if (variableElement.isField) {
         bodyBuilder.buildStaticFieldSet(variableElement, currentValue);
       } else {
         bodyBuilder.buildStaticSetterSet(variableElement, currentValue);
       }
     } else {
       ir.Primitive receiver = bodyBuilder.buildThis();
       assert(receiver != null);
@@ skipping 1064 matching lines @@
 
   ir.Primitive buildSuperFieldGet(FieldElement target) {
     return addPrimitive(new ir.GetField(buildThis(), target));
   }
 
   ir.Primitive buildSuperFieldSet(FieldElement target, ir.Primitive value) {
     addPrimitive(new ir.SetField(buildThis(), target, value));
     return value;
   }
 
-  ir.Primitive buildInvokeDirectly(FunctionElement target,
+  ir.Primitive buildInvokeDirectly(MethodElement target,
                                    ir.Primitive receiver,
                                    List<ir.Primitive> arguments,
                                    {SourceInformation sourceInformation}) {
     assert(isOpen);
     Selector selector =
-        new Selector.call(target.name, target.library, arguments.length);
+        new Selector.call(target.memberName, arguments.length);
     return _continueWithExpression(
         (k) => new ir.InvokeMethodDirectly(
             receiver, target, selector, arguments, k, sourceInformation));
   }
 
   /// Loads parameters to a constructor body into the environment.
   ///
   /// The header for a constructor body differs from other functions in that
   /// some parameters are already boxed, and the box is passed as an argument
   /// instead of being created in the header.
@@ skipping 290 matching lines @@
 }
 
 class SwitchCaseInfo {
   final List<ir.Primitive> constants = <ir.Primitive>[];
   final SubbuildFunction buildBody;
 
   SwitchCaseInfo(this.buildBody);
 
   void addConstant(ir.Primitive constant) => constants.add(constant);
 }