readonly.js 7.18 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
// Copyright 2011 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
//       with the distribution.
//     * Neither the name of Google Inc. nor the names of its
//       contributors may be used to endorse or promote products derived
//       from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

28
// Flags: --allow-natives-syntax
29 30
// This test manually triggers optimization, no need for stress modes.
// Flags: --nostress-opt --noalways-opt
31 32 33 34 35 36 37 38

// Different ways to create an object.

function CreateFromLiteral() {
  return {};
}

function CreateFromObject() {
39
  return new Object();
40 41 42 43 44 45 46 47
}

function CreateDefault() {
  return Object.create(Object.prototype);
}

function CreateFromConstructor(proto) {
  function C() {}
48
  new C().b = 9;  // Make sure that we can have an in-object property.
49
  C.prototype = proto;
50 51 52
  return function() {
    return new C();
  };
53 54 55
}

function CreateFromApi(proto) {
56 57 58
  return function() {
    return Object.create(proto);
  };
59 60 61
}

function CreateWithProperty(proto) {
62 63 64
  function C() {
    this.a = -100;
  }
65
  C.prototype = proto;
66 67 68
  return function() {
    return new C();
  };
69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
}

var bases = [CreateFromLiteral, CreateFromObject, CreateDefault];
var inherits = [CreateFromConstructor, CreateFromApi, CreateWithProperty];
var constructs = [CreateFromConstructor, CreateFromApi];

function TestAllCreates(f) {
  // The depth of the prototype chain up the.
  for (var depth = 0; depth < 3; ++depth) {
    // Introduce readonly-ness this far up the chain.
    for (var up = 0; up <= depth; ++up) {
      // Try different construction methods.
      for (var k = 0; k < constructs.length; ++k) {
        // Construct a fresh prototype chain from above functions.
        for (var i = 0; i < bases.length; ++i) {
          var p = bases[i]();
          // There may be a preexisting property under the insertion point...
          for (var j = 0; j < depth - up; ++j) {
            p = inherits[Math.floor(inherits.length * Math.random())](p)();
          }
          // ...but not above it.
          for (var j = 0; j < up; ++j) {
            p = constructs[Math.floor(constructs.length * Math.random())](p)();
          }
          // Create a fresh constructor.
          var c = constructs[k](p);
          f(function() {
            var o = c();
            o.up = o;
            for (var j = 0; j < up; ++j) o.up = Object.getPrototypeOf(o.up);
            return o;
100
          });
101 102 103 104 105 106 107 108 109 110 111 112 113 114
        }
      }
    }
  }
}


// Different ways to make a property read-only.

function ReadonlyByNonwritableDataProperty(o, name) {
  Object.defineProperty(o, name, {value: -41, writable: false});
}

function ReadonlyByAccessorPropertyWithoutSetter(o, name) {
115 116 117 118 119
  Object.defineProperty(o, name, {
    get: function() {
      return -42;
    }
  });
120 121 122
}

function ReadonlyByGetter(o, name) {
123 124 125
  o.__defineGetter__('a', function() {
    return -43;
  });
126 127 128 129 130 131 132 133 134 135 136 137 138
}

function ReadonlyByFreeze(o, name) {
  o[name] = -44;
  Object.freeze(o);
}

function ReadonlyByProto(o, name) {
  var p = Object.create(o.__proto__);
  Object.defineProperty(p, name, {value: -45, writable: false});
  o.__proto__ = p;
}

139
// TODO(neis,cbruni): Enable once the necessary traps work again.
140 141 142
// Allow Proxy to be undefined, so test can run in non-Harmony mode as well.
var global = this;

143
function ReadonlyByProxy(o, name) {
144
  if (!global.Proxy) return ReadonlyByFreeze(o, name);  // Dummy.
145
  var p = new global.Proxy({}, {
146 147 148 149
    getPropertyDescriptor: function() {
      return {value: -46, writable: false, configurable: true};
    }
  });
150

151 152 153 154 155
  o.__proto__ = p;
}

var readonlys = [
  ReadonlyByNonwritableDataProperty, ReadonlyByAccessorPropertyWithoutSetter,
156 157
  ReadonlyByGetter, ReadonlyByFreeze, ReadonlyByProto  // ReadonlyByProxy
];
158 159 160 161

function TestAllReadonlys(f) {
  // Provide various methods to making a property read-only.
  for (var i = 0; i < readonlys.length; ++i) {
162
    print('  readonly =', i);
163 164 165 166 167 168 169 170 171
    f(readonlys[i]);
  }
}


// Different use scenarios.

function Assign(o, x) {
  o.a = x;
172 173
};
%PrepareFunctionForOptimization(Assign);
174 175 176
function AssignStrict(o, x) {
  "use strict";
  o.a = x;
177 178
};
%PrepareFunctionForOptimization(AssignStrict);
179 180 181 182 183 184 185 186
function TestAllModes(f) {
  for (var strict = 0; strict < 2; ++strict) {
    print(" strict =", strict);
    f(strict);
  }
}

function TestAllScenarios(f) {
187 188
  for (var t = 0; t < 100; t = 2 * t + 1) {
    print('t =', t);
189 190 191 192
    f(function(strict, create, readonly) {
      // Make sure that the assignments are monomorphic.
      %DeoptimizeFunction(Assign);
      %DeoptimizeFunction(AssignStrict);
193 194
      %ClearFunctionFeedback(Assign);
      %ClearFunctionFeedback(AssignStrict);
195 196
      %PrepareFunctionForOptimization(Assign);
      %PrepareFunctionForOptimization(AssignStrict);
197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214
      for (var i = 0; i < t; ++i) {
        var o = create();
        assertFalse("a" in o && !("a" in o.__proto__));
        if (strict === 0)
          Assign(o, i);
        else
          AssignStrict(o, i);
        assertEquals(i, o.a);
      }
      %OptimizeFunctionOnNextCall(Assign);
      %OptimizeFunctionOnNextCall(AssignStrict);
      var o = create();
      assertFalse("a" in o && !("a" in o.__proto__));
      readonly(o.up, "a");
      assertTrue("a" in o);
      if (strict === 0)
        Assign(o, t + 1);
      else
215 216 217 218

        assertThrows(function() {
          AssignStrict(o, t + 1);
        }, TypeError);
219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238
      assertTrue(o.a < 0);
    });
  }
}


// Runner.

TestAllScenarios(function(scenario) {
  TestAllModes(function(strict) {
    TestAllReadonlys(function(readonly) {
      TestAllCreates(function(create) {
        scenario(strict, create, readonly);
      });
    });
  });
});

// Extra test forcing bailout.

239 240 241 242
function Assign2(o, x) {
  o.a = x;
};
%PrepareFunctionForOptimization(Assign2);
243
(function() {
244 245 246
var p = CreateFromConstructor(Object.prototype)();
var c = CreateFromConstructor(p);
for (var i = 0; i < 3; ++i) {
247
  var o = c();
248 249 250 251 252 253 254 255
  Assign2(o, i);
  assertEquals(i, o.a);
}
%OptimizeFunctionOnNextCall(Assign2);
ReadonlyByNonwritableDataProperty(p, "a");
var o = c();
Assign2(o, 0);
assertTrue(o.a < 0);
256
})();