de72ce6ce7
* Properly guard for..in loops with Object#hasOwnProperty.
I noticed that babylon spends a lot of time in what we call *slow mode*
`for..in` when running in Node (on V8), and the reason for that is that
the version distributed on npm is build with *loose mode*, which turns
methods on the prototype into enumerable properties. Let's look at a
simplified example of the `State` class from `src/tokenizer/state.js`:
```js
class State {
constructor() { this.x = 1; }
clone() {
var state = new State();
for (var key in this) {
var val = this[key];
state[key] = val;
}
return state;
}
}
```
According to the specification the `State.prototype.clone` method is
non-enumerable. However when transpiling this with loose mode, we get
the following output:
```js
var State = (function() {
function State() { this.x = 1; }
State.prototype.clone = function clone() {
var state = new State();
for (var key in this) {
var val = this[key];
state[key] = val;
}
return state;
}
return State;
})();
```
So all of a sudden the `State.prototype.clone` method is enumerable.
This means that the `for..in` loop inside of that method enumerates
`x` and `clone` for `key`, whereas originally it was supposed to only
enumerate `x`. This in turn means that the shape of the result of a
call to `clone` will be different than the shape of a state that is
created via the `State` constructor. You can check this in `d8` using
the `--allow-natives-syntax` flag and this simple test driver:
```js
const s = new State;
%DebugPrint(s);
%DebugPrint(s.clone());
```
Using either the class version or the transpiled version we see:
```
$ out/Release/d8 --allow-natives-syntax state-original.js
0x2a9d7970d329 <State map = 0x2a9d40b0c751>
0x2a9d7970d3c1 <State map = 0x2a9d40b0c751>
$ out/Release/d8 --allow-natives-syntax state-loose.js
0x3729ee30d1b9 <State map = 0x3729af90c701>
0x3729ee30d251 <State map = 0x3729af90c7a1>
```
So as you can see, the transpiled version (using *loose mode*) produces
a different shape for the result of `clone`, whereas the original
version is fine. This pollutes all sites which use either a state
created from the `State` constructor or returned from the `clone`
method. The original one has only the `x` property in either case,
whereas in the transpiled version the result of `clone` has properties
`x` and `clone` on the instance.
To mitigate this effect, it's best to guard the `for..in` loops with
`Object.prototype.hasOwnProperty` calls, such that the actual body of
the loop only deals with own properties and not with properties from the
prototype chain. This change does exactly that for the two affected
`clone` functions.
In addition to the performance hit because of the unnecessary
polymorphism, there's also the performance hit because of the *slow
mode* `for..in` itself, which has to collect the properties from the
instance plus the prototype. Ideally the prototype properties shouldn't
be enumerable to avoid this whole set of problems. I see a couple of
possible solutions:
1. Distribute the original ES2015 version via npm.
2. Don't use loose mode, so that `Object.defineProperty` is used
instead, correctly passing `enumerable:false`.
3. Globally change loose mode in Babel to generate the correct and
fast `Object.defineProperty` instead.
I'd personally prefer a combination of 1. and 3. here, but I'm aware
that distributing the ES2015 code might not be an option yet. So the
mitigation of properly guarding the `for..in` here should already help.
But it'd be nice to have a discussion on using `Object.defineProperty`
in general, as I imagine that this could easily bite other applications
as well and this performance cliff is completely unobvious to
developers.
* Switch to Object.keys and Array.prototype.forEach.
Woah, what's going on here?
A monorepo, muhahahahahaha. See the monorepo design doc for reasoning.
Core Packages
| Package | Version | Dependencies |
|---|---|---|
@babel/core |
 |
 |
babylon |
 |
 |
@babel/traverse |
 |
 |
@babel/generator |
 |
 |
@babel/core is the Babel compiler itself; it exposes the babel.transform method, where transformedCode = transform(src).code.
The compiler can be broken down into 3 parts:
- The parser:
babylon(moved to a separate repo and versioned independently) - The transformer[s]: All the plugins/presets
- These all use
@babel/traverseto traverse through the AST
- These all use
- The generator:
@babel/generator
The flow goes like this:
input string -> babylon parser -> AST -> transformer[s] -> AST -> @babel/generator -> output string
Check out the babel-handbook for more information on this.
Other
| Package | Version | Dependencies |
|---|---|---|
@babel/cli |
 |
 |
@babel/types |
 |
 |
@babel/polyfill |
 |
 |
@babel/runtime |
 |
 |
@babel/register |
 |
 |
@babel/template |
 |
 |
@babel/helpers |
 |
 |
@babel/code-frame |
 |
 |
@babel/cliis the CLI tool that runs@babel/coreand helps with outputting to a directory, a file, stdout and more (also includesbabel-node). Check out the docs.@babel/typesis used to validate, build and change AST nodes.@babel/polyfillis literally a wrapper aroundcore-jsand regenerator-runtime. Check out the docs.@babel/runtimeis similar to the polyfill except that it doesn't modify the global scope and is to be used with@babel/plugin-transform-runtime(usually in library/plugin code). Check out the docs.@babel/registeris a way to automatically compile files with Babel on the fly by binding to Node.jsrequire. Check out the docs.@babel/templateis a helper function that allows constructing AST nodes from a string presentation of the code; this eliminates the tedium of using@babel/typesfor building AST nodes.@babel/helpersis a set of pre-made@babel/templatefunctions that are used in some Babel plugins.@babel/code-frameis a standalone package used to generate errors that print the source code and point to error locations.
Presets
After Babel 6, the default transforms were removed; if you don't specify any plugins/presets, Babel will just return the original source code.
The transformer[s] used in Babel are the independent pieces of code that transform specific things. For example: the es2015-arrow-functions transform specifically changes arrow functions into regular functions. A preset is simply an array of plugins that make it easier to run a whole a set of transforms without specifying each one manually.
| Package | Version | Dependencies | Description |
|---|---|---|---|
@babel/preset-env |
 |
 |
automatically determines plugins and polyfills you need based on your supported environments |
You can find community maintained presets on npm
Plugins
Plugins are the heart of Babel and what make it work.
You can find community plugins on npm.
Transform Plugins
There are many kinds of plugins: ones that convert ES6/ES2015 to ES5, transform to ES3, minification, JSX, flow, experimental features, and more. Check out our website for more.
Syntax Plugins
These just enable the transform plugins to be able to parse certain features (the transform plugins already include the syntax plugins so you don't need both): @babel/plugin-syntax-x. Check out our website for more.
Helpers
These are mostly for internal use in various plugins: @babel/helper-x.