kanayago 0.1.1 → 0.2.0

data/ext/kanayago/internal/namespace.h

@@ -0,0 +1,81 @@
+#ifndef INTERNAL_NAMESPACE_H                                  /*-*-C-*-vi:se ft=c:*/
+#define INTERNAL_NAMESPACE_H
+
+#include "ruby/ruby.h"          /* for VALUE */
+
+/**
+ * @author     Ruby developers <ruby-core@ruby-lang.org>
+ * @copyright  This  file  is   a  part  of  the   programming  language  Ruby.
+ *             Permission  is hereby  granted,  to  either redistribute  and/or
+ *             modify this file, provided that  the conditions mentioned in the
+ *             file COPYING are met.  Consult the file for details.
+ * @brief      Internal header for Namespace.
+ */
+struct rb_namespace_struct {
+    /*
+     * To retrieve Namespace object that provides #require and so on.
+     * That is used from load.c, etc., that uses rb_namespace_t internally.
+     */
+    VALUE ns_object;
+    long ns_id; // namespace id to generate ext filenames
+
+    VALUE top_self;
+
+    VALUE load_path;
+    VALUE load_path_snapshot;
+    VALUE load_path_check_cache;
+    VALUE expanded_load_path;
+    VALUE loaded_features;
+    VALUE loaded_features_snapshot;
+    VALUE loaded_features_realpaths;
+    VALUE loaded_features_realpath_map;
+    struct st_table *loaded_features_index;
+    struct st_table *loading_table;
+    VALUE ruby_dln_libmap;
+
+    VALUE gvar_tbl;
+
+    bool is_user;
+    bool is_optional;
+};
+typedef struct rb_namespace_struct rb_namespace_t;
+
+#define NAMESPACE_OBJ_P(obj) (rb_obj_class(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)
+
+#define NAMESPACE_METHOD_DEFINITION(mdef) (mdef ? mdef->ns : NULL)
+#define NAMESPACE_METHOD_ENTRY(me) (me ? NAMESPACE_METHOD_DEFINITION(me->def) : NULL)
+#define NAMESPACE_CC(cc) (cc ? NAMESPACE_METHOD_ENTRY(cc->cme_) : NULL)
+#define NAMESPACE_CC_ENTRIES(ccs) (ccs ? NAMESPACE_METHOD_ENTRY(ccs->cme) : NULL)
+
+RUBY_EXTERN bool ruby_namespace_enabled;
+RUBY_EXTERN bool ruby_namespace_init_done;
+RUBY_EXTERN bool ruby_namespace_crashed;
+
+static inline bool
+rb_namespace_available(void)
+{
+    return ruby_namespace_enabled;
+}
+
+const rb_namespace_t * rb_root_namespace(void);
+const rb_namespace_t * rb_main_namespace(void);
+const rb_namespace_t * rb_current_namespace(void);
+const rb_namespace_t * rb_loading_namespace(void);
+const rb_namespace_t * rb_current_namespace_in_crash_report(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);
+
+VALUE rb_namespace_local_extension(VALUE namespace, VALUE fname, VALUE path);
+
+void rb_initialize_main_namespace(void);
+void rb_namespace_init_done(void);
+#endif /* INTERNAL_NAMESPACE_H */

data/ext/kanayago/internal/numeric.h

@@ -85,6 +85,7 @@ VALUE rb_int_cmp(VALUE x, VALUE y);
 VALUE rb_int_equal(VALUE x, VALUE y);
 VALUE rb_int_divmod(VALUE x, VALUE y);
 VALUE rb_int_and(VALUE x, VALUE y);
+VALUE rb_int_xor(VALUE x, VALUE y);
 VALUE rb_int_lshift(VALUE x, VALUE y);
 VALUE rb_int_rshift(VALUE x, VALUE y);
 VALUE rb_int_div(VALUE x, VALUE y);

data/ext/kanayago/internal/parse.h

@@ -12,6 +12,17 @@
 #include "rubyparser.h"
 #include "internal/static_assert.h"
 
+// The default parser to use for Ruby code.
+typedef enum {
+    RB_DEFAULT_PARSER_PARSE_Y,
+    RB_DEFAULT_PARSER_PRISM,
+} ruby_default_parser_enum;
+
+ruby_default_parser_enum rb_ruby_default_parser(void);
+void rb_ruby_default_parser_set(ruby_default_parser_enum parser);
+
+#define rb_ruby_prism_p() (rb_ruby_default_parser() == RB_DEFAULT_PARSER_PRISM)
+
 #ifdef UNIVERSAL_PARSER
 #define rb_encoding const void
 #endif
