Move namer into javascript backend.

lib/compiler/implementation/ssa/codegen.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.
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
   SsaCodeGeneratorTask(JavaScriptBackend backend)
       : this.backend = backend,
@@ skipping 659 matching lines @@
   visitStatement(HInstruction node) {
     assert(!isGeneratingExpression);
     visit(node);
     if (!expressionStack.isEmpty()) {
       assert(expressionStack.length == 1);
       pushExpressionAsStatement(pop());
     }
   }
 
   void continueAsBreak(LabelElement target) {
-    pushStatement(new js.Break(compiler.namer.continueLabelName(target)));
+    pushStatement(new js.Break(backend.namer.continueLabelName(target)));
   }
 
   void implicitContinueAsBreak(TargetElement target) {
     pushStatement(new js.Break(
-        compiler.namer.implicitContinueLabelName(target)));
+        backend.namer.implicitContinueLabelName(target)));
   }
 
   void implicitBreakWithLabel(TargetElement target) {
-    pushStatement(new js.Break(compiler.namer.implicitBreakLabelName(target)));
+    pushStatement(new js.Break(backend.namer.implicitBreakLabelName(target)));
   }
 
   js.Statement wrapIntoLabels(js.Statement result, List<LabelElement> labels) {
     for (LabelElement label in labels) {
       if (label.isTarget) {
-        String breakLabelString = compiler.namer.breakLabelName(label);
+        String breakLabelString = backend.namer.breakLabelName(label);
         result = new js.LabeledStatement(breakLabelString, result);
       }
     }
     return result;
   }
 
 
   // The regular [visitIf] method implements the needed logic.
   bool visitIfInfo(HIfBlockInformation info) => false;
 
@@ skipping 239 matching lines @@
 
     currentContainer = body;
 
     // If [labeledBlockInfo.isContinue], the block is an artificial
     // block around the body of a loop with an update block, so that
     // continues of the loop can be written as breaks of the body
     // block.
     if (labeledBlockInfo.isContinue) {
       for (LabelElement label in labeledBlockInfo.labels) {
         if (label.isContinueTarget) {
-          String labelName = compiler.namer.continueLabelName(label);
+          String labelName = backend.namer.continueLabelName(label);
           result = new js.LabeledStatement(labelName, result);
           continueAction[label] = continueAsBreak;
           continueOverrides = continueOverrides.prepend(label);
         }
       }
       // For handling unlabeled continues from the body of a loop.
       // TODO(lrn): Consider recording whether the target is in fact
       // a target of an unlabeled continue, and not generate this if it isn't.
       TargetElement target = labeledBlockInfo.target;
-      String labelName = compiler.namer.implicitContinueLabelName(target);
+      String labelName = backend.namer.implicitContinueLabelName(target);
       result = new js.LabeledStatement(labelName, result);
       continueAction[target] = implicitContinueAsBreak;
       continueOverrides = continueOverrides.prepend(target);
     } else {
       for (LabelElement label in labeledBlockInfo.labels) {
         if (label.isBreakTarget) {
-          String labelName = compiler.namer.breakLabelName(label);
+          String labelName = backend.namer.breakLabelName(label);
           result = new js.LabeledStatement(labelName, result);
         }
       }
       TargetElement target = labeledBlockInfo.target;
       if (target.isSwitch) {
         // This is an extra block around a switch that is generated
         // as a nested if/else chain. We add an extra break target
         // so that case code can break.
-        String labelName = compiler.namer.implicitBreakLabelName(target);
+        String labelName = backend.namer.implicitBreakLabelName(target);
         result = new js.LabeledStatement(labelName, result);
         breakAction[target] = implicitBreakWithLabel;
       }
     }
 
     currentContainer = body;
     startLabeledBlock(labeledBlockInfo);
     generateStatements(labeledBlockInfo.body);
     endLabeledBlock(labeledBlockInfo);
 
