datadog-ruby_core_source 3.3.6 → 3.4.1

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview2 → ruby-3.4.0-p0}/prism/defines.h

@@ -137,14 +137,15 @@
 #endif
 
 /**
- * isinf on Windows is defined as accepting a float, but on POSIX systems it
- * accepts a float, a double, or a long double. We want to mirror this behavior
- * on windows.
+ * isinf on POSIX systems it accepts a float, a double, or a long double.
+ * But mingw didn't provide an isinf macro, only an isinf function that only
+ * accepts floats, so we need to use _finite instead.
  */
-#ifdef _WIN32
-#   include <float.h>
-#   undef isinf
-#   define isinf(x) (sizeof(x) == sizeof(float) ? !_finitef(x) : !_finite(x))
+#ifdef __MINGW64__
+    #include <float.h>
+    #define PRISM_ISINF(x) (!_finite(x))
+#else
+    #define PRISM_ISINF(x) isinf(x)
 #endif
 
 /**

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview2 → ruby-3.4.0-p0}/prism/diagnostic.h

@@ -170,6 +170,7 @@ typedef enum {
     PM_ERR_INSTANCE_VARIABLE_BARE,
     PM_ERR_INVALID_BLOCK_EXIT,
     PM_ERR_INVALID_CHARACTER,
+    PM_ERR_INVALID_COMMA,
     PM_ERR_INVALID_ENCODING_MAGIC_COMMENT,
     PM_ERR_INVALID_ESCAPE_CHARACTER,
     PM_ERR_INVALID_FLOAT_EXPONENT,

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview2 → ruby-3.4.0-p0}/prism/extension.h

@@ -1,7 +1,7 @@
 #ifndef PRISM_EXT_NODE_H
 #define PRISM_EXT_NODE_H
 
-#define EXPECTED_PRISM_VERSION "1.0.0"
+#define EXPECTED_PRISM_VERSION "1.2.0"
 
 #include <ruby.h>
 #include <ruby/encoding.h>

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview1 → ruby-3.4.0-p0}/prism/prism.h

@@ -219,17 +219,6 @@ PRISM_EXPORTED_FUNCTION const char * pm_token_type_name(pm_token_type_t token_ty
  */
 const char * pm_token_type_human(pm_token_type_t token_type);
 
-/**
- * Format the errors on the parser into the given buffer.
- *
- * @param parser The parser to format the errors for.
- * @param error_list The list of errors to format.
- * @param buffer The buffer to format the errors into.
- * @param colorize Whether or not to colorize the errors with ANSI escape sequences.
- * @param inline_messages Whether or not to inline the messages with the source.
- */
-PRISM_EXPORTED_FUNCTION void pm_parser_errors_format(const pm_parser_t *parser, const pm_list_t *error_list, pm_buffer_t *buffer, bool colorize, bool inline_messages);
-
 // We optionally support dumping to JSON. For systems that don't want or need
 // this functionality, it can be turned off with the PRISM_EXCLUDE_JSON define.
 #ifndef PRISM_EXCLUDE_JSON
