debase-ruby_core_source 3.2.2 → 3.3.0

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview2 → ruby-3.3.0-p0}/internal/array.h

@@ -136,9 +136,16 @@ RBIMPL_ATTR_ARTIFICIAL()
 static inline VALUE
 RARRAY_AREF(VALUE ary, long i)
 {
+    VALUE val;
     RBIMPL_ASSERT_TYPE(ary, RUBY_T_ARRAY);
 
-    return RARRAY_CONST_PTR(ary)[i];
+    RBIMPL_WARNING_PUSH();
+#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ == 13
+    RBIMPL_WARNING_IGNORED(-Warray-bounds);
+#endif
+    val = RARRAY_CONST_PTR(ary)[i];
+    RBIMPL_WARNING_POP();
+    return val;
 }
 
 #endif /* INTERNAL_ARRAY_H */

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview2 → ruby-3.3.0-p0}/internal/bits.h

@@ -398,9 +398,9 @@ rb_popcount32(uint32_t x)
 #else
     x = (x & 0x55555555) + (x >> 1 & 0x55555555);
     x = (x & 0x33333333) + (x >> 2 & 0x33333333);
-    x = (x & 0x0f0f0f0f) + (x >> 4 & 0x0f0f0f0f);
-    x = (x & 0x001f001f) + (x >> 8 & 0x001f001f);
-    x = (x & 0x0000003f) + (x >>16 & 0x0000003f);
+    x = (x & 0x07070707) + (x >> 4 & 0x07070707);
+    x = (x & 0x000f000f) + (x >> 8 & 0x000f000f);
+    x = (x & 0x0000001f) + (x >>16 & 0x0000001f);
     return (unsigned int)x;
 
 #endif
@@ -428,9 +428,9 @@ rb_popcount64(uint64_t x)
     x = (x & 0x5555555555555555) + (x >> 1 & 0x5555555555555555);
     x = (x & 0x3333333333333333) + (x >> 2 & 0x3333333333333333);
     x = (x & 0x0707070707070707) + (x >> 4 & 0x0707070707070707);
-    x = (x & 0x001f001f001f001f) + (x >> 8 & 0x001f001f001f001f);
-    x = (x & 0x0000003f0000003f) + (x >>16 & 0x0000003f0000003f);
-    x = (x & 0x000000000000007f) + (x >>32 & 0x000000000000007f);
+    x = (x & 0x000f000f000f000f) + (x >> 8 & 0x000f000f000f000f);
+    x = (x & 0x0000001f0000001f) + (x >>16 & 0x0000001f0000001f);
+    x = (x & 0x000000000000003f) + (x >>32 & 0x000000000000003f);
     return (unsigned int)x;
 
 #endif

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview2 → ruby-3.3.0-p0}/internal/class.h

@@ -19,6 +19,7 @@
 #include "shape.h"
 #include "ruby_assert.h"
 #include "vm_core.h"
+#include "vm_sync.h"
 #include "method.h"             /* for rb_cref_t */
 
 #ifdef RCLASS_SUPER
