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 21 matching lines @@
 
 import 'code_generator.dart';
 import 'js_field_storage.dart';
 import 'js_interop.dart';
 import 'js_names.dart' as JS;
 import 'js_metalet.dart' as JS;
 import 'js_module_item_order.dart';
 import 'js_names.dart';
 import 'js_printer.dart' show writeJsLibrary;
 import 'side_effect_analysis.dart';
-import 'package:collection/equality.dart';
 
 // Various dynamic helpers we call.
 // If renaming these, make sure to check other places like the
 // _runtime.js file and comments.
 // TODO(jmesserly): ideally we'd have a "dynamic call" dart library we can
 // import and generate calls to, rather than dart_runtime.js
 const DPUT = 'dput';
 const DLOAD = 'dload';
 const DINDEX = 'dindex';
 const DSETINDEX = 'dsetindex';
 const DCALL = 'dcall';
 const DSEND = 'dsend';
 
-const ListEquality _listEquality = const ListEquality();
-
 class JSCodegenVisitor extends GeneralizingAstVisitor with ClosureAnnotator {
   final AbstractCompiler compiler;
   final CodegenOptions options;
   final LibraryElement currentLibrary;
   final StrongTypeSystemImpl rules;
 
   /// The global extension type table.
   final HashSet<ClassElement> _extensionTypes;
 
   /// Information that is precomputed for this library, indicates which fields
@@ skipping 34 matching lines @@
   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;
 
   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 = currentLibrary.source.uri.toString() == 'dart:_runtime';
   }
 
   TypeProvider get types => _types;
 
   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)`).
@@ skipping 50 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 needsDartRuntime = !_isDartUtils;
+    var params = [_exportsVar];
+    var lazyParams = [];
 
     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 lazy: false}) {
+      (lazy ? lazyImports : imports).add(js.string(name, "'"));
+      (lazy ? lazyParams : params).add(libVar);
+    }
+
+    if (!_isDartRuntime) {
+      addImport('dart/_runtime', _runtimeLibVar);
 
       var dartxImport =
           js.statement("let # = #.dartx;", [_dartxVar, _runtimeLibVar]);
       moduleStatements.add(dartxImport);
     }
+    _imports.forEach((LibraryElement lib, JS.TemporaryId temp) {
+      addImport(compiler.getModuleName(lib.source.uri), temp,
+          lazy: _isDartRuntime || !_loader.libraryIsLoaded(lib));
+    });
+    params.addAll(lazyParams);
+
     moduleStatements.addAll(_moduleItems);
 
-    _imports.forEach((library, temp) {
-      if (_loader.libraryIsLoaded(library)) {
-        processImport(library, temp, imports);
-      }
-    });
-
-    var lazyImports = <JS.Expression>[];
-    _imports.forEach((library, temp) {
-      if (!_loader.libraryIsLoaded(library)) {
-        processImport(library, temp, lazyImports);
-      }
-    });
-
     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",
           new JS.ArrayInitializer(lazyImports, multiline: true)),
@@ skipping 56 matching lines @@
             .map((i) => 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('dart.export(#);', [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 975 matching lines @@
             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) {
+    if (!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 = _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;
     }
 
     var id = new JS.Identifier(name);
     body.add(annotate(new JS.FunctionDeclaration(id, fn), node.element));
-    if (needsTagging) {
+    if (!_isDartRuntime) {
       body.add(_emitFunctionTagged(id, node.element.type, topLevel: true)
           .toStatement());
     }
 
     if (isPublic(name)) _addExport(name);
     return _statement(body);
   }
 
   bool _isInlineJSFunction(FunctionExpression functionExpression) {
     var body = functionExpression.body;
     if (body is ExpressionFunctionBody) {
       return _isJSInvocation(body.expression);
     } else if (body is BlockFunctionBody) {
       if (body.block.statements.length == 1) {
         var stat = body.block.statements.single;
         if (stat is ReturnStatement) {
           return _isJSInvocation(stat.expression);
         }
       }
     }
     return false;
   }
 
   bool _isJSInvocation(Expression expr) =>
       expr is MethodInvocation && isInlineJS(expr.methodName.staticElement);
 
-  // Simplify `(args) => ((x, y) => { ... })(x, y)` to `(args) => { ... }`.
-  // Note: we don't check if the top-level args match the ones passed through
-  // the arrow function, which allows silently passing args through to the
-  // body (which only works if we don't do weird renamings of Dart params).
+  // Simplify `(args) => (() => { ... })()` to `(args) => { ... }`.
+  // Note: this allows silently passing args through to the body, which only
+  // works if we don't do weird renamings of Dart params.
   JS.Fun _simplifyPassThroughArrowFunCallBody(JS.Fun fn) {
-    String getIdent(JS.Node node) => node is JS.Identifier ? node.name : null;
-    List<String> getIdents(List params) =>
-        params.map(getIdent).toList(growable: false);
-
     if (fn.body is JS.Block && fn.body.statements.length == 1) {
       var stat = fn.body.statements.single;
       if (stat is JS.Return && stat.value is JS.Call) {
         JS.Call call = stat.value;
-        if (call.target is JS.ArrowFun) {
-          var passedArgs = getIdents(call.arguments);
+        if (call.target is JS.ArrowFun && call.arguments.isEmpty) {
           JS.ArrowFun innerFun = call.target;
-          if (_listEquality.equals(getIdents(innerFun.params), passedArgs)) {
+          if (innerFun.params.isEmpty) {
             return new JS.Fun(fn.params, innerFun.body);
           }
         }
       }
     }
     return fn;
   }
 
   JS.Method _emitTopLevelProperty(FunctionDeclaration node) {
     var name = node.name.name;
@@ skipping 379 matching lines @@
       }
       if (jsArgs != null) {
         var genericName = _emitTopLevelName(element, suffix: '\$');
         return js.call('#(#)', [genericName, jsArgs]);
       }
     }
 
     return _emitTopLevelName(element);
   }
 
-  JS.Expression _emitTopLevelName(Element e, {String suffix : ''}) {
+  JS.Expression _emitTopLevelName(Element e, {String suffix: ''}) {
     var libName = _libraryName(e.library);
     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;
@@ skipping 1664 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;
+    if (library.name == 'dart._runtime') return _runtimeLibVar;
     return _imports.putIfAbsent(
         library, () => new JS.TemporaryId(jsLibraryName(library)));
   }
 
   DartType getStaticType(Expression e) =>
       e.staticType ?? DynamicTypeImpl.instance;
 
   @override
   String getQualifiedName(TypeDefiningElement type) {
     JS.TemporaryId id = _imports[type.library];
@@ skipping 160 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);
 }