v5.6.20

This reverts commit 420492388b.

.babelrc

@@ -1,6 +1,7 @@
 {
-  "experimental": true,
-  "playground": true,
-  "loose": true,
-  "blacklist": ["es6.tailCall"]
+  "stage": 0,
+  "loose": ["all"],
+  "blacklist": ["es6.tailCall"],
+  "optional": ["optimisation.flow.forOf"],
+  "plugins": ["./tools/build-plugins/protect"]
 }

.eslintrc

@@ -3,18 +3,23 @@
   "rules": {
     "strict": 0,
     "no-underscore-dangle": 0,
-    "no-unused-vars": 0,
     "curly": 0,
     "no-multi-spaces": 0,
     "key-spacing": 0,
     "no-return-assign": 0,
     "consistent-return": 0,
     "no-shadow": 0,
-    "no-comma-dangle": 0,
+    "comma-dangle": 0,
     "no-use-before-define": 0,
     "no-empty": 0,
     "new-parens": 0,
-    "no-cond-assign": 0
+    "no-cond-assign": 0,
+    "no-fallthrough": 0,
+    "new-cap": 0,
+    "no-loop-func": 0,
+    "no-unreachable": 0,
+    "no-labels": 0,
+    "no-process-exit": 0
   },
   "env": {
     "node": true

.gitignore

@@ -8,10 +8,11 @@ test/core/tmp
 /browser.js
 /browser-polyfill.js
 /runtime.js
-coverage
-dist
-.package.json
-packages/babel-runtime/core-js
-packages/babel-runtime/helpers/*.js
-packages/babel-runtime/regenerator/*.js
-lib
+/coverage
+/dist
+/.package.json
+/packages/babel-runtime/core-js
+/packages/babel-runtime/helpers/*.js
+/packages/babel-runtime/regenerator/*.js
+/lib
+_babel.github.io

.gitmodules

@@ -1,12 +1,3 @@
 [submodule "vendor/traceur"]
 	path = vendor/traceur
 	url = https://github.com/google/traceur-compiler
-[submodule "vendor/regenerator"]
-	path = vendor/regenerator
-	url = https://github.com/babel/regenerator-babel
-[submodule "vendor/test262"]
-	path = vendor/test262
-	url = https://github.com/tc39/test262
-[submodule "vendor/compat-table"]
-	path = vendor/compat-table
-	url = https://github.com/kangax/compat-table

.npmignore

@@ -13,3 +13,4 @@
 /vendor
 /packages
 /src
+_babel.github.io

.travis.yml

@@ -1,16 +1,35 @@
-sudo: false
 language: node_js
+cache:
+  directories:
+  - node_modules
 node_js:
-  - "0.12"
-  - "iojs"
+- "0.10"
+- "0.12"
+- iojs
 
-before_script: "npm install -g codeclimate-test-reporter"
-script: "make test-travis"
+before_script: ./tools/setup-git.sh
+script: make test-travis
+after_success: ./tools/merge-development-with-master.sh
 
 notifications:
-  webhooks:
-    urls:
-      - https://webhooks.gitter.im/e/acf1870e9d223c65e8d5
-    on_success: always
-    on_failure: always
-    on_start: false
+  slack: babeljs:5Wy4QX13KVkGy9CnU0rmvgeK
+
+before_deploy:
+- make prepublish
+
+deploy:
+  provider: npm
+  email: sebmck@gmail.com
+  skip_cleanup: true
+  api_key:
+    secure: Q/pZStwherdYPCqCa0aUuiEktLcx6ccBxieyH8j9IXdDgty0ydmnajZfUnlZuCjN13XI9esM44nSJFTWZvntTryDQAQm37c63VXhAEnw/qrAINI06yt0gLBTT69/fKvIAkH8l48nmW32ZS2dse3rHRPZF1CwyQLC/pdMip8I4sM=
+  on:
+    branch: master
+    tags: true
+    repo: babel/babel
+
+after_deploy:
+- make publish-cli
+- make publish-runtime
+- make build-website
+- make comment-issues

CHANGELOG.md

@@ -9,10 +9,533 @@
 > - [Internal]
 > - [Polish]
 
-_Note: Gaps between patch versions are faulty/broken releases._
+_Note: Gaps between patch versions are faulty, broken or test releases._
 
 See [CHANGELOG - 6to5](CHANGELOG-6to5.md) for the pre-4.0.0 version changelog.
 
+## 5.6.17
+
+ * **Bug Fix**
+  * Fix `CodeGenerator.findCommonStringDelimiter` causing a stack overflow.
+
+## 5.6.16
+
+ * **Internal**
+  * Fix `recast` version to avoid pulling in a newer version.
+ * **New Feature**
+  * Add support for functions in `util.shouldIgnore`.
+ * **Polish**
+  * Strip flow directives in flow transformer.
+  * Add a check for out of bounds default parameters, drastically improving performance and removes engine deoptimisations.
+  * Various performance optimisations by [@samccone](https://github.com/samccone) 💅✨
+  * Delay `this` assignment when referencing this inside an arrow function pre-bare super in derived class constructors.
+  * Split up class body pushing if the constructor is in the wrong order.
+ * **Bug Fix**
+  * Fix hoisting of `ForInStatement` `init` variables in `system` module formatter.
+  * `PathHoister`: Don't hoist to the same function as their original paths function parent.
+  * `PathHoister`: Push each violation paths ancestry to the breakOnScopePaths collection to avoid constant hoisting to nested paths.fix tail call recursion on functions with less arguments than parameters.
+  * Disallow `super.*` before `super()` in derived class constructors.
+  * Properly regenerate scope for replaced nodes. Thanks [@loganfsmyth](https://github.com/loganfsmyth)!
+  * Move up template literal simplification logic to avoid breaking on single elements.
+
+## 5.6.13-5.6.15
+
+ * Setting up automatic Travis releases.
+
+## 5.6.12
+
+ * **Bug Fix**
+  * Fix finding parent for top-level shadowed functions.
+
+## 5.6.11
+
+ ** **Internal**
+  * Merge `es6.parameters.rest` and `es6.parameters.default` transformers. See commit [c0fd4c1f9e0b18231f585c4fa793e4cb0e01aed1](https://github.com/babel/babel/commit/c0fd4c1f9e0b18231f585c4fa793e4cb0e01aed1) for more info.
+
+## 5.6.10
+
+ * **Bug Fix**
+  * Fix faulty internal require check.
+ * **Polish**
+  * Add support for trailing commas in arrow function parameter lists.
+
+## 5.6.8
+
+ * **Bug Fix**
+  * Fix binary expressions colliding with unary expression operators in compact mode.
+  * Fix node properties being set to `null` when using computed properties.
+
+## 5.6.7
+
+ * **Bug Fix**
+  * Fix hoisting of `ForXStatement` `left` `var`s when inserting a block scoping IIFE.
+ * **Polish**
+  * Combine all leading computed property initialisers into the root object in loose mode.
+ * **Internal**
+  * Deprecate returning of replacement strings from visitor methods.
+
+## 5.6.6
+
+ * **Bug Fix**
+  * Fix weird parser bug where `void` type annotations were being parsed as keywords causing the tokeniser to lose track of context.
+
+## 5.6.5
+
+ * **Bug Fix**
+  * Fix nested functions causing rest parameter optimisation to not properly detect when it should deopt on a reference.
+ * **Internal**
+  * Update Regenerator `0.8.31`.
+
+## 5.6.4
+
+ * **Internal**
+  * Add `ParenthesizedExpression` node type.
+
+## 5.6.3
+
+ * **Bug Fix**
+  * Fix rest parameter array allocation loop being incorrectly aliased.
+
+## 5.6.2
+
+ * **Bug Fix**
+  * Fix method key literals not turning into computed member expression in loose mode.
+  * Elect rest parameters in spread element position as candidates instead of replacing them in place.
+
+## 5.6.0
+
+ * **Bug Fix**
+  * Fix istanbul interop for register hook when registering for non-existence extension.
+  * Fix super class constructor call differing for no constructor in derived classes.
+  * Disable module import receiver when in loose mode.
+  * Fix duplicate filenames when using `babel` CLI when passing multiple matching patterns.
+  * Register labels as bindings to fix undeclared variable checks.
+ * **Polish**
+  * Remove unnecessary string binary expressions when transforming template literals.
+  * Support module live bindings in arbitary positions not in Program statement position.
+  * Throw error when attemping to replace a `Program` root node with another node not of type `Program`.
+  * Optimise rest parameters in spread element position and allocate rest array at the earliest common ancestor of all references.
+  * Generate original number representation when value was not changed.
+  * Check for invalid binding identifiers when generating inferred method names.
+  * Don't terminate CLI when watching files fail compilation on init.
+ * **New Feature**
+  * Add new plugin API.
+ * **Internal**
+  * Split react displayName addition into a plugin.
+  * Add check for `JSXMemberExpression` to `t.isReferenced`.
+  * Move `validation.undeclaredVariableCheck` transformer up.
+  * Start great core-to-plugin exodus.
+  * Add `BindingIdentifier` virtual type.
+  * Hidden class optimisations.
+  * Array allocation optimisations.
+  * Update `regenerator`.
+  * Update `js-tokens`.
+  * Sync with upstream Acorn.
+
+## 5.5.8
+
+ * **Internal**
+  * Remove extremely unprofessional and harsh error message for those hotlinking to `resolve-rc`.
+
+## 5.5.7
+
+ * **Bug Fix**
+  * Push newline after decorators when doing code gen.
+  * Rewriting error handling to normalise options before merging them.
+  * Remove duplicate keys in `alias-keys.json` causing errors in strict mode.
+  * Fix `$ babel --help` not showing optional transformers as such.
+ * **New Feature**
+  * Add `auxiliaryCommentBefore` and `auxiliaryCommentAfter` options.
+
+## 5.5.6
+
+ * **Bug Fix**
+  * Fix `let` binding collision in loop head not properly replacing `AssignmentExpression`s.
+
+## 5.5.5
+
+ * **Bug Fix**
+  * Fix `file.opts` not being set before `file.log.deprecate` was called causing a `ReferenceError` as it was checking for a property on it.
+
+## 5.5.4
+
+ * **Bug Fix**
+  * Add back missing `shouldIgnore` check.
+  * Log message on deprecated options rather than throw an error.
+  * Fix name of `auxiliaryComment` option when attempting Istanbul interop in `babel/register`.
+
+## 5.5.3
+
+ * **Bug Fix**
+  * Fix weird state bug when traversing overa  `node` `ClassProperty` instead of `path` in the `es6.classes` transformer.
+
+## 5.5.2
+
+ * **Bug Fix**
+  * Fix `NodePath#isPure` on `Property` nodes.
+  * Use cwd instead of entry file directory when working out relative directory for `babel/register`.
+ * **Internal**
+  * Add scary warning for those few who choose to use the WIP experimental transformers.
+
+## 5.5.1
+
+ * **Bug Fix**
+  * Remove `ClassProperty` nodes always in the `Flow` transformer. This is fine now since class properties aren't supported in any engine that supports classes but the `es7.classProperties` transformer will need to be updated in the future to desugar to ES6 classes instead of relying on the `es6.classes` transformer from being ran.
+
+## 5.5.0
+
+ * **Bug Fix**
+  * Allow pushing declarations to `SwitchStatement`s.
+  * Fix `minification.removeDebugger` to remove `DebuggerStatement`s rather than `ExpressionStatement`s with an identifier of `debugger`.
+  * Check LHS in `ForInStatement` and `ForOfStatement` for constant violations.
+  * Register function `id` as a reference when naming methods to avoid collisions.
+  * Support key literals when checking for the existence of `displayName` property when attempting to add it for `React.createClass`.
+  * Remove `ExportDefaultSpecifier` check from `t.isDefaultSpecifier`.
+  * Don't consider `JSXIdentifier` HTML tag identifiers to be references.
+ * **Polish**
+  * Update `minification.deadCodeElimination` transformer to remove all statements after completion statements.
+  * Update `minification.deadCodeElimination` transformer to not inline single used bindings that exist in different scopes.
+  * When performing Istanbul interop in `babel/register`, add the auxiliary comment `"istanbul ignore text"` to get more accurate coverage.
+  * Add `--nolazy` argument to `babel-node`.
+  * Add support for `cluster` forking.
+  * Perform scope tracking in a single pass instead of multiple.
+  * Smarten up type inferrence and resolution to support the whole array of language constructs.
+  * Optimise module metadata retrieval into a single pass.
+  * Ignore trailing commas when inferring newlines.
+  * Rename `minification.inlineExpressions` transformer to `minification.constantFolding`.
+  * Check path relative to entry file when checking to see if we're inside `node_modules` when using `babel/register`.
+  * Upgrade `regenerator`.
+
+## 5.4.7
+
+ * **Bug Fix**
+  * Don't consider `JSXAttribute` `names` to be valid `ReferencedIdentifier`s.
+
+## 5.4.6
+
+ * **Bug Fix**
+  * Fix `spec.functionName` transformer incorrectly attempting to rename a binding that doesn't exist as it's a global.
+ * **Internal**
+  * Deprecate custom module formatters.
+
+## 5.4.5
+
+ * **Bug Fix**
+  * Add `JSXIdentifier` as a valid `ReferencedIdentifier` visitor virtual type.
+  * Ignore `CallExpression` `_prettyCall` when the `retainLines` option is enabled.
+  * Inherit comments to new declaration node when exploding module declarations.
+  * Fix `es6.tailCall` transformer failing on calls that exceed the max parameters of the function.
+
+## 5.4.4
+
+ * **Bug Fix**
+  * Fix bug where replacing variable declarations in the head of a `for` loop would turn them into `ExpressionStatement`s.
+  * Fix renaming of assignment expressions that were non-identifiers ie. patterns.
+  * Force space before `class` `id` to avoid breaking named classes when using `compact` mode.
+  * Add assignment pattern explosion to avoid initial duplicate nodes.
+  * Ignore this and arguments when performing TCO on shadowed functions.
+ * **Polish**
+  * Rename `sourceMapName` option to `sourceMapTarget`. Thanks [@getify](https://github.com/getify)!
+  * Better detection of completion records, ignore those in `Function`s.
+  * Clarified descriptions of the options that are enabled by default.
+  * Resolve `\`babel-plugin-${name}\`` plugin names **before** just checking the `name`. Thanks [@jquense](https://github.com/jquense)!
+  * Update AMD module formatter to add import default remapping.
+
+## 5.4.3
+
+ * **Bug Fix**
+  * Fix `module` being incorrectly rewritten when used as in an export declaration.
+  * When performing single-reference inlining, ensure that the single reference isn't a child of the binding itself.
+  * Fix a bug in `minification.deadCodeElimination` where a new binding instance was being created for local class bindings instead of just inheriting the parent one.
+  * Fix bug with paren printing in `compact` and `retainLines` mode where a left paren was already printed before catching up.
+ * **Internal**
+  * Handle contexts for paths much better. This will ensure that the path node location info is in sync.
+
+## 5.4.2
+
+ * **Polish**
+  * `ignore` and `only` patterns are now **very** liberal. The pattern can now exist anywhere in the path.
+
+## 5.4.1
+
+ * **Bug Fix**
+  * Add missing `slash` dependency. Thanks [@browncolyn](https://github.com/browncolyn)!
+ * **Polish**
+  * Clean up `shouldIgnore` algorithm to work how you'd expect rather than being a hacky piece of shit. It now crawls the entire path, checking each section of it against the input ignore/only patterns. This means that the pattern `foo` will ignore the paths `foo/bar.js`, `bar/foo` etc.
+
+## 5.4.0
+
+ * **New Feature**
+  * Added [function bind syntax](https://github.com/zenparsing/es-function-bind) behind stage 0. Thanks [@RReverser](https://github.com/rreverser)!
+  * Added `env` option. Especially handy when using the `.babelrc`.
+ * **Bug Fix**
+  * Fix files not properly being ignored when `babel.transform` ignores them when using `$ babel`.
+  * Fix scope tracking registering loop head bindings to their `VariableDeclaration` instead of `VariableDeclarator`.
+ * **Polish**
+  * Normalise path separators for souce map paths when using `$ babel`.
+  * Rework `PathHoister` to ignore global references and to not deopt on reassignments to referenced bindings, instead it tries to hoist to the highest scope.
+  * Added missing exponential operator inlining. Thanks [@nkt](https://github.com/nkt)!
+  * Optimise `regenerator` transformer. Thanks [@benjamn](https://github.com/benjamn)!
+
+## 5.3.3
+
+ * **Bug Fix**
+  * Fix `minification.deadCodeElimination` transformer incorrectly trying to inline import declarations.
+  * Fix `minification.inlineExpression` transformer getting into an infinite loop.
+
+## 5.3.2
+
+ * **Bug Fix**
+  * Fix patterns not being considered when hoisting variables in the `es6.blockScoping` transformer.
+
+## 5.3.1
+
+ * **Bug Fix**
+  * Fix unique export specifiers not being cloned when exploding class and function exports,
+ * **Polish**
+  * Turn import remaps to sequence expressions to remove their context and improve performance.
+
+## 5.3.0
+
+**Speeeeeeed**
+
+![gifs lol](https://31.media.tumblr.com/568205a0e37ae15eca510fa639589a59/tumblr_n8kw8kpcSb1sg6cg8o1_500.gif)
+
+ * **Spec Compliancy**
+  * Allow trailing param commas for methods when using the `es7.trailingCommas` transformer.
+ * **Bug Fix**
+  * Fix `es6.blockScoping` transformer not properly ignoring `break` in `SwitchCase`.
+  * Fix lookahead context saving to avoid weird tokenizer state.
+  * Explode duplicate identifiers in export/import specifiers and property shorthand to create unique objects.
+  * Skip loose mode for class methods when they have decorators.
+  * When removing nodes, share their comments with their siblings.
+  * Properly hoist temp param declarations when doing TCO.
+ * **Internal**
+  * Add `--harmony_generators` flag to `$ babel-node`.
+  * Internal AST traversals have been minimised **drastically**. Transformers have been grouped together which means entire tree traversals are much fewer. Visiting nodes is now also skipped if the traversal context can detect that the handler is a noop. This sames precious cycles as it avoids constructing traversal paths and creating a new traversal context. See issues [#1472](https://github.com/babel/babel/issues/1472) and [#1486](https://github.com/babel/babel/issues/1486) for related discussion.
+ * **Polish**
+  * Move many `utility` transformers to `minification`.
+
+## 5.2.17
+
+ * **Bug Fix**
+  * Fix auxiliary comments not properly being attached to function declaration helpers.
+  * Add `Super` node type to `ast-types` patch.
+  * Ignore parameter bindings when attempting to inline them in the `minification.deadCodeElimination` transformer.
+  * Correct `extensions` arguments when using the Babel CLI.
+
+## 5.2.16
+
+ * **Bug Fix**
+  * Fix plugins being disabled when using the whitelist.
+  * Fix correct function scope being passed to `nameMethod.property` when inferring the function name for class methods.
+  * Fix incorrect extensions reference causing weird issues when using the Babel CLI.
+  * Fix destructuring param reference replacements not inheriting from their original param.
+ * **Spec Compliancy**
+  * Fix order that method decorators are ran in.
+
+## 5.2.15
+
+ * **Bug Fix**
+  * Fix initializer descriptor add attempt if it doesn't exist.
+
+## 5.2.14
+
+ * **Bug Fix**
+  * Fix bug with initializer decorators where the descriptors weren't being defined if there was no `initializer` property.
+ * **Internal**
+  * Expose `retainLines` option to CLI.
+  * Fix `retainLines` option not being taken into consideration when doing multiple variable declaration declarators generation.
+  * Expose minified and unminified copies of dist scripts.
+
+## 5.2.13
+
+ * **Bug Fix**
+  * Fix `ExportDeclaration`s being incorrectly removed when using the `utility.deadCodeElimination` transformer.
+  * Fix position of `utility` transformers.
+ * **New Feature**
+  * Add built-in `esquery` support.
+ * **Internal**
+  * Consolidate notion of "virtual types".
+
+## 5.2.12
+
+ * **Polish**
+  * Make UID generation based on module declarations **much** nicer.
+ * **Internal**
+  * Remove internal check for traversal path replacement of self. This is a pattern that **could** come up in the wild and it could lead to pretty nasty code and may lead to internal regressions as the test coverage isn't 100% :( Instead, just put it in the fast path.
+
+## 5.2.11
+
+ * **Internal**
+  * Rename `getModuleName` option to `getModuleId`, doh.
+
+## 5.2.10
+
+ * **Bug Fix**
+  * Fix numerous issues in `replaceWithSourceString`. Thanks [@pangratz](https://github.com/pangratz)!
+ * **New Feature**
+  * Add `getModuleName` option. Thanks [@jayphelps](https://github.com/jayphelps)!
+
+## 5.2.9
+
+ * **Bug Fix**
+  * Fix `_blockHoist` transformer incorrectly sorting nodes on shitty environments that aren't spec compliant in their key order.
+  * Fix broken `parse` API method reference to an undeclared import.
+
+## 5.2.7
+
+ * **Bug Fix**
+  * Move `utility.deadCodeElimination` transformer up to avoid race conditions.
+  * Fix shorthand property scope binding renaming.
+ * **Polish**
+  * Turn helper variable declarations into function declarations if possible.
+ * **Internal**
+  * Removed native inheritance support from classes.
+  * Added `replaceWithSourceString` path API.
+  * Split up `es3.propertyLiterals` and `es3.memberExpressionLiterals` transformers to `minfication.propertyLiterals` and `es3.memberExpressionLiterals`.
+
+## 5.2.6
+
+ * **Internal**
+  * Fix transformer aliases being accidently set as deprecated ones.
+  * Expose `Pipeline` as `TransformerPipeline` instead.
+
+## 5.2.5
+
+ * **Bug Fix**
+  * Fix `parse` API not adding all the correct pipeline transformers.
+
+## 5.2.4
+
+ * **Bug Fix**
+  * Fix race condition with the Node API being loaded awkwardly and not being able to initialise itself when used in the browser.
+ * **Internal**
+  * Expose `transform.pipeline`.
+
+## 5.2.3
+
+ * **Bug Fix**
+  * Fix plugin containers being called with an undefined import. Thanks [@timbur](https://github.com/timbur)!
+  * Allow Flow object separators to be commas. Thanks [@monsanto](https://github.com/monsanto)!
+  * Add missing `Statement` and `Declaration` node aliases to flow types.
+
+## 5.2.2
+
+ * **Internal**
+  * Allow `util.arrayify` to take arbitrary types and coerce it into an array.
+
+## 5.2.1
+
+ * **Bug Fix**
+  * Fix regression in `node/register` that caused `node_modules` to not be ignored.
+
+## 5.2.0
+
+ * **Bug Fix**
+  * Fix plugin strings splitting arbitrarily on `:` which caused full paths on Windows to fail as they include `:` after the drive letter.
+  * Call class property `initializer`s with their target instead of their descriptor.
+  * Fix `ignore` and `only` not properly working on Windows path separators. Thanks [@stagas](https://github.com/stagas)!
+  * Fix `resolveRc` running on files twice causing issues. Thanks [@lukescott](https://github.com/lukescott)!
+  * Fix shorthand properties not correctly being target for `isReferenced` checks. Thanks [@monsanto](https://github.com/monsanto)!
+ * **Polish**
+  * Allow passing an array of globs to `babel/register` `only` and `ignore` options. Thanks [@Mark-Simulacrum](https://github.com/Mark-Simulacrum)!
+  * When inferring function names that collide with upper bindings, instead of doing the wrapper, instead rename them.
+  * Consider constant-like variable declaration functions to always refer to themselves so TOC can be performed.
+  * Process globs manually when using `$ babel` as some shells such as Windows don't explode them. Thanks [@jden](https://github.com/jden)!
+  * Add alternative way to execute plugins via a closure that's called with the current Babel instance.
+ * **Internal**
+  * Remove multiple internal transformers in favor of directly doing things when we need to. Previously, declarations such as `_ref` that we needed to create in specific scopes were done at the very end via the `_declarations` transformer. Now, they're done and added to the scope **right** when they're needed. This gets rid of the crappy `_declarations` property on scope nodes and fixes the crappy regenerator bug where it was creating a new `BlockStatement` so the declarations were being lost.
+  * Rework transformer traversal optimisation. Turns out that calling a `check` function for **every single node** in the AST is ridiculously expensive. 300,000 nodes timesed by ~30 transformers meant that it took tens of seconds to perform while it's quicker to just do the unnecessary traversal. Seems obvious in hindsight.
+ * **New Feature**
+  * Add `jscript` transformer that turns named function expressions into function declarations to get around [JScript's horribly broken function expression semantics](https://kangax.github.io/nfe/#jscript-bugs). Thanks [@kondi](https://github.com/kondi)!
+  * Add `@@hasInstance` support to objects when using the `es6.spec.symbols` transformer.
+  * Add `retainLines` option that retains the line (but not the columns!) of the input code.
+
+## 5.1.13
+
+ * **Polish**
+  * Remove symbol check from `defineProperty` helper.
+
+## 5.1.12
+
+ * **Bug Fix**
+  * Fix `resolveModuleSource` not being ran on `ExportAllDeclaration`s.
+  * Fix `.babelrc` being resolved multiple times when using the require hook.
+  * Fix parse error on spread properties in assignment position.
+  * Fix `externalHelpers` option being incorrectly listed as type `string`.
+ * **Internal**
+  * Upgrade `core-js` to `0.9.0`.
+ * **Spec Compliancy**
+  * Fix object decorators not using the `initializer` pattern.
+  * Remove property initializer descriptor reflection.
+
+## 5.1.11
+
+ * **Bug Fix**
+  * Memoise and bind member expression decorators.
+  * Move JSX children cleaning to opening element visitor. Fixes elements not being cleaned in certain scenarios.
+  * Consider `SwitchStatement`s to be `Scopable`.
+  * Fix `bluebirdCoroutines` calling `interopRequireWildcard` before it's defined.
+  * Add space to `do...while` code generation.
+  * Validate `super` use before `this` on `super` exit rather than entrance.
+ * **Polish**
+  * Add Babel name to logger.
+
+## 5.1.10
+
+ * **Bug Fix**
+  * Remove `makePredicate` from acorn in favor of an `indexOf`.
+  * Remove statements to expression explosion when inserting a block statement.
+ * **Internal**
+  * Remove runtime compatibility check.
+
+## 5.1.9
+
+ * **Bug Fix**
+  * Fix class property initializers with `undefined` values not being correctly writable.
+  * Fix self inferring generators incorrectly causing a stack error.
+  * Fix default export specifiers not triggering AMD `module` argument inclusion.
+  * Fix assignments not having their module references properly remapped.
+ * **Internal**
+  * Upgrade to latest `acorn`.
+ * **Polish**
+  * Make invalid LHS pattern error messages nicer.
+
+## 5.1.8
+
+ * **Bug Fix**
+  * Only make parenthesized object pattern LHS illegal.
+
+## 5.1.7
+
+ * **Internal**
+  * Add `parse` node API.
+
+## 5.1.6
+
+ * **Bug Fix**
+  * Fix `runtime` built-in catchall not properly checking for local variables.
+
+## 5.1.5
+
+ * **Internal**
+  * Bump `core-js` version.
+
+## 5.1.4
+
+ * **Polish**
+  * Add missing `Reflect` methods to runtime transformer.
+
+## 5.1.3
+
+ * **Internal**
+  * Switch entirely to vanilla regenerator.
+  * Clean up and make the parsing of decorators stateless.
+ * **Bug Fix**
+  * Don't do TCO on generators and async functions.
+  * Add missing `core-js` runtime definitions.
+
 ## 5.1.2
 
  * **Bug Fix**

CONTRIBUTING.md

@@ -1,3 +1,23 @@
+# NOTE: BEFORE OPENING AN ISSUE PLEASE SEE THE [README](https://github.com/babel/babel#readme).
+
+----
+
+<p align="center">
+   <strong><a href="#setup">Setup</a></strong>
+   |
+   <strong><a href="#running-tests">Running tests</a></strong>
+   |
+   <strong><a href="#workflow">Workflow</a></strong>
+   |
+   <strong><a href="#dependencies">Dependencies</a></strong>
+   |
+   <strong><a href="#code-standards">Code Standards</a></strong>
+   |
+   <strong><a href="#internals">Internals</a></strong>
+</p>
+
+----
+
 # Contributing
 
 Contributions are always welcome, no matter how large or small. Before
@@ -6,6 +26,9 @@ contributing, please read the
 
 ## Developing
 
+> Note: Babel moves fast. Only the latest release is guaranteed to build correctly.
+> Older releases are not officially supported. If you attempt to build them, do that at your own risk.
+
 #### Setup
 
 ```sh
@@ -14,14 +37,19 @@ $ cd babel
 $ make bootstrap
 ```
 
-Then you need to run:
+Then you can either run:
+
+```sh
+$ make build-core
+```
+
+to build Babel **once** or:
 
 ```sh
 $ make watch-core
 ```
 
-This will compile Babel and then sit in the background and on file modification
-recompile the necessary files.
+to have Babel build itself then incrementally build files on change.
 
 #### Running tests
 
@@ -44,6 +72,11 @@ Use mocha's `--grep` option to run a subset of tests by name:
 $ mocha test/core/transformation.js --grep es7
 ```
 
+If you don't have `mocha` installed globally, you can still use it from Babel's
+dependencies in `node_modules`, but make sure `node_modules/.bin` is added to
+your [`$PATH`](http://unix.stackexchange.com/questions/26047/how-to-correctly-add-a-path-to-path) environment variable.
+
+
 #### Workflow
 
 * Fork the repository
@@ -54,24 +87,94 @@ $ mocha test/core/transformation.js --grep es7
 * Ensure the test are passing (`make test`)
 * Create new pull request explaining your proposed change or reference an issue in your commit message
 
+#### Dependencies
+
++ [ast-types](http://ghub.io/ast-types) This is required to monkeypatch regenerators AST definitions. Could be improved in the future.
+
++ [chalk](http://ghub.io/chalk) This is used for terminal color highlighting for syntax errors.
+
++ [convert-source-map](http://ghub.io/convert-source-map) Turns a source map object into a comment etc.
+
++ [core-js](http://ghub.io/core-js) Used for the polyfill.
+
++ [debug](http://ghub.io/debug) Used to output debugging information when NODE_DEBUG is set to babel.
+
++ [detect-indent](http://ghub.io/detect-indent) This is used in the code generator so it can infer indentation.
+
++ [estraverse](http://ghub.io/estraverse) The only method on this is attachComments. I'd like to implement our own comment attachment algorithm eventually though.
+
++ [esutils](http://ghub.io/esutils) Various ES related utilities. Check whether something is a keyword etc.
+
++ [fs-readdir-recursive](http://ghub.io/fs-readdir-recursive) Recursively search a directory for.
+
++ [globals](http://ghub.io/globals) A list of JavaScript global variables. This is used by the scope tracking to check for colliding variables.
+
++ [is-integer](http://ghub.io/is-integer) Checks if something is an integer.
+
++ [js-tokens](http://ghub.io/js-tokens) This is used to get tokens for syntax error highlighting.
+
++ [line-numbers](http://ghub.io/line-numbers) Used to produce the code frames in syntax errors.
+
++ [lodash](http://ghub.io/lodash) Used for various utilities.
+
++ [minimatch](http://ghub.io/minimatch) This is used to match glob-style ignore/only filters.
+
++ [output-file-sync](http://ghub.io/output-file-sync) Synchronously writes a file and create its ancestor directories if needed.
+
++ [path-is-absolute](http://ghub.io/path-is-absolute) Checks if a path is absolute. C:\foo and \foo are considered absolute.
+
++ [regenerator](http://ghub.io/regenerator) This is used to transform generators/async functions.
+
++ [regexpu](http://ghub.io/regexpu) Used to transform unicode regex patterns.
+
++ [repeating](http://ghub.io/repeating) Repeats a string.
+
++ [shebang-regex](http://ghub.io/shebang-regex) Literally just a regex that matches shebangs.
+
++ [slash](http://ghub.io/slash) Normalises path separators.
+
++ [source-map](http://ghub.io/source-map) Generates sourcemaps.
+
++ [source-map-support](http://ghub.io/source-map-support) Adds source map support to babel-node/babel/register.
+
++ [strip-json-comments](http://ghub.io/strip-json-comments) Remove comments from a JSON string. This is used for .babelrc files.
+
++ [to-fast-properties](http://ghub.io/to-fast-properties) A V8 trick to put an object into fast properties mode.
+
++ [trim-right](http://ghub.io/trim-right) Trims the rightside whitespace.
+
++ [path-exists](https://www.npmjs.com/package/path-exists) Checks if a path exists. (replaces the deprecated `fs.exists` methods)
+
++ [home-or-tmp](https://github.com/sindresorhus/home-or-tmp) Gets the user home directory with fallback to the system temporary directory. This is used to resolve the babel-node/babel/register cache.
+
++ [resolve](https://www.npmjs.com/package/resolve) Implements the [`require.resolve()` algorithm](http://nodejs.org/docs/v0.12.0/api/all.html#all_require_resolve) such that we can `require.resolve()` on behalf of a file asynchronously and synchronously.
+
 #### Code Standards
 
  * **General**
    * Max of five arguments for functions
    * Max depth of four nested blocks
    * 2-spaced soft tabs
+
  * **Naming**
    * CamelCase all class names
    * camelBack all variable names
+
  * **Spacing**
    * Spaces after all keywords
    * Spaces before all left curly braces
+
  * **Comments**
    * Use JSDoc-style comments for methods
    * Single-line comments for ambiguous code
+
  * **Quotes**
    * Always use double quotes
    * Only use single quotes when the string contains a double quote
+
  * **Declaration**
    * No unused variables
    * No pollution of global variables and prototypes
+
+#### Internals
+Please see [`/doc`](/doc) for internals documentation relevant to developing babel.

Makefile

@@ -3,23 +3,29 @@ BROWSERIFY_CMD = node_modules/browserify/bin/cmd.js
 ISTANBUL_CMD = node_modules/istanbul/lib/cli.js cover
 UGLIFY_CMD = node_modules/uglify-js/bin/uglifyjs
 #UGLIFY_CMD = node_modules/uglify-js/bin/uglifyjs --mangle sort
-JSHINT_CMD = node_modules/jshint/bin/jshint
 MOCHA_CMD = node_modules/mocha/bin/_mocha
 BABEL_CMD = node_modules/babel/bin/babel
+BROWSERIFY_IGNORE = -i esprima-fb
 
 export NODE_ENV = test
 
-.PHONY: clean test test-cov test-clean test-travis test-simple test-all test-browser test-parser publish build bootstrap publish-core publish-runtime build-core watch-core build-core-test
+.PHONY: clean test test-cov test-clean test-travis test-simple test-all test-browser test-parser publish build bootstrap publish-core publish-runtime build-website build-core watch-core build-core-test clean-core prepublish
 
-build-core:
+build-core: clean-core
 	node $(BABEL_CMD) src --out-dir lib --copy-files
 
-build-core-test:
-	node $(BABEL_CMD) src --out-dir lib --copy-files --auxiliary-comment "istanbul ignore next"
+build-core-test: clean-core
+	node $(BABEL_CMD) src --out-dir lib --copy-files --auxiliary-comment-before "istanbul ignore next"
 
-watch-core:
+watch-core: clean-core
 	node $(BABEL_CMD) src --out-dir lib --watch --copy-files
 
+clean-core:
+	rm -rf lib
+
+lint:
+	eslint src/babel packages/babel-cli/bin
+
 build:
 	mkdir -p dist
 	make build-core
@@ -29,8 +35,10 @@ build:
 	node $(BROWSERIFY_CMD) -e lib/babel/polyfill.js >dist/polyfill.js
 	node $(UGLIFY_CMD) dist/polyfill.js >dist/polyfill.min.js
 
-	node $(BROWSERIFY_CMD) lib/babel/api/browser.js -s babel >dist/babel.js
-	node $(UGLIFY_CMD) dist/babel.js >dist/babel.min.js
+	node $(BROWSERIFY_CMD) lib/babel/api/browser.js -s babel $(BROWSERIFY_IGNORE) >dist/browser.js
+	node $(UGLIFY_CMD) dist/browser.js >dist/browser.min.js
+
+	node $(BROWSERIFY_CMD) lib/babel/api/node.js --node $(BROWSERIFY_IGNORE) >dist/node.js
 
 	node packages/babel-cli/bin/babel-external-helpers >dist/external-helpers.js
 	node $(UGLIFY_CMD) dist/external-helpers.js >dist/external-helpers.min.js
@@ -59,7 +67,7 @@ test-cov:
 test-parser:
 	node test/acorn/run.js
 
-test-travis: bootstrap build test
+test-travis: bootstrap lint build test
 
 test-browser:
 	mkdir -p dist
@@ -71,30 +79,22 @@ test-browser:
 
 	test -n "`which open`" && open test/browser.html
 
-publish:
+publish: lint
 	git pull --rebase
-
 	make test
-
 	read -p "Version: " version; \
 	npm version $$version --message "v%s"
-
-	make build
-	cp dist/babel.min.js browser.js
-	cp dist/polyfill.min.js browser-polyfill.js
-	cp dist/external-helpers.min.js external-helpers.js
-
-	node tools/cache-templates
-	test -f templates.json
-
-	npm publish
-
 	git push --follow-tags
 
-	make publish-cli
-	make publish-runtime
-
-	rm -rf templates.json browser.js browser-polyfill.js external-helpers.js
+prepublish: build
+	cp dist/browser.js browser.js
+	cp dist/browser.min.js browser.min.js
+	cp dist/polyfill.js browser-polyfill.js
+	cp dist/polyfill.min.js browser-polyfill.min.js
+	cp dist/external-helpers.js external-helpers.js
+	cp dist/external-helpers.min.js external-helpers.min.js
+	node tools/cache-templates
+	test -f templates.json
 
 publish-runtime:
 	cd packages; \
@@ -103,10 +103,13 @@ publish-runtime:
 	npm publish
 
 publish-cli:
-	cd packages; \
-	node build-cli.js; \
-	cd babel-cli; \
-	npm publish
+	@./tools/publish-cli.sh
+
+build-website:
+	@./tools/build-website.sh
+
+comment-issues:
+	@./tools/comment-issues.sh
 
 bootstrap:
 	npm list --global --depth 1 babel >/dev/null 2>&1 && npm uninstall -g babel || true
@@ -114,5 +117,4 @@ bootstrap:
 	npm link
 	cd packages/babel-cli && npm install && npm link && npm link babel-core
 	git submodule update --init
-	cd vendor/regenerator && npm install
-	cd vendor/compat-table && npm install object-assign
+	make build

README.md

@@ -1,15 +1,28 @@
 <p align="center">
   <a href="https://babeljs.io/">
-    <img alt="babel" src="https://raw.githubusercontent.com/babel/logo/master/logo.png" width="546">
+    <img alt="babel" src="https://raw.githubusercontent.com/babel/logo/master/babel.png" width="546">
   </a>
 </p>
 
 <p align="center">
-  <strong>Babel</strong> is a compiler for writing next generation JavaScript.
+  The compiler for writing next generation JavaScript.
 </p>
 
 <p align="center">
-  For questions and support please visit the <a href="https://gitter.im/babel/babel">gitter room</a> or <a href="http://stackoverflow.com/questions/tagged/babeljs">StackOverflow</a>. The Babel issue tracker is <strong>exclusively</strong> for bug reports and feature requests.
+  <a href="https://travis-ci.org/babel/babel"><img alt="Build Status" src="https://img.shields.io/travis/babel/babel.svg?style=flat"></a>
+  <a href="http://badge.fury.io/js/babel-core"><img alt="npm version" src="https://badge.fury.io/js/babel-core.svg"></a>
+  <a href="https://npmjs.org/package/babel-core"><img alt="Downloads" src="http://img.shields.io/npm/dm/babel-core.svg"></a>
+</p>
+
+<p align="center">
+  <a href="http://issuestats.com/github/babel/babel"><img alt="Issue Stats" src="http://issuestats.com/github/babel/babel/badge/pr?style=flat"></a>
+  <a href="http://issuestats.com/github/babel/babel"><img alt="Issue Stats" src="http://issuestats.com/github/babel/babel/badge/issue?style=flat"></a>
+</p>
+
+----
+
+<p align="center">
+  For questions and support please visit the <a href="https://babel-slack.herokuapp.com">Slack community</a> or <a href="http://stackoverflow.com/questions/tagged/babeljs">StackOverflow</a>. The Babel issue tracker is <strong>exclusively</strong> for bug reports and feature requests.
 </p>
 
 <p align="center">

doc/index.md

@@ -0,0 +1,4 @@
+This is a collection of documentation about babel internals, for use in development of babel.
+
+# [Properties of nodes](/doc/node-props.md)
+These are properties babel stores in AST node objects for internal use, as opposed to properties that are part of the AST spec (ESTree at the time of this writing).

doc/node-props.md

@@ -0,0 +1,11 @@
+# Properties of nodes
+These are properties babel stores in AST node objects for internal use, as opposed to properties that are part of the AST spec ([ESTree](https://github.com/estree/estree) at the time of this writing).
+
+## `_blockHoist`
+`node._blockHoist != null` triggers the [block-hoist transformer](/src/babel/transformation/transformers/internal/block-hoist.js). Value should be `true` or an integer in the range `0..3`. `true` is equivalent to `2`. The value indicates whether the node should be hoisted and to what degree. See the source code for more detailed information.
+
+## `_paths`
+Stores a representation of a node's position in the tree and relationship to other nodes.
+
+## `shadow`
+A truthy value on a function node triggers the [shadow-functions transformer](/src/babel/transformation/transformers/internal/shadow-functions.js), which transforms the node so that it references (or inherits) `arguments` and the `this` context from the parent scope. It is invoked for arrow functions, for example.

index.js

@@ -0,0 +1 @@
+module.exports = require("./lib/babel/api/node.js");

package.json

@@ -1,69 +1,85 @@
 {
   "name": "babel-core",
-  "description": "Turn ES6 code into readable vanilla ES5 with source maps",
-  "version": "5.1.2",
+  "description": "A compiler for writing next generation JavaScript",
+  "version": "5.6.20",
   "author": "Sebastian McKenzie <sebmck@gmail.com>",
   "homepage": "https://babeljs.io/",
+  "license": "MIT",
   "repository": "babel/babel",
-  "main": "lib/babel/api/node.js",
   "browser": {
     "./lib/babel/api/register/node.js": "./lib/babel/api/register/browser.js"
   },
   "keywords": [
-    "harmony",
+    "6to5",
+    "babel",
     "classes",
-    "modules",
-    "let",
     "const",
-    "var",
     "es6",
+    "harmony",
+    "let",
+    "modules",
     "transpile",
     "transpiler",
-    "6to5",
-    "babel"
+    "var"
   ],
   "scripts": {
     "bench": "make bench",
     "test": "make test"
   },
   "dependencies": {
-    "ast-types": "~0.7.0",
+    "acorn-jsx": "^1.0.0",
+    "babel-plugin-constant-folding": "^1.0.1",
+    "babel-plugin-dead-code-elimination": "^1.0.2",
+    "babel-plugin-eval": "^1.0.1",
+    "babel-plugin-inline-environment-variables": "^1.0.1",
+    "babel-plugin-jscript": "^1.0.1",
+    "babel-plugin-member-expression-literals": "^1.0.1",
+    "babel-plugin-property-literals": "^1.0.1",
+    "babel-plugin-proto-to-assign": "^1.0.3",
+    "babel-plugin-react-constant-elements": "^1.0.3",
+    "babel-plugin-react-display-name": "^1.0.3",
+    "babel-plugin-remove-console": "^1.0.1",
+    "babel-plugin-remove-debugger": "^1.0.1",
+    "babel-plugin-runtime": "^1.0.7",
+    "babel-plugin-undeclared-variables-check": "^1.0.2",
+    "babel-plugin-undefined-to-void": "^1.1.6",
     "chalk": "^1.0.0",
-    "convert-source-map": "^1.0.0",
-    "core-js": "^0.8.1",
+    "convert-source-map": "^1.1.0",
+    "core-js": "^0.9.0",
     "debug": "^2.1.1",
     "detect-indent": "^3.0.0",
-    "estraverse": "^3.0.0",
+    "estraverse": "^4.0.0",
     "esutils": "^2.0.0",
     "fs-readdir-recursive": "^0.1.0",
     "globals": "^6.4.0",
+    "home-or-tmp": "^1.0.0",
     "is-integer": "^1.0.4",
-    "js-tokens": "1.0.0",
-    "leven": "^1.0.1",
+    "js-tokens": "1.0.1",
     "line-numbers": "0.2.0",
     "lodash": "^3.6.0",
     "minimatch": "^2.0.3",
     "output-file-sync": "^1.1.0",
+    "path-exists": "^1.0.0",
     "path-is-absolute": "^1.0.0",
     "private": "^0.1.6",
-    "regenerator": "https://github.com/sebmck/regenerator/archive/block-hoist.tar.gz",
+    "regenerator": "0.8.34",
     "regexpu": "^1.1.2",
     "repeating": "^1.1.2",
+    "resolve": "^1.1.6",
     "shebang-regex": "^1.0.0",
     "slash": "^1.0.0",
     "source-map": "^0.4.0",
     "source-map-support": "^0.2.10",
     "strip-json-comments": "^1.0.2",
     "to-fast-properties": "^1.0.0",
-    "trim-right": "^1.0.0",
-    "user-home": "^1.1.1"
+    "trim-right": "^1.0.0"
   },
   "devDependencies": {
-    "babel": "4.7.13",
+    "babel": "5.6.10",
+    "babel-eslint": "^3.1.19",
     "browserify": "^9.0.8",
     "chai": "^2.2.0",
-    "eslint": "^0.18.0",
-    "babel-eslint": "^2.0.0",
+    "eslint": "^0.21.2",
     "esvalid": "^1.1.0",
     "istanbul": "^0.3.5",
     "matcha": "^0.6.0",

packages/babel-cli/bin/_babel-node

@@ -18,9 +18,9 @@ program.option("-p, --print [code]", "Evaluate script and print result");
 program.option("-i, --ignore [regex]", "Ignore all files that match this regex when using the require hook");
 program.option("-x, --extensions [extensions]", "List of extensions to hook into [.es6,.js,.es,.jsx]");
 program.option("-r, --stage [stage]", "Enable support for specific ECMAScript stages");
-program.option("-w, --whitelist [whitelist]", "Whitelist of transformers to ONLY use", util.list);
-program.option("-b, --blacklist [blacklist]", "Blacklist of transformers to NOT use", util.list);
-program.option("-o, --optional [optional]", "List of optional transformers to enable", util.list);
+program.option("-w, --whitelist [whitelist]", "Whitelist of transformers separated by comma to ONLY use", util.list);
+program.option("-b, --blacklist [blacklist]", "Blacklist of transformers separated by comma to NOT use", util.list);
+program.option("-o, --optional [optional]", "List of optional transformers separated by comma to enable", util.list);
 
 var pkg = require("../package.json");
 program.version(pkg.version);
@@ -41,6 +41,7 @@ babel.register({
 //
 
 var _eval = function (code, filename) {
+  code = code.trim();
   if (!code) return undefined;
 
   code = babel.transform(code, {
@@ -107,6 +108,7 @@ if (program.eval || program.print) {
 
     // add back on node and concat the sliced args
     process.argv = ["node"].concat(args);
+    process.execArgv.unshift(__filename);
 
     Module.runMain();
   } else {

packages/babel-cli/bin/babel-node

@@ -55,6 +55,8 @@ babelArgs.forEach(function(arg){
     case "--harmony_classes":
     case "--harmony_object_literals":
     case "--harmony_templates":
+    case "--harmony_rest_parameters":
+    case "--harmony_generators":
     case "--compiled_keyed_generic_loads":
     case "--pretenuring_call_new":
     case "--allocation_site_pretenuring":
@@ -410,6 +412,7 @@ babelArgs.forEach(function(arg){
     case "--prof_auto":
     case "--prof_lazy":
     case "--sliding_state_window":
+    case "--nolazy":
       args.unshift(arg);
       break;
 

packages/babel-cli/bin/babel-plugin/index.js

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+
+var pathExists = require("path-exists");
+var readline   = require("readline");
+var child      = require("child_process");
+var path       = require("path");
+var fs         = require("fs");
+
+function spawn(cmd, args, callback) {
+  console.log(">", cmd, args);
+
+  var spawn = child.spawn(cmd, args, { stdio: "inherit" });
+
+  spawn.on("exit", function (code) {
+    if (code === 0) {
+      if (callback) callback();
+    } else {
+      console.log("Killing...");
+      process.exit(1);
+    }
+  });
+}
+
+function spawnMultiple(cmds) {
+  function next() {
+    var cmd = cmds.shift();
+    if (cmd) {
+      spawn(cmd.command, cmd.args, next);
+    } else {
+      process.exit();
+    }
+  }
+
+  next();
+}
+
+function template(name, data) {
+  var source = fs.readFileSync(path.join(__dirname, "templates", name), "utf8");
+  source = source.replace(/[A-Z_]+/g, function (key) {
+    return data[key] === undefined ? key : data[key];
+  });
+  return source;
+}
+
+function write(filename, content) {
+  console.log(filename);
+  fs.writeFileSync(filename, content);
+}
+
+var rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+
+var BABEL_PLUGIN_PREFIX = "babel-plugin-";
+
+var cmds = {
+  init: function () {
+    var name = path.basename(process.cwd());
+
+    if (name.indexOf(BABEL_PLUGIN_PREFIX) === 0) {
+      name = name.slice(BABEL_PLUGIN_PREFIX.length);
+    }
+
+    rl.question("Description (optional): ", function (description) {
+      rl.question("GitHub Repository (eg. sebmck/babel-plugin-foobar) (optional): ", function (repo) {
+        rl.close();
+
+        var templateData = {
+          DESCRIPTION: description,
+          FULL_NAME: BABEL_PLUGIN_PREFIX + name,
+          NAME: name
+        };
+
+        write("package.json", JSON.stringify({
+          name: templateData.FULL_NAME,
+          version: "1.0.0",
+          description: templateData.DESCRIPTION,
+          repository: repo || undefined,
+          license: "MIT",
+          main: "lib/index.js",
+
+          devDependencies: {
+            babel: "^5.6.0"
+          },
+
+          scripts: {
+            build: "babel-plugin build",
+            push:  "babel-plugin publish",
+            test:  "babel-plugin test"
+          },
+
+          keywords: ["babel-plugin"]
+        }, null, "  ") + "\n");
+
+        write(".npmignore", "node_modules\n*.log\nsrc\n");
+
+        write(".gitignore", "node_modules\n*.log\nlib\n");
+
+        write("README.md", template("README.md", templateData));
+
+        if (!pathExists.sync("src")) {
+          fs.mkdirSync("src");
+          write("src/index.js", template("index.js", templateData));
+        }
+      });
+    });
+  },
+
+  build: function () {
+    spawn("babel", ["src", "--out-dir", "lib", "--copy-files"]);
+  },
+
+  publish: function () {
+    var pkg = require(process.cwd() + "/package.json");
+    console.log("Current verison:", pkg.version);
+
+    rl.question("New version (enter nothing for patch): ", function (newVersion) {
+      rl.close();
+
+      newVersion = newVersion || "patch";
+
+      spawnMultiple([
+        { command: "git", args: ["pull"] },
+        { command: "git", args: ["push"] },
+        { command: "babel-plugin", args: ["build"] },
+        { command: "npm", args: ["version", newVersion] },
+        { command: "npm", args: ["publish"] },
+        { command: "git", args: ["push", "--follow-tags"] }
+      ]);
+    });
+  }
+};
+
+var cmd = cmds[process.argv[2]];
+if (cmd) {
+  cmd();
+} else {
+  console.error("Unknown command:", cmd);
+  process.exit(1);
+}

packages/babel-cli/bin/babel-plugin/templates/README.md

@@ -0,0 +1,35 @@
+# FULL_NAME
+
+DESCRIPTION
+
+## Installation
+
+```sh
+$ npm install FULL_NAME
+```
+
+## Usage
+
+### Via `.babelrc` (Recommended)
+
+**.babelrc**
+
+```json
+{
+  "plugins": ["NAME"]
+}
+```
+
+### Via CLI
+
+```sh
+$ babel --plugins NAME script.js
+```
+
+### Via Node API
+
+```javascript
+require("babel-core").transform("code", {
+  plugins: ["NAME"]
+});
+```

packages/babel-cli/bin/babel-plugin/templates/index.js

@@ -0,0 +1,7 @@
+export default function ({ Plugin, types: t }) {
+  return new Plugin("NAME", {
+    visitor: {
+      // your visitor methods go here
+    }
+  });
+}

packages/babel-cli/bin/babel/dir.js

@@ -1,11 +1,13 @@
 var outputFileSync = require("output-file-sync");
+var pathExists     = require("path-exists");
 var chokidar       = require("chokidar");
+var slash          = require("slash");
 var path           = require("path");
 var util           = require("./util");
 var fs             = require("fs");
 var _              = require("lodash");
 
-module.exports = function (commander, filenames, opts) {
+module.exports = function (commander, filenames) {
   var write = function (src, relative) {
     // remove extension and then append back on .js
     relative = relative.replace(/\.(\w*?)$/, "") + ".js";
@@ -13,8 +15,10 @@ module.exports = function (commander, filenames, opts) {
     var dest = path.join(commander.outDir, relative);
 
     var data = util.compile(src, {
-      sourceFileName: path.relative(dest + "/..", src)
+      sourceFileName: slash(path.relative(dest + "/..", src)),
+      sourceMapTarget: path.basename(relative)
     });
+    if (data.ignored) return;
 
     if (commander.sourceMaps && commander.sourceMaps !== "inline") {
       var mapLoc = dest + ".map";
@@ -24,13 +28,13 @@ module.exports = function (commander, filenames, opts) {
 
     outputFileSync(dest, data.code);
 
-    console.log(src + " -> " + dest);
+    util.log(src + " -> " + dest);
   };
 
   var handleFile = function (src, filename) {
     if (util.shouldIgnore(src)) return;
 
-    if (util.canCompile(filename)) {
+    if (util.canCompile(filename, commander.extensions)) {
       write(src, filename);
     } else if (commander.copyFiles) {
       outputFileSync(path.join(commander.outDir, filename), fs.readFileSync(src));
@@ -38,7 +42,7 @@ module.exports = function (commander, filenames, opts) {
   };
 
   var handle = function (filename) {
-    if (!fs.existsSync(filename)) return;
+    if (!pathExists.sync(filename)) return;
 
     var stat = fs.statSync(filename);
 

packages/babel-cli/bin/babel/file.js

@@ -1,6 +1,8 @@
 var convertSourceMap = require("convert-source-map");
+var pathExists       = require("path-exists");
 var sourceMap        = require("source-map");
 var chokidar         = require("chokidar");
+var slash            = require("slash");
 var path             = require("path");
 var util             = require("./util");
 var fs               = require("fs");
@@ -15,7 +17,8 @@ module.exports = function (commander, filenames, opts) {
 
   var buildResult = function () {
     var map = new sourceMap.SourceMapGenerator({
-      file: commander.outFile || "stdout"
+      file: path.basename(commander.outFile) || "stdout",
+      sourceRoot: opts.sourceRoot
     });
 
     var code = "";
@@ -28,8 +31,14 @@ module.exports = function (commander, filenames, opts) {
       if (result.map) {
         var consumer = new sourceMap.SourceMapConsumer(result.map);
 
-        map._sources.add(filename);
-        map.setSourceContent(filename, result.actual);
+        var sourceFilename = filename;
+        if (commander.outFile) {
+          sourceFilename = path.relative(path.dirname(commander.outFile), sourceFilename);
+        }
+        sourceFilename = slash(sourceFilename);
+
+        map._sources.add(sourceFilename);
+        map.setSourceContent(sourceFilename, result.actual);
 
         consumer.eachMapping(function (mapping) {
           map._mappings.add({
@@ -37,7 +46,7 @@ module.exports = function (commander, filenames, opts) {
             generatedColumn: mapping.generatedColumn,
             originalLine: mapping.originalLine,
             originalColumn: mapping.originalColumn,
-            source: filename
+            source: sourceFilename
           });
         });
 
@@ -92,7 +101,7 @@ module.exports = function (commander, filenames, opts) {
     results = [];
 
     _.each(filenames, function (filename) {
-      if (!fs.existsSync(filename)) return;
+      if (!pathExists.sync(filename)) return;
 
       var stat = fs.statSync(filename);
       if (stat.isDirectory()) {
@@ -109,7 +118,9 @@ module.exports = function (commander, filenames, opts) {
     _.each(_filenames, function (filename) {
       if (util.shouldIgnore(filename)) return;
 
-      results.push(util.compile(filename));
+      var data = util.compile(filename);
+      if (data.ignored) return;
+      results.push(data);
     });
 
     output();
@@ -124,7 +135,7 @@ module.exports = function (commander, filenames, opts) {
         ignoreInitial: true
       }).on("all", function (type, filename) {
         if (type === "add" || type === "change") {
-          console.log(type, filename);
+          util.log(type + " " + filename);
           try {
             walk();
           } catch (err) {

packages/babel-cli/bin/babel/index.js

@@ -1,13 +1,18 @@
 #!/usr/bin/env node
 
-var commander = require("commander");
-var transform = require("babel-core").transform;
-var kebabCase = require("lodash/string/kebabCase");
-var options   = require("babel-core").options;
-var util      = require("babel-core").util;
-var each      = require("lodash/collection/each");
-var keys      = require("lodash/object/keys");
-var fs        = require("fs");
+require("babel-core");
+
+var moduleFormatters = require("babel-core/lib/babel/transformation/modules");
+var pathExists       = require("path-exists");
+var commander        = require("commander");
+var transform        = require("babel-core").transform;
+var kebabCase        = require("lodash/string/kebabCase");
+var options          = require("babel-core").options;
+var util             = require("babel-core").util;
+var uniq             = require("lodash/array/uniq");
+var each             = require("lodash/collection/each");
+var keys             = require("lodash/object/keys");
+var glob             = require("glob");
 
 each(options, function (option, key) {
   if (option.hidden) return;
@@ -33,12 +38,14 @@ each(options, function (option, key) {
   if (option.description) desc.push(option.description);
 
   commander.option(arg, desc.join(" "));
-})
+});
 
+commander.option("-x, --extensions [extensions]", "List of extensions to compile when a directory has been input [.es6,.js,.es,.jsx]");
 commander.option("-w, --watch", "Recompile files on changes");
 commander.option("-o, --out-file [out]", "Compile all input files into a single file");
 commander.option("-d, --out-dir [out]", "Compile an input directory of modules into an output directory");
 commander.option("-D, --copy-files", "When compiling a directory copy over non-compilable files");
+commander.option("-q, --quiet", "Don't log anything");
 
 commander.on("--help", function () {
   var outKeys = function (title, obj) {
@@ -48,7 +55,7 @@ commander.on("--help", function () {
     each(keys(obj).sort(), function (key) {
       if (key[0] === "_") return;
 
-      if (obj[key].optional) key = "[" + key + "]";
+      if (obj[key].metadata && obj[key].metadata.optional) key = "[" + key + "]";
 
       console.log("    - " + key);
     });
@@ -56,23 +63,35 @@ commander.on("--help", function () {
     console.log();
   };
 
-  outKeys("Transformers", transform.transformers);
-  outKeys("Module formatters", transform.moduleFormatters);
+  outKeys("Transformers", transform.pipeline.transformers);
+  outKeys("Module formatters", moduleFormatters);
 });
 
 var pkg = require("../../package.json");
-commander.version(pkg.version);
+commander.version(pkg.version + " (babel-core " + require("babel-core").version + ")");
 commander.usage("[options] <files ...>");
 commander.parse(process.argv);
 
 //
 
+if (commander.extensions) {
+  commander.extensions = util.arrayify(commander.extensions);
+}
+
+//
+
 var errors = [];
 
-var filenames = commander.args;
+var filenames = commander.args.reduce(function (globbed, input) {
+  var files = glob.sync(input);
+  if (!files.length) files = [input];
+  return globbed.concat(files);
+}, []);
+
+filenames = uniq(filenames);
 
 each(filenames, function (filename) {
-  if (!fs.existsSync(filename)) {
+  if (!pathExists.sync(filename)) {
     errors.push(filename + " doesn't exist");
   }
 });
@@ -105,11 +124,16 @@ if (errors.length) {
 var opts = exports.opts = {};
 
 each(options, function (opt, key) {
-  opts[key] = commander[key];
+  if (commander[key] !== undefined) {
+    opts[key] = commander[key];
+  }
 });
 
 opts.ignore = util.arrayify(opts.ignore, util.regexify);
-opts.only   = util.arrayify(opts.only, util.regexify);
+
+if (opts.only) {
+  opts.only = util.arrayify(opts.only, util.regexify);
+}
 
 var fn;
 

packages/babel-cli/bin/babel/util.js

@@ -1,10 +1,11 @@
-var readdir = require("fs-readdir-recursive");
-var index   = require("./index");
-var babel   = require("babel-core");
-var util    = require("babel-core").util;
-var path    = require("path");
-var fs      = require("fs");
-var _       = require("lodash");
+var commander = require("commander");
+var readdir   = require("fs-readdir-recursive");
+var index     = require("./index");
+var babel     = require("babel-core");
+var util      = require("babel-core").util;
+var path      = require("path");
+var fs        = require("fs");
+var _         = require("lodash");
 
 exports.readdirFilter = function (filename) {
   return readdir(filename).filter(function (filename) {
@@ -24,6 +25,10 @@ exports.addSourceMappingUrl = function (code, loc) {
   return code + "\n//# sourceMappingURL=" + path.basename(loc);
 };
 
+exports.log = function (msg) {
+  if (!commander.quiet) console.log(msg);
+};
+
 exports.transform = function (filename, code, opts) {
   opts = _.defaults(opts || {}, index.opts);
   opts.filename = filename;
@@ -37,6 +42,15 @@ exports.transform = function (filename, code, opts) {
 };
 
 exports.compile = function (filename, opts) {
-  var code = fs.readFileSync(filename, "utf8");
-  return exports.transform(filename, code, opts);
+  try {
+    var code = fs.readFileSync(filename, "utf8");
+    return exports.transform(filename, code, opts);
+  } catch (err) {
+    if (commander.watch) {
+      console.error(err.stack);
+      return { ignored: true };
+    } else {
+      throw err;
+    }
+  }
 };

packages/babel-cli/package.json

@@ -1,25 +1,28 @@
 {
   "name": "babel",
   "description": "Turn ES6 code into readable vanilla ES5 with source maps",
-  "version": "5.1.1",
   "author": "Sebastian McKenzie <sebmck@gmail.com>",
   "homepage": "https://babeljs.io/",
+  "license": "MIT",
   "repository": "babel/babel",
   "preferGlobal": true,
   "dependencies": {
-    "babel-core": "^5.1.1",
     "chokidar": "^1.0.0",
     "commander": "^2.6.0",
+    "convert-source-map": "^1.1.0",
     "fs-readdir-recursive": "^0.1.0",
-    "output-file-sync": "^1.1.0",
+    "glob": "^5.0.5",
     "lodash": "^3.2.0",
-    "convert-source-map": "^0.5.0",
+    "output-file-sync": "^1.1.0",
+    "path-exists": "^1.0.0",
+    "path-is-absolute": "^1.0.0",
     "source-map": "^0.4.0",
-    "path-is-absolute": "^1.0.0"
+    "slash": "^1.0.0"
   },
   "bin": {
     "babel": "./bin/babel/index.js",
     "babel-node": "./bin/babel-node",
-    "babel-external-helpers": "./bin/babel-external-helpers"
+    "babel-external-helpers": "./bin/babel-external-helpers",
+    "babel-plugin": "./bin/babel-plugin/index.js"
   }
-}
+}

packages/babel-cli/register-without-polyfill.js

@@ -0,0 +1 @@
+module.exports = require("babel-core/register-without-polyfill");

packages/babel-runtime/package.json

@@ -1,10 +1,10 @@
 {
   "name": "babel-runtime",
   "description": "babel selfContained runtime",
-  "version": "5.1.1",
+  "license": "MIT",
   "repository": "babel/babel",
   "author": "Sebastian McKenzie <sebmck@gmail.com>",
   "dependencies": {
-    "core-js": "^0.8.0"
+    "core-js": "^0.9.0"
   }
-}
+}

packages/build-runtime.js

@@ -70,12 +70,11 @@ each(File.helpers, function (helperName) {
   writeFile("helpers/" + helperName + ".js", buildHelper(helperName));
 });
 
-writeFile("regenerator/index.js", readFile("regenerator-babel/runtime-module", true));
-writeFile("regenerator/runtime.js", selfContainify(readFile("regenerator-babel/runtime")));
+writeFile("regenerator/index.js", readFile("regenerator/runtime-module", true));
+writeFile("regenerator/runtime.js", selfContainify(readFile("regenerator/runtime")));
 
-//
 
-var coreDefinitions = require("../lib/babel/transformation/transformers/other/runtime/definitions");
+var coreDefinitions = require("babel-plugin-runtime/lib/definitions");
 
 var paths = ["is-iterable", "get-iterator"];
 
@@ -93,6 +92,5 @@ each(paths, function (path) {
   writeFile("core-js/" + path + ".js", defaultify('require("core-js/library/fn/' + path + '")'));
 });
 
-//
 
 updatePackage();

register-without-polyfill.js

@@ -0,0 +1 @@
+module.exports = require("./lib/babel/api/register/node");

register.js

@@ -1 +1 @@
-module.exports = require("./lib/babel/api/register/node");
+module.exports = require("./lib/babel/api/register/node-polyfill");

sebmck-bjs.nfo

@@ -0,0 +1,48 @@
+
+                          ======                             ==========M=
+                     =============        ==    ======O=   ======= MM  ==
+                   M==+===      ==M      ===  ====     ==  ===        ==
+                  =D  ===      ===      ====MM ==M    ==M ==M        ===
+                     ===M    ====M     ====    =D   ===M ===   ===   ==
+                     ==7   ====M     ==M ==   ========  =========M  ==M
+                    ===========     ======M  ===MMM === ==M         ==
+                   =======MM==========MM==  ==M     ==M===         ==
+                   ==M       === M==   ==M  ==    === ===          =D        =
+                  ==M      ===+  ==    ==  ==  ==$M   =========== ============M
+                 ===     ====M  ==    ==M ===M==     ====?MMMM       M M
+                 ==   =====   ==M     == ==MM         M
+                ==M===M=M     =M     =MM  M           M
+               ==MM=M                ==
+              MMM                   =M
+               M
+
+                              > ú B ú A ú B ú E ú L ú <
+    ÕÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÑÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ͸
+    ³ SOFTWARE .. : JavaScript Compiler  ³ COMPANY ... : N/A                     ³
+    ³ SUPPLIER .. : N/A                  ³ CRACKER ... : Sebastian McKenzie      ³
+    ³ RATING .... : depends..            ³ PACKAGER .. : Sebastian McKenzie      ³
+    ³ ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ ³
+    ³ GRAFIX .... : -                    ³ SOUND ..... : -                       ³
+    ÔÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÏÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ;
+
+     Babel is a JavaScript compiler and transformation platform for writing NeXt
+     GeNeRaTiOn JavaScript.
+
+     ÆÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÏÍÍÍÍÍÍÍÍÍÍÍÍÍÍÏÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÏÍÍÍÍÍÍÍÏÍÍÍÍÍÍÍÍÍÍÍ͵
+     ³                                :: Greets ::                              ³
+     ³                                                                          ³
+     ³  sebmck, thejameskyle, RReverser, zloirock, monsanto, gaearon, zertosh,  ³
+     ³  stefanpenner, eventualbuddha, AluisioASG, Apoxx, Couto, dominicbarnes,  ³
+     ³    es128, gordonkristan, hkjels, jmeas, josh, loganfsmyth, nightire,     ³
+     ³           Rich-Harris, shinnn, shuhei, sindresorhus, tricknotes          ³
+     ³                                                                          ³
+     ÔÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ;
+
+                  -*- JavaScripts for all , All for JavaScripts ! -*-
+
+    ÕÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ͸
+    ³  If you want to Contact us, call 555-720-4228, Use the Handle "BABEL"  w/  ³
+    ³  password : VISITOR and leave a mail to Sebastian or James.                ³
+    ÔÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ;
+
+                               -=- We LoVe fun Too! -=-

src/README.md

@@ -0,0 +1,27 @@
+## Welcome to the Babel Codebase
+
+Babel is broken down into three parts:
+
+- Parsing
+- [Transformation](babel/transformation/)
+- [Generation](babel/generation/)
+
+**Parsing** is the process of turning a piece of code into an [ESTree spec](https://github.com/estree/estree) compatible AST (Abstract
+Syntax Tree) which is a tree-like object of nodes that _describes_ the code.
+This makes it easier to transform the code over direct string manpulation.
+
+**Transformation** is the process of taking an AST and manipulating it into
+a new one. For example, Babel might take an ES2015 ArrowFunction and transform
+it into a normal Function which will work in ES5 environments.
+
+**Generation** is the process of turning an AST back into code. After Babel is
+done transforming the AST, the generation takes over to return normal code.
+
+---
+
+Babel's parsing step is done by [Acorn](https://github.com/marijnh/acorn). However, because Babel is implementing
+future standards it maintains a [fork of Acorn](acorn/) in order to do it's job. You can
+see that fork in the "acorn" folder.
+
+The transformation and generation steps are both handled inside of the Babel
+codebase itself, which is in the "babel" folder here.

src/acorn/index.js

@@ -0,0 +1,6 @@
+export * from "./src/index";
+import "./plugins/flow";
+
+import inject from "acorn-jsx/inject";
+import * as acorn from "./src/index";
+inject(acorn);

src/acorn/package.json

@@ -2,7 +2,7 @@
   "name": "acorn",
   "description": "ECMAScript parser",
   "homepage": "https://github.com/marijnh/acorn",
-  "main": "src/index.js",
+  "main": "index.js",
   "version": "1.0.0",
   "engines": {
     "node": ">=0.4.0"

src/acorn/plugins/flow.js

@@ -1,4 +1,4 @@
-var acorn = require("..")
+var acorn = require("../src/index")
 
 var pp = acorn.Parser.prototype
 var tt = acorn.tokTypes
@@ -15,6 +15,15 @@ pp.expectRelational = function (op) {
   }
 }
 
+pp.flow_parseTypeInitialiser = function (tok) {
+  var oldInType = this.inType
+  this.inType = true
+  this.expect(tok || tt.colon)
+  var type = this.flow_parseType()
+  this.inType = oldInType
+  return type;
+}
+
 pp.flow_parseDeclareClass = function (node) {
   this.next()
   this.flow_parseInterfaceish(node, true)
@@ -40,9 +49,7 @@ pp.flow_parseDeclareFunction = function (node) {
   typeNode.params = tmp.params
   typeNode.rest = tmp.rest
   this.expect(tt.parenR)
-
-  this.expect(tt.colon)
-  typeNode.returnType = this.flow_parseType()
+  typeNode.returnType = this.flow_parseTypeInitialiser()
 
   typeContainer.typeAnnotation = this.finishNode(typeNode, "FunctionTypeAnnotation")
   id.typeAnnotation = this.finishNode(typeContainer, "TypeAnnotation")
@@ -153,10 +160,7 @@ pp.flow_parseTypeAlias = function (node) {
     node.typeParameters = null
   }
 
-  this.expect(tt.eq)
-
-  node.right = this.flow_parseType()
-
+  node.right = this.flow_parseTypeInitialiser(tt.eq)
   this.semicolon()
 
   return this.finishNode(node, "TypeAlias")
@@ -209,11 +213,9 @@ pp.flow_parseObjectTypeIndexer = function (node, isStatic) {
 
   this.expect(tt.bracketL)
   node.id = this.flow_parseObjectPropertyKey()
-  this.expect(tt.colon)
-  node.key = this.flow_parseType()
+  node.key = this.flow_parseTypeInitialiser()
   this.expect(tt.bracketR)
-  this.expect(tt.colon)
-  node.value = this.flow_parseType()
+  node.value = this.flow_parseTypeInitialiser()
 
   this.flow_objectTypeSemicolon()
   return this.finishNode(node, "ObjectTypeIndexer")
@@ -240,8 +242,7 @@ pp.flow_parseObjectTypeMethodish = function (node) {
     node.rest = this.flow_parseFunctionTypeParam()
   }
   this.expect(tt.parenR)
-  this.expect(tt.colon)
-  node.returnType = this.flow_parseType()
+  node.returnType = this.flow_parseTypeInitialiser()
 
   return this.finishNode(node, "FunctionTypeAnnotation")
 }
@@ -260,7 +261,7 @@ pp.flow_parseObjectTypeCallProperty = function (node, isStatic) {
   var valueNode = this.startNode()
   node.static = isStatic
   node.value = this.flow_parseObjectTypeMethodish(valueNode)
-    this.flow_objectTypeSemicolon()
+  this.flow_objectTypeSemicolon()
   return this.finishNode(node, "ObjectTypeCallProperty")
 }
 
@@ -305,9 +306,8 @@ pp.flow_parseObjectType = function (allowStatic) {
         if (this.eat(tt.question)) {
           optional = true
         }
-        this.expect(tt.colon)
         node.key = propertyKey
-        node.value = this.flow_parseType()
+        node.value = this.flow_parseTypeInitialiser()
         node.optional = optional
         node.static = isStatic
         this.flow_objectTypeSemicolon()
@@ -322,7 +322,7 @@ pp.flow_parseObjectType = function (allowStatic) {
 }
 
 pp.flow_objectTypeSemicolon = function () {
-  if (!this.eat(tt.semi) && this.type !== tt.braceR) {
+  if (!this.eat(tt.semi) && !this.eat(tt.comma) && this.type !== tt.braceR) {
     this.unexpected()
   }
 }
@@ -347,12 +347,6 @@ pp.flow_parseGenericType = function (start, id) {
   return this.finishNode(node, "GenericTypeAnnotation")
 }
 
-pp.flow_parseVoidType = function () {
-  var node = this.startNode()
-  this.expect(tt._void)
-  return this.finishNode(node, "VoidTypeAnnotation")
-}
-
 pp.flow_parseTypeofType = function () {
   var node = this.startNode()
   this.expect(tt._typeof)
@@ -381,9 +375,8 @@ pp.flow_parseFunctionTypeParam = function () {
   if (this.eat(tt.question)) {
     optional = true
   }
-  this.expect(tt.colon)
   node.optional = optional
-  node.typeAnnotation = this.flow_parseType()
+  node.typeAnnotation = this.flow_parseTypeInitialiser()
   return this.finishNode(node, "FunctionTypeParam")
 }
 
@@ -406,10 +399,16 @@ pp.flow_identToTypeAnnotation = function (start, node, id) {
     case "any":
       return this.finishNode(node, "AnyTypeAnnotation")
 
+    case "void":
+      return this.finishNode(node, "VoidTypeAnnotation")
+
     case "bool":
     case "boolean":
       return this.finishNode(node, "BooleanTypeAnnotation")
 
+    case "mixed":
+      return this.finishNode(node, "MixedTypeAnnotation")
+
     case "number":
       return this.finishNode(node, "NumberTypeAnnotation")
 
@@ -516,14 +515,8 @@ pp.flow_parsePrimaryType = function () {
       return this.finishNode(node, "StringLiteralTypeAnnotation")
 
     default:
-      if (this.type.keyword) {
-        switch (this.type.keyword) {
-          case "void":
-            return this.flow_parseVoidType()
-
-          case "typeof":
-            return this.flow_parseTypeofType()
-        }
+      if (this.type.keyword === "typeof") {
+        return this.flow_parseTypeofType()
       }
   }
 
@@ -580,13 +573,7 @@ pp.flow_parseType = function () {
 
 pp.flow_parseTypeAnnotation = function () {
   var node = this.startNode()
-
-  var oldInType = this.inType
-  this.inType = true
-  this.expect(tt.colon)
-  node.typeAnnotation = this.flow_parseType()
-  this.inType = oldInType
-
+  node.typeAnnotation = this.flow_parseTypeInitialiser()
   return this.finishNode(node, "TypeAnnotation")
 }
 
@@ -686,6 +673,18 @@ acorn.plugins.flow = function (instance) {
     }
   })
 
+  // don't consider `void` to be a keyword as then it'll use the void token type
+  // and set startExpr
+  instance.extend("isKeyword", function (inner) {
+    return function(name) {
+      if (this.inType && name === "void") {
+        return false
+      } else {
+        return inner.call(this, name)
+      }
+    }
+  })
+
   instance.extend("readToken", function (inner) {
     return function(code) {
       if (this.inType && (code === 62 || code === 60)) {
@@ -792,16 +791,15 @@ acorn.plugins.flow = function (instance) {
 
   instance.extend("parseImportSpecifiers", function (inner) {
     return function (node) {
-      node.isType = false
-      if (this.isContextual("type")) {
-        var start = this.markPosition()
-        var typeId = this.parseIdent()
-        if ((this.type === tt.name && this.value !== "from") || this.type === tt.braceL || this.type === tt.star) {
-          node.isType = true
-        } else {
-          node.specifiers.push(this.parseImportSpecifierDefault(typeId, start))
-          if (this.isContextual("from")) return
-          this.eat(tt.comma)
+      node.importKind = "value"
+      var kind =
+        (this.type === tt._typeof ? "typeof" :
+        (this.isContextual("type") ? "type" : null))
+      if (kind) {
+        var lh = this.lookahead()
+        if ((lh.type === tt.name && lh.value !== "from") || lh.type === tt.braceL || lh.type === tt.star) {
+          this.next()
+          node.importKind = kind
         }
       }
       inner.call(this, node)

src/acorn/plugins/jsx.js

@@ -1,658 +0,0 @@
-var acorn = require("..")
-
-var tt = acorn.tokTypes;
-var tc = acorn.tokContexts;
-
-tc.j_oTag = new acorn.TokContext("<tag", false);
-tc.j_cTag = new acorn.TokContext("</tag", false);
-tc.j_expr = new acorn.TokContext("<tag>...</tag>", true, true);
-
-tt.jsxName = new acorn.TokenType("jsxName");
-tt.jsxText = new acorn.TokenType("jsxText", {beforeExpr: true});
-tt.jsxTagStart = new acorn.TokenType("jsxTagStart");
-tt.jsxTagEnd = new acorn.TokenType("jsxTagEnd");
-
-tt.jsxTagStart.updateContext = function() {
-  this.context.push(tc.j_expr); // treat as beginning of JSX expression
-  this.context.push(tc.j_oTag); // start opening tag context
-  this.exprAllowed = false;
-};
-tt.jsxTagEnd.updateContext = function(prevType) {
-  var out = this.context.pop();
-  if (out === tc.j_oTag && prevType === tt.slash || out === tc.j_cTag) {
-    this.context.pop();
-    this.exprAllowed = this.curContext() === tc.j_expr;
-  } else {
-    this.exprAllowed = true;
-  }
-};
-
-var pp = acorn.Parser.prototype;
-
-// Reads inline JSX contents token.
-
-pp.jsx_readToken = function() {
-  var out = "", chunkStart = this.pos;
-  for (;;) {
-    if (this.pos >= this.input.length)
-      this.raise(this.start, "Unterminated JSX contents");
-    var ch = this.input.charCodeAt(this.pos);
-
-    switch (ch) {
-    case 60: // '<'
-    case 123: // '{'
-      if (this.pos === this.start) {
-        if (ch === 60 && this.exprAllowed) {
-          ++this.pos;
-          return this.finishToken(tt.jsxTagStart);
-        }
-        return this.getTokenFromCode(ch);
-      }
-      out += this.input.slice(chunkStart, this.pos);
-      return this.finishToken(tt.jsxText, out);
-
-    case 38: // '&'
-      out += this.input.slice(chunkStart, this.pos);
-      out += this.jsx_readEntity();
-      chunkStart = this.pos;
-      break;
-
-    default:
-      if (acorn.isNewLine(ch)) {
-        out += this.input.slice(chunkStart, this.pos);
-        ++this.pos;
-        if (ch === 13 && this.input.charCodeAt(this.pos) === 10) {
-          ++this.pos;
-          out += "\n";
-        } else {
-          out += String.fromCharCode(ch);
-        }
-        if (this.options.locations) {
-          ++this.curLine;
-          this.lineStart = this.pos;
-        }
-        chunkStart = this.pos;
-      } else {
-        ++this.pos;
-      }
-    }
-  }
-};
-
-pp.jsx_readString = function(quote) {
-  var out = "", chunkStart = ++this.pos;
-  for (;;) {
-    if (this.pos >= this.input.length)
-      this.raise(this.start, "Unterminated string constant");
-    var ch = this.input.charCodeAt(this.pos);
-    if (ch === quote) break;
-    if (ch === 38) { // '&'
-      out += this.input.slice(chunkStart, this.pos);
-      out += this.jsx_readEntity();
-      chunkStart = this.pos;
-    } else {
-      ++this.pos;
-    }
-  }
-  out += this.input.slice(chunkStart, this.pos++);
-  return this.finishToken(tt.string, out);
-};
-
-var XHTMLEntities = {
-  quot: '\u0022',
-  amp: '&',
-  apos: '\u0027',
-  lt: '<',
-  gt: '>',
-  nbsp: '\u00A0',
-  iexcl: '\u00A1',
-  cent: '\u00A2',
-  pound: '\u00A3',
-  curren: '\u00A4',
-  yen: '\u00A5',
-  brvbar: '\u00A6',
-  sect: '\u00A7',
-  uml: '\u00A8',
-  copy: '\u00A9',
-  ordf: '\u00AA',
-  laquo: '\u00AB',
-  not: '\u00AC',
-  shy: '\u00AD',
-  reg: '\u00AE',
-  macr: '\u00AF',
-  deg: '\u00B0',
-  plusmn: '\u00B1',
-  sup2: '\u00B2',
-  sup3: '\u00B3',
-  acute: '\u00B4',
-  micro: '\u00B5',
-  para: '\u00B6',
-  middot: '\u00B7',
-  cedil: '\u00B8',
-  sup1: '\u00B9',
-  ordm: '\u00BA',
-  raquo: '\u00BB',
-  frac14: '\u00BC',
-  frac12: '\u00BD',
-  frac34: '\u00BE',
-  iquest: '\u00BF',
-  Agrave: '\u00C0',
-  Aacute: '\u00C1',
-  Acirc: '\u00C2',
-  Atilde: '\u00C3',
-  Auml: '\u00C4',
-  Aring: '\u00C5',
-  AElig: '\u00C6',
-  Ccedil: '\u00C7',
-  Egrave: '\u00C8',
-  Eacute: '\u00C9',
-  Ecirc: '\u00CA',
-  Euml: '\u00CB',
-  Igrave: '\u00CC',
-  Iacute: '\u00CD',
-  Icirc: '\u00CE',
-  Iuml: '\u00CF',
-  ETH: '\u00D0',
-  Ntilde: '\u00D1',
-  Ograve: '\u00D2',
-  Oacute: '\u00D3',
-  Ocirc: '\u00D4',
-  Otilde: '\u00D5',
-  Ouml: '\u00D6',
-  times: '\u00D7',
-  Oslash: '\u00D8',
-  Ugrave: '\u00D9',
-  Uacute: '\u00DA',
-  Ucirc: '\u00DB',
-  Uuml: '\u00DC',
-  Yacute: '\u00DD',
-  THORN: '\u00DE',
-  szlig: '\u00DF',
-  agrave: '\u00E0',
-  aacute: '\u00E1',
-  acirc: '\u00E2',
-  atilde: '\u00E3',
-  auml: '\u00E4',
-  aring: '\u00E5',
-  aelig: '\u00E6',
-  ccedil: '\u00E7',
-  egrave: '\u00E8',
-  eacute: '\u00E9',
-  ecirc: '\u00EA',
-  euml: '\u00EB',
-  igrave: '\u00EC',
-  iacute: '\u00ED',
-  icirc: '\u00EE',
-  iuml: '\u00EF',
-  eth: '\u00F0',
-  ntilde: '\u00F1',
-  ograve: '\u00F2',
-  oacute: '\u00F3',
-  ocirc: '\u00F4',
-  otilde: '\u00F5',
-  ouml: '\u00F6',
-  divide: '\u00F7',
-  oslash: '\u00F8',
-  ugrave: '\u00F9',
-  uacute: '\u00FA',
-  ucirc: '\u00FB',
-  uuml: '\u00FC',
-  yacute: '\u00FD',
-  thorn: '\u00FE',
-  yuml: '\u00FF',
-  OElig: '\u0152',
-  oelig: '\u0153',
-  Scaron: '\u0160',
-  scaron: '\u0161',
-  Yuml: '\u0178',
-  fnof: '\u0192',
-  circ: '\u02C6',
-  tilde: '\u02DC',
-  Alpha: '\u0391',
-  Beta: '\u0392',
-  Gamma: '\u0393',
-  Delta: '\u0394',
-  Epsilon: '\u0395',
-  Zeta: '\u0396',
-  Eta: '\u0397',
-  Theta: '\u0398',
-  Iota: '\u0399',
-  Kappa: '\u039A',
-  Lambda: '\u039B',
-  Mu: '\u039C',
-  Nu: '\u039D',
-  Xi: '\u039E',
-  Omicron: '\u039F',
-  Pi: '\u03A0',
-  Rho: '\u03A1',
-  Sigma: '\u03A3',
-  Tau: '\u03A4',
-  Upsilon: '\u03A5',
-  Phi: '\u03A6',
-  Chi: '\u03A7',
-  Psi: '\u03A8',
-  Omega: '\u03A9',
-  alpha: '\u03B1',
-  beta: '\u03B2',
-  gamma: '\u03B3',
-  delta: '\u03B4',
-  epsilon: '\u03B5',
-  zeta: '\u03B6',
-  eta: '\u03B7',
-  theta: '\u03B8',
-  iota: '\u03B9',
-  kappa: '\u03BA',
-  lambda: '\u03BB',
-  mu: '\u03BC',
-  nu: '\u03BD',
-  xi: '\u03BE',
-  omicron: '\u03BF',
-  pi: '\u03C0',
-  rho: '\u03C1',
-  sigmaf: '\u03C2',
-  sigma: '\u03C3',
-  tau: '\u03C4',
-  upsilon: '\u03C5',
-  phi: '\u03C6',
-  chi: '\u03C7',
-  psi: '\u03C8',
-  omega: '\u03C9',
-  thetasym: '\u03D1',
-  upsih: '\u03D2',
-  piv: '\u03D6',
-  ensp: '\u2002',
-  emsp: '\u2003',
-  thinsp: '\u2009',
-  zwnj: '\u200C',
-  zwj: '\u200D',
-  lrm: '\u200E',
-  rlm: '\u200F',
-  ndash: '\u2013',
-  mdash: '\u2014',
-  lsquo: '\u2018',
-  rsquo: '\u2019',
-  sbquo: '\u201A',
-  ldquo: '\u201C',
-  rdquo: '\u201D',
-  bdquo: '\u201E',
-  dagger: '\u2020',
-  Dagger: '\u2021',
-  bull: '\u2022',
-  hellip: '\u2026',
-  permil: '\u2030',
-  prime: '\u2032',
-  Prime: '\u2033',
-  lsaquo: '\u2039',
-  rsaquo: '\u203A',
-  oline: '\u203E',
-  frasl: '\u2044',
-  euro: '\u20AC',
-  image: '\u2111',
-  weierp: '\u2118',
-  real: '\u211C',
-  trade: '\u2122',
-  alefsym: '\u2135',
-  larr: '\u2190',
-  uarr: '\u2191',
-  rarr: '\u2192',
-  darr: '\u2193',
-  harr: '\u2194',
-  crarr: '\u21B5',
-  lArr: '\u21D0',
-  uArr: '\u21D1',
-  rArr: '\u21D2',
-  dArr: '\u21D3',
-  hArr: '\u21D4',
-  forall: '\u2200',
-  part: '\u2202',
-  exist: '\u2203',
-  empty: '\u2205',
-  nabla: '\u2207',
-  isin: '\u2208',
-  notin: '\u2209',
-  ni: '\u220B',
-  prod: '\u220F',
-  sum: '\u2211',
-  minus: '\u2212',
-  lowast: '\u2217',
-  radic: '\u221A',
-  prop: '\u221D',
-  infin: '\u221E',
-  ang: '\u2220',
-  and: '\u2227',
-  or: '\u2228',
-  cap: '\u2229',
-  cup: '\u222A',
-  'int': '\u222B',
-  there4: '\u2234',
-  sim: '\u223C',
-  cong: '\u2245',
-  asymp: '\u2248',
-  ne: '\u2260',
-  equiv: '\u2261',
-  le: '\u2264',
-  ge: '\u2265',
-  sub: '\u2282',
-  sup: '\u2283',
-  nsub: '\u2284',
-  sube: '\u2286',
-  supe: '\u2287',
-  oplus: '\u2295',
-  otimes: '\u2297',
-  perp: '\u22A5',
-  sdot: '\u22C5',
-  lceil: '\u2308',
-  rceil: '\u2309',
-  lfloor: '\u230A',
-  rfloor: '\u230B',
-  lang: '\u2329',
-  rang: '\u232A',
-  loz: '\u25CA',
-  spades: '\u2660',
-  clubs: '\u2663',
-  hearts: '\u2665',
-  diams: '\u2666'
-};
-
-var hexNumber = /^[\da-fA-F]+$/;
-var decimalNumber = /^\d+$/;
-
-pp.jsx_readEntity = function() {
-  var str = "", count = 0, entity;
-  var ch = this.input[this.pos];
-  if (ch !== "&")
-    this.raise(this.pos, "Entity must start with an ampersand");
-  var startPos = ++this.pos;
-  while (this.pos < this.input.length && count++ < 10) {
-    ch = this.input[this.pos++];
-    if (ch === ";") {
-      if (str[0] === "#") {
-        if (str[1] === "x") {
-          str = str.substr(2);
-          if (hexNumber.test(str))
-            entity = String.fromCharCode(parseInt(str, 16));
-        } else {
-          str = str.substr(1);
-          if (decimalNumber.test(str))
-            entity = String.fromCharCode(parseInt(str, 10));
-        }
-      } else {
-        entity = XHTMLEntities[str];
-      }
-      break;
-    }
-    str += ch;
-  }
-  if (!entity) {
-    this.pos = startPos;
-    return "&";
-  }
-  return entity;
-};
-
-
-// Read a JSX identifier (valid tag or attribute name).
-//
-// Optimized version since JSX identifiers can't contain
-// escape characters and so can be read as single slice.
-// Also assumes that first character was already checked
-// by isIdentifierStart in readToken.
-
-pp.jsx_readWord = function() {
-  var ch, start = this.pos;
-  do {
-    ch = this.input.charCodeAt(++this.pos);
-  } while (acorn.isIdentifierChar(ch) || ch === 45); // '-'
-  return this.finishToken(tt.jsxName, this.input.slice(start, this.pos));
-};
-
-// Transforms JSX element name to string.
-
-function getQualifiedJSXName(object) {
-  if (object.type === "JSXIdentifier")
-    return object.name;
-
-  if (object.type === "JSXNamespacedName")
-    return object.namespace.name + ':' + object.name.name;
-
-  if (object.type === "JSXMemberExpression")
-    return getQualifiedJSXName(object.object) + '.' +
-    getQualifiedJSXName(object.property);
-}
-
-// Parse next token as JSX identifier
-
-pp.jsx_parseIdentifier = function() {
-  var node = this.startNode();
-  if (this.type === tt.jsxName)
-    node.name = this.value;
-  else if (this.type.keyword)
-    node.name = this.type.keyword;
-  else
-    this.unexpected();
-  this.next();
-  return this.finishNode(node, "JSXIdentifier");
-};
-
-// Parse namespaced identifier.
-
-pp.jsx_parseNamespacedName = function() {
-  var start = this.markPosition();
-  var name = this.jsx_parseIdentifier();
-  if (!this.eat(tt.colon)) return name;
-  var node = this.startNodeAt(start);
-  node.namespace = name;
-  node.name = this.jsx_parseIdentifier();
-  return this.finishNode(node, "JSXNamespacedName");
-};
-
-// Parses element name in any form - namespaced, member
-// or single identifier.
-
-pp.jsx_parseElementName = function() {
-  var start = this.markPosition();
-  var node = this.jsx_parseNamespacedName();
-  while (this.eat(tt.dot)) {
-    var newNode = this.startNodeAt(start);
-    newNode.object = node;
-    newNode.property = this.jsx_parseIdentifier();
-    node = this.finishNode(newNode, "JSXMemberExpression");
-  }
-  return node;
-};
-
-// Parses any type of JSX attribute value.
-
-pp.jsx_parseAttributeValue = function() {
-  switch (this.type) {
-  case tt.braceL:
-    var node = this.jsx_parseExpressionContainer();
-    if (node.expression.type === "JSXEmptyExpression")
-      this.raise(node.start, "JSX attributes must only be assigned a non-empty expression");
-    return node;
-
-  case tt.jsxTagStart:
-  case tt.string:
-    return this.parseExprAtom();
-
-  default:
-    this.raise(this.start, "JSX value should be either an expression or a quoted JSX text");
-  }
-};
-
-// JSXEmptyExpression is unique type since it doesn't actually parse anything,
-// and so it should start at the end of last read token (left brace) and finish
-// at the beginning of the next one (right brace).
-
-pp.jsx_parseEmptyExpression = function() {
-  var tmp = this.start;
-  this.start = this.lastTokEnd;
-  this.lastTokEnd = tmp;
-
-  tmp = this.startLoc;
-  this.startLoc = this.lastTokEndLoc;
-  this.lastTokEndLoc = tmp;
-
-  return this.finishNode(this.startNode(), "JSXEmptyExpression");
-};
-
-// Parses JSX expression enclosed into curly brackets.
-
-
-pp.jsx_parseExpressionContainer = function() {
-  var node = this.startNode();
-  this.next();
-  node.expression = this.type === tt.braceR
-    ? this.jsx_parseEmptyExpression()
-    : this.parseExpression();
-  this.expect(tt.braceR);
-  return this.finishNode(node, "JSXExpressionContainer");
-};
-
-// Parses following JSX attribute name-value pair.
-
-pp.jsx_parseAttribute = function() {
-  var node = this.startNode();
-  if (this.eat(tt.braceL)) {
-    this.expect(tt.ellipsis);
-    node.argument = this.parseMaybeAssign();
-    this.expect(tt.braceR);
-    return this.finishNode(node, "JSXSpreadAttribute");
-  }
-  node.name = this.jsx_parseNamespacedName();
-  node.value = this.eat(tt.eq) ? this.jsx_parseAttributeValue() : null;
-  return this.finishNode(node, "JSXAttribute");
-};
-
-// Parses JSX opening tag starting after '<'.
-
-pp.jsx_parseOpeningElementAt = function(start) {
-  var node = this.startNodeAt(start);
-  node.attributes = [];
-  node.name = this.jsx_parseElementName();
-  while (this.type !== tt.slash && this.type !== tt.jsxTagEnd)
-    node.attributes.push(this.jsx_parseAttribute());
-  node.selfClosing = this.eat(tt.slash);
-  this.expect(tt.jsxTagEnd);
-  return this.finishNode(node, "JSXOpeningElement");
-};
-
-// Parses JSX closing tag starting after '</'.
-
-pp.jsx_parseClosingElementAt = function(start) {
-  var node = this.startNodeAt(start);
-  node.name = this.jsx_parseElementName();
-  this.expect(tt.jsxTagEnd);
-  return this.finishNode(node, "JSXClosingElement");
-};
-
-// Parses entire JSX element, including it's opening tag
-// (starting after '<'), attributes, contents and closing tag.
-
-pp.jsx_parseElementAt = function(start) {
-  var node = this.startNodeAt(start);
-  var children = [];
-  var openingElement = this.jsx_parseOpeningElementAt(start);
-  var closingElement = null;
-
-  if (!openingElement.selfClosing) {
-    contents: for (;;) {
-      switch (this.type) {
-      case tt.jsxTagStart:
-        start = this.markPosition();
-        this.next();
-        if (this.eat(tt.slash)) {
-          closingElement = this.jsx_parseClosingElementAt(start);
-          break contents;
-        }
-        children.push(this.jsx_parseElementAt(start));
-        break;
-
-      case tt.jsxText:
-        children.push(this.parseExprAtom());
-        break;
-
-      case tt.braceL:
-        children.push(this.jsx_parseExpressionContainer());
-        break;
-
-      default:
-        this.unexpected();
-      }
-    }
-    if (getQualifiedJSXName(closingElement.name) !== getQualifiedJSXName(openingElement.name))
-      this.raise(
-        closingElement.start,
-        "Expected corresponding JSX closing tag for <" + getQualifiedJSXName(openingElement.name) + ">");
-  }
-
-  node.openingElement = openingElement;
-  node.closingElement = closingElement;
-  node.children = children;
-  return this.finishNode(node, "JSXElement");
-};
-
-// Parses entire JSX element from current position.
-
-pp.jsx_parseElement = function() {
-  var start = this.markPosition();
-  this.next();
-  return this.jsx_parseElementAt(start);
-};
-
-acorn.plugins.jsx = function(instance) {
-  instance.extend("parseExprAtom", function(inner) {
-    return function(refShortHandDefaultPos) {
-      if (this.type === tt.jsxText)
-        return this.parseLiteral(this.value);
-      else if (this.type === tt.jsxTagStart)
-        return this.jsx_parseElement();
-      else
-        return inner.call(this, refShortHandDefaultPos);
-    };
-  });
-
-  instance.extend("readToken", function(inner) {
-    return function(code) {
-      var context = this.curContext();
-
-      if (context === tc.j_expr) return this.jsx_readToken();
-
-      if (context === tc.j_oTag || context === tc.j_cTag) {
-        if (acorn.isIdentifierStart(code)) return this.jsx_readWord();
-
-        if (code == 62) {
-          ++this.pos;
-          return this.finishToken(tt.jsxTagEnd);
-        }
-
-        if ((code === 34 || code === 39) && context == tc.j_oTag)
-          return this.jsx_readString(code);
-      }
-
-      if (code === 60 && this.exprAllowed) {
-        ++this.pos;
-        return this.finishToken(tt.jsxTagStart);
-      }
-      return inner.call(this, code);
-    };
-  });
-
-  instance.extend("updateContext", function(inner) {
-    return function(prevType) {
-      if (this.type == tt.braceL) {
-        var curContext = this.curContext();
-        if (curContext == tc.j_oTag) this.context.push(tc.b_expr);
-        else if (curContext == tc.j_expr) this.context.push(tc.b_tmpl);
-        else inner.call(this, prevType);
-        this.exprAllowed = true;
-      } else if (this.type === tt.slash && prevType === tt.jsxTagStart) {
-        this.context.length -= 2; // do not consider JSX expr -> JSX open tag -> ... anymore
-        this.context.push(tc.j_cTag); // reconsider as closing tag context
-        this.exprAllowed = false;
-      } else {
-        return inner.call(this, prevType);
-      }
-    };
-  });
-}

src/acorn/src/expression.js

@@ -29,14 +29,23 @@ const pp = Parser.prototype
 // strict mode, init properties are also not allowed to be repeated.
 
 pp.checkPropClash = function(prop, propHash) {
-  if (this.options.ecmaVersion >= 6) return
+  if (this.options.ecmaVersion >= 6 && (prop.computed || prop.method || prop.shorthand))
+    return
   let key = prop.key, name
   switch (key.type) {
   case "Identifier": name = key.name; break
   case "Literal": name = String(key.value); break
   default: return
   }
-  let kind = prop.kind || "init", other
+  let kind = prop.kind
+  if (this.options.ecmaVersion >= 6) {
+    if (name === "__proto__" && kind === "init") {
+      if (propHash.proto) this.raise(key.start, "Redefinition of __proto__ property");
+      propHash.proto = true
+    }
+    return
+  }
+  let other
   if (has(propHash, name)) {
     other = propHash[name]
     let isGetSet = kind !== "init"
@@ -104,10 +113,14 @@ pp.parseMaybeAssign = function(noIn, refShorthandDefaultPos, afterLeftParse) {
     refShorthandDefaultPos.start = 0 // reset because shorthand default was used correctly
     this.checkLVal(left)
     if (left.parenthesizedExpression) {
+      let errorMsg
       if (left.type === "ObjectPattern") {
-        this.raise(left.start, "You're trying to assign to a parenthesized expression, instead of `({ foo }) = {}` use `({ foo } = {})`");
-      } else {
-        this.raise(left.start, "Parenthesized left hand expressions are illegal");
+        errorMsg = "`({a}) = 0` use `({a} = 0)`"
+      } else if (left.type === "ArrayPattern") {
+        errorMsg = "`([a]) = 0` use `([a] = 0)`"
+      }
+      if (errorMsg) {
+        this.raise(left.start, `You're trying to assign to a parenthesized expression, eg. instead of ${errorMsg}`)
       }
     }
     this.next()
@@ -210,7 +223,12 @@ pp.parseExprSubscripts = function(refShorthandDefaultPos) {
 }
 
 pp.parseSubscripts = function(base, start, noCalls) {
-  if (this.eat(tt.dot)) {
+  if (!noCalls && this.eat(tt.doubleColon)) {
+    let node = this.startNodeAt(start)
+    node.object = base
+    node.callee = this.parseNoCallExpr()
+    return this.parseSubscripts(this.finishNode(node, "BindExpression"), start, noCalls)
+  } else if (this.eat(tt.dot)) {
     let node = this.startNodeAt(start)
     node.object = base
     node.property = this.parseIdent(true)
@@ -236,6 +254,13 @@ pp.parseSubscripts = function(base, start, noCalls) {
   } return base
 }
 
+// Parse a no-call expression (like argument of `new` or `::` operators).
+
+pp.parseNoCallExpr = function() {
+  let start = this.markPosition()
+  return this.parseSubscripts(this.parseExprAtom(), start, true)
+}
+
 // Parse an atomic expression — either a single token that is an
 // expression, an expression started by a keyword like `function` or
 // `new`, or an expression wrapped in punctuation like `()`, `[]`,
@@ -244,8 +269,10 @@ pp.parseSubscripts = function(base, start, noCalls) {
 pp.parseExprAtom = function(refShorthandDefaultPos) {
   let node, canBeArrow = this.potentialArrowAt == this.start
   switch (this.type) {
-  case tt._this:
   case tt._super:
+    if (!this.inFunction)
+      this.raise(this.start, "'super' outside of function or class")
+  case tt._this:
     let type = this.type === tt._this ? "ThisExpression" : "Super"
     node = this.startNode()
     this.next()
@@ -258,7 +285,13 @@ pp.parseExprAtom = function(refShorthandDefaultPos) {
     if (this.options.features["es7.doExpressions"]) {
       let node = this.startNode()
       this.next()
+      var oldInFunction = this.inFunction
+      var oldLabels = this.labels
+      this.labels = []
+      this.inFunction = false
       node.body = this.parseBlock()
+      this.inFunction = oldInFunction
+      this.labels = oldLabels
       return this.finishNode(node, "DoExpression")
     }
 
@@ -270,7 +303,7 @@ pp.parseExprAtom = function(refShorthandDefaultPos) {
     //
     if (this.options.features["es7.asyncFunctions"]) {
       // async functions!
-      if (id.name === "async") {
+      if (id.name === "async" && !this.canInsertSemicolon()) {
         // arrow functions
         if (this.type === tt.parenL) {
           let expr = this.parseParenAndDistinguishExpression(start, true, true)
@@ -359,6 +392,15 @@ pp.parseExprAtom = function(refShorthandDefaultPos) {
   case tt.backQuote:
     return this.parseTemplate()
 
+  case tt.doubleColon:
+    node = this.startNode()
+    this.next()
+    node.object = null
+    let callee = node.callee = this.parseNoCallExpr()
+    if (callee.type !== "MemberExpression")
+      this.raise(callee.start, "Binding should be performed on object property.")
+    return this.finishNode(node, "BindExpression")
+
   default:
     this.unexpected()
   }
@@ -390,9 +432,18 @@ pp.parseParenAndDistinguishExpression = function(start, isAsync, canBeArrow) {
     }
 
     let innerStart = this.markPosition(), exprList = [], first = true
-    let refShorthandDefaultPos = {start: 0}, spreadStart, innerParenStart
+    let refShorthandDefaultPos = {start: 0}, spreadStart, innerParenStart, optionalCommaStart
     while (this.type !== tt.parenR) {
-      first ? first = false : this.expect(tt.comma)
+      if (first) {
+        first = false;
+      } else {
+        this.expect(tt.comma)
+        if (this.type === tt.parenR && this.options.features["es7.trailingFunctionCommas"]) {
+          optionalCommaStart = this.start
+          break
+        }
+      }
+
       if (this.type === tt.ellipsis) {
         let spreadNodeStart = this.markPosition()
         spreadStart = this.start
@@ -420,6 +471,7 @@ pp.parseParenAndDistinguishExpression = function(start, isAsync, canBeArrow) {
         this.unexpected(this.lastTokStart)
       }
     }
+    if (optionalCommaStart) this.unexpected(optionalCommaStart)
     if (spreadStart) this.unexpected(spreadStart)
     if (refShorthandDefaultPos.start) this.unexpected(refShorthandDefaultPos.start)
 
@@ -468,9 +520,11 @@ pp.parseNew = function() {
       this.raise(node.property.start, "The only valid meta property for new is new.target")
     return this.finishNode(node, "MetaProperty")
   }
-  let start = this.markPosition()
-  node.callee = this.parseSubscripts(this.parseExprAtom(), start, true)
-  if (this.eat(tt.parenL)) node.arguments = this.parseExprList(tt.parenR, false)
+  node.callee = this.parseNoCallExpr()
+  if (this.eat(tt.parenL)) node.arguments = this.parseExprList(
+    tt.parenR,
+    this.options.features["es7.trailingFunctionCommas"]
+  )
   else node.arguments = empty
   return this.finishNode(node, "NewExpression")
 }
@@ -480,7 +534,7 @@ pp.parseNew = function() {
 pp.parseTemplateElement = function() {
   let elem = this.startNode()
   elem.value = {
-    raw: this.input.slice(this.start, this.end),
+    raw: this.input.slice(this.start, this.end).replace(/\r\n?/g, '\n'),
     cooked: this.value
   }
   this.next()
@@ -509,22 +563,24 @@ pp.parseTemplate = function() {
 pp.parseObj = function(isPattern, refShorthandDefaultPos) {
   let node = this.startNode(), first = true, propHash = {}
   node.properties = []
+  let decorators = []
   this.next()
   while (!this.eat(tt.braceR)) {
     if (!first) {
       this.expect(tt.comma)
       if (this.afterTrailingComma(tt.braceR)) break
     } else first = false
-
     while (this.type === tt.at) {
-      this.decorators.push(this.parseDecorator())
+      decorators.push(this.parseDecorator())
     }
-
     let prop = this.startNode(), isGenerator = false, isAsync = false, start
+    if (decorators.length) {
+      prop.decorators = decorators
+      decorators = []
+    }
     if (this.options.features["es7.objectRestSpread"] && this.type === tt.ellipsis) {
       prop = this.parseSpread()
       prop.type = "SpreadProperty"
-      this.takeDecorators(prop)
       node.properties.push(prop)
       continue
     }
@@ -550,10 +606,9 @@ pp.parseObj = function(isPattern, refShorthandDefaultPos) {
     }
     this.parseObjPropValue(prop, start, isGenerator, isAsync, isPattern, refShorthandDefaultPos);
     this.checkPropClash(prop, propHash)
-    this.takeDecorators(prop)
     node.properties.push(this.finishNode(prop, "Property"))
   }
-  if (this.decorators.length) {
+  if (decorators.length) {
     this.raise(this.start, "You have trailing decorators with no property");
   }
   return this.finishNode(node, isPattern ? "ObjectPattern" : "ObjectExpression")
@@ -575,6 +630,14 @@ pp.parseObjPropValue = function (prop, start, isGenerator, isAsync, isPattern, r
     prop.kind = prop.key.name
     this.parsePropertyName(prop)
     prop.value = this.parseMethod(false)
+    let paramCount = prop.kind === "get" ? 0 : 1
+    if (prop.value.params.length !== paramCount) {
+      let start = prop.value.start
+      if (prop.kind === "get")
+        this.raise(start, "getter should have no params");
+      else
+        this.raise(start, "setter should have exactly one param")
+    }
   } else if (this.options.ecmaVersion >= 6 && !prop.computed && prop.key.type === "Identifier") {
     prop.kind = "init"
     if (isPattern) {
@@ -600,12 +663,12 @@ pp.parsePropertyName = function(prop) {
       prop.computed = true
       prop.key = this.parseMaybeAssign()
       this.expect(tt.bracketR)
-      return
+      return prop.key
     } else {
       prop.computed = false
     }
   }
-  prop.key = (this.type === tt.num || this.type === tt.string) ? this.parseExprAtom() : this.parseIdent(true)
+  return prop.key = (this.type === tt.num || this.type === tt.string) ? this.parseExprAtom() : this.parseIdent(true)
 }
 
 // Initialize empty function node.
@@ -627,7 +690,7 @@ pp.parseMethod = function(isGenerator, isAsync) {
   let node = this.startNode()
   this.initFunction(node, isAsync)
   this.expect(tt.parenL)
-  node.params = this.parseBindingList(tt.parenR, false, false)
+  node.params = this.parseBindingList(tt.parenR, false, this.options.features["es7.trailingFunctionCommas"])
   if (this.options.ecmaVersion >= 6) {
     node.generator = isGenerator
   }

src/acorn/src/identifier.js

@@ -9,41 +9,9 @@
 
 function makePredicate(words) {
   words = words.split(" ")
-  let f = "", cats = []
-  out: for (let i = 0; i < words.length; ++i) {
-    for (let j = 0; j < cats.length; ++j)
-      if (cats[j][0].length == words[i].length) {
-        cats[j].push(words[i])
-        continue out
-      }
-    cats.push([words[i]])
+  return function(str) {
+    return words.indexOf(str) >= 0
   }
-  function compareTo(arr) {
-    if (arr.length == 1) return f += "return str === " + JSON.stringify(arr[0]) + ";"
-    f += "switch(str){"
-    for (let i = 0; i < arr.length; ++i) f += "case " + JSON.stringify(arr[i]) + ":"
-    f += "return true}return false;"
-  }
-
-  // When there are more than three length categories, an outer
-  // switch first dispatches on the lengths, to save on comparisons.
-
-  if (cats.length > 3) {
-    cats.sort((a, b) => b.length - a.length)
-    f += "switch(str.length){"
-    for (let i = 0; i < cats.length; ++i) {
-      let cat = cats[i]
-      f += "case " + cat[0].length + ":"
-      compareTo(cat)
-    }
-    f += "}"
-
-    // Otherwise, simply generate a flat `switch` statement.
-
-  } else {
-    compareTo(words)
-  }
-  return new Function("str", f)
 }
 
 // Reserved word lists for various dialects of the language

src/acorn/src/index.js

@@ -38,9 +38,6 @@ export {isIdentifierChar, isIdentifierStart} from "./identifier"
 export {Token} from "./tokenize"
 export {isNewLine, lineBreak, lineBreakG} from "./whitespace"
 
-import "../plugins/flow";
-import "../plugins/jsx";
-
 export const version = "1.0.0"
 
 // The main exported interface (under `self.acorn` when in the

src/acorn/src/lookahead.js

@@ -9,12 +9,21 @@ var STATE_KEYS = [
   "lastTokEnd",
   "lineStart",
   "startLoc",
+  "curLine",
   "endLoc",
   "start",
   "pos",
   "end",
   "type",
-  "value"
+  "value",
+  "exprAllowed",
+  "potentialArrowAt",
+  "currLine",
+  "input",
+  "inType",
+  "inFunction",
+  "inGenerator",
+  "labels"
 ];
 
 pp.getState = function () {
@@ -23,6 +32,8 @@ pp.getState = function () {
     var key = STATE_KEYS[i]
     state[key] = this[key]
   }
+  state.context = this.context.slice()
+  state.labels = this.labels.slice()
   return state
 };
 

src/acorn/src/lval.js

@@ -21,6 +21,7 @@ pp.toAssignable = function(node, isBinding) {
       node.type = "ObjectPattern"
       for (let i = 0; i < node.properties.length; i++) {
         let prop = node.properties[i]
+        if (prop.type === "SpreadProperty") continue;
         if (prop.kind !== "init") this.raise(prop.key.start, "Object pattern can't contain getter or setter")
         this.toAssignable(prop.value, isBinding)
       }
@@ -34,6 +35,7 @@ pp.toAssignable = function(node, isBinding) {
     case "AssignmentExpression":
       if (node.operator === "=") {
         node.type = "AssignmentPattern"
+        delete node.operator
       } else {
         this.raise(node.left.end, "Only '=' operator can be used for specifying default value.")
       }
@@ -170,7 +172,7 @@ pp.checkLVal = function(expr, isBinding, checkClashes) {
     break
 
   case "ObjectPattern":
-    for (let i = 0; i < expr.properties.length; i++) {
+       for (let i = 0; i < expr.properties.length; i++) {
       var prop = expr.properties[i];
       if (prop.type === "Property") prop = prop.value;
       this.checkLVal(prop, isBinding, checkClashes)
@@ -193,6 +195,10 @@ pp.checkLVal = function(expr, isBinding, checkClashes) {
     this.checkLVal(expr.argument, isBinding, checkClashes)
     break
 
+  case "ParenthesizedExpression":
+    this.checkLVal(expr.expression, isBinding, checkClashes)
+    break
+
   default:
     this.raise(expr.start, (isBinding ? "Binding" : "Assigning to") + " rvalue")
   }

src/acorn/src/options.js

@@ -1,4 +1,4 @@
-import {has, isArray} from "./util"
+import {has} from "./util"
 import {SourceLocation} from "./location"
 
 // A second optional argument can be given to further configure
@@ -94,11 +94,11 @@ export function getOptions(opts) {
   for (let opt in defaultOptions)
     options[opt] = opts && has(opts, opt) ? opts[opt] : defaultOptions[opt]
 
-  if (isArray(options.onToken)) {
+  if (Array.isArray(options.onToken)) {
     let tokens = options.onToken
     options.onToken = (token) => tokens.push(token)
   }
-  if (isArray(options.onComment))
+  if (Array.isArray(options.onComment))
     options.onComment = pushComment(options, options.onComment)
 
   return options

src/acorn/src/state.js

@@ -1,13 +1,14 @@
 import {reservedWords, keywords} from "./identifier"
-import {types as tt, lineBreak} from "./tokentype"
+import {types as tt} from "./tokentype"
+import {lineBreak} from "./whitespace"
 
 export function Parser(options, input, startPos) {
   this.options = options
-  this.loadPlugins(this.options.plugins)
   this.sourceFile = this.options.sourceFile || null
   this.isKeyword = keywords[this.options.ecmaVersion >= 6 ? 6 : 5]
   this.isReservedWord = reservedWords[this.options.ecmaVersion]
   this.input = input
+  this.loadPlugins(this.options.plugins)
 
   // Set up token state
 

src/acorn/src/statement.js

@@ -83,10 +83,13 @@ pp.parseStatement = function(declaration, topLevel) {
     return starttype === tt._import ? this.parseImport(node) : this.parseExport(node)
 
   case tt.name:
-    if (this.options.features["es7.asyncFunctions"] && this.value === "async" && this.lookahead().type === tt._function) {
-      this.next();
-      this.expect(tt._function);
-      return this.parseFunction(node, true, false, true);
+    if (this.options.features["es7.asyncFunctions"] && this.value === "async") {
+      var lookahead = this.lookahead();
+      if (lookahead.type === tt._function && !this.canInsertSemicolon.call(lookahead)) {
+        this.next();
+        this.expect(tt._function);
+        return this.parseFunction(node, true, false, true);
+      }
     }
 
     // If the statement does not start with a statement keyword or a
@@ -168,12 +171,6 @@ pp.parseDoStatement = function(node) {
   this.labels.push(loopLabel)
   node.body = this.parseStatement(false)
   this.labels.pop()
-  if (this.options.features["es7.doExpressions"] && this.type !== tt._while) {
-    let container = this.startNodeAt(start)
-    container.expression = this.finishNode(node, "DoExpression")
-    this.semicolon()
-    return this.finishNode(container, "ExpressionStatement")
-  }
   this.expect(tt._while)
   node.test = this.parseParenExpression()
   if (this.options.ecmaVersion >= 6)
@@ -350,7 +347,14 @@ pp.parseLabeledStatement = function(node, maybeName, expr) {
   for (let i = 0; i < this.labels.length; ++i)
     if (this.labels[i].name === maybeName) this.raise(expr.start, "Label '" + maybeName + "' is already declared")
   let kind = this.type.isLoop ? "loop" : this.type === tt._switch ? "switch" : null
-  this.labels.push({name: maybeName, kind: kind})
+  for (let i = this.labels.length - 1; i >= 0; i--) {
+    let label = this.labels[i]
+    if (label.statementStart == node.start) {
+      label.statementStart = this.start;
+      label.kind = kind;
+    } else break;
+  }
+  this.labels.push({name: maybeName, kind: kind, statementStart: this.start})
   node.body = this.parseStatement(true)
   this.labels.pop()
   node.label = expr
@@ -469,26 +473,29 @@ pp.parseClass = function(node, isStatement) {
   this.parseClassId(node, isStatement)
   this.parseClassSuper(node)
   var classBody = this.startNode()
+  let hadConstructor = false
   classBody.body = []
   this.expect(tt.braceL)
+  let decorators = []
   while (!this.eat(tt.braceR)) {
     if (this.eat(tt.semi)) continue
     if (this.type === tt.at) {
-      this.decorators.push(this.parseDecorator())
+      decorators.push(this.parseDecorator())
       continue
     }
     var method = this.startNode()
-    this.takeDecorators(method)
+    if (decorators.length) {
+      method.decorators = decorators
+      decorators = []
+    }
+    let isMaybeStatic = this.type === tt.name && this.value === "static"
     var isGenerator = this.eat(tt.star), isAsync = false
     this.parsePropertyName(method)
-    if (this.type !== tt.parenL && !method.computed && method.key.type === "Identifier" &&
-        method.key.name === "static") {
+    method.static = isMaybeStatic && this.type !== tt.parenL
+    if (method.static) {
       if (isGenerator) this.unexpected()
-      method['static'] = true
       isGenerator = this.eat(tt.star)
       this.parsePropertyName(method)
-    } else {
-      method['static'] = false
     }
     if (!isGenerator && method.key.type === "Identifier" && !method.computed && this.isClassProperty()) {
       classBody.body.push(this.parseClassProperty(method))
@@ -499,25 +506,41 @@ pp.parseClass = function(node, isStatement) {
       isAsync = true
       this.parsePropertyName(method)
     }
+    let isGetSet = false
     method.kind = "method"
-    if (!method.computed && !isGenerator) {
-      if (method.key.type === "Identifier") {
-        if (this.type !== tt.parenL && (method.key.name === "get" || method.key.name === "set")) {
-          method.kind = method.key.name
-          this.parsePropertyName(method)
-        } else if (!method['static'] && method.key.name === "constructor") {
-          method.kind = "constructor"
-        }
-      } else if (!method['static'] && method.key.type === "Literal" && method.key.value === "constructor") {
+    if (!method.computed) {
+      let {key} = method
+      if (!isAsync && !isGenerator && key.type === "Identifier" && this.type !== tt.parenL && (key.name === "get" || key.name === "set")) {
+        isGetSet = true
+        method.kind = key.name
+        key = this.parsePropertyName(method)
+      }
+      if (!method.static && (key.type === "Identifier" && key.name === "constructor" ||
+          key.type === "Literal" && key.value === "constructor")) {
+        if (hadConstructor) this.raise(key.start, "Duplicate constructor in the same class")
+        if (isGetSet) this.raise(key.start, "Constructor can't have get/set modifier")
+        if (isGenerator) this.raise(key.start, "Constructor can't be a generator")
+        if (isAsync) this.raise(key.start, "Constructor can't be an async function")
         method.kind = "constructor"
+        hadConstructor = true
       }
     }
     if (method.kind === "constructor" && method.decorators) {
       this.raise(method.start, "You can't attach decorators to a class constructor")
     }
     this.parseClassMethod(classBody, method, isGenerator, isAsync)
+    if (isGetSet) {
+      let paramCount = method.kind === "get" ? 0 : 1
+      if (method.value.params.length !== paramCount) {
+        let start = method.value.start
+        if (method.kind === "get")
+          this.raise(start, "getter should have no params");
+        else
+          this.raise(start, "setter should have exactly one param")
+      }
+    }
   }
-  if (this.decorators.length) {
+  if (decorators.length) {
     this.raise(this.start, "You have trailing decorators with no method");
   }
   node.body = this.finishNode(classBody, "ClassBody")
@@ -570,7 +593,7 @@ pp.parseExport = function(node) {
       this.parseExportFrom(node)
       return this.finishNode(node, "ExportAllDeclaration")
     }
-  } else if (this.isExportDefaultSpecifier()) {
+  } else if (this.options.features["es7.exportExtensions"] && this.isExportDefaultSpecifier()) {
     let specifier = this.startNode()
     specifier.exported = this.parseIdent(true)
     node.specifiers = [this.finishNode(specifier, "ExportDefaultSpecifier")]
@@ -687,7 +710,6 @@ pp.parseImport = function(node) {
   if (this.type === tt.string) {
     node.specifiers = empty
     node.source = this.parseExprAtom()
-    node.kind = ""
   } else {
     node.specifiers = []
     this.parseImportSpecifiers(node)

src/acorn/src/tokenize.js

@@ -25,6 +25,9 @@ export class Token {
 
 const pp = Parser.prototype
 
+// Are we running under Rhino?
+const isRhino = typeof Packages == "object" && Object.prototype.toString.call(Packages) == "[object JavaPackage]"
+
 // Move to the next token
 
 pp.next = function() {
@@ -283,7 +286,7 @@ pp.readToken_lt_gt = function(code) { // '<>'
   }
   if (next == 33 && code == 60 && this.input.charCodeAt(this.pos + 2) == 45 &&
       this.input.charCodeAt(this.pos + 3) == 45) {
-    if (this.inModule) unexpected()
+    if (this.inModule) this.unexpected()
     // `<!--`, an XML-style comment that should be interpreted as a line comment
     this.skipLineComment(4)
     this.skipSpace()
@@ -320,7 +323,13 @@ pp.getTokenFromCode = function(code) {
   case 93: ++this.pos; return this.finishToken(tt.bracketR)
   case 123: ++this.pos; return this.finishToken(tt.braceL)
   case 125: ++this.pos; return this.finishToken(tt.braceR)
-  case 58: ++this.pos; return this.finishToken(tt.colon)
+
+  case 58:
+    if (this.options.features["es7.functionBind"] && this.input.charCodeAt(this.pos + 1) === 58)
+      return this.finishOp(tt.doubleColon, 2)
+    ++this.pos
+    return this.finishToken(tt.colon)
+
   case 63: ++this.pos; return this.finishToken(tt.question)
   case 64: ++this.pos; return this.finishToken(tt.at)
 
@@ -424,23 +433,30 @@ pp.readRegexp = function() {
       // negatives in unlikely scenarios. For example, `[\u{61}-b]` is a
       // perfectly valid pattern that is equivalent to `[a-b]`, but it would
       // be replaced by `[x-b]` which throws an error.
-      tmp = tmp.replace(/\\u([a-fA-F0-9]{4})|\\u\{([0-9a-fA-F]+)\}|[\uD800-\uDBFF][\uDC00-\uDFFF]/g, "x")
+      tmp = tmp.replace(/\\u\{([0-9a-fA-F]+)\}/g, (match, code, offset) => {
+        code = Number("0x" + code)
+        if (code > 0x10FFFF) this.raise(start + offset + 3, "Code point out of bounds")
+        return "x"
+      });
+      tmp = tmp.replace(/\\u([a-fA-F0-9]{4})|[\uD800-\uDBFF][\uDC00-\uDFFF]/g, "x")
     }
   }
   // Detect invalid regular expressions.
-  try {
-    new RegExp(tmp)
-  } catch (e) {
-    if (e instanceof SyntaxError) this.raise(start, "Error parsing regular expression: " + e.message)
-    this.raise(e)
-  }
-  // Get a regular expression object for this pattern-flag pair, or `null` in
-  // case the current environment doesn't support the flags it uses.
-  let value
-  try {
-    value = new RegExp(content, mods)
-  } catch (err) {
-    value = null
+  let value = null
+  // Rhino's regular expression parser is flaky and throws uncatchable exceptions,
+  // so don't do detection if we are running under Rhino
+  if (!isRhino) {
+    try {
+      new RegExp(tmp)
+    } catch (e) {
+      if (e instanceof SyntaxError) this.raise(start, "Error parsing regular expression: " + e.message)
+      this.raise(e)
+    }
+    // Get a regular expression object for this pattern-flag pair, or `null` in
+    // case the current environment doesn't support the flags it uses.
+    try {
+      value = new RegExp(content, mods)
+    } catch (err) {}
   }
   return this.finishToken(tt.regexp, {pattern: content, flags: mods, value: value})
 }
@@ -508,10 +524,10 @@ pp.readCodePoint = function() {
 
   if (ch === 123) {
     if (this.options.ecmaVersion < 6) this.unexpected()
-    ++this.pos
+    let codePos = ++this.pos
     code = this.readHexChar(this.input.indexOf('}', this.pos) - this.pos)
     ++this.pos
-    if (code > 0x10FFFF) this.unexpected()
+    if (code > 0x10FFFF) this.raise(codePos, "Code point out of bounds")
   } else {
     code = this.readHexChar(4)
   }
@@ -533,7 +549,7 @@ pp.readString = function(quote) {
     if (ch === quote) break
     if (ch === 92) { // '\'
       out += this.input.slice(chunkStart, this.pos)
-      out += this.readEscapedChar()
+      out += this.readEscapedChar(false)
       chunkStart = this.pos
     } else {
       if (isNewLine(ch)) this.raise(this.start, "Unterminated string constant")
@@ -566,16 +582,20 @@ pp.readTmplToken = function() {
     }
     if (ch === 92) { // '\'
       out += this.input.slice(chunkStart, this.pos)
-      out += this.readEscapedChar()
+      out += this.readEscapedChar(true)
       chunkStart = this.pos
     } else if (isNewLine(ch)) {
       out += this.input.slice(chunkStart, this.pos)
       ++this.pos
-      if (ch === 13 && this.input.charCodeAt(this.pos) === 10) {
-        ++this.pos
-        out += "\n"
-      } else {
-        out += String.fromCharCode(ch)
+      switch (ch) {
+        case 13:
+          if (this.input.charCodeAt(this.pos) === 10) ++this.pos;
+        case 10:
+          out += "\n";
+          break;
+        default:
+          out += String.fromCharCode(ch);
+          break;
       }
       if (this.options.locations) {
         ++this.curLine
@@ -590,42 +610,46 @@ pp.readTmplToken = function() {
 
 // Used to read escaped characters
 
-pp.readEscapedChar = function() {
+pp.readEscapedChar = function(inTemplate) {
   let ch = this.input.charCodeAt(++this.pos)
-  let octal = /^[0-7]+/.exec(this.input.slice(this.pos, this.pos + 3))
-  if (octal) octal = octal[0]
-  while (octal && parseInt(octal, 8) > 255) octal = octal.slice(0, -1)
-  if (octal === "0") octal = null
   ++this.pos
-  if (octal) {
-    if (this.strict) this.raise(this.pos - 2, "Octal literal in strict mode")
-    this.pos += octal.length - 1
-    return String.fromCharCode(parseInt(octal, 8))
-  } else {
-    switch (ch) {
-    case 110: return "\n"; // 'n' -> '\n'
-    case 114: return "\r"; // 'r' -> '\r'
-    case 120: return String.fromCharCode(this.readHexChar(2)); // 'x'
-    case 117: return codePointToString(this.readCodePoint()); // 'u'
-    case 116: return "\t"; // 't' -> '\t'
-    case 98: return "\b"; // 'b' -> '\b'
-    case 118: return "\u000b"; // 'v' -> '\u000b'
-    case 102: return "\f"; // 'f' -> '\f'
-    case 48: return "\0"; // 0 -> '\0'
-    case 13: if (this.input.charCodeAt(this.pos) === 10) ++this.pos; // '\r\n'
-    case 10: // ' \n'
-      if (this.options.locations) { this.lineStart = this.pos; ++this.curLine }
-      return ""
-    default: return String.fromCharCode(ch)
+  switch (ch) {
+  case 110: return "\n"; // 'n' -> '\n'
+  case 114: return "\r"; // 'r' -> '\r'
+  case 120: return String.fromCharCode(this.readHexChar(2)); // 'x'
+  case 117: return codePointToString(this.readCodePoint()); // 'u'
+  case 116: return "\t"; // 't' -> '\t'
+  case 98: return "\b"; // 'b' -> '\b'
+  case 118: return "\u000b"; // 'v' -> '\u000b'
+  case 102: return "\f"; // 'f' -> '\f'
+  case 13: if (this.input.charCodeAt(this.pos) === 10) ++this.pos; // '\r\n'
+  case 10: // ' \n'
+    if (this.options.locations) { this.lineStart = this.pos; ++this.curLine }
+    return ""
+  default:
+    if (ch >= 48 && ch <= 55) {
+      let octalStr = this.input.substr(this.pos - 1, 3).match(/^[0-7]+/)[0]
+      let octal = parseInt(octalStr, 8)
+      if (octal > 255) {
+        octalStr = octalStr.slice(0, -1)
+        octal = parseInt(octalStr, 8)
+      }
+      if (octal > 0 && (this.strict || inTemplate)) {
+        this.raise(this.pos - 2, "Octal literal in strict mode")
+      }
+      this.pos += octalStr.length - 1
+      return String.fromCharCode(octal)
     }
+    return String.fromCharCode(ch)
   }
 }
 
 // Used to read character escape sequences ('\x', '\u', '\U').
 
 pp.readHexChar = function(len) {
+  let codePos = this.pos
   let n = this.readInt(16, len)
-  if (n === null) this.raise(this.start, "Bad character escape sequence")
+  if (n === null) this.raise(codePos, "Bad character escape sequence")
   return n
 }
 

src/acorn/src/tokentype.js

@@ -54,6 +54,7 @@ export const types = {
   comma: new TokenType(",", beforeExpr),
   semi: new TokenType(";", beforeExpr),
   colon: new TokenType(":", beforeExpr),
+  doubleColon: new TokenType("::", beforeExpr),
   dot: new TokenType("."),
   question: new TokenType("?", beforeExpr),
   arrow: new TokenType("=>", beforeExpr),
@@ -111,12 +112,12 @@ kw("case", beforeExpr)
 kw("catch")
 kw("continue")
 kw("debugger")
-kw("default")
+kw("default", beforeExpr)
 kw("do", {isLoop: true})
 kw("else", beforeExpr)
 kw("finally")
 kw("for", {isLoop: true})
-kw("function")
+kw("function", startsExpr)
 kw("if")
 kw("return", beforeExpr)
 kw("switch")

src/acorn/src/util.js

@@ -1,7 +1,3 @@
-export function isArray(obj) {
-  return Object.prototype.toString.call(obj) === "[object Array]"
-}
-
 // Checks if an object has a property.
 
 export function has(obj, propName) {

src/babel/README.md

@@ -0,0 +1,4 @@
+## Diving into Babel
+
+If you look around in the various directories in here you'll find some details
+about the organization of the Babel codebase.

src/babel/api/README.md

@@ -0,0 +1,18 @@
+## API
+
+In this directory you'll find all the public interfaces to using Babel for both
+node and the browser.
+
+### Node
+
+There are two ways people use Babel within Node, they either are manipulating
+strings of code with `babel.transform` or `babel.parse`, they also might be
+running their code through Babel before execution via `register` or `polyfill`.
+
+### Browser
+
+Usage of Babel in the browser is extremely uncommon and in most cases
+considered A Bad Idea™. However it works by loading `<script>`'s with XHR,
+transforming them and then executing them. These `<script>`'s need to have a
+`type` of "text/ecmascript-6", "text/babel", or "module" ("text/6to5" exists as
+well for legacy reasons).

src/babel/api/browser.js

@@ -1,22 +1,45 @@
+/* eslint no-new-func: 0 */
+
+require("./node");
 var transform = module.exports = require("../transformation");
 
+/**
+ * Add `options` and `version` to `babel` global.
+ */
+
 transform.options = require("../transformation/file/options");
 transform.version = require("../../../package").version;
 
+/**
+ * Add `transform` api to `babel` global.
+ */
+
 transform.transform = transform;
 
+/**
+ * Tranform and execute script, adding in inline sourcemaps.
+ */
+
 transform.run = function (code, opts = {}) {
   opts.sourceMaps = "inline";
   return new Function(transform(code, opts).code)();
 };
 
+/**
+ * Load scripts via xhr, and `transform` when complete (optional).
+ */
+
 transform.load = function (url, callback, opts = {}, hold) {
-  opts.filename ||= url;
+  opts.filename = opts.filename || url;
 
   var xhr = global.ActiveXObject ? new global.ActiveXObject("Microsoft.XMLHTTP") : new global.XMLHttpRequest();
   xhr.open("GET", url, true);
   if ("overrideMimeType" in xhr) xhr.overrideMimeType("text/plain");
 
+  /**
+   * When successfully loaded, transform (optional), and call `callback`.
+   */
+
   xhr.onreadystatechange = function () {
     if (xhr.readyState !== 4) return;
 
@@ -33,11 +56,22 @@ transform.load = function (url, callback, opts = {}, hold) {
   xhr.send(null);
 };
 
+/**
+ * Load and transform all scripts of `types`.
+ *
+ * @example
+ * <script type="module"></script>
+ */
+
 var runScripts = function () {
   var scripts = [];
   var types   = ["text/ecmascript-6", "text/6to5", "text/babel", "module"];
   var index   = 0;
 
+  /**
+   * Transform and execute script. Ensures correct load order.
+   */
+
   var exec = function () {
     var param = scripts[index];
     if (param instanceof Array) {
@@ -47,6 +81,10 @@ var runScripts = function () {
     }
   };
 
+  /**
+   * Load, transform, and execute all scripts.
+   */
+
   var run = function (script, i) {
     var opts = {};
 
@@ -61,7 +99,9 @@ var runScripts = function () {
     }
   };
 
-  var _scripts = global.document .getElementsByTagName("script");
+  // Collect scripts with Babel `types`.
+
+  var _scripts = global.document.getElementsByTagName("script");
 
   for (var i = 0; i < _scripts.length; ++i) {
     var _script = _scripts[i];
@@ -75,6 +115,10 @@ var runScripts = function () {
   exec();
 };
 
+/**
+ * Register load event to transform and execute scripts.
+ */
+
 if (global.addEventListener) {
   global.addEventListener("DOMContentLoaded", runScripts, false);
 } else if (global.attachEvent) {

src/babel/api/node.js

@@ -4,12 +4,14 @@ import * as acorn from "../../acorn";
 import * as util from "../util";
 import fs from "fs";
 
-export { util, acorn };
+export { util, acorn, transform };
+export { pipeline } from "../transformation";
 export { canCompile } from "../util";
 
-export { default as options } from "../transformation/file/options";
+export { default as options } from "../transformation/file/options/config";
+export { default as Plugin } from "../transformation/plugin";
 export { default as Transformer } from "../transformation/transformer";
-export { default as transform } from "../transformation";
+export { default as Pipeline } from "../transformation/pipeline";
 export { default as traverse } from "../traversal";
 export { default as buildExternalHelpers } from "../tools/build-external-helpers";
 export { version } from "../../../package";
@@ -17,16 +19,28 @@ export { version } from "../../../package";
 import * as t from "../types";
 export { t as types };
 
+/**
+ * Register Babel and polyfill globally.
+ */
+
 export function register(opts?: Object) {
-  var callback = require("./register/node");
+  var callback = require("./register/node-polyfill");
   if (opts != null) callback(opts);
   return callback;
 }
 
+/**
+ * Register polyfill globally.
+ */
+
 export function polyfill() {
   require("../polyfill");
 }
 
+/**
+ * Asynchronously transform `filename` with optional `opts`, calls `callback` when complete.
+ */
+
 export function transformFile(filename: string, opts?: Object, callback: Function) {
   if (isFunction(opts)) {
     callback = opts;
@@ -50,7 +64,32 @@ export function transformFile(filename: string, opts?: Object, callback: Functio
   });
 }
 
+/**
+ * Synchronous form of `transformFile`.
+ */
+
 export function transformFileSync(filename: string, opts?: Object = {}) {
   opts.filename = filename;
-  return transform(fs.readFileSync(filename), opts);
+  return transform(fs.readFileSync(filename, "utf8"), opts);
+}
+
+/**
+ * Parse script with Babel's parser.
+ */
+
+export function parse(code, opts = {}) {
+  opts.allowHashBang = true;
+  opts.sourceType = "module";
+  opts.ecmaVersion = Infinity;
+  opts.plugins = {
+    jsx:  true,
+    flow: true
+  };
+  opts.features = {};
+
+  for (var key in transform.pipeline.transformers) {
+    opts.features[key] = true;
+  }
+
+  return acorn.parse(code, opts);
 }

src/babel/api/register/browser.js

@@ -1,5 +1,5 @@
 // required to safely use babel/register within a browserify codebase
 
-export default function () {};
+export default function () {}
 
 import "../../polyfill";

src/babel/api/register/cache.js

@@ -1,22 +1,30 @@
 import path from "path";
-import os from "os";
 import fs from "fs";
-import userHome from "user-home";
+import homeOrTmp from "home-or-tmp";
+import pathExists from "path-exists";
 
-const FILENAME = process.env.BABEL_CACHE_PATH || path.join(userHome || os.tmpdir(), ".babel.json");
+const FILENAME = process.env.BABEL_CACHE_PATH || path.join(homeOrTmp, ".babel.json");
 var data = {};
 
+/**
+ * Write stringified cache to disk.
+ */
+
 export function save() {
   fs.writeFileSync(FILENAME, JSON.stringify(data, null, "  "));
 }
 
+/**
+ * Load cache from disk and parse.
+ */
+
 export function load() {
   if (process.env.BABEL_DISABLE_CACHE) return;
 
   process.on("exit", save);
   process.nextTick(save);
 
-  if (!fs.existsSync(FILENAME)) return;
+  if (!pathExists.sync(FILENAME)) return;
 
   try {
     data = JSON.parse(fs.readFileSync(FILENAME));
@@ -25,6 +33,10 @@ export function load() {
   }
 }
 
+/**
+ * Retrieve data from cache.
+ */
+
 export function get() {
   return data;
 }

src/babel/api/register/node-polyfill.js

@@ -0,0 +1,2 @@
+import "../../polyfill";
+export { default } from "./node";

src/babel/api/register/node.js

@@ -1,12 +1,16 @@
-import "../../polyfill";
 import sourceMapSupport from "source-map-support";
 import * as registerCache from "./cache";
-import resolveRc from "../../tools/resolve-rc";
+import OptionManager from "../../transformation/file/options/option-manager";
 import extend from "lodash/object/extend";
 import * as babel from "../node";
 import each from "lodash/collection/each";
 import * as util from  "../../util";
 import fs from "fs";
+import path from "path";
+
+/**
+ * Install sourcemaps into node.
+ */
 
 sourceMapSupport.install({
   handleUncaughtExceptions: false,
@@ -23,34 +27,59 @@ sourceMapSupport.install({
   }
 });
 
-//
+/**
+ * Load and setup cache.
+ */
 
 registerCache.load();
 var cache = registerCache.get();
 
-//
+/**
+ * Store options.
+ */
 
 var transformOpts = {};
-var ignoreRegex   = /node_modules/;
-var onlyRegex;
+
+var ignore;
+var only;
+
 var oldHandlers   = {};
 var maps          = {};
 
+var cwd = process.cwd();
+
+/**
+ * Get path from `filename` relative to the current working directory.
+ */
+
+var getRelativePath = function (filename){
+  return path.relative(cwd, filename);
+};
+
+/**
+ * Get last modified time for a `filename`.
+ */
+
 var mtime = function (filename) {
   return +fs.statSync(filename).mtime;
 };
 
-var compile = function (filename) {
+/**
+ * Compile a `filename` with optional `opts`.
+ */
+
+var compile = function (filename, opts = {}) {
   var result;
 
-  var opts = extend({}, transformOpts);
-
-  // this will be done when the file is transformed anyway but we need all
-  // the options so we can generate the cache key
-  resolveRc(filename, opts);
+  var optsManager = new OptionManager;
+  optsManager.mergeOptions(transformOpts);
+  opts = optsManager.init(opts);
 
   var cacheKey = `${filename}:${JSON.stringify(opts)}:${babel.version}`;
 
+  var env = process.env.BABEL_ENV || process.env.NODE_ENV;
+  if (env) cacheKey += `:${env}`;
+
   if (cache) {
     var cached = cache[cacheKey];
     if (cached && cached.mtime === mtime(filename)) {
@@ -75,13 +104,25 @@ var compile = function (filename) {
   return result.code;
 };
 
+/**
+ * Test if a `filename` should be ignored by Babel.
+ */
+
 var shouldIgnore = function (filename) {
-  return (ignoreRegex && ignoreRegex.test(filename)) || (onlyRegex && !onlyRegex.test(filename));
+  if (!ignore && !only) {
+    return getRelativePath(filename).split(path.sep).indexOf("node_modules") >= 0;
+  } else {
+    return util.shouldIgnore(filename, ignore || [], only);
+  }
 };
 
+/**
+ * Monkey patch istanbul if it is running so that it works properly.
+ */
+
 var istanbulMonkey = {};
 
-if (process.env.running_under_istanbul) { // jshint ignore:line
+if (process.env.running_under_istanbul) {
   // we need to monkey patch fs.readFileSync so we can hook into
   // what istanbul gets, it's extremely dirty but it's the only way
   var _readFileSync = fs.readFileSync;
@@ -89,7 +130,9 @@ if (process.env.running_under_istanbul) { // jshint ignore:line
   fs.readFileSync = function (filename) {
     if (istanbulMonkey[filename]) {
       delete istanbulMonkey[filename];
-      var code = compile(filename);
+      var code = compile(filename, {
+        auxiliaryCommentBefore: "istanbul ignore next"
+      });
       istanbulMonkey[filename] = true;
       return code;
     } else {
@@ -98,20 +141,32 @@ if (process.env.running_under_istanbul) { // jshint ignore:line
   };
 }
 
+/**
+ * Replacement for the loader for istanbul.
+ */
+
 var istanbulLoader = function (m, filename, old) {
   istanbulMonkey[filename] = true;
   old(m, filename);
 };
 
+/**
+ * Default loader.
+ */
+
 var normalLoader = function (m, filename) {
   m._compile(compile(filename), filename);
 };
 
+/**
+ * Register a loader for an extension.
+ */
+
 var registerExtension = function (ext) {
-  var old = oldHandlers[ext] || oldHandlers[".js"];
+  var old = oldHandlers[ext] || oldHandlers[".js"] || require.extensions[".js"];
 
   var loader = normalLoader;
-  if (process.env.running_under_istanbul) loader = istanbulLoader; // jshint ignore:line
+  if (process.env.running_under_istanbul) loader = istanbulLoader;
 
   require.extensions[ext] = function (m, filename) {
     if (shouldIgnore(filename)) {
@@ -122,6 +177,10 @@ var registerExtension = function (ext) {
   };
 };
 
+/**
+ * Register loader for given extensions.
+ */
+
 var hookExtensions = function (_exts) {
   each(oldHandlers, function (old, ext) {
     if (old === undefined) {
@@ -139,11 +198,19 @@ var hookExtensions = function (_exts) {
   });
 };
 
+/**
+ * Register loader for default extensions.
+ */
+
 hookExtensions(util.canCompile.EXTENSIONS);
 
+/**
+ * Update options at runtime.
+ */
+
 export default function (opts = {}) {
-  if (opts.only != null) onlyRegex = util.regexify(opts.only);
-  if (opts.ignore != null) ignoreRegex = util.regexify(opts.ignore);
+  if (opts.only != null) only = util.arrayify(opts.only, util.regexify);
+  if (opts.ignore != null) ignore = util.arrayify(opts.ignore, util.regexify);
 
   if (opts.extensions) hookExtensions(util.arrayify(opts.extensions));
 
@@ -155,17 +222,4 @@ export default function (opts = {}) {
   delete opts.only;
 
   extend(transformOpts, opts);
-};
-
-//
-
-try {
-  var runtimePackage = require("babel-runtime/package");
-  var version = require("../../../../package").version;
-  if (runtimePackage.version !== version) {
-    throw new ReferenceError(`The verison of babel-runtime of ${runtimePackage.runtime} that you have installed does not match the babel verison of ${version}`);
-  }
-} catch (err) {
-  if (err.code !== "MODULE_NOT_FOUND") throw err;
 }
-

src/babel/generation/README.md

@@ -0,0 +1,16 @@
+## Generation
+
+Here is Babel's code generator, here you'll find all of the code to turn an AST
+back into a string of code.
+
+[TBD: To Be Documented:]
+
+- Code Generator
+- Buffer
+- Source Maps
+  - Position
+- Printer
+- Code Style
+  - Whitespace
+  - Parenthesis
+- Generators

src/babel/generation/buffer.js

@@ -4,6 +4,10 @@ import isBoolean from "lodash/lang/isBoolean";
 import includes from "lodash/collection/includes";
 import isNumber from "lodash/lang/isNumber";
 
+/**
+ * Buffer for collecting generated output.
+ */
+
 export default class Buffer {
   constructor(position, format) {
     this.position = position;
@@ -12,10 +16,18 @@ export default class Buffer {
     this.buf      = "";
   }
 
+  /**
+   * Get the current trimmed buffer.
+   */
+
   get() {
     return trimRight(this.buf);
   }
 
+  /**
+   * Get the current indent.
+   */
+
   getIndent() {
     if (this.format.compact || this.format.concise) {
       return "";
@@ -24,43 +36,80 @@ export default class Buffer {
     }
   }
 
+  /**
+   * Get the current indent size.
+   */
+
   indentSize() {
     return this.getIndent().length;
   }
 
+  /**
+   * Increment indent size.
+   */
+
   indent() {
     this._indent++;
   }
 
+  /**
+   * Decrement indent size.
+   */
+
   dedent() {
     this._indent--;
   }
 
+  /**
+   * Add a semicolon to the buffer.
+   */
+
   semicolon() {
     this.push(";");
   }
 
+  /**
+   * Ensure last character is a semicolon.
+   */
+
   ensureSemicolon() {
     if (!this.isLast(";")) this.semicolon();
   }
 
+  /**
+   * Add a right brace to the buffer.
+   */
+
   rightBrace() {
     this.newline(true);
     this.push("}");
   }
 
+  /**
+   * Add a keyword to the buffer.
+   */
+
   keyword(name) {
     this.push(name);
     this.space();
   }
 
-  space() {
-    if (this.format.compact) return;
-    if (this.buf && !this.isLast(" ") && !this.isLast("\n")) {
+  /**
+   * Add a space to the buffer unless it is compact (override with force).
+   */
+
+  space(force?) {
+    if (!force && this.format.compact) return;
+
+    if (force || this.buf && !this.isLast(" ") && !this.isLast("\n")) {
       this.push(" ");
     }
   }
 
+  /**
+   * Remove the last character.
+   */
+
   removeLast(cha) {
     if (this.format.compact) return;
     if (!this.isLast(cha)) return;
@@ -69,15 +118,20 @@ export default class Buffer {
     this.position.unshift(cha);
   }
 
+  /**
+   * Add a newline (or many newlines), maintaining formatting.
+   * Strips multiple newlines if removeLast is true.
+   */
+
   newline(i, removeLast) {
-    if (this.format.compact) return;
+    if (this.format.compact || this.format.retainLines) return;
 
     if (this.format.concise) {
       this.space();
       return;
     }
 
-    removeLast ||= false;
+    removeLast = removeLast || false;
 
     if (isNumber(i)) {
       i = Math.min(2, i);
@@ -99,6 +153,10 @@ export default class Buffer {
     this._newline(removeLast);
   }
 
+  /**
+   * Adds a newline unless there is already two previous newlines.
+   */
+
   _newline(removeLast) {
     // never allow more than two lines
     if (this.endsWith("\n\n")) return;
@@ -117,8 +175,9 @@ export default class Buffer {
 
   _removeSpacesAfterLastNewline() {
     var lastNewlineIndex = this.buf.lastIndexOf("\n");
-    if (lastNewlineIndex === -1)
+    if (lastNewlineIndex === -1) {
       return;
+    }
 
     var index = this.buf.length - 1;
     while (index > lastNewlineIndex) {
@@ -134,6 +193,10 @@ export default class Buffer {
     }
   }
 
+  /**
+   * Push a string to the buffer, maintaining indentation and newlines.
+   */
+
   push(str, noIndent) {
     if (!this.format.compact && this._indent && !noIndent && str !== "\n") {
       // we have an indent level and we aren't pushing a newline
@@ -149,15 +212,31 @@ export default class Buffer {
     this._push(str);
   }
 
+  /**
+   * Push a string to the buffer.
+   */
+
   _push(str) {
     this.position.push(str);
     this.buf += str;
   }
 
-  endsWith(str) {
-    return this.buf.slice(-str.length) === str;
+  /**
+   * Test if the buffer ends with a string.
+   */
+
+  endsWith(str, buf = this.buf) {
+    if (str.length === 1) {
+      return buf[buf.length - 1] === str;
+    } else {
+      return buf.slice(-str.length) === str;
+    }
   }
 
+  /**
+   * Test if a character is last in the buffer.
+   */
+
   isLast(cha) {
     if (this.format.compact) return false;
 

src/babel/generation/generators/README.md

@@ -0,0 +1,10 @@
+## Generators
+
+Code generation in Babel is broken down into generators by node type, they all
+live in this directory.
+
+[TBD: To Be Documented:]
+
+- How generators work
+- How to print a node
+- How generators related to one another

src/babel/generation/generators/base.js

@@ -1,11 +1,23 @@
+/**
+ * Print File.program
+ */
+
 export function File(node, print) {
-  print(node.program);
+  print.plain(node.program);
 }
 
+/**
+ * Print all nodes in a Program.body.
+ */
+
 export function Program(node, print) {
   print.sequence(node.body);
 }
 
+/**
+ * Print BlockStatement, collapses empty blocks, prints body.
+ */
+
 export function BlockStatement(node, print) {
   if (node.body.length === 0) {
     this.push("{}");
@@ -13,7 +25,18 @@ export function BlockStatement(node, print) {
     this.push("{");
     this.newline();
     print.sequence(node.body, { indent: true });
-    this.removeLast("\n");
+    if (!this.format.retainLines) this.removeLast("\n");
     this.rightBrace();
   }
 }
+
+/**
+ * What is my purpose?
+ * Why am I here?
+ * Why are any of us here?
+ * Does any of this really matter?
+ */
+
+export function Noop() {
+
+}

src/babel/generation/generators/classes.js

@@ -1,18 +1,22 @@
+/**
+ * Print ClassDeclaration, prints decorators, typeParameters, extends, implements, and body.
+ */
+
 export function ClassDeclaration(node, print) {
-  print.list(node.decorators);
+  print.list(node.decorators, { separator: "" });
   this.push("class");
 
   if (node.id) {
-    this.space();
-    print(node.id);
+    this.push(" ");
+    print.plain(node.id);
   }
 
-  print(node.typeParameters);
+  print.plain(node.typeParameters);
 
   if (node.superClass) {
     this.push(" extends ");
-    print(node.superClass);
-    print(node.superTypeParameters);
+    print.plain(node.superClass);
+    print.plain(node.superTypeParameters);
   }
 
   if (node.implements) {
@@ -21,11 +25,19 @@ export function ClassDeclaration(node, print) {
   }
 
   this.space();
-  print(node.body);
+  print.plain(node.body);
 }
 
+/**
+ * Alias ClassDeclaration printer as ClassExpression.
+ */
+
 export { ClassDeclaration as ClassExpression };
 
+/**
+ * Print ClassBody, collapses empty blocks, prints body.
+ */
+
 export function ClassBody(node, print) {
   if (node.body.length === 0) {
     this.push("{}");
@@ -41,24 +53,32 @@ export function ClassBody(node, print) {
   }
 }
 
+/**
+ * Print ClassProperty, prints decorators, static, key, typeAnnotation, and value.
+ * Also: semicolons, deal with it.
+ */
 
 export function ClassProperty(node, print) {
-  print.list(node.decorators);
+  print.list(node.decorators, { separator: "" });
 
   if (node.static) this.push("static ");
-  print(node.key);
-  print(node.typeAnnotation);
+  print.plain(node.key);
+  print.plain(node.typeAnnotation);
   if (node.value) {
     this.space();
     this.push("=");
     this.space();
-    print(node.value);
+    print.plain(node.value);
   }
   this.semicolon();
 }
 
+/**
+ * Print MethodDefinition, prints decorations, static, and method.
+ */
+
 export function MethodDefinition(node, print) {
-  print.list(node.decorators);
+  print.list(node.decorators, { separator: "" });
 
   if (node.static) {
     this.push("static ");

src/babel/generation/generators/comprehensions.js

@@ -1,12 +1,20 @@
+/**
+ * Prints ComprehensionBlock, prints left and right.
+ */
+
 export function ComprehensionBlock(node, print) {
   this.keyword("for");
   this.push("(");
-  print(node.left);
+  print.plain(node.left);
   this.push(" of ");
-  print(node.right);
+  print.plain(node.right);
   this.push(")");
 }
 
+/**
+ * Prints ComprehensionExpression, prints blocks, filter, and body. Handles generators.
+ */
+
 export function ComprehensionExpression(node, print) {
   this.push(node.generator ? "(" : "[");
 
@@ -16,12 +24,12 @@ export function ComprehensionExpression(node, print) {
   if (node.filter) {
     this.keyword("if");
     this.push("(");
-    print(node.filter);
+    print.plain(node.filter);
     this.push(")");
     this.space();
   }
 
-  print(node.body);
+  print.plain(node.body);
 
   this.push(node.generator ? ")" : "]");
 }

src/babel/generation/generators/expressions.js

@@ -1,95 +1,144 @@
-import isInteger from "is-integer";
 import isNumber from "lodash/lang/isNumber";
 import * as t from "../../types";
 
+/**
+ * Prints UnaryExpression, prints operator and argument.
+ */
+
 export function UnaryExpression(node, print) {
-  var hasSpace = /[a-z]$/.test(node.operator);
+  var needsSpace = /[a-z]$/.test(node.operator);
   var arg = node.argument;
 
   if (t.isUpdateExpression(arg) || t.isUnaryExpression(arg)) {
-    hasSpace = true;
+    needsSpace = true;
   }
 
   if (t.isUnaryExpression(arg) && arg.operator === "!") {
-    hasSpace = false;
+    needsSpace = false;
   }
 
   this.push(node.operator);
-  if (hasSpace) this.push(" ");
-  print(node.argument);
+  if (needsSpace) this.push(" ");
+  print.plain(node.argument);
 }
 
+/**
+ * Prints DoExpression, prints body.
+ */
+
 export function DoExpression(node, print) {
   this.push("do");
   this.space();
-  print(node.body);
+  print.plain(node.body);
 }
 
+/**
+ * Prints ParenthesizedExpression, prints expression.
+ */
+
+export function ParenthesizedExpression(node, print) {
+  this.push("(");
+  print.plain(node.expression);
+  this.push(")");
+}
+
+/**
+ * Prints UpdateExpression, prints operator and argument.
+ */
+
 export function UpdateExpression(node, print) {
   if (node.prefix) {
     this.push(node.operator);
-    print(node.argument);
+    print.plain(node.argument);
   } else {
-    print(node.argument);
+    print.plain(node.argument);
     this.push(node.operator);
   }
 }
 
+/**
+ * Prints ConditionalExpression, prints test, consequent, and alternate.
+ */
+
 export function ConditionalExpression(node, print) {
-  print(node.test);
+  print.plain(node.test);
   this.space();
   this.push("?");
   this.space();
-  print(node.consequent);
+  print.plain(node.consequent);
   this.space();
   this.push(":");
   this.space();
-  print(node.alternate);
+  print.plain(node.alternate);
 }
 
+/**
+ * Prints NewExpression, prints callee and arguments.
+ */
+
 export function NewExpression(node, print) {
   this.push("new ");
-  print(node.callee);
+  print.plain(node.callee);
   this.push("(");
   print.list(node.arguments);
   this.push(")");
 }
 
+/**
+ * Prints SequenceExpression.expressions.
+ */
+
 export function SequenceExpression(node, print) {
   print.list(node.expressions);
 }
 
+/**
+ * Prints ThisExpression.
+ */
+
 export function ThisExpression() {
   this.push("this");
 }
 
+/**
+ * Prints Super.
+ */
+
 export function Super() {
   this.push("super");
 }
 
+/**
+ * Prints Decorator, prints expression.
+ */
+
 export function Decorator(node, print) {
   this.push("@");
-  print(node.expression);
+  print.plain(node.expression);
+  this.newline();
 }
 
+/**
+ * Prints CallExpression, prints callee and arguments.
+ */
+
 export function CallExpression(node, print) {
-  print(node.callee);
+  print.plain(node.callee);
 
   this.push("(");
 
-  var separator = ",";
+  var isPrettyCall = node._prettyCall && !this.format.retainLines && !this.format.compact;
 
-  if (node._prettyCall) {
-    separator += "\n";
+  var separator;
+  if (isPrettyCall) {
+    separator = ",\n";
     this.newline();
     this.indent();
-  } else {
-    separator += " ";
   }
 
-  print.list(node.arguments, { separator: separator });
+  print.list(node.arguments, { separator });
 
-  if (node._prettyCall) {
+  if (isPrettyCall) {
     this.newline();
     this.dedent();
   }
@@ -97,6 +146,11 @@ export function CallExpression(node, print) {
   this.push(")");
 }
 
+/**
+ * Builds yield or await expression printer.
+ * Prints delegate, all, and argument.
+ */
+
 var buildYieldAwait = function (keyword) {
   return function (node, print) {
     this.push(keyword);
@@ -106,44 +160,100 @@ var buildYieldAwait = function (keyword) {
     }
 
     if (node.argument) {
-      this.space();
-      print(node.argument);
+      this.push(" ");
+      print.plain(node.argument);
     }
   };
 };
 
+/**
+ * Create YieldExpression and AwaitExpression printers.
+ */
+
 export var YieldExpression = buildYieldAwait("yield");
 export var AwaitExpression = buildYieldAwait("await");
 
+/**
+ * Prints EmptyStatement.
+ */
+
 export function EmptyStatement() {
   this.semicolon();
 }
 
+/**
+ * Prints ExpressionStatement, prints expression.
+ */
+
 export function ExpressionStatement(node, print) {
-  print(node.expression);
+  print.plain(node.expression);
   this.semicolon();
 }
 
+/**
+ * Prints AssignmentPattern, prints left and right.
+ */
+
+export function AssignmentPattern(node, print) {
+  print.plain(node.left);
+  this.push(" = ");
+  print.plain(node.right);
+}
+
+/**
+ * Prints AssignmentExpression, prints left, operator, and right.
+ */
+
 export function AssignmentExpression(node, print) {
   // todo: add cases where the spaces can be dropped when in compact mode
-  print(node.left);
-  this.push(" ");
+  print.plain(node.left);
+
+  var spaces = node.operator === "in" || node.operator === "instanceof";
+  spaces = true; // todo: https://github.com/babel/babel/issues/1835
+  this.space(spaces);
+
   this.push(node.operator);
-  this.push(" ");
-  print(node.right);
+
+  if (!spaces) {
+    // space is mandatory to avoid outputting <!--
+    // http://javascript.spec.whatwg.org/#comment-syntax
+    spaces = node.operator === "<" &&
+             t.isUnaryExpression(node.right, { prefix: true, operator: "!" }) &&
+             t.isUnaryExpression(node.right.argument, { prefix: true, operator: "--" });
+  }
+
+  this.space(spaces);
+
+  print.plain(node.right);
 }
 
+/**
+ * Prints BindExpression, prints object and callee.
+ */
+
+export function BindExpression(node, print) {
+  print.plain(node.object);
+  this.push("::");
+  print.plain(node.callee);
+}
+
+/**
+ * Alias ClassDeclaration printer as ClassExpression,
+ * and AssignmentExpression printer as LogicalExpression.
+ */
+
 export {
   AssignmentExpression as BinaryExpression,
-  AssignmentExpression as LogicalExpression,
-  AssignmentExpression as AssignmentPattern
+  AssignmentExpression as LogicalExpression
 };
 
-var SCIENTIFIC_NOTATION = /e/i;
+/**
+ * Print MemberExpression, prints object, property, and value. Handles computed.
+ */
 
 export function MemberExpression(node, print) {
   var obj = node.object;
-  print(obj);
+  print.plain(obj);
 
   if (!node.computed && t.isMemberExpression(node.property)) {
     throw new TypeError("Got a MemberExpression for MemberExpression property");
@@ -156,21 +266,20 @@ export function MemberExpression(node, print) {
 
   if (computed) {
     this.push("[");
-    print(node.property);
+    print.plain(node.property);
     this.push("]");
   } else {
-    // 5..toFixed(2);
-    if (t.isLiteral(obj) && isInteger(obj.value) && !SCIENTIFIC_NOTATION.test(obj.value.toString())) {
-      this.push(".");
-    }
-
     this.push(".");
-    print(node.property);
+    print.plain(node.property);
   }
 }
 
+/**
+ * Print MetaProperty, prints meta and property.
+ */
+
 export function MetaProperty(node, print) {
-  print(node.meta);
+  print.plain(node.meta);
   this.push(".");
-  print(node.property);
+  print.plain(node.property);
 }

src/babel/generation/generators/flow.js

@@ -1,47 +1,79 @@
 import * as t from "../../types";
 
+/**
+ * Prints AnyTypeAnnotation.
+ */
+
 export function AnyTypeAnnotation() {
   this.push("any");
 }
 
+/**
+ * Prints ArrayTypeAnnotation, prints elementType.
+ */
+
 export function ArrayTypeAnnotation(node, print) {
-  print(node.elementType);
+  print.plain(node.elementType);
   this.push("[");
   this.push("]");
 }
 
+/**
+ * Prints BooleanTypeAnnotation.
+ */
+
 export function BooleanTypeAnnotation(node) {
   this.push("bool");
 }
 
+/**
+ * Prints DeclareClass, prints node.
+ */
+
 export function DeclareClass(node, print) {
   this.push("declare class ");
   this._interfaceish(node, print);
 }
 
+/**
+ * Prints DeclareFunction, prints id and id.typeAnnotation.
+ */
+
 export function DeclareFunction(node, print) {
   this.push("declare function ");
-  print(node.id);
-  print(node.id.typeAnnotation.typeAnnotation);
+  print.plain(node.id);
+  print.plain(node.id.typeAnnotation.typeAnnotation);
   this.semicolon();
 }
 
+/**
+ * Prints DeclareModule, prints id and body.
+ */
+
 export function DeclareModule(node, print) {
   this.push("declare module ");
-  print(node.id);
+  print.plain(node.id);
   this.space();
-  print(node.body);
+  print.plain(node.body);
 }
 
+/**
+ * Prints DeclareVariable, prints id and id.typeAnnotation.
+ */
+
 export function DeclareVariable(node, print) {
   this.push("declare var ");
-  print(node.id);
-  print(node.id.typeAnnotation);
+  print.plain(node.id);
+  print.plain(node.id.typeAnnotation);
   this.semicolon();
 }
 
+/**
+ * Prints FunctionTypeAnnotation, prints typeParameters, params, and rest.
+ */
+
 export function FunctionTypeAnnotation(node, print, parent) {
-  print(node.typeParameters);
+  print.plain(node.typeParameters);
   this.push("(");
   print.list(node.params);
 
@@ -51,7 +83,7 @@ export function FunctionTypeAnnotation(node, print, parent) {
       this.space();
     }
     this.push("...");
-    print(node.rest);
+    print.plain(node.rest);
   }
 
   this.push(")");
@@ -65,98 +97,175 @@ export function FunctionTypeAnnotation(node, print, parent) {
   }
 
   this.space();
-  print(node.returnType);
+  print.plain(node.returnType);
 }
 
+/**
+ * Prints FunctionTypeParam, prints name and typeAnnotation, handles optional.
+ */
+
 export function FunctionTypeParam(node, print) {
-  print(node.name);
+  print.plain(node.name);
   if (node.optional) this.push("?");
   this.push(":");
   this.space();
-  print(node.typeAnnotation);
+  print.plain(node.typeAnnotation);
 }
 
+/**
+ * Prints InterfaceExtends, prints id and typeParameters.
+ */
+
 export function InterfaceExtends(node, print) {
-  print(node.id);
-  print(node.typeParameters);
+  print.plain(node.id);
+  print.plain(node.typeParameters);
 }
 
+/**
+ * Alias InterfaceExtends printer as ClassImplements,
+ * and InterfaceExtends printer as GenericTypeAnnotation.
+ */
+
 export { InterfaceExtends as ClassImplements, InterfaceExtends as GenericTypeAnnotation };
 
+/**
+ * Prints interface-like node, prints id, typeParameters, extends, and body.
+ */
+
 export function _interfaceish(node, print) {
-  print(node.id);
-  print(node.typeParameters);
+  print.plain(node.id);
+  print.plain(node.typeParameters);
   if (node.extends.length) {
     this.push(" extends ");
     print.join(node.extends, { separator: ", " });
   }
   this.space();
-  print(node.body);
+  print.plain(node.body);
 }
 
+/**
+ * Prints InterfaceDeclaration, prints node.
+ */
+
 export function InterfaceDeclaration(node, print) {
   this.push("interface ");
   this._interfaceish(node, print);
 }
 
+/**
+ * Prints IntersectionTypeAnnotation, prints types.
+ */
+
 export function IntersectionTypeAnnotation(node, print) {
   print.join(node.types, { separator: " & " });
 }
 
+/**
+ * Prints MixedTypeAnnotation.
+ */
+
+export function MixedTypeAnnotation() {
+  this.push("mixed");
+}
+
+/**
+ * Prints NullableTypeAnnotation, prints typeAnnotation.
+ */
+
 export function NullableTypeAnnotation(node, print) {
   this.push("?");
-  print(node.typeAnnotation);
+  print.plain(node.typeAnnotation);
 }
 
+/**
+ * Prints NumberTypeAnnotation.
+ */
+
 export function NumberTypeAnnotation() {
   this.push("number");
 }
 
+/**
+ * Prints StringLiteralTypeAnnotation, prints value.
+ */
+
 export function StringLiteralTypeAnnotation(node) {
   this._stringLiteral(node.value);
 }
 
+/**
+ * Prints StringTypeAnnotation.
+ */
+
 export function StringTypeAnnotation() {
   this.push("string");
 }
 
+/**
+ * Prints TupleTypeAnnotation, prints types.
+ */
+
 export function TupleTypeAnnotation(node, print) {
   this.push("[");
   print.join(node.types, { separator: ", " });
   this.push("]");
 }
 
+/**
+ * Prints TypeofTypeAnnotation, prints argument.
+ */
+
 export function TypeofTypeAnnotation(node, print) {
   this.push("typeof ");
-  print(node.argument);
+  print.plain(node.argument);
 }
 
+/**
+ * Prints TypeAlias, prints id, typeParameters, and right.
+ */
+
 export function TypeAlias(node, print) {
   this.push("type ");
-  print(node.id);
-  print(node.typeParameters);
+  print.plain(node.id);
+  print.plain(node.typeParameters);
   this.space();
   this.push("=");
   this.space();
-  print(node.right);
+  print.plain(node.right);
   this.semicolon();
 }
 
+/**
+ * Prints TypeAnnotation, prints typeAnnotation, handles optional.
+ */
+
 export function TypeAnnotation(node, print) {
   this.push(":");
   this.space();
   if (node.optional) this.push("?");
-  print(node.typeAnnotation);
+  print.plain(node.typeAnnotation);
 }
 
+/**
+ * Prints TypeParameterInstantiation, prints params.
+ */
+
 export function TypeParameterInstantiation(node, print) {
   this.push("<");
   print.join(node.params, { separator: ", " });
   this.push(">");
 }
 
+/**
+ * Alias TypeParameterInstantiation printer as TypeParameterDeclaration
+ */
+
 export { TypeParameterInstantiation as TypeParameterDeclaration };
 
+/**
+ * Prints ObjectTypeAnnotation, prints properties, callProperties, and indexers.
+ */
+
 export function ObjectTypeAnnotation(node, print) {
   this.push("{");
   var props = node.properties.concat(node.callProperties, node.indexers);
@@ -181,52 +290,80 @@ export function ObjectTypeAnnotation(node, print) {
   this.push("}");
 }
 
+/**
+ * Prints ObjectTypeCallProperty, prints value, handles static.
+ */
+
 export function ObjectTypeCallProperty(node, print) {
   if (node.static) this.push("static ");
-  print(node.value);
+  print.plain(node.value);
 }
 
+/**
+ * Prints ObjectTypeIndexer, prints id, key, and value, handles static.
+ */
+
 export function ObjectTypeIndexer(node, print) {
   if (node.static) this.push("static ");
   this.push("[");
-  print(node.id);
+  print.plain(node.id);
   this.push(":");
   this.space();
-  print(node.key);
+  print.plain(node.key);
   this.push("]");
   this.push(":");
   this.space();
-  print(node.value);
+  print.plain(node.value);
 }
 
+/**
+ * Prints ObjectTypeProperty, prints static, key, and value.
+ */
+
 export function ObjectTypeProperty(node, print) {
   if (node.static) this.push("static ");
-  print(node.key);
+  print.plain(node.key);
   if (node.optional) this.push("?");
   if (!t.isFunctionTypeAnnotation(node.value)) {
     this.push(":");
     this.space();
   }
-  print(node.value);
+  print.plain(node.value);
 }
 
+/**
+ * Prints QualifiedTypeIdentifier, prints qualification and id.
+ */
+
 export function QualifiedTypeIdentifier(node, print) {
-  print(node.qualification);
+  print.plain(node.qualification);
   this.push(".");
-  print(node.id);
+  print.plain(node.id);
 }
 
+/**
+ * Prints UnionTypeAnnotation, prints types.
+ */
+
 export function UnionTypeAnnotation(node, print) {
   print.join(node.types, { separator: " | " });
 }
 
+/**
+ * Prints TypeCastExpression, prints expression and typeAnnotation.
+ */
+
 export function TypeCastExpression(node, print) {
   this.push("(");
-  print(node.expression);
-  print(node.typeAnnotation);
+  print.plain(node.expression);
+  print.plain(node.typeAnnotation);
   this.push(")");
 }
 
+/**
+ * Prints VoidTypeAnnotation.
+ */
+
 export function VoidTypeAnnotation(node) {
   this.push("void");
 }

src/babel/generation/generators/jsx.js

@@ -1,63 +1,94 @@
-import each from "lodash/collection/each";
 import * as t from "../../types";
 
+/**
+ * Prints JSXAttribute, prints name and value.
+ */
+
 export function JSXAttribute(node, print) {
-  print(node.name);
+  print.plain(node.name);
   if (node.value) {
     this.push("=");
-    print(node.value);
+    print.plain(node.value);
   }
 }
 
+/**
+ * Prints JSXIdentifier, prints name.
+ */
+
 export function JSXIdentifier(node) {
   this.push(node.name);
 }
 
+/**
+ * Prints JSXNamespacedName, prints namespace and name.
+ */
+
 export function JSXNamespacedName(node, print) {
-  print(node.namespace);
+  print.plain(node.namespace);
   this.push(":");
-  print(node.name);
+  print.plain(node.name);
 }
 
+/**
+ * Prints JSXMemberExpression, prints object and property.
+ */
+
 export function JSXMemberExpression(node, print) {
-  print(node.object);
+  print.plain(node.object);
   this.push(".");
-  print(node.property);
+  print.plain(node.property);
 }
 
+/**
+ * Prints JSXSpreadAttribute, prints argument.
+ */
+
 export function JSXSpreadAttribute(node, print) {
   this.push("{...");
-  print(node.argument);
+  print.plain(node.argument);
   this.push("}");
 }
 
+/**
+ * Prints JSXExpressionContainer, prints expression.
+ */
+
 export function JSXExpressionContainer(node, print) {
   this.push("{");
-  print(node.expression);
+  print.plain(node.expression);
   this.push("}");
 }
 
+/**
+ * Prints JSXElement, prints openingElement, children, and closingElement.
+ */
+
 export function JSXElement(node, print) {
   var open = node.openingElement;
-  print(open);
+  print.plain(open);
   if (open.selfClosing) return;
 
   this.indent();
-  each(node.children, (child) => {
+  for (var child of (node.children: Array)) {
     if (t.isLiteral(child)) {
-      this.push(child.value);
+      this.push(child.value, true);
     } else {
-      print(child);
+      print.plain(child);
     }
-  });
+  }
   this.dedent();
 
-  print(node.closingElement);
+  print.plain(node.closingElement);
 }
 
+/**
+ * Prints JSXOpeningElement, prints name and attributes, handles selfClosing.
+ */
+
 export function JSXOpeningElement(node, print) {
   this.push("<");
-  print(node.name);
+  print.plain(node.name);
   if (node.attributes.length > 0) {
     this.push(" ");
     print.join(node.attributes, { separator: " " });
@@ -65,10 +96,18 @@ export function JSXOpeningElement(node, print) {
   this.push(node.selfClosing ? " />" : ">");
 }
 
+/**
+ * Prints JSXClosingElement, prints name.
+ */
+
 export function JSXClosingElement(node, print) {
   this.push("</");
-  print(node.name);
+  print.plain(node.name);
   this.push(">");
 }
 
+/**
+ * Prints JSXEmptyExpression.
+ */
+
 export function JSXEmptyExpression() {}

src/babel/generation/generators/methods.js

@@ -1,21 +1,29 @@
 import * as t from "../../types";
 
+/**
+ * Prints nodes with params, prints typeParameters, params, and returnType, handles optional params.
+ */
+
 export function _params(node, print) {
-  print(node.typeParameters);
+  print.plain(node.typeParameters);
   this.push("(");
   print.list(node.params, {
     iterator: (node) =>{
       if (node.optional) this.push("?");
-      print(node.typeAnnotation);
+      print.plain(node.typeAnnotation);
     }
   });
   this.push(")");
 
   if (node.returnType) {
-    print(node.returnType);
+    print.plain(node.returnType);
   }
 }
 
+/**
+ * Prints method-like nodes, prints key, value, and body, handles async, generator, computed, and get or set.
+ */
+
 export function _method(node, print) {
   var value = node.value;
   var kind  = node.kind;
@@ -35,17 +43,21 @@ export function _method(node, print) {
 
   if (node.computed) {
     this.push("[");
-    print(key);
+    print.plain(key);
     this.push("]");
   } else {
-    print(key);
+    print.plain(key);
   }
 
   this._params(value, print);
-  this.push(" ");
-  print(value.body);
+  this.space();
+  print.plain(value.body);
 }
 
+/**
+ * Prints FunctionExpression, prints id and body, handles async and generator.
+ */
+
 export function FunctionExpression(node, print) {
   if (node.async) this.push("async ");
   this.push("function");
@@ -53,23 +65,32 @@ export function FunctionExpression(node, print) {
 
   if (node.id) {
     this.push(" ");
-    print(node.id);
+    print.plain(node.id);
   } else {
     this.space();
   }
 
   this._params(node, print);
   this.space();
-  print(node.body);
+  print.plain(node.body);
 }
 
+/**
+ * Alias FunctionExpression printer as FunctionDeclaration.
+ */
+
 export { FunctionExpression as FunctionDeclaration };
 
+/**
+ * Prints ArrowFunctionExpression, prints params and body, handles async.
+ * Leaves out parentheses when single param.
+ */
+
 export function ArrowFunctionExpression(node, print) {
   if (node.async) this.push("async ");
 
   if (node.params.length === 1 && t.isIdentifier(node.params[0])) {
-    print(node.params[0]);
+    print.plain(node.params[0]);
   } else {
     this._params(node, print);
   }
@@ -82,7 +103,7 @@ export function ArrowFunctionExpression(node, print) {
     this.push("(");
   }
 
-  print(node.body);
+  print.plain(node.body);
 
   if (bodyNeedsParens) {
     this.push(")");

src/babel/generation/generators/modules.js

@@ -1,69 +1,104 @@
-import each from "lodash/collection/each";
 import * as t from "../../types";
 
+/**
+ * Prints ImportSpecifier, prints imported and local.
+ */
+
 export function ImportSpecifier(node, print) {
-  print(node.imported);
-  if (node.local && node.local !== node.imported) {
+  print.plain(node.imported);
+  if (node.local && node.local.name !== node.imported.name) {
     this.push(" as ");
-    print(node.local);
+    print.plain(node.local);
   }
 }
 
+/**
+ * Prints ImportDefaultSpecifier, prints local.
+ */
+
 export function ImportDefaultSpecifier(node, print) {
-  print(node.local);
+  print.plain(node.local);
 }
 
+/**
+ * Prints ExportDefaultSpecifier, prints exported.
+ */
+
 export function ExportDefaultSpecifier(node, print) {
-  print(node.exported);
+  print.plain(node.exported);
 }
 
+/**
+ * Prints ExportSpecifier, prints local and exported.
+ */
+
 export function ExportSpecifier(node, print) {
-  print(node.local);
-  if (node.exported && node.local !== node.exported) {
+  print.plain(node.local);
+  if (node.exported && node.local.name !== node.exported.name) {
     this.push(" as ");
-    print(node.exported);
+    print.plain(node.exported);
   }
 }
 
+/**
+ * Prints ExportNamespaceSpecifier, prints exported.
+ */
+
 export function ExportNamespaceSpecifier(node, print) {
   this.push("* as ");
-  print(node.exported);
+  print.plain(node.exported);
 }
 
+/**
+ * Prints ExportAllDeclaration, prints exported and source.
+ */
+
 export function ExportAllDeclaration(node, print) {
   this.push("export *");
   if (node.exported) {
     this.push(" as ");
-    print(node.exported);
+    print.plain(node.exported);
   }
   this.push(" from ");
-  print(node.source);
+  print.plain(node.source);
   this.semicolon();
 }
 
+/**
+ * Prints ExportNamedDeclaration, delegates to ExportDeclaration.
+ */
+
 export function ExportNamedDeclaration(node, print) {
   this.push("export ");
   ExportDeclaration.call(this, node, print);
 }
 
+/**
+ * Prints ExportDefaultDeclaration, delegates to ExportDeclaration.
+ */
+
 export function ExportDefaultDeclaration(node, print) {
   this.push("export default ");
   ExportDeclaration.call(this, node, print);
 }
 
+/**
+ * Prints ExportDeclaration, prints specifiers, declration, and source.
+ */
+
 function ExportDeclaration(node, print) {
   var specifiers = node.specifiers;
 
   if (node.declaration) {
     var declar = node.declaration;
-    print(declar);
+    print.plain(declar);
     if (t.isStatement(declar) || t.isFunction(declar) || t.isClass(declar)) return;
   } else {
     var first = specifiers[0];
     var hasSpecial = false;
     if (t.isExportDefaultSpecifier(first) || t.isExportNamespaceSpecifier(first)) {
       hasSpecial = true;
-      print(specifiers.shift());
+      print.plain(specifiers.shift());
       if (specifiers.length) {
         this.push(", ");
       }
@@ -81,25 +116,29 @@ function ExportDeclaration(node, print) {
 
     if (node.source) {
       this.push(" from ");
-      print(node.source);
+      print.plain(node.source);
     }
   }
 
   this.ensureSemicolon();
 }
 
+/**
+ * Prints ImportDeclaration, prints specifiers and source, handles isType.
+ */
+
 export function ImportDeclaration(node, print) {
   this.push("import ");
 
-  if (node.isType) {
-    this.push("type ");
+  if (node.importKind === "type" || node.importKind === "typeof") {
+    this.push(node.importKind + " ");
   }
 
   var specfiers = node.specifiers;
   if (specfiers && specfiers.length) {
     var first = node.specifiers[0];
     if (t.isImportDefaultSpecifier(first) || t.isImportNamespaceSpecifier(first)) {
-      print(node.specifiers.shift());
+      print.plain(node.specifiers.shift());
       if (node.specifiers.length) {
         this.push(", ");
       }
@@ -107,20 +146,24 @@ export function ImportDeclaration(node, print) {
 
     if (node.specifiers.length) {
       this.push("{");
-      this.space()
+      this.space();
       print.join(node.specifiers, { separator: ", " });
-      this.space()
+      this.space();
       this.push("}");
     }
 
     this.push(" from ");
   }
 
-  print(node.source);
+  print.plain(node.source);
   this.semicolon();
 }
 
+/**
+ * Prints ImportNamespaceSpecifier, prints local.
+ */
+
 export function ImportNamespaceSpecifier(node, print) {
   this.push("* as ");
-  print(node.local);
+  print.plain(node.local);
 }

src/babel/generation/generators/statements.js

@@ -1,18 +1,26 @@
 import repeating from "repeating";
 import * as t from "../../types";
 
+/**
+ * Prints WithStatement, prints object and body.
+ */
+
 export function WithStatement(node, print) {
   this.keyword("with");
   this.push("(");
-  print(node.object);
+  print.plain(node.object);
   this.push(")");
   print.block(node.body);
 }
 
+/**
+ * Prints IfStatement, prints test, consequent, and alternate.
+ */
+
 export function IfStatement(node, print) {
   this.keyword("if");
   this.push("(");
-  print(node.test);
+  print.plain(node.test);
   this.push(")");
   this.space();
 
@@ -25,61 +33,87 @@ export function IfStatement(node, print) {
   }
 }
 
+/**
+ * Prints ForStatement, prints init, test, update, and body.
+ */
+
 export function ForStatement(node, print) {
   this.keyword("for");
   this.push("(");
 
-  print(node.init);
+  print.plain(node.init);
   this.push(";");
 
   if (node.test) {
-    this.push(" ");
-    print(node.test);
+    this.space();
+    print.plain(node.test);
   }
   this.push(";");
 
   if (node.update) {
-    this.push(" ");
-    print(node.update);
+    this.space();
+    print.plain(node.update);
   }
 
   this.push(")");
   print.block(node.body);
 }
 
+/**
+ * Prints WhileStatement, prints test and body.
+ */
+
 export function WhileStatement(node, print) {
   this.keyword("while");
   this.push("(");
-  print(node.test);
+  print.plain(node.test);
   this.push(")");
   print.block(node.body);
 }
 
+/**
+ * Builds ForIn or ForOf statement printers.
+ * Prints left, right, and body.
+ */
+
 var buildForXStatement = function (op) {
   return function (node, print) {
     this.keyword("for");
     this.push("(");
-    print(node.left);
+    print.plain(node.left);
     this.push(` ${op} `);
-    print(node.right);
+    print.plain(node.right);
     this.push(")");
     print.block(node.body);
   };
 };
 
+/**
+ * Create ForInStatement and ForOfStatement printers.
+ */
+
 export var ForInStatement = buildForXStatement("in");
 export var ForOfStatement = buildForXStatement("of");
 
+/**
+ * Prints DoWhileStatement, prints body and test.
+ */
+
 export function DoWhileStatement(node, print) {
-  this.keyword("do");
-  print(node.body);
+  this.push("do ");
+  print.plain(node.body);
   this.space();
   this.keyword("while");
   this.push("(");
-  print(node.test);
+  print.plain(node.test);
   this.push(");");
 }
 
+/**
+ * Builds continue, return, or break statement printers.
+ * Prints label (or key).
+ */
+
 var buildLabelStatement = function (prefix, key) {
   return function (node, print) {
     this.push(prefix);
@@ -87,62 +121,86 @@ var buildLabelStatement = function (prefix, key) {
     var label = node[key || "label"];
     if (label) {
       this.push(" ");
-      print(label);
+      print.plain(label);
     }
 
     this.semicolon();
   };
 };
 
+/**
+ * Create ContinueStatement, ReturnStatement, and BreakStatement printers.
+ */
+
 export var ContinueStatement = buildLabelStatement("continue");
 export var ReturnStatement   = buildLabelStatement("return", "argument");
 export var BreakStatement    = buildLabelStatement("break");
 
+/**
+ * Prints LabeledStatement, prints label and body.
+ */
+
 export function LabeledStatement(node, print) {
-  print(node.label);
+  print.plain(node.label);
   this.push(": ");
-  print(node.body);
+  print.plain(node.body);
 }
 
+/**
+ * Prints TryStatement, prints block, handlers, and finalizer.
+ */
+
 export function TryStatement(node, print) {
   this.keyword("try");
-  print(node.block);
+  print.plain(node.block);
   this.space();
 
   // Esprima bug puts the catch clause in a `handlers` array.
   // see https://code.google.com/p/esprima/issues/detail?id=433
   // We run into this from regenerator generated ast.
   if (node.handlers) {
-    print(node.handlers[0]);
+    print.plain(node.handlers[0]);
   } else {
-    print(node.handler);
+    print.plain(node.handler);
   }
 
   if (node.finalizer) {
     this.space();
     this.push("finally ");
-    print(node.finalizer);
+    print.plain(node.finalizer);
   }
 }
 
+/**
+ * Prints CatchClause, prints param and body.
+ */
+
 export function CatchClause(node, print) {
   this.keyword("catch");
   this.push("(");
-  print(node.param);
+  print.plain(node.param);
   this.push(") ");
-  print(node.body);
+  print.plain(node.body);
 }
 
+/**
+ * Prints ThrowStatement, prints argument.
+ */
+
 export function ThrowStatement(node, print) {
   this.push("throw ");
-  print(node.argument);
+  print.plain(node.argument);
   this.semicolon();
 }
 
+/**
+ * Prints SwitchStatement, prints discriminant and cases.
+ */
+
 export function SwitchStatement(node, print) {
   this.keyword("switch");
   this.push("(");
-  print(node.discriminant);
+  print.plain(node.discriminant);
   this.push(")");
   this.space();
   this.push("{");
@@ -157,10 +215,14 @@ export function SwitchStatement(node, print) {
   this.push("}");
 }
 
+/**
+ * Prints SwitchCase, prints test and consequent.
+ */
+
 export function SwitchCase(node, print) {
   if (node.test) {
     this.push("case ");
-    print(node.test);
+    print.plain(node.test);
     this.push(":");
   } else {
     this.push("default:");
@@ -172,47 +234,72 @@ export function SwitchCase(node, print) {
   }
 }
 
+/**
+ * Prints DebuggerStatement.
+ */
+
 export function DebuggerStatement() {
   this.push("debugger;");
 }
 
+/**
+ * Prints VariableDeclaration, prints declarations, handles kind and format.
+ */
+
 export function VariableDeclaration(node, print, parent) {
   this.push(node.kind + " ");
 
   var hasInits = false;
   // don't add whitespace to loop heads
   if (!t.isFor(parent)) {
-    for (var i = 0; i < node.declarations.length; i++) {
-      if (node.declarations[i].init) {
+    for (var declar of (node.declarations: Array)) {
+      if (declar.init) {
         // has an init so let's split it up over multiple lines
         hasInits = true;
       }
     }
   }
 
-  var sep = ",";
-  if (!this.format.compact && hasInits) {
-    sep += `\n${repeating(" ", node.kind.length + 1)}`;
-  } else {
-    sep += " ";
+  //
+  // use a pretty separator when we aren't in compact mode, have initializers and don't have retainLines on
+  // this will format declarations like:
+  //
+  //   var foo = "bar", bar = "foo";
+  //
+  // into
+  //
+  //   var foo = "bar",
+  //       bar = "foo";
+  //
+
+  var sep;
+  if (!this.format.compact && !this.format.concise && hasInits && !this.format.retainLines) {
+    sep = `,\n${repeating(" ", node.kind.length + 1)}`;
   }
 
+  //
+
   print.list(node.declarations, { separator: sep });
 
   if (t.isFor(parent)) {
+    // don't give semicolons to these nodes since they'll be inserted in the parent generator
     if (parent.left === node || parent.init === node) return;
   }
 
   this.semicolon();
 }
 
+/**
+ * Prints VariableDeclarator, handles id, id.typeAnnotation, and init.
+ */
+
 export function VariableDeclarator(node, print) {
-  print(node.id);
-  print(node.id.typeAnnotation);
+  print.plain(node.id);
+  print.plain(node.id.typeAnnotation);
   if (node.init) {
     this.space();
     this.push("=");
     this.space();
-    print(node.init);
+    print.plain(node.init);
   }
 }

src/babel/generation/generators/template-literals.js

@@ -1,29 +1,39 @@
-import each from "lodash/collection/each";
+/**
+ * Prints TaggedTemplateExpression, prints tag and quasi.
+ */
 
 export function TaggedTemplateExpression(node, print) {
-  print(node.tag);
-  print(node.quasi);
+  print.plain(node.tag);
+  print.plain(node.quasi);
 }
 
+/**
+ * Prints TemplateElement, prints value.
+ */
+
 export function TemplateElement(node) {
   this._push(node.value.raw);
 }
 
+/**
+ * Prints TemplateLiteral, prints quasis, and expressions.
+ */
+
 export function TemplateLiteral(node, print) {
   this.push("`");
 
   var quasis = node.quasis;
   var len    = quasis.length;
 
-  each(quasis, (quasi, i) => {
-    print(quasi);
+  for (var i = 0; i < len; i++) {
+    print.plain(quasis[i]);
 
     if (i + 1 < len) {
       this.push("${ ");
-      print(node.expressions[i]);
+      print.plain(node.expressions[i]);
       this.push(" }");
     }
-  });
+  }
 
   this._push("`");
 }

src/babel/generation/generators/types.js

@@ -1,16 +1,36 @@
-import each from "lodash/collection/each";
+/* eslint quotes: 0 */
+
+import isInteger from "is-integer";
+import * as t from "../../types";
+
+/**
+ * Prints Identifier, prints name.
+ */
 
 export function Identifier(node) {
   this.push(node.name);
 }
 
+/**
+ * Prints RestElement, prints argument.
+ */
+
 export function RestElement(node, print) {
   this.push("...");
-  print(node.argument);
+  print.plain(node.argument);
 }
 
+/**
+ * Alias RestElement printer as SpreadElement,
+ * and RestElement printer as SpreadProperty.
+ */
+
 export { RestElement as SpreadElement, RestElement as SpreadProperty };
 
+/**
+ * Prints ObjectExpression, prints properties.
+ */
+
 export function ObjectExpression(node, print) {
   var props = node.properties;
 
@@ -27,34 +47,62 @@ export function ObjectExpression(node, print) {
   }
 }
 
+/**
+ * Alias ObjectExpression printer as ObjectPattern.
+ */
+
 export { ObjectExpression as ObjectPattern };
 
+/**
+ * Prints Property, prints decorators, key, and value, handles kind, computed, and shorthand.
+ */
+
 export function Property(node, print) {
+  print.list(node.decorators, { separator: "" });
+
   if (node.method || node.kind === "get" || node.kind === "set") {
     this._method(node, print);
   } else {
     if (node.computed) {
       this.push("[");
-      print(node.key);
+      print.plain(node.key);
       this.push("]");
     } else {
-      print(node.key);
-      if (node.shorthand) return;
+      // print `({ foo: foo = 5 } = {})` as `({ foo = 5 } = {});`
+      if (t.isAssignmentPattern(node.value) && t.isIdentifier(node.key) && node.key.name === node.value.left.name) {
+        print.plain(node.value);
+        return;
+      }
+
+      print.plain(node.key);
+
+      // shorthand!
+      if (node.shorthand &&
+        (t.isIdentifier(node.key) &&
+         t.isIdentifier(node.value) &&
+         node.key.name === node.value.name)) {
+        return;
+      }
     }
 
     this.push(":");
     this.space();
-    print(node.value);
+    print.plain(node.value);
   }
 }
 
+/**
+ * Prints ArrayExpression, prints elements.
+ */
+
 export function ArrayExpression(node, print) {
   var elems = node.elements;
   var len   = elems.length;
 
   this.push("[");
 
-  each(elems, (elem, i) => {
+  for (var i = 0; i < elems.length; i++) {
+    var elem = elems[i];
     if (!elem) {
       // If the array expression ends with a hole, that hole
       // will be ignored by the interpreter, but if it ends with
@@ -63,25 +111,52 @@ export function ArrayExpression(node, print) {
       // both (all) of the holes.
       this.push(",");
     } else {
-      if (i > 0) this.push(" ");
-      print(elem);
+      if (i > 0) this.space();
+      print.plain(elem);
       if (i < len - 1) this.push(",");
     }
-  });
+  }
 
   this.push("]");
 }
 
+/**
+ * Alias ArrayExpression printer as ArrayPattern.
+ */
+
 export { ArrayExpression as ArrayPattern };
 
-export function Literal(node) {
+/**
+ * RegExp for testing scientific notation in literals.
+ */
+
+const SCIENTIFIC_NOTATION = /e/i;
+
+/**
+ * Prints Literal, prints value, regex, raw, handles val type.
+ */
+
+export function Literal(node, print, parent) {
   var val  = node.value;
   var type = typeof val;
 
   if (type === "string") {
     this._stringLiteral(val);
   } else if (type === "number") {
-    this.push(val + "");
+    // check to see if this is the same number as the raw one in the original source as asm.js uses
+    // numbers in the form 5.0 for type hinting
+    var raw = node.raw;
+    if (val === +raw && raw[raw.length - 1] !== "." && !/^0[bo]/i.test(raw)) {
+      val = raw;
+    }
+
+    val = val + "";
+
+    if (isInteger(+val) && t.isMemberExpression(parent, { object: node }) && !SCIENTIFIC_NOTATION.test(val)) {
+      val += ".";
+    }
+
+    this.push(val);
   } else if (type === "boolean") {
     this.push(val ? "true" : "false");
   } else if (node.regex) {
@@ -91,6 +166,10 @@ export function Literal(node) {
   }
 }
 
+/**
+ * Prints string literals, handles format.
+ */
+
 export function _stringLiteral(val) {
   val = JSON.stringify(val);
 
@@ -100,9 +179,16 @@ export function _stringLiteral(val) {
   });
 
   if (this.format.quotes === "single") {
+    // remove double quotes
     val = val.slice(1, -1);
+
+    // unescape double quotes
     val = val.replace(/\\"/g, '"');
+
+    // escape single quotes
     val = val.replace(/'/g, "\\'");
+
+    // add single quotes
     val = `'${val}'`;
   }
 

src/babel/generation/index.js

@@ -1,5 +1,6 @@
 import detectIndent from "detect-indent";
 import Whitespace from "./whitespace";
+import NodePrinter from "./node/printer";
 import repeating from "repeating";
 import SourceMap from "./source-map";
 import Position from "./position";
@@ -10,9 +11,14 @@ import each from "lodash/collection/each";
 import n from "./node";
 import * as t from "../types";
 
+/**
+ * Babel's code generator, turns an ast into code, maintaining sourcemaps,
+ * user preferences, and valid output.
+ */
+
 class CodeGenerator {
   constructor(ast, opts, code) {
-    opts ||= {};
+    opts = opts || {};
 
     this.comments = ast.comments || [];
     this.tokens   = ast.tokens || [];
@@ -20,12 +26,19 @@ class CodeGenerator {
     this.opts     = opts;
     this.ast      = ast;
 
-    this.whitespace = new Whitespace(this.tokens, this.comments, this.format);
+    this.whitespace = new Whitespace(this.tokens);
     this.position   = new Position;
     this.map        = new SourceMap(this.position, opts, code);
     this.buffer     = new Buffer(this.position, this.format);
   }
 
+  /**
+   * Normalize generator options, setting defaults.
+   *
+   * - Detects code indentation.
+   * - If `opts.compact = "auto"` and the code is over 100KB, `compact` will be set to `true`.
+   */
+
   static normalizeOptions(code, opts, tokens) {
     var style = "  ";
     if (code) {
@@ -34,9 +47,10 @@ class CodeGenerator {
     }
 
     var format = {
+      retainLines: opts.retainLines,
       comments: opts.comments == null || opts.comments,
       compact: opts.compact,
-      quotes: CodeGenerator.findCommonStringDelimeter(code, tokens),
+      quotes: CodeGenerator.findCommonStringDelimiter(code, tokens),
       indent: {
         adjustMultilineComment: true,
         style: style,
@@ -48,14 +62,17 @@ class CodeGenerator {
       format.compact = code.length > 100000; // 100KB
 
       if (format.compact) {
-        console.error(messages.get("codeGeneratorDeopt", opts.filename, "100KB"));
+        console.error("[BABEL] " + messages.get("codeGeneratorDeopt", opts.filename, "100KB"));
       }
     }
 
     return format;
   }
 
-  static findCommonStringDelimeter(code, tokens) {
+  /**
+   * Determine if input code uses more single or double quotes.
+   */
+  static findCommonStringDelimiter(code, tokens) {
     var occurences = {
       single: 0,
       double: 0
@@ -66,7 +83,6 @@ class CodeGenerator {
     for (var i = 0; i < tokens.length; i++) {
       var token = tokens[i];
       if (token.type.label !== "string") continue;
-      if (checked >= 3) continue;
 
       var raw = code.slice(token.start, token.end);
       if (raw[0] === "'") {
@@ -76,8 +92,8 @@ class CodeGenerator {
       }
 
       checked++;
+      if (checked >= 3) break;
     }
-
     if (occurences.single > occurences.double) {
       return "single";
     } else {
@@ -85,6 +101,10 @@ class CodeGenerator {
     }
   }
 
+  /**
+   * All node generators.
+   */
+
   static generators = {
     templateLiterals: require("./generators/template-literals"),
     comprehensions:   require("./generators/comprehensions"),
@@ -99,16 +119,24 @@ class CodeGenerator {
     jsx:              require("./generators/jsx")
   };
 
+  /**
+   * Generate code and sourcemap from ast.
+   *
+   * Appends comments that weren't attached to any node to the end of the generated output.
+   */
+
   generate() {
     var ast = this.ast;
 
     this.print(ast);
 
-    var comments = [];
-    each(ast.comments, function (comment) {
-      if (!comment._displayed) comments.push(comment);
-    });
-    this._printComments(comments);
+    if (ast.comments) {
+      var comments = [];
+      for (var comment of (ast.comments: Array)) {
+        if (!comment._displayed) comments.push(comment);
+      }
+      this._printComments(comments);
+    }
 
     return {
       map:  this.map.get(),
@@ -116,36 +144,72 @@ class CodeGenerator {
     };
   }
 
+  /**
+   * Build NodePrinter.
+   */
+
   buildPrint(parent) {
-    var print = (node, opts) => {
-      return this.print(node, parent, opts);
-    };
-
-    print.sequence = (nodes, opts = {}) => {
-      opts.statement = true;
-      return this.printJoin(print, nodes, opts);
-    };
-
-    print.join = (nodes, opts) => {
-      return this.printJoin(print, nodes, opts);
-    };
-
-    print.list = function (items, opts = {}) {
-      if (opts.separator == null) opts.separator = ", ";
-      print.join(items, opts);
-    };
-
-    print.block = (node) => {
-      return this.printBlock(print, node);
-    };
-
-    print.indentOnComments = (node) => {
-      return this.printAndIndentOnComments(print, node);
-    };
-
-    return print;
+    return new NodePrinter(this, parent);
   }
 
+  /**
+   * [Please add a description.]
+   */
+
+  catchUp(node, parent, leftParenPrinted) {
+    // catch up to this nodes newline if we're behind
+    if (node.loc && this.format.retainLines && this.buffer.buf) {
+      var needsParens = false;
+      if (!leftParenPrinted && parent && this.position.line < node.loc.start.line && t.isTerminatorless(parent)) {
+        needsParens = true;
+        this._push("(");
+      }
+      while (this.position.line < node.loc.start.line) {
+        this._push("\n");
+      }
+      return needsParens;
+    }
+    return false;
+  }
+
+  /**
+   * [Please add a description.]
+   */
+
+  _printNewline(leading, node, parent, opts) {
+    if (!opts.statement && !n.isUserWhitespacable(node, parent)) {
+      return;
+    }
+
+    var lines = 0;
+
+    if (node.start != null && !node._ignoreUserWhitespace) {
+      // user node
+      if (leading) {
+        lines = this.whitespace.getNewlinesBefore(node);
+      } else {
+        lines = this.whitespace.getNewlinesAfter(node);
+      }
+    } else {
+      // generated node
+      if (!leading) lines++; // always include at least a single line after
+      if (opts.addNewlines) lines += opts.addNewlines(leading, node) || 0;
+
+      var needs = n.needsWhitespaceAfter;
+      if (leading) needs = n.needsWhitespaceBefore;
+      if (needs(node, parent)) lines++;
+
+      // generated nodes can't add starting file whitespace
+      if (!this.buffer.buf) lines = 0;
+    }
+
+    this.newline(lines);
+  }
+
+  /**
+   * [Please add a description.]
+   */
+
   print(node, parent, opts = {}) {
     if (!node) return;
 
@@ -158,36 +222,6 @@ class CodeGenerator {
       this.format.concise = true;
     }
 
-    var newline = (leading) => {
-      if (!opts.statement && !n.isUserWhitespacable(node, parent)) {
-        return;
-      }
-
-      var lines = 0;
-
-      if (node.start != null && !node._ignoreUserWhitespace) {
-        // user node
-        if (leading) {
-          lines = this.whitespace.getNewlinesBefore(node);
-        } else {
-          lines = this.whitespace.getNewlinesAfter(node);
-        }
-      } else {
-        // generated node
-        if (!leading) lines++; // always include at least a single line after
-        if (opts.addNewlines) lines += opts.addNewlines(leading, node) || 0;
-
-        var needs = n.needsWhitespaceAfter;
-        if (leading) needs = n.needsWhitespaceBefore;
-        if (needs(node, parent)) lines++;
-
-        // generated nodes can't add starting file whitespace
-        if (!this.buffer.buf) lines = 0;
-      }
-
-      this.newline(lines);
-    };
-
     if (this[node.type]) {
       var needsNoLineTermParens = n.needsParensNoLineTerminator(node, parent);
       var needsParens           = needsNoLineTermParens || n.needsParens(node, parent);
@@ -197,7 +231,9 @@ class CodeGenerator {
 
       this.printLeadingComments(node, parent);
 
-      newline(true);
+      var needsParensFromCatchup = this.catchUp(node, parent, needsParens);
+
+      this._printNewline(true, node, parent, opts);
 
       if (opts.before) opts.before();
       this.map.mark(node, "start");
@@ -208,21 +244,25 @@ class CodeGenerator {
         this.newline();
         this.dedent();
       }
-      if (needsParens) this.push(")");
+      if (needsParens || needsParensFromCatchup) this.push(")");
 
       this.map.mark(node, "end");
       if (opts.after) opts.after();
 
-      newline(false);
+      this.format.concise = oldConcise;
+
+      this._printNewline(false, node, parent, opts);
 
       this.printTrailingComments(node, parent);
     } else {
       throw new ReferenceError(`unknown node of type ${JSON.stringify(node.type)} with constructor ${JSON.stringify(node && node.constructor.name)}`);
     }
-
-    this.format.concise = oldConcise;
   }
 
+  /**
+   * [Please add a description.]
+   */
+
   printJoin(print, nodes, opts = {}) {
     if (!nodes || !nodes.length) return;
 
@@ -230,44 +270,59 @@ class CodeGenerator {
 
     if (opts.indent) this.indent();
 
-    each(nodes, (node, i) => {
-      print(node, {
-        statement: opts.statement,
-        addNewlines: opts.addNewlines,
-        after: () => {
-          if (opts.iterator) {
-            opts.iterator(node, i);
-          }
-
-          if (opts.separator && i < len - 1) {
-            this.push(opts.separator);
-          }
+    var printOpts = {
+      statement: opts.statement,
+      addNewlines: opts.addNewlines,
+      after: () => {
+        if (opts.iterator) {
+          opts.iterator(node, i);
         }
-      });
-    });
+
+        if (opts.separator && i < len - 1) {
+          this.push(opts.separator);
+        }
+      }
+    };
+
+    for (var i = 0; i < nodes.length; i++) {
+      var node = nodes[i];
+      print.plain(node, printOpts);
+    }
 
     if (opts.indent) this.dedent();
   }
 
+  /**
+   * [Please add a description.]
+   */
+
   printAndIndentOnComments(print, node) {
     var indent = !!node.leadingComments;
     if (indent) this.indent();
-    print(node);
+    print.plain(node);
     if (indent) this.dedent();
   }
 
+  /**
+   * [Please add a description.]
+   */
+
   printBlock(print, node) {
     if (t.isEmptyStatement(node)) {
       this.semicolon();
     } else {
       this.push(" ");
-      print(node);
+      print.plain(node);
     }
   }
 
+  /**
+   * [Please add a description.]
+   */
+
   generateComment(comment) {
     var val = comment.value;
-    if (comment.type === "Line") {
+    if (comment.type === "CommentLine") {
       val = `//${val}`;
     } else {
       val = `/*${val}*/`;
@@ -275,14 +330,26 @@ class CodeGenerator {
     return val;
   }
 
+  /**
+   * [Please add a description.]
+   */
+
   printTrailingComments(node, parent) {
     this._printComments(this.getComments("trailingComments", node, parent));
   }
 
+  /**
+   * [Please add a description.]
+   */
+
   printLeadingComments(node, parent) {
     this._printComments(this.getComments("leadingComments", node, parent));
   }
 
+  /**
+   * [Please add a description.]
+   */
+
   getComments(key, node, parent) {
     if (t.isExpressionStatement(parent)) {
       return [];
@@ -295,39 +362,50 @@ class CodeGenerator {
       nodes.push(node.argument);
     }
 
-    each(nodes, (node) => {
+    for (let node of (nodes: Array)) {
       comments = comments.concat(this._getComments(key, node));
-    });
+    }
 
     return comments;
   }
 
+  /**
+   * [Please add a description.]
+   */
+
   _getComments(key, node) {
     return (node && node[key]) || [];
   }
 
+  /**
+   * [Please add a description.]
+   */
+
   _printComments(comments) {
     if (this.format.compact) return;
-
     if (!this.format.comments) return;
     if (!comments || !comments.length) return;
 
-    each(comments, (comment) => {
+    for (var comment of (comments: Array)) {
       var skip = false;
 
-      // find the original comment in the ast and set it as displayed
-      each(this.ast.comments, function (origComment) {
-        if (origComment.start === comment.start) {
-          // comment has already been output
-          if (origComment._displayed) skip = true;
+      if (this.ast.comments) {
+        // find the original comment in the ast and set it as displayed
+        for (var origComment of (this.ast.comments: Array)) {
+          if (origComment.start === comment.start) {
+            // comment has already been output
+            if (origComment._displayed) skip = true;
 
-          origComment._displayed = true;
-          return false;
+            origComment._displayed = true;
+            break;
+          }
         }
-      });
+      }
 
       if (skip) return;
 
+      this.catchUp(comment);
+
       // whitespace before
       this.newline(this.whitespace.getNewlinesBefore(comment));
 
@@ -340,9 +418,8 @@ class CodeGenerator {
       }
 
       //
-
-      if (comment.type === "Block" && this.format.indent.adjustMultilineComment) {
-        var offset = comment.loc.start.column;
+      if (comment.type === "CommentBlock" && this.format.indent.adjustMultilineComment) {
+        var offset = comment.loc && comment.loc.start.column;
         if (offset) {
           var newlineRegex = new RegExp("\\n\\s{1," + offset + "}", "g");
           val = val.replace(newlineRegex, "\n");
@@ -356,26 +433,43 @@ class CodeGenerator {
         val = this.getIndent() + val;
       }
 
-      //
+      // force a newline for line comments when retainLines is set in case the next printed node
+      // doesn't catch up
+      if (this.format.retainLines && comment.type === "CommentLine") {
+        val += "\n";
+      }
 
+      //
       this._push(val);
 
       // whitespace after
       this.newline(this.whitespace.getNewlinesAfter(comment));
-    });
+    }
   }
 }
 
+/**
+ * [Please add a description.]
+ */
+
 each(Buffer.prototype, function (fn, key) {
   CodeGenerator.prototype[key] = function () {
     return fn.apply(this.buffer, arguments);
   };
 });
 
+/**
+ * [Please add a description.]
+ */
+
 each(CodeGenerator.generators, function (generator) {
   extend(CodeGenerator.prototype, generator);
 });
 
+/**
+ * [Please add a description.]
+ */
+
 module.exports = function (ast, opts, code) {
   var gen = new CodeGenerator(ast, opts, code);
   return gen.generate();

src/babel/generation/node/index.js

@@ -4,6 +4,16 @@ import each from "lodash/collection/each";
 import some from "lodash/collection/some";
 import * as t from "../../types";
 
+/**
+ * Test if node matches a set of type-matcher pairs.
+ * @example
+ * find({
+ *   VariableDeclaration(node, parent) {
+ *     return true;
+ *   }
+ * }, node, parent);
+ */
+
 var find = function (obj, node, parent) {
   if (!obj) return;
   var result;
@@ -22,16 +32,28 @@ var find = function (obj, node, parent) {
   return result;
 };
 
+/**
+ * Whitespace and Parenthesis related methods for nodes.
+ */
+
 export default class Node {
   constructor(node, parent) {
     this.parent = parent;
     this.node   = node;
   }
 
+  /**
+   * Test if `node` can have whitespace set by the user.
+   */
+
   static isUserWhitespacable(node) {
     return t.isUserWhitespacable(node);
   }
 
+  /**
+   * Test if a `node` requires whitespace.
+   */
+
   static needsWhitespace(node, parent, type) {
     if (!node) return 0;
 
@@ -54,14 +76,26 @@ export default class Node {
     return (linesInfo && linesInfo[type]) || 0;
   }
 
+  /**
+   * Test if a `node` requires whitespace before it.
+   */
+
   static needsWhitespaceBefore(node, parent) {
     return Node.needsWhitespace(node, parent, "before");
   }
 
+  /**
+   * Test if a `note` requires whitespace after it.
+   */
+
   static needsWhitespaceAfter(node, parent) {
     return Node.needsWhitespace(node, parent, "after");
   }
 
+  /**
+   * Test if a `node` needs parentheses around it.
+   */
+
   static needsParens(node, parent) {
     if (!parent) return false;
 
@@ -77,6 +111,10 @@ export default class Node {
     return find(parens, node, parent);
   }
 
+  /**
+   * [Please add a description.]
+   */
+
   static needsParensNoLineTerminator(node, parent) {
     if (!parent) return false;
 
@@ -85,19 +123,14 @@ export default class Node {
       return false;
     }
 
-    if (t.isYieldExpression(parent) || t.isAwaitExpression(parent)) {
-      return true;
-    }
-
-    if (t.isContinueStatement(parent) || t.isBreakStatement(parent) ||
-        t.isReturnStatement(parent) || t.isThrowStatement(parent)) {
-      return true;
-    }
-
-    return false;
+    return t.isTerminatorless(parent);
   }
 }
 
+/**
+ * Add all static methods from `Node` to `Node.prototype`.
+ */
+
 each(Node, function (fn, key) {
   Node.prototype[key] = function () {
     // Avoid leaking arguments to prevent deoptimization

src/babel/generation/node/parentheses.js

@@ -1,6 +1,12 @@
 import each from "lodash/collection/each";
 import * as t from "../../types";
 
+/**
+ * Create a mapping of operators to precendence.
+ *
+ * @example
+ * { "==": 6, "+": 9 }
+ */
 const PRECEDENCE = {};
 
 each([
@@ -21,12 +27,24 @@ each([
   });
 });
 
+/**
+ * Test if NullableTypeAnnotation needs parentheses.
+ */
+
 export function NullableTypeAnnotation(node, parent) {
   return t.isArrayTypeAnnotation(parent);
 }
 
+/**
+ * Alias NullableTypeAnnotation test as FunctionTypeAnnotation.
+ */
+
 export { NullableTypeAnnotation as FunctionTypeAnnotation };
 
+/**
+ * Test if UpdateExpression needs parentheses.
+ */
+
 export function UpdateExpression(node, parent) {
   if (t.isMemberExpression(parent) && parent.object === node) {
     // (foo++).test()
@@ -34,6 +52,10 @@ export function UpdateExpression(node, parent) {
   }
 }
 
+/**
+ * Test if ObjectExpression needs parentheses.
+ */
+
 export function ObjectExpression(node, parent) {
   if (t.isExpressionStatement(parent)) {
     // ({ foo: "bar" });
@@ -48,6 +70,10 @@ export function ObjectExpression(node, parent) {
   return false;
 }
 
+/**
+ * Test if Binary needs parentheses.
+ */
+
 export function Binary(node, parent) {
   if ((t.isCallExpression(parent) || t.isNewExpression(parent)) && parent.callee === node) {
     return true;
@@ -78,6 +104,10 @@ export function Binary(node, parent) {
   }
 }
 
+/**
+ * Test if BinaryExpression needs parentheses.
+ */
+
 export function BinaryExpression(node, parent) {
   if (node.operator === "in") {
     // var i = (1 in []);
@@ -92,6 +122,10 @@ export function BinaryExpression(node, parent) {
   }
 }
 
+/**
+ * Test if SequenceExpression needs parentheses.
+ */
+
 export function SequenceExpression(node, parent) {
   if (t.isForStatement(parent)) {
     // Although parentheses wouldn't hurt around sequence
@@ -110,6 +144,10 @@ export function SequenceExpression(node, parent) {
   return true;
 }
 
+/**
+ * Test if YieldExpression needs parentheses.
+ */
+
 export function YieldExpression(node, parent) {
   return t.isBinary(parent) ||
          t.isUnaryLike(parent) ||
@@ -120,14 +158,26 @@ export function YieldExpression(node, parent) {
          t.isYieldExpression(parent);
 }
 
+/**
+ * Test if ClassExpression needs parentheses.
+ */
+
 export function ClassExpression(node, parent) {
   return t.isExpressionStatement(parent);
 }
 
+/**
+ * Test if UnaryLike needs parentheses.
+ */
+
 export function UnaryLike(node, parent) {
   return t.isMemberExpression(parent) && parent.object === node;
 }
 
+/**
+ * Test if FunctionExpression needs parentheses.
+ */
+
 export function FunctionExpression(node, parent) {
   // function () {};
   if (t.isExpressionStatement(parent)) {
@@ -145,6 +195,10 @@ export function FunctionExpression(node, parent) {
   }
 }
 
+/**
+ * Test if ConditionalExpression needs parentheses.
+ */
+
 export function ConditionalExpression(node, parent) {
   if (t.isUnaryLike(parent)) {
     return true;
@@ -171,4 +225,14 @@ export function ConditionalExpression(node, parent) {
   return false;
 }
 
-export { ConditionalExpression as AssignmentExpression };
+/**
+ * Test if AssignmentExpression needs parentheses.
+ */
+
+export function AssignmentExpression(node) {
+  if (t.isObjectPattern(node.left)) {
+    return true;
+  } else {
+    return ConditionalExpression(...arguments);
+  }
+}

src/babel/generation/node/printer.js

@@ -0,0 +1,64 @@
+/**
+ * Printer for nodes, needs a `generator` and a `parent`.
+ */
+
+export default class NodePrinter {
+  constructor(generator, parent) {
+    this.generator = generator;
+    this.parent = parent;
+  }
+
+  /**
+   * Print a plain node.
+   */
+
+  plain(node, opts) {
+    return this.generator.print(node, this.parent, opts);
+  }
+
+  /**
+   * Print a sequence of nodes as statements.
+   */
+
+  sequence(nodes, opts = {}) {
+    opts.statement = true;
+    return this.generator.printJoin(this, nodes, opts);
+  }
+
+  /**
+   * Print a sequence of nodes as expressions.
+   */
+
+  join(nodes, opts) {
+    return this.generator.printJoin(this, nodes, opts);
+  }
+
+  /**
+   * Print a list of nodes, with a customizable separator (defaults to ",").
+   */
+
+  list(items, opts = {}) {
+    if (opts.separator == null) {
+      opts.separator = ",";
+      if (!this.generator.format.compact) opts.separator += " ";
+    }
+
+    return this.join(items, opts);
+  }
+
+  /**
+   * Print a block-like node.
+   */
+
+  block(node) {
+    return this.generator.printBlock(this, node);
+  }
+
+  /**
+   * Print node and indent comments.
+   */
+
+  indentOnComments(node) {
+    return this.generator.printAndIndentOnComments(this, node);
+  }
+}

src/babel/generation/node/whitespace.js

@@ -3,6 +3,14 @@ import each from "lodash/collection/each";
 import map from "lodash/collection/map";
 import * as t from "../../types";
 
+/**
+ * Crawl a node to test if it contains a CallExpression, a Function, or a Helper.
+ *
+ * @example
+ * crawl(node)
+ * // { hasCall: false, hasFunction: true, hasHelper: false }
+ */
+
 function crawl(node, state = {}) {
   if (t.isMemberExpression(node)) {
     crawl(node.object, state);
@@ -16,12 +24,16 @@ function crawl(node, state = {}) {
   } else if (t.isFunction(node)) {
     state.hasFunction = true;
   } else if (t.isIdentifier(node)) {
-    state.hasHelper ||= isHelper(node.callee);
+    state.hasHelper = state.hasHelper || isHelper(node.callee);
   }
 
   return state;
 }
 
+/**
+ * Test if a node is or has a helper.
+ */
+
 function isHelper(node) {
   if (t.isMemberExpression(node)) {
     return isHelper(node.object) || isHelper(node.property);
@@ -36,12 +48,25 @@ function isHelper(node) {
   }
 }
 
+/**
+ * [Please add a description.]
+ */
+
 function isType(node) {
   return t.isLiteral(node) || t.isObjectExpression(node) || t.isArrayExpression(node) ||
          t.isIdentifier(node) || t.isMemberExpression(node);
 }
 
+/**
+ * Tests for node types that need whitespace.
+ */
+
 exports.nodes = {
+
+  /**
+   * Test if AssignmentExpression needs whitespace.
+   */
+
   AssignmentExpression(node) {
     var state = crawl(node.right);
     if ((state.hasCall && state.hasHelper) || state.hasFunction) {
@@ -52,12 +77,20 @@ exports.nodes = {
     }
   },
 
+  /**
+   * Test if SwitchCase needs whitespace.
+   */
+
   SwitchCase(node, parent) {
     return {
       before: node.consequent.length || parent.cases[0] === node
     };
   },
 
+  /**
+   * Test if LogicalExpression needs whitespace.
+   */
+
   LogicalExpression(node) {
     if (t.isFunction(node.left) || t.isFunction(node.right)) {
       return {
@@ -66,6 +99,10 @@ exports.nodes = {
     }
   },
 
+  /**
+   * Test if Literal needs whitespace.
+   */
+
   Literal(node) {
     if (node.value === "use strict") {
       return {
@@ -74,6 +111,10 @@ exports.nodes = {
     }
   },
 
+  /**
+   * Test if CallExpression needs whitespace.
+   */
+
   CallExpression(node) {
     if (t.isFunction(node.callee) || isHelper(node)) {
       return {
@@ -83,6 +124,10 @@ exports.nodes = {
     }
   },
 
+  /**
+   * Test if VariableDeclaration needs whitespace.
+   */
+
   VariableDeclaration(node) {
     for (var i = 0; i < node.declarations.length; i++) {
       var declar = node.declarations[i];
@@ -102,6 +147,10 @@ exports.nodes = {
     }
   },
 
+  /**
+   * Test if IfStatement needs whitespace.
+   */
+
   IfStatement(node) {
     if (t.isBlockStatement(node.consequent)) {
       return {
@@ -112,6 +161,10 @@ exports.nodes = {
   }
 };
 
+/**
+ * Test if Property or SpreadProperty needs whitespace.
+ */
+
 exports.nodes.Property =
 exports.nodes.SpreadProperty = function (node, parent) {
   if (parent.properties[0] === node) {
@@ -121,20 +174,41 @@ exports.nodes.SpreadProperty = function (node, parent) {
   }
 };
 
+/**
+ * Returns lists from node types that need whitespace.
+ */
+
 exports.list = {
+
+  /**
+   * Return VariableDeclaration declarations init properties.
+   */
+
   VariableDeclaration(node) {
     return map(node.declarations, "init");
   },
 
+  /**
+   * Return VariableDeclaration elements.
+   */
+
   ArrayExpression(node) {
     return node.elements;
   },
 
+  /**
+   * Return VariableDeclaration properties.
+   */
+
   ObjectExpression(node) {
     return node.properties;
   }
 };
 
+/**
+ * Add whitespace tests for nodes and their aliases.
+ */
+
 each({
   Function: true,
   Class: true,

src/babel/generation/position.js

@@ -1,9 +1,17 @@
+/**
+ * Track current position in code generation.
+ */
+
 export default class Position {
   constructor() {
     this.line = 1;
     this.column = 0;
   }
 
+  /**
+   * Push a string to the current position, mantaining the current line and column.
+   */
+
   push(str) {
     for (var i = 0; i < str.length; i++) {
       if (str[i] === "\n") {
@@ -15,6 +23,10 @@ export default class Position {
     }
   }
 
+  /**
+   * Unshift a string from the current position, mantaining the current line and column.
+   */
+
   unshift(str) {
     for (var i = 0; i < str.length; i++) {
       if (str[i] === "\n") {

src/babel/generation/source-map.js

@@ -1,6 +1,10 @@
 import sourceMap from "source-map";
 import * as t from "../types";
 
+/**
+ * Build a sourcemap.
+ */
+
 export default class SourceMap {
   constructor(position, opts, code) {
     this.position = position;
@@ -8,7 +12,7 @@ export default class SourceMap {
 
     if (opts.sourceMaps) {
       this.map = new sourceMap.SourceMapGenerator({
-        file: opts.sourceMapName,
+        file: opts.sourceMapTarget,
         sourceRoot: opts.sourceRoot
       });
 
@@ -18,6 +22,10 @@ export default class SourceMap {
     }
   }
 
+  /**
+   * Get the sourcemap.
+   */
+
   get() {
     var map = this.map;
     if (map) {
@@ -27,6 +35,10 @@ export default class SourceMap {
     }
   }
 
+  /**
+   * Mark a node's generated position, and add it to the sourcemap.
+   */
+
   mark(node, type) {
     var loc = node.loc;
     if (!loc) return; // no location info

src/babel/generation/whitespace.js

@@ -1,5 +1,3 @@
-import sortBy from "lodash/collection/sortBy";
-
 /**
  * Returns `i`th number from `base`, continuing from 0 when `max` is reached.
  * Useful for shifting `for` loop by a fixed number but going over all items.
@@ -20,9 +18,13 @@ function getLookupIndex(i, base, max) {
   return i;
 }
 
+/**
+ * Get whitespace around tokens.
+ */
+
 export default class Whitespace {
-  constructor(tokens, comments) {
-    this.tokens = sortBy(tokens.concat(comments), "start");
+  constructor(tokens) {
+    this.tokens = tokens;
     this.used   = {};
 
     // Profiling this code shows that while generator passes over it, indexes
@@ -36,16 +38,19 @@ export default class Whitespace {
     this._lastFoundIndex = 0;
   }
 
+  /**
+   * Count all the newlines before a node.
+   */
+
   getNewlinesBefore(node) {
     var startToken;
     var endToken;
     var tokens = this.tokens;
-    var token;
 
     for (var j = 0; j < tokens.length; j++) {
       // optimize for forward traversal by shifting for loop index
       var i = getLookupIndex(j, this._lastFoundIndex, this.tokens.length);
-      token = tokens[i];
+      var token = tokens[i];
 
       // this is the token this node starts with
       if (node.start === token.start) {
@@ -60,21 +65,25 @@ export default class Whitespace {
     return this.getNewlinesBetween(startToken, endToken);
   }
 
+  /**
+   * Count all the newlines after a node.
+   */
+
   getNewlinesAfter(node) {
     var startToken;
     var endToken;
     var tokens = this.tokens;
-    var token;
 
     for (var j = 0; j < tokens.length; j++) {
       // optimize for forward traversal by shifting for loop index
       var i = getLookupIndex(j, this._lastFoundIndex, this.tokens.length);
-      token = tokens[i];
+      var token = tokens[i];
 
       // this is the token this node ends with
       if (node.end === token.end) {
         startToken = token;
         endToken = tokens[i + 1];
+        if (endToken.type.label === ",") endToken = tokens[i + 2];
 
         this._lastFoundIndex = i;
         break;
@@ -85,7 +94,7 @@ export default class Whitespace {
       return 1;
     } else {
       var lines = this.getNewlinesBetween(startToken, endToken);
-      if (node.type === "Line" && !lines) {
+      if (node.type === "CommentLine" && !lines) {
         // line comment
         return 1;
       } else {
@@ -94,6 +103,10 @@ export default class Whitespace {
     }
   }
 
+  /**
+   * Count all the newlines between two tokens.
+   */
+
   getNewlinesBetween(startToken, endToken) {
     if (!endToken || !endToken.loc) return 0;
 

src/babel/helpers/README.md

@@ -0,0 +1,4 @@
+## Helpers
+
+Utilities for Babel, which is just another way to say "helpers", but I wrote it
+anyways, so– deal with it.

src/babel/helpers/code-frame.js

@@ -4,6 +4,10 @@ import jsTokens from "js-tokens";
 import esutils from "esutils";
 import chalk from "chalk";
 
+/**
+ * Chalk styles for token types.
+ */
+
 var defs = {
   string:     chalk.red,
   punctuator: chalk.bold,
@@ -17,8 +21,16 @@ var defs = {
   invalid:    chalk.inverse
 };
 
+/**
+ * RegExp to test for newlines in terminal.
+ */
+
 const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
 
+/**
+ * Get the type of token, specifying punctuator type.
+ */
+
 function getTokenType(match) {
   var token = jsTokens.matchToToken(match);
   if (token.type === "name" && esutils.keyword.isReservedWordES6(token.value)) {
@@ -42,6 +54,10 @@ function getTokenType(match) {
   return token.type;
 }
 
+/**
+ * Highlight `text`.
+ */
+
 function highlight(text) {
   return text.replace(jsTokens, function (...args) {
     var type = getTokenType(args);
@@ -54,6 +70,10 @@ function highlight(text) {
   });
 }
 
+/**
+ * Create a code frame, adding line numbers, code highlighting, and pointing to a given position.
+ */
+
 export default function (lines: number, lineNumber: number, colNumber: number, opts = {}): string {
   colNumber = Math.max(colNumber, 0);
 
@@ -79,10 +99,12 @@ export default function (lines: number, lineNumber: number, colNumber: number, o
       if (params.number !== lineNumber) {
         return;
       }
+
       if (colNumber) {
         params.line += `\n${params.before}${repeating(" ", params.width)}${params.after}${repeating(" ", colNumber - 1)}^`;
       }
+
       params.before = params.before.replace(/^./, ">");
     }
   }).join("\n");
-};
+}

src/babel/helpers/merge.js

@@ -0,0 +1,21 @@
+import merge from "lodash/object/merge";
+
+/**
+ * Merge options.
+ */
+
+export default function (dest, src) {
+  if (!dest || !src) return;
+
+  return merge(dest, src, function (a, b) {
+    if (b && Array.isArray(a)) {
+      var c = a.slice(0);
+      for (var v of b) {
+        if (a.indexOf(v) < 0) {
+          c.push(v);
+        }
+      }
+      return c;
+    }
+  });
+}

src/babel/helpers/normalize-ast.js

@@ -1,9 +1,15 @@
 import * as t from "../types";
 
+/**
+ * Normalize an AST.
+ *
+ * - Wrap `Program` node with a `File` node.
+ */
+
 export default function (ast, comments, tokens) {
   if (ast && ast.type === "Program") {
     return t.file(ast, comments || [], tokens || []);
   } else {
     throw new Error("Not a valid ast?");
   }
-};
+}

src/babel/helpers/object.js

@@ -1,3 +1,7 @@
+/**
+ * Create an object with a `null` prototype.
+ */
+
 export default function () {
   return Object.create(null);
-};
+}

src/babel/helpers/parse.js

@@ -1,65 +1,62 @@
 import normalizeAst from "./normalize-ast";
 import estraverse from "estraverse";
-import codeFrame from "./code-frame";
 import * as acorn from "../../acorn";
 
-export default function (opts, code, callback) {
-  try {
-    var comments = [];
-    var tokens   = [];
+/**
+ * Parse `code` with normalized options, collecting tokens and comments.
+ */
 
-    var parseOpts = {
-      allowImportExportEverywhere: opts.looseModules,
-      allowReturnOutsideFunction:  opts.looseModules,
-      ecmaVersion:                 6,
-      strictMode:                  opts.strictMode,
-      sourceType:                  opts.sourceType,
-      onComment:                   comments,
-      locations:                   true,
-      features:                    opts.features || {},
-      plugins:                     opts.plugins || {},
-      onToken:                     tokens,
-      ranges:                      true
+export default function (code, opts = {}) {
+  var commentsAndTokens = [];
+  var comments          = [];
+  var tokens            = [];
+
+  var parseOpts = {
+    allowImportExportEverywhere: opts.looseModules,
+    allowReturnOutsideFunction:  opts.looseModules,
+    allowHashBang:               true,
+    ecmaVersion:                 6,
+    strictMode:                  opts.strictMode,
+    sourceType:                  opts.sourceType,
+    locations:                   true,
+    features:                    opts.features || {},
+    plugins:                     opts.plugins || {},
+    onToken:                     tokens,
+    ranges:                      true
+  };
+
+  /**
+   * Collect all tokens.
+   */
+  parseOpts.onToken = function (token) {
+    tokens.push(token);
+    commentsAndTokens.push(token);
+  };
+
+  /**
+   * Collection all comments.
+   */
+  parseOpts.onComment = function (block, text, start, end, startLoc, endLoc) {
+    var comment = {
+      type: block ? "CommentBlock" : "CommentLine",
+      value: text,
+      start: start,
+      end: end,
+      loc: new acorn.SourceLocation(this, startLoc, endLoc),
+      range: [start, end]
     };
 
-    if (opts.nonStandard) {
-      parseOpts.plugins.jsx = true;
-      parseOpts.plugins.flow = true;
-    }
+    commentsAndTokens.push(comment);
+    comments.push(comment);
+  };
 
-    var ast = acorn.parse(code, parseOpts);
-
-    estraverse.attachComments(ast, comments, tokens);
-
-    ast = normalizeAst(ast, comments, tokens);
-
-    if (callback) {
-      return callback(ast);
-    } else {
-      return ast;
-    }
-  } catch (err) {
-    if (!err._babel) {
-      err._babel = true;
-
-      var message = err.message = `${opts.filename}: ${err.message}`;
-
-      var loc = err.loc;
-      if (loc) {
-        err.codeFrame = codeFrame(code, loc.line, loc.column + 1, opts);
-        message += "\n" + err.codeFrame;
-      }
-
-      if (err.stack) {
-        var newStack = err.stack.replace(err.message, message);
-        try {
-          err.stack = newStack;
-        } catch (e) {
-          // `err.stack` may be a readonly property in some environments
-        }
-      }
-    }
-
-    throw err;
+  if (opts.nonStandard) {
+    parseOpts.plugins.jsx = true;
+    parseOpts.plugins.flow = true;
   }
-};
+
+  var ast = acorn.parse(code, parseOpts);
+  estraverse.attachComments(ast, comments, tokens);
+  ast = normalizeAst(ast, comments, commentsAndTokens);
+  return ast;
+}

src/babel/messages.js

@@ -1,42 +1,82 @@
 import * as util from  "util";
 
+/**
+ * Mapping of messages to be used in Babel.
+ * Messages can include $0-style placeholders.
+ */
+
 export const MESSAGES = {
-  tailCallReassignmentDeopt: "Function reference has been reassigned so it's probably be dereferenced so we can't optimise this with confidence",
+  tailCallReassignmentDeopt: "Function reference has been reassigned, so it will probably be dereferenced, therefore we can't optimise this with confidence",
   JSXNamespacedTags: "Namespace tags are not supported. ReactJSX is not XML.",
   classesIllegalBareSuper: "Illegal use of bare super",
   classesIllegalSuperCall: "Direct super call is illegal in non-constructor, use super.$1() instead",
-  classesIllegalConstructorKind: "Illegal kind for constructor method",
   scopeDuplicateDeclaration: "Duplicate declaration $1",
-  undeclaredVariable: "Reference to undeclared variable $1",
-  undeclaredVariableSuggestion: "Reference to undeclared variable $1 - did you mean $2?",
-  settersInvalidParamLength: "Setters must have exactly one parameter",
   settersNoRest: "Setters aren't allowed to have a rest",
   noAssignmentsInForHead: "No assignments allowed in for-in/of head",
-  expectedMemberExpressionOrIdentifier: "Expected type MemeberExpression or Identifier",
+  expectedMemberExpressionOrIdentifier: "Expected type MemberExpression or Identifier",
   invalidParentForThisNode: "We don't know how to handle this node within the current parent - please open an issue",
   readOnly: "$1 is read-only",
-  modulesIllegalExportName: "Illegal export $1",
   unknownForHead: "Unknown node type $1 in ForStatement",
   didYouMean: "Did you mean $1?",
-  evalInStrictMode: "eval is not allowed in strict mode",
   codeGeneratorDeopt: "Note: The code generator has deoptimised the styling of $1 as it exceeds the max of $2.",
   missingTemplatesDirectory: "no templates directory - this is most likely the result of a broken `npm publish`. Please report to https://github.com/babel/babel/issues",
   unsupportedOutputType: "Unsupported output type $1",
-  illegalMethodName: "Illegal method name $1"
+  illegalMethodName: "Illegal method name $1",
+  lostTrackNodePath: "We lost track of this node's position, likely because the AST was directly manipulated",
+
+  modulesIllegalExportName: "Illegal export $1",
+  modulesDuplicateDeclarations: "Duplicate module declarations with the same source but in different scopes",
+
+  undeclaredVariable: "Reference to undeclared variable $1",
+  undeclaredVariableType: "Referencing a type alias outside of a type annotation",
+  undeclaredVariableSuggestion: "Reference to undeclared variable $1 - did you mean $2?",
+
+  traverseNeedsParent: "You must pass a scope and parentPath unless traversing a Program/File got a $1 node",
+  traverseVerifyRootFunction: "You passed `traverse()` a function when it expected a visitor object, are you sure you didn't mean `{ enter: Function }`?",
+  traverseVerifyVisitorProperty: "You passed `traverse()` a visitor object with the property $1 that has the invalid property $2",
+  traverseVerifyNodeType: "You gave us a visitor for the node type $1 but it's not a valid type",
+
+  pluginIllegalKind: "Illegal kind $1 for plugin $2",
+  pluginIllegalPosition: "Illegal position $1 for plugin $2",
+  pluginKeyCollision: "The plugin $1 collides with another of the same name",
+  pluginNotTransformer: "The plugin $1 didn't export a Plugin instance",
+  pluginUnknown: "Unknown plugin $1",
+
+  pluginNotFile: "Plugin $1 is resolving to a different Babel version than what is performing the transformation.",
+
+  pluginInvalidProperty: "Plugin $1 provided an invalid property of $2.",
+  pluginInvalidPropertyVisitor: `Define your visitor methods inside a \`visitor\` property like so:
+
+  new Plugin("foobar", {
+    visitor: {
+      // define your visitor methods here!
+    }
+  });
+`
 };
 
-export function get(key: String, ...args) {
+/**
+ * Get a message with $0 placeholders replaced by arguments.
+ */
+
+export function get(key: string, ...args): string {
   var msg = MESSAGES[key];
   if (!msg) throw new ReferenceError(`Unknown message ${JSON.stringify(key)}`);
 
+  // stringify args
   args = parseArgs(args);
 
+  // replace $0 placeholders with args
   return msg.replace(/\$(\d+)/g, function (str, i) {
     return args[--i];
   });
 }
 
-export function parseArgs(args: Array<any>) {
+/**
+ * Stingify arguments to be used inside messages.
+ */
+
+export function parseArgs(args: Array<any>): Array<string> {
   return args.map(function (val) {
     if (val != null && val.inspect) {
       return val.inspect();

src/babel/patch.js

@@ -1,58 +1,7 @@
 import estraverse from "estraverse";
 import extend from "lodash/object/extend";
-import types from "ast-types";
 import * as t from "./types";
 
 // estraverse
 
 extend(estraverse.VisitorKeys, t.VISITOR_KEYS);
-
-// regenerator/ast-types
-
-var def = types.Type.def;
-var or  = types.Type.or;
-
-//def("File")
-//  .bases("Node")
-//  .build("program")
-//  .field("program", def("Program"));
-
-def("AssignmentPattern")
-  .bases("Pattern")
-  .build("left", "right")
-  .field("left", def("Pattern"))
-  .field("right", def("Expression"));
-
-def("RestElement")
-  .bases("Pattern")
-  .build("argument")
-  .field("argument", def("expression"));
-
-def("DoExpression")
-  .bases("Expression")
-  .build("body")
-  .field("body", [def("Statement")]);
-
-def("ExportDefaultDeclaration")
-  .bases("Declaration")
-  .build("declaration")
-  .field("declaration", or(
-    def("Declaration"),
-    def("Expression"),
-    null
-  ));
-
-def("ExportNamedDeclaration")
-  .bases("Declaration")
-  .build("declaration")
-  .field("declaration", or(
-    def("Declaration"),
-    def("Expression"),
-    null
-  ))
-  .field("specifiers", [or(
-    def("ExportSpecifier")
-  )])
-  .field("source", or(def("ModuleSpecifier"), null));
-
-types.finalize();

src/babel/tools/README.md

@@ -0,0 +1,15 @@
+## Tools
+
+> This directory is best browsed while listening to
+> https://www.youtube.com/watch?v=hglVqACd1C8.
+
+### Protect Babel
+
+The protect script seen here is to throw errors if someone ever tries to
+include internal babel files in their script. If you need something to be
+exposed, you should ask for it, not try to hack your way into getting it.
+
+### External Helpers
+
+You'll also find the script for building the external helpers file, this is
+the Babel "runtime" where all helper functions go instead of the top of a file.

src/babel/tools/build-external-helpers.js

@@ -5,6 +5,10 @@ import File from "../transformation/file";
 import each from "lodash/collection/each";
 import * as t from "../types";
 
+/**
+ * [Please add a description.]
+ */
+
 function buildGlobal(namespace, builder) {
   var body      = [];
   var container = t.functionExpression(null, [t.identifier("global")], t.blockStatement(body));
@@ -22,6 +26,10 @@ function buildGlobal(namespace, builder) {
   return tree;
 }
 
+/**
+ * [Please add a description.]
+ */
+
 function buildUmd(namespace, builder) {
   var body = [];
   body.push(t.variableDeclaration("var", [
@@ -41,6 +49,10 @@ function buildUmd(namespace, builder) {
   return t.program([container]);
 }
 
+/**
+ * [Please add a description.]
+ */
+
 function buildVar(namespace, builder) {
   var body = [];
   body.push(t.variableDeclaration("var", [
@@ -50,6 +62,10 @@ function buildVar(namespace, builder) {
   return t.program(body);
 }
 
+/**
+ * [Please add a description.]
+ */
+
 function buildHelpers(body, namespace, whitelist) {
   each(File.helpers, function (name) {
     if (whitelist && whitelist.indexOf(name) === -1) return;
@@ -61,6 +77,10 @@ function buildHelpers(body, namespace, whitelist) {
   });
 }
 
+/**
+ * [Please add a description.]
+ */
+
 export default function (whitelist, outputType = "global") {
   var namespace = t.identifier("babelHelpers");
 
@@ -83,4 +103,4 @@ export default function (whitelist, outputType = "global") {
   }
 
   return generator(tree).code;
-};
+}

src/babel/tools/protect.js

@@ -0,0 +1,14 @@
+import path from "path";
+
+var root = path.resolve(__dirname, "../../../");
+
+/**
+ * Protect Babel internals from being hotlinked by other tools.
+ * Sorry, not sorry.
+ */
+
+export default function (module) {
+  if (module.parent && module.parent.filename.indexOf(root) !== 0) {
+    throw new Error("Don't hotlink internal Babel files.");
+  }
+}

src/babel/tools/resolve-rc.js

@@ -1,54 +0,0 @@
-import stripJsonComments from "strip-json-comments";
-import merge from "lodash/object/merge";
-import path from "path";
-import fs from "fs";
-
-var cache = {};
-var jsons = {};
-
-function exists(filename) {
-  if (!fs.existsSync) return false;
-
-  var cached = cache[filename];
-  if (cached != null) return cached;
-  return cache[filename] = fs.existsSync(filename);
-}
-
-export default function (loc, opts = {}) {
-  var rel = ".babelrc";
-
-  function find(start, rel) {
-    var file = path.join(start, rel);
-
-    if (exists(file)) {
-      var content = fs.readFileSync(file, "utf8");
-      var json;
-
-      try {
-        json = jsons[content] ||= JSON.parse(stripJsonComments(content));
-      } catch (err) {
-        err.message = `${file}: ${err.message}`;
-        throw err;
-      }
-
-      if (json.breakConfig) return;
-      merge(opts, json, function(a, b) {
-        if (Array.isArray(a)) {
-          return a.concat(b);
-        }
-      });
-    }
-
-    var up = path.dirname(start);
-    if (up !== start) { // root
-      find(up, rel);
-    }
-  }
-  
-  if (opts.breakConfig !== true) {
-    find(loc, rel);
-  }
-  
-
-  return opts;
-};

src/babel/transformation/README.md

@@ -0,0 +1,3 @@
+## Transformation
+
+This is the Transformation directory.

src/babel/transformation/file/README.md

@@ -0,0 +1,3 @@
+## File Transformation
+
+This is the File Transformation directory.

src/babel/transformation/file/index.js

@@ -1,67 +1,74 @@
 import convertSourceMap from "convert-source-map";
-import * as optionParsers from "./option-parsers";
+import moduleFormatters from "../modules";
+import OptionManager from "./options/option-manager";
+import PluginManager from "./plugin-manager";
 import shebangRegex from "shebang-regex";
-import TraversalPath from "../../traversal/path";
+import NodePath from "../../traversal/path";
 import isFunction from "lodash/lang/isFunction";
-import isAbsolute from "path-is-absolute";
-import resolveRc from "../../tools/resolve-rc";
 import sourceMap from "source-map";
-import transform from "./../index";
 import generate from "../../generation";
+import codeFrame from "../../helpers/code-frame";
 import defaults from "lodash/object/defaults";
 import includes from "lodash/collection/includes";
 import traverse from "../../traversal";
-import assign from "lodash/object/assign";
 import Logger from "./logger";
+import Plugin from "../plugin";
 import parse from "../../helpers/parse";
-import Scope from "../../traversal/scope";
-import slash from "slash";
+import Hub from "../../traversal/hub";
 import * as util from  "../../util";
 import path from "path";
-import each from "lodash/collection/each";
 import * as t from "../../types";
 
-var checkTransformerVisitor = {
-  enter(node, parent, scope, state) {
-    checkNode(state.stack, node, scope);
-  }
-};
-
-function checkNode(stack, node, scope) {
-  each(stack, function (pass) {
-    if (pass.shouldRun || pass.ran) return;
-    pass.checkNode(node, scope);
-  });
-}
+/**
+ * [Please add a description.]
+ */
 
 export default class File {
-  constructor(opts = {}) {
-    this.dynamicImportAbsoluteDefaults = [];
-    this.dynamicImportIds              = {};
-    this.dynamicImports                = [];
+  constructor(opts = {}, pipeline) {
+    this.transformerDependencies = {};
 
-    this.usedHelpers = {};
-    this.dynamicData = {};
-    this.data        = {};
-    this.uids        = {};
+    this.dynamicImportTypes = {};
+    this.dynamicImportIds   = {};
+    this.dynamicImports     = [];
 
-    this.lastStatements = [];
-    this.log            = new Logger(this, opts.filename || "unknown");
-    this.opts           = this.normalizeOptions(opts);
-    this.ast            = {};
+    this.declarations = {};
+    this.usedHelpers  = {};
+    this.dynamicData  = {};
+    this.data         = {};
+
+    this.metadata = {
+      modules: {
+        imports: [],
+        exports: {
+          exported: [],
+          specifiers: []
+        }
+      }
+    };
+
+    this.pipeline = pipeline;
+    this.log      = new Logger(this, opts.filename || "unknown");
+    this.opts     = this.initOptions(opts);
+    this.ast      = {};
 
     this.buildTransformers();
+
+    this.hub = new Hub(this);
   }
 
+  /**
+   * [Please add a description.]
+   */
+
   static helpers = [
     "inherits",
     "defaults",
     "create-class",
     "create-decorated-class",
     "create-decorated-object",
+    "define-decorated-property-descriptor",
     "tagged-template-literal",
     "tagged-template-literal-loose",
-    "interop-require",
     "to-array",
     "to-consumable-array",
     "sliced-to-array",
@@ -73,6 +80,7 @@ export default class File {
     "define-property",
     "async-to-generator",
     "interop-require-wildcard",
+    "interop-require-default",
     "typeof",
     "extends",
     "get",
@@ -82,63 +90,31 @@ export default class File {
     "temporal-undefined",
     "temporal-assert-defined",
     "self-global",
-    "default-props"
+    "default-props",
+    "instanceof",
+
+    // legacy
+    "interop-require"
   ];
 
+  /**
+   * [Please add a description.]
+   */
+
   static soloHelpers = [];
 
-  static options = require("./options");
 
-  normalizeOptions(opts: Object) {
-    opts = assign({}, opts);
+  /**
+   * [Please add a description.]
+   */
 
-    if (opts.filename) {
-      var rcFilename = opts.filename;
-      if (!isAbsolute(rcFilename)) rcFilename = path.join(process.cwd(), rcFilename);
-      opts = resolveRc(rcFilename, opts);
-    }
-
-    //
-
-    for (let key in opts) {
-      if (key[0] === "_") continue;
-
-      let option = File.options[key];
-      if (!option) this.log.error(`Unknown option: ${key}`, ReferenceError);
-    }
-
-    for (let key in File.options) {
-      let option = File.options[key];
-
-      var val = opts[key];
-      if (!val && option.optional) continue;
-
-      if (val && option.deprecated) {
-        throw new Error("Deprecated option " + key + ": " + option.deprecated);
-      }
-
-      if (val == null) val = option.default || val;
-
-      var optionParser = optionParsers[option.type];
-      if (optionParser) val = optionParser(key, val);
-
-      if (option.alias) {
-        opts[option.alias] ||= val;
-      } else {
-        opts[key] = val;
-      }
-    }
+  initOptions(opts) {
+    opts = new OptionManager(this.log, this.pipeline).init(opts);
 
     if (opts.inputSourceMap) {
       opts.sourceMaps = true;
     }
 
-    // normalize windows path separators to unix
-    opts.filename = slash(opts.filename);
-    if (opts.sourceRoot) {
-      opts.sourceRoot = slash(opts.sourceRoot);
-    }
-
     if (opts.moduleId) {
       opts.moduleIds = true;
     }
@@ -146,7 +122,8 @@ export default class File {
     opts.basename = path.basename(opts.filename, path.extname(opts.filename));
 
     opts.ignore = util.arrayify(opts.ignore, util.regexify);
-    opts.only   = util.arrayify(opts.only, util.regexify);
+
+    if (opts.only) opts.only = util.arrayify(opts.only, util.regexify);
 
     defaults(opts, {
       moduleRoot: opts.sourceRoot
@@ -162,7 +139,7 @@ export default class File {
 
     defaults(opts, {
       sourceFileName: opts.filenameRelative,
-      sourceMapName:  opts.filenameRelative
+      sourceMapTarget:  opts.filenameRelative
     });
 
     //
@@ -172,12 +149,20 @@ export default class File {
     }
 
     return opts;
-  };
+  }
+
+  /**
+   * [Please add a description.]
+   */
 
   isLoose(key: string) {
     return includes(this.opts.loose, key);
   }
 
+  /**
+   * [Please add a description.]
+   */
+
   buildTransformers() {
     var file = this;
 
@@ -187,8 +172,9 @@ export default class File {
     var stack = [];
 
     // build internal transformers
-    each(transform.transformers, function (transformer, key) {
-      var pass = transformers[key] = transformer.buildPass(file);
+    for (var key in this.pipeline.transformers) {
+      var transformer = this.pipeline.transformers[key];
+      let pass = transformers[key] = transformer.buildPass(file);
 
       if (pass.canTransform()) {
         stack.push(pass);
@@ -201,121 +187,96 @@ export default class File {
           transformer.manipulateOptions(file.opts, file);
         }
       }
-    });
+    }
 
     // init plugins!
     var beforePlugins = [];
     var afterPlugins = [];
+    var pluginManager = new PluginManager({
+      file: this,
+      transformers: this.transformers,
+      before: beforePlugins,
+      after: afterPlugins
+    });
     for (var i = 0; i < file.opts.plugins.length; i++) {
-      this.addPlugin(file.opts.plugins[i], beforePlugins, afterPlugins);
+      pluginManager.add(file.opts.plugins[i]);
     }
     stack = beforePlugins.concat(stack, afterPlugins);
 
-    // register
-    this.transformerStack = stack.concat(secondaryStack);
-  }
+    // build transformer stack
+    this.uncollapsedTransformerStack = stack = stack.concat(secondaryStack);
 
-  getModuleFormatter(type: string) {
-    var ModuleFormatter = isFunction(type) ? type : transform.moduleFormatters[type];
-
-    if (!ModuleFormatter) {
-      var loc = util.resolveRelative(type);
-      if (loc) ModuleFormatter = require(loc);
+    // build dependency graph
+    for (let pass of (stack: Array)) {
+      for (var dep of (pass.plugin.dependencies: Array)) {
+        this.transformerDependencies[dep] = pass.key;
+      }
     }
 
-    if (!ModuleFormatter) {
-      throw new ReferenceError(`Unknown module formatter type ${JSON.stringify(type)}`);
-    }
-
-    return new ModuleFormatter(this);
+    // collapse stack categories
+    this.transformerStack = this.collapseStack(stack);
   }
 
-  addPlugin(name, before, after) {
-    var position = "before";
-    var plugin;
+  /**
+   * [Please add a description.]
+   */
 
-    if (name) {
-      if (typeof name === "string") {
-        // this is a plugin in the form of "foobar" or "foobar:after"
-        // where the optional colon is the delimiter for plugin position in the transformer stack
+  collapseStack(_stack) {
+    var stack  = [];
+    var ignore = [];
 
-        [name, position = "before"] = name.split(":");
+    for (let pass of (_stack: Array)) {
+      // been merged
+      if (ignore.indexOf(pass) >= 0) continue;
 
-        var loc = util.resolveRelative(name) || util.resolveRelative(`babel-plugin-${name}`);
-        if (loc) {
-          plugin = require(loc)
-        } else {
-          throw new ReferenceError(`Unknown plugin ${JSON.stringify(name)}`);
+      var group = pass.plugin.metadata.group;
+
+      // can't merge
+      if (!pass.canTransform() || !group) {
+        stack.push(pass);
+        continue;
+      }
+
+      var mergeStack = [];
+      for (let pass of (_stack: Array)) {
+        if (pass.plugin.metadata.group === group) {
+          mergeStack.push(pass);
+          ignore.push(pass);
         }
-      } else {
-        // not a string so we'll just assume that it's a direct Transformer instance, if not then
-        // the checks later on will complain
-        plugin = name;
       }
-    } else {
-      throw new TypeError(`Ilegal kind ${typeof name} for plugin name ${JSON.stringify(name)}`);
-    }
 
-    // validate position
-    if (position !== "before" && position !== "after") {
-      throw new TypeError(`Plugin ${JSON.stringify(name)} has an illegal position of ${JSON.stringify(position)}`);
-    }
-
-    // validate transformer key
-    var key = plugin.key;
-    if (this.transformers[key]) {
-      throw new ReferenceError(`The key for plugin ${JSON.stringify(name)} of ${key} collides with an existing plugin`);
-    }
-
-    // validate Transformer instance
-    if (!plugin.buildPass || plugin.constructor.name !== "Transformer") {
-      throw new TypeError(`Plugin ${JSON.stringify(name)} didn't export a default Transformer instance`);
-    }
-
-    // build!
-    var pass = this.transformers[key] = plugin.buildPass(this);
-    if (pass.canTransform()) {
-      var stack = before;
-      if (position === "after") stack = after;
-      stack.push(pass);
-    }
-  }
-
-  parseInputSourceMap(code: string) {
-    var opts = this.opts;
-
-    if (opts.inputSourceMap !== false) {
-      var inputMap = convertSourceMap.fromSource(code);
-      if (inputMap) {
-        opts.inputSourceMap = inputMap.toObject();
-        code = convertSourceMap.removeComments(code);
+      var visitors = [];
+      for (let pass of (mergeStack: Array)) {
+        visitors.push(pass.plugin.visitor);
       }
+      var visitor = traverse.visitors.merge(visitors);
+      var mergePlugin = new Plugin(group, { visitor });
+      stack.push(mergePlugin.buildPass(this));
     }
 
-    return code;
+    return stack;
   }
 
-  parseShebang(code: string) {
-    var shebangMatch = shebangRegex.exec(code);
-
-    if (shebangMatch) {
-      this.shebang = shebangMatch[0];
-
-      // remove shebang
-      code = code.replace(shebangRegex, "");
-    }
-
-    return code;
-  }
+  /**
+   * [Please add a description.]
+   */
 
   set(key: string, val): any {
     return this.data[key] = val;
-  };
+  }
+
+  /**
+   * [Please add a description.]
+   */
 
   setDynamic(key: string, fn: Function) {
     this.dynamicData[key] = fn;
   }
 
+  /**
+   * [Please add a description.]
+   */
+
   get(key: string): any {
     var data = this.data[key];
     if (data) {
@@ -328,14 +289,22 @@ export default class File {
     }
   }
 
+  /**
+   * [Please add a description.]
+   */
+
   resolveModuleSource(source: string): string {
     var resolveModuleSource = this.opts.resolveModuleSource;
     if (resolveModuleSource) source = resolveModuleSource(source, this.opts.filename);
     return source;
   }
 
-  addImport(source: string, name?: string, absoluteDefault?: boolean): Object {
-    name ||= source;
+  /**
+   * [Please add a description.]
+   */
+
+  addImport(source: string, name?: string, type?: string): Object {
+    name = name || source;
     var id = this.dynamicImportIds[name];
 
     if (!id) {
@@ -345,10 +314,14 @@ export default class File {
       var specifiers = [t.importDefaultSpecifier(id)];
       var declar = t.importDeclaration(specifiers, t.literal(source));
       declar._blockHoist = 3;
-      if (absoluteDefault) this.dynamicImportAbsoluteDefaults.push(declar);
+
+      if (type) {
+        var modules = this.dynamicImportTypes[type] = this.dynamicImportTypes[type] || [];
+        modules.push(declar);
+      }
 
       if (this.transformers["es6.modules"].canTransform()) {
-        this.moduleFormatter.importSpecifier(specifiers[0], declar, this.dynamicImports);
+        this.moduleFormatter.importSpecifier(specifiers[0], declar, this.dynamicImports, this.scope);
         this.moduleFormatter.hasLocalImports = true;
       } else {
         this.dynamicImports.push(declar);
@@ -358,22 +331,36 @@ export default class File {
     return id;
   }
 
-  isConsequenceExpressionStatement(node: Object): boolean {
-    return t.isExpressionStatement(node) && this.lastStatements.indexOf(node) >= 0;
-  }
+  /**
+   * [Please add a description.]
+   */
 
   attachAuxiliaryComment(node: Object): Object {
-    var comment = this.opts.auxiliaryComment;
-    if (comment) {
-      node.leadingComments ||= [];
+    var beforeComment = this.opts.auxiliaryCommentBefore;
+    if (beforeComment) {
+      node.leadingComments = node.leadingComments || [];
       node.leadingComments.push({
-        type: "Line",
-        value: " " + comment
+        type: "CommentLine",
+        value: " " + beforeComment
       });
     }
+
+    var afterComment = this.opts.auxiliaryCommentAfter;
+    if (afterComment) {
+      node.trailingComments = node.trailingComments || [];
+      node.trailingComments.push({
+        type: "CommentLine",
+        value: " " + afterComment
+      });
+    }
+
     return node;
   }
 
+  /**
+   * [Please add a description.]
+   */
+
   addHelper(name: string): Object {
     var isSolo = includes(File.soloHelpers, name);
 
@@ -381,10 +368,8 @@ export default class File {
       throw new ReferenceError(`Unknown helper ${name}`);
     }
 
-    var program = this.ast.program;
-
-    var declar = program._declarations && program._declarations[name];
-    if (declar) return declar.id;
+    var declar = this.declarations[name];
+    if (declar) return declar;
 
     this.usedHelpers[name] = true;
 
@@ -400,47 +385,99 @@ export default class File {
     }
 
     var ref = util.template("helper-" + name);
-    ref._compact = true;
-    var uid = this.scope.generateUidIdentifier(name);
-    this.scope.push({
-      key: name,
-      id: uid,
-      init: ref
-    });
+
+    var uid = this.declarations[name] = this.scope.generateUidIdentifier(name);
+
+    if (t.isFunctionExpression(ref) && !ref.id) {
+      ref.body._compact = true;
+      ref._generated = true;
+      ref.id = uid;
+      ref.type = "FunctionDeclaration";
+      this.attachAuxiliaryComment(ref);
+      this.path.unshiftContainer("body", ref);
+    } else {
+      ref._compact = true;
+      this.scope.push({
+        id: uid,
+        init: ref,
+        unique: true
+      });
+    }
+
     return uid;
   }
 
+  /**
+   * [Please add a description.]
+   */
+
   errorWithNode(node, msg, Error = SyntaxError) {
-    var loc = node.loc.start;
-    var err = new Error(`Line ${loc.line}: ${msg}`);
-    err.loc = loc;
+    var err;
+    if (node && node.loc) {
+      var loc = node.loc.start;
+      err = new Error(`Line ${loc.line}: ${msg}`);
+      err.loc = loc;
+    } else {
+      // todo: find errors with nodes inside to at least point to something
+      err = new Error("There's been an error on a dynamic node. This is almost certainly an internal error. Please report it.");
+    }
     return err;
   }
 
-  addCode(code: string) {
-    code = (code || "") + "";
-    code = this.parseInputSourceMap(code);
-    this.code = code;
-    return this.parseShebang(code);
-  }
+  /**
+   * [Please add a description.]
+   */
 
-  shouldIgnore() {
+  mergeSourceMap(map: Object) {
     var opts = this.opts;
-    return util.shouldIgnore(opts.filename, opts.ignore, opts.only);
-  }
 
-  parse(code: string) {
-    if (this.shouldIgnore()) {
-      return {
-        metadata: {},
-        code:     code,
-        map:      null,
-        ast:      null
-      };
+    var inputMap = opts.inputSourceMap;
+
+    if (inputMap) {
+      map.sources[0] = inputMap.file;
+
+      var inputMapConsumer   = new sourceMap.SourceMapConsumer(inputMap);
+      var outputMapConsumer  = new sourceMap.SourceMapConsumer(map);
+      var outputMapGenerator = sourceMap.SourceMapGenerator.fromSourceMap(outputMapConsumer);
+      outputMapGenerator.applySourceMap(inputMapConsumer);
+
+      var mergedMap = outputMapGenerator.toJSON();
+      mergedMap.sources = inputMap.sources;
+      mergedMap.file    = inputMap.file;
+      return mergedMap;
     }
 
-    code = this.addCode(code);
+    return map;
+  }
 
+  /**
+   * [Please add a description.]
+   */
+
+  getModuleFormatter(type: string) {
+    if (isFunction(type) || !moduleFormatters[type]) {
+      this.log.deprecate("Custom module formatters are deprecated and will be removed in the next major. Please use Babel plugins instead.");
+    }
+
+    var ModuleFormatter = isFunction(type) ? type : moduleFormatters[type];
+
+    if (!ModuleFormatter) {
+      var loc = util.resolveRelative(type);
+      if (loc) ModuleFormatter = require(loc);
+    }
+
+    if (!ModuleFormatter) {
+      throw new ReferenceError(`Unknown module formatter type ${JSON.stringify(type)}`);
+    }
+
+    return new ModuleFormatter(this);
+  }
+
+  /**
+   * [Please add a description.]
+   */
+
+  parse(code: string) {
     var opts = this.opts;
 
     //
@@ -462,129 +499,217 @@ export default class File {
     parseOpts.strictMode = features.strict;
     parseOpts.sourceType = "module";
 
-    //
-
-    return parse(parseOpts, code, (tree) => {
-      this.transform(tree);
-      return this.generate();
-    });
+    this.log.debug("Parse start");
+    var tree = parse(code, parseOpts);
+    this.log.debug("Parse stop");
+    return tree;
   }
 
-  setAst(ast) {
-    this.path  = TraversalPath.get(null, null, ast, ast, "program", this);
+  /**
+   * [Please add a description.]
+   */
+
+  _addAst(ast) {
+    this.path = NodePath.get({
+      hub: this.hub,
+      parentPath: null,
+      parent: ast,
+      container: ast,
+      key: "program"
+    }).setContext();
     this.scope = this.path.scope;
     this.ast   = ast;
-
-    this.path.traverse({
-      enter(node, parent, scope) {
-        if (this.isScope()) {
-          for (var key in scope.bindings) {
-            scope.bindings[key].setTypeAnnotation();
-          }
-        }
-      }
-    });
   }
 
-  transform(ast) {
-    this.log.debug();
+  /**
+   * [Please add a description.]
+   */
 
-    this.setAst(ast);
-
-    this.lastStatements = t.getLastStatements(ast.program);
+  addAst(ast) {
+    this.log.debug("Start set AST");
+    this._addAst(ast);
+    this.log.debug("End set AST");
 
+    this.log.debug("Start module formatter init");
     var modFormatter = this.moduleFormatter = this.getModuleFormatter(this.opts.modules);
     if (modFormatter.init && this.transformers["es6.modules"].canTransform()) {
       modFormatter.init();
     }
-
-    this.checkNode(ast);
-
-    this.call("pre");
-
-    each(this.transformerStack, function (pass) {
-      pass.transform();
-    });
-
-    this.call("post");
+    this.log.debug("End module formatter init");
   }
 
+  /**
+   * [Please add a description.]
+   */
+
+  transform() {
+    this.call("pre");
+    for (var pass of (this.transformerStack: Array)) {
+      pass.transform();
+    }
+    this.call("post");
+
+    return this.generate();
+  }
+
+  /**
+   * [Please add a description.]
+   */
+
+  wrap(code, callback) {
+    code = code + "";
+
+    try {
+      if (this.shouldIgnore()) {
+        return this.makeResult({ code, ignored: true });
+      } else {
+        return callback();
+      }
+    } catch (err) {
+      if (err._babel) {
+        throw err;
+      } else {
+        err._babel = true;
+      }
+
+      var message = err.message = `${this.opts.filename}: ${err.message}`;
+
+      var loc = err.loc;
+      if (loc) {
+        err.codeFrame = codeFrame(code, loc.line, loc.column + 1, this.opts);
+        message += "\n" + err.codeFrame;
+      }
+
+      if (err.stack) {
+        var newStack = err.stack.replace(err.message, message);
+        try {
+          err.stack = newStack;
+        } catch (e) {
+          // `err.stack` may be a readonly property in some environments
+        }
+      }
+
+      throw err;
+    }
+  }
+
+  /**
+   * [Please add a description.]
+   */
+
+  addCode(code: string) {
+    code = (code || "") + "";
+    code = this.parseInputSourceMap(code);
+    this.code = code;
+  }
+
+  /**
+   * [Please add a description.]
+   */
+
+  parseCode() {
+    this.parseShebang();
+    this.addAst(this.parse(this.code));
+  }
+
+  /**
+   * [Please add a description.]
+   */
+
+  shouldIgnore() {
+    var opts = this.opts;
+    return util.shouldIgnore(opts.filename, opts.ignore, opts.only);
+  }
+
+  /**
+   * [Please add a description.]
+   */
+
   call(key: string) {
-    var stack = this.transformerStack;
-    for (var i = 0; i < stack.length; i++) {
-      var transformer = stack[i].transformer;
-      var fn = transformer[key];
+    for (var pass of (this.uncollapsedTransformerStack: Array)) {
+      var fn = pass.plugin[key];
       if (fn) fn(this);
     }
   }
 
-  checkNode(node, scope) {
-    if (Array.isArray(node)) {
-      for (var i = 0; i < node.length; i++) {
-        this.checkNode(node[i], scope);
+  /**
+   * [Please add a description.]
+   */
+
+  parseInputSourceMap(code: string) {
+    var opts = this.opts;
+
+    if (opts.inputSourceMap !== false) {
+      var inputMap = convertSourceMap.fromSource(code);
+      if (inputMap) {
+        opts.inputSourceMap = inputMap.toObject();
+        code = convertSourceMap.removeComments(code);
       }
-      return;
     }
 
-    var stack = this.transformerStack;
-    scope ||= this.scope;
-
-    checkNode(stack, node, scope);
-
-    scope.traverse(node, checkTransformerVisitor, {
-      stack: stack
-    });
+    return code;
   }
 
-  mergeSourceMap(map: Object) {
-    var opts = this.opts;
+  /**
+   * [Please add a description.]
+   */
 
-    var inputMap = opts.inputSourceMap;
-
-    if (inputMap) {
-      map.sources[0] = inputMap.file;
-
-      var inputMapConsumer   = new sourceMap.SourceMapConsumer(inputMap);
-      var outputMapConsumer  = new sourceMap.SourceMapConsumer(map);
-      var outputMapGenerator = sourceMap.SourceMapGenerator.fromSourceMap(outputMapConsumer);
-      outputMapGenerator.applySourceMap(inputMapConsumer);
-
-      var mergedMap = outputMapGenerator.toJSON();
-      mergedMap.sources = inputMap.sources
-      mergedMap.file    = inputMap.file;
-      return mergedMap;
+  parseShebang() {
+    var shebangMatch = shebangRegex.exec(this.code);
+    if (shebangMatch) {
+      this.shebang = shebangMatch[0];
+      this.code = this.code.replace(shebangRegex, "");
     }
-
-    return map;
   }
 
-  generate(): {
-    usedHelpers?: Array<string>;
-    code: string;
-    map?: Object;
-    ast?: Object;
-  } {
-    var opts = this.opts;
-    var ast  = this.ast;
+  /**
+   * [Please add a description.]
+   */
 
+  makeResult({ code, map = null, ast, ignored }) {
     var result = {
-      metadata: {},
-      code:     "",
-      map:      null,
-      ast:      null
+      metadata: null,
+      ignored:  !!ignored,
+      code:     null,
+      ast:      null,
+      map:      map
     };
 
-    if (this.opts.metadataUsedHelpers) {
+    if (this.opts.code) {
+      result.code = code;
+    }
+
+    if (this.opts.ast) {
+      result.ast = ast;
+    }
+
+    if (this.opts.metadata) {
+      result.metadata = this.metadata;
       result.metadata.usedHelpers = Object.keys(this.usedHelpers);
     }
 
-    if (opts.ast) result.ast = ast;
-    if (!opts.code) return result;
+    return result;
+  }
+
+  /**
+   * [Please add a description.]
+   */
+
+  generate() {
+    var opts = this.opts;
+    var ast  = this.ast;
+
+    var result = { ast };
+    if (!opts.code) return this.makeResult(result);
+
+    this.log.debug("Generation start");
 
     var _result = generate(ast, opts, this.code);
     result.code = _result.code;
     result.map  = _result.map;
 
+    this.log.debug("Generation end");
+
     if (this.shebang) {
       // add back shebang
       result.code = `${this.shebang}\n${result.code}`;
@@ -602,6 +727,6 @@ export default class File {
       result.map = null;
     }
 
-    return result;
+    return this.makeResult(result);
   }
 }

src/babel/transformation/file/logger.js

@@ -1,4 +1,14 @@
-import * as util from  "../../util";
+import type File from "./index";
+import buildDebug from "debug/node";
+
+var verboseDebug = buildDebug("babel:verbose");
+var generalDebug = buildDebug("babel");
+
+var seenDeprecatedMessages = [];
+
+/**
+ * [Please add a description.]
+ */
 
 export default class Logger {
   constructor(file: File, filename: string) {
@@ -6,27 +16,71 @@ export default class Logger {
     this.file     = file;
   }
 
+  /**
+   * [Please add a description.]
+   */
+
   _buildMessage(msg: string): string {
-    var parts = this.filename;
+    var parts = `[BABEL] ${this.filename}`;
     if (msg) parts += `: ${msg}`;
     return parts;
   }
 
+  /**
+   * [Please add a description.]
+   */
+
+  warn(msg) {
+    console.warn(this._buildMessage(msg));
+  }
+
+  /**
+   * [Please add a description.]
+   */
+
   error(msg: string, Constructor = Error) {
     throw new Constructor(this._buildMessage(msg));
   }
 
+  /**
+   * [Please add a description.]
+   */
+
   deprecate(msg) {
-    if (!this.file.opts.suppressDeprecationMessages) {
-      console.error(msg);
-    }
+    if (this.file.opts.suppressDeprecationMessages) return;
+
+    msg = this._buildMessage(msg);
+
+    // already seen this message
+    if (seenDeprecatedMessages.indexOf(msg) >= 0) return;
+
+    // make sure we don't see it again
+    seenDeprecatedMessages.push(msg);
+
+    console.error(msg);
   }
 
+  /**
+   * [Please add a description.]
+   */
+
+  verbose(msg: string) {
+    if (verboseDebug.enabled) verboseDebug(this._buildMessage(msg));
+  }
+
+  /**
+   * [Please add a description.]
+   */
+
   debug(msg: string) {
-    util.debug(this._buildMessage(msg));
+    if (generalDebug.enabled) generalDebug(this._buildMessage(msg));
   }
 
+  /**
+   * [Please add a description.]
+   */
+
   deopt(node: Object, msg: string) {
-    util.debug(this._buildMessage(msg));
+    this.debug(msg);
   }
 }

src/babel/transformation/file/option-parsers.js

@@ -1,28 +0,0 @@
-import transform from "./../index";
-import * as util from  "../../util";
-
-export function transformerList(key, val) {
-  val = util.arrayify(val);
-
-  if (val.indexOf("all") >= 0 || val.indexOf(true) >= 0) {
-    val = Object.keys(transform.transformers);
-  }
-
-  return transform._ensureTransformerNames(key, val);
-}
-
-export function number(key, val) {
-  return +val;
-}
-
-export function boolean(key, val) {
-  return !!val;
-}
-
-export function booleanString(key, val) {
-  return util.booleanify(val);
-}
-
-export function list(key, val) {
-  return util.list(val);
-}

src/babel/transformation/file/options/README.md

@@ -0,0 +1,3 @@
+## File Options
+
+This is the File Options directory.

src/babel/transformation/file/options/config.json

@@ -1,6 +1,6 @@
 {
   "filename": {
-    "type": "string",
+    "type": "filename",
     "description": "filename to use when reading from stdin - this will be used in source-maps, errors etc",
     "default": "unknown",
     "shorthand": "f"
@@ -15,23 +15,45 @@
     "hidden": true
   },
 
+  "extra": {
+    "hidden": true,
+    "default": {}
+  },
+
+  "env": {
+    "hidden": true,
+    "default": {}
+  },
+
   "moduleId": {
     "description": "specify a custom name for module ids",
     "type": "string"
   },
 
+  "getModuleId": {
+    "hidden": true
+  },
+
+  "retainLines": {
+    "type": "boolean",
+    "default": false,
+    "description": "retain line numbers - will result in really ugly code"
+  },
+
   "nonStandard": {
     "type": "boolean",
     "default": true,
-    "description": "enable support for JSX and Flow"
+    "description": "enable/disable support for JSX and Flow (on by default)"
   },
 
   "experimental": {
-    "deprecated": "use `--stage 0`/`{ stage: 0 }` instead"
+    "type": "boolean",
+    "description": "allow use of experimental transformers",
+    "default": false
   },
 
   "highlightCode": {
-    "description": "ANSI syntax highlight code frames",
+    "description": "enable/disable ANSI syntax highlighting of code frames (on by default)",
     "type": "boolean",
     "default": true
   },
@@ -56,7 +78,8 @@
   "blacklist": {
     "type": "transformerList",
     "description": "blacklist of transformers to NOT use",
-    "shorthand": "b"
+    "shorthand": "b",
+    "default": []
   },
 
   "whitelist": {
@@ -68,7 +91,8 @@
 
   "optional": {
     "type": "transformerList",
-    "description": "list of optional transformers to enable"
+    "description": "list of optional transformers to enable",
+    "default": []
   },
 
   "modules": {
@@ -100,12 +124,14 @@
 
   "plugins": {
     "type": "list",
-    "description": ""
+    "description": "",
+    "default": []
   },
 
   "ignore": {
     "type": "list",
-    "description": "list of glob paths to **not** compile"
+    "description": "list of glob paths to **not** compile",
+    "default": []
   },
 
   "only": {
@@ -119,6 +145,12 @@
     "type": "boolean"
   },
 
+  "metadata": {
+    "hidden": true,
+    "default": true,
+    "type": "boolean"
+  },
+
   "ast": {
     "hidden": true,
     "default": true,
@@ -128,7 +160,7 @@
   "comments": {
     "type": "boolean",
     "default": true,
-    "description": "output comments in generated output"
+    "description": "strip/output comments in generated output (on by default)"
   },
 
   "compact": {
@@ -145,20 +177,32 @@
   },
 
   "auxiliaryComment": {
+    "deprecated": "renamed to auxiliaryCommentBefore",
+    "shorthand": "a",
+    "alias": "auxiliaryCommentBefore"
+  },
+
+  "auxiliaryCommentBefore": {
     "type": "string",
     "default": "",
-    "shorthand": "a",
     "description": "attach a comment before all helper declarations and auxiliary code"
   },
 
-  "externalHelpers": {
+  "auxiliaryCommentAfter": {
     "type": "string",
+    "default": "",
+    "description": "attach a comment after all helper declarations and auxiliary code"
+  },
+
+  "externalHelpers": {
+    "type": "boolean",
     "default": false,
     "shorthand": "r",
     "description": "uses a reference to `babelHelpers` instead of placing helpers at the top of your code."
   },
 
   "metadataUsedHelpers": {
+    "deprecated": "Not required anymore as this is enabled by default",
     "type": "boolean",
     "default": false,
     "hidden": true
@@ -177,6 +221,11 @@
   },
 
   "sourceMapName": {
+    "alias": "sourceMapTarget",
+    "description": "DEPRECATED - Please use sourceMapTarget"
+  },
+
+  "sourceMapTarget": {
     "type": "string",
     "description": "set `file` on returned source map"
   },
@@ -187,12 +236,12 @@
   },
 
   "sourceRoot": {
-    "type": "string",
+    "type": "filename",
     "description": "the root from which all sources are relative"
   },
 
   "moduleRoot": {
-    "type": "string",
+    "type": "filename",
     "description": "optional prefix for the AMD module formatter that will be prepend to the filename on module definitions"
   },
 
@@ -201,6 +250,10 @@
     "default": false,
     "hidden": true,
     "description": "stop trying to load .babelrc files"
-  }
+  },
 
+  "babelrc": {
+    "description": "Specify a custom list of babelrc files to use",
+    "type": "list"
+  }
 }

src/babel/transformation/file/options/index.js

@@ -0,0 +1,39 @@
+import * as parsers from "./parsers";
+import config from "./config";
+
+export { config };
+
+/**
+ * Validate an option.
+ */
+
+export function validateOption(key, val, pipeline) {
+  var opt = config[key];
+  var parser = opt && parsers[opt.type];
+  if (parser && parser.validate) {
+    return parser.validate(key, val, pipeline);
+  } else {
+    return val;
+  }
+}
+
+/**
+ * Normalize all options.
+ */
+
+export function normaliseOptions(options = {}) {
+  for (var key in options) {
+    var val = options[key];
+    if (val == null) continue;
+
+    var opt = config[key];
+    if (!opt) continue;
+
+    var parser = parsers[opt.type];
+    if (parser) val = parser(val);
+
+    options[key] = val;
+  }
+
+  return options;
+}

src/babel/transformation/file/options/option-manager.js

@@ -0,0 +1,170 @@
+import { validateOption, normaliseOptions } from "./index";
+import stripJsonComments from "strip-json-comments";
+import isAbsolute from "path-is-absolute";
+import pathExists from "path-exists";
+import clone from "lodash/lang/clone";
+import merge from "../../../helpers/merge";
+import config from "./config";
+import path from "path";
+import fs from "fs";
+
+var existsCache = {};
+var jsonCache   = {};
+
+const CONFIG_FILENAME = ".babelrc";
+
+function exists(filename) {
+  var cached = existsCache[filename];
+  if (cached != null) {
+    return cached;
+  } else {
+    return existsCache[filename] = pathExists.sync(filename);
+  }
+}
+
+export default class OptionManager {
+  constructor(log, pipeline) {
+    this.resolvedConfigs = [];
+    this.options         = OptionManager.createBareOptions();
+    this.pipeline        = pipeline;
+    this.log             = log;
+  }
+
+  /**
+   * [Please add a description.]
+   */
+
+  static createBareOptions() {
+    var opts = {};
+
+    for (var key in config) {
+      var opt = config[key];
+      opts[key] = clone(opt.default);
+    }
+
+    return opts;
+  }
+
+  /**
+   * [Please add a description.]
+   */
+
+  addConfig(loc) {
+    if (this.resolvedConfigs.indexOf(loc) >= 0) return;
+
+    var content = fs.readFileSync(loc, "utf8");
+    var opts;
+
+    try {
+      opts = jsonCache[content] = jsonCache[content] || JSON.parse(stripJsonComments(content));
+    } catch (err) {
+      err.message = `${loc}: ${err.message}`;
+      throw err;
+    }
+
+    this.mergeOptions(opts, loc);
+    this.resolvedConfigs.push(loc);
+  }
+
+  /**
+   * [Please add a description.]
+   */
+
+  mergeOptions(opts, alias = "foreign") {
+    if (!opts) return;
+
+    for (let key in opts) {
+      if (key[0] === "_") continue;
+
+      let option = config[key];
+
+      // check for an unknown option
+      if (!option) this.log.error(`Unknown option: ${alias}.${key}`, ReferenceError);
+    }
+
+    // normalise options
+    normaliseOptions(opts);
+
+    // merge them into this current files options
+    merge(this.options, opts);
+  }
+
+  /**
+   * [Please add a description.]
+   */
+
+  findConfigs(loc) {
+    if (!loc) return;
+
+    if (!isAbsolute(loc)) {
+      loc = path.join(process.cwd(), loc);
+    }
+
+    while (loc !== (loc = path.dirname(loc))) {
+      if (this.options.breakConfig) return;
+
+      var configLoc = path.join(loc, CONFIG_FILENAME);
+      if (exists(configLoc)) this.addConfig(configLoc);
+    }
+  }
+
+  /**
+   * [Please add a description.]
+   */
+
+  normaliseOptions() {
+    var opts = this.options;
+
+    for (let key in config) {
+      var option = config[key];
+      var val    = opts[key];
+
+      // optional
+      if (!val && option.optional) continue;
+
+      // deprecated
+      if (this.log && val && option.deprecated) {
+        this.log.deprecate(`Deprecated option ${key}: ${option.deprecated}`);
+      }
+
+      // validate
+      if (this.pipeline && val) {
+        val = validateOption(key, val, this.pipeline);
+      }
+
+      // aaliases
+      if (option.alias) {
+        opts[option.alias] = opts[option.alias] || val;
+      } else {
+        opts[key] = val;
+      }
+    }
+  }
+
+  /**
+   * [Please add a description.]
+   */
+
+  init(opts) {
+    this.mergeOptions(opts, "direct");
+
+    // babelrc option
+    if (opts.babelrc) {
+      for (var loc of (opts.babelrc: Array)) this.addConfig(loc);
+    }
+
+    // resolve all .babelrc files
+    this.findConfigs(opts.filename);
+
+    // merge in env
+    var envKey = process.env.BABEL_ENV || process.env.NODE_ENV || "development";
+    if (this.options.env) {
+      this.mergeOptions(this.options.env[envKey], `direct.env.${envKey}`);
+    }
+
+    // normalise
+    this.normaliseOptions(opts);
+
+    return this.options;
+  }
+}

src/babel/transformation/file/options/parsers.js

@@ -0,0 +1,60 @@
+import slash from "slash";
+import * as util from "../../../util";
+
+/**
+ * Get a transformer list from a value.
+ */
+
+export function transformerList(val) {
+  return util.arrayify(val);
+}
+
+/**
+ * Validate transformer list. Maps "all" to all transformer names.
+ */
+
+transformerList.validate = function (key, val, pipeline) {
+  if (val.indexOf("all") >= 0 || val.indexOf(true) >= 0) {
+    val = Object.keys(pipeline.transformers);
+  }
+
+  return pipeline._ensureTransformerNames(key, val);
+};
+
+/**
+ * Cast a value to a number.
+ */
+
+export function number(val) {
+  return +val;
+}
+
+/**
+ * Cast a value to a boolean.
+ */
+
+export var filename = slash;
+
+/**
+ * [Please add a description.]
+ */
+
+export function boolean(val) {
+  return !!val;
+}
+
+/**
+ * Cast a boolean-like string to a boolean.
+ */
+
+export function booleanString(val) {
+  return util.booleanify(val);
+}
+
+/**
+ * Cast a value to an array, splitting strings by ",".
+ */
+
+export function list(val) {
+  return util.list(val);
+}

src/babel/transformation/file/plugin-manager.js

@@ -0,0 +1,160 @@
+import Transformer from "../transformer";
+import Plugin from "../plugin";
+import * as types from "../../types";
+import * as messages from "../../messages";
+import traverse from "../../traversal";
+import parse from "../../helpers/parse";
+
+/**
+ * [Please add a description.]
+ */
+
+var context = {
+  messages,
+  Transformer,
+  Plugin,
+  types,
+  parse,
+  traverse
+};
+
+import * as util from  "../../util";
+
+/**
+ * [Please add a description.]
+ */
+
+export default class PluginManager {
+
+  /**
+   * [Please add a description.]
+   */
+
+  static memoisedPlugins = [];
+
+  /**
+   * [Please add a description.]
+   */
+
+  static memoisePluginContainer(fn) {
+    for (var i = 0; i < PluginManager.memoisedPlugins.length; i++) {
+      var plugin = PluginManager.memoisedPlugins[i];
+      if (plugin.container === fn) return plugin.transformer;
+    }
+
+    var transformer = fn(context);
+    PluginManager.memoisedPlugins.push({
+      container: fn,
+      transformer: transformer
+    });
+    return transformer;
+  }
+
+  /**
+   * [Please add a description.]
+   */
+
+  static positions = ["before", "after"];
+
+  /**
+   * [Please add a description.]
+   */
+
+  constructor({ file, transformers, before, after } = { transformers: {}, before: [], after: [] }) {
+    this.transformers = transformers;
+    this.file         = file;
+    this.before       = before;
+    this.after        = after;
+  }
+
+  /**
+   * [Please add a description.]
+   */
+
+  subnormaliseString(name, position) {
+    // this is a plugin in the form of "foobar" or "foobar:after"
+    // where the optional colon is the delimiter for plugin position in the transformer stack
+
+    var match = name.match(/^(.*?):(after|before)$/);
+    if (match) [, name, position] = match;
+
+    var loc = util.resolveRelative(`babel-plugin-${name}`) || util.resolveRelative(name);
+    if (loc) {
+      var plugin = require(loc);
+      return {
+        position: position,
+        plugin:   plugin.default || plugin
+      };
+    } else {
+      throw new ReferenceError(messages.get("pluginUnknown", name));
+    }
+  }
+
+  /**
+   * [Please add a description.]
+   */
+
+  validate(name, plugin) {
+    // validate transformer key
+    var key = plugin.key;
+    if (this.transformers[key]) {
+      throw new ReferenceError(messages.get("pluginKeyCollision", key));
+    }
+
+    // validate Transformer instance
+    if (!plugin.buildPass || plugin.constructor.name !== "Plugin") {
+      throw new TypeError(messages.get("pluginNotTransformer", name));
+    }
+
+    // register as a plugin
+    plugin.metadata.plugin = true;
+  }
+
+  /**
+   * [Please add a description.]
+   */
+
+  add(name) {
+    var position;
+    var plugin;
+
+    if (name) {
+      if (typeof name === "object" && name.transformer) {
+        ({ transformer: plugin, position } = name);
+      } else if (typeof name !== "string") {
+        // not a string so we'll just assume that it's a direct Transformer instance, if not then
+        // the checks later on will complain
+        plugin = name;
+      }
+
+      if (typeof name === "string") {
+        ({ plugin, position } = this.subnormaliseString(name, position));
+      }
+    } else {
+      throw new TypeError(messages.get("pluginIllegalKind", typeof name, name));
+    }
+
+    // default position
+    position = position || "before";
+
+    // validate position
+    if (PluginManager.positions.indexOf(position) < 0) {
+      throw new TypeError(messages.get("pluginIllegalPosition", position, name));
+    }
+
+    // allow plugin containers to be specified so they don't have to manually require
+    if (typeof plugin === "function") {
+      plugin = PluginManager.memoisePluginContainer(plugin);
+    }
+
+    //
+    this.validate(name, plugin);
+
+    // build!
+    var pass = this.transformers[plugin.key] = plugin.buildPass(this.file);
+    if (pass.canTransform()) {
+      var stack = position === "before" ? this.before : this.after;
+      stack.push(pass);
+    }
+  }
+}

src/babel/transformation/helpers/README.md

@@ -0,0 +1,3 @@
+## Transformation Helpers
+
+This is the Transformation Helpers directory.