looksee 4.2.0 → 4.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9accc508994e31a5c5ee5c3b07d0ac494a9d69635057f5a682e993a4ed3619d
-  data.tar.gz: 8f1c98f73662fae5bf0dc552cade610e82f58d5399c65802813f4bcc9d5c9be9
+  metadata.gz: 600194bca92f1417cef56f15fb778bf97169424c779269d16dc87afde159013b
+  data.tar.gz: a9548afb11a7e6ebbe7fa43d7155d6258871530d135197f93ed79573d899432a
 SHA512:
-  metadata.gz: 11161fbe1bfd1d630d59e5d1f1b3acf8f0564c7ca1cf971d35f12fb5e906118a782df27ca869f277205eb43bba3ffbdf6b59c8e96a9daa438cc54aa7865ffe08
-  data.tar.gz: f899f2c10409413e1ef77d2d0d64636922b39837fe8c3f04969619e8da32bf8195fdaca6d44ae79524c11736764e6419f83a6ea59a57d0343c94463f0eb8f39c
+  metadata.gz: '08f3978dbed48efa7daaba8fe778b9dfdf3032748dc2cdfd9ac5d36667bfd2ea7eff4b3662d660f97784d99459d082c0228c188bd2b3261e3ed5935d06a45460'
+  data.tar.gz: ec4dbddc1ca894b843d0ad187ea4ce35a4a1c6890a920790479d01e35ccb81f19bf321dff7001060d5f3280dd312d27b7c74494a756fad02613ad30b96dcae86

data/CHANGELOG

@@ -1,3 +1,7 @@
+== 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/ext/extconf.rb

@@ -4,7 +4,9 @@ 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.0.0'
+    $CPPFLAGS << " -Imri/3.0.0"
+  elsif RUBY_VERSION >= '2.7.0'
     $CPPFLAGS << " -Imri/2.7.0"
   elsif RUBY_VERSION >= '2.3.0'
     $CPPFLAGS << " -Imri/2.3.0"

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.h

@@ -0,0 +1,107 @@
+#ifndef RUBY_INTERNAL_H                                  /*-*-C-*-vi:se ft=c:*/
+#define RUBY_INTERNAL_H 1
+/**
+ * @file
+ * @author     $Author$
+ * @date       Tue May 17 11:42:20 JST 2011
+ * @copyright  Copyright (C) 2011 Yukihiro Matsumoto
+ * @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.
+ */
+#include "ruby/internal/config.h"
+
+#ifdef __cplusplus
+# error not for C++
+#endif
+
+#define LIKELY(x) RB_LIKELY(x)
+#define UNLIKELY(x) RB_UNLIKELY(x)
+
+#define numberof(array) ((int)(sizeof(array) / sizeof((array)[0])))
+#define roomof(x, y) (((x) + (y) - 1) / (y))
+#define type_roomof(x, y) roomof(sizeof(x), sizeof(y))
+
+/* Prevent compiler from reordering access */
+#define ACCESS_ONCE(type,x) (*((volatile type *)&(x)))
+
+#include "ruby/ruby.h"
+
+/* Following macros were formerly defined in this header but moved to somewhere
+ * else.  In order to detect them we undef here. */
+
+/* internal/array.h */
+#undef RARRAY_AREF
+
+/* internal/class.h */
+#undef RClass
+#undef RCLASS_SUPER
+
+/* internal/gc.h */
+#undef NEWOBJ_OF
+#undef RB_NEWOBJ_OF
+#undef RB_OBJ_WRITE
+
+/* internal/hash.h */
+#undef RHASH_IFNONE
+#undef RHASH_SIZE
+#undef RHASH_TBL
+#undef RHASH_EMPTY_P
+
+/* internal/object.h */
+#undef ROBJECT_IV_INDEX_TBL
+
+/* internal/struct.h */
+#undef RSTRUCT_LEN
+#undef RSTRUCT_PTR
+#undef RSTRUCT_SET
+#undef RSTRUCT_GET
+
+/* Also,  we  keep  the  following  macros  here.   They  are  expected  to  be
+ * overridden in each headers. */
+
+/* internal/array.h */
+#define rb_ary_new_from_args(...) rb_nonexistent_symbol(__VA_ARGS__)
+
+/* internal/io.h */
+#define rb_io_fptr_finalize(...) rb_nonexistent_symbol(__VA_ARGS__)
+
+/* internal/string.h */
+#define rb_fstring_cstr(...) rb_nonexistent_symbol(__VA_ARGS__)
+
+/* internal/symbol.h */
+#define rb_sym_intern_ascii_cstr(...) rb_nonexistent_symbol(__VA_ARGS__)
+
+/* internal/vm.h */
+#define rb_funcallv(...) rb_nonexistent_symbol(__VA_ARGS__)
+#define rb_method_basic_definition_p(...) rb_nonexistent_symbol(__VA_ARGS__)
+
+
+/* MRI debug support */
+
+/* gc.c */
+void rb_obj_info_dump(VALUE obj);
+void rb_obj_info_dump_loc(VALUE obj, const char *file, int line, const char *func);
+
+/* debug.c */
+
+RUBY_SYMBOL_EXPORT_BEGIN
+void ruby_debug_breakpoint(void);
+PRINTF_ARGS(void ruby_debug_printf(const char*, ...), 1, 2);
+RUBY_SYMBOL_EXPORT_END
+
+// show obj data structure without any side-effect
+#define rp(obj) rb_obj_info_dump_loc((VALUE)(obj), __FILE__, __LINE__, RUBY_FUNCTION_NAME_STRING)
+
+// same as rp, but add message header
+#define rp_m(msg, obj) do { \
+fprintf(stderr, "%s", (msg)); \
+rb_obj_info_dump((VALUE)obj); \
+} while (0)
+
+// `ruby_debug_breakpoint()` does nothing,
+// but breakpoint is set in run.gdb, so `make gdb` can stop here.
+#define bp() ruby_debug_breakpoint()
+
+#endif /* RUBY_INTERNAL_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 */