@@ -245,6 +234,53 @@ PRISM_EXPORTED_FUNCTION void pm_dump_json(pm_buffer_t *buffer, const pm_parser_t
 
 #endif
 
+/**
+ * Represents the results of a slice query.
+ */
+typedef enum {
+    /** Returned if the encoding given to a slice query was invalid. */
+    PM_STRING_QUERY_ERROR = -1,
+
+    /** Returned if the result of the slice query is false. */
+    PM_STRING_QUERY_FALSE,
+
+    /** Returned if the result of the slice query is true. */
+    PM_STRING_QUERY_TRUE
+} pm_string_query_t;
+
+/**
+ * Check that the slice is a valid local variable name.
+ *
+ * @param source The source to check.
+ * @param length The length of the source.
+ * @param encoding_name The name of the encoding of the source.
+ * @return PM_STRING_QUERY_TRUE if the query is true, PM_STRING_QUERY_FALSE if
+ *   the query is false, and PM_STRING_QUERY_ERROR if the encoding was invalid.
+ */
+PRISM_EXPORTED_FUNCTION pm_string_query_t pm_string_query_local(const uint8_t *source, size_t length, const char *encoding_name);
+
+/**
+ * Check that the slice is a valid constant name.
+ *
+ * @param source The source to check.
+ * @param length The length of the source.
+ * @param encoding_name The name of the encoding of the source.
+ * @return PM_STRING_QUERY_TRUE if the query is true, PM_STRING_QUERY_FALSE if
+ *   the query is false, and PM_STRING_QUERY_ERROR if the encoding was invalid.
+ */
+PRISM_EXPORTED_FUNCTION pm_string_query_t pm_string_query_constant(const uint8_t *source, size_t length, const char *encoding_name);
+
+/**
+ * Check that the slice is a valid method name.
+ *
+ * @param source The source to check.
+ * @param length The length of the source.
+ * @param encoding_name The name of the encoding of the source.
+ * @return PM_STRING_QUERY_TRUE if the query is true, PM_STRING_QUERY_FALSE if
+ *   the query is false, and PM_STRING_QUERY_ERROR if the encoding was invalid.
+ */
+PRISM_EXPORTED_FUNCTION pm_string_query_t pm_string_query_method_name(const uint8_t *source, size_t length, const char *encoding_name);
+
 /**
  * @mainpage
  *

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview2 → ruby-3.4.0-p0}/prism/version.h

@@ -14,7 +14,7 @@
 /**
  * The minor version of the Prism library as an int.
  */
-#define PRISM_VERSION_MINOR 0
+#define PRISM_VERSION_MINOR 2
 
 /**
  * The patch version of the Prism library as an int.
@@ -24,6 +24,6 @@
 /**
  * The version of the Prism library as a constant string.
  */
-#define PRISM_VERSION "1.0.0"
+#define PRISM_VERSION "1.2.0"
 
 #endif

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview2 → ruby-3.4.0-p0}/prism_compile.h

@@ -90,10 +90,10 @@ VALUE pm_parse_string(pm_parse_result_t *result, VALUE source, VALUE filepath, V
 VALUE pm_parse_stdin(pm_parse_result_t *result);
 void pm_parse_result_free(pm_parse_result_t *result);
 
-rb_iseq_t *pm_iseq_new(pm_scope_node_t *node, VALUE name, VALUE path, VALUE realpath, const rb_iseq_t *parent, enum rb_iseq_type);
-rb_iseq_t *pm_iseq_new_top(pm_scope_node_t *node, VALUE name, VALUE path, VALUE realpath, const rb_iseq_t *parent);
-rb_iseq_t *pm_iseq_new_main(pm_scope_node_t *node, VALUE path, VALUE realpath, const rb_iseq_t *parent, int opt);
-rb_iseq_t *pm_iseq_new_eval(pm_scope_node_t *node, VALUE name, VALUE path, VALUE realpath, int first_lineno, const rb_iseq_t *parent, int isolated_depth);
-rb_iseq_t *pm_iseq_new_with_opt(pm_scope_node_t *node, VALUE name, VALUE path, VALUE realpath, int first_lineno, const rb_iseq_t *parent, int isolated_depth, enum rb_iseq_type, const rb_compile_option_t*);
+rb_iseq_t *pm_iseq_new(pm_scope_node_t *node, VALUE name, VALUE path, VALUE realpath, const rb_iseq_t *parent, enum rb_iseq_type, int *error_state);
+rb_iseq_t *pm_iseq_new_top(pm_scope_node_t *node, VALUE name, VALUE path, VALUE realpath, const rb_iseq_t *parent, int *error_state);
+rb_iseq_t *pm_iseq_new_main(pm_scope_node_t *node, VALUE path, VALUE realpath, const rb_iseq_t *parent, int opt, int *error_state);
+rb_iseq_t *pm_iseq_new_eval(pm_scope_node_t *node, VALUE name, VALUE path, VALUE realpath, int first_lineno, const rb_iseq_t *parent, int isolated_depth, int *error_state);
+rb_iseq_t *pm_iseq_new_with_opt(pm_scope_node_t *node, VALUE name, VALUE path, VALUE realpath, int first_lineno, const rb_iseq_t *parent, int isolated_depth, enum rb_iseq_type, const rb_compile_option_t *option, int *error_state);
 
 VALUE pm_iseq_compile_node(rb_iseq_t *iseq, pm_scope_node_t *node);

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview2 → ruby-3.4.0-p0}/ractor_core.h