@@ -63,12 +74,15 @@ rb_encoding *rb_ruby_parser_encoding(rb_parser_t *p);
 int rb_ruby_parser_end_seen_p(rb_parser_t *p);
 int rb_ruby_parser_set_yydebug(rb_parser_t *p, int flag);
 rb_parser_string_t *rb_str_to_parser_string(rb_parser_t *p, VALUE str);
+void rb_parser_string_free(rb_parser_t *p, rb_parser_string_t *str);
 
 int rb_parser_dvar_defined_ref(struct parser_params*, ID, ID**);
 ID rb_parser_internal_id(struct parser_params*);
-int rb_parser_reg_fragment_check(struct parser_params*, rb_parser_string_t*, int);
-int rb_reg_named_capture_assign_iter_impl(struct parser_params *p, const char *s, long len, rb_encoding *enc, NODE **succ_block, const rb_code_location_t *loc);
+typedef void (*rb_parser_reg_fragment_error_func)(struct parser_params *, VALUE);
+int rb_parser_reg_fragment_check(struct parser_params*, rb_parser_string_t*, int, rb_parser_reg_fragment_error_func);
+int rb_reg_named_capture_assign_iter_impl(struct parser_params *p, const char *s, long len, rb_encoding *enc, NODE **succ_block, const rb_code_location_t *loc, rb_parser_assignable_func assignable);
 int rb_parser_local_defined(struct parser_params *p, ID id, const struct rb_iseq_struct *iseq);
+NODE *rb_parser_assignable(struct parser_params *p, ID id, NODE *val, const YYLTYPE *loc);
 
 RUBY_SYMBOL_EXPORT_END
 
@@ -97,7 +111,7 @@ VALUE rb_ruby_parser_ruby_sourcefile_string(rb_parser_t *p);
 int rb_ruby_parser_ruby_sourceline(rb_parser_t *p);
 int rb_ruby_parser_lex_state(rb_parser_t *p);
 void rb_ruby_ripper_parse0(rb_parser_t *p);
-int rb_ruby_ripper_dedent_string(rb_parser_t *p, VALUE string, int width);
+int rb_ruby_ripper_dedent_string(rb_parser_t *p, rb_parser_string_t *string, int width);
 int rb_ruby_ripper_initialized_p(rb_parser_t *p);
 void rb_ruby_ripper_parser_initialize(rb_parser_t *p);
 long rb_ruby_ripper_column(rb_parser_t *p);

data/ext/kanayago/internal/re.h

@@ -14,15 +14,20 @@
 /* re.c */
 VALUE rb_reg_compile(VALUE str, int options, const char *sourcefile, int sourceline);
 VALUE rb_reg_check_preprocess(VALUE);
-long rb_reg_search0(VALUE, VALUE, long, int, int);
+long rb_reg_search0(VALUE, VALUE, long, int, int, VALUE *);
 VALUE rb_reg_match_p(VALUE re, VALUE str, long pos);
 bool rb_reg_start_with_p(VALUE re, VALUE str);
 VALUE rb_reg_hash(VALUE re);
 VALUE rb_reg_equal(VALUE re1, VALUE re2);
-void rb_backref_set_string(VALUE string, long pos, long len);
+VALUE rb_backref_set_string(VALUE string, long pos, long len);
 void rb_match_unbusy(VALUE);
 int rb_match_count(VALUE match);
 VALUE rb_reg_new_ary(VALUE ary, int options);
 VALUE rb_reg_last_defined(VALUE match);
 
+#define ARG_REG_OPTION_MASK \
+    (ONIG_OPTION_IGNORECASE|ONIG_OPTION_MULTILINE|ONIG_OPTION_EXTEND)
+#define ARG_ENCODING_FIXED    16
+#define ARG_ENCODING_NONE     32
+
 #endif /* INTERNAL_RE_H */

data/ext/kanayago/internal/sanitizers.h

@@ -16,7 +16,7 @@
 #endif
 
 #ifdef HAVE_SANITIZER_ASAN_INTERFACE_H
-# if __has_feature(address_sanitizer)
+# if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__)
 #  define RUBY_ASAN_ENABLED
 #  include <sanitizer/asan_interface.h>
 # endif