@@ -85,7 +86,12 @@ struct RClass {
 // Assert that classes can be embedded in size_pools[2] (which has 160B slot size)
 STATIC_ASSERT(sizeof_rb_classext_t, sizeof(struct RClass) + sizeof(rb_classext_t) <= 4 * RVALUE_SIZE);
 
-#define RCLASS_EXT(c) ((rb_classext_t *)((char *)(c) + sizeof(struct RClass)))
+struct RClass_and_rb_classext_t {
+    struct RClass rclass;
+    rb_classext_t classext;
+};
+
+#define RCLASS_EXT(c) (&((struct RClass_and_rb_classext_t*)(c))->classext)
 #define RCLASS_CONST_TBL(c) (RCLASS_EXT(c)->const_tbl)
 #define RCLASS_M_TBL(c) (RCLASS(c)->m_tbl)
 #define RCLASS_IVPTR(c) (RCLASS_EXT(c)->iv_ptr)
@@ -106,6 +112,51 @@ STATIC_ASSERT(sizeof_rb_classext_t, sizeof(struct RClass) + sizeof(rb_classext_t
 #define RCLASS_SUPERCLASSES_INCLUDE_SELF FL_USER2
 #define RICLASS_ORIGIN_SHARED_MTBL FL_USER3
 
+static inline st_table *
+RCLASS_IV_HASH(VALUE obj)
+{
+    RUBY_ASSERT(RB_TYPE_P(obj, RUBY_T_CLASS) || RB_TYPE_P(obj, RUBY_T_MODULE));
+    RUBY_ASSERT(rb_shape_obj_too_complex(obj));
+    return (st_table *)RCLASS_IVPTR(obj);
+}
+
+static inline void
+RCLASS_SET_IV_HASH(VALUE obj, const st_table *tbl)
+{
+    RUBY_ASSERT(RB_TYPE_P(obj, RUBY_T_CLASS) || RB_TYPE_P(obj, RUBY_T_MODULE));
+    RUBY_ASSERT(rb_shape_obj_too_complex(obj));
+    RCLASS_IVPTR(obj) = (VALUE *)tbl;
+}
+
+static inline uint32_t
+RCLASS_IV_COUNT(VALUE obj)
+{
+    RUBY_ASSERT(RB_TYPE_P(obj, RUBY_T_CLASS) || RB_TYPE_P(obj, RUBY_T_MODULE));
+    if (rb_shape_obj_too_complex(obj)) {
+        uint32_t count;
+
+        // "Too complex" classes could have their IV hash mutated in
+        // parallel, so lets lock around getting the hash size.
+        RB_VM_LOCK_ENTER();
+        {
+            count = (uint32_t)rb_st_table_size(RCLASS_IV_HASH(obj));
+        }
+        RB_VM_LOCK_LEAVE();
+
+        return count;
+    }
+    else {
+        return rb_shape_get_shape_by_id(RCLASS_SHAPE_ID(obj))->next_iv_index;
+    }
+}
+
+static inline void
+RCLASS_SET_M_TBL(VALUE klass, struct rb_id_table *table)
+{
+    RUBY_ASSERT(!RB_OBJ_PROMOTED(klass));
+    RCLASS_M_TBL(klass) = table;
+}
+
 /* class.c */
 void rb_class_subclass_add(VALUE super, VALUE klass);
 void rb_class_remove_from_super_subclasses(VALUE);
@@ -119,7 +170,6 @@ VALUE rb_module_s_alloc(VALUE klass);
 void rb_module_set_initialized(VALUE module);
 void rb_module_check_initializable(VALUE module);
 VALUE rb_make_metaclass(VALUE, VALUE);
-VALUE rb_iclass_alloc(VALUE klass);
 VALUE rb_include_class_new(VALUE, VALUE);
 void rb_class_foreach_subclass(VALUE klass, void (*f)(VALUE, VALUE), VALUE);
 void rb_class_detach_subclasses(VALUE);
@@ -206,7 +256,7 @@ RCLASS_SET_SUPER(VALUE klass, VALUE super)
 static inline void
 RCLASS_SET_CLASSPATH(VALUE klass, VALUE classpath, bool permanent)
 {
-    assert(BUILTIN_TYPE(klass) == T_CLASS || BUILTIN_TYPE(klass) == T_MODULE || klass == rb_mRubyVMFrozenCore);
+    assert(BUILTIN_TYPE(klass) == T_CLASS || BUILTIN_TYPE(klass) == T_MODULE);
     assert(classpath == 0 || BUILTIN_TYPE(classpath) == T_STRING);
 
     RB_OBJ_WRITE(klass, &(RCLASS_EXT(klass)->classpath), classpath);

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview2 → ruby-3.3.0-p0}/internal/cmdlineopt.h

@@ -28,6 +28,8 @@ typedef struct ruby_cmdline_options {
     struct rb_rjit_options rjit;
 #endif
 
+    const char *crash_report;
+
     signed int sflag: 2;
     unsigned int xflag: 1;
     unsigned int warning: 1;

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview2 → ruby-3.3.0-p0}/internal/cont.h

@@ -22,6 +22,9 @@ void rb_jit_cont_init(void);
 void rb_jit_cont_each_iseq(rb_iseq_callback callback, void *data);
 void rb_jit_cont_finish(void);
 
+/* vm.c */
+void rb_free_shared_fiber_pool(void);
+
 // Copy locals from the current execution to the specified fiber.
 VALUE rb_fiber_inherit_storage(struct rb_execution_context_struct *ec, struct rb_fiber_struct *fiber);
 

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview2 → ruby-3.3.0-p0}/internal/encoding.h

@@ -29,4 +29,7 @@ void rb_enc_set_base(const char *name, const char *orig);
 int rb_enc_set_dummy(int index);
 PUREFUNC(int rb_data_is_encoding(VALUE obj));
 
+/* vm.c */
+void rb_free_global_enc_table(void);
+
 #endif /* INTERNAL_ENCODING_H */

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview2 → ruby-3.3.0-p0}/internal/error.h

@@ -169,6 +169,9 @@ VALUE rb_syserr_new_path_in(const char *func_name, int n, VALUE path);
 #endif
 RUBY_SYMBOL_EXPORT_END
 
+/* vm.c */
+void rb_free_warning(void);
+
 static inline void
 rb_raise_cstr_i(VALUE etype, VALUE mesg)
 {

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview2 → ruby-3.3.0-p0}/internal/gc.h

@@ -227,6 +227,7 @@ __attribute__((__alloc_align__(1)))
 RUBY_ATTR_MALLOC void *rb_aligned_malloc(size_t, size_t) RUBY_ATTR_ALLOC_SIZE((2));
 size_t rb_size_mul_or_raise(size_t, size_t, VALUE); /* used in compile.c */
 size_t rb_size_mul_add_or_raise(size_t, size_t, size_t, VALUE); /* used in iseq.h */
+size_t rb_malloc_grow_capa(size_t current_capacity, size_t type_size);
 RUBY_ATTR_MALLOC void *rb_xmalloc_mul_add(size_t, size_t, size_t);
 RUBY_ATTR_MALLOC void *rb_xcalloc_mul_add(size_t, size_t, size_t);
 void *rb_xrealloc_mul_add(const void *, size_t, size_t, size_t);
@@ -249,6 +250,8 @@ void rb_gc_mark_and_move(VALUE *ptr);
 void rb_gc_mark_weak(VALUE *ptr);
 void rb_gc_remove_weak(VALUE parent_obj, VALUE *ptr);
 
+void rb_gc_ref_update_table_values_only(st_table *tbl);
+
 #define rb_gc_mark_and_move_ptr(ptr) do { \
     VALUE _obj = (VALUE)*(ptr); \
     rb_gc_mark_and_move(&_obj); \

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview2 → ruby-3.3.0-p0}/internal/hash.h

