v5.6.3

matchPattern fixes and "this" handling

.eslintrc

@@ -3,18 +3,22 @@
   "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
   },
   "env": {
     "node": true

.gitignore

@@ -8,10 +8,10 @@ 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

.gitmodules

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

.travis.yml

@@ -11,9 +11,4 @@ before_script: "npm install -g codeclimate-test-reporter"
 script: "make test-travis"
 
 notifications:
-  webhooks:
-    urls:
-      - https://webhooks.gitter.im/e/acf1870e9d223c65e8d5
-    on_success: always
-    on_failure: always
-    on_start: false
+  slack: babeljs:5Wy4QX13KVkGy9CnU0rmvgeK

CHANGELOG.md

@@ -13,6 +13,280 @@ _Note: Gaps between patch versions are faulty/broken releases._
 
 See [CHANGELOG - 6to5](CHANGELOG-6to5.md) for the pre-4.0.0 version changelog.
 
+## 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**

CONTRIBUTING.md

@@ -1,3 +1,7 @@
+# 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>
    |
@@ -8,6 +12,8 @@
    <strong><a href="#dependencies">Dependencies</a></strong>
    |
    <strong><a href="#code-standards">Code Standards</a></strong>
+   |
+   <strong><a href="#internals">Internals</a></strong>
 </p>
 
 ----
@@ -18,9 +24,11 @@ Contributions are always welcome, no matter how large or small. Before
 contributing, please read the
 [code of conduct](https://github.com/babel/babel/blob/master/CODE_OF_CONDUCT.md).
 
-
 ## 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
@@ -79,7 +87,6 @@ your [`$PATH`](http://unix.stackexchange.com/questions/26047/how-to-correctly-ad
 * 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.
@@ -167,3 +174,6 @@ your [`$PATH`](http://unix.stackexchange.com/questions/26047/how-to-correctly-ad
  * **Declaration**
    * No unused variables
    * No pollution of global variables and prototypes
+
+#### Internals
+Please see [`/doc`](/doc) for internals documentation relevant to developing babel.

Makefile

@@ -5,6 +5,7 @@ UGLIFY_CMD = node_modules/uglify-js/bin/uglifyjs
 #UGLIFY_CMD = node_modules/uglify-js/bin/uglifyjs --mangle sort
 MOCHA_CMD = node_modules/mocha/bin/_mocha
 BABEL_CMD = node_modules/babel/bin/babel
+BROWSERIFY_IGNORE = -i esprima-fb
 
 export NODE_ENV = test
 
@@ -14,7 +15,7 @@ build-core: clean-core
 	node $(BABEL_CMD) src --out-dir lib --copy-files
 
 build-core-test: clean-core
-	node $(BABEL_CMD) src --out-dir lib --copy-files --auxiliary-comment "istanbul ignore next"
+	node $(BABEL_CMD) src --out-dir lib --copy-files --auxiliary-comment-before "istanbul ignore next"
 
 watch-core: clean-core
 	node $(BABEL_CMD) src --out-dir lib --watch --copy-files
@@ -22,6 +23,9 @@ watch-core: clean-core
 clean-core:
 	rm -rf lib
 
+lint:
+	eslint src/babel
+
 build:
 	mkdir -p dist
 	make build-core
@@ -31,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
@@ -61,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
@@ -73,7 +79,7 @@ test-browser:
 
 	test -n "`which open`" && open test/browser.html
 
-publish:
+publish: lint
 	git pull --rebase
 
 	make test
@@ -82,9 +88,15 @@ publish:
 	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
+
+	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
@@ -96,7 +108,7 @@ publish:
 	make publish-cli
 	make publish-runtime
 
-	rm -rf templates.json browser.js browser-polyfill.js external-helpers.js
+	rm -rf templates.json browser.js browser.min.js browser-polyfill.js browser-polyfill.min.js external-helpers.js external-helpers.min.js
 
 publish-runtime:
 	cd packages; \
@@ -116,5 +128,4 @@ bootstrap:
 	npm link
 	cd packages/babel-cli && npm install && npm link && npm link babel-core
 	git submodule update --init
-	cd vendor/compat-table && npm install object-assign
 	make build

README.md

@@ -9,7 +9,11 @@
 </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.
+  For questions and support please visit the <a href="https://babel-slack.herokuapp.com">slack channel</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">
+  Issues without instructions to reproduce <strong>will be immediately closed<strong>.
 </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 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 `this` from the parent scope. It is invoked for arrow functions, for example.

package.json

@@ -1,9 +1,10 @@
 {
   "name": "babel-core",
-  "description": "Turn ES6 code into readable vanilla ES5 with source maps",
-  "version": "5.2.12",
+  "description": "A compiler for writing next generation JavaScript",
+  "version": "5.6.3",
   "author": "Sebastian McKenzie <sebmck@gmail.com>",
   "homepage": "https://babeljs.io/",
+  "license": "MIT",
   "repository": "babel/babel",
   "main": "lib/babel/api/node.js",
   "browser": {
@@ -29,18 +30,33 @@
   "dependencies": {
     "acorn-jsx": "^1.0.0",
     "ast-types": "~0.7.0",
-    "bluebird": "^2.9.25",
+    "babel-plugin-constant-folding": "^1.0.1",
+    "babel-plugin-dead-code-elimination": "^1.0.1",
+    "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.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",
+    "js-tokens": "1.0.1",
     "leven": "^1.0.1",
     "line-numbers": "0.2.0",
     "lodash": "^3.6.0",
@@ -48,7 +64,7 @@
     "output-file-sync": "^1.1.0",
     "path-is-absolute": "^1.0.0",
     "private": "^0.1.6",
-    "regenerator": "^0.8.20",
+    "regenerator": "0.8.30",
     "regexpu": "^1.1.2",
     "repeating": "^1.1.2",
     "resolve": "^1.1.6",
@@ -58,15 +74,14 @@
     "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": "5.1.13",
+    "babel": "5.5.7",
     "browserify": "^9.0.8",
     "chai": "^2.2.0",
-    "eslint": "^0.18.0",
-    "babel-eslint": "^2.0.0",
+    "eslint": "^0.21.2",
+    "babel-eslint": "^3.1.9",
     "esvalid": "^1.1.0",
     "istanbul": "^0.3.5",
     "matcha": "^0.6.0",

packages/babel-cli/bin/_babel-node

@@ -107,6 +107,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,140 @@
+#!/usr/bin/env node
+
+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(__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 (!fs.existsSync("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,5 +1,6 @@
 var outputFileSync = require("output-file-sync");
 var chokidar       = require("chokidar");
+var slash          = require("slash");
 var path           = require("path");
 var util           = require("./util");
 var fs             = require("fs");
@@ -13,8 +14,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";

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

@@ -1,6 +1,7 @@
 var convertSourceMap = require("convert-source-map");
 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 +16,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 = "";
@@ -27,11 +29,12 @@ module.exports = function (commander, filenames, opts) {
 
       if (result.map) {
         var consumer = new sourceMap.SourceMapConsumer(result.map);
-        var sourceFilename = filename;
 
+        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);
@@ -114,7 +117,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();

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

@@ -6,6 +6,7 @@ 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 fs               = require("fs");
@@ -35,7 +36,7 @@ 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");
@@ -51,7 +52,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);
     });
@@ -70,12 +71,22 @@ commander.parse(process.argv);
 
 //
 
+if (commander.extensions) {
+  commander.extensions = util.arrayify(commander.extensions);
+}
+
+//
+
 var errors = [];
 
 var filenames = commander.args.reduce(function (globbed, input) {
-  return globbed.concat(glob.sync(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)) {
     errors.push(filename + " doesn't exist");
@@ -110,11 +121,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) {
@@ -37,6 +38,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,13 +1,14 @@
 {
   "name": "babel",
   "description": "Turn ES6 code into readable vanilla ES5 with source maps",
-  "version": "5.2.11",
+  "version": "5.6.2",
   "author": "Sebastian McKenzie <sebmck@gmail.com>",
   "homepage": "https://babeljs.io/",
+  "license": "MIT",
   "repository": "babel/babel",
   "preferGlobal": true,
   "dependencies": {
-    "babel-core": "^5.2.11",
+    "babel-core": "^5.6.2",
     "chokidar": "^1.0.0",
     "commander": "^2.6.0",
     "convert-source-map": "^1.1.0",
@@ -16,11 +17,13 @@
     "lodash": "^3.2.0",
     "output-file-sync": "^1.1.0",
     "path-is-absolute": "^1.0.0",
-    "source-map": "^0.4.0"
+    "source-map": "^0.4.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-runtime/package.json

@@ -1,7 +1,8 @@
 {
   "name": "babel-runtime",
   "description": "babel selfContained runtime",
-  "version": "5.2.11",
+  "version": "5.6.2",
+  "license": "MIT",
   "repository": "babel/babel",
   "author": "Sebastian McKenzie <sebmck@gmail.com>",
   "dependencies": {

packages/build-runtime.js

@@ -75,7 +75,7 @@ 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"];
 

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/acorn/plugins/flow.js

@@ -153,10 +153,15 @@ pp.flow_parseTypeAlias = function (node) {
     node.typeParameters = null
   }
 
+  var oldInType = this.inType;
+  this.inType = true;
+
   this.expect(tt.eq)
 
   node.right = this.flow_parseType()
 
+  this.inType = oldInType;
+
   this.semicolon()
 
   return this.finishNode(node, "TypeAlias")
@@ -410,6 +415,9 @@ pp.flow_identToTypeAnnotation = function (start, node, id) {
     case "boolean":
       return this.finishNode(node, "BooleanTypeAnnotation")
 
+    case "mixed":
+      return this.finishNode(node, "MixedTypeAnnotation")
+
     case "number":
       return this.finishNode(node, "NumberTypeAnnotation")
 

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"
@@ -214,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)
@@ -240,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 `()`, `[]`,
@@ -248,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()
@@ -262,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")
     }
 
@@ -274,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)
@@ -363,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()
   }
@@ -472,9 +510,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")
 }
@@ -484,7 +524,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()
@@ -580,6 +620,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) {
@@ -605,12 +653,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.
@@ -632,7 +680,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/lookahead.js

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

src/acorn/src/lval.js

@@ -35,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.")
       }
@@ -171,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)
@@ -194,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/state.js

@@ -1,5 +1,6 @@
 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

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,6 +473,7 @@ 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 = []
@@ -483,16 +488,14 @@ pp.parseClass = function(node, isStatement) {
       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))
@@ -503,23 +506,39 @@ 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 (decorators.length) {
     this.raise(this.start, "You have trailing decorators with no method");
@@ -574,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")]

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),

src/babel/api/browser.js

@@ -1,3 +1,5 @@
+/* eslint no-new-func: 0 */
+
 require("./node");
 var transform = module.exports = require("../transformation");
 

src/babel/api/node.js

@@ -8,9 +8,10 @@ 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 TransformerPipeline } from "../transformation/transformer-pipeline";
+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";
@@ -61,8 +62,8 @@ export function parse(code, opts = {}) {
   opts.sourceType = "module";
   opts.ecmaVersion = Infinity;
   opts.plugins = {
-    flow: true,
-    jsx:  true
+    jsx:  true,
+    flow: true
   };
   opts.features = {};
 

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,9 +1,8 @@
 import path from "path";
-import os from "os";
 import fs from "fs";
-import userHome from "user-home";
+import homeOrTmp from "home-or-tmp";
 
-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 = {};
 
 export function save() {

src/babel/api/register/node.js

@@ -1,12 +1,12 @@
 import sourceMapSupport from "source-map-support";
 import * as registerCache from "./cache";
-import resolveRc from "../../tools/resolve-rc";
+import resolveRc from "../../transformation/file/options/resolve-rc";
 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 slash from "slash";
+import path from "path";
 
 sourceMapSupport.install({
   handleUncaughtExceptions: false,
@@ -38,14 +38,20 @@ var only;
 var oldHandlers   = {};
 var maps          = {};
 
+var cwd = process.cwd();
+
+var getRelativePath = function (filename){
+  return path.relative(cwd, filename);
+};
+
 var mtime = function (filename) {
   return +fs.statSync(filename).mtime;
 };
 
-var compile = function (filename) {
+var compile = function (filename, opts = {}) {
   var result;
 
-  var opts = extend({}, transformOpts);
+  opts = extend(opts, transformOpts);
 
   // this will be done when the file is transformed anyway but we need all
   // the options so we can generate the cache key
@@ -53,6 +59,9 @@ var compile = function (filename) {
 
   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)) {
@@ -79,9 +88,9 @@ var compile = function (filename) {
 
 var shouldIgnore = function (filename) {
   if (!ignore && !only) {
-    return /node_modules/.test(filename);
+    return getRelativePath(filename).split(path.sep).indexOf("node_modules") >= 0;
   } else {
-    return util.shouldIgnore(filename, ignore || [], only || []);
+    return util.shouldIgnore(filename, ignore || [], only);
   }
 };
 
@@ -95,7 +104,9 @@ if (process.env.running_under_istanbul) {
   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 {
@@ -114,7 +125,7 @@ var normalLoader = function (m, filename) {
 };
 
 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;
@@ -161,4 +172,4 @@ export default function (opts = {}) {
   delete opts.only;
 
   extend(transformOpts, opts);
-};
+}

src/babel/generation/buffer.js

@@ -117,8 +117,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) {

src/babel/generation/generators/base.js

@@ -1,5 +1,5 @@
 export function File(node, print) {
-  print(node.program);
+  print.plain(node.program);
 }
 
 export function Program(node, print) {
@@ -17,3 +17,7 @@ export function BlockStatement(node, print) {
     this.rightBrace();
   }
 }
+
+export function Noop() {
+
+}

src/babel/generation/generators/classes.js

@@ -3,16 +3,16 @@ export function ClassDeclaration(node, print) {
   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,7 +21,7 @@ export function ClassDeclaration(node, print) {
   }
 
   this.space();
-  print(node.body);
+  print.plain(node.body);
 }
 
 export { ClassDeclaration as ClassExpression };
@@ -46,13 +46,13 @@ export function ClassProperty(node, print) {
   print.list(node.decorators);
 
   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();
 }

src/babel/generation/generators/comprehensions.js

@@ -1,9 +1,9 @@
 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(")");
 }
 
@@ -16,12 +16,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,4 +1,3 @@
-import isInteger from "is-integer";
 import isNumber from "lodash/lang/isNumber";
 import * as t from "../../types";
 
@@ -16,40 +15,40 @@ export function UnaryExpression(node, print) {
 
   this.push(node.operator);
   if (hasSpace) this.push(" ");
-  print(node.argument);
+  print.plain(node.argument);
 }
 
 export function DoExpression(node, print) {
   this.push("do");
   this.space();
-  print(node.body);
+  print.plain(node.body);
 }
 
 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);
   }
 }
 
 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);
 }
 
 export function NewExpression(node, print) {
   this.push("new ");
-  print(node.callee);
+  print.plain(node.callee);
   this.push("(");
   print.list(node.arguments);
   this.push(")");
@@ -69,17 +68,20 @@ export function Super() {
 
 export function Decorator(node, print) {
   this.push("@");
-  print(node.expression);
+  print.plain(node.expression);
+  this.newline();
 }
 
 export function CallExpression(node, print) {
-  print(node.callee);
+  print.plain(node.callee);
 
   this.push("(");
 
   var separator = ",";
 
-  if (node._prettyCall) {
+  var isPrettyCall = node._prettyCall && !this.format.retainLines;
+
+  if (isPrettyCall) {
     separator += "\n";
     this.newline();
     this.indent();
@@ -89,7 +91,7 @@ export function CallExpression(node, print) {
 
   print.list(node.arguments, { separator: separator });
 
-  if (node._prettyCall) {
+  if (isPrettyCall) {
     this.newline();
     this.dedent();
   }
@@ -106,8 +108,8 @@ var buildYieldAwait = function (keyword) {
     }
 
     if (node.argument) {
-      this.space();
-      print(node.argument);
+      this.push(" ");
+      print.plain(node.argument);
     }
   };
 };
@@ -120,30 +122,39 @@ export function EmptyStatement() {
 }
 
 export function ExpressionStatement(node, print) {
-  print(node.expression);
+  print.plain(node.expression);
   this.semicolon();
 }
 
+export function AssignmentPattern(node, print) {
+  print.plain(node.left);
+  this.push(" = ");
+  print.plain(node.right);
+}
+
 export function AssignmentExpression(node, print) {
   // todo: add cases where the spaces can be dropped when in compact mode
-  print(node.left);
+  print.plain(node.left);
   this.push(" ");
   this.push(node.operator);
   this.push(" ");
-  print(node.right);
+  print.plain(node.right);
+}
+
+export function BindExpression(node, print) {
+  print.plain(node.object);
+  this.push("::");
+  print.plain(node.callee);
 }
 
 export {
   AssignmentExpression as BinaryExpression,
-  AssignmentExpression as LogicalExpression,
-  AssignmentExpression as AssignmentPattern
+  AssignmentExpression as LogicalExpression
 };
 
-var SCIENTIFIC_NOTATION = /e/i;
-
 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 +167,16 @@ 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);
   }
 }
 
 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

@@ -5,7 +5,7 @@ export function AnyTypeAnnotation() {
 }
 
 export function ArrayTypeAnnotation(node, print) {
-  print(node.elementType);
+  print.plain(node.elementType);
   this.push("[");
   this.push("]");
 }
@@ -21,27 +21,27 @@ export function DeclareClass(node, print) {
 
 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();
 }
 
 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);
 }
 
 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();
 }
 
 export function FunctionTypeAnnotation(node, print, parent) {
-  print(node.typeParameters);
+  print.plain(node.typeParameters);
   this.push("(");
   print.list(node.params);
 
@@ -51,7 +51,7 @@ export function FunctionTypeAnnotation(node, print, parent) {
       this.space();
     }
     this.push("...");
-    print(node.rest);
+    print.plain(node.rest);
   }
 
   this.push(")");
@@ -65,33 +65,33 @@ export function FunctionTypeAnnotation(node, print, parent) {
   }
 
   this.space();
-  print(node.returnType);
+  print.plain(node.returnType);
 }
 
 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);
 }
 
 export function InterfaceExtends(node, print) {
-  print(node.id);
-  print(node.typeParameters);
+  print.plain(node.id);
+  print.plain(node.typeParameters);
 }
 
 export { InterfaceExtends as ClassImplements, InterfaceExtends as GenericTypeAnnotation };
 
 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);
 }
 
 export function InterfaceDeclaration(node, print) {
@@ -103,9 +103,13 @@ export function IntersectionTypeAnnotation(node, print) {
   print.join(node.types, { separator: " & " });
 }
 
+export function MixedTypeAnnotation() {
+  this.push("mixed");
+}
+
 export function NullableTypeAnnotation(node, print) {
   this.push("?");
-  print(node.typeAnnotation);
+  print.plain(node.typeAnnotation);
 }
 
 export function NumberTypeAnnotation() {
@@ -128,17 +132,17 @@ export function TupleTypeAnnotation(node, print) {
 
 export function TypeofTypeAnnotation(node, print) {
   this.push("typeof ");
-  print(node.argument);
+  print.plain(node.argument);
 }
 
 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();
 }
 
@@ -146,7 +150,7 @@ export function TypeAnnotation(node, print) {
   this.push(":");
   this.space();
   if (node.optional) this.push("?");
-  print(node.typeAnnotation);
+  print.plain(node.typeAnnotation);
 }
 
 export function TypeParameterInstantiation(node, print) {
@@ -183,37 +187,37 @@ export function ObjectTypeAnnotation(node, print) {
 
 export function ObjectTypeCallProperty(node, print) {
   if (node.static) this.push("static ");
-  print(node.value);
+  print.plain(node.value);
 }
 
 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);
 }
 
 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);
 }
 
 export function QualifiedTypeIdentifier(node, print) {
-  print(node.qualification);
+  print.plain(node.qualification);
   this.push(".");
-  print(node.id);
+  print.plain(node.id);
 }
 
 export function UnionTypeAnnotation(node, print) {
@@ -222,8 +226,8 @@ export function UnionTypeAnnotation(node, print) {
 
 export function TypeCastExpression(node, print) {
   this.push("(");
-  print(node.expression);
-  print(node.typeAnnotation);
+  print.plain(node.expression);
+  print.plain(node.typeAnnotation);
   this.push(")");
 }
 

src/babel/generation/generators/jsx.js

@@ -1,11 +1,10 @@
-import each from "lodash/collection/each";
 import * as t from "../../types";
 
 export function JSXAttribute(node, print) {
-  print(node.name);
+  print.plain(node.name);
   if (node.value) {
     this.push("=");
-    print(node.value);
+    print.plain(node.value);
   }
 }
 
@@ -14,50 +13,50 @@ export function JSXIdentifier(node) {
 }
 
 export function JSXNamespacedName(node, print) {
-  print(node.namespace);
+  print.plain(node.namespace);
   this.push(":");
-  print(node.name);
+  print.plain(node.name);
 }
 
 export function JSXMemberExpression(node, print) {
-  print(node.object);
+  print.plain(node.object);
   this.push(".");
-  print(node.property);
+  print.plain(node.property);
 }
 
 export function JSXSpreadAttribute(node, print) {
   this.push("{...");
-  print(node.argument);
+  print.plain(node.argument);
   this.push("}");
 }
 
 export function JSXExpressionContainer(node, print) {
   this.push("{");
-  print(node.expression);
+  print.plain(node.expression);
   this.push("}");
 }
 
 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, true);
     } else {
-      print(child);
+      print.plain(child);
     }
-  });
+  }
   this.dedent();
 
