Generate all runtime files from dart.

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 76 matching lines @@
   final _privateNames = new HashMap<String, JS.TemporaryId>();
   final _moduleItems = <JS.Statement>[];
   final _temps = new HashMap<Element, JS.TemporaryId>();
   final _qualifiedIds = new List<Tuple2<Element, JS.MaybeQualifiedId>>();
 
   /// The name for the library's exports inside itself.
   /// `exports` was chosen as the most similar to ES module patterns.
   final _dartxVar = new JS.Identifier('dartx');
   final _exportsVar = new JS.TemporaryId('exports');
   final _runtimeLibVar = new JS.Identifier('dart');
+  final _utilsLibVar = new JS.TemporaryId('utils');
+  final _classesLibVar = new JS.TemporaryId('classes');
+  final _rttiLibVar = new JS.TemporaryId('rtti');
   final _namedArgTemp = new JS.TemporaryId('opts');
 
   final TypeProvider _types;
 
   ConstFieldVisitor _constField;
 
   ModuleItemLoadOrder _loader;
 
   /// _interceptors.JSArray<E>, used for List literals.
   ClassElement _jsArray;
 
   /// The default value of the module object. See [visitLibraryDirective].
   String _jsModuleValue;
 
-  bool _isDartUtils;
+  bool _isDartRuntime;
 
   Map<String, DartType> _objectMembers;
 
   JSCodegenVisitor(AbstractCompiler compiler, this.rules, this.currentLibrary,
       this._extensionTypes, this._fieldsNeedingStorage)
       : compiler = compiler,
         options = compiler.options.codegenOptions,
         _types = compiler.context.typeProvider {
     _loader = new ModuleItemLoadOrder(_emitModuleItem);
 
     var context = compiler.context;
     var src = context.sourceFactory.forUri('dart:_interceptors');
     var interceptors = context.computeLibraryElement(src);
     _jsArray = interceptors.getType('JSArray');
-    _isDartUtils = currentLibrary.source.uri.toString() == 'dart:_utils';
+
+    _isDartRuntime = _runtimeLibUris.contains(_getLibUri(currentLibrary));
 
     _objectMembers = getObjectMemberMap(types);
   }
