Use CFUNC namespace only for IFUNC frames, its behavior should be unchanged

Author: tagomoris

test/ruby/test_namespace.rb

@@ -711,12 +711,26 @@ def ns4 = Namespace.current
         def self.ns5 = NS2
         def self.ns6 = Namespace.current
         def self.ns6_proc = ->(){ Namespace.current }
+        def self.ns7
+          res = []
+          [1,2].chunk{ it.even? }.each do |bool, members|
+            res << Namespace.current.object_id.to_s + ":" + bool.to_s + ":" + members.map(&:to_s).join(",")
+          end
+          res
+        end
 
         def self.yield_block = yield
         def self.call_block(&b) = b.call
       end
       FOO_NAME = Foo.name
-      NS9 = Foo.new.ns4
+
+      module Kernel
+        def foo_namespace = Namespace.current
+        module_function :foo_namespace
+      end
+
+      NS_X = Foo.new.ns4
+      NS_Y = foo_namespace
       EOC
       ns.eval(code)
       outer = Namespace.current
@@ -729,9 +743,14 @@ def self.call_block(&b) = b.call
       assert_equal ns, ns::Foo.ns6     # singleton method -> the current
       assert_equal ns, ns::Foo.ns6_proc.call # method returns a proc -> the current
 
+      # a block after CFUNC/IFUNC in a method -> the current
+      assert_equal ["#{ns.object_id}:false:1", "#{ns.object_id}:true:2"], ns::Foo.ns7
+
       assert_equal outer, ns::Foo.yield_block{ Namespace.current } # method yields
       assert_equal outer, ns::Foo.call_block{ Namespace.current }  # method calls a block
-      assert_equal ns, ns::NS9 # on TOP frame, referring a class in the current
+
+      assert_equal ns, ns::NS_X # on TOP frame, referring a class in the current
+      assert_equal ns, ns::NS_Y # on TOP frame, referring Kernel method defined by a CFUNC method
 
       assert_equal "Foo", ns::FOO_NAME
       assert_equal "Foo", ns::Foo.name

vm.c

