kanayago 0.6.1 → 0.7.0

data/patch/3.4.8/kanayago.patch

@@ -0,0 +1,210 @@
+diff -ruN a/ext/kanayago/internal/ruby_parser.h b/ext/kanayago/internal/ruby_parser.h
+--- a/ext/kanayago/internal/ruby_parser.h	2025-12-17 19:50:40.592959132 +0900
++++ b/ext/kanayago/internal/ruby_parser.h	2025-12-17 19:50:40.592959132 +0900
+@@ -10,11 +10,35 @@
+ #include "rubyparser.h"
+ #include "vm.h"
+
+-struct lex_pointer_string {
++    struct lex_pointer_string {
+     VALUE str;
+     long ptr;
+ };
+
++
++// Add Ruby's Parser struct and enum for Kanayago
++enum lex_type {
++    lex_type_str,
++    lex_type_io,
++    lex_type_array,
++    lex_type_generic,
++};
++
++struct ruby_parser {
++    rb_parser_t *parser_params;
++    enum lex_type type;
++    union {
++        struct lex_pointer_string lex_str;
++        struct {
++            VALUE file;
++        } lex_io;
++        struct {
++            VALUE ary;
++        } lex_array;
++    } data;
++};
++// End for Kanayago
++
+ RUBY_SYMBOL_EXPORT_BEGIN
+ #ifdef UNIVERSAL_PARSER
+ const rb_parser_config_t *rb_ruby_parser_config(void);
+diff -ruN a/ext/kanayago/parse.c b/ext/kanayago/parse.c
+--- a/ext/kanayago/parse.c	2025-12-17 19:50:40.592959132 +0900
++++ b/ext/kanayago/parse.c	2025-12-17 19:50:40.592959132 +0900
+@@ -26941,6 +26941,16 @@
+     return p->value;
+ }
+
++#else /* !RIPPER */
++
++// Accessor function for error_buffer (for Kanayago)
++VALUE
++rb_ruby_parser_error_buffer_get(rb_parser_t *p)
++{
++    return p->error_buffer;
++}
++
++
+ #endif /* RIPPER */
+ /*
+  * Local variables:
+diff -ruN a/ext/kanayago/ruby_parser.c b/ext/kanayago/ruby_parser.c
+--- a/ext/kanayago/ruby_parser.c	2025-12-17 19:50:40.592959132 +0900
++++ b/ext/kanayago/ruby_parser.c	2025-12-17 19:50:40.592959132 +0900
+@@ -326,6 +326,51 @@
+
+ extern VALUE rb_eArgError;
+
++// Add for Kanayago - wrapper functions to avoid unexported symbols
++static void *
++xmalloc_mul_add(size_t x, size_t y, size_t z)
++{
++    size_t size;
++    if (y != 0 && x > (SIZE_MAX - z) / y) {
++        rb_raise(rb_eArgError, "allocation size overflow");
++    }
++    size = x * y + z;
++    return ruby_xmalloc(size);
++}
++
++static VALUE
++suppress_tracing(VALUE (*func)(VALUE), VALUE arg)
++{
++    return func(arg);
++}
++
++static ID
++make_temporary_id(size_t n)
++{
++    char buf[64];
++    snprintf(buf, sizeof(buf), "@kanayago_tmp_%zu", n);
++    return rb_intern(buf);
++}
++
++static int
++stderr_tty_p(void)
++{
++    return isatty(fileno(stderr));
++}
++
++static VALUE
++reg_compile(VALUE str, int options, const char *sourcefile, int sourceline)
++{
++    return rb_reg_new_str(str, options);
++}
++
++static VALUE
++reg_check_preprocess(VALUE val)
++{
++    return Qnil;
++}
++// End of Add for Kanayago
++
+ static const rb_parser_config_t rb_global_parser_config = {
+     .malloc = ruby_xmalloc,
+     .calloc = ruby_xcalloc,
+@@ -337,9 +382,9 @@
+     .zalloc = zalloc,
+     .rb_memmove = memmove2,
+     .nonempty_memcpy = nonempty_memcpy,
+-    .xmalloc_mul_add = rb_xmalloc_mul_add,
++    .xmalloc_mul_add = xmalloc_mul_add,
+
+-    .compile_callback = rb_suppress_tracing,
++    .compile_callback = suppress_tracing,
+     .reg_named_capture_assign = reg_named_capture_assign,
+
+     .attr_get = rb_attr_get,
+@@ -348,7 +393,7 @@
+     .ary_new_from_args = rb_ary_new_from_args,
+     .ary_unshift = rb_ary_unshift,
+
+-    .make_temporary_id = rb_make_temporary_id,
++    .make_temporary_id = make_temporary_id,
+     .is_local_id = is_local_id2,
+     .is_attrset_id = is_attrset_id2,
+     .is_global_name_punct = is_global_name_punct,
+@@ -380,7 +425,7 @@
+
+     .int2num = rb_int2num_inline,
+
+-    .stderr_tty_p = rb_stderr_tty_p,
++    .stderr_tty_p = stderr_tty_p,
+     .write_error_str = rb_write_error_str,
+     .io_write = rb_io_write,
+     .io_flush = rb_io_flush,
+@@ -430,8 +475,8 @@
+     .gc_guard = gc_guard,
+     .gc_mark = rb_gc_mark,
+
+-    .reg_compile = rb_reg_compile,
+-    .reg_check_preprocess = rb_reg_check_preprocess,
++    .reg_compile = reg_compile,
++    .reg_check_preprocess = reg_check_preprocess,
+     .memcicmp = rb_memcicmp,
+
+     .compile_warn = rb_compile_warn,
+@@ -461,26 +506,6 @@
+ };
+ #endif
+
+-enum lex_type {
+-    lex_type_str,
+-    lex_type_io,
+-    lex_type_array,
+-    lex_type_generic,
+-};
+-
+-struct ruby_parser {
+-    rb_parser_t *parser_params;
+-    enum lex_type type;
+-    union {
+-        struct lex_pointer_string lex_str;
+-        struct {
+-            VALUE file;
+-        } lex_io;
+-        struct {
+-            VALUE ary;
+-        } lex_array;
+-    } data;
+-};
+
+ static void
+ parser_mark(void *ptr)
+@@ -519,7 +544,7 @@
+     return rb_ruby_parser_memsize(parser->parser_params);
+ }
+
+-static const rb_data_type_t ruby_parser_data_type = {
++const rb_data_type_t ruby_parser_data_type = {
+     "parser",
+     {
+         parser_mark,
+@@ -891,7 +916,7 @@
+ VALUE
+ rb_str_new_parser_string(rb_parser_string_t *str)
+ {
+-    VALUE string = rb_enc_literal_str(str->ptr, str->len, str->enc);
++    VALUE string = rb_enc_str_new(str->ptr, str->len, str->enc);
+     rb_enc_str_coderange(string);
+     return string;
+ }
+@@ -1073,7 +1098,7 @@
+     rb_parser_string_t *string = node_reg->string;
+     VALUE str = rb_enc_str_new(string->ptr, string->len, string->enc);
+
+-    return rb_reg_compile(str, node_reg->options, NULL, 0);
++    return rb_reg_new_str(str, node_reg->options);
+ }
+
+ VALUE

data/patch/4.0.0/copy_target.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+RUBY_PARSER_COPY_TARGETS = %w[
+  ccan/check_type/check_type.h
+  ccan/container_of/container_of.h
+  ccan/list/list.h
+  ccan/str/str.h
+  constant.h
+  id.h
+  id_table.h
+  include/ruby/st.h
+  internal/array.h
+  internal/basic_operators.h
+  internal/bignum.h
+  internal/bits.h
+  internal/box.h
+  internal/compile.h
+  internal/compilers.h
+  internal/complex.h
+  internal/encoding.h
+  internal/error.h
+  internal/fixnum.h
+  internal/gc.h
+  internal/hash.h
+  internal/imemo.h
+  internal/io.h
+  internal/namespace.h
+  internal/numeric.h
+  internal/parse.h
+  internal/rational.h
+  internal/re.h
+  internal/ruby_parser.h
+  internal/sanitizers.h
+  internal/serial.h
+  internal/set_table.h
+  internal/static_assert.h
+  internal/string.h
+  internal/symbol.h
+  internal/thread.h
+  internal/variable.h
+  internal/warnings.h
+  internal/vm.h
+  internal.h
+  lex.c
+  method.h
+  node.c
+  node.h
+  node_name.inc
+  parse.c
+  parse.h
+  parser_bits.h
+  parser_node.h
+  parser_st.c
+  parser_st.h
+  parser_value.h
+  ruby_assert.h
+  ruby_atomic.h
+  ruby_parser.c
+  rubyparser.h
+  shape.h
+  st.c
+  symbol.h
+  thread_pthread.h
+  universal_parser.c
+  vm_core.h
+  vm_opts.h
+].freeze
+
+MAKE_DIRECTORIES = [
+  'ccan',
+  'ccan/check_type',
+  'ccan/container',
+  'ccan/container_of',
+  'ccan/list',
+  'ccan/str',
+  'internal',
+  'include',
+  'include/ruby'
+].freeze
+
+DELETE_DIRECTORIES = %w[
+  ccan
+  internal
+  include
+].freeze

data/patch/4.0.0/kanayago.patch

@@ -0,0 +1,282 @@
+diff --git a/ext/kanayago/internal/ruby_parser.h b/ext/kanayago/internal/ruby_parser.h
+index 8e306d1..d420a02 100644
+--- a/ext/kanayago/internal/ruby_parser.h
++++ b/ext/kanayago/internal/ruby_parser.h
+@@ -15,6 +15,29 @@ struct lex_pointer_string {
+     long ptr;
+ };
+
++// Add Ruby's Parser struct and enum for Kanayago
++enum lex_type {
++    lex_type_str,
++    lex_type_io,
++    lex_type_array,
++    lex_type_generic,
++};
++
++struct ruby_parser {
++    rb_parser_t *parser_params;
++    enum lex_type type;
++    union {
++        struct lex_pointer_string lex_str;
++        struct {
++            VALUE file;
++        } lex_io;
++        struct {
++            VALUE ary;
++        } lex_array;
++    } data;
++};
++// End for Kanayago
++
+ RUBY_SYMBOL_EXPORT_BEGIN
+ #ifdef UNIVERSAL_PARSER
+ const rb_parser_config_t *rb_ruby_parser_config(void);
+diff --git a/ext/kanayago/ruby_parser.c b/ext/kanayago/ruby_parser.c
+index 267f619..841db65 100644
+--- a/ext/kanayago/ruby_parser.c
++++ b/ext/kanayago/ruby_parser.c
+@@ -34,6 +34,100 @@
+
+ #define parser_encoding const void
+
++/*
++ * The following functions are ported from Ruby's error.c for Kanayago:
++ *   - err_vcatf
++ *   - syntax_error_with_path
++ *   - rb_syntax_error_append
++ *
++ * Copyright (C) 1993-2007 Yukihiro Matsumoto
++ *
++ * Ruby is copyrighted free software by Yukihiro Matsumoto <matz@netlab.jp>.
++ * You can redistribute it and/or modify it under either the terms of the
++ * 2-clause BSDL (see the file BSDL), or the conditions below:
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions
++ * are met:
++ * 1. Redistributions of source code must retain the above copyright
++ *    notice, this list of conditions and the following disclaimer.
++ * 2. Redistributions in binary form must reproduce the above copyright
++ *    notice, this list of conditions and the following disclaimer in the
++ *    documentation and/or other materials provided with the distribution.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
++ * SUCH DAMAGE.
++ */
++
++static VALUE
++err_vcatf(VALUE str, const char *pre, const char *file, int line,
++          const char *fmt, va_list args)
++{
++    if (file) {
++        rb_str_cat_cstr(str, file);
++        if (line) rb_str_catf(str, ":%d", line);
++        rb_str_cat_cstr(str, ": ");
++    }
++    if (pre) rb_str_cat_cstr(str, pre);
++    rb_str_vcatf(str, fmt, args);
++    return str;
++}
++
++static VALUE
++syntax_error_with_path(VALUE exc, VALUE file, VALUE *mesg, rb_encoding *enc)
++{
++    // Create new SyntaxError if exc is nil or Qfalse (for error_tolerant mode)
++    if (NIL_P(exc) || exc == Qfalse) {
++        exc = rb_class_new_instance(0, 0, rb_eSyntaxError);
++    }
++    *mesg = rb_attr_get(exc, rb_intern("mesg"));
++    // Check if mesg is nil or frozen (default "compile error" may be frozen)
++    if (NIL_P(*mesg) || OBJ_FROZEN(*mesg)) {
++        *mesg = rb_enc_str_new(0, 0, enc);
++        rb_ivar_set(exc, rb_intern("mesg"), *mesg);
++    }
++    return exc;
++}
++
++RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 6, 0)
++VALUE
++rb_syntax_error_append(VALUE exc, VALUE file, int line, int column,
++                       rb_encoding *enc, const char *fmt, va_list args)
++{
++    const char *fn = NIL_P(file) ? NULL : RSTRING_PTR(file);
++    if (!exc) {
++        // For error_tolerant mode, create SyntaxError even when writing to stderr
++        exc = rb_class_new_instance(0, 0, rb_eSyntaxError);
++        VALUE mesg = rb_attr_get(exc, rb_intern("mesg"));
++        // Check if mesg is nil or frozen (default "compile error" may be frozen)
++        if (NIL_P(mesg) || OBJ_FROZEN(mesg)) {
++            mesg = rb_enc_str_new(0, 0, enc);
++            rb_ivar_set(exc, rb_intern("mesg"), mesg);
++        }
++        err_vcatf(mesg, NULL, fn, line, fmt, args);
++        // Still write to stderr for compatibility
++        VALUE err_mesg = rb_str_dup(mesg);
++        rb_str_cat_cstr(err_mesg, "\n");
++        rb_write_error_str(err_mesg);
++    }
++    else {
++        VALUE mesg;
++        exc = syntax_error_with_path(exc, file, &mesg, enc);
++        err_vcatf(mesg, NULL, fn, line, fmt, args);
++    }
++
++    return exc;
++}
++
+ RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 6, 0)
+ static VALUE
+ syntax_error_append(VALUE exc, VALUE file, int line, int column,
+@@ -314,6 +408,44 @@ enc_mbc_to_codepoint(const char *p, const char *e, parser_encoding *enc)
+
+ extern VALUE rb_eArgError;
+
++//　Add for Kanayago
++static void *
++xmalloc_mul_add(size_t x, size_t y, size_t z)
++{
++    return rb_xmalloc_mul_add(x, y, z);
++}
++
++static VALUE
++suppress_tracing(VALUE (*func)(VALUE), VALUE arg)
++{
++    return func(arg);
++}
++
++static ID
++make_temporary_id(size_t n)
++{
++    return rb_make_temporary_id(n);
++}
++
++static int
++stderr_tty_p(void)
++{
++    return rb_stderr_tty_p();
++}
++
++static VALUE
++reg_compile(VALUE str, int options, const char *sourcefile, int sourceline)
++{
++     return rb_reg_compile(str, options, sourcefile, sourceline);
++}
++
++static VALUE
++reg_check_preprocess(VALUE val)
++{
++    return rb_reg_check_preprocess(val);
++}
++// End of Add for Kanayago
++
+ static const rb_parser_config_t rb_global_parser_config = {
+     .malloc = ruby_xmalloc,
+     .calloc = ruby_xcalloc,
+@@ -325,9 +457,9 @@ static const rb_parser_config_t rb_global_parser_config = {
+     .zalloc = zalloc,
+     .rb_memmove = memmove2,
+     .nonempty_memcpy = nonempty_memcpy,
+-    .xmalloc_mul_add = rb_xmalloc_mul_add,
++    .xmalloc_mul_add = xmalloc_mul_add, // use xmalloc_mul_add for Kanayago
+
+-    .compile_callback = rb_suppress_tracing,
++    .compile_callback = suppress_tracing, // use suppress_tracing for Kanayago
+     .reg_named_capture_assign = reg_named_capture_assign,
+
+     .attr_get = rb_attr_get,
+@@ -335,7 +467,7 @@ static const rb_parser_config_t rb_global_parser_config = {
+     .ary_new_from_args = rb_ary_new_from_args,
+     .ary_unshift = rb_ary_unshift,
+
+-    .make_temporary_id = rb_make_temporary_id,
++    .make_temporary_id = make_temporary_id, // use make_temporary_id for Kanayago
+     .is_local_id = is_local_id2,
+     .is_attrset_id = is_attrset_id2,
+     .is_global_name_punct = is_global_name_punct,
+@@ -365,7 +497,7 @@ static const rb_parser_config_t rb_global_parser_config = {
+
+     .int2num = rb_int2num_inline,
+
+-    .stderr_tty_p = rb_stderr_tty_p,
++    .stderr_tty_p = stderr_tty_p, //use stderr_tty_p for Kanayago
+     .write_error_str = rb_write_error_str,
+     .io_write = rb_io_write,
+     .io_flush = rb_io_flush,
+@@ -412,8 +544,8 @@ static const rb_parser_config_t rb_global_parser_config = {
+     .gc_guard = gc_guard,
+     .gc_mark = rb_gc_mark,
+
+-    .reg_compile = rb_reg_compile,
+-    .reg_check_preprocess = rb_reg_check_preprocess,
++    .reg_compile = reg_compile, // use reg_compile for Kanayago
++    .reg_check_preprocess = reg_check_preprocess, // use reg_check_preprocess for Kanayago
+     .memcicmp = rb_memcicmp,
+
+     .compile_warn = rb_compile_warn,
+@@ -443,27 +575,6 @@ static const rb_parser_config_t rb_global_parser_config = {
+ };
+ #endif
+
+-enum lex_type {
+-    lex_type_str,
+-    lex_type_io,
+-    lex_type_array,
+-    lex_type_generic,
+-};
+-
+-struct ruby_parser {
+-    rb_parser_t *parser_params;
+-    enum lex_type type;
+-    union {
+-        struct lex_pointer_string lex_str;
+-        struct {
+-            VALUE file;
+-        } lex_io;
+-        struct {
+-            VALUE ary;
+-        } lex_array;
+-    } data;
+-};
+-
+ static void
+ parser_mark(void *ptr)
+ {
+@@ -501,7 +612,8 @@ parser_memsize(const void *ptr)
+     return rb_ruby_parser_memsize(parser->parser_params);
+ }
+
+-static const rb_data_type_t ruby_parser_data_type = {
++// Not static const for Kanayago
++const rb_data_type_t ruby_parser_data_type = {
+     "parser",
+     {
+         parser_mark,
+diff --git a/ext/kanayago/parse.c b/ext/kanayago/parse.c
+--- a/ext/kanayago/parse.c
++++ b/ext/kanayago/parse.c
+@@ -27350,6 +27350,15 @@ ripper_value(struct parser_params *p)
+     return p->value;
+ }
+
++#else /* !RIPPER */
++
++// Accessor function for error_buffer (for Kanayago)
++VALUE
++rb_ruby_parser_error_buffer_get(rb_parser_t *p)
++{
++    return p->error_buffer;
++}
++
+ #endif /* RIPPER */
+ /*
+  * Local variables:

data/patch/4.0.0/macos.patch

@@ -0,0 +1,46 @@
+--- a/ext/kanayago/ruby_parser.c
++++ b/ext/kanayago/ruby_parser.c
+@@ -433,16 +433,21 @@
+     return rb_stderr_tty_p();
+ }
+ 
++// Kanayago macOS: Use rb_reg_new_str instead of rb_reg_compile (not exported in Ruby head)
+ static VALUE
+ reg_compile(VALUE str, int options, const char *sourcefile, int sourceline)
+ {
+-     return rb_reg_compile(str, options, sourcefile, sourceline);
++    (void)sourcefile;
++    (void)sourceline;
++    return rb_reg_new_str(str, options);
+ }
+ 
++// Kanayago macOS: Return Qnil instead of calling rb_reg_check_preprocess (not exported in Ruby head)
+ static VALUE
+ reg_check_preprocess(VALUE val)
+ {
+-    return rb_reg_check_preprocess(val);
++    (void)val;
++    return Qnil;
+ }
+ // End of Add for Kanayago
+ 
+@@ -985,7 +990,8 @@
+ VALUE
+ rb_str_new_parser_string(rb_parser_string_t *str)
+ {
+-    VALUE string = rb_enc_literal_str(str->ptr, str->len, str->enc);
++    // Kanayago macOS: Use rb_enc_str_new instead of rb_enc_literal_str (not exported in Ruby head)
++    VALUE string = rb_enc_str_new(str->ptr, str->len, str->enc);
+     rb_enc_str_coderange(string);
+     return string;
+ }
+@@ -1167,7 +1173,8 @@
+     rb_parser_string_t *string = node_reg->string;
+     VALUE str = rb_enc_str_new(string->ptr, string->len, string->enc);
+ 
+-    return rb_reg_compile(str, node_reg->options, NULL, 0);
++    // Kanayago macOS: Use rb_reg_new_str instead of rb_reg_compile
++    return rb_reg_new_str(str, node_reg->options);
+ }
+ 
+ VALUE

data/patch/head/kanayago.patch

@@ -264,7 +264,7 @@ index 267f619..841db65 100644
 diff --git a/ext/kanayago/parse.c b/ext/kanayago/parse.c
 --- a/ext/kanayago/parse.c
 +++ b/ext/kanayago/parse.c
-@@ -27391,6 +27391,15 @@ ripper_value(struct parser_params *p)
+@@ -27350,6 +27350,15 @@ ripper_value(struct parser_params *p)
      return p->value;
  }
 

data/patch/head/macos.patch

@@ -0,0 +1,65 @@
+--- a/ext/kanayago/ruby_parser.c	
++++ b/ext/kanayago/ruby_parser.c
+@@ -6,7 +6,6 @@
+ 
+ #include "node.h"
+ #include "rubyparser.h"
+-#include "internal/error.h"
+ 
+ #ifdef UNIVERSAL_PARSER
+ 
+@@ -433,16 +432,21 @@ stderr_tty_p(void)
+     return rb_stderr_tty_p();
+ }
+ 
++// Kanayago macOS: Use rb_reg_new_str instead of rb_reg_compile (not exported in Ruby head)
+ static VALUE
+ reg_compile(VALUE str, int options, const char *sourcefile, int sourceline)
+ {
+-     return rb_reg_compile(str, options, sourcefile, sourceline);
++    (void)sourcefile;
++    (void)sourceline;
++    return rb_reg_new_str(str, options);
+ }
+ 
++// Kanayago macOS: Return Qnil instead of calling rb_reg_check_preprocess (not exported in Ruby head)
+ static VALUE
+ reg_check_preprocess(VALUE val)
+ {
+-    return rb_reg_check_preprocess(val);
++    (void)val;
++    return Qnil;
+ }
+ // End of Add for Kanayago
+ 
+@@ -985,7 +989,8 @@ rb_parser_build_script_lines_from(rb_par
+ VALUE
+ rb_str_new_parser_string(rb_parser_string_t *str)
+ {
+-    VALUE string = rb_enc_literal_str(str->ptr, str->len, str->enc);
++    // Kanayago macOS: Use rb_enc_str_new instead of rb_enc_literal_str (not exported in Ruby head)
++    VALUE string = rb_enc_str_new(str->ptr, str->len, str->enc);
+     rb_enc_str_coderange(string);
+     return string;
+ }
+@@ -1027,8 +1032,9 @@ negative_numeric(VALUE val)
+         break;
+       unknown:
+       default:
++        // Kanayago macOS: Use rb_obj_classname instead of rb_builtin_class_name
+         rb_bug("unknown literal type (%s) passed to negative_numeric",
+-               rb_builtin_class_name(val));
++               rb_obj_classname(val));
+         break;
+     }
+     return val;
+@@ -1167,7 +1173,8 @@ rb_node_regx_string_val(const NODE *node
+     rb_parser_string_t *string = node_reg->string;
+     VALUE str = rb_enc_str_new(string->ptr, string->len, string->enc);
+ 
+-    return rb_reg_compile(str, node_reg->options, NULL, 0);
++    // Kanayago macOS: Use rb_reg_new_str instead of rb_reg_compile
++    return rb_reg_new_str(str, node_reg->options);
+ }
+ 
+ VALUE