@@ -29,6 +29,13 @@
 # endif
 #endif
 
+#ifdef HAVE_SANITIZER_TSAN_INTERFACE_H
+# if __has_feature(thread_sanitizer) || defined(__SANITIZE_THREAD__)
+#  define RUBY_TSAN_ENABLED
+#  include <sanitizer/tsan_interface.h>
+# endif
+#endif
+
 #include "ruby/internal/stdbool.h"     /* for bool */
 #include "ruby/ruby.h"          /* for VALUE */
 
@@ -39,6 +46,12 @@
 #elif defined(RUBY_ASAN_ENABLED)
 # define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(x) \
     __attribute__((__no_sanitize__("address"), __noinline__)) x
+#elif defined(RUBY_MSAN_ENABLED)
+    # define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(x) \
+    __attribute__((__no_sanitize__("memory"), __noinline__)) x
+#elif defined(RUBY_TSAN_ENABLED)
+# define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(x) \
+    __attribute__((__no_sanitize__("thread"), __noinline__)) x
 #elif defined(NO_SANITIZE_ADDRESS)
 # define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(x) \
     NO_SANITIZE_ADDRESS(NOINLINE(x))
@@ -54,10 +67,11 @@
 # include "internal/warnings.h"
 # undef NO_SANITIZE
 # define NO_SANITIZE(x, y) \
-    COMPILER_WARNING_PUSH; \
-    COMPILER_WARNING_IGNORED(-Wattributes); \
+    COMPILER_WARNING_PUSH \
+    COMPILER_WARNING_IGNORED(-Wattributes) \
     __attribute__((__no_sanitize__(x))) y; \
-    COMPILER_WARNING_POP
+    COMPILER_WARNING_POP \
+    y
 #endif
 
 #ifndef NO_SANITIZE
@@ -115,26 +129,23 @@ asan_poison_memory_region(const volatile void *ptr, size_t size)
     __asan_poison_memory_region(ptr, size);
 }
 
-/**
- * This is a variant of asan_poison_memory_region that takes a VALUE.
- *
- * @param[in]  obj   target object.
- */
-static inline void
-asan_poison_object(VALUE obj)
-{
-    MAYBE_UNUSED(struct RVALUE *) ptr = (void *)obj;
-    asan_poison_memory_region(ptr, SIZEOF_VALUE);
-}
-
 #ifdef RUBY_ASAN_ENABLED
 #define asan_poison_object_if(ptr, obj) do { \
-        if (ptr) asan_poison_object(obj); \
+        if (ptr) rb_asan_poison_object(obj); \
     } while (0)
 #else
 #define asan_poison_object_if(ptr, obj) ((void)(ptr), (void)(obj))
 #endif
 
+#ifdef RUBY_ASAN_ENABLED
+RUBY_SYMBOL_EXPORT_BEGIN
+/**
+ * This is a variant of asan_poison_memory_region that takes a VALUE.
+ *
+ * @param[in]  obj   target object.
+ */
+void rb_asan_poison_object(VALUE obj);
+
 /**
  * This function predicates if the given object is fully addressable or not.
  *
@@ -142,12 +153,22 @@ asan_poison_object(VALUE obj)
  * @retval     0          the given object is fully addressable.
  * @retval     otherwise  pointer to first such byte who is poisoned.
  */
-static inline void *
-asan_poisoned_object_p(VALUE obj)
-{
-    MAYBE_UNUSED(struct RVALUE *) ptr = (void *)obj;
-    return __asan_region_is_poisoned(ptr, SIZEOF_VALUE);
-}
+void *rb_asan_poisoned_object_p(VALUE obj);
+
+/**
+ * This is a variant of asan_unpoison_memory_region that takes a VALUE.
+ *
+ * @param[in]  obj       target object.
+ * @param[in]  malloc_p  if the memory region is like a malloc's return value or not.
+ */
+void rb_asan_unpoison_object(VALUE obj, bool newobj_p);
+
+RUBY_SYMBOL_EXPORT_END
+#else
+# define rb_asan_poison_object(obj) ((void)obj)
+# define rb_asan_poisoned_object_p(obj) ((void)obj, NULL)
+# define rb_asan_unpoison_object(obj, newobj_p) ((void)obj, (void)newobj_p)
+#endif
 
 /**
  * This function asserts that a (formally poisoned) memory region from ptr to
@@ -176,24 +197,11 @@ asan_unpoison_memory_region(const volatile void *ptr, size_t size, bool malloc_p
     }
 }
 
-/**
- * This is a variant of asan_unpoison_memory_region that takes a VALUE.
- *
- * @param[in]  obj       target object.
- * @param[in]  malloc_p  if the memory region is like a malloc's return value or not.
- */
-static inline void
-asan_unpoison_object(VALUE obj, bool newobj_p)
-{
-    MAYBE_UNUSED(struct RVALUE *) ptr = (void *)obj;
-    asan_unpoison_memory_region(ptr, SIZEOF_VALUE, newobj_p);
-}
-
 static inline void *
 asan_unpoison_object_temporary(VALUE obj)
 {
-    void *ptr = asan_poisoned_object_p(obj);
-    asan_unpoison_object(obj, false);
+    void *ptr = rb_asan_poisoned_object_p(obj);
+    rb_asan_unpoison_object(obj, false);
     return ptr;
 }
 
