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

pkg/compiler/lib/src/enqueue.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 dart2js.enqueue;
 
 import 'dart:collection' show
     Queue;
 
+import 'common/names.dart' show
+    Identifiers;
 import 'common/work.dart' show
     ItemCompilationContext,
     WorkItem;
 import 'common/tasks.dart' show
     CompilerTask,
     DeferredAction,
     DeferredTask;
 import 'common/registry.dart' show
     Registry;
 import 'common/codegen.dart' show
@@ skipping 15 matching lines @@
     ClassElement,
     ConstructorElement,
     Element,
     Elements,
     FunctionElement,
     LibraryElement,
     LocalFunctionElement,
     Member,
     MemberElement,
     MethodElement,
+    Name,
     TypedElement,
     TypedefElement;
 import 'js/js.dart' as js;
 import 'native/native.dart' as native;
 import 'resolution/members.dart' show
     ResolverVisitor;
 import 'tree/tree.dart' show
     Send;
 import 'universe/universe.dart';
 import 'util/util.dart' show
@@ skipping 184 matching lines @@
       } else {
         // All field initializers must be resolved as they could
         // have an observable side-effect (and cannot be tree-shaken
         // away).
         addToWorkList(member);
         return;
       }
     } else if (member.isFunction) {
       FunctionElement function = member;
       function.computeType(compiler);
-      if (function.name == Compiler.NO_SUCH_METHOD) {
+      if (function.name == Identifiers.noSuchMethod_) {
         registerNoSuchMethod(function);
       }
-      if (function.name == Compiler.CALL_OPERATOR_NAME &&
+      if (function.name == Identifiers.call &&
           !cls.typeVariables.isEmpty) {
         registerCallMethodWithFreeTypeVariables(
             function, compiler.globalDependencies);
       }
       // If there is a property access with the same name as a method we
       // need to emit the method.
       if (universe.hasInvokedGetter(function, compiler.world)) {
         registerClosurizedMember(function, compiler.globalDependencies);
         addToWorkList(function);
         return;
@@ skipping 141 matching lines @@
         registerStaticUse(element.declaration);
       } else if (element.isInstanceMember) {
         // We need to enqueue all members matching this one in subclasses, as
         // well.
         // TODO(herhut): Use TypedSelector.subtype for enqueueing
         UniverseSelector selector = new UniverseSelector(
             new Selector.fromElement(element), null);
         registerSelectorUse(selector);
         if (element.isField) {
           UniverseSelector selector = new UniverseSelector(
-              new Selector.setter(element.name, element.library), null);
+              new Selector.setter(new Name(
+                  element.name, element.library, isSetter: true)), null);
           registerInvokedSetter(selector);
         }
       }
     }
   }
 
   /// Enqeue the member [element] if it is required for reflection.
   ///
   /// [enclosingWasIncluded] provides a hint whether the enclosing element was
   /// needed for reflection.
@@ skipping 388 matching lines @@
       } else if (uri == 'dart:async') {
         if (element.name == '_createTimer' ||
             element.name == '_createPeriodicTimer') {
           // The [:Timer:] class uses the event queue of the isolate
           // library, so we make sure that event queue is generated.
           enableIsolateSupport();
         }
       }
     }
 
-    if (element.isGetter && element.name == Compiler.RUNTIME_TYPE) {
+    if (element.isGetter && element.name == Identifiers.runtimeType_) {
       // Enable runtime type support if we discover a getter called runtimeType.
       // We have to enable runtime type before hitting the codegen, so
       // that constructors know whether they need to generate code for
       // runtime type.
       compiler.enabledRuntimeType = true;
       // TODO(ahe): Record precise dependency here.
       compiler.backend.registerRuntimeType(this, compiler.globalDependencies);
     } else if (element == compiler.functionApplyMethod) {
       compiler.enabledFunctionApply = true;
     }
@@ skipping 174 matching lines @@
   void processWorkItem(void f(WorkItem work), WorkItem work) {
     f(work);
   }
 }
 
 void removeFromSet(Map<String, Set<Element>> map, Element element) {
   Set<Element> set = map[element.name];
   if (set == null) return;
   set.remove(element);
 }