@@ -87,6 +87,7 @@ int rb_hash_stlike_delete(VALUE hash, st_data_t *pkey, st_data_t *pval);
 int rb_hash_stlike_foreach_with_replace(VALUE hash, st_foreach_check_callback_func *func, st_update_callback_func *replace, st_data_t arg);
 int rb_hash_stlike_update(VALUE hash, st_data_t key, st_update_callback_func *func, st_data_t arg);
 VALUE rb_ident_hash_new_with_size(st_index_t size);
+void rb_hash_free(VALUE hash);
 
 static inline unsigned RHASH_AR_TABLE_SIZE_RAW(VALUE h);
 static inline VALUE RHASH_IFNONE(VALUE h);

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview2 → ruby-3.3.0-p0}/internal/imemo.h

@@ -129,7 +129,6 @@ struct MEMO {
 typedef struct rb_imemo_tmpbuf_struct rb_imemo_tmpbuf_t;
 rb_imemo_tmpbuf_t *rb_imemo_tmpbuf_parser_heap(void *buf, rb_imemo_tmpbuf_t *old_heap, size_t cnt);
 struct vm_ifunc *rb_vm_ifunc_new(rb_block_call_func_t func, const void *data, int min_argc, int max_argc);
-void rb_strterm_mark(VALUE obj);
 static inline enum imemo_type imemo_type(VALUE imemo);
 static inline int imemo_type_p(VALUE imemo, enum imemo_type imemo_type);
 static inline bool imemo_throw_data_p(VALUE imemo);

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview2 → ruby-3.3.0-p0}/internal/object.h

@@ -11,6 +11,7 @@
 #include "ruby/ruby.h"          /* for VALUE */
 
 /* object.c */
+size_t rb_obj_embedded_size(uint32_t numiv);
 VALUE rb_class_search_ancestor(VALUE klass, VALUE super);
 NORETURN(void rb_undefined_alloc(VALUE klass));
 double rb_num_to_dbl(VALUE val);

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview2 → ruby-3.3.0-p0}/internal/parse.h

@@ -22,47 +22,22 @@ struct rb_iseq_struct;          /* in vm_core.h */
 
 /* structs for managing terminator of string literal and heredocment */
 typedef struct rb_strterm_literal_struct {
-    union {
-        VALUE dummy;
-        long nest;
-    } u0;
-    union {
-        VALUE dummy;
-        long func;	    /* STR_FUNC_* (e.g., STR_FUNC_ESCAPE and STR_FUNC_EXPAND) */
-    } u1;
-    union {
-        VALUE dummy;
-        long paren;	    /* '(' of `%q(...)` */
-    } u2;
-    union {
-        VALUE dummy;
-        long term;	    /* ')' of `%q(...)` */
-    } u3;
+    long nest;
+    int func;	    /* STR_FUNC_* (e.g., STR_FUNC_ESCAPE and STR_FUNC_EXPAND) */
+    int paren;	    /* '(' of `%q(...)` */
+    int term;	    /* ')' of `%q(...)` */
 } rb_strterm_literal_t;
 