@@ -201,11 +209,40 @@ static inline void *
 asan_poison_object_restore(VALUE obj, void *ptr)
 {
     if (ptr) {
-        asan_poison_object(obj);
+        rb_asan_poison_object(obj);
     }
     return NULL;
 }
 
+#define asan_unpoisoning_object(obj) \
+    for (void *poisoned = asan_unpoison_object_temporary(obj), \
+              *unpoisoning = &poisoned; /* flag to loop just once */ \
+         unpoisoning; \
+         unpoisoning = asan_poison_object_restore(obj, poisoned))
+
+
+static inline void *
+asan_unpoison_memory_region_temporary(void *ptr, size_t len)
+{
+    void *poisoned_ptr = __asan_region_is_poisoned(ptr, len);
+    asan_unpoison_memory_region(ptr, len, false);
+    return poisoned_ptr;
+}
+
+static inline void *
+asan_poison_memory_region_restore(void *ptr, size_t len, void *poisoned_ptr)
+{
+    if (poisoned_ptr) {
+        asan_poison_memory_region(ptr, len);
+    }
+    return NULL;
+}
+
+#define asan_unpoisoning_memory_region(ptr, len) \
+    for (void *poisoned = asan_unpoison_memory_region_temporary(ptr, len), \
+              *unpoisoning = &poisoned; /* flag to loop just once */ \
+         unpoisoning; \
+         unpoisoning = asan_poison_memory_region_restore(ptr, len, poisoned))
 
 /**
  * Checks if the given pointer is on an ASAN fake stack. If so, it returns the
@@ -293,5 +330,17 @@ asan_get_fake_stack_extents(void *thread_fake_stack_handle, VALUE slot,
     return false;
 }
 
+extern const char ruby_asan_default_options[];
+
+#ifdef RUBY_ASAN_ENABLED
+/* Compile in the ASAN options Ruby needs, rather than relying on environment variables, so
+ * that even tests which fork ruby with a clean environment will run ASAN with the right
+ * settings */
+# undef RUBY__ASAN_DEFAULT_OPTIONS
+# define RUBY__ASAN_DEFAULT_OPTIONS \
+    RBIMPL_SYMBOL_EXPORT_BEGIN() \
+    const char * __asan_default_options(void) {return ruby_asan_default_options;} \
+    RBIMPL_SYMBOL_EXPORT_END()
+#endif
 
 #endif /* INTERNAL_SANITIZERS_H */

data/ext/kanayago/internal/set_table.h