@@ skipping 15 matching lines @@
   // to (if necessary).
   void wrapLoopBodyForContinue(HLoopBlockInformation info) {
     TargetElement target = info.target;
     if (target !== null && target.isContinueTarget) {
       js.Block oldContainer = currentContainer;
       js.Block body = new js.Block.empty();
       currentContainer = body;
       js.Statement result = body;
       for (LabelElement label in info.labels) {
         if (label.isContinueTarget) {
-          String labelName = compiler.namer.continueLabelName(label);
+          String labelName = backend.namer.continueLabelName(label);
           result = new js.LabeledStatement(labelName, result);
           continueAction[label] = continueAsBreak;
         }
       }
-      String labelName = compiler.namer.implicitContinueLabelName(target);
+      String labelName = backend.namer.implicitContinueLabelName(target);
       result = new js.LabeledStatement(labelName, result);
       continueAction[info.target] = implicitContinueAsBreak;
       visitBodyIgnoreLabels(info);
       continueAction.remove(info.target);
       for (LabelElement label in info.labels) {
         if (label.isContinueTarget) {
           continueAction.remove(label);
         }
       }
       currentContainer = oldContainer;
@@ skipping 298 matching lines @@
     if (action === null) return false;
     action(element);
     return true;
   }
 
   visitBreak(HBreak node) {
     assert(currentBlock.successors.length == 1);
     if (node.label !== null) {
       LabelElement label = node.label;
       if (!tryCallAction(breakAction, label)) {
-        pushStatement(new js.Break(compiler.namer.breakLabelName(label)), node);
+        pushStatement(new js.Break(backend.namer.breakLabelName(label)), node);
       }
     } else {
       TargetElement target = node.target;
       if (!tryCallAction(breakAction, target)) {
         pushStatement(new js.Break(null), node);
       }
     }
   }
 
   visitContinue(HContinue node) {
     assert(currentBlock.successors.length == 1);
     if (node.label !== null) {
       LabelElement label = node.label;
       if (!tryCallAction(continueAction, label)) {
         // TODO(floitsch): should this really be the breakLabelName?
-        pushStatement(new js.Continue(compiler.namer.breakLabelName(label)),
+        pushStatement(new js.Continue(backend.namer.breakLabelName(label)),
                       node);
       }
     } else {
       TargetElement target = node.target;
       if (!tryCallAction(continueAction, target)) {
         pushStatement(new js.Continue(null), node);
       }
     }
   }
 
@@ skipping 87 matching lines @@
     List<js.Expression> arguments;
 
     // Avoid adding the generative constructor name to the list of
     // seen selectors.
     if (node.inputs[0] is HForeignNew) {
       // TODO(ahe): The constructor name was statically resolved in
       // SsaBuilder.buildFactory. Is there a cleaner way to do this?
       methodName = name.slowToString();
       arguments = visitArguments(node.inputs);
     } else {
-      methodName = compiler.namer.instanceMethodInvocationName(
+      methodName = backend.namer.instanceMethodInvocationName(
           node.selector.library, name, node.selector);
       arguments = visitArguments(node.inputs);
       bool inLoop = node.block.enclosingLoopHeader !== null;
 
       // Register this invocation to collect the types used at all call sites.
       Selector selector = getOptimizedSelectorFor(node, node.selector);
       backend.registerDynamicInvocation(node, selector, types);
 
       // If we don't know what we're calling or if we are calling a getter,
       // we need to register that fact that we may be calling a closure
@@ skipping 29 matching lines @@
     if (receiverType !== null) {
       return new TypedSelector(receiverType, defaultSelector);
     } else {
       return defaultSelector;
     }
   }
 
   visitInvokeDynamicSetter(HInvokeDynamicSetter node) {
     use(node.receiver);
     Selector setter = node.selector;
-    String name = compiler.namer.setterName(setter.library, setter.name);
+    String name = backend.namer.setterName(setter.library, setter.name);
     push(jsPropertyCall(pop(), name, visitArguments(node.inputs)), node);
     world.registerDynamicSetter(
         setter.name, getOptimizedSelectorFor(node, setter));
   }
 
   visitInvokeDynamicGetter(HInvokeDynamicGetter node) {
     use(node.receiver);
     Selector getter = node.selector;
-    String name = compiler.namer.getterName(getter.library, getter.name);
+    String name = backend.namer.getterName(getter.library, getter.name);
     push(jsPropertyCall(pop(), name, visitArguments(node.inputs)), node);
     world.registerDynamicGetter(
         getter.name, getOptimizedSelectorFor(node, getter));
   }
 
   visitInvokeClosure(HInvokeClosure node) {
     use(node.receiver);
     push(jsPropertyCall(pop(),
-                        compiler.namer.closureInvocationName(node.selector),
+                        backend.namer.closureInvocationName(node.selector),
                         visitArguments(node.inputs)),
          node);
     Selector call = new Selector.callClosureFrom(node.selector);
     world.registerDynamicInvocation(call.name, call);
   }
 
   visitInvokeStatic(HInvokeStatic node) {
     if (true &&
         (node.typeCode() == HInstruction.INVOKE_STATIC_TYPECODE ||
          node.typeCode() == HInstruction.INVOKE_INTERCEPTOR_TYPECODE)) {
@@ skipping 10 matching lines @@
     // Remove the element and 'this'.
     int argumentCount = node.inputs.length - 2;
     if (superMethod.kind == ElementKind.FIELD) {
       ClassElement currentClass = work.element.getEnclosingClass();
       if (currentClass.isClosure()) {
         ClosureClassElement closure = currentClass;
         currentClass = closure.methodElement.getEnclosingClass();
       }
       String fieldName;
       if (currentClass.isShadowedByField(superMethod)) {
-        fieldName = compiler.namer.shadowedFieldName(superMethod);
+        fieldName = backend.namer.shadowedFieldName(superMethod);
       } else {
         LibraryElement library = superMethod.getLibrary();
         SourceString name = superMethod.name;
-        fieldName = compiler.namer.instanceFieldName(library, name);
+        fieldName = backend.namer.instanceFieldName(library, name);
       }
       use(node.inputs[1]);
       js.PropertyAccess access =
           new js.PropertyAccess.field(pop(), fieldName);
       if (node.isSetter) {
         use(node.value);
         push(new js.Assignment(access, pop()), node);
       } else {
         push(access, node);
       }
     } else {
       String methodName;
       if (superMethod.kind == ElementKind.FUNCTION ||
           superMethod.kind == ElementKind.GENERATIVE_CONSTRUCTOR) {
-        methodName = compiler.namer.instanceMethodName(
+        methodName = backend.namer.instanceMethodName(
             currentLibrary, superMethod.name, argumentCount);
       } else if (superMethod.kind == ElementKind.GETTER) {
         methodName =
-            compiler.namer.getterName(currentLibrary, superMethod.name);
+            backend.namer.getterName(currentLibrary, superMethod.name);
       } else {
         assert(superMethod.kind == ElementKind.SETTER);
         methodName =
-            compiler.namer.setterName(currentLibrary, superMethod.name);
+            backend.namer.setterName(currentLibrary, superMethod.name);
       }
-      String className = compiler.namer.isolateAccess(superClass);
+      String className = backend.namer.isolateAccess(superClass);
       js.VariableUse classReference = new js.VariableUse(className);
       js.PropertyAccess prototype =
           new js.PropertyAccess.field(classReference, "prototype");
       js.PropertyAccess method =
           new js.PropertyAccess.field(prototype, methodName);
       push(jsPropertyCall(method, "call", visitArguments(node.inputs)), node);
     }
     world.registerStaticUse(superMethod);
   }
 
   visitFieldGet(HFieldGet node) {
-    String name = compiler.namer.getName(node.element);
+    String name = backend.namer.getName(node.element);
     use(node.receiver);
     push(new js.PropertyAccess.field(pop(), name), node);
     HType receiverHType = types[node.receiver];
     DartType type = receiverHType.computeType(compiler);
     if (type != null) {
       world.registerFieldGetter(
           node.element.name, node.element.getLibrary(), type);
     }
   }
 
@@ skipping 11 matching lines @@
   }
 
   visitFieldSet(HFieldSet node) {
     if (work.element.isGenerativeConstructorBody() &&
         node.element.isMember() &&
         node.value.hasGuaranteedType() &&
         node.block.dominates(currentGraph.exit)) {
       backend.updateFieldConstructorSetters(node.element,
                                             node.value.guaranteedType);
     }
-    String name = compiler.namer.getName(node.element);
+    String name = backend.namer.getName(node.element);
     DartType type = types[node.receiver].computeType(compiler);
     if (type != null) {
       if (!work.element.isGenerativeConstructorBody()) {
         world.registerFieldSetter(
             node.element.name, node.element.getLibrary(), type);
       }
       // Determine the types seen so far for the field. If only number
       // types have been seen and the value of the field set is a
       // simple number computation only depending on that field, we
       // can safely keep the number type for the field.
@@ skipping 45 matching lines @@
 
   visitForeignNew(HForeignNew node) {
     int j = 0;
     node.element.forEachInstanceField(
       includeBackendMembers: true,
       includeSuperMembers: true,
       f: (ClassElement enclosingClass, Element member) {
         backend.updateFieldInitializers(member, types[node.inputs[j]]);
         j++;
       });
-    String jsClassReference = compiler.namer.isolateAccess(node.element);
+    String jsClassReference = backend.namer.isolateAccess(node.element);
     List<HInstruction> inputs = node.inputs;
     // We can't use 'visitArguments', since our arguments start at input[0].
     List<js.Expression> arguments = <js.Expression>[];
     for (int i = 0; i < inputs.length; i++) {
       use(inputs[i]);
       arguments.add(pop());
     }
     // TODO(floitsch): jsClassReference is an Access. We shouldn't treat it
     // as if it was a string.
     push(new js.New(new js.VariableUse(jsClassReference), arguments), node);
@@ skipping 15 matching lines @@
         push(new js.LiteralNull());
       } else if (constant.isString()) {
         // TODO(floitsch): get rid of the code buffer.
         CodeBuffer buffer = new CodeBuffer();
         handler.writeConstant(buffer, constant);
         push(new js.LiteralString(buffer.toString()));
       } else if (constant.isFunction()) {
         FunctionConstant function = constant;
         world.registerStaticUse(function.element);
         push(new js.VariableUse(
-            compiler.namer.isolateAccess(function.element)));
+            backend.namer.isolateAccess(function.element)));
       } else if (constant.isSentinel()) {
         // TODO(floitsch): get rid of the code buffer.
         CodeBuffer buffer = new CodeBuffer();
         handler.writeConstant(buffer, constant);
         push(new js.VariableUse(buffer.toString()));
       } else {
         compiler.internalError(
             "The compiler does not know how generate code for "
             "constant $constant");
       }
     } else {
       js.VariableUse currentIsolateUse =
-          new js.VariableUse(compiler.namer.CURRENT_ISOLATE);
+          new js.VariableUse(backend.namer.CURRENT_ISOLATE);
       push(new js.PropertyAccess.field(currentIsolateUse, name));
     }
   }
 
   visitConstant(HConstant node) {
     assert(isGenerateAtUseSite(node));
     generateConstant(node.constant);
   }
 
   visitLoopBranch(HLoopBranch node) {
@@ skipping 188 matching lines @@
       pushStatement(new js.If.noElse(test, thenBody), node);
     } else {
       generateThrowWithHelper('iae', node.value);
     }
   }
 
   void generateThrowWithHelper(String helperName, HInstruction argument) {
     Element helper = compiler.findHelper(new SourceString(helperName));
     world.registerStaticUse(helper);
     js.VariableUse jsHelper =
-        new js.VariableUse(compiler.namer.isolateAccess(helper));
+        new js.VariableUse(backend.namer.isolateAccess(helper));
     js.Call value = new js.Call(jsHelper, visitArguments([null, argument]));
     attachLocation(value, argument);
     // BUG(4906): Using throw here adds to the size of the generated code
     // but it has the advantage of explicitly telling the JS engine that
     // this code path will terminate abruptly. Needs more work.
     pushStatement(new js.Throw(value));
   }
 
   void visitSwitch(HSwitch node) {
     // Switches are handled using [visitSwitchInfo].
@@ skipping 12 matching lines @@
         // which will also be non call static use.
         for (int i = 1; i < node.inputs.length; i++) {
           if (node.inputs === node) {
             backend.registerNonCallStaticUse(node);
             break;
           }
         }
       }
     });
     world.registerStaticUse(node.element);
