looksee 4.2.0 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9accc508994e31a5c5ee5c3b07d0ac494a9d69635057f5a682e993a4ed3619d
-  data.tar.gz: 8f1c98f73662fae5bf0dc552cade610e82f58d5399c65802813f4bcc9d5c9be9
+  metadata.gz: 48ef0a2047045795c76025fd0544aaa9c2c2545903cad6c944fffcfcb2ee75d0
+  data.tar.gz: 23493fa986e3b3eb584db4d50d921aa036ee260dc69a6a87f03fe194aed4c26a
 SHA512:
-  metadata.gz: 11161fbe1bfd1d630d59e5d1f1b3acf8f0564c7ca1cf971d35f12fb5e906118a782df27ca869f277205eb43bba3ffbdf6b59c8e96a9daa438cc54aa7865ffe08
-  data.tar.gz: f899f2c10409413e1ef77d2d0d64636922b39837fe8c3f04969619e8da32bf8195fdaca6d44ae79524c11736764e6419f83a6ea59a57d0343c94463f0eb8f39c
+  metadata.gz: 3e286370942fed7ed9b420e5448639a1a7a3903afcb092d6777f974632ba78c347fc146f95b0dd0b9bb215743d94a498a7402ee17a84d95bcfb4638da14efb6f
+  data.tar.gz: e96734ae3281967a23a13c287c39e1ea2469782348886936ba63827de8cdbeb2e0fa0a0698658351078f31accb6efeabcc3152eab71917b5412602056c9f0055

data/CHANGELOG

@@ -1,3 +1,18 @@
+== 5.0.0 2022-11-08
+
+ * Rename #ls to #look. Sorry! irb now defines an ls built-in, though, and the
+   old name emits a warning on startup.
+ * Support for MRI 3.2.0 preview2. From 3.2 onwards, we once again display
+   undef'd methods.
+ * Remove support for MRI < 2.7. (2.6 is EOL anyway.)
+ * Remove support for Rubinius.
+ * Fix showing modules included in singleton classes with no direct methods.
+ * Fix ANSI color escaping in ruby >= 3.0.
+
+== 4.4.0 2021-01-17
+
+ * Support for MRI 3.0. [Mathieu Jobin]
+
 == 4.2.0 2019-12-26
 
  * Support for MRI 2.7.

data/Rakefile

@@ -11,3 +11,30 @@ end
 task :default => [:clobber, :ext] do
   sh 'bundle exec rspec -I. spec'
 end
+
+task :test_all do
+  docker_configs.each do |config|
+    docker_run(config, 'rspec')
+  end
+end
+
+task :console, :config do |task, args|
+  docker_run(args[:config], nil)
+end
+
+task :test, :config do |task, args|
+  docker_run(args[:config], 'rspec')
+end
+
+task :shell, :config do |task, args|
+  docker_run(args[:config], '/bin/bash')
+end
+
+def docker_configs
+  Dir['Dockerfile.*'].map { |path| path[/(?<=\.).*?\z/] }
+end
+
+def docker_run(config, command)
+  sh "docker build -f Dockerfile.#{config} -t looksee:#{config} ."
+  sh "docker run -it looksee:#{config} #{command}"
+end

data/ext/extconf.rb

@@ -4,14 +4,13 @@ extension = ruby_engine == 'ruby' ? 'mri' : ruby_engine
 require 'mkmf'
 $CPPFLAGS << " -DRUBY_VERSION=#{RUBY_VERSION.tr('.', '')}"
 if extension == 'mri'
-  if RUBY_VERSION >= '2.7.0'
+  if RUBY_VERSION >= '3.2.0'
+    $CPPFLAGS << " -Imri/3.2.0"
+  elsif RUBY_VERSION >= '3.0.0'
+    $CPPFLAGS << " -Imri/3.0.0"
+  else
     $CPPFLAGS << " -Imri/2.7.0"
