Implemented Reflect.ownKeys, and added more tests.

es6-shim.js

@@ -2346,8 +2346,24 @@
 
         isExtensible: throwUnlessTargetIsObject(Object.isExtensible),
 
-        // Different name.
-        ownKeys: throwUnlessTargetIsObject(Object.keys),
+        // Basically the result of calling the internal [[OwnPropertyKeys]].
+        // Concatenating propertyNames and propertySymbols should do the trick.
+        // This should continue to work together with a Symbol shim
+        // which overrides Object.getOwnPropertyNames and implements
+        // Object.getOwnPropertySymbols.
+        ownKeys: function ownKeys(target) {
+          if (!ES.TypeIsObject(target)) {
+            throw new TypeError('target must be an object');
+          }
+
+          var keys = Object.getOwnPropertyNames(target);
+
+          if (ES.IsCallable(Object.getOwnPropertySymbols)) {
+            keys = keys.concat(Object.getOwnPropertySymbols(target));
+          }
+
+          return keys;
+        },
 
         preventExtensions: wrapObjectFunction(Object.preventExtensions),
 

test/reflect.js

@@ -366,10 +366,27 @@ describe('Reflect', function () {
       });
     });
 
-    it('should return the same result as Object.keys()', function () {
-      var obj = { foo: 1, bar: 2};
+    it('should return the same result as Object.getOwnPropertyNames if there are no Symbols', function () {
+      var obj = { foo: 1, bar: 2 };
 
-      expect(Reflect.ownKeys(obj)).to.deep.equal(Object.keys(obj));
+      obj[1] = 'first';
+
+      var result = Object.getOwnPropertyNames(obj);
+
+      expect(Reflect.ownKeys(obj)).to.deep.equal(result);
+      expect(result).to.deep.equal(['1', 'foo', 'bar']);
+    });
+
+    (typeof Symbol === 'function' ? it : xit)('symbols come last', function () {
+      var s = Symbol();
+
+      var o = {
+        'non-symbol': true
+      };
+
+      o[s] = true;
+
+      expect(Reflect.ownKeys(o)).to.deep.equal(['non-symbol', s]);
     });
   });