-    push(new js.VariableUse(compiler.namer.isolateAccess(node.element)));
+    push(new js.VariableUse(backend.namer.isolateAccess(node.element)));
   }
 
   void visitLazyStatic(HLazyStatic node) {
     Element element = node.element;
     world.registerStaticUse(element);
-    String lazyGetter = compiler.namer.isolateLazyInitializerAccess(element);
+    String lazyGetter = backend.namer.isolateLazyInitializerAccess(element);
     js.VariableUse target = new js.VariableUse(lazyGetter);
     js.Call call = new js.Call(target, <js.Expression>[]);
     push(call, node);
   }
 
   void visitStaticStore(HStaticStore node) {
     world.registerStaticUse(node.element);
     js.VariableUse variableUse =
-        new js.VariableUse(compiler.namer.isolateAccess(node.element));
+        new js.VariableUse(backend.namer.isolateAccess(node.element));
     use(node.inputs[0]);
     push(new js.Assignment(variableUse, pop()), node);
   }
 
   void visitStringConcat(HStringConcat node) {
     if (isEmptyString(node.left)) {
       useStringified(node.right);
    } else if (isEmptyString(node.right)) {
       useStringified(node.left);
     } else {
@@ skipping 11 matching lines @@
     return string.value.length == 0;
   }
 
   void useStringified(HInstruction node) {
     if (node.isString(types)) {
       use(node);
     } else {
       Element convertToString = compiler.findHelper(const SourceString("S"));
       world.registerStaticUse(convertToString);
       js.VariableUse variableUse =
-          new js.VariableUse(compiler.namer.isolateAccess(convertToString));
+          new js.VariableUse(backend.namer.isolateAccess(convertToString));
       use(node);
       push(new js.Call(variableUse, <js.Expression>[pop()]), node);
     }
   }
 
   void visitLiteralList(HLiteralList node) {
     generateArrayLiteral(node);
   }
 
   void generateArrayLiteral(HLiteralList node) {
@@ skipping 172 matching lines @@
     checkType(input, element);
     push(new js.Binary('||',
                        functionTest,
                        new js.Binary('&&', objectTest, pop())));
   }
 
   void checkType(HInstruction input, Element element, [bool negative = false]) {
     world.registerIsCheck(element);
     use(input);
     js.PropertyAccess field =
-        new js.PropertyAccess.field(pop(), compiler.namer.operatorIs(element));
+        new js.PropertyAccess.field(pop(), backend.namer.operatorIs(element));
     if (backend.emitter.nativeEmitter.requiresNativeIsCheck(element)) {
       push(new js.Call(field, <js.Expression>[]));
       if (negative) push(new js.Prefix('!', pop()));
     } else {
       // We always negate at least once so that the result is boolified.
       push(new js.Prefix('!', field));
       // If the result is not negated, put another '!' in front.
       if (!negative) push(new js.Prefix('!', pop()));
     }
   }
@@ skipping 152 matching lines @@
         currentContainer = body;
         generateThrowWithHelper('iae', node.checkedInput);
         currentContainer = oldContainer;
         body = unwrapStatement(body);
         pushStatement(new js.If.noElse(test, body), node);
         return;
       }
 
       assert(node.isCheckedModeCheck || node.isCastTypeCheck);
       SourceString helper = backend.getCheckedModeHelper(type);
