Merge branch 'proxies'

# Conflicts:
#	src/babel/transformation/file/index.js

src/babel/transformation/file/index.js

@@ -85,7 +85,10 @@ export default class File {
     "default-props"
   ];
 
-  static soloHelpers = [];
+  static soloHelpers = [
+    "proxy-create",
+    "proxy-directory"
+  ];
 
   static options = require("./options");
 

src/babel/transformation/file/options.json

@@ -15,6 +15,10 @@
     "hidden": true
   },
 
+  "pluginOptions": {
+    "hidden": true
+  },
+
   "moduleId": {
     "description": "specify a custom name for module ids",
     "type": "string"

src/babel/transformation/templates/helper-proxy-create.js

@@ -0,0 +1,4 @@
+(function (proxy, directory) {
+  directory.push(proxy);
+  return proxy;
+})

src/babel/transformation/templates/helper-proxy-directory.js

@@ -0,0 +1 @@
+[];

src/babel/transformation/transformers/es6/proxies.js

@@ -0,0 +1,43 @@
+import * as t from "../../../types";
+
+export var metadata = {
+  optional: true
+};
+
+// foo.bar
+export function MemberExpression(node) {
+
+}
+
+// Object.setPrototypeOf
+// Object.preventExtensions
+// Object.keys
+// Object.isExtensible
+// Object.getOwnPropertyDescriptor
+// Object.defineProperty
+export function CallExpression(node) {
+
+}
+
+// delete foo.bar
+export function UnaryExpression(node) {
+
+}
+
+// foo in bar
+export function BinaryExpression(node) {
+
+}
+
+export function AssignmentExpression(node) {
+
+}
+
+// new Proxy
+export function NewExpression(node, parent, scope, file) {
+  if (this.get("callee").isIdentifier({ name: "Proxy" })) {
+    return t.callExpression(file.addHelper("proxy-create"), [node.arguments[0], file.addHelper("proxy-directory")]);
+  } else {
+    // possible proxy constructor
+  }
+}

src/babel/transformation/transformers/index.js

@@ -3,6 +3,7 @@ export default {
   "es7.trailingFunctionCommas":            require("./es7/trailing-function-commas"),
   "es7.asyncFunctions":                    require("./es7/async-functions"),
   "es7.decorators":                        require("./es7/decorators"),
+  "es6.proxies":                           require("./es6/proxies"),
 
   strict:                                  require("./other/strict"),
 

src/babel/traversal/path/hoister.js

@@ -91,7 +91,7 @@ export default class PathHoister {
   run() {
     var node = this.path.node;
     if (node._hoisted) return;
-    this.path._hoisted = true;
+    node._hoisted = true;
 
     this.path.traverse(referenceVisitor, this);
     if (this.foundIncompatible) return;

test/core/fixtures/transformation/es6.proxies/apply-handler.js

@@ -0,0 +1,11 @@
+var proxied = function(){};
+var passed = false;
+var host = {
+  method: new Proxy(proxied, {
+    apply: function (t, thisArg, args) {
+      passed = t === proxied && thisArg === host && args + "" === "foo,bar";
+    }
+  })
+};
+host.method("foo", "bar");
+assert.ok(passed);

test/core/fixtures/transformation/es6.proxies/construct-handler.js

@@ -0,0 +1,9 @@
+var proxied = function(){};
+var passed = false;
+new new Proxy(proxied, {
+  construct: function (t, args) {
+    passed = t === proxied && args + "" === "foo,bar";
+    return {};
+  }
+})("foo","bar");
+assert.ok(passed);

test/core/fixtures/transformation/es6.proxies/define-property-handler.js

@@ -0,0 +1,13 @@
+var proxied = {};
+var passed = false;
+Object.defineProperty(
+  new Proxy(proxied, {
+    defineProperty: function (t, k, d) {
+      passed = t === proxied && k === "foo" && d.value === 5;
+      return true;
+    }
+  }),
+  "foo",
+  { value: 5, configurable: true }
+);
+assert.ok(passed);

test/core/fixtures/transformation/es6.proxies/delete-property-handler.js

@@ -0,0 +1,8 @@
+var proxied = {};
+var passed = false;
+delete new Proxy(proxied, {
+  deleteProperty: function (t, k) {
+    passed = t === proxied && k === "foo";
+  }
+}).foo;
+assert.ok(passed);

test/core/fixtures/transformation/es6.proxies/enumerate-handler.js

@@ -0,0 +1,13 @@
+var proxied = {};
+var passed = false;
+for (var i in
+  new Proxy(proxied, {
+    enumerate: function (t) {
+      passed = t === proxied;
+      return {
+        next: function(){ return { done: true, value: null };}
+      };
+    }
+  })
+) { }
+assert.ok(passed);

test/core/fixtures/transformation/es6.proxies/get-handler-instance-of-proxies.js

@@ -0,0 +1,7 @@
+var proxied = { };
+var proxy = Object.create(new Proxy(proxied, {
+  get: function (t, k, r) {
+    return t === proxied && k === "foo" && r === proxy && 5;
+  }
+}));
+assert.equal(proxy.foo, 5);

test/core/fixtures/transformation/es6.proxies/get-handler.js

@@ -0,0 +1,7 @@
+var proxied = {};
+var proxy = new Proxy(proxied, {
+  get: function (t, k, r) {
+    return t === proxied && k === "foo" && r === proxy && 5;
+  }
+});
+assert.equal(proxy.foo, 5);

test/core/fixtures/transformation/es6.proxies/get-own-property-descriptor-handler.js

@@ -0,0 +1,14 @@
+var proxied = {};
+var fakeDesc = { value: "foo", configurable: true };
+var returnedDesc = Object.getOwnPropertyDescriptor(
+  new Proxy(proxied, {
+    getOwnPropertyDescriptor: function (t, k) {
+      return t === proxied && k === "foo" && fakeDesc;
+    }
+  }),
+  "foo"
+);
+assert.equal(returnedDesc.value, fakeDesc.value);
+assert.equal(returnedDesc.configurable, fakeDesc.configurable);
+assert.equal(returnedDesc.writable, false);
+assert.equal(returnedDesc.enumerable, false);

test/core/fixtures/transformation/es6.proxies/get-prototype-of-handler.js

@@ -0,0 +1,8 @@
+var proxied = {};
+var fakeProto = {};
+var proxy = new Proxy(proxied, {
+  getPrototypeOf: function (t) {
+    return t === proxied && fakeProto;
+  }
+});
+assert.equal(Object.getPrototypeOf(proxy), fakeProto);

test/core/fixtures/transformation/es6.proxies/has-handler-instance-of-proxies.js

@@ -0,0 +1,8 @@
+var proxied = {};
+var passed = false;
+"foo" in Object.create(new Proxy(proxied, {
+  has: function (t, k) {
+    passed = t === proxied && k === "foo";
+  }
+}));
+assert.ok(passed);

test/core/fixtures/transformation/es6.proxies/has-handler.js

@@ -0,0 +1,8 @@
+var proxied = {};
+var passed = false;
+"foo" in new Proxy(proxied, {
+  has: function (t, k) {
+    passed = t === proxied && k === "foo";
+  }
+});
+assert.ok(passed);

test/core/fixtures/transformation/es6.proxies/is-extensible-handler.js

@@ -0,0 +1,10 @@
+var proxied = {};
+var passed = false;
+Object.isExtensible(
+  new Proxy(proxied, {
+    isExtensible: function (t) {
+      passed = t === proxied; return true;
+    }
+  })
+);
+assert.ok(passed);

test/core/fixtures/transformation/es6.proxies/options.json

@@ -0,0 +1,3 @@
+{
+  "optional": ["es6.proxies"]
+}

test/core/fixtures/transformation/es6.proxies/own-keys-handler.js

@@ -0,0 +1,11 @@
+var proxied = {};
+var passed = false;
+Object.keys(
+  new Proxy(proxied, {
+    ownKeys: function (t) {
+      passed = t === proxied; return [];
+    }
+  })
+);
+assert.ok(passed);
+

test/core/fixtures/transformation/es6.proxies/prevent-extensions.js

@@ -0,0 +1,12 @@
+var proxied = {};
+var passed = false;
+Object.preventExtensions(
+  new Proxy(proxied, {
+    preventExtensions: function (t) {
+      passed = t === proxied;
+      return Object.preventExtensions(proxied);
+    }
+  })
+);
+assert.ok(passed);
+

test/core/fixtures/transformation/es6.proxies/set-handler-instance-of-proxies.js

@@ -0,0 +1,10 @@
+var proxied = {};
+var passed = false;
+var proxy = Object.create(new Proxy(proxied, {
+  set: function (t, k, v, r) {
+    passed = t === proxied && k + v === "foobar" && r === proxy;
+  }
+}));
+proxy.foo = "bar";
+assert.ok(passed);
+

test/core/fixtures/transformation/es6.proxies/set-handler.js

@@ -0,0 +1,9 @@
+var proxied = {};
+var passed = false;
+var proxy = new Proxy(proxied, {
+  set: function (t, k, v, r) {
+    passed = t === proxied && k + v === "foobar" && r === proxy;
+  }
+});
+proxy.foo = "bar";
+assert.ok(passed);

test/core/fixtures/transformation/es6.proxies/set-prototype-of-handler.js

@@ -0,0 +1,13 @@
+var proxied = {};
+var newProto = {};
+var passed = false;
+Object.setPrototypeOf(
+  new Proxy(proxied, {
+    setPrototypeOf: function (t, p) {
+      passed = t === proxied && p === newProto;
+      return true;
+    }
+  }),
+  newProto
+);
+assert.ok(passed);