From 14c7a9c548ce7a1e38812fb4490e7c1a838652dc Mon Sep 17 00:00:00 2001
From: "Yukihiro \"Matz\" Matsumoto" <matz@ruby.or.jp>
Date: Thu, 2 Aug 2018 21:08:50 +0900
Subject: Revert 04dbbff.

Use segment list for instance variable again to reduce memory.
---
 src/variable.c | 335 +++++++++++++++++++++++++++++++++++----------------------
 1 file changed, 205 insertions(+), 130 deletions(-)

(limited to 'src/variable.c')

diff --git a/src/variable.c b/src/variable.c
index de36efac6..cbfdb2f2d 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -12,152 +12,243 @@
 
 typedef int (iv_foreach_func)(mrb_state*,mrb_sym,mrb_value,void*);
 
-#include <mruby/khash.h>
-
-#ifndef MRB_IVHASH_INIT_SIZE
-#define MRB_IVHASH_INIT_SIZE KHASH_MIN_SIZE
+#ifndef MRB_IV_SEGMENT_SIZE
+#define MRB_IV_SEGMENT_SIZE 4
 #endif
 
-KHASH_DECLARE(iv, mrb_sym, mrb_value, TRUE)
-KHASH_DEFINE(iv, mrb_sym, mrb_value, TRUE, kh_int_hash_func, kh_int_hash_equal)
+typedef struct segment {
+  mrb_sym key[MRB_IV_SEGMENT_SIZE];
+  mrb_value val[MRB_IV_SEGMENT_SIZE];
+  struct segment *next;
+} segment;
 
 /* Instance variable table structure */
 typedef struct iv_tbl {
-  khash_t(iv) h;
+  segment *rootseg;
+  size_t size;
+  size_t last_len;
 } iv_tbl;
 
-/*
- * Creates the instance variable table.
- *
- * Parameters
- *   mrb
- * Returns
- *   the instance variable table.
- */
+/* Creates the instance variable table. */
 static iv_tbl*
 iv_new(mrb_state *mrb)
 {
-  return (iv_tbl*)kh_init_size(iv, mrb, MRB_IVHASH_INIT_SIZE);
+  iv_tbl *t;
+
+  t = (iv_tbl*)mrb_malloc(mrb, sizeof(iv_tbl));
+  t->size = 0;
+  t->rootseg =  NULL;
+  t->last_len = 0;
+
+  return t;
 }
 
-/*
- * Set the value for the symbol in the instance variable table.
- *
- * Parameters
- *   mrb
- *   t     the instance variable table to be set in.
- *   sym   the symbol to be used as the key.
- *   val   the value to be set.
- */
+/* Set the value for the symbol in the instance variable table. */
 static void
 iv_put(mrb_state *mrb, iv_tbl *t, mrb_sym sym, mrb_value val)
 {
-  khash_t(iv) *h = &t->h;
-  khiter_t k;
+  segment *seg;
+  segment *prev = NULL;
+  segment *matched_seg = NULL;
+  size_t matched_idx = 0;
+  size_t i;
 
-  k = kh_put(iv, mrb, h, sym);
-  kh_value(h, k) = val;
+  if (t == NULL) return;
+  seg = t->rootseg;
+  while (seg) {
+    for (i=0; i<MRB_IV_SEGMENT_SIZE; i++) {
+      mrb_sym key = seg->key[i];
+      /* Found room in last segment after last_len */
+      if (!seg->next && i >= t->last_len) {
+        seg->key[i] = sym;
+        seg->val[i] = val;
+        t->last_len = i+1;
+        t->size++;
+        return;
+      }
+      if (!matched_seg && key == 0) {
+        matched_seg = seg;
+        matched_idx = i;
+      }
+      else if (key == sym) {
+        seg->val[i] = val;
+        return;
+      }
+    }
+    prev = seg;
+    seg = seg->next;
+  }
+
+  /* Not found */
+  t->size++;
+  if (matched_seg) {
+    matched_seg->key[matched_idx] = sym;
+    matched_seg->val[matched_idx] = val;
+    return;
+  }
+
+  seg = (segment*)mrb_malloc(mrb, sizeof(segment));
+  if (!seg) return;
+  seg->next = NULL;
+  seg->key[0] = sym;
+  seg->val[0] = val;
+  t->last_len = 1;
+  if (prev) {
+    prev->next = seg;
+  }
+  else {
+    t->rootseg = seg;
+  }
 }
 
