From dd883de5ba311c38818d0f638a94b4fbc63f5ee5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=8D=9C=E9=83=A8=E6=98=8C=E5=B9=B3?= Date: Thu, 26 Sep 2019 10:22:01 +0900 Subject: refactor constify most of rb_method_entry_t Now that we have eliminated most destructive operations over the rb_method_entry_t / rb_callable_method_entry_t, let's make them mostly immutabe and mark them const. One exception is rb_export_method(), which destructively modifies visibilities of method entries. I have left that operation as is because I suspect that destructiveness is the nature of that function. --- class.c | 6 +-- ext/coverage/coverage.c | 2 +- gc.c | 2 +- method.h | 43 +++--------------- proc.c | 8 ++-- vm.c | 2 +- vm_backtrace.c | 4 +- vm_insnhelper.c | 12 ++--- vm_method.c | 118 ++++++++++++++++++++++++++---------------------- 9 files changed, 88 insertions(+), 109 deletions(-) diff --git a/class.c b/class.c index 3160444239..aaf754146d 100644 --- a/class.c +++ b/class.c @@ -965,7 +965,7 @@ static enum rb_id_table_iterator_result inject_refined_method(ID *key, VALUE *value, void *data, int _) { const tuple *ptr = data; - const rb_method_entry_t *me = *(rb_method_entry_t **) value; + const rb_method_entry_t *me = *(const rb_method_entry_t **) value; const rb_method_entry_t *orig_me = me->def->body.refined.orig_me; const rb_method_entry_t *new_me = rb_method_entry_from_template( @@ -982,8 +982,8 @@ inject_refined_method(ID *key, VALUE *value, void *data, int _) static enum rb_id_table_iterator_result move_refined_method(ID key, VALUE value, void *data) { - const tuple *ptr = data; - rb_method_entry_t *me = (rb_method_entry_t *) value; + const tuple *ptr = data; + const rb_method_entry_t *me = (const rb_method_entry_t *) value; if (me->def->type == VM_METHOD_TYPE_REFINED) { if (me->def->body.refined.orig_me) { diff --git a/ext/coverage/coverage.c b/ext/coverage/coverage.c index 8503c9d6c6..cb571caa4b 100644 --- a/ext/coverage/coverage.c +++ b/ext/coverage/coverage.c @@ -123,7 +123,7 @@ method_coverage_i(void *vstart, void *vend, size_t stride, void *data) for (v = (VALUE)vstart; v != (VALUE)vend; v += stride) { if (RB_TYPE_P(v, T_IMEMO) && imemo_type(v) == imemo_ment) { - const rb_method_entry_t *me = (rb_method_entry_t *) v; + const rb_method_entry_t *me = (const rb_method_entry_t *) v; VALUE path, first_lineno, first_column, last_lineno, last_column; VALUE data[5], ncoverage, methods; VALUE methods_id = ID2SYM(rb_intern("methods")); diff --git a/gc.c b/gc.c index 0caee4c260..52b3a66b6c 100644 --- a/gc.c +++ b/gc.c @@ -7829,7 +7829,7 @@ void rb_update_st_references(struct st_table *ht) } static void -gc_ref_update_method_entry(rb_objspace_t *objspace, rb_method_entry_t *me) +gc_ref_update_method_entry(rb_objspace_t *objspace, const rb_method_entry_t *me) { const rb_method_definition_t *def = me->def; diff --git a/method.h b/method.h index 105e4b6a40..b203f7112d 100644 --- a/method.h +++ b/method.h @@ -49,53 +49,24 @@ typedef struct rb_cref_struct { /* method data type */ typedef struct rb_method_entry_struct { - VALUE flags; - VALUE defined_class; + const VALUE flags; + const VALUE defined_class; struct rb_method_definition_struct * const def; - ID called_id; - VALUE owner; + const ID called_id; + const VALUE owner; } rb_method_entry_t; typedef struct rb_callable_method_entry_struct { /* same fields with rb_method_entry_t */ - VALUE flags; + const VALUE flags; const VALUE defined_class; struct rb_method_definition_struct * const def; - ID called_id; + const ID called_id; const VALUE owner; } rb_callable_method_entry_t; #define METHOD_ENTRY_VISI(me) (rb_method_visibility_t)(((me)->flags & (IMEMO_FL_USER0 | IMEMO_FL_USER1)) >> (IMEMO_FL_USHIFT+0)) #define METHOD_ENTRY_BASIC(me) (int) (((me)->flags & (IMEMO_FL_USER2 )) >> (IMEMO_FL_USHIFT+2)) -static inline void -METHOD_ENTRY_VISI_SET(rb_method_entry_t *me, rb_method_visibility_t visi) -{ - VM_ASSERT((int)visi >= 0 && visi <= 3); - me->flags = (me->flags & ~(IMEMO_FL_USER0 | IMEMO_FL_USER1)) | (visi << (IMEMO_FL_USHIFT+0)); -} -static inline void -METHOD_ENTRY_BASIC_SET(rb_method_entry_t *me, unsigned int basic) -{ - VM_ASSERT(basic <= 1); - me->flags = (me->flags & ~(IMEMO_FL_USER2 )) | (basic << (IMEMO_FL_USHIFT+2)); -} -static inline void -METHOD_ENTRY_FLAGS_SET(rb_method_entry_t *me, rb_method_visibility_t visi, unsigned int basic) -{ - VM_ASSERT((int)visi >= 0 && visi <= 3); - VM_ASSERT(basic <= 1); - me->flags = - (me->flags & ~(IMEMO_FL_USER0|IMEMO_FL_USER1|IMEMO_FL_USER2)) | - ((visi << (IMEMO_FL_USHIFT+0)) | (basic << (IMEMO_FL_USHIFT+2))); -} -static inline void -METHOD_ENTRY_FLAGS_COPY(rb_method_entry_t *dst, const rb_method_entry_t *src) -{ - dst->flags = - (dst->flags & ~(IMEMO_FL_USER0|IMEMO_FL_USER1|IMEMO_FL_USER2)) | - (src->flags & (IMEMO_FL_USER0|IMEMO_FL_USER1|IMEMO_FL_USER2)); -} - typedef enum { VM_METHOD_TYPE_ISEQ, /*!< Ruby method */ VM_METHOD_TYPE_CFUNC, /*!< C method */ @@ -190,7 +161,7 @@ void rb_add_method_iseq(VALUE klass, ID mid, const rb_iseq_t *iseq, rb_cref_t *c void rb_add_refined_method_entry(VALUE refined_class, ID mid); void rb_add_method(VALUE klass, ID mid, rb_method_type_t type, void *option, rb_method_visibility_t visi); -rb_method_entry_t *rb_method_entry_set(VALUE klass, ID mid, const rb_method_entry_t *, rb_method_visibility_t noex); +const rb_method_entry_t *rb_method_entry_set(VALUE klass, ID mid, const rb_method_entry_t *, rb_method_visibility_t noex); const rb_method_entry_t *rb_method_entry_from_template(const rb_method_entry_t *template, const void *opts); const rb_method_entry_t *rb_method_entry_for_missing(ID mid, VALUE klass); diff --git a/proc.c b/proc.c index 09b310356c..0fd2126fff 100644 --- a/proc.c +++ b/proc.c @@ -1426,7 +1426,7 @@ bm_compact(void *ptr) UPDATE_REFERENCE(data->recv); UPDATE_REFERENCE(data->klass); UPDATE_REFERENCE(data->iclass); - UPDATE_TYPED_REFERENCE(rb_method_entry_t *, data->me); + UPDATE_TYPED_REFERENCE(const rb_method_entry_t *, data->me); } static size_t @@ -1519,7 +1519,7 @@ mnew_internal(const rb_method_entry_t *me, VALUE klass, VALUE iclass, if (me->defined_class) { VALUE klass = RCLASS_SUPER(RCLASS_ORIGIN(me->defined_class)); id = me->def->original_id; - me = (rb_method_entry_t *)rb_callable_method_entry_with_refinements(klass, id, &iclass); + me = (const rb_method_entry_t *)rb_callable_method_entry_with_refinements(klass, id, &iclass); } else { VALUE klass = RCLASS_SUPER(me->owner); @@ -1557,7 +1557,7 @@ mnew(VALUE klass, VALUE obj, ID id, VALUE mclass, int scope) me = rb_method_entry_with_refinements(klass, id, &iclass); } else { - me = (rb_method_entry_t *)rb_callable_method_entry_with_refinements(klass, id, &iclass); + me = (const rb_method_entry_t *)rb_callable_method_entry_with_refinements(klass, id, &iclass); } return mnew_from_me(me, klass, iclass, obj, id, mclass, scope); } @@ -2947,7 +2947,7 @@ method_super_method(VALUE method) super_class = RCLASS_SUPER(RCLASS_ORIGIN(iclass)); mid = data->me->called_id; if (!super_class) return Qnil; - me = (rb_method_entry_t *)rb_callable_method_entry_with_refinements(super_class, mid, &iclass); + me = (const rb_method_entry_t *)rb_callable_method_entry_with_refinements(super_class, mid, &iclass); if (!me) return Qnil; return mnew_internal(me, me->owner, iclass, data->recv, mid, rb_obj_class(method), FALSE, FALSE); } diff --git a/vm.c b/vm.c index 2483180061..16a15c2151 100644 --- a/vm.c +++ b/vm.c @@ -1595,7 +1595,7 @@ static enum rb_id_table_iterator_result check_redefined_method(ID mid, VALUE value, void *data) { VALUE klass = (VALUE)data; - const rb_method_entry_t *me = (rb_method_entry_t *)value; + const rb_method_entry_t *me = (const rb_method_entry_t *)value; const rb_method_entry_t *newme = rb_method_entry(klass, mid); if (newme != me) rb_vm_check_redefinition_opt_method(me, me->owner); diff --git a/vm_backtrace.c b/vm_backtrace.c index 44a4ac0784..3a8ad9143d 100644 --- a/vm_backtrace.c +++ b/vm_backtrace.c @@ -1349,7 +1349,7 @@ frame2iseq(VALUE frame) return (const rb_iseq_t *)frame; case imemo_ment: { - const rb_callable_method_entry_t *cme = (rb_callable_method_entry_t *)frame; + const rb_callable_method_entry_t *cme = (const rb_callable_method_entry_t *)frame; switch (cme->def->type) { case VM_METHOD_TYPE_ISEQ: return cme->def->body.iseq.iseqptr; @@ -1405,7 +1405,7 @@ frame2klass(VALUE frame) if (frame == Qnil) return Qnil; if (RB_TYPE_P(frame, T_IMEMO)) { - const rb_callable_method_entry_t *cme = (rb_callable_method_entry_t *)frame; + const rb_callable_method_entry_t *cme = (const rb_callable_method_entry_t *)frame; if (imemo_type(frame) == imemo_ment) { return cme->defined_class; diff --git a/vm_insnhelper.c b/vm_insnhelper.c index adad1df6dd..197e100607 100644 --- a/vm_insnhelper.c +++ b/vm_insnhelper.c @@ -578,8 +578,8 @@ vm_getspecial(const rb_execution_context_t *ec, const VALUE *lep, rb_num_t key, return val; } -PUREFUNC(static rb_callable_method_entry_t *check_method_entry(VALUE obj, int can_be_svar)); -static rb_callable_method_entry_t * +PUREFUNC(static const rb_callable_method_entry_t *check_method_entry(VALUE obj, int can_be_svar)); +static const rb_callable_method_entry_t * check_method_entry(VALUE obj, int can_be_svar) { if (obj == Qfalse) return NULL; @@ -590,7 +590,7 @@ check_method_entry(VALUE obj, int can_be_svar) switch (imemo_type(obj)) { case imemo_ment: - return (rb_callable_method_entry_t *)obj; + return (const rb_callable_method_entry_t *)obj; case imemo_cref: return NULL; case imemo_svar: @@ -609,7 +609,7 @@ MJIT_STATIC const rb_callable_method_entry_t * rb_vm_frame_method_entry(const rb_control_frame_t *cfp) { const VALUE *ep = cfp->ep; - rb_callable_method_entry_t *me; + const rb_callable_method_entry_t *me; while (!VM_ENV_LOCAL_P(ep)) { if ((me = check_method_entry(ep[VM_ENV_DATA_INDEX_ME_CREF], FALSE)) != NULL) return me; @@ -620,7 +620,7 @@ rb_vm_frame_method_entry(const rb_control_frame_t *cfp) } static rb_cref_t * -method_entry_cref(rb_callable_method_entry_t *me) +method_entry_cref(const rb_callable_method_entry_t *me) { switch (me->def->type) { case VM_METHOD_TYPE_ISEQ: @@ -644,7 +644,7 @@ check_cref(VALUE obj, int can_be_svar) switch (imemo_type(obj)) { case imemo_ment: - return method_entry_cref((rb_callable_method_entry_t *)obj); + return method_entry_cref((const rb_callable_method_entry_t *)obj); case imemo_cref: return (rb_cref_t *)obj; case imemo_svar: diff --git a/vm_method.c b/vm_method.c index ce703f3d34..38da273feb 100644 --- a/vm_method.c +++ b/vm_method.c @@ -41,7 +41,7 @@ struct cache_entry { rb_serial_t method_state; rb_serial_t class_serial; ID mid; - rb_method_entry_t* me; + const rb_method_entry_t* me; VALUE defined_class; }; @@ -167,17 +167,17 @@ rb_free_method_entry(const rb_method_entry_t *me) } } -static inline rb_method_entry_t *search_method(VALUE klass, ID id, VALUE *defined_class_ptr); +static inline const rb_method_entry_t *search_method(VALUE klass, ID id, VALUE *defined_class_ptr); extern int rb_method_definition_eq(const rb_method_definition_t *d1, const rb_method_definition_t *d2); -static inline rb_method_entry_t * +static inline const rb_method_entry_t * lookup_method_table(VALUE klass, ID id) { st_data_t body; struct rb_id_table *m_tbl = RCLASS_M_TBL(klass); if (rb_id_table_lookup(m_tbl, id, &body)) { - return (rb_method_entry_t *) body; + return (const rb_method_entry_t *) body; } else { return 0; @@ -477,15 +477,15 @@ method_definition_addref_complement(rb_method_definition_t *def) return def; } -static rb_method_entry_t * +static const rb_method_entry_t * rb_method_entry_alloc(VALUE flags, ID called_id, VALUE owner, VALUE defined_class, const rb_method_definition_t *def) { - rb_method_entry_t tmp = { flags, }; - rb_method_entry_t *me = (rb_method_entry_t *)rb_imemo_new(imemo_ment, (VALUE)def, (VALUE)called_id, owner, defined_class); - METHOD_ENTRY_FLAGS_COPY(me, &tmp); - if (def) { - method_definition_reset(me); - } + VALUE v = rb_imemo_new(imemo_ment, (VALUE)def, (VALUE)called_id, owner, defined_class); + RBASIC(v)->flags = + (RBASIC(v)->flags & ~(IMEMO_FL_USER0|IMEMO_FL_USER1|IMEMO_FL_USER2)) | + (flags & (IMEMO_FL_USER0|IMEMO_FL_USER1|IMEMO_FL_USER2)); + const rb_method_entry_t *me = (void *)v; + method_definition_reset(me); return me; } @@ -506,9 +506,8 @@ filter_defined_class(VALUE klass) static inline VALUE method_entry_flags(rb_method_visibility_t visi) { - rb_method_entry_t tmp = { 0, }; - METHOD_ENTRY_FLAGS_SET(&tmp, visi, !ruby_running); - return tmp.flags; + return (visi << (IMEMO_FL_USHIFT+0)) | + ((!ruby_running) << (IMEMO_FL_USHIFT+2)); } MJIT_FUNC_EXPORTED const rb_method_entry_t * @@ -556,7 +555,6 @@ MJIT_FUNC_EXPORTED const rb_callable_method_entry_t * rb_method_entry_complement_defined_class(const rb_method_entry_t *src_me, ID called_id, VALUE defined_class) { const rb_method_definition_t *def = src_me->def; - rb_method_entry_t *me; if (!src_me->defined_class && def->type == VM_METHOD_TYPE_REFINED && @@ -570,24 +568,26 @@ rb_method_entry_complement_defined_class(const rb_method_entry_t *src_me, ID cal &(rb_method_refined_t) { .orig_me = orig_me, .owner = orig_me->owner}); + } else { - def = method_definition_addref_complement((rb_method_definition_t *)def); + def = method_definition_addref_complement((rb_method_definition_t *)def); } - me = rb_method_entry_alloc( - src_me->flags, - called_id, - src_me->owner, - defined_class, - def); + const rb_method_entry_t *me = + rb_method_entry_alloc( + src_me->flags, + called_id, + src_me->owner, + defined_class, + def); VM_ASSERT(RB_TYPE_P(me->owner, T_MODULE)); - return (rb_callable_method_entry_t *)me; + return (const rb_callable_method_entry_t *)me; } -static rb_method_entry_t* -make_method_entry_refined(VALUE owner, rb_method_entry_t *me) +static const rb_method_entry_t* +make_method_entry_refined(VALUE owner, const rb_method_entry_t *me) { if (me->def->type == VM_METHOD_TYPE_REFINED) { return me; @@ -620,7 +620,7 @@ make_method_entry_refined(VALUE owner, rb_method_entry_t *me) void rb_add_refined_method_entry(VALUE refined_class, ID mid) { - rb_method_entry_t *me = lookup_method_table(refined_class, mid); + const rb_method_entry_t *me = lookup_method_table(refined_class, mid); if (me) { me = make_method_entry_refined(refined_class, me); @@ -654,11 +654,10 @@ check_override_opt_method(VALUE klass, VALUE arg) * If def is given (!= NULL), then just use it and ignore original_id and otps. * If not given, then make a new def with original_id and opts. */ -static rb_method_entry_t * +static const rb_method_entry_t * rb_method_entry_make(VALUE klass, ID mid, VALUE defined_class, rb_method_visibility_t visi, rb_method_type_t type, const rb_method_definition_t *def, ID original_id, void *opts) { - rb_method_entry_t *me; struct rb_id_table *mtbl; st_data_t data; int make_refined = 0; @@ -686,7 +685,7 @@ rb_method_entry_make(VALUE klass, ID mid, VALUE defined_class, rb_method_visibil rb_add_refined_method_entry(refined_class, mid); } if (type == VM_METHOD_TYPE_REFINED) { - rb_method_entry_t *old_me = lookup_method_table(RCLASS_ORIGIN(klass), mid); + const rb_method_entry_t *old_me = lookup_method_table(RCLASS_ORIGIN(klass), mid); if (old_me) rb_vm_check_redefinition_opt_method(old_me, klass); } else { @@ -696,8 +695,8 @@ rb_method_entry_make(VALUE klass, ID mid, VALUE defined_class, rb_method_visibil /* check re-definition */ if (rb_id_table_lookup(mtbl, mid, &data)) { - rb_method_entry_t *old_me = (rb_method_entry_t *)data; - const rb_method_definition_t *old_def = old_me->def; + const rb_method_entry_t *old_me = (const rb_method_entry_t *)data; + const rb_method_definition_t *old_def = old_me->def; if (rb_method_definition_eq(old_def, def)) return old_me; rb_vm_check_redefinition_opt_method(old_me, klass); @@ -737,12 +736,13 @@ rb_method_entry_make(VALUE klass, ID mid, VALUE defined_class, rb_method_visibil if (!def) { def = rb_method_definition_create(type, original_id, opts); } - me = rb_method_entry_alloc( - method_entry_flags(visi), - mid, - defined_class, - filter_defined_class(defined_class), - def); + const rb_method_entry_t *me = + rb_method_entry_alloc( + method_entry_flags(visi), + mid, + defined_class, + filter_defined_class(defined_class), + def); rb_clear_method_cache_by_class(klass); @@ -816,17 +816,17 @@ rb_add_method_iseq(VALUE klass, ID mid, const rb_iseq_t *iseq, rb_cref_t *cref, rb_add_method(klass, mid, VM_METHOD_TYPE_ISEQ, &iseq_body, visi); } -static rb_method_entry_t * +static const rb_method_entry_t * method_entry_set(VALUE klass, ID mid, const rb_method_entry_t *me, rb_method_visibility_t visi, VALUE defined_class) { - rb_method_entry_t *newme = rb_method_entry_make(klass, mid, defined_class, visi, + const rb_method_entry_t *newme = rb_method_entry_make(klass, mid, defined_class, visi, me->def->type, method_definition_addref(me->def), 0, NULL); method_added(klass, mid); return newme; } -rb_method_entry_t * +const rb_method_entry_t * rb_method_entry_set(VALUE klass, ID mid, const rb_method_entry_t *me, rb_method_visibility_t visi) { return method_entry_set(klass, mid, me, visi, klass); @@ -860,10 +860,10 @@ rb_get_alloc_func(VALUE klass) return 0; } -static inline rb_method_entry_t* +static inline const rb_method_entry_t* search_method(VALUE klass, ID id, VALUE *defined_class_ptr) { - rb_method_entry_t *me; + const rb_method_entry_t *me; for (; klass; klass = RCLASS_SUPER(klass)) { RB_DEBUG_COUNTER_INC(mc_search_super); @@ -887,12 +887,12 @@ rb_method_entry_at(VALUE klass, ID id) * if you need method entry with method cache (normal case), use * rb_method_entry() simply. */ -static rb_method_entry_t * +static const rb_method_entry_t * method_entry_get_without_cache(VALUE klass, ID id, VALUE *defined_class_ptr) { VALUE defined_class; - rb_method_entry_t *me = search_method(klass, id, &defined_class); + const rb_method_entry_t *me = search_method(klass, id, &defined_class); if (ruby_running) { if (OPT_GLOBAL_METHOD_CACHE) { @@ -924,11 +924,11 @@ method_entry_get_without_cache(VALUE klass, ID id, } static void -verify_method_cache(VALUE klass, ID id, VALUE defined_class, rb_method_entry_t *me) +verify_method_cache(VALUE klass, ID id, VALUE defined_class, const rb_method_entry_t *me) { if (!VM_DEBUG_VERIFY_METHOD_CACHE) return; VALUE actual_defined_class; - rb_method_entry_t *actual_me = + const rb_method_entry_t *actual_me = method_entry_get_without_cache(klass, id, &actual_defined_class); if (me != actual_me || defined_class != actual_defined_class) { @@ -936,7 +936,7 @@ verify_method_cache(VALUE klass, ID id, VALUE defined_class, rb_method_entry_t * } } -static rb_method_entry_t * +static const rb_method_entry_t * method_entry_get(VALUE klass, ID id, VALUE *defined_class_ptr) { struct cache_entry *ent; @@ -977,7 +977,7 @@ prepare_callable_method_entry(VALUE defined_class, ID id, const rb_method_entry_ if (mtbl && rb_id_table_lookup(mtbl, id, (VALUE *)&me)) { RB_DEBUG_COUNTER_INC(mc_cme_complement_hit); - cme = (rb_callable_method_entry_t *)me; + cme = (const rb_callable_method_entry_t *)me; VM_ASSERT(callable_method_entry_p(cme)); } else { @@ -1001,7 +1001,7 @@ MJIT_FUNC_EXPORTED const rb_callable_method_entry_t * rb_callable_method_entry(VALUE klass, ID id) { VALUE defined_class; - rb_method_entry_t *me = method_entry_get(klass, id, &defined_class); + const rb_method_entry_t *me = method_entry_get(klass, id, &defined_class); return prepare_callable_method_entry(defined_class, id, me); } @@ -1115,7 +1115,7 @@ static void remove_method(VALUE klass, ID mid) { VALUE data; - rb_method_entry_t *me = 0; + const rb_method_entry_t *me = NULL; VALUE self = klass; klass = RCLASS_ORIGIN(klass); @@ -1125,7 +1125,7 @@ remove_method(VALUE klass, ID mid) } if (!rb_id_table_lookup(RCLASS_M_TBL(klass), mid, &data) || - !(me = (rb_method_entry_t *)data) || + !(me = (const rb_method_entry_t *)data) || (!me->def || me->def->type == VM_METHOD_TYPE_UNDEF) || UNDEFINED_REFINED_METHOD_P(me->def)) { rb_name_err_raise("method `%1$s' not defined in %2$s", @@ -1183,10 +1183,18 @@ rb_mod_remove_method(int argc, VALUE *argv, VALUE mod) return mod; } +static inline void +METHOD_ENTRY_VISI_SET(rb_method_entry_t *me, rb_method_visibility_t visi) +{ + VM_ASSERT((int)visi >= 0 && visi <= 3); + VALUE flags = (me->flags & ~(IMEMO_FL_USER0 | IMEMO_FL_USER1)) | (visi << (IMEMO_FL_USHIFT+0)); + memcpy((void *)&me->flags, &flags, sizeof flags); +} + static void rb_export_method(VALUE klass, ID name, rb_method_visibility_t visi) { - rb_method_entry_t *me; + const rb_method_entry_t *me; VALUE defined_class; VALUE origin_class = RCLASS_ORIGIN(klass); @@ -1204,7 +1212,7 @@ rb_export_method(VALUE klass, ID name, rb_method_visibility_t visi) rb_vm_check_redefinition_opt_method(me, klass); if (klass == defined_class || origin_class == defined_class) { - METHOD_ENTRY_VISI_SET(me, visi); + METHOD_ENTRY_VISI_SET((rb_method_entry_t *)me, visi); if (me->def->type == VM_METHOD_TYPE_REFINED && me->def->body.refined.orig_me) { METHOD_ENTRY_VISI_SET((rb_method_entry_t *)me->def->body.refined.orig_me, visi); @@ -1732,7 +1740,7 @@ rb_alias(VALUE klass, ID alias_name, ID original_name) method_added(target_klass, alias_name); } else { - rb_method_entry_t *alias_me; + const rb_method_entry_t *alias_me; alias_me = method_entry_set(target_klass, alias_name, orig_me, visi, orig_me->owner); RB_OBJ_WRITE(alias_me, &alias_me->owner, target_klass); @@ -1923,7 +1931,7 @@ rb_mod_ruby2_keywords(int argc, VALUE *argv, VALUE module) for (i = 0; i < argc; i++) { VALUE v = argv[i]; ID name = rb_check_id(&v); - rb_method_entry_t *me; + const rb_method_entry_t *me; VALUE defined_class; if (!name) { -- cgit v1.2.3