-  elsif RUBY_VERSION >= '2.3.0'
-    $CPPFLAGS << " -Imri/2.3.0"
-  elsif RUBY_VERSION >= '2.2.0'
-    $CPPFLAGS << " -Imri/2.2.0"
-  elsif RUBY_VERSION >= '2.1.0'
-    $CPPFLAGS << " -Imri/2.1.0"
   end
 end
+
 create_makefile "looksee/#{extension}", extension

data/ext/mri/3.0.0/id_table.h

@@ -0,0 +1,36 @@
+#ifndef RUBY_ID_TABLE_H
+#define RUBY_ID_TABLE_H 1
+#include "ruby/internal/config.h"
+#include <stddef.h>
+#include "ruby/ruby.h"
+
+struct rb_id_table;
+
+/* compatible with ST_* */
+enum rb_id_table_iterator_result {
+  ID_TABLE_CONTINUE = ST_CONTINUE,
+  ID_TABLE_STOP     = ST_STOP,
+  ID_TABLE_DELETE   = ST_DELETE,
+  ID_TABLE_REPLACE  = ST_REPLACE,
+  ID_TABLE_ITERATOR_RESULT_END
+};
+
+struct rb_id_table *rb_id_table_create(size_t size);
+void rb_id_table_free(struct rb_id_table *tbl);
+void rb_id_table_clear(struct rb_id_table *tbl);
+
+size_t rb_id_table_size(const struct rb_id_table *tbl);
+size_t rb_id_table_memsize(const struct rb_id_table *tbl);
+
+int rb_id_table_insert(struct rb_id_table *tbl, ID id, VALUE val);
+int rb_id_table_lookup(struct rb_id_table *tbl, ID id, VALUE *valp);
+int rb_id_table_delete(struct rb_id_table *tbl, ID id);
+
+typedef enum rb_id_table_iterator_result rb_id_table_update_callback_func_t(ID *id, VALUE *val, void *data, int existing);
+typedef enum rb_id_table_iterator_result rb_id_table_foreach_func_t(ID id, VALUE val, void *data);
+typedef enum rb_id_table_iterator_result rb_id_table_foreach_values_func_t(VALUE val, void *data);
+void rb_id_table_foreach(struct rb_id_table *tbl, rb_id_table_foreach_func_t *func, void *data);
+void rb_id_table_foreach_with_replace(struct rb_id_table *tbl, rb_id_table_foreach_func_t *func, rb_id_table_update_callback_func_t *replace, void *data);
+void rb_id_table_foreach_values(struct rb_id_table *tbl, rb_id_table_foreach_values_func_t *func, void *data);
+
+#endif	/* RUBY_ID_TABLE_H */

data/ext/mri/3.0.0/internal/array.h

