[modules] Implement @@iterator on namespace objects.

src/builtins/builtins-iterator.cc

 // Copyright 2016 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.
 
+#include "src/builtins/builtins-utils.h"
 #include "src/builtins/builtins.h"
-#include "src/builtins/builtins-utils.h"
+#include "src/frames-inl.h"
 
 namespace v8 {
 namespace internal {
 
 void Builtins::Generate_IteratorPrototypeIterator(
     CodeStubAssembler* assembler) {
   assembler->Return(assembler->Parameter(0));
 }
 
+BUILTIN(ModuleNamespaceIterator) {
+  HandleScope scope(isolate);
+  DCHECK_EQ(1, args.length());
+  Handle<Object> receiver = args.at<Object>(0);
+
+  if (!receiver->IsJSModuleNamespace()) {
+    THROW_NEW_ERROR_RETURN_FAILURE(
+        isolate, NewTypeError(MessageTemplate::kIncompatibleMethodReceiver,
+                              isolate->factory()->iterator_symbol(), receiver));
+  }
+  auto ns = Handle<JSModuleNamespace>::cast(receiver);
+
+  Handle<FixedArray> names =
+      KeyAccumulator::GetKeys(ns, KeyCollectionMode::kOwnOnly, SKIP_SYMBOLS)
+          .ToHandleChecked();
+  return *isolate->factory()->NewJSFixedArrayIterator(names);
+}
+
+BUILTIN(FixedArrayIteratorNext) {

[Benedikt Meurer, 2016/10/12 03:24:05]

Nice idea!

+  HandleScope scope(isolate);
+  DCHECK_EQ(1, args.length());
+  Handle<Object> receiver = args.at<Object>(0);
+
+  // It is an error if this function is called on anything other than the
+  // particular iterator object for which the function was created.
+  bool error = !receiver->IsJSFixedArrayIterator();
+  if (!error) {
+    StackFrameIterator it(isolate);
+    error = BuiltinExitFrame::cast(it.frame())->function() !=
+            Handle<JSFixedArrayIterator>::cast(receiver)->next();
+  }

[neis, 2016/10/11 18:36:17]

This is awesome, isn't it?  Is there any better way to do this?

[adamk, 2016/10/11 19:42:53]

This looks about right to me (this "next" function should be the same one
attached to the receiver), except for the frame stuff (on which I defer to
bmeurer).

[Benedikt Meurer, 2016/10/12 03:24:05]

Adam is right, you need this.

But please don't go hunting in the stack frames. There's args.target() which
yields the closure, just use that instead. And please rephrase it as a single
if, without the magical error variable.

[neis, 2016/10/13 07:37:21]

Thanks for pointing me to args.target(), that's exactly what I was looking for
but couldn't find at the time.

I don't think there was anything magical about the error variable but now I
don't need it anymore.

+  if (error) {
+    THROW_NEW_ERROR_RETURN_FAILURE(
+        isolate, NewTypeError(MessageTemplate::kIncompatibleMethodReceiver,
+                              isolate->factory()->next_string(), receiver));
+  }
+
+  auto iterator = Handle<JSFixedArrayIterator>::cast(receiver);
+  Handle<Object> value;
+  bool done;
+
+  int index = iterator->index();
+  if (index < iterator->array()->length()) {
+    value = handle(iterator->array()->get(index), isolate);
+    done = false;
+    iterator->set_index(index + 1);
+  } else {
+    value = isolate->factory()->undefined_value();
+    done = true;
+  }
+
+  return *isolate->factory()->NewJSIteratorResult(value, done);
+}
+
 }  // namespace internal
 }  // namespace v8