Update current namespace management by using control frames and lexical contexts

to fix inconsistent and wrong current namespace detections.

This includes:
* Moving load_path and related things from rb_vm_t to rb_namespace_t to simplify
  accessing those values via namespace (instead of accessing either vm or ns)
* Initializing root_namespace earlier and consolidate builtin_namespace into root_namespace
* Adding VM_FRAME_FLAG_NS_REQUIRE for checkpoints to detect a namespace to load/require files
* Removing implicit refinements in the root namespace which was used to determine
  the namespace to be loaded (replaced by VM_FRAME_FLAG_NS_REQUIRE)
* Removing namespaces from rb_proc_t because its namespace can be identified by lexical context
* Starting to use ep[VM_ENV_DATA_INDEX_SPECVAL] to store the current namespace when
  the frame type is MAGIC_TOP or MAGIC_CLASS (block handlers don't exist in this case)

Author: tagomoris

builtin.c

@@ -50,17 +50,8 @@ load_with_builtin_functions(const char *feature_name, const struct rb_builtin_fu
     ASSUME(iseq); // otherwise an exception should have raised
     vm->builtin_function_table = NULL;
 
-    rb_namespace_enable_builtin();
-
     // exec
-    if (rb_namespace_available() && rb_mNamespaceRefiner) {
-        rb_iseq_eval_with_refinement(rb_iseq_check(iseq), rb_mNamespaceRefiner);
-    }
-    else {
-        rb_iseq_eval(rb_iseq_check(iseq));
-    }
-
-    rb_namespace_disable_builtin();
+    rb_iseq_eval(rb_iseq_check(iseq), rb_root_namespace()); // builtin functions are loaded in the root namespace
 }
 
 void

class.c

@@ -650,7 +650,7 @@ class_alloc0(enum ruby_value_type type, VALUE klass, bool namespaceable)
 {
     rb_ns_subclasses_t *ns_subclasses;
     rb_subclass_anchor_t *anchor;
-    const rb_namespace_t *ns = rb_definition_namespace();
+    const rb_namespace_t *ns = rb_current_namespace();
 
     if (!ruby_namespace_init_done) {
         namespaceable = true;

eval.c

@@ -80,6 +80,7 @@ ruby_setup(void)
     rb_vm_encoded_insn_data_table_init();
     Init_enable_namespace();
     Init_vm_objects();
+    Init_root_namespace();
     Init_fstring_table();
 
     EC_PUSH_TAG(GET_EC());

eval_intern.h

@@ -296,7 +296,10 @@ VALUE rb_vm_make_jump_tag_but_local_jump(enum ruby_tag_type state, VALUE val);
 rb_cref_t *rb_vm_cref(void);
 rb_cref_t *rb_vm_cref_replace_with_duplicated_cref(void);
 VALUE rb_vm_call_cfunc(VALUE recv, VALUE (*func)(VALUE), VALUE arg, VALUE block_handler, VALUE filename);
-VALUE rb_vm_call_cfunc2(VALUE recv, VALUE (*func)(VALUE, VALUE), VALUE arg1, VALUE arg2, VALUE block_handler, VALUE filename);
+VALUE rb_vm_call_cfunc_in_namespace(VALUE recv, VALUE (*func)(VALUE, VALUE), VALUE arg1, VALUE arg2, VALUE filename, const rb_namespace_t *ns);
+void rb_vm_frame_flag_set_ns_require(const rb_execution_context_t *ec);
+const rb_namespace_t *rb_vm_current_namespace(const rb_execution_context_t *ec);
+const rb_namespace_t *rb_vm_loading_namespace(const rb_execution_context_t *ec);
 void rb_vm_set_progname(VALUE filename);
 VALUE rb_vm_cbase(void);
 

inits.c

@@ -52,6 +52,7 @@ rb_call_inits(void)
     CALL(Time);
     CALL(Random);
     CALL(load);
+    CALL(Namespace);
     CALL(Proc);
     CALL(Binding);
     CALL(Math);
@@ -78,7 +79,6 @@ rb_call_inits(void)
     CALL(Prism);
     CALL(unicode_version);
     CALL(Set);
-    CALL(Namespace);
 
     // enable builtin loading
     CALL(builtin);

insns.def

@@ -803,12 +803,13 @@ defineclass
 (VALUE val)
 {
     VALUE klass = vm_find_or_create_class_by_id(id, flags, cbase, super);
+    const rb_namespace_t *ns = rb_current_namespace();
 
     rb_iseq_check(class_iseq);
 
     /* enter scope */
     vm_push_frame(ec, class_iseq, VM_FRAME_MAGIC_CLASS | VM_ENV_FLAG_LOCAL, klass,
-                  GET_BLOCK_HANDLER(),
+                  GC_GUARDED_PTR(ns),
                   (VALUE)vm_cref_push(ec, klass, NULL, FALSE, FALSE),
                   ISEQ_BODY(class_iseq)->iseq_encoded, GET_SP(),
                   ISEQ_BODY(class_iseq)->local_table_size,

internal/class.h

@@ -390,8 +390,7 @@ RCLASS_EXT_READABLE_LOOKUP(VALUE obj, const rb_namespace_t *ns)
 static inline rb_classext_t *
 RCLASS_EXT_READABLE_IN_NS(VALUE obj, const rb_namespace_t *ns)
 {
-    if (!ns
-        || NAMESPACE_BUILTIN_P(ns)
+    if (NAMESPACE_ROOT_P(ns)
         || RCLASS_PRIME_CLASSEXT_READABLE_P(obj)) {
         return RCLASS_EXT_PRIME(obj);
     }
@@ -405,9 +404,9 @@ RCLASS_EXT_READABLE(VALUE obj)
     if (RCLASS_PRIME_CLASSEXT_READABLE_P(obj)) {
         return RCLASS_EXT_PRIME(obj);
     }
-    // delay namespace loading to optimize for unmodified classes
+    // delay determining the current namespace to optimize for unmodified classes
     ns = rb_current_namespace();
-    if (!ns || NAMESPACE_BUILTIN_P(ns)) {
+    if (NAMESPACE_ROOT_P(ns)) {
         return RCLASS_EXT_PRIME(obj);
     }
     return RCLASS_EXT_READABLE_LOOKUP(obj, ns);
@@ -440,8 +439,7 @@ RCLASS_EXT_WRITABLE_LOOKUP(VALUE obj, const rb_namespace_t *ns)
 static inline rb_classext_t *
 RCLASS_EXT_WRITABLE_IN_NS(VALUE obj, const rb_namespace_t *ns)
 {
-    if (!ns
-        || NAMESPACE_BUILTIN_P(ns)
+    if (NAMESPACE_ROOT_P(ns)
         || RCLASS_PRIME_CLASSEXT_WRITABLE_P(obj)) {
         return RCLASS_EXT_PRIME(obj);
     }
@@ -455,11 +453,9 @@ RCLASS_EXT_WRITABLE(VALUE obj)
     if (LIKELY(RCLASS_PRIME_CLASSEXT_WRITABLE_P(obj))) {
         return RCLASS_EXT_PRIME(obj);
     }
-    // delay namespace loading to optimize for unmodified classes
+    // delay determining the current namespace to optimize for unmodified classes
     ns = rb_current_namespace();
-    if (!ns || NAMESPACE_BUILTIN_P(ns)) {
-        // If no namespace is specified, Ruby VM is in bootstrap
-        // and the clean class definition is under construction.
+    if (NAMESPACE_ROOT_P(ns)) {
         return RCLASS_EXT_PRIME(obj);
     }
     return RCLASS_EXT_WRITABLE_LOOKUP(obj, ns);

internal/inits.h

@@ -32,6 +32,9 @@ void Init_enable_namespace(void);
 void Init_BareVM(void);
 void Init_vm_objects(void);
 
+/* namespace.c */
+void Init_root_namespace(void);
+
 /* vm_backtrace.c */
 void Init_vm_backtrace(void);
 

internal/namespace.h

@@ -35,13 +35,14 @@ struct rb_namespace_struct {
 
     VALUE gvar_tbl;
 
-    bool is_builtin;
     bool is_user;
     bool is_optional;
 };
 typedef struct rb_namespace_struct rb_namespace_t;
 
-#define NAMESPACE_BUILTIN_P(ns) (ns && ns->is_builtin)
+#define NAMESPACE_OBJ_P(obj) (CLASS_OF(obj) == rb_cNamespace)
+
+#define NAMESPACE_ROOT_P(ns) (ns && !ns->is_user)
 #define NAMESPACE_USER_P(ns) (ns && ns->is_user)
 #define NAMESPACE_OPTIONAL_P(ns) (ns && ns->is_optional)
 #define NAMESPACE_MAIN_P(ns) (ns && ns->is_user && !ns->is_optional)
@@ -60,24 +61,16 @@ rb_namespace_available(void)
     return ruby_namespace_enabled;
 }
 
-void rb_namespace_enable_builtin(void);
-void rb_namespace_disable_builtin(void);
-void rb_namespace_push_loading_namespace(const rb_namespace_t *);
-void rb_namespace_pop_loading_namespace(const rb_namespace_t *);
-rb_namespace_t * rb_root_namespace(void);
-const rb_namespace_t *rb_builtin_namespace(void);
-rb_namespace_t * rb_main_namespace(void);
-const rb_namespace_t * rb_definition_namespace(void);
-const rb_namespace_t * rb_loading_namespace(void);
+const rb_namespace_t * rb_root_namespace(void);
+const rb_namespace_t * rb_main_namespace(void);
 const rb_namespace_t * rb_current_namespace(void);
-VALUE rb_current_namespace_details(VALUE);
+const rb_namespace_t * rb_loading_namespace(void);
 
 void rb_namespace_entry_mark(void *);
+void rb_namespace_gc_update_references(void *ptr);
 
 rb_namespace_t * rb_get_namespace_t(VALUE ns);
 VALUE rb_get_namespace_object(rb_namespace_t *ns);
-typedef VALUE namespace_exec_func(VALUE arg);
-VALUE rb_namespace_exec(const rb_namespace_t *ns, namespace_exec_func *func, VALUE arg);
 
 VALUE rb_namespace_local_extension(VALUE namespace, VALUE fname, VALUE path);
 

iseq.c

@@ -1966,7 +1966,7 @@ iseqw_eval(VALUE self)
     if (0 == ISEQ_BODY(iseq)->iseq_size) {
         rb_raise(rb_eTypeError, "attempt to evaluate dummy InstructionSequence");
     }
-    return rb_iseq_eval(iseq);
+    return rb_iseq_eval(iseq, rb_current_namespace());
 }
 
 /*