@@ -0,0 +1,119 @@
+#ifndef INTERNAL_ARRAY_H                                 /*-*-C-*-vi:se ft=c:*/
+#define INTERNAL_ARRAY_H
+/**
+ * @file
+ * @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 Array.
+ */
+#include "ruby/internal/config.h"
+#include <stddef.h>                 /* for size_t */
+#include "internal/static_assert.h" /* for STATIC_ASSERT */
+#include "ruby/internal/stdbool.h"         /* for bool */
+#include "ruby/ruby.h"              /* for RARRAY_LEN */
+
+#ifndef ARRAY_DEBUG
+# define ARRAY_DEBUG (0+RUBY_DEBUG)
+#endif
+
+#define RARRAY_PTR_IN_USE_FLAG FL_USER14
+
+/* array.c */
+VALUE rb_ary_last(int, const VALUE *, VALUE);
+void rb_ary_set_len(VALUE, long);
+void rb_ary_delete_same(VALUE, VALUE);
+VALUE rb_ary_tmp_new_fill(long capa);
+VALUE rb_ary_at(VALUE, VALUE);
+size_t rb_ary_memsize(VALUE);
+VALUE rb_to_array_type(VALUE obj);
+void rb_ary_cancel_sharing(VALUE ary);
+
+static inline VALUE rb_ary_entry_internal(VALUE ary, long offset);
+static inline bool ARY_PTR_USING_P(VALUE ary);
+static inline void RARY_TRANSIENT_SET(VALUE ary);
+static inline void RARY_TRANSIENT_UNSET(VALUE ary);
+
+RUBY_SYMBOL_EXPORT_BEGIN
+/* array.c (export) */
+void rb_ary_detransient(VALUE a);
+VALUE *rb_ary_ptr_use_start(VALUE ary);
+void rb_ary_ptr_use_end(VALUE ary);
+RUBY_SYMBOL_EXPORT_END
+
+MJIT_SYMBOL_EXPORT_BEGIN
+VALUE rb_ary_tmp_new_from_values(VALUE, long, const VALUE *);
+VALUE rb_check_to_array(VALUE ary);
+VALUE rb_ary_behead(VALUE, long);
+VALUE rb_ary_aref1(VALUE ary, VALUE i);
+
+struct rb_execution_context_struct;
+VALUE rb_ec_ary_new_from_values(struct rb_execution_context_struct *ec, long n, const VALUE *elts);
+MJIT_SYMBOL_EXPORT_END
+
+static inline VALUE
+rb_ary_entry_internal(VALUE ary, long offset)
+{
+  long len = RARRAY_LEN(ary);
+  const VALUE *ptr = RARRAY_CONST_PTR_TRANSIENT(ary);
+  if (len == 0) return Qnil;
+  if (offset < 0) {
+    offset += len;
+    if (offset < 0) return Qnil;
+  }
+  else if (len <= offset) {
+    return Qnil;
+  }
+  return ptr[offset];
+}
+
+static inline bool
+ARY_PTR_USING_P(VALUE ary)
+{
+  return FL_TEST_RAW(ary, RARRAY_PTR_IN_USE_FLAG);
+}
+
+static inline void
+RARY_TRANSIENT_SET(VALUE ary)
+{
+  #if USE_TRANSIENT_HEAP
+  FL_SET_RAW(ary, RARRAY_TRANSIENT_FLAG);
+  #endif
+}
+
+static inline void
+RARY_TRANSIENT_UNSET(VALUE ary)
+{
+  #if USE_TRANSIENT_HEAP
+  FL_UNSET_RAW(ary, RARRAY_TRANSIENT_FLAG);
+  #endif
+}
+
+#undef rb_ary_new_from_args
+#if RBIMPL_HAS_WARNING("-Wgnu-zero-variadic-macro-arguments")
+# /* Skip it; clang -pedantic doesn't like the following */
+#elif defined(__GNUC__) && defined(HAVE_VA_ARGS_MACRO)
+#define rb_ary_new_from_args(n, ...) \
+__extension__ ({ \
+  const VALUE args_to_new_ary[] = {__VA_ARGS__}; \
+  if (__builtin_constant_p(n)) { \
+    STATIC_ASSERT(rb_ary_new_from_args, numberof(args_to_new_ary) == (n)); \
+  } \
+  rb_ary_new_from_values(numberof(args_to_new_ary), args_to_new_ary); \
+})
+#endif
+
+#undef RARRAY_AREF
+RBIMPL_ATTR_PURE_UNLESS_DEBUG()
+RBIMPL_ATTR_ARTIFICIAL()
+static inline VALUE
+RARRAY_AREF(VALUE ary, long i)
+{
+  RBIMPL_ASSERT_TYPE(ary, RUBY_T_ARRAY);
+
+  return RARRAY_CONST_PTR_TRANSIENT(ary)[i];
+}
+
+#endif /* INTERNAL_ARRAY_H */

data/ext/mri/3.0.0/internal/class.h

