Delete --harmony-computed-property-names flag

test/mjsunit/harmony/computed-property-names-classes.js

Index: test/mjsunit/harmony/computed-property-names-classes.js
diff --git a/test/mjsunit/harmony/computed-property-names-classes.js b/test/mjsunit/harmony/computed-property-names-classes.js
deleted file mode 100644
index 46a9e9ec2de7025f5ebc8b988ff106eed562c0d0..0000000000000000000000000000000000000000
--- a/test/mjsunit/harmony/computed-property-names-classes.js
+++ /dev/null
@@ -1,463 +0,0 @@
-// Copyright 2014 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.
-
-'use strict';
-
-// Flags: --harmony-computed-property-names
-
-
-function ID(x) {
-  return x;
-}
-
-
-(function TestClassMethodString() {
-  class C {
-    a() { return 'A'}
-    ['b']() { return 'B'; }
-    c() { return 'C'; }
-    [ID('d')]() { return 'D'; }
-  }
-  assertEquals('A', new C().a());
-  assertEquals('B', new C().b());
-  assertEquals('C', new C().c());
-  assertEquals('D', new C().d());
-  assertArrayEquals([], Object.keys(C.prototype));
-  assertArrayEquals(['constructor', 'a', 'b', 'c', 'd'],
-                    Object.getOwnPropertyNames(C.prototype));
-})();
-
-
-(function TestClassMethodNumber() {
-  class C {
-    a() { return 'A'; }
-    [1]() { return 'B'; }
-    c() { return 'C'; }
-    [ID(2)]() { return 'D'; }
-  }
-  assertEquals('A', new C().a());
-  assertEquals('B', new C()[1]());
-  assertEquals('C', new C().c());
-  assertEquals('D', new C()[2]());
-  // Array indexes first.
-  assertArrayEquals([], Object.keys(C.prototype));
-  assertArrayEquals(['1', '2', 'constructor', 'a', 'c'],
-                    Object.getOwnPropertyNames(C.prototype));
-})();
-
-
-(function TestClassMethodSymbol() {
-  var sym1 = Symbol();
-  var sym2 = Symbol();
-  class C {
-    a() { return 'A'; }
-    [sym1]() { return 'B'; }
-    c() { return 'C'; }
-    [ID(sym2)]() { return 'D'; }
-  }
-  assertEquals('A', new C().a());
-  assertEquals('B', new C()[sym1]());
-  assertEquals('C', new C().c());
-  assertEquals('D', new C()[sym2]());
-  assertArrayEquals([], Object.keys(C.prototype));
-  assertArrayEquals(['constructor', 'a', 'c'],
-                    Object.getOwnPropertyNames(C.prototype));
-  assertArrayEquals([sym1, sym2], Object.getOwnPropertySymbols(C.prototype));
-})();
-
-
-
-(function TestStaticClassMethodString() {
-  class C {
-    static a() { return 'A'}
-    static ['b']() { return 'B'; }
-    static c() { return 'C'; }
-    static ['d']() { return 'D'; }
-  }
-  assertEquals('A', C.a());
-  assertEquals('B', C.b());
-  assertEquals('C', C.c());
-  assertEquals('D', C.d());
-  assertArrayEquals([], Object.keys(C));
-  // TODO(arv): It is not clear that we are adding the "standard" properties
-  // in the right order. As far as I can tell the spec adds them in alphabetical
-  // order.
-  assertArrayEquals(['length', 'name', 'prototype', 'a', 'b', 'c', 'd'],
-                    Object.getOwnPropertyNames(C));
-})();
-
-
-(function TestStaticClassMethodNumber() {
-  class C {
-    static a() { return 'A'; }
-    static [1]() { return 'B'; }
-    static c() { return 'C'; }
-    static [2]() { return 'D'; }
-  }
-  assertEquals('A', C.a());
-  assertEquals('B', C[1]());
-  assertEquals('C', C.c());
-  assertEquals('D', C[2]());
-  // Array indexes first.
-  assertArrayEquals([], Object.keys(C));
-  assertArrayEquals(['1', '2', 'length', 'name', 'prototype', 'a', 'c'],
-                    Object.getOwnPropertyNames(C));
-})();
-
-
-(function TestStaticClassMethodSymbol() {
-  var sym1 = Symbol();
-  var sym2 = Symbol();
-  class C {
-    static a() { return 'A'; }
-    static [sym1]() { return 'B'; }
-    static c() { return 'C'; }
-    static [sym2]() { return 'D'; }
-  }
-  assertEquals('A', C.a());
-  assertEquals('B', C[sym1]());
-  assertEquals('C', C.c());
-  assertEquals('D', C[sym2]());
-  assertArrayEquals([], Object.keys(C));
-  assertArrayEquals(['length', 'name', 'prototype', 'a', 'c'],
-                    Object.getOwnPropertyNames(C));
-  assertArrayEquals([sym1, sym2], Object.getOwnPropertySymbols(C));
-})();
-
-
-
-function assertIteratorResult(value, done, result) {
-  assertEquals({ value: value, done: done}, result);
-}
-
-
-(function TestGeneratorComputedName() {
-  class C {
-    *['a']() {
-      yield 1;
-      yield 2;
-    }
-  }
-  var iter = new C().a();
-  assertIteratorResult(1, false, iter.next());
-  assertIteratorResult(2, false, iter.next());
-  assertIteratorResult(undefined, true, iter.next());
-  assertArrayEquals([], Object.keys(C.prototype));
-  assertArrayEquals(['constructor', 'a'],
-                    Object.getOwnPropertyNames(C.prototype));
-})();
-
-
-(function TestToNameSideEffects() {
-  var counter = 0;
-  var key1 = {
-    toString: function() {
-      assertEquals(0, counter++);
-      return 'b';
-    }
-  };
-  var key2 = {
-    toString: function() {
-      assertEquals(1, counter++);
-      return 'd';
-    }
-  };
-  class C {
-    a() { return 'A'; }
-    [key1]() { return 'B'; }
-    c() { return 'C'; }
-    [key2]() { return 'D'; }
-  }
-  assertEquals(2, counter);
-  assertEquals('A', new C().a());
-  assertEquals('B', new C().b());
-  assertEquals('C', new C().c());
-  assertEquals('D', new C().d());
-  assertArrayEquals([], Object.keys(C.prototype));
-  assertArrayEquals(['constructor', 'a', 'b', 'c', 'd'],
-                    Object.getOwnPropertyNames(C.prototype));
-})();
-
-
-(function TestToNameSideEffectsNumbers() {
-  var counter = 0;
-  var key1 = {
-    valueOf: function() {
-      assertEquals(0, counter++);
-      return 1;
-    },
-    toString: null
-  };
-  var key2 = {
-    valueOf: function() {
-      assertEquals(1, counter++);
-      return 2;
-    },
-    toString: null
-  };
-
-  class C {
-    a() { return 'A'; }
-    [key1]() { return 'B'; }
-    c() { return 'C'; }
-    [key2]() { return 'D'; }
-  }
-  assertEquals(2, counter);
-  assertEquals('A', new C().a());
-  assertEquals('B', new C()[1]());
-  assertEquals('C', new C().c());
-  assertEquals('D', new C()[2]());
-  // Array indexes first.
-  assertArrayEquals([], Object.keys(C.prototype));
-  assertArrayEquals(['1', '2', 'constructor', 'a', 'c'],
-                    Object.getOwnPropertyNames(C.prototype));
-})();
-
-
-(function TestGetter() {
-  class C {
-    get ['a']() {
-      return 'A';
-    }
-  }
-  assertEquals('A', new C().a);
-
-  class C2 {
-    get b() {
-      assertUnreachable();
-    }
-    get ['b']() {
-      return 'B';
-    }
-  }
-  assertEquals('B', new C2().b);
-
-  class C3 {
-    get c() {
-      assertUnreachable();
-    }
-    get ['c']() {
-      assertUnreachable();
-    }
-    get ['c']() {
-      return 'C';
-    }
-  }
-  assertEquals('C', new C3().c);
-
-  class C4 {
-    get ['d']() {
-      assertUnreachable();
-    }
-    get d() {
-      return 'D';
-    }
-  }
-  assertEquals('D', new C4().d);
-})();
-
-
-(function TestSetter() {
-  var calls = 0;
-  class C {
-    set ['a'](_) {
-      calls++;
-    }
-  }
-  new C().a = 'A';
-  assertEquals(1, calls);
-
-  calls = 0;
-  class C2 {
-    set b(_) {
-      assertUnreachable();
-    }
-    set ['b'](_) {
-      calls++;
-    }
-  }
-  new C2().b = 'B';
-  assertEquals(1, calls);
-
-  calls = 0;
-  class C3 {
-    set c(_) {
-      assertUnreachable()
-    }
-    set ['c'](_) {
-      assertUnreachable()
-    }
-    set ['c'](_) {
-      calls++
-    }
-  }
-  new C3().c = 'C';
-  assertEquals(1, calls);
-
-  calls = 0;
-  class C4 {
-    set ['d'](_) {
-      assertUnreachable()
-    }
-    set d(_) {
-      calls++
-    }
-  }
-  new C4().d = 'D';
-  assertEquals(1, calls);
-})();
-
-
-(function TestPrototype() {
-  assertThrows(function() {
-    class C {
-      static ['prototype']() {
-        return 1;
-      }
-    }
-  }, TypeError);
-
-  assertThrows(function() {
-    class C2 {
-      static get ['prototype']() {
-        return 2;
-      }
-    }
-  }, TypeError);
-
-  assertThrows(function() {
-    class C3 {
-      static set ['prototype'](x) {
-        assertEquals(3, x);
-      }
-    }
-  }, TypeError);
-
-  assertThrows(function() {
-    class C4 {
-      static *['prototype']() {
-        yield 1;
-        yield 2;
-      }
-    }
-  }, TypeError);
-})();
-
-
-(function TestPrototypeConcat() {
-  assertThrows(function() {
-    class C {
-      static ['pro' + 'tot' + 'ype']() {
-        return 1;
-      }
-    }
-  }, TypeError);
-
-  assertThrows(function() {
-    class C2 {
-      static get ['pro' + 'tot' + 'ype']() {
-        return 2;
-      }
-    }
-  }, TypeError);
-
-  assertThrows(function() {
-    class C3 {
-      static set ['pro' + 'tot' + 'ype'](x) {
-        assertEquals(3, x);
-      }
-    }
-  }, TypeError);
-
-  assertThrows(function() {
-    class C4 {
-      static *['pro' + 'tot' + 'ype']() {
-        yield 1;
-        yield 2;
-      }
-    }
-  }, TypeError);
-})();
-
-
-(function TestConstructor() {
-  // Normally a constructor property is not allowed.
-  class C {
-    ['constructor']() {
-      return 1;
-    }
-  }
-  assertTrue(C !== C.prototype.constructor);
-  assertEquals(1, new C().constructor());
-
-  class C2 {
-    get ['constructor']() {
-      return 2;
-    }
-  }
-  assertEquals(2, new C2().constructor);
-
-  var calls = 0;
-  class C3 {
-    set ['constructor'](x) {
-      assertEquals(3, x);
-      calls++;
-    }
-  }
-  new C3().constructor = 3;
-  assertEquals(1, calls);
-
-  class C4 {
-    *['constructor']() {
-      yield 1;
-      yield 2;
-    }
-  }
-  var iter = new C4().constructor();
-  assertIteratorResult(1, false, iter.next());
-  assertIteratorResult(2, false, iter.next());
-  assertIteratorResult(undefined, true, iter.next());
-})();
-
-
-(function TestExceptionInName() {
-  function MyError() {};
-  function throwMyError() {
-    throw new MyError();
-  }
-  assertThrows(function() {
-    class C {
-      [throwMyError()]() {}
-    }
-  }, MyError);
-  assertThrows(function() {
-    class C {
-      get [throwMyError()]() { return 42; }
-    }
-  }, MyError);
-  assertThrows(function() {
-    class C {
-      set [throwMyError()](_) { }
-    }
-  }, MyError);
-})();
-
-
-(function TestTdzName() {
-  assertThrows(function() {
-    class C {
-      [C]() {}
-    }
-  }, ReferenceError);
-  assertThrows(function() {
-    class C {
-      get [C]() { return 42; }
-    }
-  }, ReferenceError);
-  assertThrows(function() {
-    class C {
-      set [C](_) { }
-    }
-  }, ReferenceError);
-})();