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

pkg/compiler/lib/src/resolution/class_members.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.resolution.compute_members;
 
+import '../common/names.dart' show
+    Identifiers;
 import '../compiler.dart' show
     Compiler,
     isPrivateName;
 import '../dart_types.dart';
 import '../diagnostics/invariant.dart' show
     invariant;
 import '../diagnostics/messages.dart' show
     MessageKind;
 import '../elements/elements.dart' show
     ClassElement,
@@ skipping 36 matching lines @@
     }
   }
 
   bool shouldSkipMember(MemberSignature member) {
     return member == null || shouldSkipName(member.name.text);
 
   }
 
   bool shouldSkipName(String name) {
     return computedMemberNames != null &&
-           computedMemberNames.contains(name);
+           // 'call' is implicitly contained in [computedMemberNames].
+           (name == Identifiers.call || computedMemberNames.contains(name));
   }
 
   /// Compute all members of [cls] with the given names.
   void computeMembersByName(String name, Setlet<Name> names) {
     computeMembers(name, names);
   }
 
   /// Compute all members of [cls] and checked that [cls] implements its
   /// interface unless it is abstract or declares a `noSuchMethod` method.
   void computeAllMembers() {
@@ skipping 225 matching lines @@
     // TODO(johnniwinther): If [cls] is not abstract, check that for all
     // interface members, there is a class member whose type is a subtype of
     // the interface member.
   }
 
   /// Checks that [cls], if it implements Function, has defined call().
   void checkImplementsFunctionWithCall() {
     assert(!cls.isAbstract);
 
     if (cls.asInstanceOf(compiler.functionClass) == null) return;
-    if (cls.lookupMember(Compiler.CALL_OPERATOR_NAME) != null) return;
+    if (cls.lookupMember(Identifiers.call) != null) return;
     // TODO(johnniwinther): Make separate methods for backend exceptions.
     // Avoid warnings on backend implementation classes for closures.
     if (compiler.backend.isBackendLibrary(cls.library)) return;
 
     reportMessage(compiler.functionClass, MessageKind.UNIMPLEMENTED_METHOD, () {
       compiler.reportWarning(cls, MessageKind.UNIMPLEMENTED_METHOD_ONE,
           {'class': cls.name,
-           'name': Compiler.CALL_OPERATOR_NAME,
-           'method': Compiler.CALL_OPERATOR_NAME,
+           'name': Identifiers.call,
+           'method': Identifiers.call,
            'declarer': compiler.functionClass.name});
     });
   }
 
   /// Checks that a class member exists for every interface member.
   void checkInterfaceImplementation();
 
   /// Check that [declared] is a valid override of [superMember].
   void checkValidOverride(Member declared, MemberSignature superMember) {
     if (superMember == null) {
@@ skipping 509 matching lines @@
     if (isMemberComputed(name)) return;
     if (isPrivateName(name)) {
       names..add(new Name(name, library))
            ..add(new Name(name, library, isSetter: true));
     }
     MembersCreator creator = _prepareCreator(compiler);
     creator.computeMembersByName(name, names);
     if (computedMemberNames == null) {
       computedMemberNames = _EMPTY_MEMBERS_NAMES;
     }
-    if (name != Compiler.CALL_OPERATOR_NAME) {
+    if (name != Identifiers.call) {
       Setlet<String> set;
       if (identical(computedMemberNames, _EMPTY_MEMBERS_NAMES)) {
         computedMemberNames = set = new Setlet<String>();
       } else {
         set = computedMemberNames;
       }
       set.add(name);
     }
   }
 
   void computeAllClassMembers(Compiler compiler) {
     if (areAllMembersComputed()) return;
     MembersCreator creator = _prepareCreator(compiler);
     creator.computeAllMembers();
     computedMemberNames = null;
     assert(invariant(this, areAllMembersComputed()));
   }
 
   bool areAllMembersComputed() {
     return computedMemberNames == null && classMembers != null;
   }
 
   bool isMemberComputed(String name) {
     if (computedMemberNames == null) {
       return classMembers != null;
     } else {
-      return name == Compiler.CALL_OPERATOR_NAME ||
+      return name == Identifiers.call ||
              computedMemberNames.contains(name);
     }
   }
 
   Member lookupClassMember(Name name) {
     assert(invariant(this,
         isMemberComputed(name.text),
         message: "Member ${name} has not been computed for $this."));
     return classMembers[name];
   }
@@ skipping 20 matching lines @@
         message: "Members have not been fully computed for $this."));
     if (interfaceMembersAreClassMembers) {
       classMembers.forEach((_, member) {
         if (!member.isStatic) f(member);
       });
     } else {
       interfaceMembers.forEach((_, member) => f(member));
     }
   }
 }