Treat our type objects as core.Type

lib/src/codegen/js_codegen.dart

 // Copyright (c) 2015, 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 dev_compiler.src.codegen.js_codegen;
 
 import 'dart:collection' show HashSet, HashMap;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
@@ skipping 1029 matching lines @@
     // Get the original declaring element. If we had a property accessor, this
     // indirects back to a (possibly synthetic) field.
     var element = accessor;
     if (element is PropertyAccessorElement) element = accessor.variable;
     var name = element.name;
 
     // library member
     if (element.enclosingElement is CompilationUnitElement &&
         (element.library != libraryInfo.library ||
             element is TopLevelVariableElement && !element.isConst)) {
-      return js.call('#.#', [_libraryName(element.library), name]);
+      dynamic memberName = name;

[vsm, 2015/04/24 00:12:11]

Note: this is to map exports._foo as exports[_foo], etc.

[Jennifer Messerly, 2015/04/24 00:43:14]

Interesting, how is that used? Would anybody have the key to access it? My
assumption so far was only member types would use symbols, it doesn't seem as
useful at the library level.

I didn't see any generated code changes, is there a sample of what this looks
like?

[vsm, 2015/04/24 13:25:44]

Yes, I was hitting this in angular (application.js) - no cases in the sdk. 
Here's the original generated code:

Def site:
  let _rootBindings = Symbol('_rootBindings');
  dart.defineLazyProperties(exports, {
    get [_rootBindings]() {
      return [binding.bind(reflector.Reflector).toValue(reflection.reflector)];
    },

Use site:
  exports._rootInjector = new injector.Injector(exports._rootBindings);

The change produces exports[_rootBindings] at the use site instead.

[Jennifer Messerly, 2015/04/24 21:23:23]

Aha, lazy top-level field. Interesting. I suppose we could change how it's
generated (to _rootBindings), but then again, I suppose this pattern does give a
bit more protection for private library fields. And maybe it is consistent if
all private state is like that?

Anyway a few small nits:
* can we use `JS.Expression` instead of `dynamic`?
* add a comment explaining how this happens?

[vsm, 2015/05/01 17:24:12]

Not sure I still need this with your recent change to emitMemberName.  I'm
reverting this change from this CL.  I'll revisit - if needed - if I see it come
up again.

+      if (name.startsWith('_')) {

[Jennifer Messerly, 2015/04/24 21:23:23]

in the if body:

assert(element.library == currentLibrary);

[Jennifer Messerly, 2015/04/24 21:25:13]

Maybe won't need with emitMemberName suggestion though. In that case it would
be:

assert(element.isPublic || element.library == currentLibrary);
var memberName = emitMemberName(...)
return js.call(...);

+        memberName = _privateNames.putIfAbsent(

[Jennifer Messerly, 2015/04/24 21:23:23]

Maybe should go through emitMemberName then, with isStatic: true? I think we
ended up here because _emitLazyFields calls emitMemberName.

+            name, () => _initSymbol(new JSTemporary(name)));
+      }
+      return js.call('#.#', [_libraryName(element.library), memberName]);
     }
 
     // Unqualified class member. This could mean implicit-this, or implicit
     // call to a static from the same class.
     if (element is ClassMemberElement && element is! ConstructorElement) {
       bool isStatic = element.isStatic;
       var type = element.enclosingElement.type;
       var member = _emitMemberName(name, isStatic: isStatic, type: type);
 
       // For static methods, we add the raw type name, without generics or
@@ skipping 1447 matching lines @@
 // TODO(jmesserly): validate the library. See issue #135.
 bool _isJsNameAnnotation(DartObjectImpl value) => value.type.name == 'JsName';
 
 bool _isJsPeerInterface(DartObjectImpl value) =>
     value.type.name == 'JsPeerInterface';
 
 // TODO(jacobr): we would like to do something like the following
 // but we don't have summary support yet.
 // bool _supportJsExtensionMethod(AnnotatedNode node) =>
 //    _getAnnotation(node, "SupportJsExtensionMethod") != null;