6.0.0

I'm extremely stupid and didn't commit as I go. To anyone reading this
I'm extremely sorry. A lot of these changes are very broad and I plan on
releasing Babel 6.0.0 today live on stage at Ember Camp London so I'm
afraid I couldn't wait. If you're ever in London I'll buy you a beer
(or assorted beverage!) to make up for it, also I'll kiss your feet and
give you a back massage, maybe.

packages/babel-plugin-transform-es2015-parameters/src/default.js

@@ -0,0 +1,149 @@
+import getFunctionArity from "babel-helper-get-function-arity";
+import callDelegate from "babel-helper-call-delegate";
+import template from "babel-template";
+import * as t from "babel-types";
+
+let buildDefaultParam = template(`
+  let VARIABLE_NAME =
+    ARGUMENTS.length <= ARGUMENT_KEY || ARGUMENTS[ARGUMENT_KEY] === undefined ?
+      DEFAULT_VALUE
+    :
+      ARGUMENTS[ARGUMENT_KEY];
+`);
+
+let buildDefaultParamAssign = template(`
+  if (VARIABLE_NAME === undefined) VARIABLE_NAME = DEFAULT_VALUE;
+`);
+
+let buildCutOff = template(`
+  let $0 = arguments[$1];
+`);
+
+function hasDefaults(node) {
+  for (let param of (node.params: Array<Object>)) {
+    if (!t.isIdentifier(param)) return true;
+  }
+  return false;
+}
+
+let iifeVisitor = {
+  ReferencedIdentifier(path, state) {
+    let name = path.node.name;
+    if (name === "eval" || (path.scope.hasOwnBinding(name) && path.scope.getOwnBinding(name).kind !== "param")) {
+      state.iife = true;
+      path.stop();
+    }
+  },
+
+  Scope(path) {
+    // different bindings
+    path.skip();
+  }
+};
+
+export let visitor = {
+  Function(path) {
+    let { node, scope } = path;
+    if (!hasDefaults(node)) return;
+
+    // ensure it's a block, useful for arrow functions
+    path.ensureBlock();
+
+    let state = {
+      iife: false,
+      scope: scope
+    };
+
+    let body = [];
+
+    //
+    let argsIdentifier = t.identifier("arguments");
+    argsIdentifier._shadowedFunctionLiteral = path;
+
+    // push a default parameter definition
+    function pushDefNode(left, right, i) {
+      let defNode;
+      if (exceedsLastNonDefault(i) || t.isPattern(left)) {
+        defNode = buildDefaultParam({
+          VARIABLE_NAME: left,
+          DEFAULT_VALUE: right,
+          ARGUMENT_KEY:  t.numberLiteral(i),
+          ARGUMENTS:     argsIdentifier
+        });
+      } else {
+        defNode = buildDefaultParamAssign({
+          VARIABLE_NAME: left,
+          DEFAULT_VALUE: right
+        });
+      }
+      defNode._blockHoist = node.params.length - i;
+      body.push(defNode);
+    }
+
+    // check if an index exceeds the functions arity
+    function exceedsLastNonDefault(i) {
+      return i + 1 > lastNonDefaultParam;
+    }
+
+    //
+    let lastNonDefaultParam = getFunctionArity(node);
+
+    //
+    let params = path.get("params");
+    for (let i = 0; i < params.length; i++) {
+      let param = params[i];
+
+      if (!param.isAssignmentPattern()) {
+        if (!param.isIdentifier()) {
+          param.traverse(iifeVisitor, state);
+        }
+
+        continue;
+      }
+
+      let left  = param.get("left");
+      let right = param.get("right");
+
+      //
+      if (exceedsLastNonDefault(i) || left.isPattern()) {
+        let placeholder = scope.generateUidIdentifier("x");
+        placeholder._isDefaultPlaceholder = true;
+        node.params[i] = placeholder;
+      } else {
+        node.params[i] = left.node;
+      }
+
+      //
+      if (!state.iife) {
+        if (right.isIdentifier() && scope.hasOwnBinding(right.node.name) && scope.getOwnBinding(right.node.name).kind !== "param") {
+          // the right hand side references a parameter
+          state.iife = true;
+        } else {
+          right.traverse(iifeVisitor, state);
+        }
+      }
+
+      pushDefNode(left.node, right.node, i);
+    }
+
+    // add declarations for trailing parameters
+    for (let i = lastNonDefaultParam + 1; i < node.params.length; i++) {
+      let param = node.params[i];
+      if (param._isDefaultPlaceholder) continue;
+
+      let declar = buildCutOff(param, t.numberLiteral(i));
+      declar._blockHoist = node.params.length - i;
+      body.push(declar);
+    }
+
+    // we need to cut off all trailing parameters
+    node.params = node.params.slice(0, lastNonDefaultParam);
+
+    if (state.iife) {
+      body.push(callDelegate(path, scope));
+      path.set("body", t.blockStatement(body));
+    } else {
+      path.get("body").unshiftContainer("body", body);
+    }
+  }
+};