+  String _getLibUri(LibraryElement lib) => lib.source.uri.toString();
+
+  static final _runtimeLibUris = new Set<String>.from([
+    'dart:_utils',
+    'dart:_runtime',
+    'dart:_operations',
+    'dart:_errors',
+    'dart:_classes',
+    'dart:_generators',
+    'dart:_operations',
+    'dart:_types',
+    'dart:_rtti'
+  ]);
 
   TypeProvider get types => rules.provider;
 
   JS.Program emitLibrary(LibraryUnit library) {
     // Modify the AST to make coercions explicit.
     new CoercionReifier(library, rules).reify();
 
     // Build the public namespace for this library. This allows us to do
     // constant time lookups (contrast with `Element.getChild(name)`).
     if (currentLibrary.publicNamespace == null) {
@@ skipping 49 matching lines @@
     // TODO(jmesserly): make these immutable in JS?
     for (var name in _exports) {
       _moduleItems.add(js.statement('#.# = #;', [_exportsVar, name, name]));
     }
 
     var jsPath = compiler.getModuleName(currentLibrary.source.uri);
 
     // TODO(jmesserly): it would be great to run the renamer on the body,
     // then figure out if we really need each of these parameters.
     // See ES6 modules: https://github.com/dart-lang/dev_compiler/issues/34
-    var params = [_exportsVar, _runtimeLibVar];
-    var processImport =
-        (LibraryElement library, JS.TemporaryId temp, List list) {
-      params.add(temp);
-      list.add(js.string(compiler.getModuleName(library.source.uri), "'"));
-    };
+    var params = [_exportsVar];
+    var lazyParams = [];
 
-    var needsDartRuntime = !_isDartUtils;
+    var libUri = _getLibUri(currentLibrary);
 
     var imports = <JS.Expression>[];
+    var lazyImports = <JS.Expression>[];
     var moduleStatements = <JS.Statement>[];
-    if (needsDartRuntime) {
-      imports.add(js.string('dart/_runtime'));
+
+    addImport(String name, JS.Expression libVar, {bool eager: true}) {
+      (eager ? imports : lazyImports).add(js.string(name, "'"));
+      (eager ? params : lazyParams).add(libVar);
+    }
+
+    if (!_isDartRuntime) {
+      addImport('dart/_runtime', _runtimeLibVar);
 
       var dartxImport =
           js.statement("let # = #.dartx;", [_dartxVar, _runtimeLibVar]);
       moduleStatements.add(dartxImport);
+    } else {
+      if (libUri == 'dart:_generators') {
+        addImport('dart/_classes', _classesLibVar);
+      }
     }
     moduleStatements.addAll(_moduleItems);
 
-    _imports.forEach((library, temp) {
-      if (_loader.libraryIsLoaded(library)) {
-        processImport(library, temp, imports);
-      }
+    bool shouldImportEagerly(lib) {
+      var otherLibUri = _getLibUri(lib);
+      if (otherLibUri == 'dart:_utils') return true;
+      if (libUri == 'dart:_types' && otherLibUri == 'dart:_rtti') return true;
+      if (libUri == 'dart:_runtime') return otherLibUri != 'dart:_js_helper';
+      return !_isDartRuntime && _loader.libraryIsLoaded(lib);
+    }
+
+    var importsEagerness = new Map<LibraryElement, bool>.fromIterable(
+        _imports.keys, value: shouldImportEagerly);
+
+    _imports.forEach((LibraryElement lib, JS.TemporaryId temp) {
+      bool eager = importsEagerness[lib];
+      addImport(compiler.getModuleName(lib.source.uri), temp, eager: eager);
     });
 
-    var lazyImports = <JS.Expression>[];
-    _imports.forEach((library, temp) {
-      if (!_loader.libraryIsLoaded(library)) {
-        processImport(library, temp, lazyImports);
-      }
-    });
+    params.addAll(lazyParams);
 
     var module =
         js.call("function(#) { 'use strict'; #; }", [params, moduleStatements]);
 
     var moduleDef = js.statement("dart_library.library(#, #, #, #, #)", [
       js.string(jsPath, "'"),
       _jsModuleValue ?? new JS.LiteralNull(),
       js.commentExpression(
           "Imports", new JS.ArrayInitializer(imports, multiline: true)),
       js.commentExpression("Lazy imports",
@@ skipping 16 matching lines @@
     if (node is! FunctionDeclaration) _flushLibraryProperties(_moduleItems);
 
     var code = _visit(node);
     if (code != null) _moduleItems.add(code);
   }
 
   @override
   void visitLibraryDirective(LibraryDirective node) {
     assert(_jsModuleValue == null);
 
-    var jsName = findAnnotation(node.element, isJSAnnotation);
-    _jsModuleValue =
-        getConstantField(jsName, 'name', types.stringType)?.toStringValue();
+    _jsModuleValue = _getJsName(node.element);
+  }
+
+  String _getJsName(Element e) {
+    var jsName = findAnnotation(e, isJSAnnotation);
+    return getConstantField(jsName, 'name', types.stringType)?.toStringValue();
   }
 
   @override
   void visitImportDirective(ImportDirective node) {
     // Nothing to do yet, but we'll want to convert this to an ES6 import once
     // we have support for modules.
   }
 
   @override void visitPartDirective(PartDirective node) {}
   @override void visitPartOfDirective(PartOfDirective node) {}
 
   @override
   void visitExportDirective(ExportDirective node) {
     var exportName = _libraryName(node.uriElement);
 
     var currentLibNames = currentLibrary.publicNamespace.definedNames;
 
     var args = [_exportsVar, exportName];
     if (node.combinators.isNotEmpty) {
       var shownNames = <JS.Expression>[];
       var hiddenNames = <JS.Expression>[];
 
       var show = node.combinators.firstWhere((c) => c is ShowCombinator,
           orElse: () => null) as ShowCombinator;
       var hide = node.combinators.firstWhere((c) => c is HideCombinator,
           orElse: () => null) as HideCombinator;
       if (show != null) {
+        var singleName = _getJsName(node.element);
+        if (singleName != null && show.shownNames.length != 1) {
+          throw new StateError('Cannot set js name on more than one name');
+        }
         shownNames.addAll(show.shownNames
-            .map((i) => i.name)
+            .map((i) => singleName ?? i.name)
             .where((s) => !currentLibNames.containsKey(s))
             .map((s) => js.string(s, "'")));
       }
       if (hide != null) {
         hiddenNames.addAll(hide.hiddenNames.map((i) => js.string(i.name, "'")));
       }
       args.add(new JS.ArrayInitializer(shownNames));
       args.add(new JS.ArrayInitializer(hiddenNames));
     }
-    _moduleItems.add(js.statement('dart.export_(#);', [args]));
+
+    // When we compile _runtime.js, we need to source export_ from _utils.js:
+    _moduleItems.add(js.statement('#.export(#);',
+        [_isDartRuntime ? _utilsLibVar : _runtimeLibVar, args]));
   }
 
   JS.Identifier _initSymbol(JS.Identifier id) {
     var s =
         js.statement('const # = $_SYMBOL(#);', [id, js.string(id.name, "'")]);
     _moduleItems.add(s);
     return id;
   }
 
   // TODO(jmesserly): this is a temporary workaround for `Symbol` in core,
@@ skipping 253 matching lines @@
       return js.statement('{ #; let # = #; }', [genericDef, name, genericInst]);
     }
     return body;
   }
 
   JS.Statement _emitGenericClassDef(ParameterizedType type, JS.Statement body) {
     var name = type.name;
     var genericName = '$name\$';
     var typeParams = type.typeParameters.map((p) => p.name);
     if (isPublic(name)) _exports.add(genericName);
-    return js.statement('const # = dart.generic(function(#) { #; return #; });',
-        [genericName, typeParams, body, name]);
+
+    return js.statement('const # = #(function(#) { #; return #; });',
+        [genericName, _dartGeneric, typeParams, body, name]);
   }
 
+  get _dartGeneric =>
+      js.call('#.generic', [_isDartRuntime ? _classesLibVar : _runtimeLibVar]);
+
   final _hasDeferredSupertype = new HashSet<ClassElement>();
 
   bool _deferIfNeeded(DartType type, ClassElement current) {
     if (type is ParameterizedType) {
       var typeArguments = type.typeArguments;
       for (var typeArg in typeArguments) {
         var typeElement = typeArg.element;
         // FIXME(vsm): This does not track mutual recursive dependences.
         if (current == typeElement || _deferIfNeeded(typeArg, current)) {
           return true;
@@ skipping 229 matching lines @@
       if (!tStatics.isEmpty) {
         assert(!sNames.isEmpty);
         var aNames = new JS.Property(
             _propertyName('names'), new JS.ArrayInitializer(sNames));
         sigFields.add(build('statics', tStatics));
         sigFields.add(aNames);
       }
       if (!sigFields.isEmpty || extensions.isNotEmpty) {
         var sig = new JS.ObjectInitializer(sigFields);
         var classExpr = new JS.Identifier(name);
-        body.add(js.statement('dart.setSignature(#, #);', [classExpr, sig]));
+        body.add(js.statement('#(#, #);', [_dartSetSignature, classExpr, sig]));
       }
     }
 
     // If a concrete class implements one of our extensions, we might need to
     // add forwarders.
     if (extensions.isNotEmpty) {
       var methodNames = <JS.Expression>[];
       for (var e in extensions) {
         methodNames.add(_elementMemberName(e));
       }
       body.add(js.statement('dart.defineExtensionMembers(#, #);', [
         name,
         new JS.ArrayInitializer(methodNames, multiline: methodNames.length > 4)
       ]));
     }
 
     // TODO(vsm): Make this optional per #268.
     // Metadata
     if (metadata.isNotEmpty) {
       body.add(js.statement('#[dart.metadata] = () => #;', [
         name,
         new JS.ArrayInitializer(
             new List<JS.Expression>.from(metadata.map(_instantiateAnnotation)))
       ]));
     }
 
     return _statement(body);
   }
 
+  get _dartSetSignature =>
+      js.call('#.setSignature', [_isDartRuntime ? _classesLibVar : _runtimeLibVar]);
+
   List<ExecutableElement> _extensionsToImplement(ClassElement element) {
     var members = <ExecutableElement>[];
     if (_extensionTypes.contains(element)) return members;
 
     // Collect all extension types we implement.
     var type = element.type;
     var types = new Set<ClassElement>();
     _collectExtensions(type, types);
     if (types.isEmpty) return members;
 
@@ skipping 420 matching lines @@
 
     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 = _getJsName(node.element) ?? node.name.name;
 
     var fn = _visit(node.functionExpression);
-    bool needsTagging = true;
+    bool needsTagging = !_isDartRuntime;
 
     if (currentLibrary.source.isInSystemLibrary &&
         _isInlineJSFunction(node.functionExpression)) {
       fn = _simplifyPassThroughArrowFunCallBody(fn);
-      needsTagging = !_isDartUtils;
     }
 
     var id = new JS.Identifier(name);
     body.add(annotate(new JS.FunctionDeclaration(id, fn), node.element));
     if (needsTagging) {
       body.add(_emitFunctionTagged(id, node.element.type, topLevel: true)
           .toStatement());
     }
 
     if (isPublic(name)) _addExport(name);
@@ skipping 75 matching lines @@
   JS.Expression _emitFunctionTagged(JS.Expression clos, DartType type,
       {topLevel: false}) {
     var name = type.name;
     var lazy = topLevel && !_typeIsLoaded(type);
 
     if (type is FunctionType && (name == '' || name == null)) {
       if (type.returnType.isDynamic &&
           type.optionalParameterTypes.isEmpty &&
           type.namedParameterTypes.isEmpty &&
           type.normalParameterTypes.every((t) => t.isDynamic)) {
-        return js.call('dart.fn(#)', [clos]);
+        return js.call('#(#)', [_dartFn, clos]);
       }
       if (lazy) {
-        return js.call('dart.fn(#, () => #)', [clos, _emitFunctionRTTI(type)]);
+        return js.call('#(#, () => #)', [_dartFn, clos, _emitFunctionRTTI(type)]);
       }
-      return js.call('dart.fn(#, #)', [clos, _emitFunctionTypeParts(type)]);
+      return js.call('#(#, #)', [_dartFn, clos, _emitFunctionTypeParts(type)]);
     }
     throw 'Function has non function type: $type';
   }
 
+  get _dartFn => js.call('#.fn', _isDartRuntime ? _rttiLibVar : _runtimeLibVar);
+
   @override
   JS.Expression visitFunctionExpression(FunctionExpression node) {
     var params = _visit(node.parameters) as List<JS.Parameter>;
     if (params == null) params = <JS.Parameter>[];
 
     var parent = node.parent;
     var inStmt = parent.parent is FunctionDeclarationStatement;
     if (parent is FunctionDeclaration) {
       return _emitFunctionBody(params, node.body);
     } else {
@@ skipping 130 matching lines @@
           'Unimplemented unknown name', new JS.Identifier(node.name));
     }
 
     // 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;
 
     _loader.declareBeforeUse(element);
 
-    var name = element.name;
+    var name = _getJsName(element) ?? 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 _maybeQualifiedName(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
@@ skipping 282 matching lines @@
     var stmts = _visitList(node.block.statements) as List<JS.Statement>;
     if (initArgs != null) stmts.insert(0, initArgs);
     return new JS.Block(stmts);
   }
 
   @override
   JS.Block visitBlock(Block node) =>
       new JS.Block(_visitList(node.statements) as List<JS.Statement>,
           isScope: true);
 
+  /// Return the type constructor `_foolib.Bar$` given `Bar` from lib `_foolib`.
+  JS.Expression _emitGenericTypeConstructor(Expression typeExpression) {
+    var ref = _visit(typeExpression);
+    if (ref is JS.PropertyAccess) {
+      var name = (ref.selector as JS.LiteralString).valueWithoutQuotes;
+      return new JS.PropertyAccess(
+          ref.receiver, new JS.LiteralString("'$name\$'"));
+    } else if (ref is JS.MaybeQualifiedId) {
+      var name = (ref.name as JS.Identifier).name;
+      return new JS.PropertyAccess(
+          ref.qualifier, new JS.Identifier('$name\$'));
+    } else {
+      throw new ArgumentError('Invalid type ref: $ref (${ref?.runtimeType})');
+    }
+  }
+
   @override
   visitMethodInvocation(MethodInvocation node) {
     if (node.operator != null && node.operator.lexeme == '?.') {
       return _emitNullSafe(node);
     }
+    if (isGenericTypeConstructorInvocation(node)) {
+      return _emitGenericTypeConstructor(node.argumentList.arguments.single);
+    }
 
     var target = _getTarget(node);
     var result = _emitForeignJS(node);
     if (result != null) return result;
 
     String code;
     if (target == null || isLibraryPrefix(target)) {
       if (DynamicInvoke.get(node.methodName)) {
         code = 'dart.$DCALL(#, #)';
       } else {
@@ skipping 305 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 = _getJsName(element) ?? field.name.name;
+
     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 615 matching lines @@
     }
 
     String code;
     if (member != null && member is MethodElement && !isStatic) {
       // Tear-off methods: explicitly bind it.
       if (target is SuperExpression) {
         return js.call('dart.bind(this, #, #.#)', [name, _visit(target), name]);
       } else if (_requiresStaticDispatch(target, memberId.name)) {
         var type = member.type;
         var clos = js.call('dart.#.bind(#)', [name, _visit(target)]);
-        return js.call('dart.fn(#, #)', [clos, _emitFunctionTypeParts(type)]);
+        return js.call('#(#, #)', [_dartFn, clos, _emitFunctionTypeParts(type)]);
       }
       code = 'dart.bind(#, #)';
     } else if (_requiresStaticDispatch(target, memberId.name)) {
       return js.call('dart.#(#)', [name, _visit(target)]);
     } else {
       code = '#.#';
     }
 
     return js.call(code, [_visit(target), name]);
   }
@@ skipping 548 matching lines @@
       node.externalKeyword != null || _functionBody(node) is NativeFunctionBody;
 
   FunctionBody _functionBody(node) =>
       node is FunctionDeclaration ? node.functionExpression.body : node.body;
 
   /// Choose a canonical name from the library element.
   /// This never uses the library's name (the identifier in the `library`
   /// declaration) as it doesn't have any meaningful rules enforced.
   JS.Identifier _libraryName(LibraryElement library) {
     if (library == currentLibrary) return _exportsVar;
-    return _imports.putIfAbsent(
-        library, () => new JS.TemporaryId(jsLibraryName(library)));
+    return _imports.putIfAbsent(library, () {
+      var name = library.name;
+      if (name == 'dart._utils') return _utilsLibVar;
+      else if (name == 'dart._classes') return _classesLibVar;
+      else if (name == 'dart._rtti') return _rttiLibVar;
+      else return new JS.TemporaryId(jsLibraryName(library));
+    });
   }
 
   DartType getStaticType(Expression e) => rules.getStaticType(e);
 
   @override
   String getQualifiedName(TypeDefiningElement type) {
     JS.TemporaryId id = _imports[type.library];
     return id == null ? type.name : '${id.name}.${type.name}';
   }
 
@@ skipping 90 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);
 }