Convert dart_utils.js to input_sdk/lib/_internal/utils.dart (#310)

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 19 matching lines @@
 import '../utils.dart';
 
 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_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 TypeRules rules;
   final LibraryElement currentLibrary;
 
   /// 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;
+
   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';
 
     _objectMembers = getObjectMemberMap(types);
   }
 
   TypeProvider get types => rules.provider;
 
   JS.Program emitLibrary(LibraryUnit library) {
     // Modify the AST to make coercions explicit.
     new CoercionReifier(library, rules).reify();
 
@@ skipping 59 matching lines @@
     // 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 imports = <JS.Expression>[js.string('dart/_runtime')];
+    var needsDartRuntime = !_isDartUtils;
+
+    var imports = <JS.Expression>[];
+    var moduleStatements = <JS.Statement>[];
+    if (needsDartRuntime) {
+      imports.add(js.string('dart/_runtime'));
+
+      var dartxImport =
+          js.statement("let # = #.dartx;", [_dartxVar, _runtimeLibVar]);
+      moduleStatements.add(dartxImport);
+    }
+    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 dartxImport =
-        js.statement("let # = #.dartx;", [_dartxVar, _runtimeLibVar]);
-
-    var module = js.call("function(#) { 'use strict'; #; #; }",
-        [params, dartxImport, _moduleItems]);
+    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)),
       module
     ]);
@@ skipping 54 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]));
+    _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 @@
       // 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 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, _visit(node.functionExpression)),
-        node.element));
-    body.add(_emitFunctionTagged(id, node.element.type, topLevel: true)
-        .toStatement());
+    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);
     return _statement(body);
   }
 
+  bool _isInlineJSFunction(FunctionExpression functionExpression) {
+    bool isJsInvocation(Expression expr) =>
+        expr is MethodInvocation && isInlineJS(expr.methodName.staticElement);
+
+    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;
+  }
+
+  // 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).
+  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);
+          JS.ArrowFun innerFun = call.target;
+          if (_listEquality.equals(getIdents(innerFun.params), passedArgs)) {
+            return new JS.Fun(fn.params, innerFun.body);
+          }
+        }
+      }
+    }
+    return fn;
+  }
+
   JS.Method _emitTopLevelProperty(FunctionDeclaration node) {
     var name = node.name.name;
     return annotate(
         new JS.Method(_propertyName(name), _visit(node.functionExpression),
             isGetter: node.isGetter, isSetter: node.isSetter),
         node.element);
   }
 
   bool _executesAtTopLevel(AstNode node) {
     var ancestor = node.getAncestor((n) => n is FunctionBody ||
@@ skipping 2041 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);
 }