@@ -180,6 +180,7 @@ struct rb_ractor_struct {
 
     st_table *local_storage;
     struct rb_id_table *idkey_local_storage;
+    VALUE local_storage_store_lock;
 
     VALUE r_stdin;
     VALUE r_stdout;
@@ -222,6 +223,8 @@ void rb_ractor_terminate_interrupt_main_thread(rb_ractor_t *r);
 void rb_ractor_terminate_all(void);
 bool rb_ractor_main_p_(void);
 void rb_ractor_atfork(rb_vm_t *vm, rb_thread_t *th);
+VALUE rb_ractor_require(VALUE feature);
+VALUE rb_ractor_autoload_load(VALUE space, ID id);
 
 VALUE rb_ractor_ensure_shareable(VALUE obj, VALUE name);
 
@@ -304,18 +307,15 @@ rb_ractor_thread_switch(rb_ractor_t *cr, rb_thread_t *th)
 }
 
 #define rb_ractor_set_current_ec(cr, ec) rb_ractor_set_current_ec_(cr, ec, __FILE__, __LINE__)
+#ifdef RB_THREAD_LOCAL_SPECIFIER
+void rb_current_ec_set(rb_execution_context_t *ec);
+#endif
 
 static inline void
 rb_ractor_set_current_ec_(rb_ractor_t *cr, rb_execution_context_t *ec, const char *file, int line)
 {
 #ifdef RB_THREAD_LOCAL_SPECIFIER
-
-# ifdef __APPLE__
     rb_current_ec_set(ec);
-# else
-    ruby_current_ec = ec;
-# endif
-
 #else
     native_tls_set(ruby_current_ec_key, ec);
 #endif

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview2 → ruby-3.4.0-p0}/rubyparser.h

@@ -1171,6 +1171,8 @@ typedef struct parser_params rb_parser_t;
 typedef struct rb_imemo_tmpbuf_struct rb_imemo_tmpbuf_t;
 #endif
 