@@ -0,0 +1,174 @@
+#ifndef INTERNAL_CLASS_H                                 /*-*-C-*-vi:se ft=c:*/
+#define INTERNAL_CLASS_H
+/**
+ * @file
+ * @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 Class.
+ */
+#include "id_table.h"           /* for struct rb_id_table */
+#include "internal/gc.h"        /* for RB_OBJ_WRITE */
+#include "internal/serial.h"    /* for rb_serial_t */
+#include "ruby/internal/stdbool.h"     /* for bool */
+#include "ruby/intern.h"        /* for rb_alloc_func_t */
+#include "ruby/ruby.h"          /* for struct RBasic */
+
+#ifdef RCLASS_SUPER
+# undef RCLASS_SUPER
+#endif
+
+struct rb_subclass_entry {
+  VALUE klass;
+  struct rb_subclass_entry *next;
+};
+
+struct rb_iv_index_tbl_entry {
+  uint32_t index;
+  rb_serial_t class_serial;
+  VALUE class_value;
+};
+
+struct rb_classext_struct {
+  struct st_table *iv_index_tbl; // ID -> struct rb_iv_index_tbl_entry
+  struct st_table *iv_tbl;
+  #if SIZEOF_SERIAL_T == SIZEOF_VALUE /* otherwise m_tbl is in struct RClass */
+  struct rb_id_table *m_tbl;
+  #endif
+  struct rb_id_table *const_tbl;
+  struct rb_id_table *callable_m_tbl;
+  struct rb_id_table *cc_tbl; /* ID -> [[ci, cc1], cc2, ...] */
+  struct rb_subclass_entry *subclasses;
+  struct rb_subclass_entry **parent_subclasses;
+  /**
+   * In the case that this is an `ICLASS`, `module_subclasses` points to the link
+   * in the module's `subclasses` list that indicates that the klass has been
+   * included. Hopefully that makes sense.
+   */
+  struct rb_subclass_entry **module_subclasses;
+  #if SIZEOF_SERIAL_T != SIZEOF_VALUE /* otherwise class_serial is in struct RClass */
+  rb_serial_t class_serial;
+  #endif
+  const VALUE origin_;
+  const VALUE refined_class;
+  rb_alloc_func_t allocator;
+  const VALUE includer;
+};
+
+struct RClass {
+  struct RBasic basic;
+  VALUE super;
+  struct rb_classext_struct *ptr;
+  #if SIZEOF_SERIAL_T == SIZEOF_VALUE
+  /* Class serial is as wide as VALUE.  Place it here. */
+  rb_serial_t class_serial;
+  #else
+  /* Class serial does not fit into struct RClass. Place m_tbl instead. */
+  struct rb_id_table *m_tbl;
+  #endif
+};
+
+typedef struct rb_subclass_entry rb_subclass_entry_t;
+typedef struct rb_classext_struct rb_classext_t;
+
+#define RCLASS_EXT(c) (RCLASS(c)->ptr)
+#define RCLASS_IV_TBL(c) (RCLASS_EXT(c)->iv_tbl)
+#define RCLASS_CONST_TBL(c) (RCLASS_EXT(c)->const_tbl)
+#if SIZEOF_SERIAL_T == SIZEOF_VALUE
+# define RCLASS_M_TBL(c) (RCLASS_EXT(c)->m_tbl)
+#else
+# define RCLASS_M_TBL(c) (RCLASS(c)->m_tbl)
+#endif
+#define RCLASS_CALLABLE_M_TBL(c) (RCLASS_EXT(c)->callable_m_tbl)
+#define RCLASS_CC_TBL(c) (RCLASS_EXT(c)->cc_tbl)
+#define RCLASS_IV_INDEX_TBL(c) (RCLASS_EXT(c)->iv_index_tbl)
+#define RCLASS_ORIGIN(c) (RCLASS_EXT(c)->origin_)
+#define RCLASS_REFINED_CLASS(c) (RCLASS_EXT(c)->refined_class)
+#if SIZEOF_SERIAL_T == SIZEOF_VALUE
+# define RCLASS_SERIAL(c) (RCLASS(c)->class_serial)
+#else
+# define RCLASS_SERIAL(c) (RCLASS_EXT(c)->class_serial)
+#endif
+#define RCLASS_INCLUDER(c) (RCLASS_EXT(c)->includer)
+
+#define RICLASS_IS_ORIGIN FL_USER5
+#define RCLASS_CLONED     FL_USER6
+#define RICLASS_ORIGIN_SHARED_MTBL FL_USER8
+
+/* class.c */
+void rb_class_subclass_add(VALUE super, VALUE klass);
+void rb_class_remove_from_super_subclasses(VALUE);
+int rb_singleton_class_internal_p(VALUE sklass);
+VALUE rb_class_boot(VALUE);
+VALUE rb_make_metaclass(VALUE, VALUE);
+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);
+void rb_class_detach_module_subclasses(VALUE);
+void rb_class_remove_from_module_subclasses(VALUE);
+VALUE rb_obj_methods(int argc, const VALUE *argv, VALUE obj);
+VALUE rb_obj_protected_methods(int argc, const VALUE *argv, VALUE obj);
+VALUE rb_obj_private_methods(int argc, const VALUE *argv, VALUE obj);
+VALUE rb_obj_public_methods(int argc, const VALUE *argv, VALUE obj);
+VALUE rb_special_singleton_class(VALUE);
+VALUE rb_singleton_class_clone_and_attach(VALUE obj, VALUE attach);
+VALUE rb_singleton_class_get(VALUE obj);
+int rb_class_has_methods(VALUE c);
+void rb_undef_methods_from(VALUE klass, VALUE super);
+
+static inline void RCLASS_SET_ORIGIN(VALUE klass, VALUE origin);
+static inline void RICLASS_SET_ORIGIN_SHARED_MTBL(VALUE iclass);
+static inline VALUE RCLASS_SUPER(VALUE klass);
+static inline VALUE RCLASS_SET_SUPER(VALUE klass, VALUE super);
+static inline void RCLASS_SET_INCLUDER(VALUE iclass, VALUE klass);
+
+MJIT_SYMBOL_EXPORT_BEGIN
+VALUE rb_class_inherited(VALUE, VALUE);
+VALUE rb_keyword_error_new(const char *, VALUE);
+MJIT_SYMBOL_EXPORT_END
+
+static inline void
+RCLASS_SET_ORIGIN(VALUE klass, VALUE origin)
+{
+  RB_OBJ_WRITE(klass, &RCLASS_ORIGIN(klass), origin);
+  if (klass != origin) FL_SET(origin, RICLASS_IS_ORIGIN);
+}
+
+static inline void
+RICLASS_SET_ORIGIN_SHARED_MTBL(VALUE iclass)
+{
+  FL_SET(iclass, RICLASS_ORIGIN_SHARED_MTBL);
+}
+
+static inline bool
+RICLASS_OWNS_M_TBL_P(VALUE iclass)
+{
+  return FL_TEST_RAW(iclass, RICLASS_IS_ORIGIN | RICLASS_ORIGIN_SHARED_MTBL) == RICLASS_IS_ORIGIN;
+}
+
+static inline void
+RCLASS_SET_INCLUDER(VALUE iclass, VALUE klass)
+{
+  RB_OBJ_WRITE(iclass, &RCLASS_INCLUDER(iclass), klass);
+}
+
+static inline VALUE
+RCLASS_SUPER(VALUE klass)
+{
+  return RCLASS(klass)->super;
+}
+
+static inline VALUE
+RCLASS_SET_SUPER(VALUE klass, VALUE super)
+{
+  if (super) {
+    rb_class_remove_from_super_subclasses(klass);
+    rb_class_subclass_add(super, klass);
+  }
+  RB_OBJ_WRITE(klass, &RCLASS(klass)->super, super);
+  return super;
+}
+
+#endif /* INTERNAL_CLASS_H */