-#define HERETERM_LENGTH_BITS ((SIZEOF_VALUE - 1) * CHAR_BIT - 1)
-
 typedef struct rb_strterm_heredoc_struct {
     VALUE lastline;	/* the string of line that contains `<<"END"` */
     long offset;	/* the column of END in `<<"END"` */
     int sourceline;	/* lineno of the line that contains `<<"END"` */
-    unsigned length	/* the length of END in `<<"END"` */
-#if HERETERM_LENGTH_BITS < SIZEOF_INT * CHAR_BIT
-    : HERETERM_LENGTH_BITS
-# define HERETERM_LENGTH_MAX ((1U << HERETERM_LENGTH_BITS) - 1)
-#else
-# define HERETERM_LENGTH_MAX UINT_MAX
-#endif
-    ;
-#if HERETERM_LENGTH_BITS < SIZEOF_INT * CHAR_BIT
-    unsigned quote: 1;
-    unsigned func: 8;
-#else
+    unsigned length;	/* the length of END in `<<"END"` */
     uint8_t quote;
     uint8_t func;
-#endif
 } rb_strterm_heredoc_t;
-STATIC_ASSERT(rb_strterm_heredoc_t, sizeof(rb_strterm_heredoc_t) <= 4 * SIZEOF_VALUE);
+
+#define HERETERM_LENGTH_MAX UINT_MAX
 
 typedef struct rb_strterm_struct {
     VALUE flags;

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview2 → ruby-3.3.0-p0}/internal/random.h

@@ -12,5 +12,6 @@
 
 /* random.c */
 int ruby_fill_random_bytes(void *, size_t, int);
+void rb_free_default_rand_key(void);
 
 #endif /* INTERNAL_RANDOM_H */

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview2 → ruby-3.3.0-p0}/internal/string.h

@@ -64,7 +64,6 @@ 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);
-void rb_str_update_shared_ary(VALUE str, VALUE old_root, VALUE new_root);
 RUBY_SYMBOL_EXPORT_END
 
 VALUE rb_fstring_new(const char *ptr, long len);

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview2 → ruby-3.3.0-p0}/internal/symbol.h

@@ -32,6 +32,9 @@ ID rb_make_temporary_id(size_t n);
 void rb_gc_free_dsymbol(VALUE);
 int rb_static_id_valid_p(ID id);
 
+/* vm.c */
+void rb_free_static_symid_str(void);
+
 #if __has_builtin(__builtin_constant_p)
 #define rb_sym_intern_ascii_cstr(ptr) \
     (__builtin_constant_p(ptr) ? \

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview2 → ruby-3.3.0-p0}/internal/thread.h

@@ -50,6 +50,7 @@ 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_wait_for_single_fd(int fd, int events, struct timeval * timeout);
 
@@ -62,11 +63,14 @@ 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);
 
 RUBY_SYMBOL_EXPORT_BEGIN
+
 /* 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);
 
 /* thread.c (export) */
 int ruby_thread_has_gvl_p(void); /* for ext/fiddle/closure.c */
+
 RUBY_SYMBOL_EXPORT_END
 
 int rb_threadptr_execute_interrupts(struct rb_thread_struct *th, int blocking_timing);

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview2 → ruby-3.3.0-p0}/internal/transcode.h

@@ -17,4 +17,7 @@
 extern VALUE rb_cEncodingConverter;
 size_t rb_econv_memsize(rb_econv_t *);
 
+/* vm.c */
+void rb_free_transcoder_table(void);
+
 #endif /* INTERNAL_TRANSCODE_H */

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview2 → ruby-3.3.0-p0}/internal/variable.h

@@ -47,11 +47,14 @@ VALUE rb_mod_set_temporary_name(VALUE, VALUE);
 
 struct gen_ivtbl;
 int rb_gen_ivtbl_get(VALUE obj, ID id, struct gen_ivtbl **ivtbl);
-int rb_obj_evacuate_ivs_to_hash_table(ID key, VALUE val, st_data_t arg);
+void rb_obj_copy_ivs_to_hash_table(VALUE obj, st_table *table);
+void rb_obj_convert_to_too_complex(VALUE obj, st_table *table);
+void rb_evict_ivars_to_hash(VALUE obj);
 
 RUBY_SYMBOL_EXPORT_BEGIN
 /* variable.c (export) */