-  print(node.closingElement);
+  print.plain(node.closingElement);
 }
 
 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: " " });
@@ -67,7 +66,7 @@ export function JSXOpeningElement(node, print) {
 
 export function JSXClosingElement(node, print) {
   this.push("</");
-  print(node.name);
+  print.plain(node.name);
   this.push(">");
 }
 

src/babel/generation/generators/methods.js

@@ -1,18 +1,18 @@
 import * as t from "../../types";
 
 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);
   }
 }
 
@@ -35,15 +35,15 @@ 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);
+  print.plain(value.body);
 }
 
 export function FunctionExpression(node, print) {
@@ -53,14 +53,14 @@ 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);
 }
 
 export { FunctionExpression as FunctionDeclaration };
@@ -69,7 +69,7 @@ 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 +82,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,43 +1,42 @@
-import each from "lodash/collection/each";
 import * as t from "../../types";
 
 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);
   }
 }
 
 export function ImportDefaultSpecifier(node, print) {
-  print(node.local);
+  print.plain(node.local);
 }
 
 export function ExportDefaultSpecifier(node, print) {
-  print(node.exported);
+  print.plain(node.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);
   }
 }
 
 export function ExportNamespaceSpecifier(node, print) {
   this.push("* as ");
-  print(node.exported);
+  print.plain(node.exported);
 }
 
 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();
 }
 
@@ -56,14 +55,14 @@ function ExportDeclaration(node, print) {
 
   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,7 +80,7 @@ function ExportDeclaration(node, print) {
 
     if (node.source) {
       this.push(" from ");
-      print(node.source);
+      print.plain(node.source);
     }
   }
 
@@ -99,7 +98,7 @@ export function ImportDeclaration(node, print) {
   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 +106,20 @@ 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();
 }
 
 export function ImportNamespaceSpecifier(node, print) {
   this.push("* as ");
-  print(node.local);
+  print.plain(node.local);
 }

src/babel/generation/generators/statements.js

@@ -4,7 +4,7 @@ import * as t from "../../types";
 export function WithStatement(node, print) {
   this.keyword("with");
   this.push("(");
-  print(node.object);
+  print.plain(node.object);
   this.push(")");
   print.block(node.body);
 }
@@ -12,7 +12,7 @@ export function WithStatement(node, print) {
 export function IfStatement(node, print) {
   this.keyword("if");
   this.push("(");
-  print(node.test);
+  print.plain(node.test);
   this.push(")");
   this.space();
 
@@ -29,18 +29,18 @@ 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);
+    print.plain(node.test);
   }
   this.push(";");
 
   if (node.update) {
     this.push(" ");
-    print(node.update);
+    print.plain(node.update);
   }
 
   this.push(")");
@@ -50,7 +50,7 @@ export function ForStatement(node, print) {
 export function WhileStatement(node, print) {
   this.keyword("while");
   this.push("(");
-  print(node.test);
+  print.plain(node.test);
   this.push(")");
   print.block(node.body);
 }
@@ -59,9 +59,9 @@ 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);
   };
@@ -72,11 +72,11 @@ export var ForOfStatement = buildForXStatement("of");
 
 export function DoWhileStatement(node, print) {
   this.push("do ");
-  print(node.body);
+  print.plain(node.body);
   this.space();
   this.keyword("while");
   this.push("(");
-  print(node.test);
+  print.plain(node.test);
   this.push(");");
 }
 