data/ext/mri/3.0.0/internal/compilers.h

@@ -0,0 +1,108 @@
+#ifndef INTERNAL_COMPILERS_H                             /*-*-C-*-vi:se ft=c:*/
+#define INTERNAL_COMPILERS_H
+/**
+ * @file
+ * @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 absorbing C compipler differences.
+ */
+#include "ruby/internal/compiler_since.h"
+#include "ruby/internal/has/attribute.h"
+#include "ruby/internal/has/builtin.h"
+#include "ruby/internal/has/c_attribute.h"
+#include "ruby/internal/has/declspec_attribute.h"
+#include "ruby/internal/has/extension.h"
+#include "ruby/internal/has/feature.h"
+#include "ruby/internal/has/warning.h"
+#include "ruby/backward/2/gcc_version_since.h"
+
+#define MSC_VERSION_SINCE(_)   RBIMPL_COMPILER_SINCE(MSVC, (_) / 100, (_) % 100, 0)
+#define MSC_VERSION_BEFORE(_)  RBIMPL_COMPILER_BEFORE(MSVC, (_) / 100, (_) % 100, 0)
+
+#ifndef __has_attribute
+# define __has_attribute(...) RBIMPL_HAS_ATTRIBUTE(__VA_ARGS__)
+#endif
+
+#ifndef __has_c_attribute
+# /* As  of writing  everything  that lacks  __has_c_attribute also  completely
+#  * lacks C2x attributes as well.  Might change in future? */
+# define __has_c_attribute(...) 0
+#endif
+
+#ifndef __has_declspec_attribute
+# define __has_declspec_attribute(...) RBIMPL_HAS_DECLSPEC_ATTRIBUTE(__VA_ARGS__)
+#endif
+
+#ifndef __has_builtin
+# define __has_builtin(...) RBIMPL_HAS_BUILTIN(__VA_ARGS__)
+#endif
+
+#ifndef __has_feature
+# define __has_feature(...) RBIMPL_HAS_FEATURE(__VA_ARGS__)
+#endif
+
+#ifndef __has_extension
+# define __has_extension(...) RBIMPL_HAS_EXTENSION(__VA_ARGS__)
+#endif
+
+#ifndef __has_warning
+# define __has_warning(...) RBIMPL_HAS_WARNING(__VA_ARGS__)
+#endif
+
+#ifndef __GNUC__
+# define __extension__ /* void */
+#endif
+
+#ifndef MAYBE_UNUSED
+# define MAYBE_UNUSED(x) x
+#endif
+
+#ifndef WARN_UNUSED_RESULT
+# define WARN_UNUSED_RESULT(x) x
+#endif
+
+#define RB_OBJ_BUILTIN_TYPE(obj) rb_obj_builtin_type(obj)
+#define OBJ_BUILTIN_TYPE(obj) RB_OBJ_BUILTIN_TYPE(obj)
+#ifdef __GNUC__
+#define rb_obj_builtin_type(obj) \
+__extension__({ \
+  VALUE arg_obj = (obj); \
+  RB_SPECIAL_CONST_P(arg_obj) ? -1 : \
+  (int)RB_BUILTIN_TYPE(arg_obj);    \
+})
+#else
+# include "ruby/ruby.h"
+static inline int
+rb_obj_builtin_type(VALUE obj)
+{
+  return RB_SPECIAL_CONST_P(obj) ? -1 :
+  (int)RB_BUILTIN_TYPE(obj);
+}
+#endif
+
+/* A macro for defining a flexible array, like: VALUE ary[FLEX_ARY_LEN]; */
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
+# define FLEX_ARY_LEN   /* VALUE ary[]; */
+#elif defined(__GNUC__) && !defined(__STRICT_ANSI__)
+# define FLEX_ARY_LEN 0 /* VALUE ary[0]; */
+#else
+# define FLEX_ARY_LEN 1 /* VALUE ary[1]; */
+#endif
+
+/*
+ * For declaring bitfields out of non-unsigned int types:
+ *   struct date {
+ *      BITFIELD(enum months, month, 4);
+ *      ...
+ *   };
+ */
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
+# define BITFIELD(type, name, size) type name : size
+#else
+# define BITFIELD(type, name, size) unsigned int name : size
+#endif
+
+#endif /* INTERNAL_COMPILERS_H */

