Move elementAccess() from namer to emitter.

pkg/compiler/lib/src/js_emitter/interceptor_stub_generator.dart

 // Copyright (c) 2014, 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 dart2js.js_emitter;
 
 class InterceptorStubGenerator {
   final Compiler compiler;
   final Namer namer;
   final JavaScriptBackend backend;
 
   InterceptorStubGenerator(this.compiler, this.namer, this.backend);
 
   jsAst.Expression generateGetInterceptorMethod(Set<ClassElement> classes) {
     jsAst.Expression interceptorFor(ClassElement cls) {
-      return js('#.prototype', namer.elementAccess(cls));
+      return js('#.prototype', backend.emitter.globalPropertyAccess(cls));

[floitsch, 2014/12/03 17:02:25]

classAccess
Maybe even classPrototypeAccess

Interestingly we needed to add "eager" classes because of the interceptors.
If we change the way we access classPrototypes we could potentially remove the
eager classes again.

[zarah, 2014/12/05 08:22:50]

Done.

     }
 
     /**
      * Build a JavaScrit AST node for doing a type check on
      * [cls]. [cls] must be a non-native interceptor class.
      */
     jsAst.Statement buildInterceptorCheck(ClassElement cls) {
       jsAst.Expression condition;
       assert(backend.isInterceptorClass(cls));
       if (cls == backend.jsBoolClass) {
@@ skipping 108 matching lines @@
     if (hasArray) {
       statements.add(buildInterceptorCheck(backend.jsArrayClass));
     }
 
     if (hasNative) {
       statements.add(js.statement(r'''{
           if (typeof receiver != "object") return receiver;
           if (receiver instanceof #) return receiver;
           return #(receiver);
       }''', [
-          namer.elementAccess(compiler.objectClass),
-          namer.elementAccess(backend.getNativeInterceptorMethod)]));
+          backend.emitter.globalPropertyAccess(compiler.objectClass),

[floitsch, 2014/12/03 17:02:25]

either classAccess or constructorAccess.
Both make sense:
- classAccess, because we make an is-check.
- constructorAccess, because that's what we have to use in JS to do an is-check.

Almost leaning towards constructorAccess.
Also: should probably be jsConstructorAccess.

[zarah, 2014/12/05 08:22:50]

Done.

+          backend.emitter.globalPropertyAccess(backend.getNativeInterceptorMethod)]));

[floitsch, 2014/12/03 17:02:25]

staticFunctionAccess.

Long line.

[zarah, 2014/12/05 08:22:50]

Done.

 
     } else {
       ClassElement jsUnknown = backend.jsUnknownJavaScriptObjectClass;
       if (compiler.codegenWorld
               .directlyInstantiatedClasses.contains(jsUnknown)) {
         statements.add(
             js.statement('if (!(receiver instanceof #)) return #;',
-                [namer.elementAccess(compiler.objectClass),
+                [backend.emitter.globalPropertyAccess(compiler.objectClass),

[floitsch, 2014/12/03 17:02:25]

as in line 145.

[zarah, 2014/12/05 08:22:51]

Done.

                  interceptorFor(jsUnknown)]));
       }
 
       statements.add(js.statement('return receiver'));
     }
 
     return js('''function(receiver) { #; }''', new jsAst.Block(statements));
   }
 
   // Returns a statement that takes care of performance critical
@@ skipping 144 matching lines @@
         _fastPathForOneShotInterceptor(selector, classes);
     if (optimizedPath == null) optimizedPath = js.statement(';');
 
     return js(
         'function(#) { #; return #.#(receiver).#(#) }',
         [parameterNames,
          optimizedPath,
          globalObject, getInterceptorName, invocationName, parameterNames]);
   }
 }