Class methods should be non enumerable

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

 // 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 --harmony-classes
 
 
 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(['a', 'b', 'c', 'd'], Object.keys(C.prototype));
+  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(['1', '2', 'a', 'c'], Object.keys(C.prototype));
+  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(['a', 'c'], Object.keys(C.prototype));
+  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(['a', 'b', 'c', 'd'], Object.keys(C));
+  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', 'arguments', 'caller', '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(['1', '2', 'a', 'c'], Object.keys(C));
+  assertArrayEquals([], Object.keys(C));
+  assertArrayEquals(['1', '2', 'length', 'name', 'arguments', 'caller',
+      '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(['a', 'c'], Object.keys(C));
+  assertArrayEquals([], Object.keys(C));
+  assertArrayEquals(['length', 'name', 'arguments', 'caller', '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(['a'], Object.keys(C.prototype));
+  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(['a', 'b', 'c', 'd'], Object.keys(C.prototype));
+  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;
     },
@@ skipping 12 matching lines @@
     [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(['1', '2', 'a', 'c'], Object.keys(C.prototype));
+  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);
@@ skipping 154 matching lines @@
     *['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());
 })();