update runtime transformer to modular core-js - fixes #1206

.gitignore

@@ -11,6 +11,7 @@ test/core/tmp
 coverage
 dist
 .package.json
+packages/babel-runtime/core-js
 packages/babel-runtime/helpers/*.js
 packages/babel-runtime/regenerator/*.js
 lib

packages/build-runtime.js

@@ -13,16 +13,20 @@ function relative(filename) {
   return __dirname + "/babel-runtime/" + filename;
 }
 
-function readFile(filename, defaultify) {
+function readFile(filename, shouldDefaultify) {
   var file = fs.readFileSync(require.resolve(filename), "utf8");
 
-  if (defaultify) {
-    file += '\nmodule.exports = { "default": module.exports, __esModule: true };\n';
+  if (shouldDefaultify) {
+    file += "\n" + defaultify("module.exports") + "\n";
   }
 
   return file;
 }
 
+function defaultify(name) {
+  return 'module.exports = { "default": ' + name + ', __esModule: true };';
+}
+
 function updatePackage() {
   var pkgLoc = relative("package.json");
   var pkg    = require(pkgLoc);
@@ -69,4 +73,26 @@ each(File.helpers, function (helperName) {
 writeFile("regenerator/index.js", readFile("regenerator-babel/runtime-module", true));
 writeFile("regenerator/runtime.js", selfContainify(readFile("regenerator-babel/runtime")));
 
+//
+
+var coreDefinitions = require("../lib/babel/transformation/transformers/other/runtime/definitions");
+
+var paths = [];
+
+each(coreDefinitions.builtins, function (path) {
+  paths.push(path);
+});
+
+each(coreDefinitions.methods, function (props) {
+  each(props, function (path) {
+    paths.push(path);
+  });
+});
+
+each(paths, function (path) {
+  writeFile("core-js/" + path + ".js", defaultify('require("core-js/library/fn/' + path + '")'));
+});
+
+//
+
 updatePackage();

src/babel/transformation/transformers/other/runtime/definitions.json

@@ -0,0 +1,99 @@
+{
+  "builtins": {
+    "Symbol": "symbol",
+    "Promise": "promise",
+    "Map": "map",
+    "WeakMap": "weak-map",
+    "Set": "set",
+    "WeakSet": "weak-set"
+  },
+  "methods": {
+    "Array": {
+      "concat": "array/concat",
+      "copyWithin": "array/copy-within",
+      "entries": "array/entries",
+      "every": "array/every",
+      "fill": "array/fill",
+      "filter": "array/filter",
+      "findIndex": "array/find-index",
+      "find": "array/find",
+      "forEach": "array/for-each",
+      "from": "array/from",
+      "includes": "array/includes",
+      "indexOf": "array/index-of",
+      "join": "array/join",
+      "keys": "array/keys",
+      "lastIndexOf": "array/last-index-of",
+      "map": "array/map",
+      "of": "array/of",
+      "pop": "array/pop",
+      "push": "array/push",
+      "reduceRight": "array/reduce-right",
+      "reduce": "array/reduce",
+      "reverse": "array/reverse",
+      "shift": "array/shift",
+      "slice": "array/slice",
+      "some": "array/some",
+      "sort": "array/sort",
+      "splice": "array/splice",
+      "turn": "array/turn",
+      "unshift": "array/unshift",
+      "values": "array/values"
+    },
+    "Object": {
+      "assign": "object/assign",
+      "classof": "object/classof",
+      "define": "object/define",
+      "entries": "object/entries",
+      "freeze": "object/freeze",
+      "getOwnPropertyDescriptor": "object/get-own-property-descriptor",
+      "getOwnPropertyDescriptors": "object/get-own-property-descriptors",
+      "getOwnPropertyNames": "object/get-own-property-names",
+      "getOwnPropertySymbols": "object/get-own-property-symbols",
+      "getPrototypePf": "object/get-prototype-of",
+      "index": "object/index",
+      "isExtensible": "object/is-extensible",
+      "isFrozen": "object/is-frozen",
+      "isObject": "object/is-object",
+      "isSealed": "object/is-sealed",
+      "is": "object/is",
+      "keys": "object/keys",
+      "make": "object/make",
+      "preventExtensions": "object/prevent-extensions",
+      "seal": "object/seal",
+      "setPrototypeOf": "object/set-prototype-of",
+      "values": "object/values"
+    },
+    "RegExp": {
+      "escape": "regexp/escape"
+    },
+    "Function": {
+      "only": "function/only",
+      "part": "function/part"
+    },
+    "Math": {
+      "acosh": "math/acosh",
+      "asinh": "math/asinh",
+      "atanh": "math/atanh",
+      "cbrt": "math/cbrt",
+      "clz32": "math/clz32",
+      "cosh": "math/cosh",
+      "expm1": "math/expm1",
+      "fround": "math/fround",
+      "pot": "math/pot",
+      "imul": "math/imul",
+      "log10": "math/log10",
+      "log1p": "math/log1p",
+      "log2": "math/log2",
+      "sign": "math/sign",
+      "sinh": "math/sinh",
+      "tanh": "math/tanh",
+      "trunc": "math/trunc"
+    },
+    "Date": {
+      "addLocale": "date/add-locale",
+      "formatUTC": "date/format-utc",
+      "format": "date/format"
+    }
+  }
+}

src/babel/transformation/transformers/other/runtime/index.js

@@ -1,22 +1,15 @@
-import core from "core-js/library";
 import includes from "lodash/collection/includes";
-import * as util from  "../../../util";
+import * as util from  "../../../../util";
 import has from "lodash/object/has";
-import * as t from "../../../types";
+import * as t from "../../../../types";
+import definitions from "./definitions";
 
 var isSymbolIterator = t.buildMatchMemberExpression("Symbol.iterator");
 
-var ALIASABLE_CONSTRUCTORS = [
-"Symbol",
-"Promise",
-"Map",
-"WeakMap",
-"Set",
-"WeakSet"
-];
+const RUNTIME_MODULE_NAME = "babel-runtime";
 
-function coreHas(node) {
-  return node.name !== "_" && has(core, node.name);
+function getForPath(file) {
+  return file.addImport(`${RUNTIME_MODULE_NAME}/core-js/$for`, "iterator", true);
 }
 
 var astVisitor = {
@@ -30,13 +23,17 @@ var astVisitor = {
 
       if (!t.isReferenced(obj, node)) return;
 
-      if (!node.computed && coreHas(obj) && has(core[obj.name], prop.name) && !scope.getBindingIdentifier(obj.name)) {
-        this.skip();
-        return t.prependToMemberExpression(node, file.get("coreIdentifier"));
-      }
-    } else if (this.isReferencedIdentifier() && !t.isMemberExpression(parent) && includes(ALIASABLE_CONSTRUCTORS, node.name) && !scope.getBindingIdentifier(node.name)) {
+      if (node.computed) return;
+      if (!has(definitions.methods, obj.name)) return;
+      if (!has(definitions.methods[obj.name], prop.name)) return;
+      if (scope.getBindingIdentifier(obj.name)) return;
+
+      var modulePath = definitions.methods[obj.name][prop.name];
+      return file.addImport(`${RUNTIME_MODULE_NAME}/core-js/${modulePath}`, `${obj.name}$${prop.name}`, true);
+    } else if (this.isReferencedIdentifier() && !t.isMemberExpression(parent) && has(definitions.builtins, node.name) && !scope.getBindingIdentifier(node.name)) {
       // Symbol() -> _core.Symbol(); new Promise -> new _core.Promise
-      return t.memberExpression(file.get("coreIdentifier"), node);
+      var modulePath = definitions.builtins[node.name];
+      return file.addImport(`${RUNTIME_MODULE_NAME}/core-js/${modulePath}`, node.name, true);
     } else if (this.isCallExpression()) {
       // arr[Symbol.iterator]() -> _core.$for.getIterator(arr)
 
@@ -50,7 +47,7 @@ var astVisitor = {
       if (!isSymbolIterator(prop)) return false;
 
       return util.template("corejs-iterator", {
-        CORE_ID: file.get("coreIdentifier"),
+        CORE_ID: getForPath(file),
         VALUE:   callee.object
       });
     } else if (this.isBinaryExpression()) {
@@ -62,7 +59,7 @@ var astVisitor = {
       if (!isSymbolIterator(left)) return;
 
       return util.template("corejs-is-iterator", {
-        CORE_ID: file.get("coreIdentifier"),
+        CORE_ID: getForPath(file),
         VALUE:   node.right
       });
     }
@@ -79,15 +76,11 @@ exports.Program = function (node, parent, scope, file) {
 
 exports.pre = function (file) {
   file.set("helperGenerator", function (name) {
-    return file.addImport(`babel-runtime/helpers/${name}`, name, true);
-  });
-
-  file.setDynamic("coreIdentifier", function () {
-    return file.addImport("babel-runtime/core-js", "core", true);
+    return file.addImport(`${RUNTIME_MODULE_NAME}/helpers/${name}`, name, true);
   });
 
   file.setDynamic("regeneratorIdentifier", function () {
-    return file.addImport("babel-runtime/regenerator", "regeneratorRuntime", true);
+    return file.addImport(`${RUNTIME_MODULE_NAME}/regenerator`, "regeneratorRuntime", true);
   });
 };
 

test/core/fixtures/transformation/runtime/aliased-constructors/expected.js

@@ -1,11 +1,15 @@
 "use strict";
 
-var _core = require("babel-runtime/core-js")["default"];
+var _Promise = require("babel-runtime/core-js/promise")["default"];
+
+var _Symbol = require("babel-runtime/core-js/symbol")["default"];
+
+var _Map = require("babel-runtime/core-js/map")["default"];
 
 obj.constructor === Object;
-obj.constructor === _core.Promise;
+obj.constructor === _Promise;
 
-_core.Symbol();
-_core.Symbol("test");
+_Symbol();
+_Symbol("test");
 
-new _core.Map();
+new _Map();

test/core/fixtures/transformation/runtime/es6-for-of/expected.js

@@ -1,13 +1,13 @@
 "use strict";
 
-var _core = require("babel-runtime/core-js")["default"];
+var _iterator2 = require("babel-runtime/core-js/$for")["default"];
 
 var _iteratorNormalCompletion = true;
 var _didIteratorError = false;
 var _iteratorError = undefined;
 
 try {
-  for (var _iterator = _core.getIterator(arr), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+  for (var _iterator = _iterator2.getIterator(arr), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
     var i = _step.value;
   }
 } catch (err) {
@@ -23,4 +23,4 @@ try {
       throw _iteratorError;
     }
   }
-}
+}

test/core/fixtures/transformation/runtime/es7-array-comprehensions/expected.js

@@ -1,6 +1,6 @@
 "use strict";
 
-var _core = require("babel-runtime/core-js")["default"];
+var _iterator2 = require("babel-runtime/core-js/$for")["default"];
 
 var arr = (function () {
   var _arr = [];
@@ -9,7 +9,7 @@ var arr = (function () {
   var _iteratorError = undefined;
 
   try {
-    for (var _iterator = _core.getIterator(nums), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+    for (var _iterator = _iterator2.getIterator(nums), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
       var i = _step.value;
 
       _arr.push(i * i);
@@ -30,4 +30,4 @@ var arr = (function () {
   }
 
   return _arr;
-})();
+})();

test/core/fixtures/transformation/runtime/full/expected.js

@@ -1,15 +1,14 @@
 "use strict";
 
-var _core = require("babel-runtime/core-js")["default"];
+var _Symbol = require("babel-runtime/core-js/symbol")["default"];
 
 var _regeneratorRuntime = require("babel-runtime/regenerator")["default"];
 
 var _interopRequireWildcard = require("babel-runtime/helpers/interop-require-wildcard")["default"];
 
-_core.Object.defineProperty(exports, "__esModule", {
+Object.defineProperty(exports, "__esModule", {
   value: true
 });
-
 exports.giveWord = giveWord;
 var marked0$0 = [giveWord].map(_regeneratorRuntime.mark);
 
@@ -19,7 +18,7 @@ var _foo2 = _interopRequireWildcard(_foo);
 
 var bar = _interopRequireWildcard(_foo);
 
-var myWord = _core.Symbol("abc");
+var myWord = _Symbol("abc");
 exports.myWord = myWord;
 
 function giveWord() {

test/core/fixtures/transformation/runtime/regenerator-runtime/expected.js

@@ -10,4 +10,4 @@ void _regeneratorRuntime.mark(function callee$0$0() {
         return context$1$0.stop();
     }
   }, callee$0$0, this);
-});
+});

test/core/fixtures/transformation/runtime/symbol-iterator-in/expected.js

@@ -1,5 +1,5 @@
 "use strict";
 
-var _core = require("babel-runtime/core-js")["default"];
+var _iterator = require("babel-runtime/core-js/$for")["default"];
 
-_core.isIterable(Object(arr));
+_iterator.isIterable(Object(arr));