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

pkg/compiler/lib/src/ssa/builder.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.
 
 part of ssa;
 
 class SsaFunctionCompiler implements FunctionCompiler {
   final SsaCodeGeneratorTask generator;
   final SsaBuilderTask builder;
   final SsaOptimizerTask optimizer;
@@ skipping 2453 matching lines @@
       return new HTypeConversion.withTypeRepresentation(type, kind, subtype,
           original, typeVariable);
     } else if (type.isFunctionType) {
       String name = kind == HTypeConversion.CAST_TYPE_CHECK
           ? '_asCheck' : '_assertCheck';
 
       List<HInstruction> arguments =
           <HInstruction>[buildFunctionType(type), original];
       pushInvokeDynamic(
           null,
-          new Selector.call(name, backend.jsHelperLibrary, 1),
+          new Selector.call(new Name(name, backend.jsHelperLibrary), 1),
           null,
           arguments);
 
       return new HTypeConversion(type, kind, original.instructionType, pop());
     } else {
       return original.convertType(compiler, type, kind);
     }
   }
 
   HInstruction _trustType(HInstruction original, DartType type) {
@@ skipping 1254 matching lines @@
   }
 
   HInstruction buildIsNode(ast.Node node,
                            DartType type,
                            HInstruction expression) {
     type = localsHandler.substInContext(type).unalias(compiler);
     if (type.isFunctionType) {
       List arguments = [buildFunctionType(type), expression];
       pushInvokeDynamic(
           node,
-          new Selector.call('_isTest', backend.jsHelperLibrary, 1),
+          new Selector.call(new Name('_isTest', backend.jsHelperLibrary), 1),
           null,
           arguments);
       return new HIs.compound(type, expression, pop(), backend.boolType);
     } else if (type.isTypeVariable) {
       HInstruction runtimeType = addTypeVariableReference(type);
       Element helper = backend.getCheckSubtypeOfRuntimeType();
       List<HInstruction> inputs = <HInstruction>[expression, runtimeType];
       pushInvokeStatic(null, helper, inputs, typeMask: backend.boolType);
       HInstruction call = pop();
       return new HIs.variable(type, expression, call, backend.boolType);
@@ skipping 633 matching lines @@
                            targetCanThrow: false)
         ..sourceInformation = sourceInformation);
   }
 
   generateSuperNoSuchMethodSend(ast.Send node,
                                 Selector selector,
                                 List<HInstruction> arguments) {
     String name = selector.name;
 
     ClassElement cls = currentNonClosureClass;
-    Element element = cls.lookupSuperMember(Compiler.NO_SUCH_METHOD);
+    Element element = cls.lookupSuperMember(Identifiers.noSuchMethod_);
     if (compiler.enabledInvokeOn
         && element.enclosingElement.declaration != compiler.objectClass) {
       // Register the call as dynamic if [noSuchMethod] on the super
       // class is _not_ the default implementation from [Object], in
       // case the [noSuchMethod] implementation calls
       // [JSInvocationMirror._invokeOn].
       registry.registerSelectorUse(selector);
     }
     String publicName = name;
     if (selector.isSetter) publicName += '=';
@@ skipping 22 matching lines @@
     pushInvokeStatic(null,
                      createInvocationMirror,
                      [graph.addConstant(nameConstant, compiler),
                       graph.addConstantStringFromName(internalName, compiler),
                       graph.addConstant(kindConstant, compiler),
                       argumentsInstruction,
                       argumentNamesInstruction],
                      typeMask: backend.dynamicType);
 
     var inputs = <HInstruction>[pop()];
-    push(buildInvokeSuper(compiler.noSuchMethodSelector, element, inputs));
+    push(buildInvokeSuper(Selectors.noSuchMethod_, element, inputs));
   }
 
   /// Generate a call to a super method or constructor.
   void generateSuperInvoke(ast.Send node,
                            FunctionElement function,
                            SourceInformation sourceInformation) {
     // TODO(5347): Try to avoid the need for calling [implementation] before
     // calling [makeStaticArgumentList].
     Selector selector = elements.getSelector(node);
     assert(invariant(node,
@@ skipping 2662 matching lines @@
     void buildUpdate() {};
 
     buildProtectedByFinally(() {
       handleLoop(node,
                  buildInitializer,
                  buildCondition,
                  buildUpdate,
                  buildBody);
     }, () {
       pushInvokeDynamic(node,
-          new Selector.call("cancel", null, 0),
+          Selectors.cancel,
           null,
           [streamIterator]);
       push(new HAwait(pop(), new TypeMask.subclass(compiler.objectClass,
           compiler.world)));
       pop();
     });
   }
 
   visitSyncForIn(ast.SyncForIn node) {
     // The 'get iterator' selector for this node has the inferred receiver type.
@@ skipping 1151 matching lines @@
     //      conversions.
     //   2. The value can be primitive, because the library stringifier has
     //      fast-path code for most primitives.
     if (expression.canBePrimitive(compiler)) {
       append(stringify(node, expression));
       return;
     }
 
     // If the `toString` method is guaranteed to return a string we can call it
     // directly.
-    Selector selector = new Selector.call('toString', null, 0);
+    Selector selector = Selectors.toString_;
     TypeMask type = TypeMaskFactory.inferredTypeForSelector(
         selector, expression.instructionType, compiler);
     if (type.containsOnlyString(compiler.world)) {
       builder.pushInvokeDynamic(
-          node, selector, expression.instructionType, <HInstruction>[expression]);
+          node, selector,
+          expression.instructionType, <HInstruction>[expression]);
       append(builder.pop());
       return;
     }
 
     append(stringify(node, expression));
   }
 
   void visitStringInterpolation(ast.StringInterpolation node) {
     node.visitChildren(this);
   }
@@ skipping 536 matching lines @@
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
     ClassElement cls = backend.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls, classWorld)));
   }
 }