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);
     }
 
+    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, suffix: '\$');
         return js.call('#(#)', [genericName, jsArgs]);
       }
     }
 
-    return _maybeQualifiedName(element);
+    return _emitTopLevelName(element);
   }
 
-  JS.Expression _maybeQualifiedName(Element e, [String name]) {
+  JS.Expression _emitTopLevelName(Element e, {String suffix : ''}) {
     var libName = _libraryName(e.library);
-    var nameExpr = _propertyName(name ?? e.name);
+    var nameExpr = _propertyName((_getJSExportName(e) ?? e.name) + suffix);
 
     // 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 443 matching lines @@
       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;
+    if (element is TopLevelVariableElement) {
+      fieldName = _getJSExportName(element) ?? fieldName;
+    }
     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);
 }