node/deps/v8/test/mjsunit/strong/class-literals.js

// Copyright 2015 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// Flags: --strong-mode --allow-natives-syntax

'use strict';

function assertWeakClassWeakInstances(x) {
  assertFalse(%IsStrong(x));
  assertFalse(%IsStrong(x.prototype));
  assertFalse(%IsStrong(new x));
}

function assertWeakClassStrongInstances(x) {
  assertFalse(%IsStrong(x));
  assertFalse(%IsStrong(x.prototype));
  assertTrue(%IsStrong(new x));
}

function assertStrongClassWeakInstances(x) {
  assertTrue(%IsStrong(x));
  assertTrue(%IsStrong(x.prototype));
  assertFalse(%IsStrong(new x));
}

function assertStrongClassStrongInstances(x) {
  assertTrue(%IsStrong(x));
  assertTrue(%IsStrong(x.prototype));
  assertTrue(%IsStrong(new x));
}

function getWeakClass() {
  return (class {});
}

function getWeakClassExtends(x) {
  return (class extends x {});
}

function getStrongClass() {
  "use strong";
  return (class {});
}

function getStrongClassExtends(x) {
  "use strong";
  return (class extends x {});
}

(function SimpleWeakClassLiterals() {
  class C {};
  class D extends C {};
  class E extends Object {};

  assertWeakClassWeakInstances(C);
  assertWeakClassWeakInstances(D);
  assertWeakClassWeakInstances(E);

  assertWeakClassWeakInstances(class {});
  assertWeakClassWeakInstances(class extends Object {});
  assertWeakClassWeakInstances(class extends C {});
  assertWeakClassWeakInstances(class extends class {} {});
})();

(function SimpleStrongClassLiterals() {
  'use strong';
  class C {};
  class D extends C {};

  assertStrongClassStrongInstances(C);
  assertStrongClassStrongInstances(D);

  assertStrongClassStrongInstances(class {});
  assertStrongClassStrongInstances(class extends C {});
  assertStrongClassStrongInstances(class extends class {} {});
})();

(function MixedWeakClassLiterals() {
  class C extends getStrongClass() {};
  class D extends getStrongClassExtends((class {})) {};
  class E extends getStrongClassExtends(C) {};

  assertWeakClassStrongInstances(C);
  assertWeakClassStrongInstances(class extends getStrongClass() {});

  assertWeakClassWeakInstances(D);
  assertWeakClassWeakInstances(
    class extends getStrongClassExtends((class {})) {});

  assertWeakClassStrongInstances(E);
  assertWeakClassStrongInstances(
    class extends getStrongClassExtends(class extends getStrongClass() {}) {});
})();

(function MixedStrongClassLiterals() {
  'use strong';
  class C extends getWeakClass() {};
  class D extends getWeakClassExtends((class {})) {};
  class E extends getWeakClassExtends(C) {};
  class F extends Object {};

  assertStrongClassWeakInstances(C);
  assertStrongClassWeakInstances(class extends getWeakClass() {});

  assertStrongClassStrongInstances(D);
  assertStrongClassStrongInstances(
    class extends getWeakClassExtends((class {})) {});

  assertStrongClassWeakInstances(E);
  assertStrongClassWeakInstances(
    class extends getWeakClassExtends(class extends getWeakClass() {}) {});

  assertStrongClassWeakInstances(F);
  assertStrongClassWeakInstances(class extends Object {});
})();

(function WeakMonkeyPatchedClassLiterals() {
  class C {};
  assertWeakClassWeakInstances(C);
  C.__proto__ = getStrongClass();
  // C's default constructor doesn't call super.
  assertWeakClassWeakInstances(C);

  class D extends Object {};
  assertWeakClassWeakInstances(D);
  D.__proto__ = getStrongClass();
  // D is a derived class, so its default constructor calls super.
  assertWeakClassStrongInstances(D);

  class E extends (class {}) {};
  E.__proto__ = C;
  assertWeakClassWeakInstances(E);

  class F extends (class {}) {};
  F.__proto__ = D;
  assertWeakClassStrongInstances(F);

  class G extends getStrongClass() {};
  G.__proto__ = getWeakClass();
  assertWeakClassWeakInstances(G);
})();

(function StrongMonkeyPatchedClassLiterals() {
  let C = getStrongClassExtends(getWeakClassExtends(getStrongClass()));
  let D = getStrongClassExtends(getWeakClassExtends(getWeakClass()));

  assertStrongClassStrongInstances(C);
  C.__proto__.__proto__ = getWeakClass();
  assertStrongClassWeakInstances(C);
  C.__proto__.__proto__ = getStrongClass();
  assertStrongClassStrongInstances(C);

  assertStrongClassWeakInstances(D);
  D.__proto__.__proto__ = getStrongClass();
  assertStrongClassStrongInstances(D);
  D.__proto__.__proto__ = getWeakClass();
  assertStrongClassWeakInstances(D);
})();