data/ext/mri/3.0.0/internal/gc.h

@@ -0,0 +1,161 @@
+#ifndef INTERNAL_GC_H                                    /*-*-C-*-vi:se ft=c:*/
+#define INTERNAL_GC_H
+/**
+ * @file
+ * @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 GC.
+ */
+#include "ruby/internal/config.h"
+
+#include <stddef.h>             /* for size_t */
+
+#include "internal/compilers.h" /* for __has_attribute */
+#include "ruby/ruby.h"          /* for rb_event_flag_t */
+
+struct rb_execution_context_struct; /* in vm_core.h */
+struct rb_objspace; /* in vm_core.h */
+
+#ifdef NEWOBJ_OF
+# undef NEWOBJ_OF
+# undef RB_NEWOBJ_OF
+# undef RB_OBJ_WRITE
+#endif
+
+/* optimized version of NEWOBJ() */
+#define RB_NEWOBJ_OF(var, T, c, f) \
+T *(var) = (T *)(((f) & FL_WB_PROTECTED) ? \
+rb_wb_protected_newobj_of((c), (f) & ~FL_WB_PROTECTED) : \
+rb_wb_unprotected_newobj_of((c), (f)))
+
+#define RB_EC_NEWOBJ_OF(ec, var, T, c, f) \
+T *(var) = (T *)(((f) & FL_WB_PROTECTED) ? \
+rb_ec_wb_protected_newobj_of((ec), (c), (f) & ~FL_WB_PROTECTED) : \
+rb_wb_unprotected_newobj_of((c), (f)))
+
+#define NEWOBJ_OF(var, T, c, f) RB_NEWOBJ_OF((var), T, (c), (f))
+#define RB_OBJ_GC_FLAGS_MAX 6   /* used in ext/objspace */
+
+#ifndef USE_UNALIGNED_MEMBER_ACCESS
+# define UNALIGNED_MEMBER_ACCESS(expr) (expr)
+#elif ! USE_UNALIGNED_MEMBER_ACCESS
+# define UNALIGNED_MEMBER_ACCESS(expr) (expr)
+#elif ! (__has_warning("-Waddress-of-packed-member") || GCC_VERSION_SINCE(9, 0, 0))
+# define UNALIGNED_MEMBER_ACCESS(expr) (expr)
+#else
+# include "internal/warnings.h"
+# define UNALIGNED_MEMBER_ACCESS(expr) __extension__({ \
+COMPILER_WARNING_PUSH; \
+COMPILER_WARNING_IGNORED(-Waddress-of-packed-member); \
+__typeof__(expr) unaligned_member_access_result = (expr); \
+COMPILER_WARNING_POP; \
+unaligned_member_access_result; \
+})
+#endif
+
+#define UNALIGNED_MEMBER_PTR(ptr, mem) UNALIGNED_MEMBER_ACCESS(&(ptr)->mem)
+#define RB_OBJ_WRITE(a, slot, b) \
+rb_obj_write((VALUE)(a), UNALIGNED_MEMBER_ACCESS((VALUE *)(slot)), \
+(VALUE)(b), __FILE__, __LINE__)
+
+/* gc.c */
+extern VALUE *ruby_initial_gc_stress_ptr;
+extern int ruby_disable_gc;
+RUBY_ATTR_MALLOC void *ruby_mimmalloc(size_t size);
+void ruby_mimfree(void *ptr);
+void rb_objspace_set_event_hook(const rb_event_flag_t event);
+VALUE rb_objspace_gc_enable(struct rb_objspace *);
+VALUE rb_objspace_gc_disable(struct rb_objspace *);
+void ruby_gc_set_params(void);
+void rb_copy_wb_protected_attribute(VALUE dest, VALUE obj);
+#if __has_attribute(alloc_align)
+__attribute__((__alloc_align__(1)))
+#endif
+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 */
+RUBY_ATTR_MALLOC void *rb_xmalloc_mul_add(size_t, size_t, size_t);
+void *rb_xrealloc_mul_add(const void *, size_t, size_t, size_t);
+RUBY_ATTR_MALLOC void *rb_xmalloc_mul_add_mul(size_t, size_t, size_t, size_t);
+RUBY_ATTR_MALLOC void *rb_xcalloc_mul_add_mul(size_t, size_t, size_t, size_t);
+static inline void *ruby_sized_xrealloc_inlined(void *ptr, size_t new_size, size_t old_size) RUBY_ATTR_RETURNS_NONNULL RUBY_ATTR_ALLOC_SIZE((2));
+static inline void *ruby_sized_xrealloc2_inlined(void *ptr, size_t new_count, size_t elemsiz, size_t old_count) RUBY_ATTR_RETURNS_NONNULL RUBY_ATTR_ALLOC_SIZE((2, 3));
+static inline void ruby_sized_xfree_inlined(void *ptr, size_t size);
+VALUE rb_class_allocate_instance(VALUE klass);
+
+RUBY_SYMBOL_EXPORT_BEGIN
+/* gc.c (export) */
+const char *rb_objspace_data_type_name(VALUE obj);
+VALUE rb_wb_protected_newobj_of(VALUE, VALUE);
+VALUE rb_wb_unprotected_newobj_of(VALUE, VALUE);
+VALUE rb_ec_wb_protected_newobj_of(struct rb_execution_context_struct *ec, VALUE klass, VALUE flags);
+size_t rb_obj_memsize_of(VALUE);
+void rb_gc_verify_internal_consistency(void);
+size_t rb_obj_gc_flags(VALUE, ID[], size_t);
+void rb_gc_mark_values(long n, const VALUE *values);
+void rb_gc_mark_vm_stack_values(long n, const VALUE *values);
+void *ruby_sized_xrealloc(void *ptr, size_t new_size, size_t old_size) RUBY_ATTR_RETURNS_NONNULL RUBY_ATTR_ALLOC_SIZE((2));
+void *ruby_sized_xrealloc2(void *ptr, size_t new_count, size_t element_size, size_t old_count) RUBY_ATTR_RETURNS_NONNULL RUBY_ATTR_ALLOC_SIZE((2, 3));
+void ruby_sized_xfree(void *x, size_t size);
+RUBY_SYMBOL_EXPORT_END
+
+MJIT_SYMBOL_EXPORT_BEGIN
+int rb_ec_stack_check(struct rb_execution_context_struct *ec);
+void rb_gc_writebarrier_remember(VALUE obj);
+const char *rb_obj_info(VALUE obj);
+MJIT_SYMBOL_EXPORT_END
+
+#if defined(HAVE_MALLOC_USABLE_SIZE) || defined(HAVE_MALLOC_SIZE) || defined(_WIN32)
+
+static inline void *
+ruby_sized_xrealloc_inlined(void *ptr, size_t new_size, size_t old_size)
+{
+  return ruby_xrealloc(ptr, new_size);
+}
+
+static inline void *
+ruby_sized_xrealloc2_inlined(void *ptr, size_t new_count, size_t elemsiz, size_t old_count)
+{
+  return ruby_xrealloc2(ptr, new_count, elemsiz);
+}
+
+static inline void
+ruby_sized_xfree_inlined(void *ptr, size_t size)
+{
+  ruby_xfree(ptr);
+}
+
+# define SIZED_REALLOC_N(x, y, z, w) REALLOC_N(x, y, z)
+
+#else
+
+static inline void *
+ruby_sized_xrealloc_inlined(void *ptr, size_t new_size, size_t old_size)
+{
+  return ruby_sized_xrealloc(ptr, new_size, old_size);
+}
+
+static inline void *
+ruby_sized_xrealloc2_inlined(void *ptr, size_t new_count, size_t elemsiz, size_t old_count)
+{
+  return ruby_sized_xrealloc2(ptr, new_count, elemsiz, old_count);
+}
+
+static inline void
+ruby_sized_xfree_inlined(void *ptr, size_t size)
+{
+  ruby_sized_xfree(ptr, size);
+}
+
+# define SIZED_REALLOC_N(v, T, m, n) \
+((v) = (T *)ruby_sized_xrealloc2((void *)(v), (m), sizeof(T), (n)))
+
+#endif /* HAVE_MALLOC_USABLE_SIZE */
+
+#define ruby_sized_xrealloc ruby_sized_xrealloc_inlined
+#define ruby_sized_xrealloc2 ruby_sized_xrealloc2_inlined
+#define ruby_sized_xfree ruby_sized_xfree_inlined
+#endif /* INTERNAL_GC_H */