Home | History | Annotate | Download | only in harmony
      1 // Copyright 2011 the V8 project authors. All rights reserved.
      2 // Redistribution and use in source and binary forms, with or without
      3 // modification, are permitted provided that the following conditions are
      4 // met:
      5 //
      6 //     * Redistributions of source code must retain the above copyright
      7 //       notice, this list of conditions and the following disclaimer.
      8 //     * Redistributions in binary form must reproduce the above
      9 //       copyright notice, this list of conditions and the following
     10 //       disclaimer in the documentation and/or other materials provided
     11 //       with the distribution.
     12 //     * Neither the name of Google Inc. nor the names of its
     13 //       contributors may be used to endorse or promote products derived
     14 //       from this software without specific prior written permission.
     15 //
     16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     27 
     28 // Flags: --harmony
     29 
     30 
     31 // A simple no-op handler. Adapted from:
     32 // http://wiki.ecmascript.org/doku.php?id=harmony:proxies#examplea_no-op_forwarding_proxy
     33 
     34 function createHandler(obj) {
     35   return {
     36     getOwnPropertyDescriptor: function(name) {
     37       var desc = Object.getOwnPropertyDescriptor(obj, name);
     38       if (desc !== undefined) desc.configurable = true;
     39       return desc;
     40     },
     41     getPropertyDescriptor: function(name) {
     42       var desc = Object.getOwnPropertyDescriptor(obj, name);
     43       //var desc = Object.getPropertyDescriptor(obj, name);  // not in ES5
     44       if (desc !== undefined) desc.configurable = true;
     45       return desc;
     46     },
     47     getOwnPropertyNames: function() {
     48       return Object.getOwnPropertyNames(obj);
     49     },
     50     getPropertyNames: function() {
     51       return Object.getOwnPropertyNames(obj);
     52       //return Object.getPropertyNames(obj);  // not in ES5
     53     },
     54     defineProperty: function(name, desc) {
     55       Object.defineProperty(obj, name, desc);
     56     },
     57     delete: function(name) {
     58       return delete obj[name];
     59     },
     60     fix: function() {
     61       if (Object.isFrozen(obj)) {
     62         var result = {};
     63         Object.getOwnPropertyNames(obj).forEach(function(name) {
     64           result[name] = Object.getOwnPropertyDescriptor(obj, name);
     65         });
     66         return result;
     67       }
     68       // As long as obj is not frozen, the proxy won't allow itself to be fixed
     69       return undefined; // will cause a TypeError to be thrown
     70     },
     71     has: function(name) { return name in obj; },
     72     hasOwn: function(name) { return ({}).hasOwnProperty.call(obj, name); },
     73     get: function(receiver, name) { return obj[name]; },
     74     set: function(receiver, name, val) {
     75       obj[name] = val;  // bad behavior when set fails in non-strict mode
     76       return true;
     77     },
     78     enumerate: function() {
     79       var result = [];
     80       for (var name in obj) { result.push(name); };
     81       return result;
     82     },
     83     keys: function() { return Object.keys(obj); }
     84   };
     85 }
     86 
     87 
     88 
     89 // Auxiliary definitions enabling tracking of object identity in output.
     90 
     91 var objectMap = new WeakMap;
     92 var objectCounter = 0;
     93 
     94 function registerObject(x, s) {
     95   if (x === Object(x) && !objectMap.has(x))
     96     objectMap.set(x, ++objectCounter + (s == undefined ? "" : ":" + s));
     97 }
     98 
     99 registerObject(this, "global");
    100 registerObject(Object.prototype, "Object.prototype");
    101 
    102 function str(x) {
    103   if (x === Object(x)) return "[" + typeof x + " " + objectMap.get(x) + "]";
    104   if (typeof x == "string") return "\"" + x + "\"";
    105   return "" + x;
    106 }
    107 
    108 
    109 
    110 // A simple membrane. Adapted from:
    111 // http://wiki.ecmascript.org/doku.php?id=harmony:proxies#a_simple_membrane
    112 
    113 function createSimpleMembrane(target) {
    114   var enabled = true;
    115 
    116   function wrap(obj) {
    117     registerObject(obj);
    118     print("wrap enter", str(obj));
    119     try {
    120       var x = wrap2(obj);
    121       registerObject(x, "wrapped");
    122       print("wrap exit", str(obj), "as", str(x));
    123       return x;
    124     } catch(e) {
    125       print("wrap exception", str(e));
    126       throw e;
    127     }
    128   }
    129 
    130   function wrap2(obj) {
    131     if (obj !== Object(obj)) {
    132       return obj;
    133     }
    134 
    135     function wrapCall(fun, that, args) {
    136       registerObject(that);
    137       print("wrapCall enter", fun, str(that));
    138       try {
    139         var x = wrapCall2(fun, that, args);
    140         print("wrapCall exit", fun, str(that), "returning", str(x));
    141         return x;
    142       } catch(e) {
    143         print("wrapCall exception", fun, str(that), str(e));
    144         throw e;
    145       }
    146     }
    147 
    148     function wrapCall2(fun, that, args) {
    149       if (!enabled) { throw new Error("disabled"); }
    150       try {
    151         return wrap(fun.apply(that, Array.prototype.map.call(args, wrap)));
    152       } catch (e) {
    153         throw wrap(e);
    154       }
    155     }
    156 
    157     var baseHandler = createHandler(obj);
    158     var handler = Proxy.create(Object.freeze({
    159       get: function(receiver, name) {
    160         return function() {
    161           var arg = (name === "get" || name == "set") ? arguments[1] : "";
    162           print("handler enter", name, arg);
    163           var x = wrapCall(baseHandler[name], baseHandler, arguments);
    164           print("handler exit", name, arg, "returning", str(x));
    165           return x;
    166         }
    167       }
    168     }));
    169     registerObject(baseHandler, "basehandler");
    170     registerObject(handler, "handler");
    171 
    172     if (typeof obj === "function") {
    173       function callTrap() {
    174         print("call trap enter", str(obj), str(this));
    175         var x = wrapCall(obj, wrap(this), arguments);
    176         print("call trap exit", str(obj), str(this), "returning", str(x));
    177         return x;
    178       }
    179       function constructTrap() {
    180         if (!enabled) { throw new Error("disabled"); }
    181         try {
    182           function forward(args) { return obj.apply(this, args) }
    183           return wrap(new forward(Array.prototype.map.call(arguments, wrap)));
    184         } catch (e) {
    185           throw wrap(e);
    186         }
    187       }
    188       return Proxy.createFunction(handler, callTrap, constructTrap);
    189     } else {
    190       var prototype = wrap(Object.getPrototypeOf(obj));
    191       return Proxy.create(handler, prototype);
    192     }
    193   }
    194 
    195   var gate = Object.freeze({
    196     enable: function() { enabled = true; },
    197     disable: function() { enabled = false; }
    198   });
    199 
    200   return Object.freeze({
    201     wrapper: wrap(target),
    202     gate: gate
    203   });
    204 }
    205 
    206 
    207 var o = {
    208   a: 6,
    209   b: {bb: 8},
    210   f: function(x) { return x },
    211   g: function(x) { return x.a },
    212   h: function(x) { this.q = x }
    213 };
    214 o[2] = {c: 7};
    215 var m = createSimpleMembrane(o);
    216 var w = m.wrapper;
    217 print("o =", str(o))
    218 print("w =", str(w));
    219 
    220 var f = w.f;
    221 var x = f(66);
    222 var x = f({a: 1});
    223 var x = w.f({a: 1});
    224 var a = x.a;
    225 assertEquals(6, w.a);
    226 assertEquals(8, w.b.bb);
    227 assertEquals(7, w[2]["c"]);
    228 assertEquals(undefined, w.c);
    229 assertEquals(1, w.f(1));
    230 assertEquals(1, w.f({a: 1}).a);
    231 assertEquals(2, w.g({a: 2}));
    232 assertEquals(3, (w.r = {a: 3}).a);
    233 assertEquals(3, w.r.a);
    234 assertEquals(3, o.r.a);
    235 w.h(3);
    236 assertEquals(3, w.q);
    237 assertEquals(3, o.q);
    238 assertEquals(4, (new w.h(4)).q);
    239 
    240 var wb = w.b;
    241 var wr = w.r;
    242 var wf = w.f;
    243 var wf3 = w.f(3);
    244 var wfx = w.f({a: 6});
    245 var wgx = w.g({a: {aa: 7}});
    246 var wh4 = new w.h(4);
    247 m.gate.disable();
    248 assertEquals(3, wf3);
    249 assertThrows(function() { w.a }, Error);
    250 assertThrows(function() { w.r }, Error);
    251 assertThrows(function() { w.r = {a: 4} }, Error);
    252 assertThrows(function() { o.r.a }, Error);
    253 assertEquals("object", typeof o.r);
    254 assertEquals(5, (o.r = {a: 5}).a);
    255 assertEquals(5, o.r.a);
    256 assertThrows(function() { w[1] }, Error);
    257 assertThrows(function() { w.c }, Error);
    258 assertThrows(function() { wb.bb }, Error);
    259 assertThrows(function() { wr.a }, Error);
    260 assertThrows(function() { wf(4) }, Error);
    261 assertThrows(function() { wfx.a }, Error);
    262 assertThrows(function() { wgx.aa }, Error);
    263 assertThrows(function() { wh4.q }, Error);
    264 
    265 m.gate.enable();
    266 assertEquals(6, w.a);
    267 assertEquals(5, w.r.a);
    268 assertEquals(5, o.r.a);
    269 assertEquals(7, w.r = 7);
    270 assertEquals(7, w.r);
    271 assertEquals(7, o.r);
    272 assertEquals(8, w.b.bb);
    273 assertEquals(7, w[2]["c"]);
    274 assertEquals(undefined, w.c);
    275 assertEquals(8, wb.bb);
    276 assertEquals(3, wr.a);
    277 assertEquals(4, wf(4));
    278 assertEquals(3, wf3);
    279 assertEquals(6, wfx.a);
    280 assertEquals(7, wgx.aa);
    281 assertEquals(4, wh4.q);
    282 
    283 
    284 // An identity-preserving membrane. Adapted from:
    285 // http://wiki.ecmascript.org/doku.php?id=harmony:proxies#an_identity-preserving_membrane
    286 
    287 function createMembrane(wetTarget) {
    288   var wet2dry = WeakMap();
    289   var dry2wet = WeakMap();
    290 
    291   function asDry(obj) {
    292     registerObject(obj)
    293     print("asDry enter", str(obj))
    294     try {
    295       var x = asDry2(obj);
    296       registerObject(x, "dry");
    297       print("asDry exit", str(obj), "as", str(x));
    298       return x;
    299     } catch(e) {
    300       print("asDry exception", str(e));
    301       throw e;
    302     }
    303   }
    304   function asDry2(wet) {
    305     if (wet !== Object(wet)) {
    306       // primitives provide only irrevocable knowledge, so don't
    307       // bother wrapping it.
    308       return wet;
    309     }
    310     var dryResult = wet2dry.get(wet);
    311     if (dryResult) { return dryResult; }
    312 
    313     var wetHandler = createHandler(wet);
    314     var dryRevokeHandler = Proxy.create(Object.freeze({
    315       get: function(receiver, name) {
    316         return function() {
    317           var arg = (name === "get" || name == "set") ? arguments[1] : "";
    318           print("dry handler enter", name, arg);
    319           var optWetHandler = dry2wet.get(dryRevokeHandler);
    320           try {
    321             var x = asDry(optWetHandler[name].apply(
    322               optWetHandler, Array.prototype.map.call(arguments, asWet)));
    323             print("dry handler exit", name, arg, "returning", str(x));
    324             return x;
    325           } catch (eWet) {
    326             var x = asDry(eWet);
    327             print("dry handler exception", name, arg, "throwing", str(x));
    328             throw x;
    329           }
    330         };
    331       }
    332     }));
    333     dry2wet.set(dryRevokeHandler, wetHandler);
    334 
    335     if (typeof wet === "function") {
    336       function callTrap() {
    337         print("dry call trap enter", str(this));
    338         var x = asDry(wet.apply(
    339           asWet(this), Array.prototype.map.call(arguments, asWet)));
    340         print("dry call trap exit", str(this), "returning", str(x));
    341         return x;
    342       }
    343       function constructTrap() {
    344         function forward(args) { return wet.apply(this, args) }
    345         return asDry(new forward(Array.prototype.map.call(arguments, asWet)));
    346       }
    347       dryResult =
    348         Proxy.createFunction(dryRevokeHandler, callTrap, constructTrap);
    349     } else {
    350       dryResult =
    351         Proxy.create(dryRevokeHandler, asDry(Object.getPrototypeOf(wet)));
    352     }
    353     wet2dry.set(wet, dryResult);
    354     dry2wet.set(dryResult, wet);
    355     return dryResult;
    356   }
    357 
    358   function asWet(obj) {
    359     registerObject(obj)
    360     print("asWet enter", str(obj))
    361     try {
    362       var x = asWet2(obj)
    363       registerObject(x, "wet")
    364       print("asWet exit", str(obj), "as", str(x))
    365       return x
    366     } catch(e) {
    367       print("asWet exception", str(e))
    368       throw e
    369     }
    370   }
    371   function asWet2(dry) {
    372     if (dry !== Object(dry)) {
    373       // primitives provide only irrevocable knowledge, so don't
    374       // bother wrapping it.
    375       return dry;
    376     }
    377     var wetResult = dry2wet.get(dry);
    378     if (wetResult) { return wetResult; }
    379 
    380     var dryHandler = createHandler(dry);
    381     var wetRevokeHandler = Proxy.create(Object.freeze({
    382       get: function(receiver, name) {
    383         return function() {
    384           var arg = (name === "get" || name == "set") ? arguments[1] : "";
    385           print("wet handler enter", name, arg);
    386           var optDryHandler = wet2dry.get(wetRevokeHandler);
    387           try {
    388             var x = asWet(optDryHandler[name].apply(
    389               optDryHandler, Array.prototype.map.call(arguments, asDry)));
    390             print("wet handler exit", name, arg, "returning", str(x));
    391             return x;
    392           } catch (eDry) {
    393             var x = asWet(eDry);
    394             print("wet handler exception", name, arg, "throwing", str(x));
    395             throw x;
    396           }
    397         };
    398       }
    399     }));
    400     wet2dry.set(wetRevokeHandler, dryHandler);
    401 
    402     if (typeof dry === "function") {
    403       function callTrap() {
    404         print("wet call trap enter", str(this));
    405         var x = asWet(dry.apply(
    406           asDry(this), Array.prototype.map.call(arguments, asDry)));
    407         print("wet call trap exit", str(this), "returning", str(x));
    408         return x;
    409       }
    410       function constructTrap() {
    411         function forward(args) { return dry.apply(this, args) }
    412         return asWet(new forward(Array.prototype.map.call(arguments, asDry)));
    413       }
    414       wetResult =
    415         Proxy.createFunction(wetRevokeHandler, callTrap, constructTrap);
    416     } else {
    417       wetResult =
    418         Proxy.create(wetRevokeHandler, asWet(Object.getPrototypeOf(dry)));
    419     }
    420     dry2wet.set(dry, wetResult);
    421     wet2dry.set(wetResult, dry);
    422     return wetResult;
    423   }
    424 
    425   var gate = Object.freeze({
    426     revoke: function() {
    427       dry2wet = wet2dry = Object.freeze({
    428         get: function(key) { throw new Error("revoked"); },
    429         set: function(key, val) { throw new Error("revoked"); }
    430       });
    431     }
    432   });
    433 
    434   return Object.freeze({ wrapper: asDry(wetTarget), gate: gate });
    435 }
    436 
    437 
    438 var receiver
    439 var argument
    440 var o = {
    441   a: 6,
    442   b: {bb: 8},
    443   f: function(x) { receiver = this; argument = x; return x },
    444   g: function(x) { receiver = this; argument = x; return x.a },
    445   h: function(x) { receiver = this; argument = x; this.q = x },
    446   s: function(x) { receiver = this; argument = x; this.x = {y: x}; return this }
    447 }
    448 o[2] = {c: 7}
    449 var m = createMembrane(o)
    450 var w = m.wrapper
    451 print("o =", str(o))
    452 print("w =", str(w))
    453 
    454 var f = w.f
    455 var x = f(66)
    456 var x = f({a: 1})
    457 var x = w.f({a: 1})
    458 var a = x.a
    459 assertEquals(6, w.a)
    460 assertEquals(8, w.b.bb)
    461 assertEquals(7, w[2]["c"])
    462 assertEquals(undefined, w.c)
    463 assertEquals(1, w.f(1))
    464 assertSame(o, receiver)
    465 assertEquals(1, w.f({a: 1}).a)
    466 assertSame(o, receiver)
    467 assertEquals(2, w.g({a: 2}))
    468 assertSame(o, receiver)
    469 assertSame(w, w.f(w))
    470 assertSame(o, receiver)
    471 assertSame(o, argument)
    472 assertSame(o, w.f(o))
    473 assertSame(o, receiver)
    474 // Note that argument !== o, since o isn't dry, so gets wrapped wet again.
    475 assertEquals(3, (w.r = {a: 3}).a)
    476 assertEquals(3, w.r.a)
    477 assertEquals(3, o.r.a)
    478 w.h(3)
    479 assertEquals(3, w.q)
    480 assertEquals(3, o.q)
    481 assertEquals(4, (new w.h(4)).q)
    482 assertEquals(5, w.s(5).x.y)
    483 assertSame(o, receiver)
    484 
    485 var wb = w.b
    486 var wr = w.r
    487 var wf = w.f
    488 var wf3 = w.f(3)
    489 var wfx = w.f({a: 6})
    490 var wgx = w.g({a: {aa: 7}})
    491 var wh4 = new w.h(4)
    492 var ws5 = w.s(5)
    493 var ws5x = ws5.x
    494 m.gate.revoke()
    495 assertEquals(3, wf3)
    496 assertThrows(function() { w.a }, Error)
    497 assertThrows(function() { w.r }, Error)
    498 assertThrows(function() { w.r = {a: 4} }, Error)
    499 assertThrows(function() { o.r.a }, Error)
    500 assertEquals("object", typeof o.r)
    501 assertEquals(5, (o.r = {a: 5}).a)
    502 assertEquals(5, o.r.a)
    503 assertThrows(function() { w[1] }, Error)
    504 assertThrows(function() { w.c }, Error)
    505 assertThrows(function() { wb.bb }, Error)
    506 assertEquals(3, wr.a)
    507 assertThrows(function() { wf(4) }, Error)
    508 assertEquals(6, wfx.a)
    509 assertEquals(7, wgx.aa)
    510 assertThrows(function() { wh4.q }, Error)
    511 assertThrows(function() { ws5.x }, Error)
    512 assertThrows(function() { ws5x.y }, Error)
    513