-void rb_mark_and_update_generic_ivar(VALUE);
+void rb_mark_generic_ivar(VALUE obj);
+void rb_ref_update_generic_ivar(VALUE);
 void rb_mv_generic_ivar(VALUE src, VALUE dst);
 VALUE rb_const_missing(VALUE klass, VALUE name);
 int rb_class_ivar_set(VALUE klass, ID vid, VALUE value);
@@ -63,9 +66,7 @@ VALUE rb_gvar_get(ID);
 VALUE rb_gvar_set(ID, VALUE);
 VALUE rb_gvar_defined(ID);
 void rb_const_warn_if_deprecated(const rb_const_entry_t *, VALUE, ID);
-rb_shape_t * rb_grow_iv_list(VALUE obj);
 void rb_ensure_iv_list_size(VALUE obj, uint32_t len, uint32_t newsize);
-struct gen_ivtbl *rb_ensure_generic_iv_list_size(VALUE obj, rb_shape_t *shape, uint32_t newsize);
 attr_index_t rb_obj_ivar_set(VALUE obj, ID id, VALUE val);
 
 #endif /* INTERNAL_VARIABLE_H */

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview2 → ruby-3.3.0-p0}/internal/vm.h

@@ -58,6 +58,8 @@ VALUE rb_yield_refine_block(VALUE refinement, VALUE refinements);
 VALUE ruby_vm_special_exception_copy(VALUE);
 PUREFUNC(st_table *rb_vm_fstring_table(void));
 
+void rb_lastline_set_up(VALUE val, unsigned int up);
+
 /* vm_eval.c */
 VALUE rb_current_realfilepath(void);
 VALUE rb_check_block_call(VALUE, ID, int, const VALUE *, rb_block_call_func_t, VALUE);
@@ -81,6 +83,11 @@ void rb_check_stack_overflow(void);
 extern uint64_t rb_vm_insns_count;
 #endif
 
+extern bool rb_free_at_exit;
+
+/* miniinit.c and builtin.c */
+void rb_free_loaded_builtin_table(void);
+
 /* vm_insnhelper.c */
 VALUE rb_equal_opt(VALUE obj1, VALUE obj2);
 VALUE rb_eql_opt(VALUE obj1, VALUE obj2);
@@ -95,7 +102,7 @@ int rb_ec_obj_respond_to(struct rb_execution_context_struct *ec, VALUE obj, ID i
 void rb_clear_constant_cache(void);
 
 /* vm_dump.c */
-void rb_print_backtrace(void);
+void rb_print_backtrace(FILE *);
 
 /* vm_backtrace.c */
 VALUE rb_vm_thread_backtrace(int argc, const VALUE *argv, VALUE thval);
@@ -103,7 +110,7 @@ VALUE rb_vm_thread_backtrace_locations(int argc, const VALUE *argv, VALUE thval)
 VALUE rb_vm_backtrace(int argc, const VALUE * argv, struct rb_execution_context_struct * ec);
 VALUE rb_vm_backtrace_locations(int argc, const VALUE * argv, struct rb_execution_context_struct * ec);
 VALUE rb_make_backtrace(void);
-void rb_backtrace_print_as_bugreport(void);
+void rb_backtrace_print_as_bugreport(FILE*);
 int rb_backtrace_p(VALUE obj);
 VALUE rb_backtrace_to_str_ary(VALUE obj);
 VALUE rb_backtrace_to_location_ary(VALUE obj);

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview2 → ruby-3.3.0-p0}/iseq.h

@@ -13,6 +13,7 @@
 #include "internal/gc.h"
 #include "shape.h"
 #include "vm_core.h"
+#include "prism_compile.h"
 
 RUBY_EXTERN const int ruby_api_version[];
 #define ISEQ_MAJOR_VERSION ((unsigned int)ruby_api_version[0])
@@ -173,6 +174,7 @@ void rb_iseq_init_trace(rb_iseq_t *iseq);
 int rb_iseq_add_local_tracepoint_recursively(const rb_iseq_t *iseq, rb_event_flag_t turnon_events, VALUE tpval, unsigned int target_line, bool target_bmethod);
 int rb_iseq_remove_local_tracepoint_recursively(const rb_iseq_t *iseq, VALUE tpval);
 const rb_iseq_t *rb_iseq_load_iseq(VALUE fname);