@@ -87,7 +87,7 @@ var buildLabelStatement = function (prefix, key) {
     var label = node[key || "label"];
     if (label) {
       this.push(" ");
-      print(label);
+      print.plain(label);
     }
 
     this.semicolon();
@@ -99,50 +99,50 @@ export var ReturnStatement   = buildLabelStatement("return", "argument");
 export var BreakStatement    = buildLabelStatement("break");
 
 export function LabeledStatement(node, print) {
-  print(node.label);
+  print.plain(node.label);
   this.push(": ");
-  print(node.body);
+  print.plain(node.body);
 }
 
 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);
   }
 }
 
 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);
 }
 
 export function ThrowStatement(node, print) {
   this.push("throw ");
-  print(node.argument);
+  print.plain(node.argument);
   this.semicolon();
 }
 
 export function SwitchStatement(node, print) {
   this.keyword("switch");
   this.push("(");
-  print(node.discriminant);
+  print.plain(node.discriminant);
   this.push(")");
   this.space();
   this.push("{");
@@ -160,7 +160,7 @@ export function SwitchStatement(node, print) {
 export function SwitchCase(node, print) {
   if (node.test) {
     this.push("case ");
-    print(node.test);
+    print.plain(node.test);
     this.push(":");
   } else {
     this.push("default:");
@@ -182,8 +182,8 @@ export function VariableDeclaration(node, print, parent) {
   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;
       }
@@ -191,7 +191,7 @@ export function VariableDeclaration(node, print, parent) {
   }
 
   var sep = ",";
-  if (!this.format.compact && hasInits) {
+  if (!this.format.compact && !this.format.concise && hasInits && !this.format.retainLines) {
     sep += `\n${repeating(" ", node.kind.length + 1)}`;
   } else {
     sep += " ";
@@ -207,12 +207,12 @@ export function VariableDeclaration(node, print, parent) {
 }
 
 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,8 +1,6 @@
-import each from "lodash/collection/each";
-
 export function TaggedTemplateExpression(node, print) {
-  print(node.tag);
-  print(node.quasi);
+  print.plain(node.tag);
+  print.plain(node.quasi);
 }
 
 export function TemplateElement(node) {
@@ -15,15 +13,15 @@ export function TemplateLiteral(node, print) {
   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,4 +1,7 @@
-import each from "lodash/collection/each";
+/* eslint quotes: 0 */
+
+import isInteger from "is-integer";
+import * as t from "../../types";
 
 export function Identifier(node) {
   this.push(node.name);
@@ -6,7 +9,7 @@ export function Identifier(node) {
 
 export function RestElement(node, print) {
   this.push("...");
-  print(node.argument);
+  print.plain(node.argument);
 }
 
 export { RestElement as SpreadElement, RestElement as SpreadProperty };
@@ -35,16 +38,29 @@ export function Property(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);
   }
 }
 
@@ -54,7 +70,8 @@ export function ArrayExpression(node, print) {
 
   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
@@ -64,24 +81,39 @@ export function ArrayExpression(node, print) {
       this.push(",");
     } else {
       if (i > 0) this.push(" ");
-      print(elem);
+      print.plain(elem);
       if (i < len - 1) this.push(",");
     }
-  });
+  }
 
   this.push("]");
 }
 
 export { ArrayExpression as ArrayPattern };
 
-export function Literal(node) {
+const SCIENTIFIC_NOTATION = /e/i;
+
+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) {
@@ -100,9 +132,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";
@@ -20,7 +21,7 @@ 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);
@@ -67,7 +68,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] === "'") {
@@ -77,6 +77,7 @@ class CodeGenerator {
       }
 
       checked++;
+      if (checked >= 3) break;
     }
 
     if (occurences.single > occurences.double) {
@@ -105,11 +106,13 @@ class CodeGenerator {
 
     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(),
@@ -118,40 +121,15 @@ class CodeGenerator {
   }
 
   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);
   }
 
-  catchUp(node, parent) {
+  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 (parent && this.position.line < node.loc.start.line && t.isTerminatorless(parent)) {
+      if (!leftParenPrinted && parent &&
+          this.position.line < node.loc.start.line && t.isTerminatorless(parent)) {
         needsParens = true;
         this._push("(");
       }
@@ -163,6 +141,36 @@ class CodeGenerator {
     return false;
   }
 
+  _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);
+  }
+
   print(node, parent, opts = {}) {
     if (!node) return;
 
@@ -175,36 +183,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);
@@ -214,9 +192,9 @@ class CodeGenerator {
 
       this.printLeadingComments(node, parent);
 
-      var needsParensFromCatchup = this.catchUp(node, parent);
+      var needsParensFromCatchup = this.catchUp(node, parent, needsParens);
 
-      newline(true);
+      this._printNewline(true, node, parent, opts);
 
       if (opts.before) opts.before();
       this.map.mark(node, "start");
@@ -234,7 +212,7 @@ class CodeGenerator {
 
       this.format.concise = oldConcise;
 
-      newline(false);
+      this._printNewline(false, node, parent, opts);
 
       this.printTrailingComments(node, parent);
     } else {
@@ -249,21 +227,24 @@ 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();
   }
@@ -271,7 +252,7 @@ class CodeGenerator {
   printAndIndentOnComments(print, node) {
     var indent = !!node.leadingComments;
     if (indent) this.indent();
-    print(node);
+    print.plain(node);
     if (indent) this.dedent();
   }
 
@@ -280,13 +261,13 @@ class CodeGenerator {
       this.semicolon();
     } else {
       this.push(" ");
-      print(node);
+      print.plain(node);
     }
   }
 
   generateComment(comment) {
     var val = comment.value;
-    if (comment.type === "Line") {
+    if (comment.type === "CommentLine") {
       val = `//${val}`;
     } else {
       val = `/*${val}*/`;
@@ -314,9 +295,9 @@ class CodeGenerator {
       nodes.push(node.argument);
     }
 
-    each(nodes, (node) => {
+    for (let node of (nodes: Array)) {
       comments = comments.concat(this._getComments(key, node));
-    });
+    }
 
     return comments;
   }
@@ -327,23 +308,24 @@ class CodeGenerator {
 
   _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;
 
@@ -361,8 +343,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");
@@ -378,7 +360,7 @@ class CodeGenerator {
 
       // 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 === "Line") {
+      if (this.format.retainLines && comment.type === "CommentLine") {
         val += "\n";
       }
 
@@ -387,7 +369,7 @@ class CodeGenerator {
 
       // whitespace after
       this.newline(this.whitespace.getNewlinesAfter(comment));
-    });
+    }
   }
 }
 

src/babel/generation/node/printer.js

@@ -0,0 +1,32 @@
+export default class NodePrinter {
+  constructor(generator, parent) {
+    this.generator = generator;
+    this.parent = parent;
+  }
+
+  plain(node, opts) {
+    return this.generator.print(node, this.parent, opts);
+  }
+
+  sequence(nodes, opts = {}) {
+    opts.statement = true;
+    return this.generator.printJoin(this, nodes, opts);
+  }
+
+  join(nodes, opts) {
+    return this.generator.printJoin(this, nodes, opts);
+  }
+
+  list(items, opts = {}) {
+    if (opts.separator == null) opts.separator = ", ";
+    return this.join(items, opts);
+  }
+
+  block(node) {
+    return this.generator.printBlock(this, node);
+  }
+
+  indentOnComments(node) {
+    return this.generator.printAndIndentOnComments(this, node);
+  }
+}

src/babel/generation/source-map.js

@@ -8,7 +8,7 @@ export default class SourceMap {
 
     if (opts.sourceMaps) {
       this.map = new sourceMap.SourceMapGenerator({
-        file: opts.sourceMapName,
+        file: opts.sourceMapTarget,
         sourceRoot: opts.sourceRoot
       });
 

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.
@@ -21,8 +19,8 @@ function getLookupIndex(i, base, max) {
 }
 
 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
@@ -40,12 +38,11 @@ export default class Whitespace {
     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) {
@@ -64,17 +61,17 @@ export default class Whitespace {
     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 +82,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 {

src/babel/helpers/code-frame.js

@@ -79,10 +79,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,17 @@
+import merge from "lodash/object/merge";
+
+export default function (dest, src) {
+  if (!dest || !src) return;
+
+  return merge(dest, src, function(a, b) {
+    if (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

@@ -6,4 +6,4 @@ export default function (ast, comments, tokens) {
   } else {
     throw new Error("Not a valid ast?");
   }
-};
+}

src/babel/helpers/object.js

@@ -1,3 +1,3 @@
 export default function () {
   return Object.create(null);
-};
+}

src/babel/helpers/parse.js

@@ -3,8 +3,9 @@ import estraverse from "estraverse";
 import * as acorn from "../../acorn";
 
 export default function (code, opts = {}) {
-  var comments = [];
-  var tokens   = [];
+  var commentsAndTokens = [];
+  var comments          = [];
+  var tokens            = [];
 
   var parseOpts = {
     allowImportExportEverywhere: opts.looseModules,
@@ -14,21 +15,38 @@ export default function (code, opts = {}) {
     strictMode:                  opts.strictMode,
     sourceType:                  opts.sourceType,
     locations:                   true,
-    onComment:                   comments,
     features:                    opts.features || {},
     plugins:                     opts.plugins || {},
     onToken:                     tokens,
     ranges:                      true
   };
 
+  parseOpts.onToken = function (token) {
+    tokens.push(token);
+    commentsAndTokens.push(token);
+  };
+
+  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]
+    };
+
+    commentsAndTokens.push(comment);
+    comments.push(comment);
+  };
+
   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, tokens);
+  ast = normalizeAst(ast, comments, commentsAndTokens);
   return ast;
 }

src/babel/messages.js

@@ -5,36 +5,39 @@ export const MESSAGES = {
   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",
+  lostTrackNodePath: "We lost track of this nodes 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: "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 }`?",
-  traverseVerifyVisitorFunction: "Hey! You passed \`traverse()\` a visitor object with the key $1 that's a straight up `Function` instead of `{ enter: Function }`. You need to normalise it with `traverse.explode(visitor)`.",
   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 Transformer instance",
+  pluginNotTransformer: "The plugin $1 didn't export a Plugin instance",
   pluginUnknown: "Unknown plugin $1",
 
-  transformerNotFile: "Transformer $1 is resolving to a different Babel version to what is doing the actual transformation..."
+  pluginNotFile: "Plugin $1 is resolving to a different Babel version to what is doing the actual transformation..."
 };
 
 export function get(key: String, ...args) {

src/babel/patch.js

@@ -17,6 +17,8 @@ var or  = types.Type.or;
 //  .build("program")
 //  .field("program", def("Program"));
 
+def("Noop");
+
 def("AssignmentPattern")
   .bases("Pattern")
   .build("left", "right")
@@ -33,6 +35,9 @@ def("DoExpression")
   .build("body")
   .field("body", [def("Statement")]);
 
+def("Super")
+  .bases("Expression");
+
 def("ExportDefaultDeclaration")
   .bases("Declaration")
   .build("declaration")
@@ -69,4 +74,10 @@ def("ExportAllDeclaration")
   .field("exported", def("Identifier"))
   .field("source", def("Literal"));
 
+def("BindExpression")
+  .bases("Expression")
+  .build("object", "callee")
+  .field("object", or(def("Expression"), null))
+  .field("callee", def("Expression"));
+
 types.finalize();

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

@@ -83,4 +83,4 @@ export default function (whitelist, outputType = "global") {
   }
 
   return generator(tree).code;
-};
+}

src/babel/transformation/file/index.js

@@ -1,14 +1,13 @@
+import { validateOption, normaliseOptions, config as optionsConfig } from "./options";
 import convertSourceMap from "convert-source-map";
-import * as optionParsers from "./option-parsers";
 import moduleFormatters from "../modules";
 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 resolveRc from "./options/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";
@@ -16,31 +15,20 @@ 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 merge from "../../helpers/merge";
 import slash from "slash";
 import clone from "lodash/lang/clone";
+import Hub from "../../traversal/hub";
 import * as util from  "../../util";
-import * as api from  "../../api/node";
 import path from "path";
-import each from "lodash/collection/each";
 import * as t from "../../types";
 
-var checkTransformerVisitor = {
-  exit(node, parent, scope, state) {
-    checkPath(state.stack, this);
-  }
-};
-
-function checkPath(stack, path) {
-  each(stack, function (pass) {
-    if (pass.shouldRun || pass.ran) return;
-    pass.checkPath(path);
-  });
-}
-
 export default class File {
   constructor(opts = {}, pipeline) {
+    this.transformerDependencies = {};
+
     this.dynamicImportTypes = {};
     this.dynamicImportIds   = {};
     this.dynamicImports     = [];
@@ -49,14 +37,26 @@ export default class File {
     this.usedHelpers  = {};
     this.dynamicData  = {};
     this.data         = {};
-    this.uids         = {};
+
+    this.metadata = {
+      modules: {
+        imports: [],
+        exports: {
+          exported: [],
+          specifiers: []
+        }
+      }
+    };
 
     this.pipeline = pipeline;
     this.log      = new Logger(this, opts.filename || "unknown");
-    this.opts     = this.normalizeOptions(opts);
     this.ast      = {};
 
+    this.normaliseOptions(opts);
+
     this.buildTransformers();
+
+    this.hub = new Hub(this);
   }
 
   static helpers = [
@@ -96,24 +96,21 @@ export default class File {
     "interop-require",
   ];
 
-  static soloHelpers = [
-    "ludicrous-proxy-create",
-    "ludicrous-proxy-directory"
-  ];
+  static soloHelpers = [];
 
-  static options = require("./options");
+  static options = optionsConfig;
 
-  normalizeOptions(opts: Object) {
-    opts = assign({}, opts);
+  normaliseOptions(opts: Object) {
+    opts = this.opts = normaliseOptions(assign({}, opts));
 
+    // resolve babelrc
     if (opts.filename) {
       var rcFilename = opts.filename;
       if (!isAbsolute(rcFilename)) rcFilename = path.join(process.cwd(), rcFilename);
       opts = resolveRc(rcFilename, opts);
     }
 
-    //
-
+    // check for unknown options
     for (let key in opts) {
       if (key[0] === "_") continue;
 
@@ -121,23 +118,30 @@ export default class File {
       if (!option) this.log.error(`Unknown option: ${key}`, ReferenceError);
     }
 
+    // merge in environment options
+    var envKey = process.env.BABEL_ENV || process.env.NODE_ENV || "development";
+    if (opts.env) merge(opts, normaliseOptions(opts.env[envKey]));
+
+    // normalise options
     for (let key in File.options) {
       let option = File.options[key];
+      var val    = opts[key];
 
-      var val = opts[key];
+      // optional
       if (!val && option.optional) continue;
 
+      // deprecated
       if (val && option.deprecated) {
-        throw new Error("Deprecated option " + key + ": " + option.deprecated);
+        this.log.deprecate("Deprecated option " + key + ": " + option.deprecated);
       }
 
-      if (val == null) {
-        val = clone(option.default);
-      }
+      // default
+      if (val == null) val = clone(option.default);
 
-      var optionParser = optionParsers[option.type];
-      if (optionParser) val = optionParser(key, val, this.pipeline);
+      // validate
+      if (val) val = validateOption(key, val, this.pipeline);
 
+      // aaliases
       if (option.alias) {
         opts[option.alias] = opts[option.alias] || val;
       } else {
@@ -162,7 +166,10 @@ 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
@@ -178,7 +185,7 @@ export default class File {
 
     defaults(opts, {
       sourceFileName: opts.filenameRelative,
-      sourceMapName:  opts.filenameRelative
+      sourceMapTarget:  opts.filenameRelative
     });
 
     //
@@ -203,8 +210,9 @@ export default class File {
     var stack = [];
 
     // build internal transformers
-    each(this.pipeline.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);
@@ -217,7 +225,7 @@ export default class File {
           transformer.manipulateOptions(file.opts, file);
         }
       }
-    });
+    }
 
     // init plugins!
     var beforePlugins = [];
@@ -233,8 +241,54 @@ export default class File {
     }
     stack = beforePlugins.concat(stack, afterPlugins);
 
-    // register
-    this.transformerStack = stack.concat(secondaryStack);
+    // build transformer stack
+    this.uncollapsedTransformerStack = stack = stack.concat(secondaryStack);
+
+    // build dependency graph
+    for (let pass of (stack: Array)) {
+      for (var dep of (pass.plugin.dependencies: Array)) {
+        this.transformerDependencies[dep] = pass.key;
+      }
+    }
+
+    // collapse stack categories
+    this.transformerStack = this.collapseStack(stack);
+  }
+
+  collapseStack(_stack) {
+    var stack  = [];
+    var ignore = [];
+
+    for (let pass of (_stack: Array)) {
+      // been merged
+      if (ignore.indexOf(pass) >= 0) continue;
+
+      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);
+        }
+      }
+
+      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 stack;
   }
 
   set(key: string, val): any {
@@ -281,7 +335,7 @@ export default class File {
       }
 
       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);
@@ -292,14 +346,24 @@ export default class File {
   }
 
   attachAuxiliaryComment(node: Object): Object {
-    var comment = this.opts.auxiliaryComment;
-    if (comment) {
+    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;
   }
 
@@ -310,8 +374,6 @@ export default class File {
       throw new ReferenceError(`Unknown helper ${name}`);
     }
 
-    var program = this.ast.program;
-
     var declar = this.declarations[name];
     if (declar) return declar;
 
@@ -337,6 +399,7 @@ export default class File {
       ref._generated = true;
       ref.id = uid;
       ref.type = "FunctionDeclaration";
+      this.attachAuxiliaryComment(ref);
       this.path.unshiftContainer("body", ref);
     } else {
       ref._compact = true;
@@ -351,27 +414,16 @@ export default class File {
   }
 
   errorWithNode(node, msg, Error = SyntaxError) {
-    var loc = node.loc.start;
-    var err = new Error(`Line ${loc.line}: ${msg}`);
-    err.loc = loc;
-    return err;
-  }
-
-  checkPath(path) {
-    if (Array.isArray(path)) {
-      for (var i = 0; i < path.length; i++) {
-        this.checkPath(path[i]);
-      }
-      return;
+    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.");
     }
-
-    var stack = this.transformerStack;
-
-    checkPath(stack, path);
-
-    path.traverse(checkTransformerVisitor, {
-      stack: stack
-    });
+    return err;
   }
 
   mergeSourceMap(map: Object) {
@@ -388,7 +440,7 @@ export default class File {
       outputMapGenerator.applySourceMap(inputMapConsumer);
 
       var mergedMap = outputMapGenerator.toJSON();
-      mergedMap.sources = inputMap.sources
+      mergedMap.sources = inputMap.sources;
       mergedMap.file    = inputMap.file;
       return mergedMap;
     }
@@ -398,6 +450,10 @@ export default class File {
 
 
   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) {
@@ -441,19 +497,15 @@ export default class File {
   }
 
   _addAst(ast) {
-    this.path  = TraversalPath.get(null, null, ast, ast, "program", this);
+    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();
-          }
-        }
-      }
-    });
   }
 
   addAst(ast) {
@@ -461,22 +513,22 @@ export default class File {
     this._addAst(ast);
     this.log.debug("End set AST");
 
-    this.log.debug("Start prepass");
-    this.checkPath(this.path);
-    this.log.debug("End prepass");
-
     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.log.debug("End module formatter init");
+  }
 
+  transform() {
     this.call("pre");
-    each(this.transformerStack, function (pass) {
+    for (var pass of (this.transformerStack: Array)) {
       pass.transform();
-    });
+    }
     this.call("post");
+
+    return this.generate();
   }
 
   wrap(code, callback) {
@@ -484,17 +536,10 @@ export default class File {
 
     try {
       if (this.shouldIgnore()) {
-        return {
-          metadata: {},
-          code:     code,
-          map:      null,
-          ast:      null
-        };
+        return this.makeResult({ code, ignored: true });
+      } else {
+        return callback();
       }
-
-      callback();
-
-      return this.generate();
     } catch (err) {
       if (err._babel) {
         throw err;
@@ -523,15 +568,15 @@ export default class File {
     }
   }
 
-  addCode(code: string, parseCode?) {
+  addCode(code: string) {
     code = (code || "") + "";
     code = this.parseInputSourceMap(code);
     this.code = code;
+  }
 
-    if (parseCode) {
-      this.parseShebang();
-      this.addAst(this.parse(this.code));
-    }
+  parseCode() {
+    this.parseShebang();
+    this.addAst(this.parse(this.code));
   }
 
   shouldIgnore() {
@@ -540,10 +585,8 @@ export default class File {
   }
 
   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);
     }
   }
@@ -570,28 +613,37 @@ export default class File {
     }
   }
 
-  generate(): {
-    usedHelpers?: Array<string>;
-    code: string;
-    map?: Object;
-    ast?: Object;
-  } {
-    var opts = this.opts;
-    var ast  = this.ast;
-
+  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;
+  }
+
+  generate() {
+    var opts = this.opts;
+    var ast  = this.ast;
+
+    var result = { ast };
+    if (!opts.code) return this.makeResult(result);
 
     this.log.debug("Generation start");
 
@@ -618,6 +670,6 @@ export default class File {
       result.map = null;
     }
 
-    return result;
+    return this.makeResult(result);
   }
 }

src/babel/transformation/file/logger.js

@@ -1,4 +1,8 @@
-import * as util from  "../../util";
+import type File from "./index";
+import buildDebug from "debug/node";
+
+var verboseDebug = buildDebug("babel:verbose");
+var generalDebug = buildDebug("babel");
 
 export default class Logger {
   constructor(file: File, filename: string) {
@@ -12,6 +16,10 @@ export default class Logger {
     return parts;
   }
 
+  warn(msg) {
+    console.warn(this._buildMessage(msg));
+  }
+
   error(msg: string, Constructor = Error) {
     throw new Constructor(this._buildMessage(msg));
   }
@@ -22,11 +30,15 @@ export default class Logger {
     }
   }
 
+  verbose(msg: string) {
+    if (verboseDebug.enabled) verboseDebug(this._buildMessage(msg));
+  }
+
   debug(msg: string) {
-    util.debug(this._buildMessage(msg));
+    if (generalDebug.enabled) generalDebug(this._buildMessage(msg));
   }
 
   deopt(node: Object, msg: string) {
-    util.debug(this._buildMessage(msg));
+    this.debug(msg);
   }
 }

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

@@ -1,27 +0,0 @@
-import * as util from  "../../util";
-
-export function transformerList(key, val, pipeline) {
-  val = util.arrayify(val);
-
-  if (val.indexOf("all") >= 0 || val.indexOf(true) >= 0) {
-    val = Object.keys(pipeline.transformers);
-  }
-
-  return pipeline._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/config.json

@@ -20,6 +20,11 @@
     "default": {}
   },
 
+  "env": {
+    "hidden": true,
+    "default": {}
+  },
+
   "moduleId": {
     "description": "specify a custom name for module ids",
     "type": "string"
@@ -30,7 +35,6 @@
   },
 
   "retainLines": {
-    "hidden": true,
     "type": "boolean",
     "default": false,
     "description": "retain line numbers - will result in really ugly code"
@@ -39,15 +43,17 @@
   "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
   },
@@ -72,7 +78,8 @@
   "blacklist": {
     "type": "transformerList",
     "description": "blacklist of transformers to NOT use",
-    "shorthand": "b"
+    "shorthand": "b",
+    "default": []
   },
 
   "whitelist": {
@@ -84,7 +91,8 @@
 
   "optional": {
     "type": "transformerList",
-    "description": "list of optional transformers to enable"
+    "description": "list of optional transformers to enable",
+    "default": []
   },
 
   "modules": {
@@ -116,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": {
@@ -135,6 +145,12 @@
     "type": "boolean"
   },
 
+  "metadata": {
+    "hidden": true,
+    "default": true,
+    "type": "boolean"
+  },
+
   "ast": {
     "hidden": true,
     "default": true,
@@ -144,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": {
@@ -161,12 +177,23 @@
   },
 
   "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"
   },
 
+  "auxiliaryCommentAfter": {
+    "type": "string",
+    "default": "",
+    "description": "attach a comment after all helper declarations and auxiliary code"
+  },
+
   "externalHelpers": {
     "type": "boolean",
     "default": false,
@@ -175,6 +202,7 @@
   },
 
   "metadataUsedHelpers": {
+    "deprecated": "Not required anymore as this is enabled by default",
     "type": "boolean",
     "default": false,
     "hidden": true
@@ -193,6 +221,11 @@
   },
 
   "sourceMapName": {
+    "alias": "sourceMapTarget",
+    "description": "DEPRECATED - Please use sourceMapTarget"
+  },
+
+  "sourceMapTarget": {
     "type": "string",
     "description": "set `file` on returned source map"
   },

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

@@ -0,0 +1,31 @@
+import * as parsers from "./parsers";
+import config from "./config";
+
+export { config };
+
+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;
+  }
+}
+
+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/parsers.js

@@ -0,0 +1,29 @@
+import * as util from "../../../util";
+
+export function transformerList(val) {
+  return util.arrayify(val);
+}
+
+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);
+};
+
+export function number(val) {
+  return +val;
+}
+
+export function boolean(val) {
+  return !!val;
+}
+
+export function booleanString(val) {
+  return util.booleanify(val);
+}
+
+export function list(val) {
+  return util.list(val);
+}

src/babel/transformation/file/options/resolve-rc.js

@@ -1,5 +1,6 @@
 import stripJsonComments from "strip-json-comments";
-import merge from "lodash/object/merge";
+import { normaliseOptions } from "./index";
+import merge from "../../../helpers/merge";
 import path from "path";
 import fs from "fs";
 
@@ -34,6 +35,7 @@ export default function (loc, opts = {}) {
 
       try {
         json = jsons[content] = jsons[content] || JSON.parse(stripJsonComments(content));
+        normaliseOptions(json);
       } catch (err) {
         err.message = `${file}: ${err.message}`;
         throw err;
@@ -42,17 +44,8 @@ export default function (loc, opts = {}) {
       opts.babelrc.push(file);
 
       if (json.breakConfig) return;
-      merge(opts, json, function(a, b) {
-        if (Array.isArray(a)) {
-          var c = a.slice(0);
-          for (var v of b) {
-            if (a.indexOf(v) < 0) {
-              c.push(v);
-            }
-          }
-          return c;
-        }
-      });
+
+      merge(opts, json);
     }
 
     var up = path.dirname(start);
@@ -66,4 +59,4 @@ export default function (loc, opts = {}) {
   }
 
   return opts;
-};
+}

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

@@ -1,5 +1,19 @@
-import * as node from  "../../api/node";
+import Transformer from "../transformer";
+import Plugin from "../plugin";
+import * as types from "../../types";
 import * as messages from "../../messages";
+import traverse from "../../types";
+import parse from "../../helpers/parse";
+
+var context = {
+  messages,
+  Transformer,
+  Plugin,
+  types,
+  parse,
+  traverse
+};
+
 import * as util from  "../../util";
 
 export default class PluginManager {
@@ -11,7 +25,7 @@ export default class PluginManager {
       if (plugin.container === fn) return plugin.transformer;
     }
 
-    var transformer = fn(node);
+    var transformer = fn(context);
     PluginManager.memoisedPlugins.push({
       container: fn,
       transformer: transformer
@@ -35,11 +49,12 @@ export default class PluginManager {
     var match = name.match(/^(.*?):(after|before)$/);
     if (match) [, name, position] = match;
 
-    var loc = util.resolveRelative(name) || util.resolveRelative(`babel-plugin-${name}`);
+    var loc = util.resolveRelative(`babel-plugin-${name}`) || util.resolveRelative(name);
     if (loc) {
+      var plugin = require(loc);
       return {
         position: position,
-        plugin:   require(loc)
+        plugin:   plugin.default || plugin
       };
     } else {
       throw new ReferenceError(messages.get("pluginUnknown", name));
@@ -54,9 +69,12 @@ export default class PluginManager {
     }
 
     // validate Transformer instance
-    if (!plugin.buildPass || plugin.constructor.name !== "Transformer") {
+    if (!plugin.buildPass || plugin.constructor.name !== "Plugin") {
       throw new TypeError(messages.get("pluginNotTransformer", name));
     }
+
+    // register as a plugin
+    plugin.metadata.plugin = true;
   }
 
   add(name) {
@@ -65,7 +83,7 @@ export default class PluginManager {
 
     if (name) {
       if (typeof name === "object" && name.transformer) {
-        ({ plugin: name, position } = name);
+        ({ 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

src/babel/transformation/helpers/build-binary-assignment-operator-transformer.js

@@ -1,7 +1,9 @@
 import explode from "./explode-assignable-expression";
 import * as t from "../../types";
 
-export default function (exports, opts) {
+export default function (opts) {
+  var exports = {};
+
   var isAssignment = function (node) {
     return node.operator === opts.operator + "=";
   };
@@ -10,10 +12,6 @@ export default function (exports, opts) {
     return t.assignmentExpression("=", left, right);
   };
 
-  exports.shouldVisit = function (node) {
-    return node.operator && (node.operator === opts.operator || node.operator === opts.operator + "=");
-  };
-
   exports.ExpressionStatement = function (node, parent, scope, file) {
     // hit the `AssignmentExpression` one below
     if (this.isCompletionRecord()) return;
@@ -44,4 +42,6 @@ export default function (exports, opts) {
     if (node.operator !== opts.operator) return;
     return opts.build(node.left, node.right);
   };
-};
+
+  return exports;
+}

src/babel/transformation/helpers/build-conditional-assignment-operator-transformer.js

@@ -42,4 +42,4 @@ export default function (exports, opts) {
 
     return nodes;
   };
-};
+}

src/babel/transformation/helpers/build-react-transformer.js

@@ -9,15 +9,11 @@ import esutils from "esutils";
 import * as react from "./react";
 import * as t from "../../types";
 
-export default function (exports, opts) {
-  exports.check = function (node) {
-    if (t.isJSX(node)) return true;
-    if (react.isCreateClass(node)) return true;
-    return false;
-  };
+export default function (opts) {
+  var visitor = {};
 
-  exports.JSXIdentifier = function (node, parent) {
-    if (node.name === "this" && t.isReferenced(node, parent)) {
+  visitor.JSXIdentifier = function (node) {
+    if (node.name === "this" && this.isReferenced()) {
       return t.thisExpression();
     } else if (esutils.keyword.isIdentifierNameES6(node.name)) {
       node.type = "Identifier";
@@ -26,22 +22,22 @@ export default function (exports, opts) {
     }
   };
 
-  exports.JSXNamespacedName = function (node, parent, scope, file) {
+  visitor.JSXNamespacedName = function () {
     throw this.errorWithNode(messages.get("JSXNamespacedTags"));
   };
 
-  exports.JSXMemberExpression = {
+  visitor.JSXMemberExpression = {
     exit(node) {
       node.computed = t.isLiteral(node.property);
       node.type = "MemberExpression";
     }
   };
 
-  exports.JSXExpressionContainer = function (node) {
+  visitor.JSXExpressionContainer = function (node) {
     return node.expression;
   };
 
-  exports.JSXAttribute = {
+  visitor.JSXAttribute = {
     enter(node) {
       var value = node.value;
       if (t.isLiteral(value) && isString(value.value)) {
@@ -55,7 +51,7 @@ export default function (exports, opts) {
     }
   };
 
-  exports.JSXOpeningElement = {
+  visitor.JSXOpeningElement = {
     exit(node, parent, scope, file) {
       parent.children = react.buildChildren(parent);
 
@@ -145,7 +141,7 @@ export default function (exports, opts) {
     return attribs;
   };
 
-  exports.JSXElement = {
+  visitor.JSXElement = {
     exit(node) {
       var callExpr = node.openingElement;
 
@@ -159,53 +155,5 @@ export default function (exports, opts) {
     }
   };
 
-  // display names
-
-  var addDisplayName = function (id, call) {
-    var props = call.arguments[0].properties;
-    var safe = true;
-
-    for (var i = 0; i < props.length; i++) {
-      var prop = props[i];
-      if (t.isIdentifier(prop.key, { name: "displayName" })) {
-        safe = false;
-        break;
-      }
-    }
-
-    if (safe) {
-      props.unshift(t.property("init", t.identifier("displayName"), t.literal(id)));
-    }
-  };
-
-  exports.ExportDefaultDeclaration = function (node, parent, scope, file) {
-    if (react.isCreateClass(node.declaration)) {
-      addDisplayName(file.opts.basename, node.declaration);
-    }
-  };
-
-  exports.AssignmentExpression =
-  exports.Property =
-  exports.VariableDeclarator = function (node) {
-    var left, right;
-
-    if (t.isAssignmentExpression(node)) {
-      left = node.left;
-      right = node.right;
-    } else if (t.isProperty(node)) {
-      left = node.key;
-      right = node.value;
-    } else if (t.isVariableDeclarator(node)) {
-      left = node.id;
-      right = node.init;
-    }
-
-    if (t.isMemberExpression(left)) {
-      left = left.property;
-    }
-
-    if (t.isIdentifier(left) && react.isCreateClass(right)) {
-      addDisplayName(left.name, right);
-    }
-  };
-};
+  return visitor;
+}

src/babel/transformation/helpers/call-delegate.js

@@ -1,4 +1,3 @@
-import traverse from "../../traversal";
 import * as t from "../../types";
 
 var visitor = {
@@ -7,10 +6,10 @@ var visitor = {
       state.found = true;
       this.stop();
     }
+  },
 
-    if (this.isFunction()) {
-      this.skip();
-    }
+  Function() {
+    this.skip();
   }
 };
 

src/babel/transformation/helpers/define-map.js

@@ -1,5 +1,3 @@
-import cloneDeep from "lodash/lang/cloneDeep";
-import traverse from "../../traversal";
 import each from "lodash/collection/each";
 import has from "lodash/object/has";
 import * as t from "../../types";
@@ -26,7 +24,7 @@ export function push(mutatorMap, node, kind, file) {
 
   if (node.decorators) {
     var decorators = map.decorators = map.decorators || t.arrayExpression([]);
-    decorators.elements = decorators.elements.concat(node.decorators.map(dec => dec.expression));
+    decorators.elements = decorators.elements.concat(node.decorators.map(dec => dec.expression).reverse());
   }
 
   if (map.value || map.initializer) {

src/babel/transformation/helpers/explode-assignable-expression.js

@@ -26,7 +26,7 @@ var getObjRef = function (node, nodes, file, scope) {
     throw new Error(`We can't explode this node type ${node.type}`);
   }
 
-  var temp = scope.generateUidBasedOnNode(ref);
+  var temp = scope.generateUidIdentifierBasedOnNode(ref);
   nodes.push(t.variableDeclaration("var", [
     t.variableDeclarator(temp, ref)
   ]));
@@ -38,7 +38,7 @@ var getPropRef = function (node, nodes, file, scope) {
   var key = t.toComputedKey(node, prop);
   if (t.isLiteral(key)) return key;
 
-  var temp = scope.generateUidBasedOnNode(prop);
+  var temp = scope.generateUidIdentifierBasedOnNode(prop);
   nodes.push(t.variableDeclaration("var", [
     t.variableDeclarator(temp, prop)
   ]));
@@ -68,4 +68,4 @@ export default function (node, nodes, file, scope, allowedSingleIdent) {
     uid: uid,
     ref: ref
   };
-};
+}

src/babel/transformation/helpers/get-function-arity.js

@@ -3,7 +3,10 @@ import * as t from "../../types";
 export default function (node) {
   var lastNonDefault = 0;
   for (var i = 0; i < node.params.length; i++) {
-    if (!t.isAssignmentPattern(node.params[i])) lastNonDefault = i + 1;
+    var param = node.params[i];
+    if (!t.isAssignmentPattern(param) && !t.isRestElement(param)) {
+      lastNonDefault = i + 1;
+    }
   }
   return lastNonDefault;
-};
+}

src/babel/transformation/helpers/memoise-decorators.js

@@ -6,7 +6,7 @@ export default function (decorators, scope) {
     var expression = decorator.expression;
     if (!t.isMemberExpression(expression)) continue;
 
-    var temp = scope.generateMemoisedReference(expression.object);
+    var temp = scope.maybeGenerateMemoised(expression.object);
     var ref;
 
     var nodes = [];

src/babel/transformation/helpers/name-method.js

@@ -2,25 +2,32 @@ import getFunctionArity from "./get-function-arity";
 import * as util from  "../../util";
 import * as t from "../../types";
 
+function visitIdentifier(context, node, scope, state) {
+  // check if this node matches our function id
+  if (node.name !== state.name) return;
+
+  // check that we don't have a local variable declared as that removes the need
+  // for the wrapper
+  var localDeclar = scope.getBindingIdentifier(state.name);
+  if (localDeclar !== state.outerDeclar) return;
+
+  state.selfReference = true;
+  context.stop();
+}
+
 var visitor = {
-  enter(node, parent, scope, state) {
-    // check if this node is a referenced identifier that matches the same as our
-    // function id
-    if (!this.isReferencedIdentifier({ name: state.name })) return;
+  ReferencedIdentifier(node, parent, scope, state) {
+    visitIdentifier(this, node, scope, state);
+  },
 
-    // check that we don't have a local variable declared as that removes the need
-    // for the wrapper
-    var localDeclar = scope.getBindingIdentifier(state.name);
-    if (localDeclar !== state.outerDeclar) return;
-
-    state.selfReference = true;
-    this.stop();
+  BindingIdentifier(node, parent, scope, state) {
+    visitIdentifier(this, node, scope, state);
   }
 };
 
 var wrap = function (state, method, id, scope) {
   if (state.selfReference) {
-    if (scope.hasBinding(id.name)) {
+    if (scope.hasBinding(id.name) && !scope.hasGlobal(id.name)) {
       // we can just munge the local binding
       scope.rename(id.name);
     } else {
@@ -46,6 +53,7 @@ var wrap = function (state, method, id, scope) {
   }
 
   method.id = id;
+  scope.getProgramParent().references[id.name] = true;
 };
 
 var visit = function (node, name, scope) {
@@ -60,10 +68,10 @@ var visit = function (node, name, scope) {
   // check to see if we have a local binding of the id we're setting inside of
   // the function, this is important as there are caveats associated
 
-  var bindingInfo = scope.getOwnBindingInfo(name);
+  var binding = scope.getOwnBinding(name);
 
-  if (bindingInfo) {
-    if (bindingInfo.kind === "param") {
+  if (binding) {
+    if (binding.kind === "param") {
       // safari will blow up in strict mode with code like:
       //
       //   var t = function t(t) {};
@@ -103,8 +111,7 @@ export function property(node, file, scope) {
   var key = t.toComputedKey(node, node.key);
   if (!t.isLiteral(key)) return; // we can't set a function id with this
 
-  var name = t.toIdentifier(key.value);
-  if (name === "eval" || name === "arguments") name = "_" + name;
+  var name = t.toBindingIdentifierName(key.value);
   var id = t.identifier(name);
 
   var method = node.value;
@@ -125,8 +132,8 @@ export function bare(node, parent, scope) {
     id = parent.id;
 
     if (t.isIdentifier(id)) {
-      var bindingInfo = scope.parent.getBinding(id.name);
-      if (bindingInfo && bindingInfo.constant && scope.getBinding(id.name) === bindingInfo) {
+      var binding = scope.parent.getBinding(id.name);
+      if (binding && binding.constant && scope.getBinding(id.name) === binding) {
         // always going to reference this method
         node.id = id;
         return;
@@ -145,7 +152,7 @@ export function bare(node, parent, scope) {
     return;
   }
 
-  name = t.toIdentifier(name);
+  name = t.toBindingIdentifierName(name);
   id = t.identifier(name);
 
   var state = visit(node, name, scope);

src/babel/transformation/helpers/react.js

@@ -1,35 +1,11 @@
-import isString from "lodash/lang/isString";
 import * as t from "../../types";
 
-var isCreateClassCallExpression = t.buildMatchMemberExpression("React.createClass");
-
-export function isCreateClass(node) {
-  if (!node || !t.isCallExpression(node)) return false;
-
-  // not React.createClass call member object
-  if (!isCreateClassCallExpression(node.callee)) return false;
-
-  // no call arguments
-  var args = node.arguments;
-  if (args.length !== 1) return false;
-
-  // first node arg is not an object
-  var first = args[0];
-  if (!t.isObjectExpression(first)) return false;
-
-  return true;
-}
-
 export var isReactComponent = t.buildMatchMemberExpression("React.Component");
 
 export function isCompatTag(tagName) {
   return tagName && /^[a-z]|\-/.test(tagName);
 }
 
-function isStringLiteral(node) {
-  return t.isLiteral(node) && isString(node.value);
-}
-
 function cleanJSXElementLiteralChild(child, args) {
   var lines = child.value.split(/\r\n|\n|\r/);
 

src/babel/transformation/helpers/remap-async-to-generator.js

@@ -1,35 +1,37 @@
 import * as t from "../../types";
 
 var awaitVisitor = {
-  enter(node, parent, scope, state) {
-    if (t.isFunction(node)) this.skip();
+  Function() {
+    this.skip();
+  },
 
-    if (t.isAwaitExpression(node)) {
-      node.type = "YieldExpression";
+  AwaitExpression(node) {
+    node.type = "YieldExpression";
 
-      if (node.all) {
-        // await* foo; -> yield Promise.all(foo);
-        node.all = false;
-        node.argument = t.callExpression(t.memberExpression(t.identifier("Promise"), t.identifier("all")), [node.argument]);
-      }
+    if (node.all) {
+      // await* foo; -> yield Promise.all(foo);
+      node.all = false;
+      node.argument = t.callExpression(t.memberExpression(t.identifier("Promise"), t.identifier("all")), [node.argument]);
     }
   }
 };
 
 var referenceVisitor = {
-  enter(node, parent, scope, state) {
+  ReferencedIdentifier(node, parent, scope, state) {
     var name = state.id.name;
-    if (t.isReferencedIdentifier(node, parent, { name: name }) && scope.bindingIdentifierEquals(name, state.id)) {
+    if (node.name === name && scope.bindingIdentifierEquals(name, state.id)) {
       return state.ref = state.ref || scope.generateUidIdentifier(name);
     }
   }
 };
 
-export default function (node, callId, scope) {
+export default function (path, callId) {
+  var node = path.node;
+
   node.async = false;
   node.generator = true;
 
-  scope.traverse(node, awaitVisitor, state);
+  path.traverse(awaitVisitor, state);
 
   var call = t.callExpression(callId, [node]);
 
@@ -44,15 +46,15 @@ export default function (node, callId, scope) {
     return declar;
   } else {
     if (id) {
-      var state = { id: id };
-      scope.traverse(node, referenceVisitor, state);
+      var state = { id };
+      path.traverse(referenceVisitor, state);
 
       if (state.ref) {
-        scope.parent.push({ id: state.ref });
+        path.scope.parent.push({ id: state.ref });
         return t.assignmentExpression("=", state.ref, call);
       }
     }
 
     return call;
   }
-};
+}

src/babel/transformation/helpers/replace-supers.js

@@ -1,3 +1,4 @@
+import type NodePath from "../../traversal/path";
 import * as messages from "../../messages";
 import * as t from "../../types";
 
@@ -130,7 +131,7 @@ export default class ReplaceSupers {
    * Description
    */
 
-  traverseLevel(path: TraversalPath, topLevel: boolean) {
+  traverseLevel(path: NodePath, topLevel: boolean) {
     var state = { self: this, topLevel: topLevel };
     path.traverse(visitor, state);
   }
@@ -168,7 +169,13 @@ export default class ReplaceSupers {
 
       if (methodName.name === "constructor") {
         // constructor() { super(); }
-        return t.memberExpression(superRef, t.identifier("call"));
+        if (parent.arguments.length === 2 && t.isSpreadElement(parent.arguments[1]) && t.isIdentifier(parent.arguments[1].argument, { name: "arguments" })) {
+          // special case single arguments spread
+          parent.arguments[1] = parent.arguments[1].argument;
+          return t.memberExpression(superRef, t.identifier("apply"));
+        } else {
+          return t.memberExpression(superRef, t.identifier("call"));
+        }
       } else {
         id = superRef;
 
@@ -192,7 +199,7 @@ export default class ReplaceSupers {
    * Description
    */
 
-  looseHandle(path: TraversalPath, getThisReference: Function) {
+  looseHandle(path: NodePath, getThisReference: Function) {
     var node = path.node;
     if (path.isSuper()) {
       return this.getLooseSuperProperty(node, path.parent);
@@ -234,7 +241,7 @@ export default class ReplaceSupers {
    * Description
    */
 
-  specHandle(path: TraversalPath, getThisReference: Function) {
+  specHandle(path: NodePath, getThisReference: Function) {
     var methodNode = this.methodNode;
     var property;
     var computed;
@@ -274,7 +281,7 @@ export default class ReplaceSupers {
       property = node.property;
       computed = node.computed;
     } else if (t.isUpdateExpression(node) && isMemberExpressionSuper(node.argument)) {
-      var binary = t.binaryExpression(node.operator[0], node.argument, t.literal(1))
+      var binary = t.binaryExpression(node.operator[0], node.argument, t.literal(1));
       if (node.prefix) {
         // ++super.foo; -> super.foo += 1;
         return this.specHandleAssignmentExpression(null, path, binary, getThisReference);

src/babel/transformation/helpers/strict.js

@@ -1,19 +0,0 @@
-import * as t from "../../types";
-
-export function has(node) {
-  var first = node.body[0];
-  return t.isExpressionStatement(first) && t.isLiteral(first.expression, { value: "use strict" });
-}
-
-export function wrap(node, callback) {
-  var useStrictNode;
-  if (has(node)) {
-    useStrictNode = node.body.shift();
-  }
-
-  callback();
-
-  if (useStrictNode) {
-    node.body.unshift(useStrictNode);
-  }
-}

src/babel/transformation/index.js

@@ -1,10 +1,20 @@
-import Pipeline from "./transformer-pipeline";
+import Pipeline from "./pipeline";
 
 var pipeline = new Pipeline;
 
 //
 
 import transformers from "./transformers";
+
+for (var key in transformers) {
+  var transformer = transformers[key];
+
+  if (typeof transformer === "object") {
+    var metadata = transformer.metadata = transformer.metadata || {};
+    metadata.group = metadata.group || "builtin-basic";
+  }
+}
+
 pipeline.addTransformers(transformers);
 
 //

src/babel/transformation/modules/_default.js

@@ -1,117 +1,182 @@
 import * as messages from "../../messages";
-import traverse from "../../traversal";
+import Remaps from "./lib/remaps";
 import extend from "lodash/object/extend";
 import object from "../../helpers/object";
 import * as util from  "../../util";
 import * as t from "../../types";
 
-var remapVisitor = {
-  enter(node, parent, scope, formatter) {
-    var remap = formatter.internalRemap[node.name];
-
-    if (this.isReferencedIdentifier() && remap && node !== remap) {
-      if (!scope.hasBinding(node.name) || scope.bindingIdentifierEquals(node.name, formatter.localImports[node.name])) {
-        return remap;
+var metadataVisitor = {
+  ModuleDeclaration: {
+    enter(node, parent, scope, formatter) {
+      if (node.source) {
+        node.source.value = formatter.file.resolveModuleSource(node.source.value);
+        formatter.addScope(this);
       }
     }
-
-    if (t.isUpdateExpression(node)) {
-      var exported = formatter.getExport(node.argument, scope);
-
-      if (exported) {
-        this.skip();
-
-        // expand to long file assignment expression
-        var assign = t.assignmentExpression(node.operator[0] + "=", node.argument, t.literal(1));
-
-        // remap this assignment expression
-        var remapped = formatter.remapExportAssignment(assign, exported);
-
-        // we don't need to change the result
-        if (t.isExpressionStatement(parent) || node.prefix) {
-          return remapped;
-        }
-
-        var nodes = [];
-        nodes.push(remapped);
-
-        var operator;
-        if (node.operator === "--") {
-          operator = "+";
-        } else { // "++"
-          operator = "-";
-        }
-        nodes.push(t.binaryExpression(operator, node.argument, t.literal(1)));
-
-        return t.sequenceExpression(nodes);
-      }
-    }
-
-    if (node._skipModulesRemap) {
-      return this.skip();
-    }
   },
 
-  exit(node, parent, scope, formatter) {
-    if (t.isAssignmentExpression(node) && !node._ignoreModulesRemap) {
-      var exported = formatter.getExport(node.left, scope);
-      if (exported) {
-        return formatter.remapExportAssignment(node, exported);
-      }
-    }
-  }
-};
-
-var importsVisitor = {
   ImportDeclaration: {
-    enter(node, parent, scope, formatter) {
+    exit(node, parent, scope, formatter) {
       formatter.hasLocalImports = true;
-      extend(formatter.localImports, this.getBindingIdentifiers());
+
+      var specifiers = [];
+      var imported = [];
+      formatter.metadata.imports.push({
+        source: node.source.value,
+        imported,
+        specifiers
+      });
+
+      for (var specifier of (this.get("specifiers"): Array)) {
+        var ids = specifier.getBindingIdentifiers();
+        extend(formatter.localImports, ids);
+
+        var local = specifier.node.local.name;
+
+        if (specifier.isImportDefaultSpecifier()) {
+          imported.push("default");
+          specifiers.push({
+            kind: "named",
+            imported: "default",
+            local
+          });
+        }
+
+        if (specifier.isImportSpecifier()) {
+          var importedName = specifier.node.imported.name;
+          imported.push(importedName);
+          specifiers.push({
+            kind: "named",
+            imported: importedName,
+            local
+          });
+        }
+
+        if (specifier.isImportNamespaceSpecifier()) {
+          imported.push("*");
+          specifiers.push({
+            kind: "namespace",
+            local
+          });
+        }
+      }
+    }
+  },
+
+  ExportDeclaration(node, parent, scope, formatter) {
+    formatter.hasLocalExports = true;
+
+    var source = node.source ? node.source.value : null;
+    var exports = formatter.metadata.exports;
+
+    // export function foo() {}
+    // export var foo = "bar";
+    var declar = this.get("declaration");
+    if (declar.isStatement()) {
+      var bindings = declar.getBindingIdentifiers();
+
+      for (var name in bindings) {
+        var binding = bindings[name];
+        formatter._addExport(name, binding);
+
+        exports.exported.push(name);
+        exports.specifiers.push({
+          kind: "local",
+          local: name,
+          exported: this.isExportDefaultDeclaration() ? "default" : name
+        });
+      }
+    }
+
+    if (this.isExportNamedDeclaration() && node.specifiers) {
+      for (var specifier of (node.specifiers: Array)) {
+        var exported = specifier.exported.name;
+        exports.exported.push(exported);
+
+        // export foo from "bar";
+        if (t.isExportDefaultSpecifier(specifier)) {
+          exports.specifiers.push({
+            kind: "external",
+            local: exported,
+            exported,
+            source
+          });
+        }
+
+        // export * as foo from "bar";
+        if (t.isExportNamespaceSpecifier(specifier)) {
+          exports.specifiers.push({
+            kind: "external-namespace",
+            exported,
+            source
+          });
+        }
+
+        var local = specifier.local;
+        if (!local) continue;
+
+        formatter._addExport(local.name, specifier.exported);
+
+        // export { foo } from "bar";
+        // export { foo as bar } from "bar";
+        if (source) {
+          exports.specifiers.push({
+            kind: "external",
+            local: local.name,
+            exported,
+            source
+          });
+        }
+
+        // export { foo };
+        // export { foo as bar };
+        if (!source) {
+          exports.specifiers.push({
+            kind: "local",
+            local: local.name,
+            exported
+          });
+        }
+      }
+    }
+
+    // export * from "bar";
+    if (this.isExportAllDeclaration()) {
+      exports.specifiers.push({
+        kind: "external-all",
+        source
+      });
+    }
+
+    if (!t.isExportDefaultDeclaration(node) && !declar.isTypeAlias()) {
+      var onlyDefault = node.specifiers && node.specifiers.length === 1 && t.isSpecifierDefault(node.specifiers[0]);
+      if (!onlyDefault) {
+        formatter.hasNonDefaultExports = true;
+      }
+    }
+  },
+
+  Scope(node, parent, scope, formatter) {
+    if (!formatter.isLoose()) {
+      this.skip();
     }
   }
 };
 
-var exportsVisitor = traverse.explode({
-  ExportDeclaration: {
-    enter(node, parent, scope, formatter) {
-      formatter.hasLocalExports = true;
-
-      var declar = this.get("declaration");
-      if (declar.isStatement()) {
-        var bindings = declar.getBindingIdentifiers()
-        for (var name in bindings) {
-          var binding = bindings[name];
-          formatter._addExport(name, binding);
-        }
-      }
-
-      if (this.isExportNamedDeclaration() && node.specifiers) {
-        for (var i = 0; i < node.specifiers.length; i++) {
-          var specifier = node.specifiers[i];
-          var local = specifier.local;
-          if (!local) continue;
-
-          formatter._addExport(local.name, specifier.exported);
-        }
-      }
-
-      if (!t.isExportDefaultDeclaration(node)) {
-        var onlyDefault = node.specifiers && node.specifiers.length === 1 && t.isSpecifierDefault(node.specifiers[0]);
-        if (!onlyDefault) {
-          formatter.hasNonDefaultExports = true;
-        }
-      }
-    }
-  }
-});
-
 export default class DefaultFormatter {
   constructor(file) {
-    this.internalRemap = object();
-    this.defaultIds    = object();
-    this.scope         = file.scope;
-    this.file          = file;
-    this.ids           = object();
+    // object containg all module sources with the scope that they're contained in
+    this.sourceScopes = object();
+
+    // ids for use in module ids
+    this.defaultIds = object();
+    this.ids        = object();
+
+    // contains reference aliases for live bindings
+    this.remaps = new Remaps(file, this);
+
+    this.scope = file.scope;
+    this.file  = file;
 
     this.hasNonDefaultExports = false;
 
@@ -121,8 +186,20 @@ export default class DefaultFormatter {
     this.localExports = object();
     this.localImports = object();
 
-    this.getLocalExports();
-    this.getLocalImports();
+    this.metadata = file.metadata.modules;
+    this.getMetadata();
+  }
+
+  addScope(path) {
+    var source = path.node.source && path.node.source.value;
+    if (!source) return;
+
+    var existingScope = this.sourceScopes[source];
+    if (existingScope && existingScope !== path.scope) {
+      throw path.errorWithNode(messages.get("modulesDuplicateDeclarations"));
+    }
+
+    this.sourceScopes[source] = path.scope;
   }
 
   isModuleType(node, type) {
@@ -138,17 +215,22 @@ export default class DefaultFormatter {
     return (t.isExportDefaultDeclaration(node) || t.isSpecifierDefault(node)) && !this.noInteropRequireExport && !this.hasNonDefaultExports;
   }
 
-  getLocalExports() {
-    this.file.path.traverse(exportsVisitor, this);
-  }
-
-  getLocalImports() {
-    this.file.path.traverse(importsVisitor, this);
+  getMetadata() {
+    var has = false;
+    for (var node of (this.file.ast.program.body: Array)) {
+      if (t.isModuleDeclaration(node)) {
+        has = true;
+        break;
+      }
+    }
+    if (has || this.isLoose()) {
+      this.file.path.traverse(metadataVisitor, this);
+    }
   }
 
   remapAssignments() {
     if (this.hasLocalExports || this.hasLocalImports) {
-      this.file.path.traverse(remapVisitor, this);
+      this.remaps.run();
     }
   }
 

src/babel/transformation/modules/_strict.js

@@ -10,4 +10,4 @@ export default function (Parent) {
   util.inherits(Constructor, Parent);
 
   return Constructor;
-};
+}

src/babel/transformation/modules/amd.js

@@ -6,8 +6,8 @@ import * as util from  "../../util";
 import * as t from "../../types";
 
 export default class AMDFormatter extends DefaultFormatter {
-  init() {
-    CommonFormatter.prototype._init.call(this, this.hasNonDefaultExports);
+  setup() {
+    CommonFormatter.prototype._setup.call(this, this.hasNonDefaultExports);
   }
 
   buildDependencyLiterals() {
@@ -72,7 +72,7 @@ export default class AMDFormatter extends DefaultFormatter {
     this.getExternalReference(node);
   }
 
-  importSpecifier(specifier, node, nodes) {
+  importSpecifier(specifier, node, nodes, scope) {
     var key = node.source.value;
     var ref = this.getExternalReference(node);
 
@@ -90,11 +90,11 @@ export default class AMDFormatter extends DefaultFormatter {
       // import * as bar from "foo";
     } else if (!includes(this.file.dynamicImported, node) && t.isSpecifierDefault(specifier) && !this.noInteropRequireImport) {
       // import foo from "foo";
-      var uid = this.scope.generateUidIdentifier(specifier.local.name);
+      var uid = scope.generateUidIdentifier(specifier.local.name);
       nodes.push(t.variableDeclaration("var", [
-        t.variableDeclarator(uid, t.callExpression(this.file.addHelper("interop-require"), [ref]))
+        t.variableDeclarator(uid, t.callExpression(this.file.addHelper("interop-require-default"), [ref]))
       ]));
-      ref = uid;
+      ref = t.memberExpression(uid, t.identifier("default"));
     } else {
       // import { foo } from "foo";
       var imported = specifier.imported;
@@ -102,7 +102,7 @@ export default class AMDFormatter extends DefaultFormatter {
       ref = t.memberExpression(ref, imported);
     }
 
-    this.internalRemap[specifier.local.name] = ref;
+    this.remaps.add(scope, specifier.local.name, ref);
   }
 
   exportSpecifier(specifier, node, nodes) {

src/babel/transformation/modules/common.js

@@ -1,14 +1,13 @@
 import DefaultFormatter from "./_default";
-import includes from "lodash/collection/includes";
 import * as util from  "../../util";
 import * as t from "../../types";
 
 export default class CommonJSFormatter extends DefaultFormatter {
-  init() {
-    this._init(this.hasLocalExports);
+  setup() {
+    this._setup(this.hasLocalExports);
   }
 
-  _init(conditional) {
+  _setup(conditional) {
     var file  = this.file;
     var scope = file.scope;
 
@@ -38,7 +37,7 @@ export default class CommonJSFormatter extends DefaultFormatter {
     }
   }
 
-  importSpecifier(specifier, node, nodes) {
+  importSpecifier(specifier, node, nodes, scope) {
     var variableName = specifier.local;
 
     var ref = this.getExternalReference(node, nodes);
@@ -48,17 +47,17 @@ export default class CommonJSFormatter extends DefaultFormatter {
       if (this.isModuleType(node, "absolute")) {
         // absolute module reference
       } else if (this.isModuleType(node, "absoluteDefault")) {
-        this.internalRemap[variableName.name] = ref;
+        this.remaps.add(scope, variableName.name, ref);
       } else if (this.noInteropRequireImport) {
-        this.internalRemap[variableName.name] = t.memberExpression(ref, t.identifier("default"));
+        this.remaps.add(scope, variableName.name, t.memberExpression(ref, t.identifier("default")));
       } else {
-        var uid = this.scope.generateUidBasedOnNode(node, "import");
+        var uid = this.scope.generateUidIdentifierBasedOnNode(node, "import");
 
         nodes.push(t.variableDeclaration("var", [
           t.variableDeclarator(uid, t.callExpression(this.file.addHelper("interop-require-default"), [ref]))
         ]));
 
-        this.internalRemap[variableName.name] = t.memberExpression(uid, t.identifier("default"));
+        this.remaps.add(scope, variableName.name, t.memberExpression(uid, t.identifier("default")));
       }
     } else {
       if (t.isImportNamespaceSpecifier(specifier)) {
@@ -72,7 +71,7 @@ export default class CommonJSFormatter extends DefaultFormatter {
         ]));
       } else {
         // import { foo } from "foo";
-        this.internalRemap[variableName.name] = t.memberExpression(ref, specifier.imported);
+        this.remaps.add(scope, variableName.name, t.memberExpression(ref, specifier.imported));
       }
     }
   }
@@ -84,7 +83,7 @@ export default class CommonJSFormatter extends DefaultFormatter {
     }, true));
   }
 
-  exportSpecifier(specifier, node, nodes) {
+  exportSpecifier(specifier) {
     if (this.doDefaultExportInterop(specifier)) {
       this.hasDefaultOnlyExport = true;
     }
@@ -92,7 +91,7 @@ export default class CommonJSFormatter extends DefaultFormatter {
     DefaultFormatter.prototype.exportSpecifier.apply(this, arguments);
   }
 
-  exportDeclaration(node, nodes) {
+  exportDeclaration(node) {
     if (this.doDefaultExportInterop(node)) {
       this.hasDefaultOnlyExport = true;
     }
@@ -101,8 +100,6 @@ export default class CommonJSFormatter extends DefaultFormatter {
   }
 
   _getExternalReference(node, nodes) {
-    var source = node.source.value;
-
     var call = t.callExpression(t.identifier("require"), [node.source]);
     var uid;
 
@@ -111,7 +108,7 @@ export default class CommonJSFormatter extends DefaultFormatter {
     } else if (this.isModuleType(node, "absoluteDefault")) {
       call = t.memberExpression(call, t.identifier("default"));
     } else {
-      uid = this.scope.generateUidBasedOnNode(node, "import");
+      uid = this.scope.generateUidIdentifierBasedOnNode(node, "import");
     }
 
     uid = uid || node.specifiers[0].local;

src/babel/transformation/modules/ignore.js

@@ -1,6 +1,7 @@
+import DefaultFormatter from "./_default";
 import * as t from "../../types";
 
-export default class IgnoreFormatter {
+export default class IgnoreFormatter extends DefaultFormatter {
   exportDeclaration(node, nodes) {
     var declar = t.toStatement(node.declaration, true);
     if (declar) nodes.push(t.inherits(declar, node));
@@ -10,4 +11,5 @@ export default class IgnoreFormatter {
   importDeclaration() {}
   importSpecifier() {}
   exportSpecifier() {}
+  transform() {}
 }

src/babel/transformation/modules/lib/remaps.js

@@ -0,0 +1,121 @@
+import * as t from "../../../types";
+
+var remapVisitor = {
+  enter(node) {
+    if (node._skipModulesRemap) {
+      return this.skip();
+    }
+  },
+
+  ReferencedIdentifier(node, parent, scope, remaps) {
+    var { formatter } = remaps;
+
+    var remap = remaps.get(scope, node.name);
+    if (!remap || node === remap) return;
+
+    if (!scope.hasBinding(node.name) ||
+        scope.bindingIdentifierEquals(node.name, formatter.localImports[node.name])) {
+      if (!formatter.isLoose() && this.key === "callee" && this.parentPath.isCallExpression()) {
+        return t.sequenceExpression([t.literal(0), remap]);
+      } else {
+        return remap;
+      }
+    }
+  },
+
+  AssignmentExpression: {
+    exit(node, parent, scope, { formatter }) {
+      if (!node._ignoreModulesRemap) {
+        var exported = formatter.getExport(node.left, scope);
+        if (exported) {
+          return formatter.remapExportAssignment(node, exported);
+        }
+      }
+    }
+  },
+
+  UpdateExpression(node, parent, scope, { formatter }) {
+    var exported = formatter.getExport(node.argument, scope);
+    if (!exported) return;
+
+    this.skip();
+
+    // expand to long file assignment expression
+    var assign = t.assignmentExpression(node.operator[0] + "=", node.argument, t.literal(1));
+
+    // remap this assignment expression
+    var remapped = formatter.remapExportAssignment(assign, exported);
+
+    // we don't need to change the result
+    if (t.isExpressionStatement(parent) || node.prefix) {
+      return remapped;
+    }
+
+    var nodes = [];
+    nodes.push(remapped);
+
+    var operator;
+    if (node.operator === "--") {
+      operator = "+";
+    } else { // "++"
+      operator = "-";
+    }
+    nodes.push(t.binaryExpression(operator, node.argument, t.literal(1)));
+
+    return t.sequenceExpression(nodes);
+  }
+};
+export default class Remaps {
+  constructor(file, formatter) {
+    this.formatter = formatter;
+    this.file      = file;
+  }
+
+  run() {
+    this.file.path.traverse(remapVisitor, this);
+  }
+
+  _getKey(name) {
+    return `${name}:moduleRemap`;
+  }
+
+  get(scope, name) {
+    return scope.getData(this._getKey(name));
+  }
+
+  add(scope, name, val) {
+    if (this.all) {
+      this.all.push({
+        name,
+        scope,
+        node: val
+      });
+    }
+
+    return scope.setData(this._getKey(name), val);
+  }
+
+  remove(scope, name) {
+    return scope.removeData(this._getKey(name));
+  }
+
+  /**
+   * These methods are used by the system module formatter who needs access to all the remaps
+   * so it can process them into it's specific setter method. We don't do this by default since
+   * no other module formatters need access to this.
+   */
+
+  getAll() {
+    return this.all;
+  }
+
+  clearAll() {
+    if (this.all) {
+      for (var remap of (this.all: Array)) {
+        remap.scope.removeData(this._getKey(remap.name));
+      }
+    }
+
+    this.all = [];
+  }
+}

src/babel/transformation/modules/system.js

@@ -2,56 +2,55 @@ import DefaultFormatter from "./_default";
 import AMDFormatter from "./amd";
 import * as util from  "../../util";
 import last from "lodash/array/last";
-import each from "lodash/collection/each";
 import map from "lodash/collection/map";
 import * as t from "../../types";
 
 var hoistVariablesVisitor = {
-  enter(node, parent, scope, state) {
-    if (t.isFunction(node)) {
-      // nothing inside is accessible
-      return this.skip();
+  Function() {
+    // nothing inside is accessible
+    this.skip();
+  },
+
+  VariableDeclaration(node, parent, scope, state) {
+    if (node.kind !== "var" && !t.isProgram(parent)) { // let, const
+      // can't be accessed
+      return;
     }
 
-    if (t.isVariableDeclaration(node)) {
-      if (node.kind !== "var" && !t.isProgram(parent)) { // let, const
-        // can't be accessed
-        return;
+    // ignore block hoisted nodes as these can be left in
+    if (state.formatter._canHoist(node)) return;
+
+    var nodes = [];
+
+    for (var i = 0; i < node.declarations.length; i++) {
+      var declar = node.declarations[i];
+      state.hoistDeclarators.push(t.variableDeclarator(declar.id));
+      if (declar.init) {
+        // no initializer so we can just hoist it as-is
+        var assign = t.expressionStatement(t.assignmentExpression("=", declar.id, declar.init));
+        nodes.push(assign);
       }
-
-      // ignore block hoisted nodes as these can be left in
-      if (state.formatter.canHoist(node)) return;
-
-      var nodes = [];
-
-      for (var i = 0; i < node.declarations.length; i++) {
-        var declar = node.declarations[i];
-        state.hoistDeclarators.push(t.variableDeclarator(declar.id));
-        if (declar.init) {
-          // no initializer so we can just hoist it as-is
-          var assign = t.expressionStatement(t.assignmentExpression("=", declar.id, declar.init));
-          nodes.push(assign);
-        }
-      }
-
-      // for (var i in test)
-      // for (var i = 0;;)
-      if (t.isFor(parent) && parent.left === node) {
-        return node.declarations[0].id;
-      }
-
-      return nodes;
     }
+
+    // for (var i in test)
+    // for (var i = 0;;)
+    if (t.isFor(parent) && (parent.left === node || parent.init === node)) {
+      return node.declarations[0].id;
+    }
+
+    return nodes;
   }
 };
 
 var hoistFunctionsVisitor = {
-  enter(node, parent, scope, state) {
-    if (t.isFunction(node)) this.skip();
+  Function() {
+    this.skip();
+  },
 
-    if (t.isFunctionDeclaration(node) || state.formatter.canHoist(node)) {
+  enter(node, parent, scope, state) {
+    if (t.isFunctionDeclaration(node) || state.formatter._canHoist(node)) {
       state.handlerBody.push(node);
-      this.remove();
+      this.dangerouslyRemove();
     }
   }
 };
@@ -60,17 +59,17 @@ var runnerSettersVisitor = {
   enter(node, parent, scope, state) {
     if (node._importSource === state.source) {
       if (t.isVariableDeclaration(node)) {
-        each(node.declarations, function (declar) {
+        for (var declar of (node.declarations: Array)) {
           state.hoistDeclarators.push(t.variableDeclarator(declar.id));
           state.nodes.push(t.expressionStatement(
             t.assignmentExpression("=", declar.id, declar.init)
           ));
-        });
+        }
       } else {
         state.nodes.push(node);
       }
 
-      this.remove();
+      this.dangerouslyRemove();
     }
   }
 };
@@ -82,6 +81,8 @@ export default class SystemFormatter extends AMDFormatter {
     this.exportIdentifier = file.scope.generateUidIdentifier("export");
     this.noInteropRequireExport = true;
     this.noInteropRequireImport = true;
+
+    this.remaps.clearAll();
   }
 
   _addImportSource(node, exportNode) {
@@ -100,14 +101,14 @@ export default class SystemFormatter extends AMDFormatter {
     var right = objectIdentifier;
 
     var block = t.blockStatement([
-      t.expressionStatement(this.buildExportCall(leftIdentifier, valIdentifier))
+      t.expressionStatement(this._buildExportCall(leftIdentifier, valIdentifier))
     ]);
 
     return this._addImportSource(t.forInStatement(left, right, block), node);
   }
 
   buildExportsAssignment(id, init, node) {
-    var call = this.buildExportCall(t.literal(id.name), init, true);
+    var call = this._buildExportCall(t.literal(id.name), init, true);
     return this._addImportSource(call, node);
   }
 
@@ -119,13 +120,13 @@ export default class SystemFormatter extends AMDFormatter {
     var assign = node;
 
     for (var i = 0; i < exported.length; i++) {
-      assign = this.buildExportCall(t.literal(exported[i].name), assign);
+      assign = this._buildExportCall(t.literal(exported[i].name), assign);
     }
 
     return assign;
   }
 
-  buildExportCall(id, init, isStatement) {
+  _buildExportCall(id, init, isStatement) {
     var call = t.callExpression(this.exportIdentifier, [id, init]);
     if (isStatement) {
       return t.expressionStatement(call);
@@ -137,18 +138,18 @@ export default class SystemFormatter extends AMDFormatter {
   importSpecifier(specifier, node, nodes) {
     AMDFormatter.prototype.importSpecifier.apply(this, arguments);
 
-    for (var name in this.internalRemap) {
+    for (var remap of (this.remaps.getAll(): Array)) {
       nodes.push(t.variableDeclaration("var", [
-        t.variableDeclarator(t.identifier(name), this.internalRemap[name])
+        t.variableDeclarator(t.identifier(remap.name), remap.node)
       ]));
     }
 
-    this.internalRemap = {};
+    this.remaps.clearAll();
 
     this._addImportSource(last(nodes), node);
   }
 
-  buildRunnerSetters(block, hoistDeclarators) {
+  _buildRunnerSetters(block, hoistDeclarators) {
     var scope = this.file.scope;
 
     return t.arrayExpression(map(this.ids, function (uid, source) {
@@ -164,7 +165,7 @@ export default class SystemFormatter extends AMDFormatter {
     }));
   }
 
-  canHoist(node) {
+  _canHoist(node) {
     return node._blockHoist && !this.file.dynamicImports.length;
   }
 
@@ -181,7 +182,7 @@ export default class SystemFormatter extends AMDFormatter {
       MODULE_DEPENDENCIES: t.arrayExpression(this.buildDependencyLiterals()),
       EXPORT_IDENTIFIER:   this.exportIdentifier,
       MODULE_NAME:         moduleNameLiteral,
-      SETTERS:             this.buildRunnerSetters(block, hoistDeclarators),
+      SETTERS:             this._buildRunnerSetters(block, hoistDeclarators),
       EXECUTE:             t.functionExpression(null, [], block)
     }, true);
 

src/babel/transformation/pipeline.js

@@ -1,10 +1,11 @@
-import Transformer from "./transformer";
+import PluginManager from "./file/plugin-manager";
 import normalizeAst from "../helpers/normalize-ast";
+import Plugin from "./plugin";
 import assign from "lodash/object/assign";
 import object from "../helpers/object";
 import File from "./file";
 
-export default class TransformerPipeline {
+export default class Pipeline {
   constructor() {
     this.transformers = object();
     this.namespaces   = object();
@@ -20,7 +21,7 @@ export default class TransformerPipeline {
     return this;
   }
 
-  addTransformer(key, transformer) {
+  addTransformer(key, plugin) {
     if (this.transformers[key]) throw new Error(); // todo: error
 
     var namespace = key.split(".")[0];
@@ -28,7 +29,19 @@ export default class TransformerPipeline {
     this.namespaces[namespace].push(key);
     this.namespaces[key] = namespace;
 
-    this.transformers[key] = new Transformer(key, transformer);
+    if (typeof plugin === "function") {
+      plugin = PluginManager.memoisePluginContainer(plugin);
+      plugin.key = key;
+      plugin.metadata.optional = true;
+
+      if (key === "react.displayName") {
+        plugin.metadata.optional = false;
+      }
+    } else {
+      plugin = new Plugin(key, plugin);
+    }
+
+    this.transformers[key] = plugin;
   }
 
   addAliases(names) {
@@ -46,19 +59,39 @@ export default class TransformerPipeline {
     return this;
   }
 
-  canTransform(transformer, fileOpts) {
+  canTransform(plugin, fileOpts) {
+    if (plugin.metadata.plugin) {
+      return true;
+    }
+
     for (var filter of (this.filters: Array)) {
-      var result = filter(transformer, fileOpts);
+      var result = filter(plugin, fileOpts);
       if (result != null) return result;
     }
 
     return true;
   }
 
+  analyze(code: string, opts?: Object = {}) {
+    opts.code = false;
+    return this.transform(code, opts);
+  }
+
+  pretransform(code: string, opts?: Object) {
+    var file = new File(opts, this);
+    return file.wrap(code, function () {
+      file.addCode(code);
+      file.parseCode(code);
+      return file;
+    });
+  }
+
   transform(code: string, opts?: Object) {
     var file = new File(opts, this);
     return file.wrap(code, function () {
-      file.addCode(code, true);
+      file.addCode(code);
+      file.parseCode(code);
+      return file.transform();
     });
   }
 
@@ -69,6 +102,7 @@ export default class TransformerPipeline {
     return file.wrap(code, function () {
       file.addCode(code);
       file.addAst(ast);
+      return file.transform();
     });
   }
 

src/babel/transformation/plugin-pass.js

@@ -0,0 +1,34 @@
+import type Transformer from "./transformer";
+import traverse from "../traversal";
+import type File from "./file";
+
+/**
+ * This class is responsible for traversing over the provided `File`s
+ * AST and running it's parent transformers handlers over it.
+ */
+
+export default class PluginPass {
+  constructor(file: File, plugin: Transformer) {
+    this.plugin = plugin;
+    this.file   = file;
+    this.key    = plugin.key;
+
+    if (this.canTransform() && plugin.metadata.experimental && !file.opts.experimental) {
+      file.log.warn(`THE TRANSFORMER ${this.key} HAS BEEN MARKED AS EXPERIMENTAL AND IS WIP. USE AT YOUR OWN RISK. ` +
+                    "THIS WILL HIGHLY LIKELY BREAK YOUR CODE SO USE WITH **EXTREME** CAUTION. ENABLE THE " +
+                    "`experimental` OPTION TO IGNORE THIS WARNING.");
+    }
+  }
+
+  canTransform(): boolean {
+    return this.file.transformerDependencies[this.key] ||
+           this.file.pipeline.canTransform(this.plugin, this.file.opts);
+  }
+
+  transform() {
+    var file = this.file;
+    file.log.debug(`Start transformer ${this.key}`);
+    traverse(file.ast, this.plugin.visitor, file.scope, file);
+    file.log.debug(`Finish transformer ${this.key}`);
+  }
+}

src/babel/transformation/plugin.js

@@ -0,0 +1,55 @@
+import PluginPass from "./plugin-pass";
+import * as messages from "../messages";
+import isFunction from "lodash/lang/isFunction";
+import traverse from "../traversal";
+import assign from "lodash/object/assign";
+import clone from "lodash/lang/clone";
+import File from "./file";
+
+export default class Plugin {
+  constructor(key: string, plugin: Object) {
+    plugin = assign({}, plugin);
+
+    var take = function (key) {
+      var val = plugin[key];
+      delete plugin[key];
+      return val;
+    };
+
+    this.manipulateOptions = take("manipulateOptions");
+    this.metadata          = take("metadata") || {};
+    this.dependencies      = this.metadata.dependencies || [];
+    this.post              = take("post");
+    this.pre               = take("pre");
+
+    //
+
+    if (this.metadata.stage != null) {
+      this.metadata.optional = true;
+    }
+
+    //
+
+    this.visitor = this.normalize(clone(take("visitor")) || {});
+    this.key     = key;
+  }
+
+  normalize(visitor: Object): Object {
+    if (isFunction(visitor)) {
+      visitor = { ast: visitor };
+    }
+
+    traverse.explode(visitor);
+
+    return visitor;
+  }
+
+  buildPass(file: File): PluginPass {
+    // validate Transformer instance
+    if (!(file instanceof File)) {
+      throw new TypeError(messages.get("pluginNotFile", this.key));
+    }
+
+    return new PluginPass(file, this);
+  }
+}

src/babel/transformation/templates/class-derived-default-constructor.js

@@ -0,0 +1,3 @@
+(function () {
+  super(...arguments);
+})

src/babel/transformation/templates/class-super-constructor-call-loose.js

@@ -1,3 +0,0 @@
-if (SUPER_NAME != null) {
-  SUPER_NAME.apply(this, arguments);
-}

src/babel/transformation/templates/class-super-constructor-call.js

@@ -1,3 +0,0 @@
-if (SUPER_NAME != null) {
-  SUPER_NAME.apply(this, arguments);
-}

src/babel/transformation/templates/class-super-native-constructor-call.js

@@ -1,5 +0,0 @@
-if (SUPER_NAME != null) {
-  var NATIVE_REF = new SUPER_NAME(...arguments);
-  NATIVE_REF.__proto__ = CLASS_NAME.prototype;
-  return NATIVE_REF;
-}

src/babel/transformation/templates/default-parameter-assign.js

@@ -0,0 +1 @@
+if (VARIABLE_NAME === undefined) VARIABLE_NAME = DEFAULT_VALUE;

src/babel/transformation/templates/helper-create-decorated-object.js

@@ -28,8 +28,9 @@
 
     if (descriptor.initializer) {
       descriptor.value = descriptor.initializer.call(target);
-      Object.defineProperty(target, key, descriptor);
     }
+
+    Object.defineProperty(target, key, descriptor);
   }
 
   return target;

src/babel/transformation/templates/helper-define-decorated-property-descriptor.js

@@ -1,12 +1,12 @@
 (function (target, key, descriptors) {
   var _descriptor = descriptors[key];
+  if (!_descriptor) return;
 
   // clone it
   var descriptor = {};
   for (var _key in _descriptor) descriptor[_key] = _descriptor[_key];
 
   // initialize it
-  if (!descriptor.initializer) return;
   descriptor.value = descriptor.initializer.call(target);
 
   Object.defineProperty(target, key, descriptor);