Refactor ObjectGetOwnPropertyKeys to accept bitmask rather than boolean

src/v8natives.js

 // Copyright 2012 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.
 
 // This file relies on the fact that the following declarations have been made
 // in runtime.js:
 // var $Object = global.Object;
 // var $Boolean = global.Boolean;
 // var $Number = global.Number;
 // var $Function = global.Function;
@@ skipping 1020 matching lines @@
     }
     array[index] = s;
     ++realLength;
     names[s] = 0;
   }
   array.length = realLength;
   return array;
 }
 
 
-function ObjectGetOwnPropertyKeys(obj, symbolsOnly) {
+function ObjectGetOwnPropertyKeys(obj, filter) {
   var nameArrays = new InternalArray();
-  var filter = symbolsOnly ?
-      PROPERTY_ATTRIBUTES_STRING | PROPERTY_ATTRIBUTES_PRIVATE_SYMBOL :
-      PROPERTY_ATTRIBUTES_SYMBOLIC;
+  filter = (filter || PROPERTY_ATTRIBUTES_NONE)

[rossberg, 2014/09/10 07:37:59]

Please remove the defaulting and make sure that it's always called with explicit
arguments.

[caitp (gmail), 2014/09/10 16:54:11]

`filter |= PROPERTY_ATTRIBUTES_PRIVATE_SYMBOL` would be semantically the same as
a default PRIVATE_SATTRIBUTES_NONE --- just that it's not clearly spelled out.

I think we do want to always filter out private symbols, since there's probably
never a time to ask for them this way (not in spec, and I can't think of a good
reason to do that)

I will change to |= just to make it shorter though.

+         | PROPERTY_ATTRIBUTES_PRIVATE_SYMBOL;
 
   // Find all the indexed properties.
 
   // Only get own element names if we want to include string keys.
-  if (!symbolsOnly) {
+  if ((filter & PROPERTY_ATTRIBUTES_STRING) === 0) {
     var ownElementNames = %GetOwnElementNames(obj);
     for (var i = 0; i < ownElementNames.length; ++i) {
       ownElementNames[i] = %_NumberToString(ownElementNames[i]);
     }
     nameArrays.push(ownElementNames);
 
     // Get names for indexed interceptor properties.
     var interceptorInfo = %GetInterceptorInfo(obj);
     if ((interceptorInfo & 1) != 0) {
       var indexedInterceptorNames = %GetIndexedInterceptorElementNames(obj);
@@ skipping 21 matching lines @@
       %Apply(InternalArray.prototype.concat,
              nameArrays[0], nameArrays, 1, nameArrays.length - 1);
 
   // Property names are expected to be unique strings,
   // but interceptors can interfere with that assumption.
   if (interceptorInfo != 0) {
     var seenKeys = { __proto__: null };
     var j = 0;
     for (var i = 0; i < propertyNames.length; ++i) {
       var name = propertyNames[i];
-      if (symbolsOnly) {
-        if (!IS_SYMBOL(name) || IS_PRIVATE(name)) continue;
+
+      if (IS_SYMBOL(name)) {
+        if ((filter & PROPERTY_ATTRIBUTES_SYMBOLIC) || IS_PRIVATE(name)) {
+          continue;
+        }
       } else {
-        if (IS_SYMBOL(name)) continue;
+        if (filter & PROPERTY_ATTRIBUTES_STRING) continue;
         name = ToString(name);
       }
+
       if (seenKeys[name]) continue;
       seenKeys[name] = true;
       propertyNames[j++] = name;
     }
     propertyNames.length = j;
   }
 
   return propertyNames;
 }
 
 
 // ES5 section 15.2.3.4.
 function ObjectGetOwnPropertyNames(obj) {
   if (!IS_SPEC_OBJECT(obj)) {
     throw MakeTypeError("called_on_non_object", ["Object.getOwnPropertyNames"]);
   }
   // Special handling for proxies.
   if (%IsJSProxy(obj)) {
     var handler = %GetHandler(obj);
     var names = CallTrap0(handler, "getOwnPropertyNames", UNDEFINED);
     return ToNameArray(names, "getOwnPropertyNames", false);
   }
 
-  return ObjectGetOwnPropertyKeys(obj, false);
+  return ObjectGetOwnPropertyKeys(obj, PROPERTY_ATTRIBUTES_SYMBOLIC);
 }
 
 
 // ES5 section 15.2.3.5.
 function ObjectCreate(proto, properties) {
   if (!IS_SPEC_OBJECT(proto) && proto !== null) {
     throw MakeTypeError("proto_object_or_null", [proto]);
   }
   var obj = {};
   %InternalSetPrototype(obj, proto);
@@ skipping 769 matching lines @@
   }
   if (!IS_SPEC_FUNCTION(method)) {
     throw MakeTypeError('not_iterable', [obj]);
   }
   var iterator = %_CallFunction(obj, method);
   if (!IS_SPEC_OBJECT(iterator)) {
     throw MakeTypeError('not_an_iterator', [iterator]);
   }
   return iterator;
 }