+typedef NODE *(*rb_parser_assignable_func)(struct parser_params *p, ID id, NODE *val, const rb_code_location_t *loc);
+
 #ifdef UNIVERSAL_PARSER
 typedef struct rb_parser_config_struct {
     /* Memory */
@@ -1188,13 +1190,12 @@ typedef struct rb_parser_config_struct {
 
     // VALUE rb_suppress_tracing(VALUE (*func)(VALUE), VALUE arg);
     VALUE (*compile_callback)(VALUE (*func)(VALUE), VALUE arg);
-    NODE *(*reg_named_capture_assign)(struct parser_params* p, VALUE regexp, const rb_code_location_t *loc);
+    NODE *(*reg_named_capture_assign)(struct parser_params* p, VALUE regexp, const rb_code_location_t *loc, rb_parser_assignable_func assignable);
 
     /* Variable */
     VALUE (*attr_get)(VALUE obj, ID id);
 
     /* Array */
-    VALUE (*ary_new)(void);
     VALUE (*ary_push)(VALUE ary, VALUE elem);
     VALUE (*ary_new_from_args)(long n, ...);
     VALUE (*ary_unshift)(VALUE ary, VALUE item);

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview2 → ruby-3.4.0-p0}/thread_pthread.h

@@ -132,7 +132,6 @@ struct rb_thread_sched {
 
 #ifdef RB_THREAD_LOCAL_SPECIFIER
   NOINLINE(void rb_current_ec_set(struct rb_execution_context_struct *));
-  NOINLINE(struct rb_execution_context_struct *rb_current_ec_noinline(void));
 
   # ifdef __APPLE__
     // on Darwin, TLS can not be accessed across .so

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview2 → ruby-3.4.0-p0}/vm_core.h

@@ -70,7 +70,30 @@
 #define RUBY_ASSERT_MUTEX_OWNED(mutex) VM_ASSERT(rb_mutex_owned_p(mutex))
 
 #if defined(RUBY_ASSERT_CRITICAL_SECTION)
-// TODO add documentation
+/*
+# Critical Section Assertions
+
+These assertions are used to ensure that context switching does not occur between two points in the code. In theory,
+such code should already be protected by a mutex, but these assertions are used to ensure that the mutex is held.
+
+The specific case where it can be useful is where a mutex is held further up the call stack, and the code in question
+may not directly hold the mutex. In this case, the critical section assertions can be used to ensure that the mutex is
+held by someone else.
+
+These assertions are only enabled when RUBY_ASSERT_CRITICAL_SECTION is defined, which is only defined if VM_CHECK_MODE
+is set.
+
+## Example Usage
+
+```c
+RUBY_ASSERT_CRITICAL_SECTION_ENTER();
+// ... some code which does not invoke rb_vm_check_ints() ...
+RUBY_ASSERT_CRITICAL_SECTION_LEAVE();
+```
+
+If `rb_vm_check_ints()` is called between the `RUBY_ASSERT_CRITICAL_SECTION_ENTER()` and
+`RUBY_ASSERT_CRITICAL_SECTION_LEAVE()`, a failed assertion will result.
+*/
 extern int ruby_assert_critical_section_entered;
 #define RUBY_ASSERT_CRITICAL_SECTION_ENTER() do{ruby_assert_critical_section_entered += 1;}while(false)
 #define RUBY_ASSERT_CRITICAL_SECTION_LEAVE() do{VM_ASSERT(ruby_assert_critical_section_entered > 0);ruby_assert_critical_section_entered -= 1;}while(false)
@@ -230,6 +253,8 @@ union ic_serial_entry {
     VALUE data[2];
 };
 
+#define IMEMO_CONST_CACHE_SHAREABLE IMEMO_FL_USER0
+
 // imemo_constcache
 struct iseq_inline_constant_cache_entry {
     VALUE flags;
@@ -370,6 +395,8 @@ enum rb_builtin_attr {
     BUILTIN_ATTR_SINGLE_NOARG_LEAF = 0x02,
     // This attribute signals JIT to duplicate the iseq for each block iseq so that its `yield` will be monomorphic.
     BUILTIN_ATTR_INLINE_BLOCK = 0x04,
+    // The iseq acts like a C method in backtraces.
+    BUILTIN_ATTR_C_TRACE = 0x08,
 };
 
 typedef VALUE (*rb_jit_func_t)(struct rb_execution_context_struct *, struct rb_control_frame_struct *);
@@ -579,6 +606,12 @@ rb_iseq_check(const rb_iseq_t *iseq)
     return iseq;
 }
 
+static inline bool
+rb_iseq_attr_p(const rb_iseq_t *iseq, enum rb_builtin_attr attr)
+{
+    return (ISEQ_BODY(iseq)->builtin_attrs & attr) == attr;
+}
+
 static inline const rb_iseq_t *
 def_iseq_ptr(rb_method_definition_t *def)
 {
@@ -766,13 +799,13 @@ typedef struct rb_vm_struct {
     struct rb_id_table *negative_cme_table;
     st_table *overloaded_cme_table; // cme -> overloaded_cme
     st_table *unused_block_warning_table;
-    bool unused_block_warning_strict;
 
     // This id table contains a mapping from ID to ICs. It does this with ID
     // keys and nested st_tables as values. The nested tables have ICs as keys
     // and Qtrue as values. It is used when inline constant caches need to be
     // invalidated or ISEQs are being freed.
     struct rb_id_table *constant_cache;
+    ID inserting_constant_cache_id;
 
 #ifndef VM_GLOBAL_CC_CACHE_TABLE_SIZE
 #define VM_GLOBAL_CC_CACHE_TABLE_SIZE 1023
@@ -1124,6 +1157,7 @@ typedef struct rb_thread_struct {
     struct rb_unblock_callback unblock;
     VALUE locking_mutex;
     struct rb_mutex_struct *keeping_mutexes;
+    struct ccan_list_head interrupt_exec_tasks;
 
     struct rb_waiting_list *join_list;
 
@@ -1280,6 +1314,7 @@ enum vm_opt_newarray_send_type {
     VM_OPT_NEWARRAY_SEND_HASH = 3,
     VM_OPT_NEWARRAY_SEND_PACK = 4,
     VM_OPT_NEWARRAY_SEND_PACK_BUFFER = 5,
+    VM_OPT_NEWARRAY_SEND_INCLUDE_P = 6,
 };
 
 enum vm_special_object_type {
@@ -1487,22 +1522,13 @@ VM_ENV_ESCAPED_P(const VALUE *ep)
     return VM_ENV_FLAGS(ep, VM_ENV_FLAG_ESCAPED) ? 1 : 0;
 }
 
-#if VM_CHECK_MODE > 0
-static inline int
-vm_assert_env(VALUE obj)
-{
-    VM_ASSERT(imemo_type_p(obj, imemo_env));
-    return 1;
-}
-#endif
-
 RBIMPL_ATTR_NONNULL((1))
 static inline VALUE
 VM_ENV_ENVVAL(const VALUE *ep)
 {
     VALUE envval = ep[VM_ENV_DATA_INDEX_ENV];
     VM_ASSERT(VM_ENV_ESCAPED_P(ep));
-    VM_ASSERT(vm_assert_env(envval));
+    VM_ASSERT(envval == Qundef || imemo_type_p(envval, imemo_env));
     return envval;
 }
 
@@ -1945,6 +1971,8 @@ rb_ec_vm_ptr(const rb_execution_context_t *ec)
     }
 }
 
+NOINLINE(struct rb_execution_context_struct *rb_current_ec_noinline(void));
+
 static inline rb_execution_context_t *
 rb_current_execution_context(bool expect_ec)
 {

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview1 → ruby-3.5.0-preview1}/id.h

@@ -110,6 +110,7 @@ enum ruby_method_ids {
     idANDDOT = RUBY_TOKEN(ANDDOT),
     tPRESERVED_ID_BEGIN = 150,
     idNilP,
+    idIncludeP,
     idNULL,
     idEmptyP,
     idEqlP,
@@ -139,6 +140,7 @@ enum ruby_method_ids {
     tInspect,
     tIntern,
     tObject_id,
+    t__id__,
     tConst_added,
     tConst_missing,
     tMethodMissing,
@@ -190,6 +192,8 @@ enum ruby_method_ids {
     tName,
     tNil,
     tPath,
+    tPack,
+    tBuffer,
     tUScore,
     tNUMPARAM_1,
     tNUMPARAM_2,
@@ -219,6 +223,7 @@ enum ruby_method_ids {
 
     /* CONST tokens {{{ */
     tTOKEN_CONST_BEGIN = tTOKEN_GLOBAL_END-1,
+    tRuby,
     tTOKEN_CONST_END,
     /* CONST tokens }}} */
 
@@ -243,6 +248,7 @@ enum ruby_method_ids {
     DEFINE_LOCALID_FROM_TOKEN(Inspect),
     DEFINE_LOCALID_FROM_TOKEN(Intern),
     DEFINE_LOCALID_FROM_TOKEN(Object_id),
+    DEFINE_LOCALID_FROM_TOKEN(__id__),
     DEFINE_LOCALID_FROM_TOKEN(Const_added),
     DEFINE_LOCALID_FROM_TOKEN(Const_missing),
     DEFINE_LOCALID_FROM_TOKEN(MethodMissing),
@@ -294,6 +300,8 @@ enum ruby_method_ids {
     DEFINE_LOCALID_FROM_TOKEN(Name),
     DEFINE_LOCALID_FROM_TOKEN(Nil),
     DEFINE_LOCALID_FROM_TOKEN(Path),
+    DEFINE_LOCALID_FROM_TOKEN(Pack),
+    DEFINE_LOCALID_FROM_TOKEN(Buffer),
     DEFINE_LOCALID_FROM_TOKEN(UScore),
     DEFINE_LOCALID_FROM_TOKEN(NUMPARAM_1),
     DEFINE_LOCALID_FROM_TOKEN(NUMPARAM_2),
@@ -323,6 +331,7 @@ enum ruby_method_ids {
 
     /* CONST IDs {{{ */
 #define DEFINE_CONSTID_FROM_TOKEN(n) id##n = TOKEN2CONSTID(t##n)
+    DEFINE_CONSTID_FROM_TOKEN(Ruby),
 #undef DEFINE_CONSTID_FROM_TOKEN
     /* CONST IDs }}} */
 

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview1 → ruby-3.5.0-preview1}/internal/array.h

@@ -37,6 +37,7 @@ size_t rb_ary_size_as_embedded(VALUE ary);
 void rb_ary_make_embedded(VALUE ary);
 bool rb_ary_embeddable_p(VALUE ary);
 VALUE rb_ary_diff(VALUE ary1, VALUE ary2);
+RUBY_EXTERN VALUE rb_cArray_empty_frozen;
 
 static inline VALUE rb_ary_entry_internal(VALUE ary, long offset);
 static inline bool ARY_PTR_USING_P(VALUE ary);

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview1 → ruby-3.5.0-preview1}/internal/basic_operators.h

@@ -37,6 +37,8 @@ enum ruby_basic_operators {
     BOP_OR,
     BOP_CMP,
     BOP_DEFAULT,
+    BOP_PACK,
+    BOP_INCLUDE_P,
 
     BOP_LAST_
 };

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview1 → ruby-3.5.0-preview1}/internal/bits.h

@@ -90,6 +90,7 @@
 
 #define UNSIGNED_INTEGER_MAX(T) ((T)~(T)0)
 
+#ifndef MUL_OVERFLOW_SIGNED_INTEGER_P
 #if __has_builtin(__builtin_mul_overflow_p)
 # define MUL_OVERFLOW_P(a, b) \
     __builtin_mul_overflow_p((a), (b), (__typeof__(a * b))0)
@@ -131,6 +132,87 @@
 # define MUL_OVERFLOW_LONG_P(a, b)      MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, LONG_MIN, LONG_MAX)
 # define MUL_OVERFLOW_INT_P(a, b)       MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, INT_MIN, INT_MAX)
 #endif
+#endif
+
+#ifndef ADD_OVERFLOW_SIGNED_INTEGER_P
+#if __has_builtin(__builtin_add_overflow_p)
+# define ADD_OVERFLOW_P(a, b) \
+    __builtin_add_overflow_p((a), (b), (__typeof__(a * b))0)
+#elif __has_builtin(__builtin_add_overflow)
+# define ADD_OVERFLOW_P(a, b) \
+    __extension__ ({ __typeof__(a) c; __builtin_add_overflow((a), (b), &c); })
+#endif
+
+#define ADD_OVERFLOW_SIGNED_INTEGER_P(a, b, min, max) ( \
+    (a) > 0 ? (b) > (max) - (a) : (b) < (min) - (a))
+
+#if __has_builtin(__builtin_add_overflow_p)
+/* __builtin_add_overflow_p can take bitfield */
+/* and GCC permits bitfields for integers other than int */
+# define ADD_OVERFLOW_FIXNUM_P(a, b) \
+    __extension__ ({ \
+        struct { long fixnum : sizeof(long) * CHAR_BIT - 1; } c = { 0 }; \
+        __builtin_add_overflow_p((a), (b), c.fixnum); \
+    })
+#else
+# define ADD_OVERFLOW_FIXNUM_P(a, b) \
+    ADD_OVERFLOW_SIGNED_INTEGER_P(a, b, FIXNUM_MIN, FIXNUM_MAX)
+#endif
+
+#if defined(ADD_OVERFLOW_P) && defined(USE___BUILTIN_ADD_OVERFLOW_LONG_LONG)
+# define ADD_OVERFLOW_LONG_LONG_P(a, b) ADD_OVERFLOW_P(a, b)
+#else
+# define ADD_OVERFLOW_LONG_LONG_P(a, b) ADD_OVERFLOW_SIGNED_INTEGER_P(a, b, LLONG_MIN, LLONG_MAX)
+#endif
+
+#ifdef ADD_OVERFLOW_P
+# define ADD_OVERFLOW_LONG_P(a, b)      ADD_OVERFLOW_P(a, b)
+# define ADD_OVERFLOW_INT_P(a, b)       ADD_OVERFLOW_P(a, b)
+#else
+# define ADD_OVERFLOW_LONG_P(a, b)      ADD_OVERFLOW_SIGNED_INTEGER_P(a, b, LONG_MIN, LONG_MAX)
+# define ADD_OVERFLOW_INT_P(a, b)       ADD_OVERFLOW_SIGNED_INTEGER_P(a, b, INT_MIN, INT_MAX)
+#endif
+#endif
+
+#ifndef SUB_OVERFLOW_SIGNED_INTEGER_P
+#if __has_builtin(__builtin_sub_overflow_p)
+# define SUB_OVERFLOW_P(a, b) \
+    __builtin_sub_overflow_p((a), (b), (__typeof__(a * b))0)
+#elif __has_builtin(__builtin_sub_overflow)
+# define SUB_OVERFLOW_P(a, b) \
+    __extension__ ({ __typeof__(a) c; __builtin_sub_overflow((a), (b), &c); })
+#endif
+
+#define SUB_OVERFLOW_SIGNED_INTEGER_P(a, b, min, max) ( \
+        (b) > 0 ? (a) < (min) + (b) : (a) > (max) + (b))
+
+#if __has_builtin(__builtin_sub_overflow_p)
+/* __builtin_sub_overflow_p can take bitfield */
+/* and GCC permits bitfields for integers other than int */
+# define SUB_OVERFLOW_FIXNUM_P(a, b) \
+    __extension__ ({ \
+        struct { long fixnum : sizeof(long) * CHAR_BIT - 1; } c = { 0 }; \
+        __builtin_sub_overflow_p((a), (b), c.fixnum); \
+    })
+#else
+# define SUB_OVERFLOW_FIXNUM_P(a, b) \
+    SUB_OVERFLOW_SIGNED_INTEGER_P(a, b, FIXNUM_MIN, FIXNUM_MAX)
+#endif
+
+#if defined(SUB_OVERFLOW_P) && defined(USE___BUILTIN_SUB_OVERFLOW_LONG_LONG)
+# define SUB_OVERFLOW_LONG_LONG_P(a, b) SUB_OVERFLOW_P(a, b)
+#else
+# define SUB_OVERFLOW_LONG_LONG_P(a, b) SUB_OVERFLOW_SIGNED_INTEGER_P(a, b, LLONG_MIN, LLONG_MAX)
+#endif
+
+#ifdef SUB_OVERFLOW_P
+# define SUB_OVERFLOW_LONG_P(a, b)      SUB_OVERFLOW_P(a, b)
+# define SUB_OVERFLOW_INT_P(a, b)       SUB_OVERFLOW_P(a, b)
+#else
+# define SUB_OVERFLOW_LONG_P(a, b)      SUB_OVERFLOW_SIGNED_INTEGER_P(a, b, LONG_MIN, LONG_MAX)
+# define SUB_OVERFLOW_INT_P(a, b)       SUB_OVERFLOW_SIGNED_INTEGER_P(a, b, INT_MIN, INT_MAX)
+#endif
+#endif
 
 #ifdef HAVE_UINT128_T
 # define bit_length(x) \

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview1 → ruby-3.5.0-preview1}/internal/class.h

@@ -83,7 +83,7 @@ struct RClass {
     struct rb_id_table *m_tbl;
 };
 
-// Assert that classes can be embedded in size_pools[2] (which has 160B slot size)
+// Assert that classes can be embedded in heaps[2] (which has 160B slot size)
 STATIC_ASSERT(sizeof_rb_classext_t, sizeof(struct RClass) + sizeof(rb_classext_t) <= 4 * RVALUE_SIZE);
 
 struct RClass_and_rb_classext_t {

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview2 → ruby-3.5.0-preview1}/internal/cmdlineopt.h

@@ -1,7 +1,6 @@
 #ifndef INTERNAL_CMDLINEOPT_H                               /*-*-C-*-vi:se ft=c:*/
 #define INTERNAL_CMDLINEOPT_H
 
-#include "rjit.h"
 #include "yjit.h"
 
 typedef struct {
@@ -24,9 +23,6 @@ typedef struct ruby_cmdline_options {
     ruby_features_t warn;
     unsigned int dump;
     long backtrace_length_limit;
-#if USE_RJIT
-    struct rb_rjit_options rjit;
-#endif
 
     const char *crash_report;
 

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview2 → ruby-3.5.0-preview1}/internal/encoding.h

@@ -28,6 +28,8 @@ int rb_encdb_dummy(const char *name);
 void rb_encdb_declare(const char *name);
 void rb_enc_set_base(const char *name, const char *orig);
 int rb_enc_set_dummy(int index);
+void rb_enc_raw_set(VALUE obj, rb_encoding *enc);
+
 PUREFUNC(int rb_data_is_encoding(VALUE obj));
 
 /* vm.c */

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview1 → ruby-3.5.0-preview1}/internal/error.h

@@ -72,6 +72,7 @@ const char *rb_builtin_type_name(int t);
 const char *rb_builtin_class_name(VALUE x);
 PRINTF_ARGS(void rb_warn_deprecated(const char *fmt, const char *suggest, ...), 1, 3);
 PRINTF_ARGS(void rb_warn_deprecated_to_remove(const char *removal, const char *fmt, const char *suggest, ...), 2, 4);
+PRINTF_ARGS(void rb_warn_reserved_name(const char *removal, const char *fmt, ...), 2, 3);
 #if RUBY_DEBUG
 # include "ruby/version.h"
 # define RUBY_VERSION_SINCE(major, minor) (RUBY_API_VERSION_CODE >= (major * 10000) + (minor) * 100)
@@ -110,6 +111,14 @@ rb_deprecated_method_to_be_removed(const char *removal)
     RBIMPL_ATTR_DIAGNOSE_IF(RUBY_VERSION_STRING_SINCE(removal), "deprecated method to be removed", "error")
 {
 }
+
+RBIMPL_ATTR_FORCEINLINE()
+static void
+rb_diagnose_reserved_name_at(const char *coming)
+    RBIMPL_ATTR_DIAGNOSE_IF(!RUBY_VERSION_isdigit(coming[0]), "malformed version number", "error")
+    RBIMPL_ATTR_DIAGNOSE_IF(RUBY_VERSION_STRING_SINCE(coming), "reserved name already in use", "error")
+{
+}
 # else
 RBIMPL_ATTR_ERROR(("deprecated"))
 void rb_deprecated_method_to_be_removed(const char *);
@@ -117,16 +126,32 @@ void rb_deprecated_method_to_be_removed(const char *);
     (sizeof(char[1-2*(!RUBY_VERSION_isdigit(removal[0]) || RUBY_VERSION_STRING_SINCE(removal))])!=1 ? \
      rb_deprecated_method_to_be_removed(removal) : \
      RBIMPL_ASSERT_NOTHING)
+
+RBIMPL_ATTR_ERROR(("deprecated"))
+void rb_diagnose_reserved_name_at(const char *);
+#   define rb_diagnose_reserved_name_at(coming) \
+    (sizeof(char[1-2*(!RUBY_VERSION_isdigit(coming[0]) || RUBY_VERSION_STRING_SINCE(coming))])!=1 ? \
+     rb_diagnose_reserved_name_at(coming) : \
+     RBIMPL_ASSERT_NOTHING)
+
 # endif
 # define rb_warn_deprecated_to_remove_at(removal, ...) \
     (rb_deprecated_method_to_be_removed(#removal), \
      rb_warn_deprecated_to_remove(#removal, __VA_ARGS__))
+
+# define rb_warn_reserved_name_at(coming, ...) \
+    (rb_diagnose_reserved_name_at(#coming), \
+     rb_warn_reserved_name(#coming, __VA_ARGS__))
 # endif
 #endif
 #ifndef rb_warn_deprecated_to_remove_at
 # define rb_warn_deprecated_to_remove_at(removal, ...) \
         rb_warn_deprecated_to_remove(#removal, __VA_ARGS__)
 #endif
+#ifndef rb_warn_reserved_name_at
+# define rb_warn_reserved_name_at(removal, ...) \
+        rb_warn_reserved_name(#removal, __VA_ARGS__)
+#endif
 #ifndef RUBY_VERSION_SINCE
 # define RUBY_VERSION_SINCE(major, minor) 0
 #endif
@@ -142,6 +167,8 @@ VALUE rb_syntax_error_append(VALUE, VALUE, int, int, rb_encoding*, const char*,
 PRINTF_ARGS(void rb_enc_warn(rb_encoding *enc, const char *fmt, ...), 2, 3);
 PRINTF_ARGS(void rb_sys_enc_warning(rb_encoding *enc, const char *fmt, ...), 2, 3);
 PRINTF_ARGS(void rb_syserr_enc_warning(int err, rb_encoding *enc, const char *fmt, ...), 3, 4);
+PRINTF_ARGS(void rb_enc_compile_warning(rb_encoding *enc, const char *file, int line, const char *fmt, ...), 4, 5);
+PRINTF_ARGS(void rb_enc_compile_warn(rb_encoding *enc, const char *file, int line, const char *fmt, ...), 4, 5);
 rb_warning_category_t rb_warning_category_from_name(VALUE category);
 bool rb_warning_category_enabled_p(rb_warning_category_t category);
 VALUE rb_name_err_new(VALUE mesg, VALUE recv, VALUE method);
@@ -158,6 +185,7 @@ NORETURN(static inline void rb_key_err_raise(VALUE mesg, VALUE recv, VALUE name)
 static inline void Check_Type(VALUE v, enum ruby_value_type t);
 static inline bool rb_typeddata_is_instance_of_inline(VALUE obj, const rb_data_type_t *data_type);
 #define rb_typeddata_is_instance_of rb_typeddata_is_instance_of_inline
+void rb_bug_without_die(const char *fmt, ...);
 
 RUBY_SYMBOL_EXPORT_BEGIN
 /* error.c (export) */

data/lib/datadog/ruby_core_source/{ruby-3.4.0-preview1 → ruby-3.5.0-preview1}/internal/fixnum.h

@@ -10,6 +10,7 @@
  */
 #include "ruby/internal/config.h"      /* for HAVE_LONG_LONG */
 #include <limits.h>             /* for CHAR_BIT */
+#include "internal/bits.h"      /* for MUL_OVERFLOW_FIXNUM_P */
 #include "internal/compilers.h" /* for __has_builtin */
 #include "ruby/internal/stdbool.h"     /* for bool */
 #include "ruby/intern.h"        /* for rb_big_mul */