Stop resolving all of js_helper unconditionally.

sdk/lib/_internal/compiler/implementation/js_backend/emitter.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 js_backend;
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
@@ skipping 51 matching lines @@
   CodeBuffer boundClosureBuffer;
   CodeBuffer mainBuffer;
   /** Shorter access to [isolatePropertiesName]. Both here in the code, as
       well as in the generated code. */
   String isolateProperties;
   String classesCollector;
   Set<ClassElement> neededClasses;
   // TODO(ngeoffray): remove this field.
   Set<ClassElement> instantiatedClasses;
 
+  JavaScriptBackend get backend => compiler.backend;
+
   String get _ => compiler.enableMinification ? "" : " ";
   String get n => compiler.enableMinification ? "" : "\n";
   String get N => compiler.enableMinification ? "\n" : ";\n";
 
   /**
    * A cache of closures that are used to closurize instance methods.
    * A closure is dynamically bound to the instance used when
    * closurized.
    */
   final Map<int, String> boundClosureCache;
@@ skipping 551 matching lines @@
     return js.fun(parameters, [
       // var getter = new Function("{ return $isolate." + fieldName + ";}");
       js['getter'].def(js['Function'].newWith([
           js.string("{ return $isolate.") + 'fieldName' + js.string('}')]))
     ]..addAll(addLazyInitializerLogic())
     );
   }
 
   List addLazyInitializerLogic() {
     String isolate = namer.CURRENT_ISOLATE;
-    JavaScriptBackend backend = compiler.backend;
-    String cyclicThrow = namer.isolateAccess(backend.cyclicThrowHelper);
+    String cyclicThrow = namer.isolateAccess(backend.getCyclicThrowHelper());
 
     return [
       // var sentinelUndefined = {};
       js['sentinelUndefined'].def({}),
 
       // var sentinelInProgress = {};
       js['sentinelInProgress'].def({}),
 
       // prototype[fieldName] = sentinelUndefined;
       js['prototype'][js['fieldName']].assign('sentinelUndefined'),
@@ skipping 115 matching lines @@
       // hit the method directly.
       return;
     }
     ConstantHandler handler = compiler.constantHandler;
     List<SourceString> names = selector.getOrderedNamedArguments();
 
     String invocationName = namer.invocationName(selector);
     if (alreadyGenerated.contains(invocationName)) return;
     alreadyGenerated.add(invocationName);
 
-    JavaScriptBackend backend = compiler.backend;
     bool isInterceptorClass =
         backend.isInterceptorClass(member.getEnclosingClass());
 
     // If the method is in an interceptor class, we need to also pass
     // the actual receiver.
     int extraArgumentCount = isInterceptorClass ? 1 : 0;
     // Use '$receiver' to avoid clashes with other parameter names. Using
     // '$receiver' works because [:namer.safeName:] used for getting parameter
     // names never returns a name beginning with a single '$'.
     String receiverArgumentName = r'$receiver';
@@ skipping 214 matching lines @@
    */
   void addInstanceMember(Element member, ClassBuilder builder) {
     assert(invariant(member, member.isDeclaration));
     // TODO(floitsch): we don't need to deal with members of
     // uninstantiated classes, that have been overwritten by subclasses.
 
     if (member.isFunction()
         || member.isGenerativeConstructorBody()
         || member.isAccessor()) {
       if (member.isAbstract(compiler)) return;
-      JavaScriptBackend backend = compiler.backend;
       jsAst.Expression code = backend.generatedCode[member];
       if (code == null) return;
       builder.addProperty(namer.getName(member), code);
       code = backend.generatedBailoutCode[member];
       if (code != null) {
         builder.addProperty(namer.getBailoutName(member), code);
       }
       FunctionElement function = member;
       FunctionSignature parameters = function.computeSignature(compiler);
       if (!parameters.optionalParameters.isEmpty) {
         addParameterStubs(member, builder.addProperty);
       }
     } else if (!member.isField()) {
       compiler.internalError('unexpected kind: "${member.kind}"',
                              element: member);
     }
     emitExtraAccessors(member, builder);
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [classElement] must be a declaration element.
    */
   void emitInstanceMembers(ClassElement classElement,
                            ClassBuilder builder) {
     assert(invariant(classElement, classElement.isDeclaration));
-    JavaScriptBackend backend = compiler.backend;
     if (classElement == backend.objectInterceptorClass) {
       emitInterceptorMethods(builder);
       // The ObjectInterceptor does not have any instance methods.
       return;
     }
 
     void visitMember(ClassElement enclosing, Element member) {
       assert(invariant(classElement, member.isDeclaration));
       if (member.isInstanceMember()) {
         addInstanceMember(member, builder);
@@ skipping 77 matching lines @@
           const SourceString('=='), 1);
       Function kind = (classElement == backend.jsNullClass)
           ? js.equals
           : js.strictEquals;
       builder.addProperty(name, js.fun(['receiver', 'a'],
           js.block(js.return_(kind(js['receiver'], js['a'])))));
     }
   }
 
   void emitRuntimeClassesAndTests(CodeBuffer buffer) {
-    JavaScriptBackend backend = compiler.backend;
     RuntimeTypeInformation rti = backend.rti;
     TypeChecks typeChecks = rti.getRequiredChecks();
 
     bool needsHolder(ClassElement cls) {
       return !neededClasses.contains(cls) || cls.isNative() ||
           rti.isJsNative(cls);
     }
 
     /**
      * Generates a holder object if it is needed.  A holder is a JavaScript
@@ skipping 165 matching lines @@
   }
 
   void generateCheckedSetter(Element member,
                              String fieldName,
                              String accessorName,
                              ClassBuilder builder) {
     assert(canGenerateCheckedSetter(member));
     DartType type = member.computeType(compiler);
     // TODO(ahe): Generate a dynamic type error here.
     if (type.element.isErroneous()) return;
-    SourceString helper = compiler.backend.getCheckedModeHelper(type);
+    SourceString helper = backend.getCheckedModeHelper(type);
     FunctionElement helperElement = compiler.findHelper(helper);
     String helperName = namer.isolateAccess(helperElement);
     List<jsAst.Expression> arguments = <jsAst.Expression>[js['v']];
     if (helperElement.computeSignature(compiler).parameterCount != 1) {
       arguments.add(js.string(namer.operatorIs(type.element)));
     }
 
     String setterName = namer.setterNameFromAccessorName(accessorName);
     builder.addProperty(setterName,
         js.fun(['v'], js['this'][fieldName].assign(js[helperName](arguments))));
@@ skipping 144 matching lines @@
   }
 
   int _compareSelectorNames(Selector selector1, Selector selector2) {
     String name1 = selector1.name.toString();
     String name2 = selector2.name.toString();
     if (name1 != name2) return Comparable.compare(name1, name2);
     return _selectorRank(selector1) - _selectorRank(selector2);
   }
 
   void emitInterceptorMethods(ClassBuilder builder) {
-    JavaScriptBackend backend = compiler.backend;
     // Emit forwarders for the ObjectInterceptor class. We need to
     // emit all possible sends on intercepted methods.
     for (Selector selector in
          backend.usedInterceptors.toList()..sort(_compareSelectorNames)) {
       List<jsAst.Parameter> parameters = <jsAst.Parameter>[];
       List<jsAst.Expression> arguments = <jsAst.Expression>[];
       parameters.add(new jsAst.Parameter('receiver'));
 
       String name = backend.namer.invocationName(selector);
       if (selector.isSetter()) {
@@ skipping 30 matching lines @@
    * substitutions, because they may have changed.
    */
   void generateIsTestsOn(ClassElement cls,
                          void emitIsTest(Element element),
                          void emitSubstitution(Element element, {emitNull})) {
     if (checkedClasses.contains(cls)) {
       emitIsTest(cls);
       emitSubstitution(cls);
     }
 
-    JavaScriptBackend jsBackend = compiler.backend;
-    RuntimeTypeInformation rti = jsBackend.rti;
+    RuntimeTypeInformation rti = backend.rti;
     ClassElement superclass = cls.superclass;
 
     bool haveSameTypeVariables(ClassElement a, ClassElement b) {
       if (a.isClosure()) return true;
       return a.typeVariables == b.typeVariables;
     }
 
     if (superclass != null && superclass != compiler.objectClass &&
         !haveSameTypeVariables(cls, superclass)) {
       // We cannot inherit the generated substitutions, because the type
@@ skipping 94 matching lines @@
   /**
    * Return a function that returns true if its argument is a class
    * that needs to be emitted.
    */
   Function computeClassFilter() {
     Set<ClassElement> unneededClasses = new Set<ClassElement>();
     // The [Bool] class is not marked as abstract, but has a factory
     // constructor that always throws. We never need to emit it.
     unneededClasses.add(compiler.boolClass);
 
-    JavaScriptBackend backend = compiler.backend;
-
     // Go over specialized interceptors and then constants to know which
     // interceptors are needed.
     Set<ClassElement> needed = new Set<ClassElement>();
     backend.specializedGetInterceptors.forEach(
         (_, Collection<ClassElement> elements) {
           needed.addAll(elements);
         }
     );
 
     ConstantHandler handler = compiler.constantHandler;
@@ skipping 70 matching lines @@
   void emitStaticFunction(CodeBuffer buffer,
                           String name,
                           jsAst.Expression functionExpression) {
     jsAst.Expression assignment =
         js[isolateProperties][name].assign(functionExpression);
     buffer.add(jsAst.prettyPrint(assignment, compiler));
     buffer.add('$N$n');
   }
 
   void emitStaticFunctions(CodeBuffer buffer) {
-    JavaScriptBackend backend = compiler.backend;
     bool isStaticFunction(Element element) =>
         !element.isInstanceMember() && !element.isField();
 
     Iterable<Element> elements =
         backend.generatedCode.keys.where(isStaticFunction);
     Set<Element> pendingElementsWithBailouts =
         backend.generatedBailoutCode.keys
             .where(isStaticFunction)
             .toSet();
 
@@ skipping 90 matching lines @@
     // are more difficult to canonicalize because they would need to have the
     // same default values.
 
     bool hasOptionalParameters = member.optionalParameterCount(compiler) != 0;
     int parameterCount = member.parameterCount(compiler);
 
     Map<int, String> cache;
     String extraArg = null;
     // Methods on interceptor classes take an extra parameter, which is the
     // actual receiver of the call.
-    JavaScriptBackend backend = compiler.backend;
     bool inInterceptor = backend.isInterceptorClass(member.getEnclosingClass());
     if (inInterceptor) {
       cache = interceptorClosureCache;
       extraArg = 'receiver';
     } else {
       cache = boundClosureCache;
     }
     List<String> fieldNames = compiler.enableMinification
         ? inInterceptor ? const ['a', 'b', 'c']
                         : const ['a', 'b']
@@ skipping 103 matching lines @@
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [member] must be a declaration element.
    */
   void emitCallStubForGetter(Element member,
                              Set<Selector> selectors,
                              DefineStubFunction defineStub) {
     assert(invariant(member, member.isDeclaration));
     LibraryElement memberLibrary = member.getLibrary();
-    JavaScriptBackend backend = compiler.backend;
     // If the class is an interceptor class, the stub gets the
     // receiver explicitely and we need to pass it to the getter call.
     bool isInterceptorClass =
         backend.isInterceptorClass(member.getEnclosingClass());
 
     const String receiverArgumentName = r'$receiver';
 
     jsAst.Expression buildGetter() {
       if (member.isGetter()) {
         String getterName = namer.getterName(member);
@@ skipping 58 matching lines @@
         buffer.add(jsAst.prettyPrint(init, compiler));
         buffer.add('$N');
       });
     }
   }
 
   void emitLazilyInitializedStaticFields(CodeBuffer buffer) {
     ConstantHandler handler = compiler.constantHandler;
     List<VariableElement> lazyFields =
         handler.getLazilyInitializedFieldsForEmission();
-    JavaScriptBackend backend = compiler.backend;
     if (!lazyFields.isEmpty) {
       needsLazyInitializer = true;
       for (VariableElement element in Elements.sortedByPosition(lazyFields)) {
         assert(backend.generatedBailoutCode[element] == null);
         jsAst.Expression code = backend.generatedCode[element];
         assert(code != null);
         // The code only computes the initial value. We build the lazy-check
         // here:
         //   lazyInitializer(prototype, 'name', fieldName, getterName, initial);
         // The name is used for error reporting. The 'initial' must be a
@@ skipping 305 matching lines @@
 
   void emitGetInterceptorMethod(CodeBuffer buffer,
                                 String objectName,
                                 String key,
                                 Collection<ClassElement> classes) {
     jsAst.Statement buildReturnInterceptor(ClassElement cls) {
       return js.return_(js[namer.isolateAccess(cls)]['prototype']);
     }
 
     jsAst.VariableUse receiver = js['receiver'];
-    JavaScriptBackend backend = compiler.backend;
-
     /**
      * Build a JavaScrit AST node for doing a type check on
      * [cls]. [cls] must be an interceptor class.
      */
     jsAst.Statement buildInterceptorCheck(ClassElement cls) {
       jsAst.Expression condition;
       assert(backend.isInterceptorClass(cls));
       if (cls == backend.jsBoolClass) {
         condition = receiver.typeof.equals(js.string('boolean'));
       } else if (cls == backend.jsIntClass ||
@@ skipping 92 matching lines @@
     buffer.add(jsAst.prettyPrint(
         js[isolateProperties][key].assign(js.fun(['receiver'], block)),
         compiler));
     buffer.add(N);
   }
 
   /**
    * Emit all versions of the [:getInterceptor:] method.
    */
   void emitGetInterceptorMethods(CodeBuffer buffer) {
-    JavaScriptBackend backend = compiler.backend;
     // If no class needs to be intercepted, just return.
     if (backend.objectInterceptorClass == null) return;
     String objectName = namer.isolateAccess(backend.objectInterceptorClass);
     var specializedGetInterceptors = backend.specializedGetInterceptors;
     for (String name in specializedGetInterceptors.keys.toList()..sort()) {
       Collection<ClassElement> classes = specializedGetInterceptors[name];
       emitGetInterceptorMethod(buffer, objectName, name, classes);
     }
   }
 
   void computeNeededClasses() {
     instantiatedClasses =
         compiler.codegenWorld.instantiatedClasses.where(computeClassFilter())
             .toSet();
     neededClasses = new Set<ClassElement>.from(instantiatedClasses);
     for (ClassElement element in instantiatedClasses) {
       for (ClassElement superclass = element.superclass;
           superclass != null;
           superclass = superclass.superclass) {
         if (neededClasses.contains(superclass)) break;
         neededClasses.add(superclass);
       }
     }
   }
 
   int _compareSelectors(Selector selector1, Selector selector2) {
     int comparison = _compareSelectorNames(selector1, selector2);
     if (comparison != 0) return comparison;
 
-    JavaScriptBackend backend = compiler.backend;
     Set<ClassElement> classes1 = backend.getInterceptedClassesOn(selector1);
     Set<ClassElement> classes2 = backend.getInterceptedClassesOn(selector2);
     if (classes1.length != classes2.length) {
       return classes1.length - classes2.length;
     }
     String getInterceptor1 =
         namer.getInterceptorName(backend.getInterceptorMethod, classes1);
     String getInterceptor2 =
         namer.getInterceptorName(backend.getInterceptorMethod, classes2);
     return Comparable.compare(getInterceptor1, getInterceptor2);
   }
 
   void emitOneShotInterceptors(CodeBuffer buffer) {
-    JavaScriptBackend backend = compiler.backend;
     for (Selector selector in
          backend.oneShotInterceptors.toList()..sort(_compareSelectors)) {
       Set<ClassElement> classes = backend.getInterceptedClassesOn(selector);
       String oneShotInterceptorName = namer.oneShotInterceptorName(selector);
       String getInterceptorName =
           namer.getInterceptorName(backend.getInterceptorMethod, classes);
 
       List<jsAst.Parameter> parameters = <jsAst.Parameter>[];
       List<jsAst.Expression> arguments = <jsAst.Expression>[];
       parameters.add(new jsAst.Parameter('receiver'));
@@ skipping 112 matching lines @@
 """;
 const String HOOKS_API_USAGE = """
 // The code supports the following hooks:
 // dartPrint(message)   - if this function is defined it is called
 //                        instead of the Dart [print] method.
 // dartMainRunner(main) - if this function is defined, the Dart [main]
 //                        method will not be invoked directly.
 //                        Instead, a closure that will invoke [main] is
 //                        passed to [dartMainRunner].
 """;