Object.observe support for Function 'prototype' property

test/mjsunit/harmony/object-observe.js

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 437 matching lines @@
     { object: obj, name: prop, type: "new" },
     { object: obj, name: prop, type: "reconfigured" },
     { object: obj, name: prop, type: "updated", oldValue: 9 },
     { object: obj, name: prop, type: "deleted", oldValue: 10 },
     { object: obj, name: prop, type: "new" },
   ]);
   Object.unobserve(obj, observer.callback);
   delete obj[prop];
 }
 
-function TestObserveNonConfigurable(obj, prop) {
+function TestObserveNonConfigurable(obj, prop, desc) {
   reset();
   obj[prop] = 1;
   Object.observe(obj, observer.callback);
   obj[prop] = 4;
   obj[prop] = 4;  // ignored
   obj[prop] = 5;
   Object.defineProperty(obj, prop, {value: 6});
   Object.defineProperty(obj, prop, {value: 6});  // ignored
   Object.defineProperty(obj, prop, {value: 7});
-  Object.defineProperty(obj, prop, {enumerable: true});  // ignored
+  Object.defineProperty(obj, prop,
+                        {enumerable: desc.enumerable});  // ignored
   Object.defineProperty(obj, prop, {writable: false});
   obj[prop] = 7;  // ignored
-  Object.defineProperty(obj, prop, {get: function() {}});  // ignored
   Object.deliverChangeRecords(observer.callback);
   observer.assertCallbackRecords([
     { object: obj, name: prop, type: "updated", oldValue: 1 },
     { object: obj, name: prop, type: "updated", oldValue: 4 },
     { object: obj, name: prop, type: "updated", oldValue: 5 },
     { object: obj, name: prop, type: "updated", oldValue: 6 },
     { object: obj, name: prop, type: "reconfigured", oldValue: 7 },
   ]);
   Object.unobserve(obj, observer.callback);
 }
@@ skipping 55 matching lines @@
 ];
 var properties = ["a", "1", 1, "length", "prototype"];
 
 // Cases that yield non-standard results.
 // TODO(observe): ...or don't work yet.
 function blacklisted(obj, prop) {
   return (obj instanceof Int32Array && prop == 1) ||
     (obj instanceof Int32Array && prop === "length") ||
     (obj instanceof ArrayBuffer && prop == 1) ||
     // TODO(observe): oldValue when reconfiguring array length
-    (obj instanceof Array && prop === "length") ||
-    // TODO(observe): prototype property on functions
-    (obj instanceof Function && prop === "prototype")
+    (obj instanceof Array && prop === "length")
 }
 
 for (var i in objects) for (var j in properties) {
   var obj = objects[i];
   var prop = properties[j];
   if (blacklisted(obj, prop)) continue;
   var desc = Object.getOwnPropertyDescriptor(obj, prop);
   print("***", typeof obj, stringifyNoThrow(obj), prop);
   if (!desc || desc.configurable)
     TestObserveConfigurable(obj, prop);
   else if (desc.writable)
-    TestObserveNonConfigurable(obj, prop);
+    TestObserveNonConfigurable(obj, prop, desc);
 }
 
 
 // Observing array length (including truncation)
 reset();
 var arr = ['a', 'b', 'c', 'd'];
 var arr2 = ['alpha', 'beta'];
 var arr3 = ['hello'];
 arr3[2] = 'goodbye';
 arr3.length = 6;
@@ skipping 238 matching lines @@
 Object.unobserve(dummy, observer.callback);
 var array = [0];
 Object.observe(array, observer.callback);
 array.splice(0, 1);
 Object.deliverChangeRecords(observer.callback);
 observer.assertCallbackRecords([
   { object: array, name: '0', type: 'deleted', oldValue: 0 },
   { object: array, name: 'length', type: 'updated', oldValue: 1},
 ]);
 
+
 // __proto__
 reset();
 var obj = {};
 Object.observe(obj, observer.callback);
 var p = {foo: 'yes'};
 var q = {bar: 'no'};
 obj.__proto__ = p;
 obj.__proto__ = p;  // ignored
 obj.__proto__ = null;
 obj.__proto__ = q;
 // TODO(adamk): Add tests for objects with hidden prototypes
 // once we support observing the global object.
 Object.deliverChangeRecords(observer.callback);
 observer.assertCallbackRecords([
   { object: obj, name: '__proto__', type: 'prototype',
     oldValue: Object.prototype },
   { object: obj, name: '__proto__', type: 'prototype', oldValue: p },
   { object: obj, name: '__proto__', type: 'prototype', oldValue: null },
 ]);
+
+// Function.prototype
+reset();
+var fun = function(){};
+Object.observe(fun, observer.callback);
+var myproto = {foo: 'bar'};
+fun.prototype = myproto;
+fun.prototype = 7;
+fun.prototype = 7;  // ignored
+Object.defineProperty(fun, 'prototype', {value: 8});
+Object.deliverChangeRecords(observer.callback);
+observer.assertRecordCount(3);
+// Manually examine the first record in order to test
+// lazy creation of oldValue
+assertSame(fun, observer.records[0].object);
+assertEquals('prototype', observer.records[0].name);
+assertEquals('updated', observer.records[0].type);
+// The only existing reference to the oldValue object is in this
+// record, so to test that lazy creation happened correctly
+// we compare its constructor to our function (one of the invariants
+// ensured when creating an object via AllocateFunctionPrototype).
+assertSame(fun, observer.records[0].oldValue.constructor);
+observer.records.splice(0, 1);
+observer.assertCallbackRecords([
+  { object: fun, name: 'prototype', type: 'updated', oldValue: myproto },
+  { object: fun, name: 'prototype', type: 'updated', oldValue: 7 },
+]);
+
+// Function.prototype should not be observable except on the object itself
+reset();
+var fun = function(){};
+var obj = { __proto__: fun };
+Object.observe(obj, observer.callback);
+obj.prototype = 7;
+Object.deliverChangeRecords(observer.callback);
+observer.assertNotCalled();