ES6: Add support for Map and Set Iterator

tools/generate-runtime-tests.py

 #!/usr/bin/env python
 # 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.
 
 import itertools
 import js2c
 import multiprocessing
 import optparse
 import os
@@ skipping 33 matching lines @@
 # TYPED_ARRAYS_CHECK_RUNTIME_FUNCTION
 
 # Counts of functions in each detection state. These are used to assert
 # that the parser doesn't bit-rot. Change the values as needed when you add,
 # remove or change runtime functions, but make sure we don't lose our ability
 # to parse them!
 EXPECTED_FUNCTION_COUNT = 358
 EXPECTED_FUZZABLE_COUNT = 325
 EXPECTED_CCTEST_COUNT = 6
 EXPECTED_UNKNOWN_COUNT = 5
-EXPECTED_BUILTINS_COUNT = 782
+EXPECTED_BUILTINS_COUNT = 797
 
 
 # Don't call these at all.
 BLACKLISTED = [
   "Abort",  # Kills the process.
   "AbortJS",  # Kills the process.
   "CompileForOnStackReplacement",  # Riddled with ASSERTs.
   "IS_VAR",  # Not implemented in the runtime.
   "ListNatives",  # Not available in Release mode.
   "SetAllocationTimeout",  # Too slow for fuzzing.
@@ skipping 87 matching lines @@
   "InternalNumberFormat": [_NUMBER_FORMAT, None, None],
   "InternalNumberParse": [_NUMBER_FORMAT, None, None],
   "IsSloppyModeFunction": ["function() {}", None],
   "LoadMutableDouble": ["{foo: 1.2}", None, None],
   "NewObjectFromBound": ["(function() {}).bind({})", None],
   "NumberToRadixString": [None, "2", None],
   "ParseJson": ["\"{}\"", 1],
   "RegExpExecMultiple": [None, None, "['a']", "['a']", None],
   "SetAccessorProperty": [None, None, "undefined", "undefined", None, None,
                           None],
-  "SetCreateIterator": [None, "2", None],
+  "SetIteratorInitialize": [None, None, "2", None],
   "SetDebugEventListener": ["undefined", None, None],
   "SetFunctionBreakPoint": [None, 200, None, None],
   "StringBuilderConcat": ["[1, 2, 3]", 3, None, None],
   "StringBuilderJoin": ["['a', 'b']", 4, None, None],
   "StringMatch": [None, None, "['a', 'b']", None],
   "StringNormalize": [None, 2, None],
   "StringReplaceGlobalRegExpWithString": [None, None, None, "['a']", None],
   "TypedArrayInitialize": [None, 6, "new ArrayBuffer(8)", None, 4, None],
   "TypedArrayInitializeFromArrayLike": [None, 6, None, None, None],
   "TypedArraySetFastCases": [None, None, "0", None],
@@ skipping 343 matching lines @@
         result += self._JSObject(key_name, recursion_budget - 1)
       else:
         result += self._Object(key_name, recursion_budget - 1)
       result += self._Object(value_name, recursion_budget - 1)
       result.append("%s.set(%s, %s)" % (name, key_name, value_name))
     return result
 
   def _JSMapIterator(self, name, recursion_budget):
     map_name = name + "_map"
     result = self._JSMap(map_name, recursion_budget)
-    iterator_type = random.randint(1, 3)
-    return (result + self._Variable(name, "%%MapCreateIterator(%s, %d)" %
+    iterator_type = random.choice(['keys', 'values', 'entries'])
+    return (result + self._Variable(name, "%s.%s()" %
                                           (map_name, iterator_type)))
 
   def _JSProxy(self, name, recursion_budget):
     # TODO(jkummerow): Revisit this as the Proxy implementation evolves.
     return self._Variable(name, "Proxy.create(%s)" % self.PROXY_TRAPS)
 
   def _JSRegExp(self, name, recursion_budget):
     flags = random.choice(["", "g", "i", "m", "gi"])
     string = "a(b|c)*a"  # TODO(jkummerow): Be more creative here?
     ctor = random.choice(["/%s/%s", "new RegExp(\"%s\", \"%s\")"])
     return self._Variable(name, ctor % (string, flags))
 
   def _JSSet(self, name, recursion_budget, weak=""):
     result = self._Variable(name, "new %sSet()" % weak)
     num_entries = random.randint(0, 3)
     for i in range(num_entries):
       element_name = "%s_e%d" % (name, i)
       if weak:
         result += self._JSObject(element_name, recursion_budget - 1)
       else:
         result += self._Object(element_name, recursion_budget - 1)
       result.append("%s.add(%s)" % (name, element_name))
     return result
 
   def _JSSetIterator(self, name, recursion_budget):
     set_name = name + "_set"
     result = self._JSSet(set_name, recursion_budget)
-    iterator_type = random.randint(2, 3)
-    return (result + self._Variable(name, "%%SetCreateIterator(%s, %d)" %
+    iterator_type = random.choice(['values', 'entries'])
+    return (result + self._Variable(name, "%s.%s()" %
                                           (set_name, iterator_type)))
 
   def _JSTypedArray(self, name, recursion_budget):
     arraytype = random.choice(["Int8", "Int16", "Int32", "Uint8", "Uint16",
                                "Uint32", "Float32", "Float64", "Uint8Clamped"])
     ctor_type = random.randint(0, 3)
     if ctor_type == 0:
       length = random.randint(0, 1000)
       return self._Variable(name, "new %sArray(%d)" % (arraytype, length),
                             fallback="new %sArray(8)" % arraytype)
@@ skipping 92 matching lines @@
     "JSArray": ["new Array()", _JSArray],
     "JSArrayBuffer": ["new ArrayBuffer(8)", _JSArrayBuffer],
     "JSArrayBufferView": ["new Int32Array(2)", _JSArrayBufferView],
     "JSDataView": ["new DataView(new ArrayBuffer(24))", _JSDataView],
     "JSDate": ["new Date()", _JSDate],
     "JSFunction": ["function() {}", _JSFunction],
     "JSFunctionProxy": ["Proxy.createFunction({}, function() {})",
                         _JSFunctionProxy],
     "JSGeneratorObject": ["(function*(){ yield 1; })()", _JSGeneratorObject],
     "JSMap": ["new Map()", _JSMap],
-    "JSMapIterator": ["%MapCreateIterator(new Map(), 3)", _JSMapIterator],
+    "JSMapIterator": ["new Map().entries()", _JSMapIterator],
     "JSObject": ["new Object()", _JSObject],
     "JSProxy": ["Proxy.create({})", _JSProxy],
     "JSReceiver": ["new Object()", _JSReceiver],
     "JSRegExp": ["/ab/g", _JSRegExp],
     "JSSet": ["new Set()", _JSSet],
-    "JSSetIterator": ["%SetCreateIterator(new Set(), 2)", _JSSetIterator],
+    "JSSetIterator": ["new Set().values()", _JSSetIterator],
     "JSTypedArray": ["new Int32Array(2)", _JSTypedArray],
     "JSValue": ["new String('foo')", _JSValue],
     "JSWeakCollection": ["new WeakMap()", _JSWeakCollection],
     "Name": ["\"name\"", _Name],
     "Number": ["1.5", _Number],
     "Object": ["new Object()", _Object],
     "PropertyDetails": ["513", _PropertyDetails],
     "SeqOneByteString": ["\"seq 1-byte\"", _SeqString],
     "SeqString": ["\"seqstring\"", _SeqString],
     "SeqTwoByteString": ["\"seq \\u2082-byte\"", _SeqTwoByteString],
@@ skipping 628 matching lines @@
       for i in range(len(processes)):
         processes[i].join()
     except KeyboardInterrupt:
       stop_running.set()
       for i in range(len(processes)):
         processes[i].join()
     return 0
 
 if __name__ == "__main__":
   sys.exit(Main())