@@ -113,39 +113,62 @@ VM_EP_RUBY_LEP(const rb_execution_context_t *ec, const rb_control_frame_t *curre
     // rb_vmdebug_namespace_env_dump_raw() simulates this function
     const VALUE *ep = current_cfp->ep;
     const rb_control_frame_t * const eocfp = RUBY_VM_END_CONTROL_FRAME(ec); /* end of control frame pointer */
-    const rb_control_frame_t *cfp = NULL, *checkpoint_cfp = current_cfp;
+    const rb_control_frame_t *cfp = current_cfp;
+
+    if (VM_ENV_FRAME_TYPE_P(ep, VM_FRAME_MAGIC_IFUNC)) {
+        ep = VM_EP_LEP(current_cfp->ep);
+        /**
+         * Returns CFUNC frame only in this case.
+         *
+         * Usually CFUNC frame doesn't represent the current namespace and it should operate
+         * the caller namespace. See the example:
+         *
+         * # in the main namespace
+         * module Kernel
+         *   def foo = "foo"
+         *   module_function :foo
+         * end
+         *
+         * In the case above, `module_function` is defined in the root namespace.
+         * If `module_function` worked in the root namespace, `Kernel#foo` is invisible
+         * from it and it causes NameError: undefined method `foo` for module `Kernel`.
+         *
+         * But in cases of IFUNC (blocks written in C), IFUNC doesn't have its own namespace
+         * and its local env frame will be CFUNC frame.
+         * For example, `Enumerator#chunk` calls IFUNC blocks, written as `chunk_i` function.
+         *
+         * [1].chunk{ it.even? }.each{ ... }
+         *
+         * Before calling the Ruby block `{ it.even? }`, `#chunk` calls `chunk_i` as IFUNC
+         * to iterate the array's members (it's just like `#each`).
+         * We expect that `chunk_i` works as expected by the implementation of `#chunk`
+         * without any overwritten definitions from namespaces.
+         * So the definitions on IFUNC frames should be equal to the caller CFUNC.
+         */
+        VM_ASSERT(VM_ENV_FRAME_TYPE_P(ep, VM_FRAME_MAGIC_CFUNC));
+        return ep;
+    }
 
-    while (!VM_ENV_LOCAL_P(ep) || VM_ENV_FRAME_TYPE_P(ep, VM_FRAME_MAGIC_CFUNC)) {
-        while (!VM_ENV_LOCAL_P(ep)) {
-            ep = VM_ENV_PREV_EP(ep);
-        }
-        while (VM_ENV_FLAGS(ep, VM_FRAME_FLAG_CFRAME) != 0) {
-            if (!cfp) {
-                cfp = rb_vm_search_cf_from_ep(ec, checkpoint_cfp, ep);
-                VM_NAMESPACE_ASSERT(cfp, "Failed to search cfp from ep");
-                VM_NAMESPACE_ASSERT(cfp->ep == ep, "Searched cfp's ep is not equal to ep");
-            }
-            if (!cfp) {
-                return NULL;
-            }
-            VM_NAMESPACE_ASSERT(cfp->ep, "cfp->ep == NULL");
-            VM_NAMESPACE_ASSERT(cfp->ep == ep, "cfp->ep != ep");
+    while (VM_ENV_FRAME_TYPE_P(ep, VM_FRAME_MAGIC_CFUNC)) {
+        cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
 
-            VM_NAMESPACE_ASSERT(!VM_FRAME_FINISHED_P(cfp), "CFUNC frame should not FINISHED");
+        VM_NAMESPACE_ASSERT(cfp, "CFUNC should have a valid previous control frame");
+        VM_NAMESPACE_ASSERT(cfp < eocfp, "CFUNC should have a valid caller frame");
+        if (!cfp || cfp >= eocfp) {
+            return NULL;
+        }
 
-            cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
-            if (cfp >= eocfp) {
-                return NULL;
-            }
-            VM_NAMESPACE_ASSERT(cfp, "CFUNC should have a valid previous control frame");
-            ep = cfp->ep;
-            if (!ep) {
-                return NULL;
-            }
+        VM_NAMESPACE_ASSERT(cfp->ep, "CFUNC should have a valid caller frame with env");
+        ep = cfp->ep;
+        if (!ep) {
+            return NULL;
         }
-        checkpoint_cfp = cfp;
-        cfp = NULL;
     }
+
+    while (!VM_ENV_LOCAL_P(ep)) {
+        ep = VM_ENV_PREV_EP(ep);
+    }
+
     return ep;
 }
 
@@ -3096,7 +3119,7 @@ current_namespace_on_cfp(const rb_execution_context_t *ec, const rb_control_fram
     VM_NAMESPACE_ASSERT(lep, "lep should be valid");
     VM_NAMESPACE_ASSERT(rb_namespace_available(), "namespace should be available here");
 
-    if (VM_ENV_FRAME_TYPE_P(lep, VM_FRAME_MAGIC_METHOD)) {
+    if (VM_ENV_FRAME_TYPE_P(lep, VM_FRAME_MAGIC_METHOD) || VM_ENV_FRAME_TYPE_P(lep, VM_FRAME_MAGIC_CFUNC)) {
         cme = check_method_entry(lep[VM_ENV_DATA_INDEX_ME_CREF], TRUE);
         VM_NAMESPACE_ASSERT(cme, "cme should be valid");
         VM_NAMESPACE_ASSERT(cme->def, "cme->def shold be valid");

vm_dump.c

@@ -421,39 +421,42 @@ rb_vmdebug_namespace_env_dump_raw(const rb_execution_context_t *ec, const rb_con
     // See VM_EP_RUBY_LEP for the original logic
     const VALUE *ep = current_cfp->ep;
     const rb_control_frame_t * const eocfp = RUBY_VM_END_CONTROL_FRAME(ec); /* end of control frame pointer */
-    const rb_control_frame_t *cfp = NULL, *checkpoint_cfp = current_cfp;
+    const rb_control_frame_t *cfp = current_cfp, *checkpoint_cfp = current_cfp;
 
     kprintf("-- Namespace detection information "
             "-----------------------------------------\n");
 
     namespace_env_dump_unchecked(ec, ep, checkpoint_cfp, errout);
 
-    while (!VM_ENV_LOCAL_P(ep) || VM_ENV_FRAME_TYPE_P(ep, VM_FRAME_MAGIC_CFUNC)) {
+    if (VM_ENV_FRAME_TYPE_P(ep, VM_FRAME_MAGIC_IFUNC)) {
         while (!VM_ENV_LOCAL_P(ep)) {
             ep = VM_ENV_PREV_EP(ep);
             namespace_env_dump_unchecked(ec, ep, checkpoint_cfp, errout);
         }
-        while (VM_ENV_FLAGS(ep, VM_FRAME_FLAG_CFRAME) != 0) {
-            if (!cfp) {
-                cfp = vmdebug_search_cf_from_ep(ec, checkpoint_cfp, ep);
-            }
-            if (!cfp) {
-                goto stop;
-            }
-            cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
-            if (cfp >= eocfp) {
-                kprintf("[PREVIOUS CONTROL FRAME IS OUT OF BOUND]\n");
-                goto stop;
-            }
-            ep = cfp->ep;
-            namespace_env_dump_unchecked(ec, ep, checkpoint_cfp, errout);
-            if (!ep) {
-                goto stop;
-            }
+        goto stop;
+    }
+
+    while (VM_ENV_FRAME_TYPE_P(ep, VM_FRAME_MAGIC_CFUNC)) {
+        cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
+        if (!cfp) {
+            goto stop;
+        }
+        if (cfp >= eocfp) {
+            kprintf("[PREVIOUS CONTROL FRAME IS OUT OF BOUND]\n");
+            goto stop;
+        }
+        ep = cfp->ep;
+        namespace_env_dump_unchecked(ec, ep, checkpoint_cfp, errout);
+        if (!ep) {
+            goto stop;
         }
-        checkpoint_cfp = cfp;
-        cfp = NULL;
     }
+
+    while (!VM_ENV_LOCAL_P(ep)) {
+        ep = VM_ENV_PREV_EP(ep);
+        namespace_env_dump_unchecked(ec, ep, checkpoint_cfp, errout);
+    }
+
   stop:
     kprintf("\n");
     return true;