+rb_iseq_t * rb_iseq_new_main_prism(pm_string_t *input, pm_options_t *options, VALUE path);
 
 #if VM_INSN_INFO_TABLE_IMPL == 2
 unsigned int *rb_iseq_insns_info_decode_positions(const struct rb_iseq_constant_body *body);
@@ -189,7 +191,7 @@ VALUE *rb_iseq_original_iseq(const rb_iseq_t *iseq);
 void rb_iseq_build_from_ary(rb_iseq_t *iseq, VALUE misc,
                             VALUE locals, VALUE args,
                             VALUE exception, VALUE body);
-void rb_iseq_mark_and_move_insn_storage(struct iseq_compile_data_storage *arena);
+void rb_iseq_mark_and_pin_insn_storage(struct iseq_compile_data_storage *arena);
 
 VALUE rb_iseq_load(VALUE data, VALUE parent, VALUE opt);
 VALUE rb_iseq_parameters(const rb_iseq_t *iseq, int is_proc);
@@ -329,6 +331,8 @@ VALUE rb_iseq_local_variables(const rb_iseq_t *iseq);
 
 attr_index_t rb_estimate_iv_count(VALUE klass, const rb_iseq_t * initialize_iseq);
 
+void rb_free_encoded_insn_data(void);
+
 RUBY_SYMBOL_EXPORT_END
 
 #endif /* RUBY_ISEQ_H */

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview2 → ruby-3.3.0-p0}/method.h

