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

pkg/compiler/lib/src/universe/universe.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.
 
 library universe;
 
 import 'dart:collection';
 
+import '../common/names.dart' show
+    Identifiers,
+    Names,
+    Selectors;
 import '../compiler.dart' show
     Compiler;
 import '../diagnostics/invariant.dart' show
     invariant;
 import '../diagnostics/spannable.dart' show
     SpannableAssertionFailure;
 import '../elements/elements.dart';
 import '../dart_types.dart';
 import '../types/types.dart';
 import '../tree/tree.dart';
@@ skipping 647 matching lines @@
   int get namedArgumentCount => callStructure.namedArgumentCount;
   int get positionalArgumentCount => callStructure.positionalArgumentCount;
   List<String> get namedArguments => callStructure.namedArguments;
 
   String get name => memberName.text;
 
   LibraryElement get library => memberName.library;
 
   static const Name INDEX_NAME = const PublicName("[]");
   static const Name INDEX_SET_NAME = const PublicName("[]=");
-  static const Name CALL_NAME = const PublicName(Compiler.CALL_OPERATOR_NAME);
+  static const Name CALL_NAME = Names.call;
 
   Selector.internal(this.kind,
                     this.memberName,
                     this.callStructure,
                     this.hashCode) {
     assert(kind == SelectorKind.INDEX ||
            (memberName != INDEX_NAME && memberName != INDEX_SET_NAME));
     assert(kind == SelectorKind.OPERATOR ||
            kind == SelectorKind.INDEX ||
            !Elements.isOperatorName(memberName.text) ||
@@ skipping 23 matching lines @@
         return existing;
       }
     }
     Selector result = new Selector.internal(
         kind, name, callStructure, hashCode);
     list.add(result);
     return result;
   }
 
   factory Selector.fromElement(Element element) {
-    String name = element.name;
+    Name name = new Name(element.name, element.library);
     if (element.isFunction) {
-      if (name == '[]') {
+      if (name == INDEX_NAME) {
         return new Selector.index();
-      } else if (name == '[]=') {
+      } else if (name == INDEX_SET_NAME) {
         return new Selector.indexSet();
       }
       FunctionSignature signature =
           element.asFunctionElement().functionSignature;
       int arity = signature.parameterCount;
       List<String> namedArguments = null;
       if (signature.optionalParametersAreNamed) {
         namedArguments =
             signature.orderedOptionalParameters.map((e) => e.name).toList();
       }
       if (element.isOperator) {
         // Operators cannot have named arguments, however, that doesn't prevent
         // a user from declaring such an operator.
         return new Selector(
             SelectorKind.OPERATOR,
-            new PublicName(name),
+            name,
             new CallStructure(arity, namedArguments));
       } else {
         return new Selector.call(
-            name, element.library, arity, namedArguments);
+            name, arity, namedArguments);
       }
     } else if (element.isSetter) {
-      return new Selector.setter(name, element.library);
+      return new Selector.setter(name);
     } else if (element.isGetter) {
-      return new Selector.getter(name, element.library);
+      return new Selector.getter(name);
     } else if (element.isField) {
-      return new Selector.getter(name, element.library);
+      return new Selector.getter(name);
     } else if (element.isConstructor) {
-      return new Selector.callConstructor(name, element.library);
+      return new Selector.callConstructor(name);
     } else {
       throw new SpannableAssertionFailure(
           element, "Can't get selector from $element");
     }
   }
 
-  factory Selector.getter(String name, LibraryElement library)
+  factory Selector.getter(Name name)
       => new Selector(SelectorKind.GETTER,
-                      new Name(name, library),
+                      name.getter,
                       CallStructure.NO_ARGS);
 
   factory Selector.getterFrom(Selector selector)
       => new Selector(SelectorKind.GETTER,
                       selector.memberName.getter,
                       CallStructure.NO_ARGS);
 
-  factory Selector.setter(String name, LibraryElement library)
+  factory Selector.setter(Name name)
       => new Selector(SelectorKind.SETTER,
-                      new Name(name, library, isSetter: true),
+                      name.setter,
                       CallStructure.ONE_ARG);
 
   factory Selector.unaryOperator(String name) => new Selector(
       SelectorKind.OPERATOR,
       new PublicName(Elements.constructOperatorName(name, true)),
       CallStructure.NO_ARGS);
 
   factory Selector.binaryOperator(String name) => new Selector(
       SelectorKind.OPERATOR,
       new PublicName(Elements.constructOperatorName(name, false)),
       CallStructure.ONE_ARG);
 
   factory Selector.index()
       => new Selector(SelectorKind.INDEX, INDEX_NAME,
                       CallStructure.ONE_ARG);
 
   factory Selector.indexSet()
       => new Selector(SelectorKind.INDEX, INDEX_SET_NAME,
                       CallStructure.TWO_ARGS);
 
-  factory Selector.call(String name,
-                        LibraryElement library,
+  factory Selector.call(Name name,
                         int arity,
                         [List<String> namedArguments])
-      => new Selector(SelectorKind.CALL,
-          new Name(name, library),
+      => new Selector(SelectorKind.CALL, name,
           new CallStructure(arity, namedArguments));
 
   factory Selector.callClosure(int arity, [List<String> namedArguments])
       => new Selector(SelectorKind.CALL, CALL_NAME,
                       new CallStructure(arity, namedArguments));
 
   factory Selector.callClosureFrom(Selector selector)
       => new Selector(SelectorKind.CALL, CALL_NAME, selector.callStructure);
 
-  factory Selector.callConstructor(String name, LibraryElement library,
+  factory Selector.callConstructor(Name name,
                                    [int arity = 0,
                                     List<String> namedArguments])
-      => new Selector(SelectorKind.CALL, new Name(name, library),
+      => new Selector(SelectorKind.CALL, name,
                       new CallStructure(arity, namedArguments));
 
   factory Selector.callDefaultConstructor()
       => new Selector(
           SelectorKind.CALL,
           const PublicName(''),
           CallStructure.NO_ARGS);
 
   bool get isGetter => kind == SelectorKind.GETTER;
   bool get isSetter => kind == SelectorKind.SETTER;
@@ skipping 87 matching lines @@
     // Add bits from the call structure.
     return Hashing.mixHashCodeBits(hash, callStructure.hashCode);
   }
 
   String toString() {
     return 'Selector($kind, $name, ${callStructure.structureToString()})';
   }
 
   Selector toCallSelector() => new Selector.callClosureFrom(this);
 }