Add a `@JSExportName` annotation for internal use in the runtime (use it to export dart.assert inst…

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, SplayTreeSet;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
@@ skipping 1276 matching lines @@
     }
 
     return annotate(
         new JS.Method(_elementMemberName(node.element), fn,
             isGetter: node.isGetter,
             isSetter: node.isSetter,
             isStatic: node.isStatic),
         node.element);
   }
 
+  /// Returns the name value of the `JSExportName` annotation (when compiling
+  /// the SDK), or `null` if there's none. This is used to control the name
+  /// under which functions are compiled and exported.
+  String _getJSExportName(Element e) {
+    if (e is! FunctionElement || !currentLibrary.source.isInSystemLibrary) {
+      return null;
+    }
+    var jsName = findAnnotation(e, isJSExportNameAnnotation);
+    return getConstantField(jsName, 'name', types.stringType)?.toStringValue();
+  }
+
   @override
   JS.Statement visitFunctionDeclaration(FunctionDeclaration node) {
     assert(node.parent is CompilationUnit);
 
     if (_externalOrNative(node)) return null;
 
     if (node.isGetter || node.isSetter) {
       // Add these later so we can use getter/setter syntax.
       _properties.add(node);
       return null;
     }
 
     var body = <JS.Statement>[];
     _flushLibraryProperties(body);
 
-    var name = node.name.name;
+    var name = _getJSExportName(node.element) ?? node.name.name;
 
     var fn = _visit(node.functionExpression);
     bool needsTagging = true;
 
     if (currentLibrary.source.isInSystemLibrary &&
         _isInlineJSFunction(node.functionExpression)) {
       fn = _simplifyPassThroughArrowFunCallBody(fn);
       needsTagging = !_isDartUtils;
     }
 
@@ skipping 245 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 (accessor is PropertyAccessorElement) element = accessor.variable;
     if (accessor is FunctionMember) element = accessor.baseElement;
 
     _loader.declareBeforeUse(element);
 
-    var name = element.name;
-
     // type literal
     if (element is ClassElement ||
         element is DynamicElementImpl ||
         element is FunctionTypeAliasElement) {
       return _emitTypeName(
           fillDynamicTypeArgs((element as dynamic).type, types));
     }
 
     // library member
     if (element.enclosingElement is CompilationUnitElement) {
-      return _maybeQualifiedName(element);
+      return _emitTopLevelName(element);

[Jennifer Messerly, 2016/01/13 17:43:59]

nice! it's funny how a name change makes such a difference to how the code reads
:)

[ochafik, 2016/01/13 18:51:29]

Yeah, *sounds* so much more deterministic now ;-)

     }
 
+    var name = element.name;
+
     // 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
       // library prefix. We don't need those because static calls can't use
       // the generic type.
@@ skipping 147 matching lines @@
       if (args
           .any((a) => a != types.dynamicType && !_isGenericTypeParameter(a))) {
         jsArgs = args.map(_emitTypeName);
       } else if (lowerGeneric || isCurrentClass) {
         // When creating a `new S<dynamic>` we try and use the raw form
         // `new S()`, but this does not work if we're inside the same class,
         // because `S` refers to the current S<T> we are generating.
         jsArgs = [];
       }
       if (jsArgs != null) {
-        var genericName = _maybeQualifiedName(element, '$name\$');
+        var genericName = _emitTopLevelName(element, '$name\$');
         return js.call('#(#)', [genericName, jsArgs]);
       }
     }
 
-    return _maybeQualifiedName(element);
+    return _emitTopLevelName(element);
   }
 
-  JS.Expression _maybeQualifiedName(Element e, [String name]) {
+  JS.Expression _emitTopLevelName(Element e, [String name]) {
     var libName = _libraryName(e.library);
-    var nameExpr = _propertyName(name ?? e.name);
+    var nameExpr = _propertyName(name ?? _getJSExportName(e) ?? e.name);

[Jennifer Messerly, 2016/01/13 17:44:00]

oh wow, the [name] optional parameter--which was probably my fault--is really
hacky. I think it breaks your JSExportName logic on generic classes.

It seems like it should maybe just be a suffix. That would allow you to rename a
generic class def, and it would generate as the exported name followed by '$'.
So this line would have:

    _propertyName((_getJSExportName(e) ?? e.name) + suffix)

and the call 10 lines above would be like:

    _emitTopLevelName(element, suffix: r'$')

[ochafik, 2016/01/13 18:51:29]

Cool! Done.

 
     // Always qualify:
     // * mutable top-level fields
     // * elements from other libraries
     bool mutableTopLevel = e is TopLevelVariableElement &&
         !e.isConst &&
         !_isFinalJSDecl(e.computeNode());
     bool fromAnotherLibrary = e.library != currentLibrary;
     if (mutableTopLevel || fromAnotherLibrary) {
       return new JS.PropertyAccess(libName, nameExpr);
@@ skipping 442 matching lines @@
     } else {
       jsInit = _visitInitializer(field);
       eagerInit = false;
     }
 
     // Treat `final x = JS('', '...')` as a const (non-lazy) to help compile
     // runtime helpers.
     var isJSTopLevel = field.isFinal && _isFinalJSDecl(field);
     if (isJSTopLevel) eagerInit = true;
 
-    var fieldName = field.name.name;
+    var fieldName = _getJSExportName(element) ?? field.name.name;

[Jennifer Messerly, 2016/01/13 17:43:59]

So for top-level fields, I think this works.

I worry it's in a slightly strange place for static fields, because we'll
generate uses of them using the Element.name, but we'll generate definitions
using the @JSExportName name. So if the dart code  is:

class Foo {
  @JSExportName('foo')
  static int bar = 42;
}
main() => print(Foo.bar);

I think it will generate the definition as 'Foo.foo' but the use as 'Foo.bar'

Huh, and looking at _emitMemberName, it's not easy to fix -- we don't always
have an Element when we need to emit a member name.

Probably the safest thing to do for now is only have this logic kick in for
top-level fields, something like:

var fieldName = field.name.name;
if (element is TopLevelVariableElement) {
  String exportName = _getJSExportName(element);
  if (exportName != null) fieldName = exportName;
}
...

(aside: we might be in a good place now with the Analyzer, where we can rely on
Elements being correctly populated for things like
MethodInvocation.methodName.staticElement. But that wasn't the case in the
past.)

[ochafik, 2016/01/13 18:51:29]

Aaaah, absolutely, thanks!

     if ((field.isConst && eagerInit && element is TopLevelVariableElement) ||
         isJSTopLevel) {
       // constant fields don't change, so we can generate them as `let`
       // but add them to the module's exports. However, make sure we generate
       // anything they depend on first.
 
       if (isPublic(fieldName)) _addExport(fieldName);
       var declKeyword = field.isConst || field.isFinal ? 'const' : 'let';
       return annotateVariable(
           js.statement(
@@ skipping 1376 matching lines @@
 
 /// A special kind of element created by the compiler, signifying a temporary
 /// variable. These objects use instance equality, and should be shared
 /// everywhere in the tree where they are treated as the same variable.
 class TemporaryVariableElement extends LocalVariableElementImpl {
   TemporaryVariableElement.forNode(Identifier name) : super.forNode(name);
 
   int get hashCode => identityHashCode(this);
   bool operator ==(Object other) => identical(this, other);
 }