-/*
- * Get a value for a symbol from the instance variable table.
- *
- * Parameters
- *   mrb
- *   t     the variable table to be searched.
- *   sym   the symbol to be used as the key.
- *   vp    the value pointer. Receives the value if the specified symbol is
- *         contained in the instance variable table.
- * Returns
- *   true if the specified symbol is contained in the instance variable table.
- */
+/* Get a value for a symbol from the instance variable table. */
 static mrb_bool
 iv_get(mrb_state *mrb, iv_tbl *t, mrb_sym sym, mrb_value *vp)
 {
-  khash_t(iv) *h = &t->h;
-  khiter_t k;
+  segment *seg;
+  size_t i;
 
-  k = kh_get(iv, mrb, h, sym);
-  if (k != kh_end(h)) {
-    if (vp) *vp = kh_value(h, k);
-    return TRUE;
+  if (t == NULL) return FALSE;
+  seg = t->rootseg;
+  while (seg) {
+    for (i=0; i<MRB_IV_SEGMENT_SIZE; i++) {
+      mrb_sym key = seg->key[i];
+
+      if (!seg->next && i >= t->last_len) {
+        return FALSE;
+      }
+      if (key == sym) {
+        if (vp) *vp = seg->val[i];
+        return TRUE;
+      }
+    }
+    seg = seg->next;
   }
   return FALSE;
 }
 
-/*
- * Deletes the value for the symbol from the instance variable table.
- *
- * Parameters
- *   t    the variable table to be searched.
- *   sym  the symbol to be used as the key.
- *   vp   the value pointer. Receive the deleted value if the symbol is
- *        contained in the instance variable table.
- * Returns
- *   true if the specified symbol is contained in the instance variable table.
- */
+/* Deletes the value for the symbol from the instance variable table. */
 static mrb_bool
 iv_del(mrb_state *mrb, iv_tbl *t, mrb_sym sym, mrb_value *vp)
 {
+  segment *seg;
+  size_t i;
+
   if (t == NULL) return FALSE;
-  else {
-    khash_t(iv) *h = &t->h;
-    khiter_t k;
-
-    k = kh_get(iv, mrb, h, sym);
-    if (k != kh_end(h)) {
-      mrb_value val = kh_value(h, k);
-      kh_del(iv, mrb, h, k);
-      if (vp) *vp = val;
-      return TRUE;
+  seg = t->rootseg;
+  while (seg) {
+    for (i=0; i<MRB_IV_SEGMENT_SIZE; i++) {
+      mrb_sym key = seg->key[i];
+
+      if (!seg->next && i >= t->last_len) {
+        return FALSE;
+      }
+      if (key == sym) {
+        t->size--;
+        seg->key[i] = 0;
+        if (vp) *vp = seg->val[i];
+        return TRUE;
+      }
     }
+    seg = seg->next;
   }
   return FALSE;
 }
 
+/* Iterates over the instance variable table. */
 static mrb_bool
 iv_foreach(mrb_state *mrb, iv_tbl *t, iv_foreach_func *func, void *p)
 {
-  if (t == NULL) {
-    return TRUE;
-  }
-  else {
-    khash_t(iv) *h = &t->h;
-    khiter_t k;
-    int n;
+  segment *seg;
+  size_t i;
+  int n;
+
+  if (t == NULL) return TRUE;
+  seg = t->rootseg;
+  while (seg) {
+    for (i=0; i<MRB_IV_SEGMENT_SIZE; i++) {
+      mrb_sym key = seg->key[i];
 
-    for (k = kh_begin(h); k != kh_end(h); k++) {
-      if (kh_exist(h, k)) {
-        n = (*func)(mrb, kh_key(h, k), kh_value(h, k), p);
+      /* no value in last segment after last_len */
+      if (!seg->next && i >= t->last_len) {
+        return FALSE;
+      }
+      if (key != 0) {
+        n =(*func)(mrb, key, seg->val[i], p);
         if (n > 0) return FALSE;
         if (n < 0) {
-          kh_del(iv, mrb, h, k);
+          t->size--;
+          seg->key[i] = 0;
         }
       }
     }
+    seg = seg->next;
   }
   return TRUE;
 }
 
+/* Get the size of the instance variable table. */
 static size_t
 iv_size(mrb_state *mrb, iv_tbl *t)
 {
-  if (t) {
-    return kh_size(&t->h);
+  segment *seg;
+  size_t size = 0;
+
+  if (t == NULL) return 0;
+  if (t->size > 0) return t->size;
+  seg = t->rootseg;
+  while (seg) {
+    if (seg->next == NULL) {
+      size += t->last_len;
+      return size;
+    }
+    seg = seg->next;
+    size += MRB_IV_SEGMENT_SIZE;
   }
+  /* empty iv_tbl */
   return 0;
 }
 
+/* Copy the instance variable table. */
 static iv_tbl*
 iv_copy(mrb_state *mrb, iv_tbl *t)
 {
-  return (iv_tbl*)kh_copy(iv, mrb, &t->h);
+  segment *seg;
+  iv_tbl *t2;
+
+  size_t i;
+
+  seg = t->rootseg;
+  t2 = iv_new(mrb);
+
+  while (seg != NULL) {
+    for (i=0; i<MRB_IV_SEGMENT_SIZE; i++) {
+      mrb_sym key = seg->key[i];
+      mrb_value val = seg->val[i];
+
+      if ((seg->next == NULL) && (i >= t->last_len)) {
+        return t2;
+      }
+      iv_put(mrb, t2, key, val);
+    }
+    seg = seg->next;
+  }
+  return t2;
 }
 
+/* Free memory of the instance variable table. */
 static void
 iv_free(mrb_state *mrb, iv_tbl *t)
 {
-  kh_destroy(iv, mrb, &t->h);
+  segment *seg;
+
+  seg = t->rootseg;
+  while (seg) {
+    segment *p = seg;
+    seg = seg->next;
+    mrb_free(mrb, p);
+  }
+  mrb_free(mrb, t);
 }
 
 static int
@@ -170,9 +261,7 @@ iv_mark_i(mrb_state *mrb, mrb_sym sym, mrb_value v, void *p)
 static void
 mark_tbl(mrb_state *mrb, iv_tbl *t)
 {
-  if (t) {
-    iv_foreach(mrb, t, iv_mark_i, 0);
-  }
+  iv_foreach(mrb, t, iv_mark_i, 0);
 }
 
 void
@@ -258,16 +347,17 @@ mrb_iv_get(mrb_state *mrb, mrb_value obj, mrb_sym sym)
 MRB_API void
 mrb_obj_iv_set(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
 {
-  iv_tbl *t = obj->iv;
+  iv_tbl *t;
 
   if (MRB_FROZEN_P(obj)) {
     mrb_raisef(mrb, E_FROZEN_ERROR, "can't modify frozen %S", mrb_obj_value(obj));
   }
-  if (!t) {
-    t = obj->iv = iv_new(mrb);
+  if (!obj->iv) {
+    obj->iv = iv_new(mrb);
   }
-  mrb_write_barrier(mrb, (struct RBasic*)obj);
+  t = obj->iv;
   iv_put(mrb, t, sym, v);
+  mrb_write_barrier(mrb, (struct RBasic*)obj);
 }
 
 MRB_API void
@@ -401,7 +491,7 @@ mrb_iv_remove(mrb_state *mrb, mrb_value obj, mrb_sym sym)
     iv_tbl *t = mrb_obj_ptr(obj)->iv;
     mrb_value val;
 
-    if (t && iv_del(mrb, t, sym, &val)) {
+    if (iv_del(mrb, t, sym, &val)) {
       return val;
     }
   }
@@ -460,7 +550,7 @@ mrb_obj_instance_variables(mrb_state *mrb, mrb_value self)
   mrb_value ary;
 
   ary = mrb_ary_new(mrb);
-  if (obj_iv_p(self) && mrb_obj_ptr(self)->iv) {
+  if (obj_iv_p(self)) {
     iv_foreach(mrb, mrb_obj_ptr(self)->iv, iv_i, &ary);
   }
   return ary;
@@ -506,9 +596,7 @@ mrb_mod_class_variables(mrb_state *mrb, mrb_value mod)
   ary = mrb_ary_new(mrb);
   c = mrb_class_ptr(mod);
   while (c) {
-    if (c->iv) {
-      iv_foreach(mrb, c->iv, cv_i, &ary);
-    }
+    iv_foreach(mrb, c->iv, cv_i, &ary);
     c = c->super;
   }
   return ary;
@@ -563,14 +651,12 @@ mrb_mod_cv_set(mrb_state *mrb, struct RClass *c, mrb_sym sym, mrb_value v)
   struct RClass * cls = c;
 
   while (c) {
-    if (c->iv) {
-      iv_tbl *t = c->iv;
+    iv_tbl *t = c->iv;
 
-      if (iv_get(mrb, t, sym, NULL)) {
-        mrb_write_barrier(mrb, (struct RBasic*)c);
-        iv_put(mrb, t, sym, v);
-        return;
-      }
+    if (iv_get(mrb, t, sym, NULL)) {
+      iv_put(mrb, t, sym, v);
+      mrb_write_barrier(mrb, (struct RBasic*)c);
+      return;
     }
     c = c->super;
   }
@@ -599,8 +685,8 @@ mrb_mod_cv_set(mrb_state *mrb, struct RClass *c, mrb_sym sym, mrb_value v)
     c->iv = iv_new(mrb);
   }
 
-  mrb_write_barrier(mrb, (struct RBasic*)c);
   iv_put(mrb, c->iv, sym, v);
+  mrb_write_barrier(mrb, (struct RBasic*)c);
 }
 
 MRB_API void
@@ -613,10 +699,8 @@ MRB_API mrb_bool
 mrb_mod_cv_defined(mrb_state *mrb, struct RClass * c, mrb_sym sym)
 {
   while (c) {
-    if (c->iv) {
-      iv_tbl *t = c->iv;
-      if (iv_get(mrb, t, sym, NULL)) return TRUE;
-    }
+    iv_tbl *t = c->iv;
+    if (iv_get(mrb, t, sym, NULL)) return TRUE;
     c = c->super;
   }
 
@@ -672,7 +756,7 @@ const_get(mrb_state *mrb, struct RClass *base, mrb_sym sym, mrb_bool top)
 
 L_RETRY:
   while (c) {
-    if (c->iv && (top || c != oclass || base == oclass)) {
+    if (top || c != oclass || base == oclass) {
       if (iv_get(mrb, c->iv, sym, &v))
         return v;
     }
@@ -703,22 +787,25 @@ mrb_vm_const_get(mrb_state *mrb, mrb_sym sym)
   struct RProc *proc;
 
   c = MRB_PROC_TARGET_CLASS(mrb->c->ci->proc);
-  if (c->iv && iv_get(mrb, c->iv, sym, &v)) {
+  if (iv_get(mrb, c->iv, sym, &v)) {
     return v;
   }
   c2 = c;
   while (c2 && c2->tt == MRB_TT_SCLASS) {
     mrb_value klass;
-    klass = mrb_obj_iv_get(mrb, (struct RObject *)c2,
-                           mrb_intern_lit(mrb, "__attached__"));
+
+    if (!iv_get(mrb, c2->iv, mrb_intern_lit(mrb, "__attached__"), &klass)) {
+      c2 = NULL;
+      break;
+    }
     c2 = mrb_class_ptr(klass);
   }
-  if (c2->tt == MRB_TT_CLASS || c2->tt == MRB_TT_MODULE) c = c2;
+  if (c2 && (c2->tt == MRB_TT_CLASS || c2->tt == MRB_TT_MODULE)) c = c2;
   mrb_assert(!MRB_PROC_CFUNC_P(mrb->c->ci->proc));
   proc = mrb->c->ci->proc;
   while (proc) {
     c2 = MRB_PROC_TARGET_CLASS(proc);
-    if (c2 && c2->iv && iv_get(mrb, c2->iv, sym, &v)) { 
+    if (c2 && iv_get(mrb, c2->iv, sym, &v)) { 
       return v;
     }
     proc = proc->upper;
@@ -796,9 +883,7 @@ mrb_mod_constants(mrb_state *mrb, mrb_value mod)
   mrb_get_args(mrb, "|b", &inherit);
   ary = mrb_ary_new(mrb);
   while (c) {
-    if (c->iv) {
-      iv_foreach(mrb, c->iv, const_i, &ary);
-    }
+    iv_foreach(mrb, c->iv, const_i, &ary);
     if (!inherit) break;
     c = c->super;
     if (c == mrb->object_class) break;
@@ -811,9 +896,6 @@ mrb_gv_get(mrb_state *mrb, mrb_sym sym)
 {
   mrb_value v;
 
-  if (!mrb->globals) {
-    return mrb_nil_value();
-  }
   if (iv_get(mrb, mrb->globals, sym, &v))
     return v;
   return mrb_nil_value();
@@ -825,20 +907,15 @@ mrb_gv_set(mrb_state *mrb, mrb_sym sym, mrb_value v)
   iv_tbl *t;
 
   if (!mrb->globals) {
-    t = mrb->globals = iv_new(mrb);
-  }
-  else {
-    t = mrb->globals;
+    mrb->globals = iv_new(mrb);
   }
+  t = mrb->globals;
   iv_put(mrb, t, sym, v);
 }
 
 MRB_API void
 mrb_gv_remove(mrb_state *mrb, mrb_sym sym)
 {
-  if (!mrb->globals) {
-    return;
-  }
   iv_del(mrb, mrb->globals, sym, NULL);
 }
 
@@ -870,9 +947,7 @@ mrb_f_global_variables(mrb_state *mrb, mrb_value self)
   size_t i;
   char buf[3];
 
-  if (t) {
-    iv_foreach(mrb, t, gv_i, &ary);
-  }
+  iv_foreach(mrb, t, gv_i, &ary);
   buf[0] = '$';
   buf[2] = 0;
   for (i = 1; i <= 9; ++i) {
@@ -892,7 +967,7 @@ mrb_const_defined_0(mrb_state *mrb, mrb_value mod, mrb_sym id, mrb_bool exclude,
   tmp = klass;
 retry:
   while (tmp) {
-    if (tmp->iv && iv_get(mrb, tmp->iv, id, NULL)) {
+    if (iv_get(mrb, tmp->iv, id, NULL)) {
       return TRUE;
     }
     if (!recurse && (klass != mrb->object_class)) break;
-- 
cgit v1.2.3


From 8f386f7663b099ec6861ec97e2192cdd71fbf7ff Mon Sep 17 00:00:00 2001
From: "Yukihiro \"Matz\" Matsumoto" <matz@ruby.or.jp>
Date: Thu, 2 Aug 2018 21:14:52 +0900
Subject: Remove utility functions: `mrb_vm_iv_{get,set}`.

---
 include/mruby/variable.h |  2 --
 src/variable.c           | 14 --------------
 src/vm.c                 |  4 ++--
 3 files changed, 2 insertions(+), 18 deletions(-)

(limited to 'src/variable.c')

diff --git a/include/mruby/variable.h b/include/mruby/variable.h
index 5fef83faf..a4394fbd3 100644
--- a/include/mruby/variable.h
+++ b/include/mruby/variable.h
@@ -31,8 +31,6 @@ struct global_entry {
 
 mrb_value mrb_vm_special_get(mrb_state*, mrb_sym);
 void mrb_vm_special_set(mrb_state*, mrb_sym, mrb_value);
-mrb_value mrb_vm_iv_get(mrb_state*, mrb_sym);
-void mrb_vm_iv_set(mrb_state*, mrb_sym, mrb_value);
 mrb_value mrb_vm_cv_get(mrb_state*, mrb_sym);
 void mrb_vm_cv_set(mrb_state*, mrb_sym, mrb_value);
 mrb_value mrb_vm_const_get(mrb_state*, mrb_sym);
diff --git a/src/variable.c b/src/variable.c
index cbfdb2f2d..6612c186f 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -498,20 +498,6 @@ mrb_iv_remove(mrb_state *mrb, mrb_value obj, mrb_sym sym)
   return mrb_undef_value();
 }
 
-mrb_value
-mrb_vm_iv_get(mrb_state *mrb, mrb_sym sym)
-{
-  /* get self */
-  return mrb_iv_get(mrb, mrb->c->stack[0], sym);
-}
-
-void
-mrb_vm_iv_set(mrb_state *mrb, mrb_sym sym, mrb_value v)
-{
-  /* get self */
-  mrb_iv_set(mrb, mrb->c->stack[0], sym, v);
-}
-
 static int
 iv_i(mrb_state *mrb, mrb_sym sym, mrb_value v, void *p)
 {
diff --git a/src/vm.c b/src/vm.c
index 066c6ba2e..2bf8f965d 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -1141,7 +1141,7 @@ RETRY_TRY_BLOCK:
       /* A Bx   R(A) := ivget(Bx) */
       int a = GETARG_A(i);
       int bx = GETARG_Bx(i);
-      mrb_value val = mrb_vm_iv_get(mrb, syms[bx]);
+      mrb_value val = mrb_iv_get(mrb, regs[0], syms[bx]);
       regs[a] = val;
       NEXT;
     }
@@ -1150,7 +1150,7 @@ RETRY_TRY_BLOCK:
       /* A Bx   ivset(Syms(Bx),R(A)) */
       int a = GETARG_A(i);
       int bx = GETARG_Bx(i);
-      mrb_vm_iv_set(mrb, syms[bx], regs[a]);
+      mrb_iv_set(mrb, regs[0], syms[bx], regs[a]);
       NEXT;
     }
 
-- 
cgit v1.2.3


From 0dca6206c1920d388fbf4d125c5984b1af530f2b Mon Sep 17 00:00:00 2001
From: "Yukihiro \"Matz\" Matsumoto" <matz@ruby.or.jp>
Date: Fri, 3 Aug 2018 15:03:09 +0900
Subject: Rename ambiguous function names.

`mrb_iv_p` -> `mrb_iv_name_sym_p`
`mrb_iv_check` -> `mrb_iv_name_sym_check`
---
 include/mruby/variable.h | 4 ++--
 src/class.c              | 4 ++--
 src/kernel.c             | 8 ++++----
 src/variable.c           | 6 +++---
 4 files changed, 11 insertions(+), 11 deletions(-)

(limited to 'src/variable.c')

diff --git a/include/mruby/variable.h b/include/mruby/variable.h
index a4394fbd3..a0fbca1f9 100644
--- a/include/mruby/variable.h
+++ b/include/mruby/variable.h
@@ -40,8 +40,8 @@ MRB_API void mrb_const_set(mrb_state*, mrb_value, mrb_sym, mrb_value);
 MRB_API mrb_bool mrb_const_defined(mrb_state*, mrb_value, mrb_sym);
 MRB_API void mrb_const_remove(mrb_state*, mrb_value, mrb_sym);
 
-MRB_API mrb_bool mrb_iv_p(mrb_state *mrb, mrb_sym sym);
-MRB_API void mrb_iv_check(mrb_state *mrb, mrb_sym sym);
+MRB_API mrb_bool mrb_iv_name_sym_p(mrb_state *mrb, mrb_sym sym);
+MRB_API void mrb_iv_name_sym_check(mrb_state *mrb, mrb_sym sym);
 MRB_API mrb_value mrb_obj_iv_get(mrb_state *mrb, struct RObject *obj, mrb_sym sym);
 MRB_API void mrb_obj_iv_set(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v);
 MRB_API mrb_bool mrb_obj_iv_defined(mrb_state *mrb, struct RObject *obj, mrb_sym sym);
diff --git a/src/class.c b/src/class.c
index 97b5df926..d3a1e2fb2 100644
--- a/src/class.c
+++ b/src/class.c
@@ -1480,7 +1480,7 @@ mrb_mod_attr_reader(mrb_state *mrb, mrb_value mod)
     mrb_str_cat_lit(mrb, str, "@");
     mrb_str_cat_str(mrb, str, name);
     sym = mrb_intern_str(mrb, str);
-    mrb_iv_check(mrb, sym);
+    mrb_iv_name_sym_check(mrb, sym);
     name = mrb_symbol_value(sym);
     p = mrb_proc_new_cfunc_with_env(mrb, attr_reader, 1, &name);
     MRB_METHOD_FROM_PROC(m, p);
@@ -1525,7 +1525,7 @@ mrb_mod_attr_writer(mrb_state *mrb, mrb_value mod)
     mrb_str_cat_lit(mrb, str, "@");
     mrb_str_cat_str(mrb, str, name);
     sym = mrb_intern_str(mrb, str);
-    mrb_iv_check(mrb, sym);
+    mrb_iv_name_sym_check(mrb, sym);
     attr = mrb_symbol_value(sym);
 
     /* prepare method name (name=) */
diff --git a/src/kernel.c b/src/kernel.c
index 7459c83af..50ad50f00 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -575,7 +575,7 @@ mrb_obj_ivar_defined(mrb_state *mrb, mrb_value self)
   mrb_sym sym;
 
   mrb_get_args(mrb, "n", &sym);
-  mrb_iv_check(mrb, sym);
+  mrb_iv_name_sym_check(mrb, sym);
   return mrb_bool_value(mrb_iv_defined(mrb, self, sym));
 }
 
@@ -605,7 +605,7 @@ mrb_obj_ivar_get(mrb_state *mrb, mrb_value self)
   mrb_sym iv_name;
 
   mrb_get_args(mrb, "n", &iv_name);
-  mrb_iv_check(mrb, iv_name);
+  mrb_iv_name_sym_check(mrb, iv_name);
   return mrb_iv_get(mrb, self, iv_name);
 }
 
@@ -636,7 +636,7 @@ mrb_obj_ivar_set(mrb_state *mrb, mrb_value self)
   mrb_value val;
 
   mrb_get_args(mrb, "no", &iv_name, &val);
-  mrb_iv_check(mrb, iv_name);
+  mrb_iv_name_sym_check(mrb, iv_name);
   mrb_iv_set(mrb, self, iv_name, val);
   return val;
 }
@@ -951,7 +951,7 @@ mrb_obj_remove_instance_variable(mrb_state *mrb, mrb_value self)
   mrb_value val;
 
   mrb_get_args(mrb, "n", &sym);
-  mrb_iv_check(mrb, sym);
+  mrb_iv_name_sym_check(mrb, sym);
   val = mrb_iv_remove(mrb, self, sym);
   if (mrb_undef_p(val)) {
     mrb_name_error(mrb, sym, "instance variable %S not defined", mrb_sym2str(mrb, sym));
diff --git a/src/variable.c b/src/variable.c
index 6612c186f..e753f8d29 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -393,7 +393,7 @@ mrb_iv_defined(mrb_state *mrb, mrb_value obj, mrb_sym sym)
 #define identchar(c) (ISALNUM(c) || (c) == '_' || !ISASCII(c))
 
 MRB_API mrb_bool
-mrb_iv_p(mrb_state *mrb, mrb_sym iv_name)
+mrb_iv_name_sym_p(mrb_state *mrb, mrb_sym iv_name)
 {
   const char *s;
   mrb_int i, len;
@@ -409,9 +409,9 @@ mrb_iv_p(mrb_state *mrb, mrb_sym iv_name)
 }
 
 MRB_API void
-mrb_iv_check(mrb_state *mrb, mrb_sym iv_name)
+mrb_iv_name_sym_check(mrb_state *mrb, mrb_sym iv_name)
 {
-  if (!mrb_iv_p(mrb, iv_name)) {
+  if (!mrb_iv_name_sym_p(mrb, iv_name)) {
     mrb_name_error(mrb, iv_name, "'%S' is not allowed as an instance variable name", mrb_sym2str(mrb, iv_name));
   }
 }
-- 
cgit v1.2.3


From 9b5910bd0f674f5948cd1185e07d8a024477d162 Mon Sep 17 00:00:00 2001
From: "Yukihiro \"Matz\" Matsumoto" <matz@ruby.or.jp>
Date: Tue, 4 Sep 2018 21:06:36 +0900
Subject: Revert "Remove top-level constant lookup; CRuby2.5"; fix #4070

This reverts commit c96def7c96c50f3b8e22e47ce31a6c5a37939dfd.
This change was from my misunderstanding.
---
 src/variable.c | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

(limited to 'src/variable.c')

diff --git a/src/variable.c b/src/variable.c
index e753f8d29..00bdb4b8d 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -732,24 +732,23 @@ mod_const_check(mrb_state *mrb, mrb_value mod)
 }
 
 static mrb_value
-const_get(mrb_state *mrb, struct RClass *base, mrb_sym sym, mrb_bool top)
+const_get(mrb_state *mrb, struct RClass *base, mrb_sym sym)
 {
   struct RClass *c = base;
   mrb_value v;
   mrb_bool retry = FALSE;
   mrb_value name;
-  struct RClass *oclass = mrb->object_class;
 
 L_RETRY:
   while (c) {
-    if (top || c != oclass || base == oclass) {
+    if (c->iv) {
       if (iv_get(mrb, c->iv, sym, &v))
         return v;
     }
     c = c->super;
   }
   if (!retry && base->tt == MRB_TT_MODULE) {
-    c = oclass;
+    c = mrb->object_class;
     retry = TRUE;
     goto L_RETRY;
   }
@@ -761,7 +760,7 @@ MRB_API mrb_value
 mrb_const_get(mrb_state *mrb, mrb_value mod, mrb_sym sym)
 {
   mod_const_check(mrb, mod);
-  return const_get(mrb, mrb_class_ptr(mod), sym, FALSE);
+  return const_get(mrb, mrb_class_ptr(mod), sym);
 }
 
 mrb_value
@@ -796,7 +795,7 @@ mrb_vm_const_get(mrb_state *mrb, mrb_sym sym)
     }
     proc = proc->upper;
   }
-  return const_get(mrb, c, sym, TRUE);
+  return const_get(mrb, c, sym);
 }
 
 MRB_API void
-- 
cgit v1.2.3


From 2a24b40d300b1e0072a4a0f7de43b126479bc390 Mon Sep 17 00:00:00 2001
From: dearblue <dearblue@users.noreply.github.com>
Date: Wed, 5 Sep 2018 22:13:46 +0900
Subject: Not set a class/module name into anonymous class/module

---
 src/variable.c | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

(limited to 'src/variable.c')

diff --git a/src/variable.c b/src/variable.c
index 00bdb4b8d..4bb3e4bef 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -1069,8 +1069,10 @@ mrb_class_find_path(mrb_state *mrb, struct RClass *c)
 
   str = mrb_sym2name_len(mrb, name, &len);
   mrb_str_cat(mrb, path, str, len);
-  iv_del(mrb, c->iv, mrb_intern_lit(mrb, "__outer__"), NULL);
-  iv_put(mrb, c->iv, mrb_intern_lit(mrb, "__classname__"), path);
-  mrb_field_write_barrier_value(mrb, (struct RBasic*)c, path);
+  if (RSTRING_PTR(path)[0] != '#') {
+    iv_del(mrb, c->iv, mrb_intern_lit(mrb, "__outer__"), NULL);
+    iv_put(mrb, c->iv, mrb_intern_lit(mrb, "__classname__"), path);
+    mrb_field_write_barrier_value(mrb, (struct RBasic*)c, path);
+  }
   return path;
 }
-- 
cgit v1.2.3


From 9b0ef58a48aced26538f3f9ed2490ce34e2e5840 Mon Sep 17 00:00:00 2001
From: dearblue <dearblue@users.noreply.github.com>
Date: Thu, 6 Sep 2018 00:09:49 +0900
Subject: A class/module name is now defined for meta programing

---
 src/variable.c | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

(limited to 'src/variable.c')

diff --git a/src/variable.c b/src/variable.c
index 4bb3e4bef..a2d002892 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -344,6 +344,8 @@ mrb_iv_get(mrb_state *mrb, mrb_value obj, mrb_sym sym)
   return mrb_nil_value();
 }
 
+static inline void assign_class_name(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v);
+
 MRB_API void
 mrb_obj_iv_set(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
 {
@@ -352,6 +354,7 @@ mrb_obj_iv_set(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
   if (MRB_FROZEN_P(obj)) {
     mrb_raisef(mrb, E_FROZEN_ERROR, "can't modify frozen %S", mrb_obj_value(obj));
   }
+  assign_class_name(mrb, obj, sym, v);
   if (!obj->iv) {
     obj->iv = iv_new(mrb);
   }
@@ -360,6 +363,36 @@ mrb_obj_iv_set(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
   mrb_write_barrier(mrb, (struct RBasic*)obj);
 }
 
+static inline mrb_bool
+is_namespace(enum mrb_vtype tt)
+{
+  return tt == MRB_TT_CLASS || tt == MRB_TT_MODULE ? TRUE : FALSE;
+}
+
+static inline void
+assign_class_name(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
+{
+  if (is_namespace(obj->tt) && is_namespace(mrb_type(v)) && ISUPPER(mrb_sym2name(mrb, sym)[0])) {
+    struct RObject *c = mrb_obj_ptr(v);
+    mrb_sym id_classname = mrb_intern_lit(mrb, "__classname__");
+    mrb_value o = mrb_obj_iv_get(mrb, c, id_classname);
+
+    if (mrb_nil_p(o)) {
+      mrb_sym id_outer = mrb_intern_lit(mrb, "__outer__");
+      o = mrb_obj_iv_get(mrb, c, id_outer);
+
+      if (mrb_nil_p(o)) {
+        if ((struct RClass *)obj == mrb->object_class) {
+          mrb_obj_iv_set(mrb, c, id_classname, mrb_symbol_value(sym));
+        }
+        else {
+          mrb_obj_iv_set(mrb, c, id_outer, mrb_obj_value(obj));
+        }
+      }
+    }
+  }
+}
+
 MRB_API void
 mrb_iv_set(mrb_state *mrb, mrb_value obj, mrb_sym sym, mrb_value v)
 {
-- 
cgit v1.2.3


From 1997fcf98f596f6af2bf1d20ccde1b1abfe7324d Mon Sep 17 00:00:00 2001
From: dearblue <dearblue@users.noreply.github.com>
Date: Fri, 7 Sep 2018 22:00:18 +0900
Subject: Add MRB_IMPROVE_META_PROGRAMMING configuration

---
 include/mrbconf.h |  3 +++
 src/variable.c    | 10 ++++++++++
 2 files changed, 13 insertions(+)

(limited to 'src/variable.c')

diff --git a/include/mrbconf.h b/include/mrbconf.h
index cc28acfaa..379386896 100644
--- a/include/mrbconf.h
+++ b/include/mrbconf.h
@@ -110,6 +110,9 @@
 /* fixed size state atexit stack */
 //#define MRB_FIXED_STATE_ATEXIT_STACK
 
+/* improve meta programming support */
+//#define MRB_IMPROVE_META_PROGRAMMING
+
 /* -DMRB_DISABLE_XXXX to drop following features */
 //#define MRB_DISABLE_STDIO /* use of stdio */
 
diff --git a/src/variable.c b/src/variable.c
index a2d002892..047c96e8a 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -344,7 +344,9 @@ mrb_iv_get(mrb_state *mrb, mrb_value obj, mrb_sym sym)
   return mrb_nil_value();
 }
 
+#ifdef MRB_IMPROVE_META_PROGRAMMING
 static inline void assign_class_name(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v);
+#endif
 
 MRB_API void
 mrb_obj_iv_set(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
@@ -354,7 +356,9 @@ mrb_obj_iv_set(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
   if (MRB_FROZEN_P(obj)) {
     mrb_raisef(mrb, E_FROZEN_ERROR, "can't modify frozen %S", mrb_obj_value(obj));
   }
+#ifdef MRB_IMPROVE_META_PROGRAMMING
   assign_class_name(mrb, obj, sym, v);
+#endif
   if (!obj->iv) {
     obj->iv = iv_new(mrb);
   }
@@ -363,6 +367,7 @@ mrb_obj_iv_set(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
   mrb_write_barrier(mrb, (struct RBasic*)obj);
 }
 
+#ifdef MRB_IMPROVE_META_PROGRAMMING
 static inline mrb_bool
 is_namespace(enum mrb_vtype tt)
 {
@@ -392,6 +397,7 @@ assign_class_name(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
     }
   }
 }
+#endif
 
 MRB_API void
 mrb_iv_set(mrb_state *mrb, mrb_value obj, mrb_sym sym, mrb_value v)
@@ -1102,10 +1108,14 @@ mrb_class_find_path(mrb_state *mrb, struct RClass *c)
 
   str = mrb_sym2name_len(mrb, name, &len);
   mrb_str_cat(mrb, path, str, len);
+#ifdef MRB_IMPROVE_META_PROGRAMMING
   if (RSTRING_PTR(path)[0] != '#') {
+#endif
     iv_del(mrb, c->iv, mrb_intern_lit(mrb, "__outer__"), NULL);
     iv_put(mrb, c->iv, mrb_intern_lit(mrb, "__classname__"), path);
     mrb_field_write_barrier_value(mrb, (struct RBasic*)c, path);
+#ifdef MRB_IMPROVE_META_PROGRAMMING
   }
+#endif
   return path;
 }
-- 
cgit v1.2.3


From 366848996a6cce8e733246bce6c3f76d797003bb Mon Sep 17 00:00:00 2001
From: dearblue <dearblue@users.noreply.github.com>
Date: Fri, 7 Sep 2018 00:22:36 +0900
Subject: Clear terminated space

---
 examples/targets/build_config_android_arm64-v8a.rb |  4 ++--
 examples/targets/build_config_android_armeabi.rb   |  4 ++--
 mrbgems/mruby-array-ext/test/array.rb              |  2 +-
 mrbgems/mruby-compiler/core/codegen.c              |  8 ++++----
 mrbgems/mruby-random/src/random.c                  |  2 +-
 src/array.c                                        |  2 +-
 src/codedump.c                                     |  2 +-
 src/gc.c                                           |  2 +-
 src/numeric.c                                      |  2 +-
 src/variable.c                                     | 10 +++++-----
 src/vm.c                                           |  4 ++--
 tasks/toolchains/gcc.rake                          |  2 +-
 test/t/kernel.rb                                   |  2 +-
 test/t/syntax.rb                                   |  6 +++---
 14 files changed, 26 insertions(+), 26 deletions(-)

(limited to 'src/variable.c')

diff --git a/examples/targets/build_config_android_arm64-v8a.rb b/examples/targets/build_config_android_arm64-v8a.rb
index 6188c13ec..70b0f4b97 100644
--- a/examples/targets/build_config_android_arm64-v8a.rb
+++ b/examples/targets/build_config_android_arm64-v8a.rb
@@ -15,8 +15,8 @@ end
 
 # Requires Android NDK r13 or later.
 MRuby::CrossBuild.new('android-arm64-v8a') do |conf|
-  params = { 
-    :arch => 'arm64-v8a', 
+  params = {
+    :arch => 'arm64-v8a',
     :platform => 'android-24',
     :toolchain => :clang,
   }
diff --git a/examples/targets/build_config_android_armeabi.rb b/examples/targets/build_config_android_armeabi.rb
index b7eb33a92..17330242a 100644
--- a/examples/targets/build_config_android_armeabi.rb
+++ b/examples/targets/build_config_android_armeabi.rb
@@ -15,8 +15,8 @@ end
 
 # Requires Android NDK r13 or later.
 MRuby::CrossBuild.new('android-armeabi') do |conf|
-  params = { 
-    :arch => 'armeabi', 
+  params = {
+    :arch => 'armeabi',
     :platform => 'android-24',
     :toolchain => :clang,
   }
diff --git a/mrbgems/mruby-array-ext/test/array.rb b/mrbgems/mruby-array-ext/test/array.rb
index 7d810acc2..4f54c65c3 100644
--- a/mrbgems/mruby-array-ext/test/array.rb
+++ b/mrbgems/mruby-array-ext/test/array.rb
@@ -418,5 +418,5 @@ assert('Array#transpose') do
   assert_equal([[1], [2], [3]].transpose, [[1,2,3]])
   assert_equal([[1,2], [3,4], [5,6]].transpose, [[1,3,5], [2,4,6]])
   assert_raise(TypeError) { [1].transpose }
-  assert_raise(IndexError) { [[1], [2,3,4]].transpose } 
+  assert_raise(IndexError) { [[1], [2,3,4]].transpose }
 end
diff --git a/mrbgems/mruby-compiler/core/codegen.c b/mrbgems/mruby-compiler/core/codegen.c
index 8be9a8ebe..74504ffd1 100644
--- a/mrbgems/mruby-compiler/core/codegen.c
+++ b/mrbgems/mruby-compiler/core/codegen.c
@@ -419,7 +419,7 @@ gen_move(codegen_scope *s, uint16_t dst, uint16_t src, int nopeep)
   }
   else {
     struct mrb_insn_data data = mrb_last_insn(s);
-  
+
     switch (data.insn) {
     case OP_MOVE:
       if (dst == src) return;             /* remove useless MOVE */
@@ -456,7 +456,7 @@ gen_return(codegen_scope *s, uint8_t op, uint16_t src)
   }
   else {
     struct mrb_insn_data data = mrb_last_insn(s);
-  
+
     if (data.insn == OP_MOVE && src == data.a) {
       s->pc = s->lastpc;
       genop_1(s, op, data.b);
@@ -764,7 +764,7 @@ lambda_body(codegen_scope *s, node *tree, int blk)
     kd = tail && tail->cdr->cdr->car? 1 : 0;
     /* block argument? */
     ba = tail && tail->cdr->cdr->cdr->car ? 1 : 0;
- 
+
     if (ma > 0x1f || oa > 0x1f || pa > 0x1f || ka > 0x1f) {
       codegen_error(s, "too many formal arguments");
     }
@@ -3118,7 +3118,7 @@ generate_code(mrb_state *mrb, parser_state *p, int val)
   scope->filename_index = p->current_filename_index;
 
   MRB_TRY(&scope->jmp) {
-    mrb->jmp = &scope->jmp; 
+    mrb->jmp = &scope->jmp;
     /* prepare irep */
     codegen(scope, p->tree, val);
     proc = mrb_proc_new(mrb, scope->irep);
diff --git a/mrbgems/mruby-random/src/random.c b/mrbgems/mruby-random/src/random.c
index b865244cc..5b926a228 100644
--- a/mrbgems/mruby-random/src/random.c
+++ b/mrbgems/mruby-random/src/random.c
@@ -219,7 +219,7 @@ mrb_ary_shuffle_bang(mrb_state *mrb, mrb_value ary)
       mrb_int j;
       mrb_value *ptr = RARRAY_PTR(ary);
       mrb_value tmp;
-      
+
 
       j = mrb_fixnum(mrb_random_mt_rand(mrb, random, mrb_fixnum_value(RARRAY_LEN(ary))));
 
diff --git a/src/array.c b/src/array.c
index 2152e292d..f0c32bc7f 100644
--- a/src/array.c
+++ b/src/array.c
@@ -231,7 +231,7 @@ ary_expand_capa(mrb_state *mrb, struct RArray *a, mrb_int len)
 static void
 ary_shrink_capa(mrb_state *mrb, struct RArray *a)
 {
-  
+
   mrb_int capa;
 
   if (ARY_EMBED_P(a)) return;
diff --git a/src/codedump.c b/src/codedump.c
index 454b16b36..30a14f937 100644
--- a/src/codedump.c
+++ b/src/codedump.c
@@ -516,7 +516,7 @@ codedump(mrb_state *mrb, mrb_irep *irep)
 #undef OPCODE
       }
       break;
-      
+
     default:
       printf("OP_unknown (0x%x)\n", ins);
       break;
diff --git a/src/gc.c b/src/gc.c
index 9858e45fc..e429603dd 100644
--- a/src/gc.c
+++ b/src/gc.c
@@ -1559,7 +1559,7 @@ mrb_objspace_each_objects(mrb_state *mrb, mrb_each_object_callback *callback, vo
       mrb->jmp = &c_jmp;
       gc_each_objects(mrb, &mrb->gc, callback, data);
       mrb->jmp = prev_jmp;
-      mrb->gc.iterating = iterating; 
+      mrb->gc.iterating = iterating;
    } MRB_CATCH(&c_jmp) {
       mrb->gc.iterating = iterating;
       mrb->jmp = prev_jmp;
diff --git a/src/numeric.c b/src/numeric.c
index c3e7d77a3..f7f0318e8 100644
--- a/src/numeric.c
+++ b/src/numeric.c
@@ -433,7 +433,7 @@ flo_shift(mrb_state *mrb, mrb_value x, mrb_int width)
     val = trunc(val);
 #else
     if (val > 0){
-        val = floor(val);    
+        val = floor(val);
     } else {
         val = ceil(val);
     }
diff --git a/src/variable.c b/src/variable.c
index 00bdb4b8d..506b4b63e 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -790,7 +790,7 @@ mrb_vm_const_get(mrb_state *mrb, mrb_sym sym)
   proc = mrb->c->ci->proc;
   while (proc) {
     c2 = MRB_PROC_TARGET_CLASS(proc);
-    if (c2 && iv_get(mrb, c2->iv, sym, &v)) { 
+    if (c2 && iv_get(mrb, c2->iv, sym, &v)) {
       return v;
     }
     proc = proc->upper;
@@ -988,25 +988,25 @@ struct csym_arg {
   struct RClass *c;
   mrb_sym sym;
 };
- 
+
 static int
 csym_i(mrb_state *mrb, mrb_sym sym, mrb_value v, void *p)
 {
   struct csym_arg *a = (struct csym_arg*)p;
   struct RClass *c = a->c;
- 
+
   if (mrb_type(v) == c->tt && mrb_class_ptr(v) == c) {
     a->sym = sym;
     return 1;     /* stop iteration */
   }
   return 0;
 }
- 
+
 static mrb_sym
 find_class_sym(mrb_state *mrb, struct RClass *outer, struct RClass *c)
 {
   struct csym_arg arg;
- 
+
   if (!outer) return 0;
   if (outer == c) return 0;
   arg.c = c;
diff --git a/src/vm.c b/src/vm.c
index 9c4580fb3..14c42984e 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -1818,7 +1818,7 @@ RETRY_TRY_BLOCK:
         }
         regs[blk_pos] = *blk; /* move block */
         if (kd) regs[len + 1] = kdict;
- 
+
         /* copy mandatory and optional arguments */
         if (argv0 != argv) {
           value_move(&regs[1], argv, argc-mlen); /* m1 + o */
@@ -2077,7 +2077,7 @@ RETRY_TRY_BLOCK:
           break;
         case OP_R_BREAK:
           if (MRB_PROC_STRICT_P(proc)) goto NORMAL_RETURN;
-          if (MRB_PROC_ORPHAN_P(proc)) { 
+          if (MRB_PROC_ORPHAN_P(proc)) {
             mrb_value exc;
 
           L_BREAK_ERROR:
diff --git a/tasks/toolchains/gcc.rake b/tasks/toolchains/gcc.rake
index fc2e0bff3..e0eb36f26 100644
--- a/tasks/toolchains/gcc.rake
+++ b/tasks/toolchains/gcc.rake
@@ -55,7 +55,7 @@ MRuby::Toolchain.new(:gcc) do |conf, _params|
       @header_search_paths
     end
   end
-  
+
   def conf.enable_sanitizer(*opts)
     fail 'sanitizer already set' if @sanitizer_list
 
diff --git a/test/t/kernel.rb b/test/t/kernel.rb
index a730bdb24..74176fbd0 100644
--- a/test/t/kernel.rb
+++ b/test/t/kernel.rb
@@ -157,7 +157,7 @@ assert('Kernel#clone', '15.3.1.3.8') do
   assert_true a.respond_to?(:test)
   assert_false b.respond_to?(:test)
   assert_true c.respond_to?(:test)
-  
+
   a.freeze
   d = a.clone
   assert_true d.frozen?
diff --git a/test/t/syntax.rb b/test/t/syntax.rb
index c5405aa9c..883cbd1ba 100644
--- a/test/t/syntax.rb
+++ b/test/t/syntax.rb
@@ -454,15 +454,15 @@ assert('multiline comments work correctly') do
 =begin
 this is a comment with nothing after begin and end
 =end
-=begin  this is a comment 
+=begin  this is a comment
 this is a comment with extra after =begin
 =end
 =begin
 this is a comment that has =end with spaces after it
-=end  
+=end
 =begin this is a comment
 this is a comment that has extra after =begin and =end with spaces after it
-=end  
+=end
   line = __LINE__
 =begin	this is a comment
 this is a comment that has extra after =begin and =end with tabs after it
-- 
cgit v1.2.3


From 5e6cd86f6eedea213fbeb5f1e7a5aa0ab303036a Mon Sep 17 00:00:00 2001
From: dearblue <dearblue@users.noreply.github.com>
Date: Fri, 7 Sep 2018 23:56:06 +0900
Subject: Fix to not define outer when outer is itself.

example:
  a = Class.new
  a::A = a
---
 src/class.c    |  2 +-
 src/variable.c | 26 ++++++++++++++------------
 2 files changed, 15 insertions(+), 13 deletions(-)

(limited to 'src/variable.c')

diff --git a/src/class.c b/src/class.c
index 22fe36fb3..96d32b4c5 100644
--- a/src/class.c
+++ b/src/class.c
@@ -65,7 +65,7 @@ mrb_class_name_class(mrb_state *mrb, struct RClass *outer, struct RClass *c, mrb
   else {
     name = mrb_class_path(mrb, outer);
     if (mrb_nil_p(name)) {      /* unnamed outer class */
-      if (outer != mrb->object_class) {
+      if (outer != mrb->object_class && outer != c) {
         mrb_obj_iv_set(mrb, (struct RObject*)c, mrb_intern_lit(mrb, "__outer__"),
                        mrb_obj_value(outer));
       }
diff --git a/src/variable.c b/src/variable.c
index 047c96e8a..20edd56e4 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -377,21 +377,23 @@ is_namespace(enum mrb_vtype tt)
 static inline void
 assign_class_name(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
 {
-  if (is_namespace(obj->tt) && is_namespace(mrb_type(v)) && ISUPPER(mrb_sym2name(mrb, sym)[0])) {
+  if (is_namespace(obj->tt) && is_namespace(mrb_type(v))) {
     struct RObject *c = mrb_obj_ptr(v);
-    mrb_sym id_classname = mrb_intern_lit(mrb, "__classname__");
-    mrb_value o = mrb_obj_iv_get(mrb, c, id_classname);
-
-    if (mrb_nil_p(o)) {
-      mrb_sym id_outer = mrb_intern_lit(mrb, "__outer__");
-      o = mrb_obj_iv_get(mrb, c, id_outer);
+    if (obj != c && ISUPPER(mrb_sym2name(mrb, sym)[0])) {
+      mrb_sym id_classname = mrb_intern_lit(mrb, "__classname__");
+      mrb_value o = mrb_obj_iv_get(mrb, c, id_classname);
 
       if (mrb_nil_p(o)) {
-        if ((struct RClass *)obj == mrb->object_class) {
-          mrb_obj_iv_set(mrb, c, id_classname, mrb_symbol_value(sym));
-        }
-        else {
-          mrb_obj_iv_set(mrb, c, id_outer, mrb_obj_value(obj));
+        mrb_sym id_outer = mrb_intern_lit(mrb, "__outer__");
+        o = mrb_obj_iv_get(mrb, c, id_outer);
+
+        if (mrb_nil_p(o)) {
+          if ((struct RClass *)obj == mrb->object_class) {
+            mrb_obj_iv_set(mrb, c, id_classname, mrb_symbol_value(sym));
+          }
+          else {
+            mrb_obj_iv_set(mrb, c, id_outer, mrb_obj_value(obj));
+          }
         }
       }
     }
-- 
cgit v1.2.3


From 505e6017306e09487a4a7f1b0fb1c9976f4f5ec5 Mon Sep 17 00:00:00 2001
From: "Yukihiro \"Matz\" Matsumoto" <matz@ruby.or.jp>
Date: Thu, 20 Sep 2018 13:53:55 +0900
Subject: Revert "Add MRB_IMPROVE_META_PROGRAMMING configuration"

This reverts commit 1997fcf98f596f6af2bf1d20ccde1b1abfe7324d.
It became the default behavior.
---
 include/mrbconf.h |  3 ---
 src/variable.c    | 10 ----------
 2 files changed, 13 deletions(-)

(limited to 'src/variable.c')

diff --git a/include/mrbconf.h b/include/mrbconf.h
index 379386896..cc28acfaa 100644
--- a/include/mrbconf.h
+++ b/include/mrbconf.h
@@ -110,9 +110,6 @@
 /* fixed size state atexit stack */
 //#define MRB_FIXED_STATE_ATEXIT_STACK
 
-/* improve meta programming support */
-//#define MRB_IMPROVE_META_PROGRAMMING
-
 /* -DMRB_DISABLE_XXXX to drop following features */
 //#define MRB_DISABLE_STDIO /* use of stdio */
 
diff --git a/src/variable.c b/src/variable.c
index 01077a34e..cc7936a46 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -344,9 +344,7 @@ mrb_iv_get(mrb_state *mrb, mrb_value obj, mrb_sym sym)
   return mrb_nil_value();
 }
 
-#ifdef MRB_IMPROVE_META_PROGRAMMING
 static inline void assign_class_name(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v);
-#endif
 
 MRB_API void
 mrb_obj_iv_set(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
@@ -356,9 +354,7 @@ mrb_obj_iv_set(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
   if (MRB_FROZEN_P(obj)) {
     mrb_raisef(mrb, E_FROZEN_ERROR, "can't modify frozen %S", mrb_obj_value(obj));
   }
-#ifdef MRB_IMPROVE_META_PROGRAMMING
   assign_class_name(mrb, obj, sym, v);
-#endif
   if (!obj->iv) {
     obj->iv = iv_new(mrb);
   }
@@ -367,7 +363,6 @@ mrb_obj_iv_set(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
   mrb_write_barrier(mrb, (struct RBasic*)obj);
 }
 
-#ifdef MRB_IMPROVE_META_PROGRAMMING
 static inline mrb_bool
 is_namespace(enum mrb_vtype tt)
 {
@@ -399,7 +394,6 @@ assign_class_name(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
     }
   }
 }
-#endif
 
 MRB_API void
 mrb_iv_set(mrb_state *mrb, mrb_value obj, mrb_sym sym, mrb_value v)
@@ -1110,14 +1104,10 @@ mrb_class_find_path(mrb_state *mrb, struct RClass *c)
 
   str = mrb_sym2name_len(mrb, name, &len);
   mrb_str_cat(mrb, path, str, len);
-#ifdef MRB_IMPROVE_META_PROGRAMMING
   if (RSTRING_PTR(path)[0] != '#') {
-#endif
     iv_del(mrb, c->iv, mrb_intern_lit(mrb, "__outer__"), NULL);
     iv_put(mrb, c->iv, mrb_intern_lit(mrb, "__classname__"), path);
     mrb_field_write_barrier_value(mrb, (struct RBasic*)c, path);
-#ifdef MRB_IMPROVE_META_PROGRAMMING
   }
-#endif
   return path;
 }
-- 
cgit v1.2.3


From 159575f63024c79592229f9c0e7da42a0075dae9 Mon Sep 17 00:00:00 2001
From: "Yukihiro \"Matz\" Matsumoto" <matz@ruby.or.jp>
Date: Thu, 20 Sep 2018 13:57:43 +0900
Subject: Renamed `is_namespace()` to `namespace_p()`.

---
 src/variable.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'src/variable.c')

diff --git a/src/variable.c b/src/variable.c
index cc7936a46..72c13aa1f 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -364,7 +364,7 @@ mrb_obj_iv_set(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
 }
 
 static inline mrb_bool
-is_namespace(enum mrb_vtype tt)
+namespace_p(enum mrb_vtype tt)
 {
   return tt == MRB_TT_CLASS || tt == MRB_TT_MODULE ? TRUE : FALSE;
 }
@@ -372,7 +372,7 @@ is_namespace(enum mrb_vtype tt)
 static inline void
 assign_class_name(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
 {
-  if (is_namespace(obj->tt) && is_namespace(mrb_type(v))) {
+  if (namespace_p(obj->tt) && namespace_p(mrb_type(v))) {
     struct RObject *c = mrb_obj_ptr(v);
     if (obj != c && ISUPPER(mrb_sym2name(mrb, sym)[0])) {
       mrb_sym id_classname = mrb_intern_lit(mrb, "__classname__");
-- 
cgit v1.2.3


From f6b2e6231a1c07438915c2d32ab6002c2a2256b9 Mon Sep 17 00:00:00 2001
From: "Yukihiro \"Matz\" Matsumoto" <matz@ruby.or.jp>
Date: Tue, 11 Dec 2018 09:47:06 +0900
Subject: Update `iv_foreach()` function.

* return `void` instead of `mrb_bool'.
* non zero return value from `func` breaks the loop.
* no longer remove items on negative return value from `func`.
---
 src/variable.c | 16 ++++++----------
 1 file changed, 6 insertions(+), 10 deletions(-)

(limited to 'src/variable.c')

diff --git a/src/variable.c b/src/variable.c
index 72c13aa1f..669a4f5cd 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -156,14 +156,13 @@ iv_del(mrb_state *mrb, iv_tbl *t, mrb_sym sym, mrb_value *vp)
 }
 
 /* Iterates over the instance variable table. */
-static mrb_bool
+static void
 iv_foreach(mrb_state *mrb, iv_tbl *t, iv_foreach_func *func, void *p)
 {
   segment *seg;
   size_t i;
-  int n;
 
-  if (t == NULL) return TRUE;
+  if (t == NULL) return;
   seg = t->rootseg;
   while (seg) {
     for (i=0; i<MRB_IV_SEGMENT_SIZE; i++) {
@@ -171,20 +170,17 @@ iv_foreach(mrb_state *mrb, iv_tbl *t, iv_foreach_func *func, void *p)
 
       /* no value in last segment after last_len */
       if (!seg->next && i >= t->last_len) {
-        return FALSE;
+        return;
       }
       if (key != 0) {
-        n =(*func)(mrb, key, seg->val[i], p);
-        if (n > 0) return FALSE;
-        if (n < 0) {
-          t->size--;
-          seg->key[i] = 0;
+        if ((*func)(mrb, key, seg->val[i], p) != 0) {
+          return;
         }
       }
     }
     seg = seg->next;
   }
-  return TRUE;
+  return;
 }
 
 /* Get the size of the instance variable table. */
-- 
cgit v1.2.3


From a0df27d8e04f5d042040c794b79b9b213e7092e0 Mon Sep 17 00:00:00 2001
From: "Yukihiro \"Matz\" Matsumoto" <matz@ruby.or.jp>
Date: Tue, 11 Dec 2018 09:48:15 +0900
Subject: Add new API `mrb_iv_foreach()` to iterate over instance variables.

---
 include/mruby/variable.h |  4 ++++
 src/variable.c           | 11 +++++++++--
 2 files changed, 13 insertions(+), 2 deletions(-)

(limited to 'src/variable.c')

diff --git a/include/mruby/variable.h b/include/mruby/variable.h
index a0fbca1f9..c031567ea 100644
--- a/include/mruby/variable.h
+++ b/include/mruby/variable.h
@@ -131,6 +131,10 @@ void mrb_gc_mark_iv(mrb_state*, struct RObject*);
 size_t mrb_gc_mark_iv_size(mrb_state*, struct RObject*);
 void mrb_gc_free_iv(mrb_state*, struct RObject*);
 
+/* return non zero to break the loop */
+typedef int (iv_foreach_func)(mrb_state*,mrb_sym,mrb_value,void*);
+MRB_API void mrb_iv_foreach(mrb_state *mrb, mrb_value obj, iv_foreach_func *func, void *p);
+
 MRB_END_DECL
 
 #endif  /* MRUBY_VARIABLE_H */
diff --git a/src/variable.c b/src/variable.c
index 669a4f5cd..fafec81bd 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -9,8 +9,7 @@
 #include <mruby/class.h>
 #include <mruby/proc.h>
 #include <mruby/string.h>
-
-typedef int (iv_foreach_func)(mrb_state*,mrb_sym,mrb_value,void*);
+#include <mruby/variable.h>
 
 #ifndef MRB_IV_SEGMENT_SIZE
 #define MRB_IV_SEGMENT_SIZE 4
@@ -359,6 +358,14 @@ mrb_obj_iv_set(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
   mrb_write_barrier(mrb, (struct RBasic*)obj);
 }
 
+/* Iterates over the instance variable table. */
+MRB_API void
+mrb_iv_foreach(mrb_state *mrb, mrb_value obj, iv_foreach_func *func, void *p)
+{
+  if (!obj_iv_p(obj)) return;
+  iv_foreach(mrb, mrb_obj_ptr(obj)->iv, func, p);
+}
+
 static inline mrb_bool
 namespace_p(enum mrb_vtype tt)
 {
-- 
cgit v1.2.3


From e935d20ab52ddc68d4d55444d0fa3974b035c098 Mon Sep 17 00:00:00 2001
From: "Yukihiro \"Matz\" Matsumoto" <matz@ruby.or.jp>
Date: Tue, 11 Dec 2018 10:39:53 +0900
Subject: Add `mrb_` prefix to `iv_foreach_func`.

---
 include/mruby/variable.h | 4 ++--
 src/variable.c           | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'src/variable.c')

diff --git a/include/mruby/variable.h b/include/mruby/variable.h
index c031567ea..68a2a7121 100644
--- a/include/mruby/variable.h
+++ b/include/mruby/variable.h
@@ -132,8 +132,8 @@ size_t mrb_gc_mark_iv_size(mrb_state*, struct RObject*);
 void mrb_gc_free_iv(mrb_state*, struct RObject*);
 
 /* return non zero to break the loop */
-typedef int (iv_foreach_func)(mrb_state*,mrb_sym,mrb_value,void*);
-MRB_API void mrb_iv_foreach(mrb_state *mrb, mrb_value obj, iv_foreach_func *func, void *p);
+typedef int (mrb_iv_foreach_func)(mrb_state*,mrb_sym,mrb_value,void*);
+MRB_API void mrb_iv_foreach(mrb_state *mrb, mrb_value obj, mrb_iv_foreach_func *func, void *p);
 
 MRB_END_DECL
 
diff --git a/src/variable.c b/src/variable.c
index fafec81bd..14e9da9ef 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -156,7 +156,7 @@ iv_del(mrb_state *mrb, iv_tbl *t, mrb_sym sym, mrb_value *vp)
 
 /* Iterates over the instance variable table. */
 static void
-iv_foreach(mrb_state *mrb, iv_tbl *t, iv_foreach_func *func, void *p)
+iv_foreach(mrb_state *mrb, iv_tbl *t, mrb_iv_foreach_func *func, void *p)
 {
   segment *seg;
   size_t i;
@@ -360,7 +360,7 @@ mrb_obj_iv_set(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
 
 /* Iterates over the instance variable table. */
 MRB_API void
-mrb_iv_foreach(mrb_state *mrb, mrb_value obj, iv_foreach_func *func, void *p)
+mrb_iv_foreach(mrb_state *mrb, mrb_value obj, mrb_iv_foreach_func *func, void *p)
 {
   if (!obj_iv_p(obj)) return;
   iv_foreach(mrb, mrb_obj_ptr(obj)->iv, func, p);
-- 
cgit v1.2.3


From 16b1b2978e4f4d838f3d12e7221139a92429603b Mon Sep 17 00:00:00 2001
From: KOBAYASHI Shuji <shuujii@gmail.com>
Date: Thu, 14 Mar 2019 23:09:05 +0900
Subject: Fix constant name validation

`X!` etc are invalid constant name.
---
 include/mruby/variable.h |  1 +
 src/class.c              |  2 +-
 src/variable.c           | 20 +++++++++++++-------
 test/t/module.rb         | 24 ++++++++++--------------
 4 files changed, 25 insertions(+), 22 deletions(-)

(limited to 'src/variable.c')

diff --git a/include/mruby/variable.h b/include/mruby/variable.h
index 68a2a7121..ba6037959 100644
--- a/include/mruby/variable.h
+++ b/include/mruby/variable.h
@@ -123,6 +123,7 @@ mrb_value mrb_obj_instance_variables(mrb_state*, mrb_value);
 mrb_value mrb_mod_class_variables(mrb_state*, mrb_value);
 mrb_value mrb_mod_cv_get(mrb_state *mrb, struct RClass * c, mrb_sym sym);
 mrb_bool mrb_mod_cv_defined(mrb_state *mrb, struct RClass * c, mrb_sym sym);
+mrb_bool mrb_ident_p(const char *s, mrb_int len);
 
 /* GC functions */
 void mrb_gc_mark_gv(mrb_state*);
diff --git a/src/class.c b/src/class.c
index 9d6fd631f..da95f5c22 100644
--- a/src/class.c
+++ b/src/class.c
@@ -1898,7 +1898,7 @@ mrb_mod_undef(mrb_state *mrb, mrb_value mod)
 static mrb_bool
 const_name_p(mrb_state *mrb, const char *name, mrb_int len)
 {
-  return len > 0 && ISUPPER(name[0]);
+  return len > 0 && ISUPPER(name[0]) && mrb_ident_p(name+1, len-1);
 }
 
 static void
diff --git a/src/variable.c b/src/variable.c
index 14e9da9ef..b712af261 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -428,22 +428,17 @@ mrb_iv_defined(mrb_state *mrb, mrb_value obj, mrb_sym sym)
   return mrb_obj_iv_defined(mrb, mrb_obj_ptr(obj), sym);
 }
 
-#define identchar(c) (ISALNUM(c) || (c) == '_' || !ISASCII(c))
-
 MRB_API mrb_bool
 mrb_iv_name_sym_p(mrb_state *mrb, mrb_sym iv_name)
 {
   const char *s;
-  mrb_int i, len;
+  mrb_int len;
 
   s = mrb_sym2name_len(mrb, iv_name, &len);
   if (len < 2) return FALSE;
   if (s[0] != '@') return FALSE;
   if (s[1] == '@') return FALSE;
-  for (i=1; i<len; i++) {
-    if (!identchar(s[i])) return FALSE;
-  }
-  return TRUE;
+  return mrb_ident_p(s+1, len-1);
 }
 
 MRB_API void
@@ -1114,3 +1109,14 @@ mrb_class_find_path(mrb_state *mrb, struct RClass *c)
   }
   return path;
 }
+
+#define identchar(c) (ISALNUM(c) || (c) == '_' || !ISASCII(c))
+
+mrb_bool
+mrb_ident_p(const char *s, mrb_int len)
+{
+  for (mrb_int i = 0; i < len; i++) {
+    if (!identchar(s[i])) return FALSE;
+  }
+  return TRUE;
+}
diff --git a/test/t/module.rb b/test/t/module.rb
index b2dbe52a2..ec36855e8 100644
--- a/test/t/module.rb
+++ b/test/t/module.rb
@@ -210,6 +210,7 @@ assert('Module#const_defined?', '15.2.2.4.20') do
 
   assert_true Test4ConstDefined.const_defined?(:Const4Test4ConstDefined)
   assert_false Test4ConstDefined.const_defined?(:NotExisting)
+  assert_raise(NameError){ Test4ConstDefined.const_defined?(:wrong_name) }
 end
 
 assert('Module#const_get', '15.2.2.4.21') do
@@ -224,6 +225,7 @@ assert('Module#const_get', '15.2.2.4.21') do
   assert_raise(TypeError){ Test4ConstGet.const_get(123) }
   assert_raise(NameError){ Test4ConstGet.const_get(:I_DO_NOT_EXIST) }
   assert_raise(NameError){ Test4ConstGet.const_get("I_DO_NOT_EXIST::ME_NEITHER") }
+  assert_raise(NameError){ Test4ConstGet.const_get(:wrong_name) }
 end
 
 assert('Module#const_set', '15.2.2.4.23') do
@@ -233,6 +235,9 @@ assert('Module#const_set', '15.2.2.4.23') do
 
   assert_equal 23, Test4ConstSet.const_set(:Const4Test4ConstSet, 23)
   assert_equal 23, Test4ConstSet.const_get(:Const4Test4ConstSet)
+  ["", "wrongNAME", "Wrong-Name"].each do |n|
+    assert_raise(NameError) { Test4ConstSet.const_set(n, 1) }
+  end
 end
 
 assert('Module#remove_const', '15.2.2.4.40') do
@@ -240,21 +245,12 @@ assert('Module#remove_const', '15.2.2.4.40') do
     ExistingConst = 23
   end
 
-  result = Test4RemoveConst.module_eval { remove_const :ExistingConst }
-
-  name_error = false
-  begin
-    Test4RemoveConst.module_eval { remove_const :NonExistingConst }
-  rescue NameError
-    name_error = true
+  assert_equal 23, Test4RemoveConst.remove_const(:ExistingConst)
+  assert_false Test4RemoveConst.const_defined?(:ExistingConst)
+  assert_raise(NameError) { Test4RemoveConst.remove_const(:NonExistingConst) }
+  %i[x X!].each do |n|
+    assert_raise(NameError) { Test4RemoveConst.remove_const(n) }
   end
-
-  # Constant removed from Module
-  assert_false Test4RemoveConst.const_defined? :ExistingConst
-  # Return value of binding
-  assert_equal 23, result
-  # Name Error raised when Constant doesn't exist
-  assert_true name_error
 end
 
 assert('Module#const_missing', '15.2.2.4.22') do
-- 
cgit v1.2.3


From b588e5a5b7cfc0e7a1c84c235a0f5daa5bf83a47 Mon Sep 17 00:00:00 2001
From: KOBAYASHI Shuji <shuujii@gmail.com>
Date: Sun, 17 Mar 2019 16:58:31 +0900
Subject: Fix class/instance variable name validation

- `@@?` etc are invalid class variable name.
- `@1` etc are invalid instance variable name.
---
 mrbgems/mruby-metaprog/src/metaprog.c   |  3 ++-
 mrbgems/mruby-metaprog/test/metaprog.rb | 38 +++++++++++++++++++++++++++++++++
 src/variable.c                          |  2 +-
 test/t/kernel.rb                        |  7 +++---
 4 files changed, 44 insertions(+), 6 deletions(-)

(limited to 'src/variable.c')

diff --git a/mrbgems/mruby-metaprog/src/metaprog.c b/mrbgems/mruby-metaprog/src/metaprog.c
index 75913dab5..0aafb4c34 100644
--- a/mrbgems/mruby-metaprog/src/metaprog.c
+++ b/mrbgems/mruby-metaprog/src/metaprog.c
@@ -403,7 +403,8 @@ mod_define_singleton_method(mrb_state *mrb, mrb_value self)
 static mrb_bool
 cv_name_p(mrb_state *mrb, const char *name, mrb_int len)
 {
-  return len > 2 && name[0] == '@' && name[1] == '@';
+  return len > 2 && name[0] == '@' && name[1] == '@' &&
+         !ISDIGIT(name[2]) && mrb_ident_p(name+2, len-2);
 }
 
 static void
diff --git a/mrbgems/mruby-metaprog/test/metaprog.rb b/mrbgems/mruby-metaprog/test/metaprog.rb
index 8bc3719b8..1262c9945 100644
--- a/mrbgems/mruby-metaprog/test/metaprog.rb
+++ b/mrbgems/mruby-metaprog/test/metaprog.rb
@@ -34,6 +34,30 @@ assert('Kernel#instance_variable_defined?', '15.3.1.3.20') do
   assert_false o.instance_variable_defined?("@b")
   assert_true o.instance_variable_defined?("@a"[0,2])
   assert_true o.instance_variable_defined?("@abc"[0,2])
+  assert_raise(NameError) { o.instance_variable_defined?("@0") }
+end
+
+assert('Kernel#instance_variable_get', '15.3.1.3.21') do
+  o = Class.new { attr_accessor :foo, :bar }.new
+  o.foo = "one"
+  o.bar = 2
+  assert_equal("one", o.instance_variable_get(:@foo))
+  assert_equal(2, o.instance_variable_get("@bar"))
+  assert_equal(nil, o.instance_variable_get(:@baz))
+  %w[foo @1].each do |n|
+    assert_raise(NameError) { o.instance_variable_get(n) }
+  end
+end
+
+assert('Kernel#instance_variable_set', '15.3.1.3.22') do
+  o = Class.new { attr_reader :foo, :_bar }.new
+  assert_equal("one", o.instance_variable_set(:@foo, "one"))
+  assert_equal("one", o.foo)
+  assert_equal(2, o.instance_variable_set("@_bar", 2))
+  assert_equal(2, o._bar)
+  %w[@6 @% @@a @ a].each do |n|
+    assert_raise(NameError) { o.instance_variable_set(n, 1) }
+  end
 end
 
 assert('Kernel#instance_variables', '15.3.1.3.23') do
@@ -125,6 +149,7 @@ assert('Module#class_variable_defined?', '15.2.2.4.16') do
 
   assert_true Test4ClassVariableDefined.class_variable_defined?(:@@cv)
   assert_false Test4ClassVariableDefined.class_variable_defined?(:@@noexisting)
+  assert_raise(NameError) { Test4ClassVariableDefined.class_variable_defined?("@@2") }
 end
 
 assert('Module#class_variable_get', '15.2.2.4.17') do
@@ -133,6 +158,10 @@ assert('Module#class_variable_get', '15.2.2.4.17') do
   end
 
   assert_equal 99, Test4ClassVariableGet.class_variable_get(:@@cv)
+  assert_raise(NameError) { Test4ClassVariableGet.class_variable_get(:@@a) }
+  %w[@@a? @@! @a a].each do |n|
+    assert_raise(NameError) { Test4ClassVariableGet.class_variable_get(n) }
+  end
 end
 
 assert('Module#class_variable_set', '15.2.2.4.18') do
@@ -148,6 +177,9 @@ assert('Module#class_variable_set', '15.2.2.4.18') do
   assert_true Test4ClassVariableSet.class_variables.include? :@@cv
   assert_equal 99, Test4ClassVariableSet.class_variable_get(:@@cv)
   assert_equal 101, Test4ClassVariableSet.new.foo
+  %w[@@ @@1 @@x= @x @ x 1].each do |n|
+    assert_raise(NameError) { Test4ClassVariableSet.class_variable_set(n, 1) }
+  end
 end
 
 assert('Module#class_variables', '15.2.2.4.19') do
@@ -223,6 +255,12 @@ assert('Module#remove_class_variable', '15.2.2.4.39') do
 
   assert_equal 99, Test4RemoveClassVariable.remove_class_variable(:@@cv)
   assert_false Test4RemoveClassVariable.class_variables.include? :@@cv
+  assert_raise(NameError) do
+    Test4RemoveClassVariable.remove_class_variable(:@@cv)
+  end
+  assert_raise(NameError) do
+    Test4RemoveClassVariable.remove_class_variable(:@v)
+  end
 end
 
 assert('Module#remove_method', '15.2.2.4.41') do
diff --git a/src/variable.c b/src/variable.c
index b712af261..90efe9e0e 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -437,7 +437,7 @@ mrb_iv_name_sym_p(mrb_state *mrb, mrb_sym iv_name)
   s = mrb_sym2name_len(mrb, iv_name, &len);
   if (len < 2) return FALSE;
   if (s[0] != '@') return FALSE;
-  if (s[1] == '@') return FALSE;
+  if (ISDIGIT(s[1])) return FALSE;
   return mrb_ident_p(s+1, len-1);
 }
 
diff --git a/test/t/kernel.rb b/test/t/kernel.rb
index 74176fbd0..d99358c0c 100644
--- a/test/t/kernel.rb
+++ b/test/t/kernel.rb
@@ -391,11 +391,10 @@ assert('Kernel#remove_instance_variable', '15.3.1.3.41') do
 
   tri = Test4RemoveInstanceVar.new
   assert_equal 99, tri.var
-  tri.remove
+  assert_equal 99, tri.remove
   assert_equal nil, tri.var
-  assert_raise NameError do
-    tri.remove
-  end
+  assert_raise(NameError) { tri.remove }
+  assert_raise(NameError) { tri.remove_instance_variable(:var) }
 end
 
 # Kernel#require is defined in mruby-require. '15.3.1.3.42'
-- 
cgit v1.2.3


From c2660b8111cd6cd98a41aa257c503cbd3a7cf881 Mon Sep 17 00:00:00 2001
From: "Yukihiro \"Matz\" Matsumoto" <matz@ruby.or.jp>
Date: Tue, 26 Mar 2019 10:23:52 +0900
Subject: Fix missing `MRB_API` prefix for functions below; clse #4267

Functions to add prototypes to headers:
* mrb_ary_splice()
* mrb_notimplement()
* mrb_vformat()
* mrb_cstr_to_dbl()
* mrb_cstr_to_inum()

Functions to be made `static` (`MRB_API` was not needed):
* mrb_mod_module_function()
* mrb_obj_hash()
* mrb_str_len_to_inum()

Functions to remove `MRB_API` from definitions (referenced from within `libmruby`):
* mrb_mod_cv_defined()
* mrb_mod_cv_get()
* mrb_f_send()
---
 include/mruby.h        |  5 +++++
 include/mruby/array.h  | 16 ++++++++++++++++
 include/mruby/error.h  |  2 +-
 include/mruby/string.h |  2 ++
 src/class.c            |  2 +-
 src/kernel.c           |  2 +-
 src/string.c           |  4 ++--
 src/variable.c         |  4 ++--
 src/vm.c               |  2 +-
 9 files changed, 31 insertions(+), 8 deletions(-)

(limited to 'src/variable.c')

diff --git a/include/mruby.h b/include/mruby.h
index 9792d7482..f2c800eec 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -708,6 +708,9 @@ MRB_API struct RClass * mrb_module_get(mrb_state *mrb, const char *name);
  * @return [struct RClass *] A reference to the module.
 */
 MRB_API struct RClass * mrb_module_get_under(mrb_state *mrb, struct RClass *outer, const char *name);
+/* a function to raise NotImplementedError with current method name */
+MRB_API void mrb_notimplement(mrb_state*);
+/* a function to be replacement of unimplemented method */
 MRB_API mrb_value mrb_notimplement_m(mrb_state*, mrb_value);
 
 /**
@@ -1143,6 +1146,8 @@ MRB_API void mrb_warn(mrb_state *mrb, const char *fmt, ...);
 MRB_API mrb_noreturn void mrb_bug(mrb_state *mrb, const char *fmt, ...);
 MRB_API void mrb_print_backtrace(mrb_state *mrb);
 MRB_API void mrb_print_error(mrb_state *mrb);
+/* function for `raisef` formatting */
+MRB_API mrb_value mrb_vformat(mrb_state *mrb, const char *format, va_list ap);
 
 /* macros to get typical exception objects
    note:
diff --git a/include/mruby/array.h b/include/mruby/array.h
index 2457f68f2..2e6951c0d 100644
--- a/include/mruby/array.h
+++ b/include/mruby/array.h
@@ -227,6 +227,22 @@ MRB_API mrb_value mrb_ary_unshift(mrb_state *mrb, mrb_value self, mrb_value item
  */
 MRB_API mrb_value mrb_ary_entry(mrb_value ary, mrb_int offset);
 
+/*
+ * Replace subsequence of an array.
+ *
+ * Equivalent to:
+ *
+ *      ary.shift
+ *
+ * @param mrb The mruby state reference.
+ * @param self The array from which the value will be shifted.
+ * @param head Beginning position of a replacement subsequence.
+ * @param len Length of a replacement subsequence.
+ * @param rpl The array of replacement elements.
+ * @return The receiver array.
+ */
+MRB_API mrb_value mrb_ary_splice(mrb_state *mrb, mrb_value self, mrb_int head, mrb_int len, mrb_value rpl);
+
 /*
  * Shifts the first element from the array.
  *
diff --git a/include/mruby/error.h b/include/mruby/error.h
index 1587795fc..237c701ad 100644
--- a/include/mruby/error.h
+++ b/include/mruby/error.h
@@ -29,7 +29,7 @@ MRB_API mrb_value mrb_exc_backtrace(mrb_state *mrb, mrb_value exc);
 MRB_API mrb_value mrb_get_backtrace(mrb_state *mrb);
 MRB_API mrb_noreturn void mrb_no_method_error(mrb_state *mrb, mrb_sym id, mrb_value args, const char *fmt, ...);
 
-/* declaration for fail method */
+/* declaration for `fail` method */
 MRB_API mrb_value mrb_f_raise(mrb_state*, mrb_value);
 
 struct RBreak {
diff --git a/include/mruby/string.h b/include/mruby/string.h
index 6fe0556b0..0b90debec 100644
--- a/include/mruby/string.h
+++ b/include/mruby/string.h
@@ -352,7 +352,9 @@ MRB_API mrb_value mrb_str_dup(mrb_state *mrb, mrb_value str);
 MRB_API mrb_value mrb_str_intern(mrb_state *mrb, mrb_value self);
 
 MRB_API mrb_value mrb_str_to_inum(mrb_state *mrb, mrb_value str, mrb_int base, mrb_bool badcheck);
+MRB_API mrb_value mrb_cstr_to_inum(mrb_state *mrb, const char *s, mrb_int base, mrb_bool badcheck);
 MRB_API double mrb_str_to_dbl(mrb_state *mrb, mrb_value str, mrb_bool badcheck);
+MRB_API double mrb_cstr_to_dbl(mrb_state *mrb, const char *s, mrb_bool badcheck);
 
 /*
  * Returns a converted string type.
diff --git a/src/class.c b/src/class.c
index da95f5c22..3354617bb 100644
--- a/src/class.c
+++ b/src/class.c
@@ -2106,7 +2106,7 @@ mrb_mod_eqq(mrb_state *mrb, mrb_value mod)
   return mrb_bool_value(eqq);
 }
 
-MRB_API mrb_value
+static mrb_value
 mrb_mod_module_function(mrb_state *mrb, mrb_value mod)
 {
   mrb_value *argv;
diff --git a/src/kernel.c b/src/kernel.c
index 8845cbce6..7890e3dac 100644
--- a/src/kernel.c
+++ b/src/kernel.c
@@ -492,7 +492,7 @@ mrb_obj_frozen(mrb_state *mrb, mrb_value self)
  *  <code>Hash</code>. Any hash value that exceeds the capacity of a
  *  <code>Fixnum</code> will be truncated before being used.
  */
-MRB_API mrb_value
+static mrb_value
 mrb_obj_hash(mrb_state *mrb, mrb_value self)
 {
   return mrb_fixnum_value(mrb_obj_id(self));
diff --git a/src/string.c b/src/string.c
index 8efea84ab..63c592d59 100644
--- a/src/string.c
+++ b/src/string.c
@@ -2006,7 +2006,7 @@ mrb_str_split_m(mrb_state *mrb, mrb_value str)
   return result;
 }
 
-MRB_API mrb_value
+static mrb_value
 mrb_str_len_to_inum(mrb_state *mrb, const char *str, mrb_int len, mrb_int base, int badcheck)
 {
   const char *p = str;
@@ -2174,7 +2174,7 @@ mrb_str_len_to_inum(mrb_state *mrb, const char *str, mrb_int len, mrb_int base,
 }
 
 MRB_API mrb_value
-mrb_cstr_to_inum(mrb_state *mrb, const char *str, int base, int badcheck)
+mrb_cstr_to_inum(mrb_state *mrb, const char *str, mrb_int base, mrb_bool badcheck)
 {
   return mrb_str_len_to_inum(mrb, str, strlen(str), base, badcheck);
 }
diff --git a/src/variable.c b/src/variable.c
index 90efe9e0e..724b153fe 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -621,7 +621,7 @@ mrb_mod_class_variables(mrb_state *mrb, mrb_value mod)
   return ary;
 }
 
-MRB_API mrb_value
+mrb_value
 mrb_mod_cv_get(mrb_state *mrb, struct RClass *c, mrb_sym sym)
 {
   struct RClass * cls = c;
@@ -714,7 +714,7 @@ mrb_cv_set(mrb_state *mrb, mrb_value mod, mrb_sym sym, mrb_value v)
   mrb_mod_cv_set(mrb, mrb_class_ptr(mod), sym, v);
 }
 
-MRB_API mrb_bool
+mrb_bool
 mrb_mod_cv_defined(mrb_state *mrb, struct RClass * c, mrb_sym sym)
 {
   while (c) {
diff --git a/src/vm.c b/src/vm.c
index 7904162be..a381de21f 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -593,7 +593,7 @@ mrb_exec_irep(mrb_state *mrb, mrb_value self, struct RProc *p)
  *     k = Klass.new
  *     k.send :hello, "gentle", "readers"   #=> "Hello gentle readers"
  */
-MRB_API mrb_value
+mrb_value
 mrb_f_send(mrb_state *mrb, mrb_value self)
 {
   mrb_sym name;
-- 
cgit v1.2.3


From 55cb625808ab9b498d42d13442f5ce5115d606a5 Mon Sep 17 00:00:00 2001
From: KOBAYASHI Shuji <shuujii@gmail.com>
Date: Mon, 1 Apr 2019 19:49:30 +0900
Subject: Fix modifiable class name

Fix the following example:

    Object.const_set :A, Module.new{const_set :B, Class.new}
    ab = A::B.to_s
    p ab         #=> "A::B" # Good
    ab[0] = "x"
    p A::B.to_s  #=> "x::B" # Bad
---
 src/variable.c | 1 +
 1 file changed, 1 insertion(+)

(limited to 'src/variable.c')

diff --git a/src/variable.c b/src/variable.c
index 724b153fe..9edfb32bd 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -1106,6 +1106,7 @@ mrb_class_find_path(mrb_state *mrb, struct RClass *c)
     iv_del(mrb, c->iv, mrb_intern_lit(mrb, "__outer__"), NULL);
     iv_put(mrb, c->iv, mrb_intern_lit(mrb, "__classname__"), path);
     mrb_field_write_barrier_value(mrb, (struct RBasic*)c, path);
+    path = mrb_str_dup(mrb, path);
   }
   return path;
 }
-- 
cgit v1.2.3


From e3beef065c2de80a843f329599b424676d83086c Mon Sep 17 00:00:00 2001
From: KOBAYASHI Shuji <shuujii@gmail.com>
Date: Tue, 9 Apr 2019 18:23:11 +0900
Subject: Extract frozen checking to function

---
 include/mruby.h                   |  6 ++++++
 mrbgems/mruby-struct/src/struct.c |  5 +----
 src/array.c                       |  4 +---
 src/class.c                       |  7 +------
 src/error.c                       |  7 +++++++
 src/hash.c                        |  5 +----
 src/string.c                      | 12 ++----------
 src/variable.c                    |  4 +---
 8 files changed, 20 insertions(+), 30 deletions(-)

(limited to 'src/variable.c')

diff --git a/include/mruby.h b/include/mruby.h
index 5b0d84cd3..939601b4d 100644
--- a/include/mruby.h
+++ b/include/mruby.h
@@ -1143,6 +1143,7 @@ MRB_API mrb_noreturn void mrb_exc_raise(mrb_state *mrb, mrb_value exc);
 MRB_API mrb_noreturn void mrb_raise(mrb_state *mrb, struct RClass *c, const char *msg);
 MRB_API mrb_noreturn void mrb_raisef(mrb_state *mrb, struct RClass *c, const char *fmt, ...);
 MRB_API mrb_noreturn void mrb_name_error(mrb_state *mrb, mrb_sym id, const char *fmt, ...);
+MRB_API mrb_noreturn void mrb_frozen_error(mrb_state *mrb, void *frozen_obj);
 MRB_API void mrb_warn(mrb_state *mrb, const char *fmt, ...);
 MRB_API mrb_noreturn void mrb_bug(mrb_state *mrb, const char *fmt, ...);
 MRB_API void mrb_print_backtrace(mrb_state *mrb);
@@ -1196,6 +1197,11 @@ MRB_API mrb_value mrb_to_int(mrb_state *mrb, mrb_value val);
 MRB_API mrb_value mrb_to_str(mrb_state *mrb, mrb_value val);
 MRB_API void mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t);
 
+static inline void mrb_check_frozen(mrb_state *mrb, void *o)
+{
+  if (MRB_FROZEN_P((struct RBasic*)o)) mrb_frozen_error(mrb, o);
+}
+
 typedef enum call_type {
   CALL_PUBLIC,
   CALL_FCALL,
diff --git a/mrbgems/mruby-struct/src/struct.c b/mrbgems/mruby-struct/src/struct.c
index c0ce71219..1df135a9f 100644
--- a/mrbgems/mruby-struct/src/struct.c
+++ b/mrbgems/mruby-struct/src/struct.c
@@ -87,10 +87,7 @@ mrb_struct_s_members_m(mrb_state *mrb, mrb_value klass)
 static void
 mrb_struct_modify(mrb_state *mrb, mrb_value strct)
 {
-  if (MRB_FROZEN_P(mrb_basic_ptr(strct))) {
-    mrb_raise(mrb, E_FROZEN_ERROR, "can't modify frozen struct");
-  }
-
+  mrb_check_frozen(mrb, mrb_basic_ptr(strct));
   mrb_write_barrier(mrb, mrb_basic_ptr(strct));
 }
 
diff --git a/src/array.c b/src/array.c
index 43f4c98b5..d4302cb22 100644
--- a/src/array.c
+++ b/src/array.c
@@ -120,9 +120,7 @@ ary_fill_with_nil(mrb_value *ptr, mrb_int size)
 static void
 ary_modify_check(mrb_state *mrb, struct RArray *a)
 {
-  if (MRB_FROZEN_P(a)) {
-    mrb_raise(mrb, E_FROZEN_ERROR, "can't modify frozen array");
-  }
+  mrb_check_frozen(mrb, a);
 }
 
 static void
diff --git a/src/class.c b/src/class.c
index eaef787f7..fd56fa399 100644
--- a/src/class.c
+++ b/src/class.c
@@ -441,12 +441,7 @@ mrb_define_method_raw(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_method_
   MRB_CLASS_ORIGIN(c);
   h = c->mt;
 
-  if (MRB_FROZEN_P(c)) {
-    if (c->tt == MRB_TT_MODULE)
-      mrb_raise(mrb, E_FROZEN_ERROR, "can't modify frozen module");
-    else
-      mrb_raise(mrb, E_FROZEN_ERROR, "can't modify frozen class");
-  }
+  mrb_check_frozen(mrb, c);
   if (!h) h = c->mt = kh_init(mt, mrb);
   k = kh_put(mt, mrb, h, mid);
   kh_value(h, k) = m;
diff --git a/src/error.c b/src/error.c
index e69812dda..4c1b67c99 100644
--- a/src/error.c
+++ b/src/error.c
@@ -484,6 +484,13 @@ mrb_no_method_error(mrb_state *mrb, mrb_sym id, mrb_value args, char const* fmt,
   mrb_exc_raise(mrb, exc);
 }
 
+MRB_API mrb_noreturn void
+mrb_frozen_error(mrb_state *mrb, void *frozen_obj)
+{
+  mrb_raisef(mrb, E_FROZEN_ERROR, "can't modify frozen %S",
+             mrb_obj_value(mrb_class(mrb, mrb_obj_value(frozen_obj))));
+}
+
 void
 mrb_init_exception(mrb_state *mrb)
 {
diff --git a/src/hash.c b/src/hash.c
index fd963c3de..c4820513b 100644
--- a/src/hash.c
+++ b/src/hash.c
@@ -746,10 +746,7 @@ mrb_hash_set(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value val)
 static void
 mrb_hash_modify(mrb_state *mrb, mrb_value hash)
 {
-  if (MRB_FROZEN_P(mrb_hash_ptr(hash))) {
-    mrb_raise(mrb, E_FROZEN_ERROR, "can't modify frozen hash");
-  }
-
+  mrb_check_frozen(mrb, mrb_hash_ptr(hash));
   if (!RHASH_TBL(hash)) {
     RHASH_TBL(hash) = ht_new(mrb);
   }
diff --git a/src/string.c b/src/string.c
index 63c592d59..f7a805a94 100644
--- a/src/string.c
+++ b/src/string.c
@@ -493,20 +493,12 @@ str_index_str(mrb_state *mrb, mrb_value str, mrb_value str2, mrb_int offset)
   return mrb_str_index(mrb, str, ptr, len, offset);
 }
 
-static void
-check_frozen(mrb_state *mrb, struct RString *s)
-{
-  if (MRB_FROZEN_P(s)) {
-    mrb_raise(mrb, E_FROZEN_ERROR, "can't modify frozen string");
-  }
-}
-
 static mrb_value
 str_replace(mrb_state *mrb, struct RString *s1, struct RString *s2)
 {
   mrb_int len;
 
-  check_frozen(mrb, s1);
+  mrb_check_frozen(mrb, s1);
   if (s1 == s2) return mrb_obj_value(s1);
   s1->flags &= ~MRB_STR_NO_UTF;
   s1->flags |= s2->flags&MRB_STR_NO_UTF;
@@ -646,7 +638,7 @@ mrb_locale_from_utf8(const char *utf8, int len)
 MRB_API void
 mrb_str_modify(mrb_state *mrb, struct RString *s)
 {
-  check_frozen(mrb, s);
+  mrb_check_frozen(mrb, s);
   s->flags &= ~MRB_STR_NO_UTF;
   if (RSTR_SHARED_P(s)) {
     mrb_shared_string *shared = s->as.heap.aux.shared;
diff --git a/src/variable.c b/src/variable.c
index 9edfb32bd..cf89a4a02 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -346,9 +346,7 @@ mrb_obj_iv_set(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
 {
   iv_tbl *t;
 
-  if (MRB_FROZEN_P(obj)) {
-    mrb_raisef(mrb, E_FROZEN_ERROR, "can't modify frozen %S", mrb_obj_value(obj));
-  }
+  mrb_check_frozen(mrb, obj);
   assign_class_name(mrb, obj, sym, v);
   if (!obj->iv) {
     obj->iv = iv_new(mrb);
-- 
cgit v1.2.3


From 16f86f8ede2f0d33fdd642d734c796b9435a57bf Mon Sep 17 00:00:00 2001
From: "Yukihiro \"Matz\" Matsumoto" <matz@ruby.or.jp>
Date: Wed, 10 Apr 2019 05:42:36 +0900
Subject: Use the old style declaration; ref #4365

---
 src/variable.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'src/variable.c')

diff --git a/src/variable.c b/src/variable.c
index 9edfb32bd..02e4f38a1 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -1116,7 +1116,9 @@ mrb_class_find_path(mrb_state *mrb, struct RClass *c)
 mrb_bool
 mrb_ident_p(const char *s, mrb_int len)
 {
-  for (mrb_int i = 0; i < len; i++) {
+  mrb_int i;
+
+  for (i = 0; i < len; i++) {
     if (!identchar(s[i])) return FALSE;
   }
   return TRUE;
-- 
cgit v1.2.3


From d557f977324bc55ae99205608099a788038712d6 Mon Sep 17 00:00:00 2001
From: dearblue <dearblue@users.noreply.github.com>
Date: Sun, 14 Apr 2019 17:39:50 +0900
Subject: Remove pointer check after `mrb_malloc()`

---
 src/variable.c | 1 -
 1 file changed, 1 deletion(-)

(limited to 'src/variable.c')

diff --git a/src/variable.c b/src/variable.c
index f97b09c52..6899d7475 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -87,7 +87,6 @@ iv_put(mrb_state *mrb, iv_tbl *t, mrb_sym sym, mrb_value val)
   }
 
   seg = (segment*)mrb_malloc(mrb, sizeof(segment));
-  if (!seg) return;
   seg->next = NULL;
   seg->key[0] = sym;
   seg->val[0] = val;
-- 
cgit v1.2.3


From d8527d17ea504aebcdbd3970127899e0216d46dc Mon Sep 17 00:00:00 2001
From: dearblue <dearblue@users.noreply.github.com>
Date: Sun, 14 Apr 2019 17:42:35 +0900
Subject: Fix wrong size of instance variable if occur out of memory

---
 src/variable.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'src/variable.c')

diff --git a/src/variable.c b/src/variable.c
index 6899d7475..983fe52f7 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -79,10 +79,10 @@ iv_put(mrb_state *mrb, iv_tbl *t, mrb_sym sym, mrb_value val)
   }
 
   /* Not found */
-  t->size++;
   if (matched_seg) {
     matched_seg->key[matched_idx] = sym;
     matched_seg->val[matched_idx] = val;
+    t->size++;
     return;
   }
 
@@ -91,6 +91,7 @@ iv_put(mrb_state *mrb, iv_tbl *t, mrb_sym sym, mrb_value val)
   seg->key[0] = sym;
   seg->val[0] = val;
   t->last_len = 1;
+  t->size++;
   if (prev) {
     prev->next = seg;
   }
-- 
cgit v1.2.3


From cc7f9190ba93ef45bf85a7278dffe6326cf620a3 Mon Sep 17 00:00:00 2001
From: KOBAYASHI Shuji <shuujii@gmail.com>
Date: Tue, 23 Apr 2019 20:45:38 +0900
Subject: Fix name assignment to frozen anonymous class/module

Fix the following issues:

  A = Class.new.freeze              #=> FrozenError
  Module.new::B = Class.new.freeze  #=> FrozenError
  String::B = Module.new.freeze     #=> FrozenError
---
 include/mruby/variable.h |  1 +
 src/class.c              |  6 +++---
 src/variable.c           | 21 ++++++++++++---------
 test/t/module.rb         |  4 ++++
 4 files changed, 20 insertions(+), 12 deletions(-)

(limited to 'src/variable.c')

diff --git a/include/mruby/variable.h b/include/mruby/variable.h
index ba6037959..ff01e5cc8 100644
--- a/include/mruby/variable.h
+++ b/include/mruby/variable.h
@@ -117,6 +117,7 @@ MRB_API void mrb_mod_cv_set(mrb_state *mrb, struct RClass * c, mrb_sym sym, mrb_
 MRB_API void mrb_cv_set(mrb_state *mrb, mrb_value mod, mrb_sym sym, mrb_value v);
 MRB_API mrb_bool mrb_cv_defined(mrb_state *mrb, mrb_value mod, mrb_sym sym);
 mrb_value mrb_obj_iv_inspect(mrb_state*, struct RObject*);
+void mrb_obj_iv_set_force(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v);
 mrb_value mrb_mod_constants(mrb_state *mrb, mrb_value mod);
 mrb_value mrb_f_global_variables(mrb_state *mrb, mrb_value self);
 mrb_value mrb_obj_instance_variables(mrb_state*, mrb_value);
diff --git a/src/class.c b/src/class.c
index d6efdbdc4..77ff04437 100644
--- a/src/class.c
+++ b/src/class.c
@@ -66,15 +66,15 @@ mrb_class_name_class(mrb_state *mrb, struct RClass *outer, struct RClass *c, mrb
     name = mrb_class_path(mrb, outer);
     if (mrb_nil_p(name)) {      /* unnamed outer class */
       if (outer != mrb->object_class && outer != c) {
-        mrb_obj_iv_set(mrb, (struct RObject*)c, mrb_intern_lit(mrb, "__outer__"),
-                       mrb_obj_value(outer));
+        mrb_obj_iv_set_force(mrb, (struct RObject*)c, mrb_intern_lit(mrb, "__outer__"),
+                             mrb_obj_value(outer));
       }
       return;
     }
     mrb_str_cat_cstr(mrb, name, "::");
     mrb_str_cat_cstr(mrb, name, mrb_sym2name(mrb, id));
   }
-  mrb_obj_iv_set(mrb, (struct RObject*)c, nsym, name);
+  mrb_obj_iv_set_force(mrb, (struct RObject*)c, nsym, name);
 }
 
 static void
diff --git a/src/variable.c b/src/variable.c
index 983fe52f7..e859f02bf 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -341,21 +341,24 @@ mrb_iv_get(mrb_state *mrb, mrb_value obj, mrb_sym sym)
 
 static inline void assign_class_name(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v);
 
-MRB_API void
-mrb_obj_iv_set(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
+void
+mrb_obj_iv_set_force(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
 {
-  iv_tbl *t;
-
-  mrb_check_frozen(mrb, obj);
   assign_class_name(mrb, obj, sym, v);
   if (!obj->iv) {
     obj->iv = iv_new(mrb);
   }
-  t = obj->iv;
-  iv_put(mrb, t, sym, v);
+  iv_put(mrb, obj->iv, sym, v);
   mrb_write_barrier(mrb, (struct RBasic*)obj);
 }
 
+MRB_API void
+mrb_obj_iv_set(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
+{
+  mrb_check_frozen(mrb, obj);
+  mrb_obj_iv_set_force(mrb, obj, sym, v);
+}
+
 /* Iterates over the instance variable table. */
 MRB_API void
 mrb_iv_foreach(mrb_state *mrb, mrb_value obj, mrb_iv_foreach_func *func, void *p)
@@ -385,10 +388,10 @@ assign_class_name(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
 
         if (mrb_nil_p(o)) {
           if ((struct RClass *)obj == mrb->object_class) {
-            mrb_obj_iv_set(mrb, c, id_classname, mrb_symbol_value(sym));
+            mrb_obj_iv_set_force(mrb, c, id_classname, mrb_symbol_value(sym));
           }
           else {
-            mrb_obj_iv_set(mrb, c, id_outer, mrb_obj_value(obj));
+            mrb_obj_iv_set_force(mrb, c, id_outer, mrb_obj_value(obj));
           }
         }
       }
diff --git a/test/t/module.rb b/test/t/module.rb
index 09613e1bc..f4999019a 100644
--- a/test/t/module.rb
+++ b/test/t/module.rb
@@ -653,6 +653,10 @@ assert('Module#to_s') do
 
   assert_match "#<Module:0x*>", Module.new.to_s
   assert_match "#<Class:0x*>", Class.new.to_s
+
+  assert_equal "FrozenClassToS", (FrozenClassToS = Class.new.freeze).to_s
+  assert_equal "Outer::A", (Outer::A = Module.new.freeze).to_s
+  assert_match "#<Module:0x*>::A", (Module.new::A = Class.new.freeze).to_s
 end
 
 assert('Module#inspect') do
-- 
cgit v1.2.3


From 4720648137f2698cceb635c251475dec645cd598 Mon Sep 17 00:00:00 2001
From: KOBAYASHI Shuji <shuujii@gmail.com>
Date: Wed, 24 Apr 2019 21:05:44 +0900
Subject: Fix modiying class variable to frozen class/module

---
 mrbgems/mruby-metaprog/test/metaprog.rb |  8 +++++++-
 src/variable.c                          |  2 ++
 test/t/class.rb                         | 19 +++++++++++++++++++
 3 files changed, 28 insertions(+), 1 deletion(-)

(limited to 'src/variable.c')

diff --git a/mrbgems/mruby-metaprog/test/metaprog.rb b/mrbgems/mruby-metaprog/test/metaprog.rb
index 1262c9945..0abeb90a6 100644
--- a/mrbgems/mruby-metaprog/test/metaprog.rb
+++ b/mrbgems/mruby-metaprog/test/metaprog.rb
@@ -171,7 +171,6 @@ assert('Module#class_variable_set', '15.2.2.4.18') do
       @@foo
     end
   end
-
   assert_equal 99, Test4ClassVariableSet.class_variable_set(:@@cv, 99)
   assert_equal 101, Test4ClassVariableSet.class_variable_set(:@@foo, 101)
   assert_true Test4ClassVariableSet.class_variables.include? :@@cv
@@ -180,6 +179,13 @@ assert('Module#class_variable_set', '15.2.2.4.18') do
   %w[@@ @@1 @@x= @x @ x 1].each do |n|
     assert_raise(NameError) { Test4ClassVariableSet.class_variable_set(n, 1) }
   end
+
+  m = Module.new.freeze
+  assert_raise(FrozenError) { m.class_variable_set(:@@cv, 1) }
+
+  parent = Class.new{ class_variable_set(:@@a, nil) }.freeze
+  child = Class.new(parent)
+  assert_raise(FrozenError) { child.class_variable_set(:@@a, 1) }
 end
 
 assert('Module#class_variables', '15.2.2.4.19') do
diff --git a/src/variable.c b/src/variable.c
index 983fe52f7..c4c9d369f 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -671,6 +671,7 @@ mrb_mod_cv_set(mrb_state *mrb, struct RClass *c, mrb_sym sym, mrb_value v)
     iv_tbl *t = c->iv;
 
     if (iv_get(mrb, t, sym, NULL)) {
+      mrb_check_frozen(mrb, c);
       iv_put(mrb, t, sym, v);
       mrb_write_barrier(mrb, (struct RBasic*)c);
       return;
@@ -698,6 +699,7 @@ mrb_mod_cv_set(mrb_state *mrb, struct RClass *c, mrb_sym sym, mrb_value v)
     c = cls;
   }
 
+  mrb_check_frozen(mrb, c);
   if (!c->iv) {
     c->iv = iv_new(mrb);
   }
diff --git a/test/t/class.rb b/test/t/class.rb
index 290ecf74a..0c95677fc 100644
--- a/test/t/class.rb
+++ b/test/t/class.rb
@@ -433,6 +433,25 @@ assert('overriding class variable with a module (#3235)') do
   end
 end
 
+assert('class variable for frozen class/module') do
+  module CVarForFrozenModule
+    freeze
+    assert_raise(FrozenError) { @@cv = 1 }
+  end
+
+  class CVarForFrozenClassA
+    @@a = nil
+    freeze
+  end
+  class CVarForFrozenClassB < CVarForFrozenClassA
+    def a=(v)
+      @@a = v
+    end
+  end
+  b = CVarForFrozenClassB.new
+  assert_raise(FrozenError) { b.a = 1 }
+end
+
 assert('class with non-class/module outer raises TypeError') do
   assert_raise(TypeError) { class 0::C1; end }
   assert_raise(TypeError) { class []::C2; end }
-- 
cgit v1.2.3


From 38f1da6f26bde5185612b66a1b1fc94f78654d78 Mon Sep 17 00:00:00 2001
From: KOBAYASHI Shuji <shuujii@gmail.com>
Date: Mon, 10 Jun 2019 18:46:57 +0900
Subject: `Kernel#global_variables` should not include undefined `$1`-`$9`

- They are not include in Ruby.
- Appear in duplicate when `$1`-`$9` are defined.
---
 mrbgems/mruby-metaprog/test/metaprog.rb | 13 ++++++++-----
 src/variable.c                          |  8 --------
 2 files changed, 8 insertions(+), 13 deletions(-)

(limited to 'src/variable.c')

diff --git a/mrbgems/mruby-metaprog/test/metaprog.rb b/mrbgems/mruby-metaprog/test/metaprog.rb
index 329580abc..685fdf196 100644
--- a/mrbgems/mruby-metaprog/test/metaprog.rb
+++ b/mrbgems/mruby-metaprog/test/metaprog.rb
@@ -104,11 +104,14 @@ assert('Kernel.global_variables', '15.3.1.2.4') do
 end
 
 assert('Kernel#global_variables', '15.3.1.3.14') do
-  variables = global_variables
-  assert_equal Array, variables.class
-  1.upto(9) do |i|
-    assert_equal variables.include?(:"$#{i}"), true
-  end
+  variables1 = global_variables
+  assert_equal Array, variables1.class
+  assert_not_include(variables1, :$kernel_global_variables_test)
+
+  $kernel_global_variables_test = nil
+  variables2 = global_variables
+  assert_include(variables2, :$kernel_global_variables_test)
+  assert_equal(1, variables2.size - variables1.size)
 end
 
 assert('Kernel.local_variables', '15.3.1.2.7') do
diff --git a/src/variable.c b/src/variable.c
index ee21a3b96..779f206dc 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -965,16 +965,8 @@ mrb_f_global_variables(mrb_state *mrb, mrb_value self)
 {
   iv_tbl *t = mrb->globals;
   mrb_value ary = mrb_ary_new(mrb);
-  size_t i;
-  char buf[3];
 
   iv_foreach(mrb, t, gv_i, &ary);
-  buf[0] = '$';
-  buf[2] = 0;
-  for (i = 1; i <= 9; ++i) {
-    buf[1] = (char)(i + '0');
-    mrb_ary_push(mrb, ary, mrb_symbol_value(mrb_intern(mrb, buf, 2)));
-  }
   return ary;
 }
 
-- 
cgit v1.2.3


From 030dd6655e47dad4af4b48a74646712c00684698 Mon Sep 17 00:00:00 2001
From: KOBAYASHI Shuji <shuujii@gmail.com>
Date: Sun, 16 Jun 2019 20:43:23 +0900
Subject: Fix cvar, ivar, const and method can be removed to frozen object

---
 mrbgems/mruby-metaprog/src/metaprog.c   | 1 +
 mrbgems/mruby-metaprog/test/metaprog.rb | 8 ++++++--
 src/variable.c                          | 1 +
 test/t/kernel.rb                        | 1 +
 test/t/module.rb                        | 1 +
 5 files changed, 10 insertions(+), 2 deletions(-)

(limited to 'src/variable.c')

diff --git a/mrbgems/mruby-metaprog/src/metaprog.c b/mrbgems/mruby-metaprog/src/metaprog.c
index 43d27f4dc..0d207ef41 100644
--- a/mrbgems/mruby-metaprog/src/metaprog.c
+++ b/mrbgems/mruby-metaprog/src/metaprog.c
@@ -641,6 +641,7 @@ mrb_mod_remove_method(mrb_state *mrb, mrb_value mod)
   mrb_value *argv;
 
   mrb_get_args(mrb, "*", &argv, &argc);
+  mrb_check_frozen(mrb, mrb_obj_ptr(mod));
   while (argc--) {
     remove_method(mrb, mod, mrb_obj_to_sym(mrb, *argv));
     argv++;
diff --git a/mrbgems/mruby-metaprog/test/metaprog.rb b/mrbgems/mruby-metaprog/test/metaprog.rb
index 685fdf196..46b98d0ed 100644
--- a/mrbgems/mruby-metaprog/test/metaprog.rb
+++ b/mrbgems/mruby-metaprog/test/metaprog.rb
@@ -298,6 +298,9 @@ assert('Module#remove_class_variable', '15.2.2.4.39') do
   assert_raise(NameError) do
     Test4RemoveClassVariable.remove_class_variable(:@v)
   end
+  assert_raise(FrozenError) do
+    Test4RemoveClassVariable.freeze.remove_class_variable(:@@cv)
+  end
 end
 
 assert('Module#remove_method', '15.2.2.4.41') do
@@ -305,9 +308,9 @@ assert('Module#remove_method', '15.2.2.4.41') do
     class Parent
       def hello
       end
-     end
+    end
 
-     class Child < Parent
+    class Child < Parent
       def hello
       end
     end
@@ -317,6 +320,7 @@ assert('Module#remove_method', '15.2.2.4.41') do
   assert_same klass, klass.class_eval{ remove_method :hello }
   assert_true klass.instance_methods.include? :hello
   assert_false klass.instance_methods(false).include? :hello
+  assert_raise(FrozenError) { klass.freeze.remove_method :m }
 end
 
 assert('Module.nesting', '15.2.2.2.2') do
diff --git a/src/variable.c b/src/variable.c
index 779f206dc..23d900b7d 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -521,6 +521,7 @@ mrb_obj_iv_inspect(mrb_state *mrb, struct RObject *obj)
 MRB_API mrb_value
 mrb_iv_remove(mrb_state *mrb, mrb_value obj, mrb_sym sym)
 {
+  mrb_check_frozen(mrb, mrb_obj_ptr(obj));
   if (obj_iv_p(obj)) {
     iv_tbl *t = mrb_obj_ptr(obj)->iv;
     mrb_value val;
diff --git a/test/t/kernel.rb b/test/t/kernel.rb
index 7f6e6c58d..950442351 100644
--- a/test/t/kernel.rb
+++ b/test/t/kernel.rb
@@ -404,6 +404,7 @@ assert('Kernel#remove_instance_variable', '15.3.1.3.41') do
   assert_equal nil, tri.var
   assert_raise(NameError) { tri.remove }
   assert_raise(NameError) { tri.remove_instance_variable(:var) }
+  assert_raise(FrozenError) { tri.freeze.remove }
 end
 
 # Kernel#require is defined in mruby-require. '15.3.1.3.42'
diff --git a/test/t/module.rb b/test/t/module.rb
index 3bb9735df..571f4759d 100644
--- a/test/t/module.rb
+++ b/test/t/module.rb
@@ -262,6 +262,7 @@ assert('Module#remove_const', '15.2.2.4.40') do
   %i[x X!].each do |n|
     assert_raise(NameError) { Test4RemoveConst.remove_const(n) }
   end
+  assert_raise(FrozenError) { Test4RemoveConst.freeze.remove_const(:A) }
 end
 
 assert('Module#const_missing', '15.2.2.4.22') do
-- 
cgit v1.2.3


From 63d8b5e1e32cbbeb2368b06b3efa7723bf0677d2 Mon Sep 17 00:00:00 2001
From: "Yukihiro \"Matz\" Matsumoto" <matz@ruby.or.jp>
Date: Tue, 25 Jun 2019 18:41:17 +0900
Subject: Fixed `mrb_iv_remove` with immediate objects; fix #4519

The #4520 tried to address the issue, but it changes the type of
`mrb_check_frozen` argument; close #4520
---
 src/variable.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/variable.c')

diff --git a/src/variable.c b/src/variable.c
index 23d900b7d..e6f2f397e 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -521,11 +521,11 @@ mrb_obj_iv_inspect(mrb_state *mrb, struct RObject *obj)
 MRB_API mrb_value
 mrb_iv_remove(mrb_state *mrb, mrb_value obj, mrb_sym sym)
 {
-  mrb_check_frozen(mrb, mrb_obj_ptr(obj));
   if (obj_iv_p(obj)) {
     iv_tbl *t = mrb_obj_ptr(obj)->iv;
     mrb_value val;
 
+    mrb_check_frozen(mrb, mrb_obj_ptr(obj));
     if (iv_del(mrb, t, sym, &val)) {
       return val;
     }
-- 
cgit v1.2.3