@@ -0,0 +1,70 @@
+#ifndef INTERNAL_SET_TABLE_H
+#define INTERNAL_SET_TABLE_H
+
+#include "include/ruby/st.h"
+
+struct set_table_entry;
+
+typedef struct set_table_entry set_table_entry;
+
+struct set_table {
+    /* Cached features of the table -- see st.c for more details.  */
+    unsigned char entry_power, bin_power, size_ind;
+    /* How many times the table was rebuilt.  */
+    unsigned int rebuilds_num;
+    const struct st_hash_type *type;
+    /* Number of entries currently in the table.  */
+    st_index_t num_entries;
+
+    /* Start and bound index of entries in array entries.
+       entries_starts and entries_bound are in interval
+       [0,allocated_entries].  */
+    st_index_t entries_start, entries_bound;
+
+    /**
+     * Array of size 2^entry_power.
+     * Followed by st_index_t *bins, Array of bins used for access by keys.
+     */
+    set_table_entry *entries;
+};
+
+typedef struct set_table set_table;
+
+typedef int set_foreach_callback_func(st_data_t, st_data_t);
+typedef int set_foreach_check_callback_func(st_data_t, st_data_t, int);
+typedef int set_update_callback_func(st_data_t *key, st_data_t arg, int existing);
+
+#define set_table_size rb_set_table_size
+size_t rb_set_table_size(const struct set_table *tbl);
+#define set_init_table_with_size rb_set_init_table_with_size
+set_table *rb_set_init_table_with_size(set_table *tab, const struct st_hash_type *, st_index_t);
+#define set_init_numtable rb_set_init_numtable
+set_table *rb_set_init_numtable(void);
+#define set_init_numtable_with_size rb_set_init_numtable_with_size
+set_table *rb_set_init_numtable_with_size(st_index_t size);
+#define set_table_delete rb_set_table_delete
+int rb_set_table_delete(set_table *, st_data_t *); /* returns 0:notfound 1:deleted */
+#define set_insert rb_set_insert
+int rb_set_insert(set_table *, st_data_t);
+#define set_table_lookup rb_set_table_lookup
+int rb_set_table_lookup(set_table *, st_data_t);
+#define set_foreach_with_replace rb_set_foreach_with_replace
+int rb_set_foreach_with_replace(set_table *tab, set_foreach_check_callback_func *func, set_update_callback_func *replace, st_data_t arg);
+#define set_table_foreach rb_set_table_foreach
+int rb_set_table_foreach(set_table *, set_foreach_callback_func *, st_data_t);
+#define set_foreach_check rb_set_foreach_check
+int rb_set_foreach_check(set_table *, set_foreach_check_callback_func *, st_data_t, st_data_t);
+#define set_keys rb_set_keys
+st_index_t rb_set_keys(set_table *table, st_data_t *keys, st_index_t size);
+#define set_free_table rb_set_free_table
+void rb_set_free_table(set_table *);
+#define set_table_clear rb_set_table_clear
+void rb_set_table_clear(set_table *);
+#define set_copy rb_set_copy
+set_table *rb_set_copy(set_table *new_table, set_table *old_table);
+#define set_memsize rb_set_memsize
+PUREFUNC(size_t rb_set_memsize(const set_table *));
+#define set_compact_table rb_set_compact_table
+void set_compact_table(set_table *tab);
+
+#endif

data/ext/kanayago/internal/string.h

@@ -15,9 +15,11 @@
 #include "ruby/encoding.h"      /* for rb_encoding */
 #include "ruby/ruby.h"          /* for VALUE */
 