@@ -101,8 +101,9 @@ static inline void
 METHOD_ENTRY_FLAGS_COPY(rb_method_entry_t *dst, const rb_method_entry_t *src)
 {
     dst->flags =
-      (dst->flags & ~(IMEMO_FL_USER0|IMEMO_FL_USER1|IMEMO_FL_USER2)) |
-        (src->flags & (IMEMO_FL_USER0|IMEMO_FL_USER1|IMEMO_FL_USER2));
+      (dst->flags & ~(IMEMO_FL_USER0|IMEMO_FL_USER1|IMEMO_FL_USER2
+      |IMEMO_FL_USER3)) |
+        (src->flags & (IMEMO_FL_USER0|IMEMO_FL_USER1|IMEMO_FL_USER2|IMEMO_FL_USER3));
 }
 
 typedef enum {
@@ -152,7 +153,6 @@ typedef struct rb_method_alias_struct {
 
 typedef struct rb_method_refined_struct {
     struct rb_method_entry_struct * orig_me;
-    VALUE owner;
 } rb_method_refined_t;
 
 typedef struct rb_method_bmethod_struct {
@@ -178,9 +178,9 @@ typedef struct rb_method_optimized {
 struct rb_method_definition_struct {
     BITFIELD(rb_method_type_t, type, VM_METHOD_TYPE_MINIMUM_BITS);
     unsigned int iseq_overload: 1;
-    int alias_count : 27;
-    int complemented_count : 28;
     unsigned int no_redef_warning: 1;
+    unsigned int aliased : 1;
+    int reference_count : 28;
 
     union {
         rb_method_iseq_t iseq;
@@ -199,7 +199,7 @@ struct rb_method_definition_struct {
 struct rb_id_table;
 
 typedef struct rb_method_definition_struct rb_method_definition_t;
-STATIC_ASSERT(sizeof_method_def, offsetof(rb_method_definition_t, body)==8);
+STATIC_ASSERT(sizeof_method_def, offsetof(rb_method_definition_t, body) <= 8);
 
 #define UNDEFINED_METHOD_ENTRY_P(me) (!(me) || !(me)->def || (me)->def->type == VM_METHOD_TYPE_UNDEF)
 #define UNDEFINED_REFINED_METHOD_P(def) \
@@ -213,7 +213,7 @@ void rb_add_method_optimized(VALUE klass, ID mid, enum method_optimized_type, un
 void rb_add_refined_method_entry(VALUE refined_class, ID mid);
 
 rb_method_entry_t *rb_method_entry_set(VALUE klass, ID mid, const rb_method_entry_t *, rb_method_visibility_t noex);
-rb_method_entry_t *rb_method_entry_create(ID called_id, VALUE klass, rb_method_visibility_t visi, const rb_method_definition_t *def);
+rb_method_entry_t *rb_method_entry_create(ID called_id, VALUE klass, rb_method_visibility_t visi, rb_method_definition_t *def);
 
 const rb_method_entry_t *rb_method_entry_at(VALUE obj, ID id);
 

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview2 → ruby-3.3.0-p0}/node.h

@@ -19,12 +19,14 @@ typedef void (*bug_report_func)(const char *fmt, ...);
 
 typedef struct node_buffer_elem_struct {
     struct node_buffer_elem_struct *next;
-    long len;
-    NODE buf[FLEX_ARY_LEN];
+    long len; /* Length of nodes */
+    size_t allocated; /* Total memory size of allocated buf */
+    size_t used; /* Current usage of buf */
+    NODE **nodes; /* Array of node pointers */
+    NODE *buf[FLEX_ARY_LEN];
 } node_buffer_elem_t;
 
 typedef struct {
-    long idx, len;
     node_buffer_elem_t *head;
     node_buffer_elem_t *last;
 } node_buffer_list_t;
@@ -50,7 +52,7 @@ RUBY_SYMBOL_EXPORT_BEGIN
 #ifdef UNIVERSAL_PARSER
 rb_ast_t *rb_ast_new(rb_parser_config_t *config);
 #else
-rb_ast_t *rb_ast_new();
+rb_ast_t *rb_ast_new(void);
 #endif
 size_t rb_ast_memsize(const rb_ast_t*);
 void rb_ast_dispose(rb_ast_t*);
@@ -59,14 +61,15 @@ VALUE rb_ast_tokens(rb_ast_t *ast);
 void rb_ast_node_type_change(NODE *n, enum node_type type);
 #endif
 const char *ruby_node_name(int node);
-void rb_node_init(NODE *n, enum node_type type, VALUE a0, VALUE a1, VALUE a2);
+void rb_node_init(NODE *n, enum node_type type);
 
 void rb_ast_mark(rb_ast_t*);
 void rb_ast_update_references(rb_ast_t*);
 void rb_ast_free(rb_ast_t*);
 void rb_ast_add_mark_object(rb_ast_t*, VALUE);
+void rb_ast_delete_mark_object(rb_ast_t*, VALUE);
 void rb_ast_set_tokens(rb_ast_t*, VALUE);
-NODE *rb_ast_newnode(rb_ast_t*, enum node_type type);
+NODE *rb_ast_newnode(rb_ast_t*, enum node_type type, size_t size, size_t alignment);
 void rb_ast_delete_node(rb_ast_t*, NODE *n);
 rb_ast_id_table_t *rb_ast_new_local_table(rb_ast_t*, int);
 rb_ast_id_table_t *rb_ast_resize_latest_local_table(rb_ast_t*, int);
@@ -94,27 +97,27 @@ RUBY_SYMBOL_EXPORT_END
 
 
 #define NODE_SPECIAL_REQUIRED_KEYWORD ((NODE *)-1)
-#define NODE_REQUIRED_KEYWORD_P(node) ((node)->nd_value == NODE_SPECIAL_REQUIRED_KEYWORD)
+#define NODE_REQUIRED_KEYWORD_P(node) ((node) == NODE_SPECIAL_REQUIRED_KEYWORD)
 #define NODE_SPECIAL_NO_NAME_REST     ((NODE *)-1)
 #define NODE_NAMED_REST_P(node) ((node) != NODE_SPECIAL_NO_NAME_REST)
 #define NODE_SPECIAL_EXCESSIVE_COMMA   ((ID)1)
 #define NODE_SPECIAL_NO_REST_KEYWORD   ((NODE *)-1)
 
-#define nd_first_column(n) ((int)((n)->nd_loc.beg_pos.column))
-#define nd_set_first_column(n, v) ((n)->nd_loc.beg_pos.column = (v))
-#define nd_first_lineno(n) ((int)((n)->nd_loc.beg_pos.lineno))
-#define nd_set_first_lineno(n, v) ((n)->nd_loc.beg_pos.lineno = (v))
-#define nd_first_loc(n) ((n)->nd_loc.beg_pos)
+#define nd_first_column(n) ((int)(RNODE(n)->nd_loc.beg_pos.column))
+#define nd_set_first_column(n, v) (RNODE(n)->nd_loc.beg_pos.column = (v))
+#define nd_first_lineno(n) ((int)(RNODE(n)->nd_loc.beg_pos.lineno))
+#define nd_set_first_lineno(n, v) (RNODE(n)->nd_loc.beg_pos.lineno = (v))
+#define nd_first_loc(n) (RNODE(n)->nd_loc.beg_pos)
 #define nd_set_first_loc(n, v) (nd_first_loc(n) = (v))
 
-#define nd_last_column(n) ((int)((n)->nd_loc.end_pos.column))
-#define nd_set_last_column(n, v) ((n)->nd_loc.end_pos.column = (v))
-#define nd_last_lineno(n) ((int)((n)->nd_loc.end_pos.lineno))
-#define nd_set_last_lineno(n, v) ((n)->nd_loc.end_pos.lineno = (v))
-#define nd_last_loc(n) ((n)->nd_loc.end_pos)
+#define nd_last_column(n) ((int)(RNODE(n)->nd_loc.end_pos.column))
+#define nd_set_last_column(n, v) (RNODE(n)->nd_loc.end_pos.column = (v))
+#define nd_last_lineno(n) ((int)(RNODE(n)->nd_loc.end_pos.lineno))
+#define nd_set_last_lineno(n, v) (RNODE(n)->nd_loc.end_pos.lineno = (v))
+#define nd_last_loc(n) (RNODE(n)->nd_loc.end_pos)
 #define nd_set_last_loc(n, v) (nd_last_loc(n) = (v))
-#define nd_node_id(n) ((n)->node_id)
-#define nd_set_node_id(n,id) ((n)->node_id = (id))
+#define nd_node_id(n) (RNODE(n)->node_id)
+#define nd_set_node_id(n,id) (RNODE(n)->node_id = (id))
 
 static inline bool
 nd_type_p(const NODE *n, enum node_type t)

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview2 → ruby-3.3.0-p0}/node_name.inc

@@ -88,8 +88,6 @@
 	return "NODE_LIST";
       case NODE_ZLIST:
 	return "NODE_ZLIST";
-      case NODE_VALUES:
-	return "NODE_VALUES";
       case NODE_HASH:
 	return "NODE_HASH";
       case NODE_RETURN:
@@ -208,3 +206,7 @@
 	return "NODE_FNDPTN";
       case NODE_ERROR:
 	return "NODE_ERROR";
+      case NODE_RIPPER:
+	return "NODE_RIPPER";
+      case NODE_RIPPER_VALUES:
+	return "NODE_RIPPER_VALUES";

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview2 → ruby-3.3.0-p0}/optunifs.inc

@@ -38,6 +38,6 @@
 
 /* Let .bss section automatically initialize this variable */
 /* cf. Section 6.7.8 of ISO/IEC 9899:1999 */
-static const int *const *const unified_insns_data[202];
+static const int *const *const unified_insns_data[204];
 
 ASSERT_VM_INSTRUCTION_SIZE(unified_insns_data);

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview2 → ruby-3.3.0-p0}/parse.h

@@ -1,4 +1,4 @@
-/* A Bison parser, made by Lrama 0.5.6.  */
+/* A Bison parser, made by Lrama 0.5.12.  */
 
 /* Bison interface for Yacc-like parsers in C
 
@@ -34,17 +34,17 @@
 /* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
    especially those whose name start with YY_ or yy_.  They are
    private implementation details that can be changed or removed.  */
-
 #ifndef YY_YY_PARSE_H_INCLUDED
 # define YY_YY_PARSE_H_INCLUDED
 /* Debug traces.  */
 #ifndef YYDEBUG
 # define YYDEBUG 0
 #endif
-#if YYDEBUG
+#if YYDEBUG && !defined(yydebug)
 extern int yydebug;
 #endif
 
+
 /* Token kinds.  */
 #ifndef YYTOKENTYPE
 # define YYTOKENTYPE
@@ -190,10 +190,19 @@ extern int yydebug;
 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 union YYSTYPE
 {
-#line 1507 "parse.y"
+#line 1963 "parse.y"
 
     VALUE val;
     NODE *node;
+    rb_node_fcall_t *node_fcall;
+    rb_node_args_t *node_args;
+    rb_node_args_aux_t *node_args_aux;
+    rb_node_opt_arg_t *node_opt_arg;
+    rb_node_kw_arg_t *node_kw_arg;
+    rb_node_block_pass_t *node_block_pass;
+    rb_node_masgn_t *node_masgn;
+    rb_node_def_temp_t *node_def_temp;
+    rb_node_exits_t *node_exits;
     ID id;
     int num;
     st_table *tbl;
@@ -201,7 +210,7 @@ union YYSTYPE
     struct rb_strterm_struct *strterm;
     struct lex_context ctxt;
 
-#line 205 "parse.h"
+#line 214 "parse.h"
 
 };
 typedef union YYSTYPE YYSTYPE;
@@ -229,4 +238,6 @@ struct YYLTYPE
 int yyparse (struct parser_params *p);
 
 
+
 #endif /* !YY_YY_PARSE_H_INCLUDED  */
+