diff options
Diffstat (limited to 'class.c')
-rw-r--r-- | class.c | 1599 |
1 files changed, 946 insertions, 653 deletions
@@ -10,16 +10,7 @@ **********************************************************************/ /*! - * \defgroup class Classes and their hierarchy. - * \par Terminology - * - class: same as in Ruby. - * - singleton class: class for a particular object - * - eigenclass: = singleton class - * - metaclass: class of a class. metaclass is a kind of singleton class. - * - metametaclass: class of a metaclass. - * - meta^(n)-class: class of a meta^(n-1)-class. - * - attached object: A singleton class knows its unique instance. - * The instance is called the attached object for the singleton class. + * \addtogroup class * \{ */ @@ -38,102 +29,173 @@ #include "internal/variable.h" #include "ruby/st.h" #include "vm_core.h" +#include "yjit.h" + +/* Flags of T_CLASS + * + * 0: RCLASS_IS_ROOT + * The class has been added to the VM roots. Will always be marked and pinned. + * This is done for classes defined from C to allow storing them in global variables. + * 1: RUBY_FL_SINGLETON + * This class is a singleton class. + * 2: RCLASS_SUPERCLASSES_INCLUDE_SELF + * The RCLASS_SUPERCLASSES contains the class as the last element. + * This means that this class owns the RCLASS_SUPERCLASSES list. + * if !SHAPE_IN_BASIC_FLAGS + * 4-19: SHAPE_FLAG_MASK + * Shape ID for the class. + * endif + */ -#define id_attached id__attached__ +/* Flags of T_ICLASS + * + * 0: RICLASS_IS_ORIGIN + * 3: RICLASS_ORIGIN_SHARED_MTBL + * The T_ICLASS does not own the method table. + * if !SHAPE_IN_BASIC_FLAGS + * 4-19: SHAPE_FLAG_MASK + * Shape ID. This is set but not used. + * endif + */ + +/* Flags of T_MODULE + * + * 0: RCLASS_IS_ROOT + * The class has been added to the VM roots. Will always be marked and pinned. + * This is done for classes defined from C to allow storing them in global variables. + * 1: RMODULE_ALLOCATED_BUT_NOT_INITIALIZED + * Module has not been initialized. + * 2: RCLASS_SUPERCLASSES_INCLUDE_SELF + * See RCLASS_SUPERCLASSES_INCLUDE_SELF in T_CLASS. + * 3: RMODULE_IS_REFINEMENT + * Module is used for refinements. + * if !SHAPE_IN_BASIC_FLAGS + * 4-19: SHAPE_FLAG_MASK + * Shape ID for the module. + * endif + */ #define METACLASS_OF(k) RBASIC(k)->klass #define SET_METACLASS_OF(k, cls) RBASIC_SET_CLASS(k, cls) RUBY_EXTERN rb_serial_t ruby_vm_global_cvar_state; -void -rb_class_subclass_add(VALUE super, VALUE klass) +static rb_subclass_entry_t * +push_subclass_entry_to_list(VALUE super, VALUE klass) { rb_subclass_entry_t *entry, *head; - if (super && super != Qundef) { - entry = ALLOC(rb_subclass_entry_t); - entry->klass = klass; - entry->next = NULL; + entry = ZALLOC(rb_subclass_entry_t); + entry->klass = klass; - head = RCLASS_SUBCLASSES(super); - if (head) { - entry->next = head; - RCLASS_PARENT_SUBCLASSES(head->klass) = &entry->next; - } + head = RCLASS_SUBCLASSES(super); + if (!head) { + head = ZALLOC(rb_subclass_entry_t); + RCLASS_SUBCLASSES(super) = head; + } + entry->next = head->next; + entry->prev = head; - RCLASS_SUBCLASSES(super) = entry; - RCLASS_PARENT_SUBCLASSES(klass) = &RCLASS_SUBCLASSES(super); + if (head->next) { + head->next->prev = entry; + } + head->next = entry; + + return entry; +} + +void +rb_class_subclass_add(VALUE super, VALUE klass) +{ + if (super && !UNDEF_P(super)) { + rb_subclass_entry_t *entry = push_subclass_entry_to_list(super, klass); + RCLASS_SUBCLASS_ENTRY(klass) = entry; } } static void rb_module_add_to_subclasses_list(VALUE module, VALUE iclass) { - rb_subclass_entry_t *entry, *head; + rb_subclass_entry_t *entry = push_subclass_entry_to_list(module, iclass); + RCLASS_MODULE_SUBCLASS_ENTRY(iclass) = entry; +} - entry = ALLOC(rb_subclass_entry_t); - entry->klass = iclass; - entry->next = NULL; +void +rb_class_remove_subclass_head(VALUE klass) +{ + rb_subclass_entry_t *head = RCLASS_SUBCLASSES(klass); - head = RCLASS_SUBCLASSES(module); if (head) { - entry->next = head; - RCLASS_MODULE_SUBCLASSES(head->klass) = &entry->next; + if (head->next) { + head->next->prev = NULL; + } + RCLASS_SUBCLASSES(klass) = NULL; + xfree(head); } - - RCLASS_SUBCLASSES(module) = entry; - RCLASS_MODULE_SUBCLASSES(iclass) = &RCLASS_SUBCLASSES(module); } void rb_class_remove_from_super_subclasses(VALUE klass) { - rb_subclass_entry_t *entry; + rb_subclass_entry_t *entry = RCLASS_SUBCLASS_ENTRY(klass); - if (RCLASS_PARENT_SUBCLASSES(klass)) { - entry = *RCLASS_PARENT_SUBCLASSES(klass); + if (entry) { + rb_subclass_entry_t *prev = entry->prev, *next = entry->next; + + if (prev) { + prev->next = next; + } + if (next) { + next->prev = prev; + } - *RCLASS_PARENT_SUBCLASSES(klass) = entry->next; - if (entry->next) { - RCLASS_PARENT_SUBCLASSES(entry->next->klass) = RCLASS_PARENT_SUBCLASSES(klass); - } - xfree(entry); + xfree(entry); } - RCLASS_PARENT_SUBCLASSES(klass) = NULL; + RCLASS_SUBCLASS_ENTRY(klass) = NULL; } void rb_class_remove_from_module_subclasses(VALUE klass) { - rb_subclass_entry_t *entry; + rb_subclass_entry_t *entry = RCLASS_MODULE_SUBCLASS_ENTRY(klass); - if (RCLASS_MODULE_SUBCLASSES(klass)) { - entry = *RCLASS_MODULE_SUBCLASSES(klass); - *RCLASS_MODULE_SUBCLASSES(klass) = entry->next; + if (entry) { + rb_subclass_entry_t *prev = entry->prev, *next = entry->next; - if (entry->next) { - RCLASS_MODULE_SUBCLASSES(entry->next->klass) = RCLASS_MODULE_SUBCLASSES(klass); - } + if (prev) { + prev->next = next; + } + if (next) { + next->prev = prev; + } - xfree(entry); + xfree(entry); } - RCLASS_MODULE_SUBCLASSES(klass) = NULL; + RCLASS_MODULE_SUBCLASS_ENTRY(klass) = NULL; } void rb_class_foreach_subclass(VALUE klass, void (*f)(VALUE, VALUE), VALUE arg) { + // RCLASS_SUBCLASSES should always point to our head element which has NULL klass rb_subclass_entry_t *cur = RCLASS_SUBCLASSES(klass); + // if we have a subclasses list, then the head is a placeholder with no valid + // class. So ignore it and use the next element in the list (if one exists) + if (cur) { + RUBY_ASSERT(!cur->klass); + cur = cur->next; + } /* do not be tempted to simplify this loop into a for loop, the order of operations is important here if `f` modifies the linked list */ while (cur) { - VALUE curklass = cur->klass; - cur = cur->next; - f(curklass, arg); + VALUE curklass = cur->klass; + cur = cur->next; + // do not trigger GC during f, otherwise the cur will become + // a dangling pointer if the subclass is collected + f(curklass, arg); } } @@ -164,35 +226,27 @@ rb_class_detach_module_subclasses(VALUE klass) /** * Allocates a struct RClass for a new class. * - * \param flags initial value for basic.flags of the returned class. - * \param klass the class of the returned class. - * \return an uninitialized Class object. - * \pre \p klass must refer \c Class class or an ancestor of Class. - * \pre \code (flags | T_CLASS) != 0 \endcode - * \post the returned class can safely be \c #initialize 'd. + * @param flags initial value for basic.flags of the returned class. + * @param klass the class of the returned class. + * @return an uninitialized Class object. + * @pre `klass` must refer `Class` class or an ancestor of Class. + * @pre `(flags | T_CLASS) != 0` + * @post the returned class can safely be `#initialize` 'd. * - * \note this function is not Class#allocate. + * @note this function is not Class#allocate. */ static VALUE class_alloc(VALUE flags, VALUE klass) { - size_t payload_size = 0; - -#if USE_RVARGC - payload_size = sizeof(rb_classext_t); -#endif + size_t alloc_size = sizeof(struct RClass) + sizeof(rb_classext_t); - RVARGC_NEWOBJ_OF(obj, struct RClass, klass, (flags & T_MASK) | FL_PROMOTED1 /* start from age == 2 */ | (RGENGC_WB_PROTECTED_CLASS ? FL_WB_PROTECTED : 0), payload_size); + flags &= T_MASK; + if (RGENGC_WB_PROTECTED_CLASS) flags |= FL_WB_PROTECTED; + NEWOBJ_OF(obj, struct RClass, klass, flags, alloc_size, 0); -#if USE_RVARGC - obj->ptr = (rb_classext_t *)rb_rvargc_payload_data_ptr((VALUE)obj + rb_slot_size()); - RB_OBJ_WRITTEN(obj, Qundef, (VALUE)obj + rb_slot_size()); -#else - obj->ptr = ZALLOC(rb_classext_t); -#endif + memset(RCLASS_EXT(obj), 0, sizeof(rb_classext_t)); /* ZALLOC - RCLASS_IV_TBL(obj) = 0; RCLASS_CONST_TBL(obj) = 0; RCLASS_M_TBL(obj) = 0; RCLASS_IV_INDEX_TBL(obj) = 0; @@ -202,9 +256,8 @@ class_alloc(VALUE flags, VALUE klass) RCLASS_MODULE_SUBCLASSES(obj) = NULL; */ RCLASS_SET_ORIGIN((VALUE)obj, (VALUE)obj); - RCLASS_SERIAL(obj) = rb_next_class_serial(); RB_OBJ_WRITE(obj, &RCLASS_REFINED_CLASS(obj), Qnil); - RCLASS_ALLOCATOR(obj) = 0; + RCLASS_SET_ALLOCATOR((VALUE)obj, 0); return (VALUE)obj; } @@ -215,14 +268,14 @@ RCLASS_M_TBL_INIT(VALUE c) RCLASS_M_TBL(c) = rb_id_table_create(0); } -/*! +/** * A utility function that wraps class_alloc. * * allocates a class and initializes safely. - * \param super a class from which the new class derives. - * \return a class object. - * \pre \a super must be a class. - * \post the metaclass of the new class is Class. + * @param super a class from which the new class derives. + * @return a class object. + * @pre `super` must be a class. + * @post the metaclass of the new class is Class. */ VALUE rb_class_boot(VALUE super) @@ -235,53 +288,103 @@ rb_class_boot(VALUE super) return (VALUE)klass; } +static VALUE * +class_superclasses_including_self(VALUE klass) +{ + if (FL_TEST_RAW(klass, RCLASS_SUPERCLASSES_INCLUDE_SELF)) + return RCLASS_SUPERCLASSES(klass); + + size_t depth = RCLASS_SUPERCLASS_DEPTH(klass); + VALUE *superclasses = xmalloc(sizeof(VALUE) * (depth + 1)); + if (depth > 0) + memcpy(superclasses, RCLASS_SUPERCLASSES(klass), sizeof(VALUE) * depth); + superclasses[depth] = klass; + + RCLASS_SUPERCLASSES(klass) = superclasses; + FL_SET_RAW(klass, RCLASS_SUPERCLASSES_INCLUDE_SELF); + return superclasses; +} + +void +rb_class_update_superclasses(VALUE klass) +{ + VALUE super = RCLASS_SUPER(klass); + + if (!RB_TYPE_P(klass, T_CLASS)) return; + if (UNDEF_P(super)) return; + + // If the superclass array is already built + if (RCLASS_SUPERCLASSES(klass)) + return; + + // find the proper superclass + while (super != Qfalse && !RB_TYPE_P(super, T_CLASS)) { + super = RCLASS_SUPER(super); + } + + // For BasicObject and uninitialized classes, depth=0 and ary=NULL + if (super == Qfalse) + return; + + // Sometimes superclasses are set before the full ancestry tree is built + // This happens during metaclass construction + if (super != rb_cBasicObject && !RCLASS_SUPERCLASS_DEPTH(super)) { + rb_class_update_superclasses(super); + + // If it is still unset we need to try later + if (!RCLASS_SUPERCLASS_DEPTH(super)) + return; + } + + RCLASS_SUPERCLASSES(klass) = class_superclasses_including_self(super); + RCLASS_SUPERCLASS_DEPTH(klass) = RCLASS_SUPERCLASS_DEPTH(super) + 1; +} -/*! - * Ensures a class can be derived from super. - * - * \param super a reference to an object. - * \exception TypeError if \a super is not a Class or \a super is a singleton class. - */ void rb_check_inheritable(VALUE super) { if (!RB_TYPE_P(super, T_CLASS)) { rb_raise(rb_eTypeError, "superclass must be an instance of Class (given an instance of %"PRIsVALUE")", - rb_obj_class(super)); + rb_obj_class(super)); } - if (RBASIC(super)->flags & FL_SINGLETON) { - rb_raise(rb_eTypeError, "can't make subclass of singleton class"); + if (RCLASS_SINGLETON_P(super)) { + rb_raise(rb_eTypeError, "can't make subclass of singleton class"); } if (super == rb_cClass) { - rb_raise(rb_eTypeError, "can't make subclass of Class"); + rb_raise(rb_eTypeError, "can't make subclass of Class"); } } - -/*! - * Creates a new class. - * \param super a class from which the new class derives. - * \exception TypeError \a super is not inheritable. - * \exception TypeError \a super is the Class class. - */ VALUE rb_class_new(VALUE super) { Check_Type(super, T_CLASS); rb_check_inheritable(super); - return rb_class_boot(super); + VALUE klass = rb_class_boot(super); + + if (super != rb_cObject && super != rb_cBasicObject) { + RCLASS_EXT(klass)->max_iv_count = RCLASS_EXT(super)->max_iv_count; + } + + return klass; +} + +VALUE +rb_class_s_alloc(VALUE klass) +{ + return rb_class_boot(0); } static void clone_method(VALUE old_klass, VALUE new_klass, ID mid, const rb_method_entry_t *me) { if (me->def->type == VM_METHOD_TYPE_ISEQ) { - rb_cref_t *new_cref; - rb_vm_rewrite_cref(me->def->body.iseq.cref, old_klass, new_klass, &new_cref); - rb_add_method_iseq(new_klass, mid, me->def->body.iseq.iseqptr, new_cref, METHOD_ENTRY_VISI(me)); + rb_cref_t *new_cref; + rb_vm_rewrite_cref(me->def->body.iseq.cref, old_klass, new_klass, &new_cref); + rb_add_method_iseq(new_klass, mid, me->def->body.iseq.iseqptr, new_cref, METHOD_ENTRY_VISI(me)); } else { - rb_method_entry_set(new_klass, mid, me, METHOD_ENTRY_VISI(me)); + rb_method_entry_set(new_klass, mid, me, METHOD_ENTRY_VISI(me)); } } @@ -325,77 +428,141 @@ static void class_init_copy_check(VALUE clone, VALUE orig) { if (orig == rb_cBasicObject) { - rb_raise(rb_eTypeError, "can't copy the root class"); + rb_raise(rb_eTypeError, "can't copy the root class"); } if (RCLASS_SUPER(clone) != 0 || clone == rb_cBasicObject) { - rb_raise(rb_eTypeError, "already initialized class"); + rb_raise(rb_eTypeError, "already initialized class"); } - if (FL_TEST(orig, FL_SINGLETON)) { - rb_raise(rb_eTypeError, "can't copy singleton class"); + if (RCLASS_SINGLETON_P(orig)) { + rb_raise(rb_eTypeError, "can't copy singleton class"); } } +struct cvc_table_copy_ctx { + VALUE clone; + struct rb_id_table * new_table; +}; + +static enum rb_id_table_iterator_result +cvc_table_copy(ID id, VALUE val, void *data) +{ + struct cvc_table_copy_ctx *ctx = (struct cvc_table_copy_ctx *)data; + struct rb_cvar_class_tbl_entry * orig_entry; + orig_entry = (struct rb_cvar_class_tbl_entry *)val; + + struct rb_cvar_class_tbl_entry *ent; + + ent = ALLOC(struct rb_cvar_class_tbl_entry); + ent->class_value = ctx->clone; + ent->cref = orig_entry->cref; + ent->global_cvar_state = orig_entry->global_cvar_state; + rb_id_table_insert(ctx->new_table, id, (VALUE)ent); + + RB_OBJ_WRITTEN(ctx->clone, Qundef, ent->cref); + + return ID_TABLE_CONTINUE; +} + static void copy_tables(VALUE clone, VALUE orig) { - if (RCLASS_IV_TBL(clone)) { - st_free_table(RCLASS_IV_TBL(clone)); - RCLASS_IV_TBL(clone) = 0; - } if (RCLASS_CONST_TBL(clone)) { - rb_free_const_table(RCLASS_CONST_TBL(clone)); - RCLASS_CONST_TBL(clone) = 0; + rb_free_const_table(RCLASS_CONST_TBL(clone)); + RCLASS_CONST_TBL(clone) = 0; + } + if (RCLASS_CVC_TBL(orig)) { + struct rb_id_table *rb_cvc_tbl = RCLASS_CVC_TBL(orig); + struct rb_id_table *rb_cvc_tbl_dup = rb_id_table_create(rb_id_table_size(rb_cvc_tbl)); + + struct cvc_table_copy_ctx ctx; + ctx.clone = clone; + ctx.new_table = rb_cvc_tbl_dup; + rb_id_table_foreach(rb_cvc_tbl, cvc_table_copy, &ctx); + RCLASS_CVC_TBL(clone) = rb_cvc_tbl_dup; } + rb_id_table_free(RCLASS_M_TBL(clone)); RCLASS_M_TBL(clone) = 0; - if (RCLASS_IV_TBL(orig)) { - st_data_t id; + if (!RB_TYPE_P(clone, T_ICLASS)) { + st_data_t id; - rb_iv_tbl_copy(clone, orig); - CONST_ID(id, "__tmp_classpath__"); - st_delete(RCLASS_IV_TBL(clone), &id, 0); - CONST_ID(id, "__classpath__"); - st_delete(RCLASS_IV_TBL(clone), &id, 0); - CONST_ID(id, "__classid__"); - st_delete(RCLASS_IV_TBL(clone), &id, 0); + rb_iv_tbl_copy(clone, orig); + CONST_ID(id, "__tmp_classpath__"); + rb_attr_delete(clone, id); + CONST_ID(id, "__classpath__"); + rb_attr_delete(clone, id); } if (RCLASS_CONST_TBL(orig)) { - struct clone_const_arg arg; + struct clone_const_arg arg; - arg.tbl = RCLASS_CONST_TBL(clone) = rb_id_table_create(0); - arg.klass = clone; - rb_id_table_foreach(RCLASS_CONST_TBL(orig), clone_const_i, &arg); + arg.tbl = RCLASS_CONST_TBL(clone) = rb_id_table_create(0); + arg.klass = clone; + rb_id_table_foreach(RCLASS_CONST_TBL(orig), clone_const_i, &arg); } } static bool ensure_origin(VALUE klass); +/** + * If this flag is set, that module is allocated but not initialized yet. + */ +enum {RMODULE_ALLOCATED_BUT_NOT_INITIALIZED = RUBY_FL_USER1}; + +static inline bool +RMODULE_UNINITIALIZED(VALUE module) +{ + return FL_TEST_RAW(module, RMODULE_ALLOCATED_BUT_NOT_INITIALIZED); +} + +void +rb_module_set_initialized(VALUE mod) +{ + FL_UNSET_RAW(mod, RMODULE_ALLOCATED_BUT_NOT_INITIALIZED); + /* no more re-initialization */ +} + +void +rb_module_check_initializable(VALUE mod) +{ + if (!RMODULE_UNINITIALIZED(mod)) { + rb_raise(rb_eTypeError, "already initialized module"); + } +} + /* :nodoc: */ VALUE rb_mod_init_copy(VALUE clone, VALUE orig) { - if (RB_TYPE_P(clone, T_CLASS)) { + switch (BUILTIN_TYPE(clone)) { + case T_CLASS: + case T_ICLASS: class_init_copy_check(clone, orig); + break; + case T_MODULE: + rb_module_check_initializable(clone); + break; + default: + break; } if (!OBJ_INIT_COPY(clone, orig)) return clone; /* cloned flag is refer at constant inline cache * see vm_get_const_key_cref() in vm_insnhelper.c */ - FL_SET(clone, RCLASS_CLONED); - FL_SET(orig , RCLASS_CLONED); + RCLASS_EXT(clone)->cloned = true; + RCLASS_EXT(orig)->cloned = true; - if (!FL_TEST(CLASS_OF(clone), FL_SINGLETON)) { + if (!RCLASS_SINGLETON_P(CLASS_OF(clone))) { RBASIC_SET_CLASS(clone, rb_singleton_class_clone(orig)); - rb_singleton_class_attached(RBASIC(clone)->klass, (VALUE)clone); + rb_singleton_class_attached(METACLASS_OF(clone), (VALUE)clone); } - RCLASS_ALLOCATOR(clone) = RCLASS_ALLOCATOR(orig); + RCLASS_SET_ALLOCATOR(clone, RCLASS_ALLOCATOR(orig)); copy_tables(clone, orig); if (RCLASS_M_TBL(orig)) { - struct clone_method_arg arg; - arg.old_klass = orig; - arg.new_klass = clone; - RCLASS_M_TBL_INIT(clone); - rb_id_table_foreach(RCLASS_M_TBL(orig), clone_method_i, &arg); + struct clone_method_arg arg; + arg.old_klass = orig; + arg.new_klass = clone; + RCLASS_M_TBL_INIT(clone); + rb_id_table_foreach(RCLASS_M_TBL(orig), clone_method_i, &arg); } if (RCLASS_ORIGIN(orig) == orig) { @@ -405,7 +572,7 @@ rb_mod_init_copy(VALUE clone, VALUE orig) VALUE p = RCLASS_SUPER(orig); VALUE orig_origin = RCLASS_ORIGIN(orig); VALUE prev_clone_p = clone; - VALUE origin_stack = rb_ary_tmp_new(2); + VALUE origin_stack = rb_ary_hidden_new(2); VALUE origin[2]; VALUE clone_p = 0; long origin_len; @@ -419,13 +586,15 @@ rb_mod_init_copy(VALUE clone, VALUE orig) if (BUILTIN_TYPE(p) != T_ICLASS) { rb_bug("non iclass between module/class and origin"); } - clone_p = class_alloc(RBASIC(p)->flags, RBASIC(p)->klass); + clone_p = class_alloc(RBASIC(p)->flags, METACLASS_OF(p)); + /* We should set the m_tbl right after allocation before anything + * that can trigger GC to avoid clone_p from becoming old and + * needing to fire write barriers. */ + RCLASS_SET_M_TBL(clone_p, RCLASS_M_TBL(p)); RCLASS_SET_SUPER(prev_clone_p, clone_p); prev_clone_p = clone_p; - RCLASS_M_TBL(clone_p) = RCLASS_M_TBL(p); RCLASS_CONST_TBL(clone_p) = RCLASS_CONST_TBL(p); - RCLASS_IV_TBL(clone_p) = RCLASS_IV_TBL(p); - RCLASS_ALLOCATOR(clone_p) = RCLASS_ALLOCATOR(p); + RCLASS_SET_ALLOCATOR(clone_p, RCLASS_ALLOCATOR(p)); if (RB_TYPE_P(clone, T_CLASS)) { RCLASS_SET_INCLUDER(clone_p, clone); } @@ -443,7 +612,7 @@ rb_mod_init_copy(VALUE clone, VALUE orig) add_subclass = FALSE; } if (add_subclass) { - rb_module_add_to_subclasses_list(RBASIC(p)->klass, clone_p); + rb_module_add_to_subclasses_list(METACLASS_OF(p), clone_p); } p = RCLASS_SUPER(p); } @@ -465,6 +634,8 @@ rb_mod_init_copy(VALUE clone, VALUE orig) else { rb_bug("no origin for class that has origin"); } + + rb_class_update_superclasses(clone); } return clone; @@ -480,72 +651,65 @@ rb_singleton_class_clone(VALUE obj) VALUE rb_singleton_class_clone_and_attach(VALUE obj, VALUE attach) { - const VALUE klass = RBASIC(obj)->klass; + const VALUE klass = METACLASS_OF(obj); // Note that `rb_singleton_class()` can create situations where `klass` is // attached to an object other than `obj`. In which case `obj` does not have // a material singleton class attached yet and there is no singleton class // to clone. - if (!(FL_TEST(klass, FL_SINGLETON) && rb_attr_get(klass, id_attached) == obj)) { + if (!(RCLASS_SINGLETON_P(klass) && RCLASS_ATTACHED_OBJECT(klass) == obj)) { // nothing to clone return klass; } else { - /* copy singleton(unnamed) class */ + /* copy singleton(unnamed) class */ bool klass_of_clone_is_new; - VALUE clone = class_alloc(RBASIC(klass)->flags, 0); + VALUE clone = class_alloc(RBASIC(klass)->flags, 0); - if (BUILTIN_TYPE(obj) == T_CLASS) { + if (BUILTIN_TYPE(obj) == T_CLASS) { klass_of_clone_is_new = true; - RBASIC_SET_CLASS(clone, clone); - } - else { + RBASIC_SET_CLASS(clone, clone); + } + else { VALUE klass_metaclass_clone = rb_singleton_class_clone(klass); // When `METACLASS_OF(klass) == klass_metaclass_clone`, it means the // recursive call did not clone `METACLASS_OF(klass)`. klass_of_clone_is_new = (METACLASS_OF(klass) != klass_metaclass_clone); RBASIC_SET_CLASS(clone, klass_metaclass_clone); - } - - RCLASS_SET_SUPER(clone, RCLASS_SUPER(klass)); - RCLASS_ALLOCATOR(clone) = RCLASS_ALLOCATOR(klass); - if (RCLASS_IV_TBL(klass)) { - rb_iv_tbl_copy(clone, klass); - } - if (RCLASS_CONST_TBL(klass)) { - struct clone_const_arg arg; - arg.tbl = RCLASS_CONST_TBL(clone) = rb_id_table_create(0); - arg.klass = clone; - rb_id_table_foreach(RCLASS_CONST_TBL(klass), clone_const_i, &arg); - } - if (attach != Qundef) { - rb_singleton_class_attached(clone, attach); - } - RCLASS_M_TBL_INIT(clone); - { - struct clone_method_arg arg; - arg.old_klass = klass; - arg.new_klass = clone; - rb_id_table_foreach(RCLASS_M_TBL(klass), clone_method_i, &arg); - } + } + + RCLASS_SET_SUPER(clone, RCLASS_SUPER(klass)); + rb_iv_tbl_copy(clone, klass); + if (RCLASS_CONST_TBL(klass)) { + struct clone_const_arg arg; + arg.tbl = RCLASS_CONST_TBL(clone) = rb_id_table_create(0); + arg.klass = clone; + rb_id_table_foreach(RCLASS_CONST_TBL(klass), clone_const_i, &arg); + } + if (!UNDEF_P(attach)) { + rb_singleton_class_attached(clone, attach); + } + RCLASS_M_TBL_INIT(clone); + { + struct clone_method_arg arg; + arg.old_klass = klass; + arg.new_klass = clone; + rb_id_table_foreach(RCLASS_M_TBL(klass), clone_method_i, &arg); + } if (klass_of_clone_is_new) { - rb_singleton_class_attached(RBASIC(clone)->klass, clone); + rb_singleton_class_attached(METACLASS_OF(clone), clone); } - FL_SET(clone, FL_SINGLETON); + FL_SET(clone, FL_SINGLETON); - return clone; + return clone; } } -/*! - * Attach a object to a singleton class. - * @pre \a klass is the singleton class of \a obj. - */ void rb_singleton_class_attached(VALUE klass, VALUE obj) { - if (FL_TEST(klass, FL_SINGLETON)) { - rb_class_ivar_set(klass, id_attached, obj); + if (RCLASS_SINGLETON_P(klass)) { + RCLASS_SET_ATTACHED_OBJECT(klass, obj); } } @@ -559,17 +723,17 @@ rb_singleton_class_attached(VALUE klass, VALUE obj) static int rb_singleton_class_has_metaclass_p(VALUE sklass) { - return rb_attr_get(METACLASS_OF(sklass), id_attached) == sklass; + return RCLASS_ATTACHED_OBJECT(METACLASS_OF(sklass)) == sklass; } int rb_singleton_class_internal_p(VALUE sklass) { - return (RB_TYPE_P(rb_attr_get(sklass, id_attached), T_CLASS) && - !rb_singleton_class_has_metaclass_p(sklass)); + return (RB_TYPE_P(RCLASS_ATTACHED_OBJECT(sklass), T_CLASS) && + !rb_singleton_class_has_metaclass_p(sklass)); } -/*! +/** * whether k has a metaclass * @retval 1 if \a k has a metaclass * @retval 0 otherwise @@ -578,25 +742,25 @@ rb_singleton_class_internal_p(VALUE sklass) (FL_TEST(METACLASS_OF(k), FL_SINGLETON) && \ rb_singleton_class_has_metaclass_p(k)) -/*! - * ensures \a klass belongs to its own eigenclass. - * @return the eigenclass of \a klass - * @post \a klass belongs to the returned eigenclass. - * i.e. the attached object of the eigenclass is \a klass. +/** + * ensures `klass` belongs to its own eigenclass. + * @return the eigenclass of `klass` + * @post `klass` belongs to the returned eigenclass. + * i.e. the attached object of the eigenclass is `klass`. * @note this macro creates a new eigenclass if necessary. */ #define ENSURE_EIGENCLASS(klass) \ (HAVE_METACLASS_P(klass) ? METACLASS_OF(klass) : make_metaclass(klass)) -/*! - * Creates a metaclass of \a klass - * \param klass a class - * \return created metaclass for the class - * \pre \a klass is a Class object - * \pre \a klass has no singleton class. - * \post the class of \a klass is the returned class. - * \post the returned class is meta^(n+1)-class when \a klass is a meta^(n)-klass for n >= 0 +/** + * Creates a metaclass of `klass` + * @param klass a class + * @return created metaclass for the class + * @pre `klass` is a Class object + * @pre `klass` has no singleton class. + * @post the class of `klass` is the returned class. + * @post the returned class is meta^(n+1)-class when `klass` is a meta^(n)-klass for n >= 0 */ static inline VALUE make_metaclass(VALUE klass) @@ -608,37 +772,41 @@ make_metaclass(VALUE klass) rb_singleton_class_attached(metaclass, klass); if (META_CLASS_OF_CLASS_CLASS_P(klass)) { - SET_METACLASS_OF(klass, metaclass); - SET_METACLASS_OF(metaclass, metaclass); + SET_METACLASS_OF(klass, metaclass); + SET_METACLASS_OF(metaclass, metaclass); } else { - VALUE tmp = METACLASS_OF(klass); /* for a meta^(n)-class klass, tmp is meta^(n)-class of Class class */ - SET_METACLASS_OF(klass, metaclass); - SET_METACLASS_OF(metaclass, ENSURE_EIGENCLASS(tmp)); + VALUE tmp = METACLASS_OF(klass); /* for a meta^(n)-class klass, tmp is meta^(n)-class of Class class */ + SET_METACLASS_OF(klass, metaclass); + SET_METACLASS_OF(metaclass, ENSURE_EIGENCLASS(tmp)); } super = RCLASS_SUPER(klass); while (RB_TYPE_P(super, T_ICLASS)) super = RCLASS_SUPER(super); RCLASS_SET_SUPER(metaclass, super ? ENSURE_EIGENCLASS(super) : rb_cClass); + // Full class ancestry may not have been filled until we reach here. + rb_class_update_superclasses(METACLASS_OF(metaclass)); + return metaclass; } -/*! - * Creates a singleton class for \a obj. - * \pre \a obj must not a immediate nor a special const. - * \pre \a obj must not a Class object. - * \pre \a obj has no singleton class. +/** + * Creates a singleton class for `obj`. + * @pre `obj` must not be an immediate nor a special const. + * @pre `obj` must not be a Class object. + * @pre `obj` has no singleton class. */ static inline VALUE make_singleton_class(VALUE obj) { - VALUE orig_class = RBASIC(obj)->klass; + VALUE orig_class = METACLASS_OF(obj); VALUE klass = rb_class_boot(orig_class); FL_SET(klass, FL_SINGLETON); RBASIC_SET_CLASS(obj, klass); rb_singleton_class_attached(klass, obj); + rb_yjit_invalidate_no_singleton_class(orig_class); SET_METACLASS_OF(klass, METACLASS_OF(rb_class_real(orig_class))); return klass; @@ -652,63 +820,134 @@ boot_defclass(const char *name, VALUE super) ID id = rb_intern(name); rb_const_set((rb_cObject ? rb_cObject : obj), id, obj); - rb_vm_add_root_module(obj); + rb_vm_register_global_object(obj); return obj; } +/*********************************************************************** + * + * Document-class: Refinement + * + * Refinement is a class of the +self+ (current context) inside +refine+ + * statement. It allows to import methods from other modules, see #import_methods. + */ + +#if 0 /* for RDoc */ +/* + * Document-method: Refinement#import_methods + * + * call-seq: + * import_methods(module, ...) -> self + * + * Imports methods from modules. Unlike Module#include, + * Refinement#import_methods copies methods and adds them into the refinement, + * so the refinement is activated in the imported methods. + * + * Note that due to method copying, only methods defined in Ruby code can be imported. + * + * module StrUtils + * def indent(level) + * ' ' * level + self + * end + * end + * + * module M + * refine String do + * import_methods StrUtils + * end + * end + * + * using M + * "foo".indent(3) + * #=> " foo" + * + * module M + * refine String do + * import_methods Enumerable + * # Can't import method which is not defined with Ruby code: Enumerable#drop + * end + * end + * + */ + +static VALUE +refinement_import_methods(int argc, VALUE *argv, VALUE refinement) +{ +} +# endif + +/*! + *-- + * \private + * Initializes the world of objects and classes. + * + * At first, the function bootstraps the class hierarchy. + * It initializes the most fundamental classes and their metaclasses. + * - \c BasicObject + * - \c Object + * - \c Module + * - \c Class + * After the bootstrap step, the class hierarchy becomes as the following + * diagram. + * + * \image html boottime-classes.png + * + * Then, the function defines classes, modules and methods as usual. + * \ingroup class + *++ + */ + void Init_class_hierarchy(void) { rb_cBasicObject = boot_defclass("BasicObject", 0); rb_cObject = boot_defclass("Object", rb_cBasicObject); - rb_gc_register_mark_object(rb_cObject); + rb_vm_register_global_object(rb_cObject); /* resolve class name ASAP for order-independence */ rb_set_class_path_string(rb_cObject, rb_cObject, rb_fstring_lit("Object")); rb_cModule = boot_defclass("Module", rb_cObject); rb_cClass = boot_defclass("Class", rb_cModule); + rb_cRefinement = boot_defclass("Refinement", rb_cModule); + +#if 0 /* for RDoc */ + // we pretend it to be public, otherwise RDoc will ignore it + rb_define_method(rb_cRefinement, "import_methods", refinement_import_methods, -1); +#endif rb_const_set(rb_cObject, rb_intern_const("BasicObject"), rb_cBasicObject); RBASIC_SET_CLASS(rb_cClass, rb_cClass); RBASIC_SET_CLASS(rb_cModule, rb_cClass); RBASIC_SET_CLASS(rb_cObject, rb_cClass); + RBASIC_SET_CLASS(rb_cRefinement, rb_cClass); RBASIC_SET_CLASS(rb_cBasicObject, rb_cClass); + + ENSURE_EIGENCLASS(rb_cRefinement); } -/*! - * \internal +/** + * @internal * Creates a new *singleton class* for an object. * - * \pre \a obj has no singleton class. - * \note DO NOT USE the function in an extension libraries. Use \ref rb_singleton_class. - * \param obj An object. - * \param unused ignored. - * \return The singleton class of the object. + * @pre `obj` has no singleton class. + * @note DO NOT USE the function in an extension libraries. Use @ref rb_singleton_class. + * @param obj An object. + * @param unused ignored. + * @return The singleton class of the object. */ VALUE rb_make_metaclass(VALUE obj, VALUE unused) { if (BUILTIN_TYPE(obj) == T_CLASS) { - return make_metaclass(obj); + return make_metaclass(obj); } else { - return make_singleton_class(obj); + return make_singleton_class(obj); } } - -/*! - * Defines a new class. - * \param id ignored - * \param super A class from which the new class will derive. NULL means \c Object class. - * \return the created class - * \throw TypeError if super is not a \c Class object. - * - * \note the returned class will not be associated with \a id. - * You must explicitly set a class name if necessary. - */ VALUE rb_define_class_id(ID id, VALUE super) { @@ -716,21 +955,21 @@ rb_define_class_id(ID id, VALUE super) if (!super) super = rb_cObject; klass = rb_class_new(super); - rb_make_metaclass(klass, RBASIC(super)->klass); + rb_make_metaclass(klass, METACLASS_OF(super)); return klass; } -/*! +/** * Calls Class#inherited. - * \param super A class which will be called #inherited. + * @param super A class which will be called #inherited. * NULL means Object class. - * \param klass A Class object which derived from \a super - * \return the value \c Class#inherited's returns - * \pre Each of \a super and \a klass must be a \c Class object. + * @param klass A Class object which derived from `super` + * @return the value `Class#inherited` returns + * @pre Each of `super` and `klass` must be a `Class` object. */ -MJIT_FUNC_EXPORTED VALUE +VALUE rb_class_inherited(VALUE super, VALUE klass) { ID inherited; @@ -739,23 +978,6 @@ rb_class_inherited(VALUE super, VALUE klass) return rb_funcall(super, inherited, 1, klass); } - - -/*! - * Defines a top-level class. - * \param name name of the class - * \param super a class from which the new class will derive. - * \return the created class - * \throw TypeError if the constant name \a name is already taken but - * the constant is not a \c Class. - * \throw TypeError if the class is already defined but the class can not - * be reopened because its superclass is not \a super. - * \throw ArgumentError if the \a super is NULL. - * \post top-level constant named \a name refers the returned class. - * - * \note if a class named \a name is already defined and its superclass is - * \a super, the function just returns the defined class. - */ VALUE rb_define_class(const char *name, VALUE super) { @@ -764,116 +986,106 @@ rb_define_class(const char *name, VALUE super) id = rb_intern(name); if (rb_const_defined(rb_cObject, id)) { - klass = rb_const_get(rb_cObject, id); - if (!RB_TYPE_P(klass, T_CLASS)) { - rb_raise(rb_eTypeError, "%s is not a class (%"PRIsVALUE")", - name, rb_obj_class(klass)); - } - if (rb_class_real(RCLASS_SUPER(klass)) != super) { - rb_raise(rb_eTypeError, "superclass mismatch for class %s", name); - } + klass = rb_const_get(rb_cObject, id); + if (!RB_TYPE_P(klass, T_CLASS)) { + rb_raise(rb_eTypeError, "%s is not a class (%"PRIsVALUE")", + name, rb_obj_class(klass)); + } + if (rb_class_real(RCLASS_SUPER(klass)) != super) { + rb_raise(rb_eTypeError, "superclass mismatch for class %s", name); + } /* Class may have been defined in Ruby and not pin-rooted */ - rb_vm_add_root_module(klass); - return klass; + rb_vm_register_global_object(klass); + return klass; } if (!super) { - rb_raise(rb_eArgError, "no super class for `%s'", name); + rb_raise(rb_eArgError, "no super class for '%s'", name); } klass = rb_define_class_id(id, super); - rb_vm_add_root_module(klass); + rb_vm_register_global_object(klass); rb_const_set(rb_cObject, id, klass); rb_class_inherited(super, klass); return klass; } - -/*! - * Defines a class under the namespace of \a outer. - * \param outer a class which contains the new class. - * \param name name of the new class - * \param super a class from which the new class will derive. - * NULL means \c Object class. - * \return the created class - * \throw TypeError if the constant name \a name is already taken but - * the constant is not a \c Class. - * \throw TypeError if the class is already defined but the class can not - * be reopened because its superclass is not \a super. - * \post top-level constant named \a name refers the returned class. - * - * \note if a class named \a name is already defined and its superclass is - * \a super, the function just returns the defined class. - * \note the compaction GC does not move classes returned by this function. - */ VALUE rb_define_class_under(VALUE outer, const char *name, VALUE super) { return rb_define_class_id_under(outer, rb_intern(name), super); } - -/*! - * Defines a class under the namespace of \a outer. - * \param outer a class which contains the new class. - * \param id name of the new class - * \param super a class from which the new class will derive. - * NULL means \c Object class. - * \return the created class - * \throw TypeError if the constant name \a name is already taken but - * the constant is not a \c Class. - * \throw TypeError if the class is already defined but the class can not - * be reopened because its superclass is not \a super. - * \post top-level constant named \a name refers the returned class. - * - * \note if a class named \a name is already defined and its superclass is - * \a super, the function just returns the defined class. - * \note the compaction GC does not move classes returned by this function. - */ VALUE -rb_define_class_id_under(VALUE outer, ID id, VALUE super) +rb_define_class_id_under_no_pin(VALUE outer, ID id, VALUE super) { VALUE klass; if (rb_const_defined_at(outer, id)) { - klass = rb_const_get_at(outer, id); - if (!RB_TYPE_P(klass, T_CLASS)) { - rb_raise(rb_eTypeError, "%"PRIsVALUE"::%"PRIsVALUE" is not a class" - " (%"PRIsVALUE")", - outer, rb_id2str(id), rb_obj_class(klass)); - } - if (rb_class_real(RCLASS_SUPER(klass)) != super) { - rb_raise(rb_eTypeError, "superclass mismatch for class " - "%"PRIsVALUE"::%"PRIsVALUE"" - " (%"PRIsVALUE" is given but was %"PRIsVALUE")", - outer, rb_id2str(id), RCLASS_SUPER(klass), super); - } - /* Class may have been defined in Ruby and not pin-rooted */ - rb_vm_add_root_module(klass); + klass = rb_const_get_at(outer, id); + if (!RB_TYPE_P(klass, T_CLASS)) { + rb_raise(rb_eTypeError, "%"PRIsVALUE"::%"PRIsVALUE" is not a class" + " (%"PRIsVALUE")", + outer, rb_id2str(id), rb_obj_class(klass)); + } + if (rb_class_real(RCLASS_SUPER(klass)) != super) { + rb_raise(rb_eTypeError, "superclass mismatch for class " + "%"PRIsVALUE"::%"PRIsVALUE"" + " (%"PRIsVALUE" is given but was %"PRIsVALUE")", + outer, rb_id2str(id), RCLASS_SUPER(klass), super); + } - return klass; + return klass; } if (!super) { - rb_raise(rb_eArgError, "no super class for `%"PRIsVALUE"::%"PRIsVALUE"'", - rb_class_path(outer), rb_id2str(id)); + rb_raise(rb_eArgError, "no super class for '%"PRIsVALUE"::%"PRIsVALUE"'", + rb_class_path(outer), rb_id2str(id)); } klass = rb_define_class_id(id, super); rb_set_class_path_string(klass, outer, rb_id2str(id)); rb_const_set(outer, id, klass); rb_class_inherited(super, klass); - rb_vm_add_root_module(klass); return klass; } VALUE -rb_module_new(void) +rb_define_class_id_under(VALUE outer, ID id, VALUE super) +{ + VALUE klass = rb_define_class_id_under_no_pin(outer, id, super); + rb_vm_register_global_object(klass); + return klass; +} + +VALUE +rb_module_s_alloc(VALUE klass) +{ + VALUE mod = class_alloc(T_MODULE, klass); + RCLASS_M_TBL_INIT(mod); + FL_SET(mod, RMODULE_ALLOCATED_BUT_NOT_INITIALIZED); + return mod; +} + +static inline VALUE +module_new(VALUE klass) { - VALUE mdl = class_alloc(T_MODULE, rb_cModule); + VALUE mdl = class_alloc(T_MODULE, klass); RCLASS_M_TBL_INIT(mdl); return (VALUE)mdl; } +VALUE +rb_module_new(void) +{ + return module_new(rb_cModule); +} + +VALUE +rb_refinement_new(void) +{ + return module_new(rb_cRefinement); +} + // Kept for compatibility. Use rb_module_new() instead. VALUE rb_define_module_id(ID id) @@ -881,9 +1093,6 @@ rb_define_module_id(ID id) return rb_module_new(); } -/*! - * \note the compaction GC does not move modules returned by this function. - */ VALUE rb_define_module(const char *name) { @@ -892,25 +1101,22 @@ rb_define_module(const char *name) id = rb_intern(name); if (rb_const_defined(rb_cObject, id)) { - module = rb_const_get(rb_cObject, id); - if (!RB_TYPE_P(module, T_MODULE)) { - rb_raise(rb_eTypeError, "%s is not a module (%"PRIsVALUE")", - name, rb_obj_class(module)); - } + module = rb_const_get(rb_cObject, id); + if (!RB_TYPE_P(module, T_MODULE)) { + rb_raise(rb_eTypeError, "%s is not a module (%"PRIsVALUE")", + name, rb_obj_class(module)); + } /* Module may have been defined in Ruby and not pin-rooted */ - rb_vm_add_root_module(module); - return module; + rb_vm_register_global_object(module); + return module; } module = rb_module_new(); - rb_vm_add_root_module(module); + rb_vm_register_global_object(module); rb_const_set(rb_cObject, id, module); return module; } -/*! - * \note the compaction GC does not move modules returned by this function. - */ VALUE rb_define_module_under(VALUE outer, const char *name) { @@ -923,20 +1129,20 @@ rb_define_module_id_under(VALUE outer, ID id) VALUE module; if (rb_const_defined_at(outer, id)) { - module = rb_const_get_at(outer, id); - if (!RB_TYPE_P(module, T_MODULE)) { - rb_raise(rb_eTypeError, "%"PRIsVALUE"::%"PRIsVALUE" is not a module" - " (%"PRIsVALUE")", - outer, rb_id2str(id), rb_obj_class(module)); - } + module = rb_const_get_at(outer, id); + if (!RB_TYPE_P(module, T_MODULE)) { + rb_raise(rb_eTypeError, "%"PRIsVALUE"::%"PRIsVALUE" is not a module" + " (%"PRIsVALUE")", + outer, rb_id2str(id), rb_obj_class(module)); + } /* Module may have been defined in Ruby and not pin-rooted */ - rb_gc_register_mark_object(module); - return module; + rb_vm_register_global_object(module); + return module; } module = rb_module_new(); rb_const_set(outer, id, module); rb_set_class_path_string(module, outer, rb_id2str(id)); - rb_gc_register_mark_object(module); + rb_vm_register_global_object(module); return module; } @@ -946,20 +1152,17 @@ rb_include_class_new(VALUE module, VALUE super) { VALUE klass = class_alloc(T_ICLASS, rb_cClass); - RCLASS_M_TBL(klass) = RCLASS_M_TBL(module); + RCLASS_SET_M_TBL(klass, RCLASS_M_TBL(module)); RCLASS_SET_ORIGIN(klass, klass); if (BUILTIN_TYPE(module) == T_ICLASS) { - module = RBASIC(module)->klass; + module = METACLASS_OF(module); } RUBY_ASSERT(!RB_TYPE_P(module, T_ICLASS)); - if (!RCLASS_IV_TBL(module)) { - RCLASS_IV_TBL(module) = st_init_numtable(); - } if (!RCLASS_CONST_TBL(module)) { - RCLASS_CONST_TBL(module) = rb_id_table_create(0); + RCLASS_CONST_TBL(module) = rb_id_table_create(0); } - RCLASS_IV_TBL(klass) = RCLASS_IV_TBL(module); + RCLASS_CVC_TBL(klass) = RCLASS_CVC_TBL(module); RCLASS_CONST_TBL(klass) = RCLASS_CONST_TBL(module); @@ -976,8 +1179,9 @@ ensure_includable(VALUE klass, VALUE module) { rb_class_modify_check(klass); Check_Type(module, T_MODULE); + rb_module_set_initialized(module); if (!NIL_P(rb_refinement_module_get_refined_class(module))) { - rb_raise(rb_eArgError, "refinement module is not allowed"); + rb_raise(rb_eArgError, "refinement module is not allowed"); } } @@ -990,24 +1194,37 @@ rb_include_module(VALUE klass, VALUE module) changed = include_modules_at(klass, RCLASS_ORIGIN(klass), module, TRUE); if (changed < 0) - rb_raise(rb_eArgError, "cyclic include detected"); + rb_raise(rb_eArgError, "cyclic include detected"); if (RB_TYPE_P(klass, T_MODULE)) { rb_subclass_entry_t *iclass = RCLASS_SUBCLASSES(klass); + // skip the placeholder subclass entry at the head of the list + if (iclass) { + RUBY_ASSERT(!iclass->klass); + iclass = iclass->next; + } + int do_include = 1; while (iclass) { VALUE check_class = iclass->klass; - while (check_class) { - if (RB_TYPE_P(check_class, T_ICLASS) && - (RBASIC(check_class)->klass == module)) { - do_include = 0; + /* During lazy sweeping, iclass->klass could be a dead object that + * has not yet been swept. */ + if (!rb_objspace_garbage_object_p(check_class)) { + while (check_class) { + RUBY_ASSERT(!rb_objspace_garbage_object_p(check_class)); + + if (RB_TYPE_P(check_class, T_ICLASS) && + (METACLASS_OF(check_class) == module)) { + do_include = 0; + } + check_class = RCLASS_SUPER(check_class); } - check_class = RCLASS_SUPER(check_class); - } - if (do_include) { - include_modules_at(iclass->klass, RCLASS_ORIGIN(iclass->klass), module, TRUE); + if (do_include) { + include_modules_at(iclass->klass, RCLASS_ORIGIN(iclass->klass), module, TRUE); + } } + iclass = iclass->next; } } @@ -1042,11 +1259,20 @@ module_in_super_chain(const VALUE klass, VALUE module) return false; } +// For each ID key in the class constant table, we're going to clear the VM's +// inline constant caches associated with it. +static enum rb_id_table_iterator_result +clear_constant_cache_i(ID id, VALUE value, void *data) +{ + rb_clear_constant_cache_for_id(id); + return ID_TABLE_CONTINUE; +} + static int do_include_modules_at(const VALUE klass, VALUE c, VALUE module, int search_super, bool check_cyclic) { VALUE p, iclass, origin_stack = 0; - int method_changed = 0, constant_changed = 0, add_subclass; + int method_changed = 0, add_subclass; long origin_len; VALUE klass_origin = RCLASS_ORIGIN(klass); VALUE original_klass = klass; @@ -1056,8 +1282,8 @@ do_include_modules_at(const VALUE klass, VALUE c, VALUE module, int search_super while (module) { int c_seen = FALSE; - int superclass_seen = FALSE; - struct rb_id_table *tbl; + int superclass_seen = FALSE; + struct rb_id_table *tbl; if (klass == c) { c_seen = TRUE; @@ -1107,12 +1333,12 @@ do_include_modules_at(const VALUE klass, VALUE c, VALUE module, int search_super } // setup T_ICLASS for the include/prepend module - iclass = rb_include_class_new(module, super_class); - c = RCLASS_SET_SUPER(c, iclass); + iclass = rb_include_class_new(module, super_class); + c = RCLASS_SET_SUPER(c, iclass); RCLASS_SET_INCLUDER(iclass, klass); add_subclass = TRUE; if (module != RCLASS_ORIGIN(module)) { - if (!origin_stack) origin_stack = rb_ary_tmp_new(2); + if (!origin_stack) origin_stack = rb_ary_hidden_new(2); VALUE origin[2] = {iclass, RCLASS_ORIGIN(module)}; rb_ary_cat(origin_stack, origin, 2); } @@ -1124,28 +1350,27 @@ do_include_modules_at(const VALUE klass, VALUE c, VALUE module, int search_super add_subclass = FALSE; } - { - VALUE m = module; - if (BUILTIN_TYPE(m) == T_ICLASS) m = RBASIC(m)->klass; - if (add_subclass) rb_module_add_to_subclasses_list(m, iclass); - } + if (add_subclass) { + VALUE m = module; + if (BUILTIN_TYPE(m) == T_ICLASS) m = METACLASS_OF(m); + rb_module_add_to_subclasses_list(m, iclass); + } - if (FL_TEST(klass, RMODULE_IS_REFINEMENT)) { - VALUE refined_class = - rb_refinement_module_get_refined_class(klass); + if (BUILTIN_TYPE(klass) == T_MODULE && FL_TEST(klass, RMODULE_IS_REFINEMENT)) { + VALUE refined_class = + rb_refinement_module_get_refined_class(klass); rb_id_table_foreach(RCLASS_M_TBL(module), add_refined_method_entry_i, (void *)refined_class); - FL_SET(c, RMODULE_INCLUDED_INTO_REFINEMENT); - } + RUBY_ASSERT(BUILTIN_TYPE(c) == T_MODULE); + } tbl = RCLASS_CONST_TBL(module); - if (tbl && rb_id_table_size(tbl)) constant_changed = 1; + if (tbl && rb_id_table_size(tbl)) + rb_id_table_foreach(tbl, clear_constant_cache_i, NULL); skip: - module = RCLASS_SUPER(module); + module = RCLASS_SUPER(module); } - if (constant_changed) rb_clear_constant_cache(); - return method_changed; } @@ -1165,20 +1390,20 @@ move_refined_method(ID key, VALUE value, void *data) struct rb_id_table *tbl = RCLASS_M_TBL(klass); if (me->def->body.refined.orig_me) { - const rb_method_entry_t *orig_me = me->def->body.refined.orig_me, *new_me; - RB_OBJ_WRITE(me, &me->def->body.refined.orig_me, NULL); - new_me = rb_method_entry_clone(me); + const rb_method_entry_t *orig_me = me->def->body.refined.orig_me, *new_me; + RB_OBJ_WRITE(me, &me->def->body.refined.orig_me, NULL); + new_me = rb_method_entry_clone(me); rb_method_table_insert(klass, tbl, key, new_me); - rb_method_entry_copy(me, orig_me); - return ID_TABLE_CONTINUE; - } - else { + rb_method_entry_copy(me, orig_me); + return ID_TABLE_CONTINUE; + } + else { rb_method_table_insert(klass, tbl, key, me); - return ID_TABLE_DELETE; - } + return ID_TABLE_DELETE; + } } else { - return ID_TABLE_CONTINUE; + return ID_TABLE_CONTINUE; } } @@ -1202,14 +1427,14 @@ ensure_origin(VALUE klass) { VALUE origin = RCLASS_ORIGIN(klass); if (origin == klass) { - origin = class_alloc(T_ICLASS, klass); - RCLASS_SET_SUPER(origin, RCLASS_SUPER(klass)); - RCLASS_SET_SUPER(klass, origin); - RCLASS_SET_ORIGIN(klass, origin); - RCLASS_M_TBL(origin) = RCLASS_M_TBL(klass); - RCLASS_M_TBL_INIT(klass); + origin = class_alloc(T_ICLASS, klass); + RCLASS_SET_M_TBL(origin, RCLASS_M_TBL(klass)); + RCLASS_SET_SUPER(origin, RCLASS_SUPER(klass)); + RCLASS_SET_SUPER(klass, origin); + RCLASS_SET_ORIGIN(klass, origin); + RCLASS_M_TBL_INIT(klass); rb_id_table_foreach(RCLASS_M_TBL(origin), cache_clear_refined_method, (void *)klass); - rb_id_table_foreach(RCLASS_M_TBL(origin), move_refined_method, (void *)klass); + rb_id_table_foreach(RCLASS_M_TBL(origin), move_refined_method, (void *)klass); return true; } return false; @@ -1229,25 +1454,37 @@ rb_prepend_module(VALUE klass, VALUE module) changed = do_include_modules_at(klass, klass, module, FALSE, false); RUBY_ASSERT(changed >= 0); // already checked for cyclic prepend above if (changed) { - rb_vm_check_redefinition_by_prepend(klass); + rb_vm_check_redefinition_by_prepend(klass); } if (RB_TYPE_P(klass, T_MODULE)) { rb_subclass_entry_t *iclass = RCLASS_SUBCLASSES(klass); + // skip the placeholder subclass entry at the head of the list if it exists + if (iclass) { + RUBY_ASSERT(!iclass->klass); + iclass = iclass->next; + } + VALUE klass_origin = RCLASS_ORIGIN(klass); struct rb_id_table *klass_m_tbl = RCLASS_M_TBL(klass); struct rb_id_table *klass_origin_m_tbl = RCLASS_M_TBL(klass_origin); while (iclass) { - if (klass_had_no_origin && klass_origin_m_tbl == RCLASS_M_TBL(iclass->klass)) { - // backfill an origin iclass to handle refinements and future prepends - rb_id_table_foreach(RCLASS_M_TBL(iclass->klass), clear_module_cache_i, (void *)iclass->klass); - RCLASS_M_TBL(iclass->klass) = klass_m_tbl; - VALUE origin = rb_include_class_new(klass_origin, RCLASS_SUPER(iclass->klass)); - RCLASS_SET_SUPER(iclass->klass, origin); - RCLASS_SET_INCLUDER(origin, RCLASS_INCLUDER(iclass->klass)); - RCLASS_SET_ORIGIN(iclass->klass, origin); - RICLASS_SET_ORIGIN_SHARED_MTBL(origin); + /* During lazy sweeping, iclass->klass could be a dead object that + * has not yet been swept. */ + if (!rb_objspace_garbage_object_p(iclass->klass)) { + const VALUE subclass = iclass->klass; + if (klass_had_no_origin && klass_origin_m_tbl == RCLASS_M_TBL(subclass)) { + // backfill an origin iclass to handle refinements and future prepends + rb_id_table_foreach(RCLASS_M_TBL(subclass), clear_module_cache_i, (void *)subclass); + RCLASS_M_TBL(subclass) = klass_m_tbl; + VALUE origin = rb_include_class_new(klass_origin, RCLASS_SUPER(subclass)); + RCLASS_SET_SUPER(subclass, origin); + RCLASS_SET_INCLUDER(origin, RCLASS_INCLUDER(subclass)); + RCLASS_SET_ORIGIN(subclass, origin); + RICLASS_SET_ORIGIN_SHARED_MTBL(origin); + } + include_modules_at(subclass, subclass, module, FALSE); } - include_modules_at(iclass->klass, iclass->klass, module, FALSE); + iclass = iclass->next; } } @@ -1284,10 +1521,10 @@ rb_mod_included_modules(VALUE mod) for (p = RCLASS_SUPER(mod); p; p = RCLASS_SUPER(p)) { if (p != origin && RCLASS_ORIGIN(p) == p && BUILTIN_TYPE(p) == T_ICLASS) { - VALUE m = RBASIC(p)->klass; - if (RB_TYPE_P(m, T_MODULE)) - rb_ary_push(ary, m); - } + VALUE m = METACLASS_OF(p); + if (RB_TYPE_P(m, T_MODULE)) + rb_ary_push(ary, m); + } } return ary; } @@ -1319,8 +1556,8 @@ rb_mod_include_p(VALUE mod, VALUE mod2) Check_Type(mod2, T_MODULE); for (p = RCLASS_SUPER(mod); p; p = RCLASS_SUPER(p)) { if (BUILTIN_TYPE(p) == T_ICLASS && !FL_TEST(p, RICLASS_IS_ORIGIN)) { - if (RBASIC(p)->klass == mod2) return Qtrue; - } + if (METACLASS_OF(p) == mod2) return Qtrue; + } } return Qfalse; } @@ -1347,19 +1584,149 @@ VALUE rb_mod_ancestors(VALUE mod) { VALUE p, ary = rb_ary_new(); + VALUE refined_class = Qnil; + if (BUILTIN_TYPE(mod) == T_MODULE && FL_TEST(mod, RMODULE_IS_REFINEMENT)) { + refined_class = rb_refinement_module_get_refined_class(mod); + } for (p = mod; p; p = RCLASS_SUPER(p)) { + if (p == refined_class) break; if (p != RCLASS_ORIGIN(p)) continue; - if (BUILTIN_TYPE(p) == T_ICLASS) { - rb_ary_push(ary, RBASIC(p)->klass); - } + if (BUILTIN_TYPE(p) == T_ICLASS) { + rb_ary_push(ary, METACLASS_OF(p)); + } else { - rb_ary_push(ary, p); - } + rb_ary_push(ary, p); + } } return ary; } +struct subclass_traverse_data +{ + VALUE buffer; + long count; + long maxcount; + bool immediate_only; +}; + +static void +class_descendants_recursive(VALUE klass, VALUE v) +{ + struct subclass_traverse_data *data = (struct subclass_traverse_data *) v; + + if (BUILTIN_TYPE(klass) == T_CLASS && !RCLASS_SINGLETON_P(klass)) { + if (data->buffer && data->count < data->maxcount && !rb_objspace_garbage_object_p(klass)) { + // assumes that this does not cause GC as long as the length does not exceed the capacity + rb_ary_push(data->buffer, klass); + } + data->count++; + if (!data->immediate_only) { + rb_class_foreach_subclass(klass, class_descendants_recursive, v); + } + } + else { + rb_class_foreach_subclass(klass, class_descendants_recursive, v); + } +} + +static VALUE +class_descendants(VALUE klass, bool immediate_only) +{ + struct subclass_traverse_data data = { Qfalse, 0, -1, immediate_only }; + + // estimate the count of subclasses + rb_class_foreach_subclass(klass, class_descendants_recursive, (VALUE) &data); + + // the following allocation may cause GC which may change the number of subclasses + data.buffer = rb_ary_new_capa(data.count); + data.maxcount = data.count; + data.count = 0; + + size_t gc_count = rb_gc_count(); + + // enumerate subclasses + rb_class_foreach_subclass(klass, class_descendants_recursive, (VALUE) &data); + + if (gc_count != rb_gc_count()) { + rb_bug("GC must not occur during the subclass iteration of Class#descendants"); + } + + return data.buffer; +} + +/* + * call-seq: + * subclasses -> array + * + * Returns an array of classes where the receiver is the + * direct superclass of the class, excluding singleton classes. + * The order of the returned array is not defined. + * + * class A; end + * class B < A; end + * class C < B; end + * class D < A; end + * + * A.subclasses #=> [D, B] + * B.subclasses #=> [C] + * C.subclasses #=> [] + * + * Anonymous subclasses (not associated with a constant) are + * returned, too: + * + * c = Class.new(A) + * A.subclasses # => [#<Class:0x00007f003c77bd78>, D, B] + * + * Note that the parent does not hold references to subclasses + * and doesn't prevent them from being garbage collected. This + * means that the subclass might disappear when all references + * to it are dropped: + * + * # drop the reference to subclass, it can be garbage-collected now + * c = nil + * + * A.subclasses + * # It can be + * # => [#<Class:0x00007f003c77bd78>, D, B] + * # ...or just + * # => [D, B] + * # ...depending on whether garbage collector was run + */ + +VALUE +rb_class_subclasses(VALUE klass) +{ + return class_descendants(klass, true); +} + +/* + * call-seq: + * attached_object -> object + * + * Returns the object for which the receiver is the singleton class. + * + * Raises an TypeError if the class is not a singleton class. + * + * class Foo; end + * + * Foo.singleton_class.attached_object #=> Foo + * Foo.attached_object #=> TypeError: `Foo' is not a singleton class + * Foo.new.singleton_class.attached_object #=> #<Foo:0x000000010491a370> + * TrueClass.attached_object #=> TypeError: `TrueClass' is not a singleton class + * NilClass.attached_object #=> TypeError: `NilClass' is not a singleton class + */ + +VALUE +rb_class_attached_object(VALUE klass) +{ + if (!RCLASS_SINGLETON_P(klass)) { + rb_raise(rb_eTypeError, "'%"PRIsVALUE"' is not a singleton class", klass); + } + + return RCLASS_ATTACHED_OBJECT(klass); +} + static void ins_methods_push(st_data_t name, st_data_t ary) { @@ -1372,10 +1739,10 @@ ins_methods_i(st_data_t name, st_data_t type, st_data_t ary) switch ((rb_method_visibility_t)type) { case METHOD_VISI_UNDEF: case METHOD_VISI_PRIVATE: - break; + break; default: /* everything but private */ - ins_methods_push(name, ary); - break; + ins_methods_push(name, ary); + break; } return ST_CONTINUE; } @@ -1384,7 +1751,7 @@ static int ins_methods_type_i(st_data_t name, st_data_t type, st_data_t ary, rb_method_visibility_t visi) { if ((rb_method_visibility_t)type == visi) { - ins_methods_push(name, ary); + ins_methods_push(name, ary); } return ST_CONTINUE; } @@ -1407,6 +1774,12 @@ ins_methods_pub_i(st_data_t name, st_data_t type, st_data_t ary) return ins_methods_type_i(name, type, ary, METHOD_VISI_PUBLIC); } +static int +ins_methods_undef_i(st_data_t name, st_data_t type, st_data_t ary) +{ + return ins_methods_type_i(name, type, ary, METHOD_VISI_UNDEF); +} + struct method_entry_arg { st_table *list; int recur; @@ -1420,19 +1793,20 @@ method_entry_i(ID key, VALUE value, void *data) rb_method_visibility_t type; if (me->def->type == VM_METHOD_TYPE_REFINED) { - VALUE owner = me->owner; - me = rb_resolve_refined_method(Qnil, me); - if (!me) return ID_TABLE_CONTINUE; - if (!arg->recur && me->owner != owner) return ID_TABLE_CONTINUE; + VALUE owner = me->owner; + me = rb_resolve_refined_method(Qnil, me); + if (!me) return ID_TABLE_CONTINUE; + if (!arg->recur && me->owner != owner) return ID_TABLE_CONTINUE; } if (!st_is_member(arg->list, key)) { - if (UNDEFINED_METHOD_ENTRY_P(me)) { - type = METHOD_VISI_UNDEF; /* none */ - } - else { - type = METHOD_ENTRY_VISI(me); - } - st_add_direct(arg->list, key, (st_data_t)type); + if (UNDEFINED_METHOD_ENTRY_P(me)) { + type = METHOD_VISI_UNDEF; /* none */ + } + else { + type = METHOD_ENTRY_VISI(me); + RUBY_ASSERT(type != METHOD_VISI_UNDEF); + } + st_add_direct(arg->list, key, (st_data_t)type); } return ID_TABLE_CONTINUE; } @@ -1449,7 +1823,7 @@ static bool particular_class_p(VALUE mod) { if (!mod) return false; - if (FL_TEST(mod, FL_SINGLETON)) return true; + if (RCLASS_SINGLETON_P(mod)) return true; if (BUILTIN_TYPE(mod) == T_ICLASS) return true; return false; } @@ -1473,14 +1847,14 @@ class_instance_method_list(int argc, const VALUE *argv, VALUE mod, int obj, int } if (!recur && RCLASS_ORIGIN(mod) != mod) { - mod = RCLASS_ORIGIN(mod); - prepended = 1; + mod = RCLASS_ORIGIN(mod); + prepended = 1; } for (; mod; mod = RCLASS_SUPER(mod)) { add_instance_method_list(mod, &me_arg); - if (BUILTIN_TYPE(mod) == T_ICLASS && !prepended) continue; - if (!recur) break; + if (BUILTIN_TYPE(mod) == T_ICLASS && !prepended) continue; + if (!recur) break; } ary = rb_ary_new2(me_arg.list->num_entries); st_foreach(me_arg.list, func, ary); @@ -1514,6 +1888,15 @@ class_instance_method_list(int argc, const VALUE *argv, VALUE mod, int obj, int * B.instance_methods(true).include?(:method1) #=> true * C.instance_methods(false) #=> [:method3] * C.instance_methods.include?(:method2) #=> true + * + * Note that method visibility changes in the current class, as well as aliases, + * are considered as methods of the current class by this method: + * + * class C < B + * alias method4 method2 + * protected :method2 + * end + * C.instance_methods(false).sort #=> [:method2, :method3, :method4] */ VALUE @@ -1577,6 +1960,21 @@ rb_class_public_instance_methods(int argc, const VALUE *argv, VALUE mod) /* * call-seq: + * mod.undefined_instance_methods -> array + * + * Returns a list of the undefined instance methods defined in <i>mod</i>. + * The undefined methods of any ancestors are not included. + */ + +VALUE +rb_class_undefined_instance_methods(VALUE mod) +{ + VALUE include_super = Qfalse; + return class_instance_method_list(1, &include_super, mod, 0, ins_methods_undef_i); +} + +/* + * call-seq: * obj.methods(regular=true) -> array * * Returns a list of the names of public and protected methods of @@ -1610,7 +2008,7 @@ rb_obj_methods(int argc, const VALUE *argv, VALUE obj) { rb_check_arity(argc, 0, 1); if (argc > 0 && !RTEST(argv[0])) { - return rb_obj_singleton_methods(argc, argv, obj); + return rb_obj_singleton_methods(argc, argv, obj); } return class_instance_method_list(argc, argv, CLASS_OF(obj), 1, ins_methods_i); } @@ -1702,22 +2100,22 @@ rb_obj_singleton_methods(int argc, const VALUE *argv, VALUE obj) int recur = TRUE; if (rb_check_arity(argc, 0, 1)) recur = RTEST(argv[0]); - if (RB_TYPE_P(obj, T_CLASS) && FL_TEST(obj, FL_SINGLETON)) { + if (RCLASS_SINGLETON_P(obj)) { rb_singleton_class(obj); } klass = CLASS_OF(obj); origin = RCLASS_ORIGIN(klass); me_arg.list = st_init_numtable(); me_arg.recur = recur; - if (klass && FL_TEST(klass, FL_SINGLETON)) { - if ((mtbl = RCLASS_M_TBL(origin)) != 0) rb_id_table_foreach(mtbl, method_entry_i, &me_arg); - klass = RCLASS_SUPER(klass); + if (klass && RCLASS_SINGLETON_P(klass)) { + if ((mtbl = RCLASS_M_TBL(origin)) != 0) rb_id_table_foreach(mtbl, method_entry_i, &me_arg); + klass = RCLASS_SUPER(klass); } if (recur) { - while (klass && (FL_TEST(klass, FL_SINGLETON) || RB_TYPE_P(klass, T_ICLASS))) { - if (klass != origin && (mtbl = RCLASS_M_TBL(klass)) != 0) rb_id_table_foreach(mtbl, method_entry_i, &me_arg); - klass = RCLASS_SUPER(klass); - } + while (klass && (RCLASS_SINGLETON_P(klass) || RB_TYPE_P(klass, T_ICLASS))) { + if (klass != origin && (mtbl = RCLASS_M_TBL(klass)) != 0) rb_id_table_foreach(mtbl, method_entry_i, &me_arg); + klass = RCLASS_SUPER(klass); + } } ary = rb_ary_new2(me_arg.list->num_entries); st_foreach(me_arg.list, ins_methods_i, ary); @@ -1730,56 +2128,7 @@ rb_obj_singleton_methods(int argc, const VALUE *argv, VALUE obj) * \} */ /*! - * \defgroup defmethod Defining methods - * There are some APIs to define a method from C. - * These API takes a C function as a method body. - * - * \par Method body functions - * Method body functions must return a VALUE and - * can be one of the following form: - * <dl> - * <dt>Fixed number of parameters</dt> - * <dd> - * This form is a normal C function, excepting it takes - * a receiver object as the first argument. - * - * \code - * static VALUE my_method(VALUE self, VALUE x, VALUE y); - * \endcode - * </dd> - * <dt>argc and argv style</dt> - * <dd> - * This form takes three parameters: \a argc, \a argv and \a self. - * \a self is the receiver. \a argc is the number of arguments. - * \a argv is a pointer to an array of the arguments. - * - * \code - * static VALUE my_method(int argc, VALUE *argv, VALUE self); - * \endcode - * </dd> - * <dt>Ruby array style</dt> - * <dd> - * This form takes two parameters: self and args. - * \a self is the receiver. \a args is an Array object which - * contains the arguments. - * - * \code - * static VALUE my_method(VALUE self, VALUE args); - * \endcode - * </dd> - * - * \par Number of parameters - * Method defining APIs takes the number of parameters which the - * method will takes. This number is called \a argc. - * \a argc can be: - * <dl> - * <dt>zero or positive number</dt> - * <dd>This means the method body function takes a fixed number of parameters</dd> - * <dt>-1</dt> - * <dd>This means the method body function is "argc and argv" style.</dd> - * <dt>-2</dt> - * <dd>This means the method body function is "self and args" style.</dd> - * </dl> + * \addtogroup defmethod * \{ */ @@ -1838,7 +2187,7 @@ rb_undef_methods_from(VALUE klass, VALUE super) { struct rb_id_table *mtbl = RCLASS_M_TBL(super); if (mtbl) { - rb_id_table_foreach(mtbl, undef_method_i, (void *)klass); + rb_id_table_foreach(mtbl, undef_method_i, (void *)klass); } } @@ -1867,13 +2216,13 @@ rb_special_singleton_class(VALUE obj) return special_singleton_class_of(obj); } -/*! - * \internal - * Returns the singleton class of \a obj. Creates it if necessary. +/** + * @internal + * Returns the singleton class of `obj`. Creates it if necessary. * - * \note DO NOT expose the returned singleton class to + * @note DO NOT expose the returned singleton class to * outside of class.c. - * Use \ref rb_singleton_class instead for + * Use @ref rb_singleton_class instead for * consistency of the metaclass hierarchy. */ static VALUE @@ -1886,28 +2235,29 @@ singleton_class_of(VALUE obj) case T_BIGNUM: case T_FLOAT: case T_SYMBOL: - rb_raise(rb_eTypeError, "can't define singleton"); + rb_raise(rb_eTypeError, "can't define singleton"); case T_FALSE: case T_TRUE: case T_NIL: - klass = special_singleton_class_of(obj); - if (NIL_P(klass)) - rb_bug("unknown immediate %p", (void *)obj); - return klass; + klass = special_singleton_class_of(obj); + if (NIL_P(klass)) + rb_bug("unknown immediate %p", (void *)obj); + return klass; case T_STRING: - if (FL_TEST_RAW(obj, RSTRING_FSTR)) { + if (CHILLED_STRING_P(obj)) { + CHILLED_STRING_MUTATED(obj); + } + else if (FL_TEST_RAW(obj, RSTRING_FSTR)) { rb_raise(rb_eTypeError, "can't define singleton"); } } - klass = RBASIC(obj)->klass; - if (!(FL_TEST(klass, FL_SINGLETON) && - rb_attr_get(klass, id_attached) == obj)) { - rb_serial_t serial = RCLASS_SERIAL(klass); - klass = rb_make_metaclass(obj, klass); - RCLASS_SERIAL(klass) = serial; + klass = METACLASS_OF(obj); + if (!(RCLASS_SINGLETON_P(klass) && + RCLASS_ATTACHED_OBJECT(klass) == obj)) { + klass = rb_make_metaclass(obj, klass); } RB_FL_SET_RAW(klass, RB_OBJ_FROZEN_RAW(obj)); @@ -1919,21 +2269,21 @@ void rb_freeze_singleton_class(VALUE x) { /* should not propagate to meta-meta-class, and so on */ - if (!(RBASIC(x)->flags & FL_SINGLETON)) { - VALUE klass = RBASIC_CLASS(x); - if (klass && (klass = RCLASS_ORIGIN(klass)) != 0 && - FL_TEST(klass, (FL_SINGLETON|FL_FREEZE)) == FL_SINGLETON) { - OBJ_FREEZE_RAW(klass); - } + if (!RCLASS_SINGLETON_P(x)) { + VALUE klass = RBASIC_CLASS(x); + if (klass && // no class when hidden from ObjectSpace + FL_TEST(klass, (FL_SINGLETON|FL_FREEZE)) == FL_SINGLETON) { + OBJ_FREEZE(klass); + } } } -/*! - * Returns the singleton class of \a obj, or nil if obj is not a +/** + * Returns the singleton class of `obj`, or nil if obj is not a * singleton object. * - * \param obj an arbitrary object. - * \return the singleton class or nil. + * @param obj an arbitrary object. + * @return the singleton class or nil. */ VALUE rb_singleton_class_get(VALUE obj) @@ -1941,31 +2291,14 @@ rb_singleton_class_get(VALUE obj) VALUE klass; if (SPECIAL_CONST_P(obj)) { - return rb_special_singleton_class(obj); + return rb_special_singleton_class(obj); } - klass = RBASIC(obj)->klass; - if (!FL_TEST(klass, FL_SINGLETON)) return Qnil; - if (rb_attr_get(klass, id_attached) != obj) return Qnil; + klass = METACLASS_OF(obj); + if (!RCLASS_SINGLETON_P(klass)) return Qnil; + if (RCLASS_ATTACHED_OBJECT(klass) != obj) return Qnil; return klass; } -/*! - * Returns the singleton class of \a obj. Creates it if necessary. - * - * \param obj an arbitrary object. - * \throw TypeError if \a obj is an Integer or a Symbol. - * \return the singleton class. - * - * \post \a obj has its own singleton class. - * \post if \a obj is a class, - * the returned singleton class also has its own - * singleton class in order to keep consistency of the - * inheritance structure of metaclasses. - * \note a new singleton class will be created - * if \a obj does not have it. - * \note the singleton classes for nil, true and false are: - * NilClass, TrueClass and FalseClass. - */ VALUE rb_singleton_class(VALUE obj) { @@ -1989,13 +2322,6 @@ rb_singleton_class(VALUE obj) #ifdef rb_define_singleton_method #undef rb_define_singleton_method #endif -/*! - * Defines a singleton method for \a obj. - * \param obj an arbitrary object - * \param name name of the singleton method - * \param func the method body - * \param argc the number of parameters, or -1 or -2. see \ref defmethod. - */ void rb_define_singleton_method(VALUE obj, const char *name, VALUE (*func)(ANYARGS), int argc) { @@ -2005,13 +2331,6 @@ rb_define_singleton_method(VALUE obj, const char *name, VALUE (*func)(ANYARGS), #ifdef rb_define_module_function #undef rb_define_module_function #endif -/*! - * Defines a module function for \a module. - * \param module an module or a class. - * \param name name of the function - * \param func the method body - * \param argc the number of parameters, or -1 or -2. see \ref defmethod. - */ void rb_define_module_function(VALUE module, const char *name, VALUE (*func)(ANYARGS), int argc) { @@ -2022,58 +2341,38 @@ rb_define_module_function(VALUE module, const char *name, VALUE (*func)(ANYARGS) #ifdef rb_define_global_function #undef rb_define_global_function #endif -/*! - * Defines a global function - * \param name name of the function - * \param func the method body - * \param argc the number of parameters, or -1 or -2. see \ref defmethod. - */ void rb_define_global_function(const char *name, VALUE (*func)(ANYARGS), int argc) { rb_define_module_function(rb_mKernel, name, func, argc); } - -/*! - * Defines an alias of a method. - * \param klass the class which the original method belongs to - * \param name1 a new name for the method - * \param name2 the original name of the method - */ void rb_define_alias(VALUE klass, const char *name1, const char *name2) { rb_alias(klass, rb_intern(name1), rb_intern(name2)); } -/*! - * Defines (a) public accessor method(s) for an attribute. - * \param klass the class which the attribute will belongs to - * \param name name of the attribute - * \param read a getter method for the attribute will be defined if \a read is non-zero. - * \param write a setter method for the attribute will be defined if \a write is non-zero. - */ void rb_define_attr(VALUE klass, const char *name, int read, int write) { rb_attr(klass, rb_intern(name), read, write, FALSE); } -MJIT_FUNC_EXPORTED VALUE +VALUE rb_keyword_error_new(const char *error, VALUE keys) { long i = 0, len = RARRAY_LEN(keys); VALUE error_message = rb_sprintf("%s keyword%.*s", error, len > 1, "s"); if (len > 0) { - rb_str_cat_cstr(error_message, ": "); - while (1) { + rb_str_cat_cstr(error_message, ": "); + while (1) { const VALUE k = RARRAY_AREF(keys, i); - rb_str_append(error_message, rb_inspect(k)); - if (++i >= len) break; - rb_str_cat_cstr(error_message, ", "); - } + rb_str_append(error_message, rb_inspect(k)); + if (++i >= len) break; + rb_str_cat_cstr(error_message, ", "); + } } return rb_exc_new_str(rb_eArgError, error_message); @@ -2092,7 +2391,7 @@ unknown_keyword_error(VALUE hash, const ID *table, int keywords) { int i; for (i = 0; i < keywords; i++) { - st_data_t key = ID2SYM(table[i]); + st_data_t key = ID2SYM(table[i]); rb_hash_stlike_delete(hash, &key, NULL); } rb_keyword_error("unknown", rb_hash_keys(hash)); @@ -2116,8 +2415,8 @@ rb_extract_keywords(VALUE *orighash) VALUE hash = *orighash; if (RHASH_EMPTY_P(hash)) { - *orighash = 0; - return hash; + *orighash = 0; + return hash; } rb_hash_foreach(hash, separate_symbol, (st_data_t)&parthash); *orighash = parthash[1]; @@ -2143,36 +2442,36 @@ rb_get_kwargs(VALUE keyword_hash, const ID *table, int required, int optional, V if (NIL_P(keyword_hash)) keyword_hash = 0; if (optional < 0) { - rest = 1; - optional = -1-optional; + rest = 1; + optional = -1-optional; } if (required) { - for (; i < required; i++) { - VALUE keyword = ID2SYM(table[i]); - if (keyword_hash) { + for (; i < required; i++) { + VALUE keyword = ID2SYM(table[i]); + if (keyword_hash) { if (extract_kwarg(keyword, values[i])) { - continue; - } - } - if (NIL_P(missing)) missing = rb_ary_tmp_new(1); - rb_ary_push(missing, keyword); - } - if (!NIL_P(missing)) { - rb_keyword_error("missing", missing); - } + continue; + } + } + if (NIL_P(missing)) missing = rb_ary_hidden_new(1); + rb_ary_push(missing, keyword); + } + if (!NIL_P(missing)) { + rb_keyword_error("missing", missing); + } } j = i; if (optional && keyword_hash) { - for (i = 0; i < optional; i++) { + for (i = 0; i < optional; i++) { if (extract_kwarg(ID2SYM(table[required+i]), values[required+i])) { - j++; - } - } + j++; + } + } } if (!rest && keyword_hash) { - if (RHASH_SIZE(keyword_hash) > (unsigned int)(values ? 0 : j)) { - unknown_keyword_error(keyword_hash, table, required+optional); - } + if (RHASH_SIZE(keyword_hash) > (unsigned int)(values ? 0 : j)) { + unknown_keyword_error(keyword_hash, table, required+optional); + } } if (values && !keyword_hash) { for (i = 0; i < required + optional; i++) { @@ -2203,30 +2502,30 @@ rb_scan_args_parse(int kw_flag, const char *fmt, struct rb_scan_args_t *arg) if (ISDIGIT(*p)) { arg->n_lead = *p - '0'; - p++; - if (ISDIGIT(*p)) { + p++; + if (ISDIGIT(*p)) { arg->n_opt = *p - '0'; - p++; - } + p++; + } } if (*p == '*') { arg->f_var = 1; - p++; + p++; } if (ISDIGIT(*p)) { arg->n_trail = *p - '0'; - p++; + p++; } if (*p == ':') { arg->f_hash = 1; - p++; + p++; } if (*p == '&') { arg->f_block = 1; - p++; + p++; } if (*p != '\0') { - rb_fatal("bad scan arg format: %s", fmt); + rb_fatal("bad scan arg format: %s", fmt); } } @@ -2262,37 +2561,37 @@ rb_scan_args_assign(const struct rb_scan_args_t *arg, int argc, const VALUE *con for (i = 0; i < n_lead; i++) { var = rb_scan_args_next_param(); if (var) *var = argv[argi]; - argi++; + argi++; } /* capture optional arguments */ for (i = 0; i < n_opt; i++) { var = rb_scan_args_next_param(); if (argi < argc - n_trail) { if (var) *var = argv[argi]; - argi++; - } - else { - if (var) *var = Qnil; - } + argi++; + } + else { + if (var) *var = Qnil; + } } /* capture variable length arguments */ if (f_var) { int n_var = argc - argi - n_trail; var = rb_scan_args_next_param(); - if (0 < n_var) { + if (0 < n_var) { if (var) *var = rb_ary_new_from_values(n_var, &argv[argi]); - argi += n_var; - } - else { - if (var) *var = rb_ary_new(); - } + argi += n_var; + } + else { + if (var) *var = rb_ary_new(); + } } /* capture trailing mandatory arguments */ for (i = 0; i < n_trail; i++) { var = rb_scan_args_next_param(); if (var) *var = argv[argi]; - argi++; + argi++; } /* capture an option hash - phase 2: assignment */ if (f_hash) { @@ -2302,12 +2601,12 @@ rb_scan_args_assign(const struct rb_scan_args_t *arg, int argc, const VALUE *con /* capture iterator block */ if (f_block) { var = rb_scan_args_next_param(); - if (rb_block_given_p()) { - *var = rb_block_proc(); - } - else { - *var = Qnil; - } + if (rb_block_given_p()) { + *var = rb_block_proc(); + } + else { + *var = Qnil; + } } if (argi == argc) { @@ -2363,12 +2662,6 @@ rb_scan_args_kw(int kw_flag, int argc, const VALUE *argv, const char *fmt, ...) return rb_scan_args_result(&arg, argc); } -int -rb_class_has_methods(VALUE c) -{ - return rb_id_table_size(RCLASS_M_TBL(c)) == 0 ? FALSE : TRUE; -} - /*! * \} */ |