Add iterator support to emval (#20364)

Author: RReverser

ChangeLog.md

@@ -40,6 +40,8 @@ See docs/process.md for more on how version tagging works.
 - `emscripten::val` now prevents accidental access to the underlying JavaScript
   value from threads other than its owner. This already didn't work correctly
   in majority of cases, but now it will throw a clear assertion failure. (#20344)
+- `emscripten::val` can now be iterated over with a C++ range-based for loop.
+  (#20364)
 
 3.1.46 - 09/15/23
 -----------------

src/embind/emval.js

@@ -521,6 +521,19 @@ var LibraryEmVal = {
     });
   },
 #endif
+
+  _emval_iter_begin__deps: ['$Emval'],
+  _emval_iter_begin: (iterable) => {
+    iterable = Emval.toValue(iterable);
+    return Emval.toHandle(iterable[Symbol.iterator]());
+  },
+
+  _emval_iter_next__deps: ['$Emval'],
+  _emval_iter_next: (iterator) => {
+    iterator = Emval.toValue(iterator);
+    var result = iterator.next();
+    return result.done ? 0 : Emval.toHandle(result.value);
+  },
 };
 
 addToLibrary(LibraryEmVal);

src/library_sigs.js

@@ -352,6 +352,8 @@ sigs = {
   _emval_instanceof__sig: 'ipp',
   _emval_is_number__sig: 'ip',
   _emval_is_string__sig: 'ip',
+  _emval_iter_begin__sig: 'pp',
+  _emval_iter_next__sig: 'pp',
   _emval_less_than__sig: 'ipp',
   _emval_new__sig: 'ppipp',
   _emval_new_array__sig: 'p',

system/include/emscripten/val.h

@@ -107,6 +107,8 @@ bool _emval_in(EM_VAL item, EM_VAL object);
 bool _emval_delete(EM_VAL object, EM_VAL property);
 [[noreturn]] bool _emval_throw(EM_VAL object);
 EM_VAL _emval_await(EM_VAL promise);
+EM_VAL _emval_iter_begin(EM_VAL iterable);
+EM_VAL _emval_iter_next(EM_VAL iterator);
 
 } // extern "C"
 
@@ -586,6 +588,12 @@ class val {
     return val(internal::_emval_await(as_handle()));
   }
 
+  struct iterator;
+
+  iterator begin() const;
+  // our iterators are sentinel-based range iterators; use nullptr as the end sentinel
+  constexpr nullptr_t end() const { return nullptr; }
+
 private:
   // takes ownership, assumes handle already incref'd and lives on the same thread
   explicit val(EM_VAL handle)
@@ -619,6 +627,27 @@ class val {
   friend struct internal::BindingType<val>;
 };
 
+struct val::iterator {
+  iterator() = delete;
+  // Make sure iterator is only moveable, not copyable as it represents a mutable state.
+  iterator(iterator&&) = default;
+  iterator(const val& v) : iter(internal::_emval_iter_begin(v.as_handle())) {
+    this->operator++();
+  }
+  val&& operator*() { return std::move(cur_value); }
+  const val& operator*() const { return cur_value; }
+  void operator++() { cur_value = val(internal::_emval_iter_next(iter.as_handle())); }
+  bool operator!=(nullptr_t) const { return cur_value.as_handle() != nullptr; }
+
+private:
+  val iter;
+  val cur_value;
+};
+
+inline val::iterator val::begin() const {
+  return iterator(*this);
+}
+
 // Declare a custom type that can be used in conjuction with
 // emscripten::register_type to emit custom TypeScript defintions for val types.
 #define EMSCRIPTEN_DECLARE_VAL_TYPE(name)                                          \

test/embind/test_val.cpp

@@ -73,6 +73,11 @@ int main() {
   ensure_js("a[1] == 1");
   ensure_js("a[2] == 3");
   ensure_js_not("a[2] == 2");
+  vector<int> vec2_from_iter;
+  for (val&& v : val::global("a")) {
+    vec2_from_iter.push_back(v.as<int>());
+  }
+  ensure(vec2 == vec2_from_iter);
 
   test("template<typename Iter> val array(Iter begin, Iter end)");
   val::global().set("a", val::array(vec1.begin(), vec1.end()));