-#define STR_NOEMBED      FL_USER1
-#define STR_SHARED       FL_USER2 /* = ELTS_SHARED */
-#define STR_CHILLED      FL_USER3
+#define STR_SHARED                  FL_USER0 /* = ELTS_SHARED */
+#define STR_NOEMBED                 FL_USER1
+#define STR_CHILLED                 (FL_USER2 | FL_USER3)
+#define STR_CHILLED_LITERAL         FL_USER2
+#define STR_CHILLED_SYMBOL_TO_S     FL_USER3
 
 enum ruby_rstring_private_flags {
     RSTRING_CHILLED = STR_CHILLED,
@@ -28,6 +30,7 @@ enum ruby_rstring_private_flags {
 #endif
 
 /* string.c */
+VALUE rb_str_dup_m(VALUE str);
 VALUE rb_fstring(VALUE);
 VALUE rb_fstring_cstr(const char *str);
 VALUE rb_fstring_enc_new(const char *ptr, long len, rb_encoding *enc);
@@ -51,6 +54,19 @@ int rb_enc_str_coderange_scan(VALUE str, rb_encoding *enc);
 int rb_ascii8bit_appendable_encoding_index(rb_encoding *enc, unsigned int code);
 VALUE rb_str_include(VALUE str, VALUE arg);
 VALUE rb_str_byte_substr(VALUE str, VALUE beg, VALUE len);
+VALUE rb_str_substr_two_fixnums(VALUE str, VALUE beg, VALUE len, int empty);
+VALUE rb_str_tmp_frozen_no_embed_acquire(VALUE str);
+void rb_str_make_embedded(VALUE);
+VALUE rb_str_upto_each(VALUE, VALUE, int, int (*each)(VALUE, VALUE), VALUE);
+size_t rb_str_size_as_embedded(VALUE);
+bool rb_str_reembeddable_p(VALUE);
+VALUE rb_str_upto_endless_each(VALUE, int (*each)(VALUE, VALUE), VALUE);
+VALUE rb_str_with_debug_created_info(VALUE, VALUE, int);
+VALUE rb_str_frozen_bare_string(VALUE);
+
+/* error.c */
+void rb_warn_unchilled_literal(VALUE str);
+void rb_warn_unchilled_symbol_to_s(VALUE str);
 
 static inline bool STR_EMBED_P(VALUE str);
 static inline bool STR_SHARED_P(VALUE str);
@@ -63,17 +79,14 @@ static inline VALUE rb_str_eql_internal(const VALUE str1, const VALUE str2);
 RUBY_SYMBOL_EXPORT_BEGIN
 /* string.c (export) */
 VALUE rb_str_tmp_frozen_acquire(VALUE str);
-VALUE rb_str_tmp_frozen_no_embed_acquire(VALUE str);
 void rb_str_tmp_frozen_release(VALUE str, VALUE tmp);
 VALUE rb_setup_fake_str(struct RString *fake_str, const char *name, long len, rb_encoding *enc);
-VALUE rb_str_upto_each(VALUE, VALUE, int, int (*each)(VALUE, VALUE), VALUE);
-VALUE rb_str_upto_endless_each(VALUE, int (*each)(VALUE, VALUE), VALUE);
-void rb_str_make_embedded(VALUE);
-size_t rb_str_size_as_embedded(VALUE);
-bool rb_str_reembeddable_p(VALUE);
 RUBY_SYMBOL_EXPORT_END
 
 VALUE rb_fstring_new(const char *ptr, long len);
+void rb_gc_free_fstring(VALUE obj);
+bool rb_obj_is_fstring_table(VALUE obj);
+void Init_fstring_table();
 VALUE rb_obj_as_string_result(VALUE str, VALUE obj);
 VALUE rb_str_opt_plus(VALUE x, VALUE y);
 VALUE rb_str_concat_literals(size_t num, const VALUE *strary);
@@ -123,14 +136,18 @@ CHILLED_STRING_P(VALUE obj)
 static inline void
 CHILLED_STRING_MUTATED(VALUE str)
 {
+    VALUE chilled_reason = RB_FL_TEST_RAW(str, STR_CHILLED);
     FL_UNSET_RAW(str, STR_CHILLED);
-    rb_category_warn(RB_WARN_CATEGORY_DEPRECATED, "literal string will be frozen in the future");
-}
-
-static inline void
-STR_CHILL_RAW(VALUE str)
-{
-    FL_SET_RAW(str, STR_CHILLED);
+    switch (chilled_reason) {
+      case STR_CHILLED_SYMBOL_TO_S:
+        rb_warn_unchilled_symbol_to_s(str);
+        break;
+      case STR_CHILLED_LITERAL:
+        rb_warn_unchilled_literal(str);
+        break;
+      default:
+        rb_bug("RString was chilled for multiple reasons");
+    }
 }
 
 static inline bool

data/ext/kanayago/internal/symbol.h

@@ -17,6 +17,7 @@
 #endif
 
 /* symbol.c */
+void rb_sym_global_symbols_mark_and_move(void);
 VALUE rb_to_symbol_type(VALUE obj);
 VALUE rb_sym_intern(const char *ptr, long len, rb_encoding *enc);
 VALUE rb_sym_intern_ascii(const char *ptr, long len);
@@ -29,11 +30,11 @@ PUREFUNC(int rb_is_const_sym(VALUE sym));
 PUREFUNC(int rb_is_attrset_sym(VALUE sym));
 ID rb_make_internal_id(void);
 ID rb_make_temporary_id(size_t n);
+bool rb_obj_is_symbol_table(VALUE obj);
+void rb_sym_global_symbol_table_foreach_weak_reference(int (*callback)(VALUE *key, void *data), void *data);
 void rb_gc_free_dsymbol(VALUE);
 int rb_static_id_valid_p(ID id);
-
-/* vm.c */
-void rb_free_static_symid_str(void);
+void rb_free_global_symbol_table(void);
 
 #if __has_builtin(__builtin_constant_p)
 #define rb_sym_intern_ascii_cstr(ptr) \

data/ext/kanayago/internal/thread.h

@@ -13,6 +13,7 @@
 #include "ccan/list/list.h"     /* for list in rb_io_close_wait_list */
 
 struct rb_thread_struct;        /* in vm_core.h */
+struct rb_io;
 
 #define RB_VM_SAVE_MACHINE_CONTEXT(th)				\
     do {							\
@@ -46,27 +47,35 @@ VALUE rb_thread_shield_wait(VALUE self);
 VALUE rb_thread_shield_release(VALUE self);
 VALUE rb_thread_shield_destroy(VALUE self);
 int rb_thread_to_be_killed(VALUE thread);
+void rb_thread_acquire_fork_lock(void);
+void rb_thread_release_fork_lock(void);
+void rb_thread_reset_fork_lock(void);
 void rb_mutex_allow_trap(VALUE self, int val);
 VALUE rb_uninterruptible(VALUE (*b_proc)(VALUE), VALUE data);
 VALUE rb_mutex_owned_p(VALUE self);
 VALUE rb_exec_recursive_outer_mid(VALUE (*f)(VALUE g, VALUE h, int r), VALUE g, VALUE h, ID mid);
 void ruby_mn_threads_params(void);
 
+int rb_thread_io_wait(struct rb_io *io, int events, struct timeval * timeout);
 int rb_thread_wait_for_single_fd(int fd, int events, struct timeval * timeout);
 
-struct rb_io_close_wait_list {
-    struct ccan_list_head pending_fd_users;
-    VALUE closing_thread;
-    VALUE wakeup_mutex;
-};
-int rb_notify_fd_close(int fd, struct rb_io_close_wait_list *busy);
-void rb_notify_fd_close_wait(struct rb_io_close_wait_list *busy);
+size_t rb_thread_io_close_interrupt(struct rb_io *);
+void rb_thread_io_close_wait(struct rb_io *);
+
+void rb_ec_check_ints(struct rb_execution_context_struct *ec);
+
+void rb_thread_free_native_thread(void *th_ptr);
 
 RUBY_SYMBOL_EXPORT_BEGIN
 
+void *rb_thread_prevent_fork(void *(*func)(void *), void *data); /* for ext/socket/raddrinfo.c */
+
 /* Temporary.  This API will be removed (renamed). */
-VALUE rb_thread_io_blocking_region(rb_blocking_function_t *func, void *data1, int fd);
-VALUE rb_thread_io_blocking_call(rb_blocking_function_t *func, void *data1, int fd, int events);
+VALUE rb_thread_io_blocking_region(struct rb_io *io, rb_blocking_function_t *func, void *data1);
+VALUE rb_thread_io_blocking_call(struct rb_io *io, rb_blocking_function_t *func, void *data1, int events);
+
+// Invoke the given function, with the specified argument, in a way that `IO#close` from another execution context can interrupt it.
+VALUE rb_thread_io_blocking_operation(VALUE self, VALUE(*function)(VALUE), VALUE argument);
 
 /* thread.c (export) */
 int ruby_thread_has_gvl_p(void); /* for ext/fiddle/closure.c */
@@ -76,4 +85,28 @@ RUBY_SYMBOL_EXPORT_END
 int rb_threadptr_execute_interrupts(struct rb_thread_struct *th, int blocking_timing);
 bool rb_thread_mn_schedulable(VALUE thread);
 
+bool rb_thread_resolve_unblock_function(rb_unblock_function_t **unblock_function, void **data2, struct rb_thread_struct *thread);
+
+// interrupt exec
+
+typedef VALUE (rb_interrupt_exec_func_t)(void *data);
+
+enum rb_interrupt_exec_flag {
+    rb_interrupt_exec_flag_none = 0x00,
+    rb_interrupt_exec_flag_value_data = 0x01,
+    rb_interrupt_exec_flag_new_thread = 0x02,
+};
+
+// interrupt the target_th and run func.
+struct rb_ractor_struct;
+
+void rb_threadptr_interrupt_exec(struct rb_thread_struct *target_th,
+                                 rb_interrupt_exec_func_t *func, void *data, enum rb_interrupt_exec_flag flags);
+
+// create a thread in the target_r and run func on the created thread.
+void rb_ractor_interrupt_exec(struct rb_ractor_struct *target_r,
+                              rb_interrupt_exec_func_t *func, void *data, enum rb_interrupt_exec_flag flags);
+
+void rb_threadptr_interrupt_exec_task_mark(struct rb_thread_struct *th);
+
 #endif /* INTERNAL_THREAD_H */