-      String additionalArgument = compiler.namer.operatorIs(element);
+      String additionalArgument = backend.namer.operatorIs(element);
       if (node.isCastTypeCheck) {
         helper = castNames[helper.stringValue];
       }
       Element helperElement = compiler.findHelper(helper);
       world.registerStaticUse(helperElement);
       List<js.Expression> arguments = <js.Expression>[];
       use(node.checkedInput);
       arguments.add(pop());
       arguments.add(new js.LiteralString("'$additionalArgument'"));
-      String helperName = compiler.namer.isolateAccess(helperElement);
+      String helperName = backend.namer.isolateAccess(helperElement);
       push(new js.Call(new js.VariableUse(helperName), arguments));
     } else {
       use(node.checkedInput);
     }
   }
 }
 
 class SsaOptimizedCodeGenerator extends SsaCodeGenerator {
   SsaOptimizedCodeGenerator(backend, work, parameters, parameterNames)
     : super(backend, work, parameterNames) {
@@ skipping 15 matching lines @@
       work.guards.forEach((HTypeGuard workGuard) {
         HBailoutTarget target = workGuard.bailoutTarget;
         int inputLength = target.inputs.length;
         if (inputLength > maxBailoutParameters) {
           maxBailoutParameters = inputLength;
         }
       });
     }
     HInstruction input = guard.guarded;
     HBailoutTarget target = guard.bailoutTarget;
-    Namer namer = compiler.namer;
+    Namer namer = backend.namer;
     Element element = work.element;
     List<js.Expression> arguments = <js.Expression>[];
     arguments.add(new js.LiteralNumber("${guard.state}"));
     // TODO(ngeoffray): try to put a variable at a deterministic
     // location, so that multiple bailout calls put the variable at
     // the same parameter index.
     int i = 0;
     for (; i < target.inputs.length; i++) {
       assert(guard.inputs.indexOf(target.inputs[i]) >= 0);
       use(target.inputs[i]);
@@ skipping 470 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }