script_core 0.2.3 → 0.3.0

data/ext/enterprise_script_service/mruby/mrbgems/mruby-math/test/math.rb

@@ -209,17 +209,18 @@ def assert_float_and_int(exp_ary, act_ary)
   assert_float(+Math::PI, Math.atan2(+0.0, -0.0))
   assert_float(-Math::PI, Math.atan2(-0.0, -0.0))
 
+  assert_float(0, Math.atan2(0, 1))
+  assert_float(Math::PI / 4, Math.atan2(1, 1))
+  assert_float(Math::PI / 2, Math.atan2(1, 0))
+
   inf = Float::INFINITY
+  skip "Math.atan2() return NaN" if Math.atan2(+inf, -inf).nan?
   expected = 3.0 * Math::PI / 4.0
   assert_float(+expected, Math.atan2(+inf, -inf))
   assert_float(-expected, Math.atan2(-inf, -inf))
   expected = Math::PI / 4.0
   assert_float(+expected, Math.atan2(+inf, +inf))
   assert_float(-expected, Math.atan2(-inf, +inf))
-
-  assert_float(0, Math.atan2(0, 1))
-  assert_float(Math::PI / 4, Math.atan2(1, 1))
-  assert_float(Math::PI / 2, Math.atan2(1, 0))
 end
 
 assert('Math.ldexp') do

data/ext/enterprise_script_service/mruby/mrbgems/mruby-metaprog/src/metaprog.c

@@ -5,6 +5,7 @@
 #include "mruby/proc.h"
 #include "mruby/class.h"
 #include "mruby/string.h"
+#include "mruby/presym.h"
 
 typedef enum {
   NOEX_PUBLIC    = 0x00,
@@ -132,66 +133,75 @@ mrb_obj_ivar_set(mrb_state *mrb, mrb_value self)
 static mrb_value
 mrb_local_variables(mrb_state *mrb, mrb_value self)
 {
-  struct RProc *proc;
-  mrb_irep *irep;
+  const struct RProc *proc;
+  const mrb_irep *irep;
   mrb_value vars;
   size_t i;
 
   proc = mrb->c->ci[-1].proc;
 
-  if (MRB_PROC_CFUNC_P(proc)) {
+  if (proc == NULL || MRB_PROC_CFUNC_P(proc)) {
     return mrb_ary_new(mrb);
   }
   vars = mrb_hash_new(mrb);
   while (proc) {
     if (MRB_PROC_CFUNC_P(proc)) break;
     irep = proc->body.irep;
-    if (!irep->lv) break;
-    for (i = 0; i + 1 < irep->nlocals; ++i) {
-      if (irep->lv[i].name) {
-        mrb_sym sym = irep->lv[i].name;
-        const char *name = mrb_sym_name(mrb, sym);
-        switch (name[0]) {
-        case '*': case '&':
-          break;
-        default:
-          mrb_hash_set(mrb, vars, mrb_symbol_value(sym), mrb_true_value());
-          break;
+    if (irep->lv) {
+      for (i = 0; i + 1 < irep->nlocals; ++i) {
+        if (irep->lv[i]) {
+          mrb_sym sym = irep->lv[i];
+          const char *name = mrb_sym_name(mrb, sym);
+          switch (name[0]) {
+          case '*': case '&':
+            break;
+          default:
+            mrb_hash_set(mrb, vars, mrb_symbol_value(sym), mrb_true_value());
+            break;
+          }
         }
       }
     }
-    if (!MRB_PROC_ENV_P(proc)) break;
+    if (MRB_PROC_SCOPE_P(proc)) break;
     proc = proc->upper;
-    //if (MRB_PROC_SCOPE_P(proc)) break;
-    if (!proc->c) break;
   }
 
   return mrb_hash_keys(mrb, vars);
 }
 
 KHASH_DECLARE(st, mrb_sym, char, FALSE)
+KHASH_DEFINE(st, mrb_sym, char, FALSE, kh_int_hash_func, kh_int_hash_equal)
 
-static void
-method_entry_loop(mrb_state *mrb, struct RClass *klass, khash_t(st) *set, khash_t(st) *undef)
+struct mt_set {
+  khash_t(st) *set;
+  khash_t(st) *undef;
+};
+
+static int
+method_entry_i(mrb_state *mrb, mrb_sym mid, mrb_method_t m, void *p)
 {
-  khint_t i;
+  struct mt_set *s = (struct mt_set*)p;
 
-  khash_t(mt) *h = klass->mt;
-  if (!h || kh_size(h) == 0) return;
-  for (i=0;i<kh_end(h);i++) {
-    if (kh_exist(h, i)) {
-      mrb_method_t m = kh_value(h, i);
-      if (MRB_METHOD_UNDEF_P(m)) {
-        if (undef) {
-          kh_put(st, mrb, undef, kh_key(h, i));
-        }
-      }
-      else if (undef == NULL ||
-               kh_get(st, mrb, undef, kh_key(h, i)) == kh_end(undef)) {
-        kh_put(st, mrb, set, kh_key(h, i));
-      }
+  if (MRB_METHOD_UNDEF_P(m)) {
+    if (s->undef) {
+      kh_put(st, mrb, s->undef, mid);
     }
   }
+  else if (s->undef == NULL ||
+           kh_get(st, mrb, s->undef, mid) == kh_end(s->undef)) {
+    kh_put(st, mrb, s->set, mid);
+  }
+  return 0;
+}
+
+static void
+method_entry_loop(mrb_state *mrb, struct RClass *klass, khash_t(st) *set, khash_t(st) *undef)
+{
+  struct mt_set s;
+
+  s.set = set;
+  s.undef = undef;
+  mrb_mt_foreach(mrb, klass, method_entry_i, (void*)&s);
 }
 
 static mrb_value
@@ -392,21 +402,12 @@ mrb_obj_singleton_methods_m(mrb_state *mrb, mrb_value self)
   return mrb_obj_singleton_methods(mrb, recur, self);
 }
 
+mrb_value mrb_mod_define_method_m(mrb_state *mrb, struct RClass *c);
+
 static mrb_value
 mod_define_singleton_method(mrb_state *mrb, mrb_value self)
 {
-  struct RProc *p;
-  mrb_method_t m;
-  mrb_sym mid;
-  mrb_value blk = mrb_nil_value();
-
-  mrb_get_args(mrb, "n&!", &mid, &blk);
-  p = (struct RProc*)mrb_obj_alloc(mrb, MRB_TT_PROC, mrb->proc_class);
-  mrb_proc_copy(p, mrb_proc_ptr(blk));
-  p->flags |= MRB_PROC_STRICT;
-  MRB_METHOD_FROM_PROC(m, p);
-  mrb_define_method_raw(mrb, mrb_class_ptr(mrb_singleton_class(mrb, self)), mid, m);
-  return mrb_symbol_value(mid);
+  return mrb_mod_define_method_m(mrb, mrb_class_ptr(mrb_singleton_class(mrb, self)));
 }
 
 static mrb_bool
@@ -609,28 +610,6 @@ mrb_mod_instance_methods(mrb_state *mrb, mrb_value mod)
   return mrb_class_instance_method_list(mrb, recur, c, 0);
 }
 
-static void
-remove_method(mrb_state *mrb, mrb_value mod, mrb_sym mid)
-{
-  struct RClass *c = mrb_class_ptr(mod);
-  khash_t(mt) *h;
-  khiter_t k;
-
-  MRB_CLASS_ORIGIN(c);
-  h = c->mt;
-
-  if (h) {
-    k = kh_get(mt, mrb, h, mid);
-    if (k != kh_end(h)) {
-      kh_del(mt, mrb, h, k);
-      mrb_funcall(mrb, mod, "method_removed", 1, mrb_symbol_value(mid));
-      return;
-    }
-  }
-
-  mrb_name_error(mrb, mid, "method '%n' not defined in %v", mid, mod);
-}
-
 /* 15.2.2.4.41 */
 /*
  *  call-seq:
@@ -644,12 +623,14 @@ static mrb_value
 mrb_mod_remove_method(mrb_state *mrb, mrb_value mod)
 {
   mrb_int argc;
-  mrb_value *argv;
+  const mrb_value *argv;
+  struct RClass *c = mrb_class_ptr(mod);
 
   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));
+    mrb_remove_method(mrb, c, mrb_obj_to_sym(mrb, *argv));
+    mrb_funcall_id(mrb, mod, MRB_SYM(method_removed), 1, *argv);
     argv++;
   }
   return mod;
@@ -665,14 +646,13 @@ mrb_mod_s_constants(mrb_state *mrb, mrb_value mod)
 static mrb_value
 mrb_mod_s_nesting(mrb_state *mrb, mrb_value mod)
 {
-  struct RProc *proc;
+  const struct RProc *proc;
   mrb_value ary;
   struct RClass *c = NULL;
 
   ary = mrb_ary_new(mrb);
   proc = mrb->c->ci[-1].proc;   /* callee proc */
-  mrb_assert(!MRB_PROC_CFUNC_P(proc));
-  while (proc) {
+  while (proc && !MRB_PROC_CFUNC_P(proc)) {
     if (MRB_PROC_SCOPE_P(proc)) {
       struct RClass *c2 = MRB_PROC_TARGET_CLASS(proc);
 
@@ -686,6 +666,9 @@ mrb_mod_s_nesting(mrb_state *mrb, mrb_value mod)
   return ary;
 }
 
+/* implementation of #send method */
+mrb_value mrb_f_send(mrb_state *mrb, mrb_value self);
+
 void
 mrb_mruby_metaprog_gem_init(mrb_state* mrb)
 {

data/ext/enterprise_script_service/mruby/mrbgems/mruby-metaprog/test/metaprog.rb

@@ -114,6 +114,15 @@ def foo
     # Kernel#local_variables: 15.3.1.3.28
     local_variables.sort
   }.call(-1, -2)
+
+  a = Object.new
+  def a.hoge(vars, *, **)
+    Proc.new {
+      x, y = 1, 2
+      local_variables.sort
+    }
+  end
+  assert_equal([:vars, :x, :y]) { a.hoge(0).call }
 end
 
 assert('Kernel#define_singleton_method') do
@@ -386,15 +395,15 @@ def foo; end
 
 assert('alias_method and remove_method') do
   begin
-    Fixnum.alias_method :to_s_, :to_s
-    Fixnum.remove_method :to_s
+    Integer.alias_method :to_s_, :to_s
+    Integer.remove_method :to_s
 
     assert_nothing_raised do
       # segfaults if mrb_cptr is used
       1.to_s
     end
   ensure
-    Fixnum.alias_method :to_s, :to_s_
-    Fixnum.remove_method :to_s_
+    Integer.alias_method :to_s, :to_s_
+    Integer.remove_method :to_s_
   end
 end

data/ext/enterprise_script_service/mruby/mrbgems/mruby-method/README.md

@@ -1,7 +1,7 @@
 mruby-method
 ===
 
-A implementetion of class **Method** and **UnboundMethod** for mruby
+A implementation of class **Method** and **UnboundMethod** for mruby
 
 ```ruby
 p Enumerable.instance_method(:find_all).source_location
@@ -10,11 +10,12 @@ p Enumerable.instance_method(:find_all).source_location
 
 # Note
 
-`source_location` method need this configuration in build_config.rb
+You need to enable debug option in your build configuration to use
+`source_location` method in this gem, for example:
 
 ```ruby
 MRuby::Build.new do |conf|
-  enable_debug
+  conf.enable_debug
 end
 ```
 

data/ext/enterprise_script_service/mruby/mrbgems/mruby-method/src/method.c

@@ -4,6 +4,7 @@
 #include "mruby/variable.h"
 #include "mruby/proc.h"
 #include "mruby/string.h"
+#include "mruby/presym.h"
 
 static struct RObject *
 method_object_alloc(mrb_state *mrb, struct RClass *mclass)
@@ -29,55 +30,54 @@ static mrb_value
 unbound_method_bind(mrb_state *mrb, mrb_value self)
 {
   struct RObject *me;
-  mrb_value owner = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_owner"));
-  mrb_value name = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_name"));
-  mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_proc"));
-  mrb_value klass = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_klass"));
-  mrb_value recv;
+  mrb_value owner = mrb_iv_get(mrb, self, MRB_SYM(_owner));
+  mrb_value name = mrb_iv_get(mrb, self, MRB_SYM(_name));
+  mrb_value proc = mrb_iv_get(mrb, self, MRB_SYM(_proc));
+  mrb_value klass = mrb_iv_get(mrb, self, MRB_SYM(_klass));
+  mrb_value recv = mrb_get_arg1(mrb);
 
-  mrb_get_args(mrb, "o", &recv);
   bind_check(mrb, recv, owner);
-  me = method_object_alloc(mrb, mrb_class_get(mrb, "Method"));
-  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_owner"), owner);
-  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_recv"), recv);
-  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_name"), name);
-  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_proc"), proc);
-  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_klass"), klass);
+  me = method_object_alloc(mrb, mrb_class_get_id(mrb, MRB_SYM(Method)));
+  mrb_obj_iv_set(mrb, me, MRB_SYM(_owner), owner);
+  mrb_obj_iv_set(mrb, me, MRB_SYM(_recv), recv);
+  mrb_obj_iv_set(mrb, me, MRB_SYM(_name), name);
+  mrb_obj_iv_set(mrb, me, MRB_SYM(_proc), proc);
+  mrb_obj_iv_set(mrb, me, MRB_SYM(_klass), klass);
 
   return mrb_obj_value(me);
 }
 
-#define IV_GET(value, name) mrb_iv_get(mrb, value, mrb_intern_lit(mrb, name))
+#define IV_GET(value, name) mrb_iv_get(mrb, value, name)
 static mrb_value
 method_eql(mrb_state *mrb, mrb_value self)
 {
-  mrb_value other, receiver, orig_proc, other_proc;
+  mrb_value other = mrb_get_arg1(mrb);
+  mrb_value receiver, orig_proc, other_proc;
   struct RClass *owner, *klass;
   struct RProc *orig_rproc, *other_rproc;
 
-  mrb_get_args(mrb, "o", &other);
   if (!mrb_obj_is_instance_of(mrb, other, mrb_class(mrb, self)))
     return mrb_false_value();
 
   if (mrb_class(mrb, self) != mrb_class(mrb, other))
     return mrb_false_value();
 
-  klass = mrb_class_ptr(IV_GET(self, "_klass"));
-  if (klass != mrb_class_ptr(IV_GET(other, "_klass")))
+  klass = mrb_class_ptr(IV_GET(self, MRB_SYM(_klass)));
+  if (klass != mrb_class_ptr(IV_GET(other, MRB_SYM(_klass))))
     return mrb_false_value();
 
-  owner = mrb_class_ptr(IV_GET(self, "_owner"));
-  if (owner != mrb_class_ptr(IV_GET(other, "_owner")))
+  owner = mrb_class_ptr(IV_GET(self, MRB_SYM(_owner)));
+  if (owner != mrb_class_ptr(IV_GET(other, MRB_SYM(_owner))))
     return mrb_false_value();
 
-  receiver = IV_GET(self, "_recv");
-  if (!mrb_obj_equal(mrb, receiver, IV_GET(other, "_recv")))
+  receiver = IV_GET(self, MRB_SYM(_recv));
+  if (!mrb_obj_equal(mrb, receiver, IV_GET(other, MRB_SYM(_recv))))
     return mrb_false_value();
 
-  orig_proc = IV_GET(self, "_proc");
-  other_proc = IV_GET(other, "_proc");
+  orig_proc = IV_GET(self, MRB_SYM(_proc));
+  other_proc = IV_GET(other, MRB_SYM(_proc));
   if (mrb_nil_p(orig_proc) && mrb_nil_p(other_proc)) {
-    if (mrb_symbol(IV_GET(self, "_name")) == mrb_symbol(IV_GET(other, "_name")))
+    if (mrb_symbol(IV_GET(self, MRB_SYM(_name))) == mrb_symbol(IV_GET(other, MRB_SYM(_name))))
       return mrb_true_value();
     else
       return mrb_false_value();
@@ -110,7 +110,7 @@ method_eql(mrb_state *mrb, mrb_value self)
 
 static mrb_value
 mcall(mrb_state *mrb, mrb_value recv, mrb_value proc, mrb_value name, struct RClass *owner,
-      int argc, mrb_value *argv, mrb_value block)
+      mrb_int argc, const mrb_value *argv, mrb_value block)
 {
   mrb_value ret;
   mrb_sym orig_mid = mrb->c->ci->mid;
@@ -119,7 +119,7 @@ mcall(mrb_state *mrb, mrb_value recv, mrb_value proc, mrb_value name, struct RCl
   if (mrb_nil_p(proc)) {
     mrb_value missing_argv = mrb_ary_new_from_values(mrb, argc, argv);
     mrb_ary_unshift(mrb, missing_argv, name);
-    ret = mrb_funcall_argv(mrb, recv, mrb_intern_lit(mrb, "method_missing"), argc + 1, RARRAY_PTR(missing_argv));
+    ret = mrb_funcall_argv(mrb, recv, MRB_SYM(method_missing), argc + 1, RARRAY_PTR(missing_argv));
   }
   else if (!mrb_nil_p(block)) {
     /*
@@ -138,12 +138,13 @@ mcall(mrb_state *mrb, mrb_value recv, mrb_value proc, mrb_value name, struct RCl
 static mrb_value
 method_call(mrb_state *mrb, mrb_value self)
 {
-  mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_proc"));
-  mrb_value name = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_name"));
-  mrb_value recv = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_recv"));
-  struct RClass *owner = mrb_class_ptr(mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_owner")));
+  mrb_value proc = mrb_iv_get(mrb, self, MRB_SYM(_proc));
+  mrb_value name = mrb_iv_get(mrb, self, MRB_SYM(_name));
+  mrb_value recv = mrb_iv_get(mrb, self, MRB_SYM(_recv));
+  struct RClass *owner = mrb_class_ptr(mrb_iv_get(mrb, self, MRB_SYM(_owner)));
   mrb_int argc;
-  mrb_value *argv, block;
+  const mrb_value *argv;
+  mrb_value block;
 
   mrb_get_args(mrb, "*&", &argv, &argc, &block);
   return mcall(mrb, recv, proc, name, owner, argc, argv, block);
@@ -152,12 +153,13 @@ method_call(mrb_state *mrb, mrb_value self)
 static mrb_value
 method_bcall(mrb_state *mrb, mrb_value self)
 {
-  mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_proc"));
-  mrb_value name = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_name"));
-  mrb_value recv = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_recv"));
-  mrb_value owner = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_owner"));
+  mrb_value proc = mrb_iv_get(mrb, self, MRB_SYM(_proc));
+  mrb_value name = mrb_iv_get(mrb, self, MRB_SYM(_name));
+  mrb_value recv = mrb_iv_get(mrb, self, MRB_SYM(_recv));
+  mrb_value owner = mrb_iv_get(mrb, self, MRB_SYM(_owner));
   mrb_int argc;
-  mrb_value *argv, block;
+  const mrb_value *argv;
+  mrb_value block;
 
   mrb_get_args(mrb, "o*&", &recv, &argv, &argc, &block);
   bind_check(mrb, recv, owner);
@@ -168,17 +170,17 @@ static mrb_value
 method_unbind(mrb_state *mrb, mrb_value self)
 {
   struct RObject *ume;
-  mrb_value owner = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_owner"));
-  mrb_value name = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_name"));
-  mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_proc"));
-  mrb_value klass = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_klass"));
+  mrb_value owner = mrb_iv_get(mrb, self, MRB_SYM(_owner));
+  mrb_value name = mrb_iv_get(mrb, self, MRB_SYM(_name));
+  mrb_value proc = mrb_iv_get(mrb, self, MRB_SYM(_proc));
+  mrb_value klass = mrb_iv_get(mrb, self, MRB_SYM(_klass));
 
   ume = method_object_alloc(mrb, mrb_class_get(mrb, "UnboundMethod"));
-  mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_owner"), owner);
-  mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_recv"), mrb_nil_value());
-  mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_name"), name);
-  mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_proc"), proc);
-  mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_klass"), klass);
+  mrb_obj_iv_set(mrb, ume, MRB_SYM(_owner), owner);
+  mrb_obj_iv_set(mrb, ume, MRB_SYM(_recv), mrb_nil_value());
+  mrb_obj_iv_set(mrb, ume, MRB_SYM(_name), name);
+  mrb_obj_iv_set(mrb, ume, MRB_SYM(_proc), proc);
+  mrb_obj_iv_set(mrb, ume, MRB_SYM(_klass), klass);
 
   return mrb_obj_value(ume);
 }
@@ -197,10 +199,10 @@ method_search_vm(mrb_state *mrb, struct RClass **cp, mrb_sym mid)
 static mrb_value
 method_super_method(mrb_state *mrb, mrb_value self)
 {
-  mrb_value recv = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_recv"));
-  mrb_value klass = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_klass"));
-  mrb_value owner = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_owner"));
-  mrb_value name = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_name"));
+  mrb_value recv = mrb_iv_get(mrb, self, MRB_SYM(_recv));
+  mrb_value klass = mrb_iv_get(mrb, self, MRB_SYM(_klass));
+  mrb_value owner = mrb_iv_get(mrb, self, MRB_SYM(_owner));
+  mrb_value name = mrb_iv_get(mrb, self, MRB_SYM(_name));
   struct RClass *super, *rklass;
   struct RProc *proc;
   struct RObject *me;
@@ -226,11 +228,11 @@ method_super_method(mrb_state *mrb, mrb_value self)
     super = super->c;
 
   me = method_object_alloc(mrb, mrb_obj_class(mrb, self));
-  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_owner"), mrb_obj_value(super));
-  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_recv"), recv);
-  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_name"), name);
-  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_proc"), mrb_obj_value(proc));
-  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_klass"), mrb_obj_value(rklass));
+  mrb_obj_iv_set(mrb, me, MRB_SYM(_owner), mrb_obj_value(super));
+  mrb_obj_iv_set(mrb, me, MRB_SYM(_recv), recv);
+  mrb_obj_iv_set(mrb, me, MRB_SYM(_name), name);
+  mrb_obj_iv_set(mrb, me, MRB_SYM(_proc), mrb_obj_value(proc));
+  mrb_obj_iv_set(mrb, me, MRB_SYM(_klass), mrb_obj_value(rklass));
 
   return mrb_obj_value(me);
 }
@@ -238,7 +240,7 @@ method_super_method(mrb_state *mrb, mrb_value self)
 static mrb_value
 method_arity(mrb_state *mrb, mrb_value self)
 {
-  mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_proc"));
+  mrb_value proc = mrb_iv_get(mrb, self, MRB_SYM(_proc));
   mrb_int arity = mrb_nil_p(proc) ? -1 : mrb_proc_arity(mrb_proc_ptr(proc));
   return mrb_fixnum_value(arity);
 }
@@ -246,7 +248,7 @@ method_arity(mrb_state *mrb, mrb_value self)
 static mrb_value
 method_source_location(mrb_state *mrb, mrb_value self)
 {
-  mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_proc"));
+  mrb_value proc = mrb_iv_get(mrb, self, MRB_SYM(_proc));
   struct RProc *rproc;
   struct RClass *orig;
   mrb_value ret;
@@ -257,7 +259,7 @@ method_source_location(mrb_state *mrb, mrb_value self)
   rproc = mrb_proc_ptr(proc);
   orig = rproc->c;
   rproc->c = mrb->proc_class;
-  ret = mrb_funcall(mrb, proc, "source_location", 0);
+  ret = mrb_funcall_id(mrb, proc, MRB_SYM(source_location), 0);
   rproc->c = orig;
   return ret;
 }
@@ -265,13 +267,13 @@ method_source_location(mrb_state *mrb, mrb_value self)
 static mrb_value
 method_parameters(mrb_state *mrb, mrb_value self)
 {
-  mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_proc"));
+  mrb_value proc = mrb_iv_get(mrb, self, MRB_SYM(_proc));
   struct RProc *rproc;
   struct RClass *orig;
   mrb_value ret;
 
   if (mrb_nil_p(proc)) {
-    mrb_value rest = mrb_symbol_value(mrb_intern_lit(mrb, "rest"));
+    mrb_value rest = mrb_symbol_value(MRB_SYM(rest));
     mrb_value arest = mrb_ary_new_from_values(mrb, 1, &rest);
     return mrb_ary_new_from_values(mrb, 1, &arest);
   }
@@ -279,7 +281,7 @@ method_parameters(mrb_state *mrb, mrb_value self)
   rproc = mrb_proc_ptr(proc);
   orig = rproc->c;
   rproc->c = mrb->proc_class;
-  ret = mrb_funcall(mrb, proc, "parameters", 0);
+  ret = mrb_funcall_id(mrb, proc, MRB_SYM(parameters), 0);
   rproc->c = orig;
   return ret;
 }
@@ -287,9 +289,9 @@ method_parameters(mrb_state *mrb, mrb_value self)
 static mrb_value
 method_to_s(mrb_state *mrb, mrb_value self)
 {
-  mrb_value owner = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_owner"));
-  mrb_value klass = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_klass"));
-  mrb_value name = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_name"));
+  mrb_value owner = mrb_iv_get(mrb, self, MRB_SYM(_owner));
+  mrb_value klass = mrb_iv_get(mrb, self, MRB_SYM(_klass));
+  mrb_value name = mrb_iv_get(mrb, self, MRB_SYM(_name));
   mrb_value str = mrb_str_new_lit(mrb, "#<");
   struct RClass *rklass;
 
@@ -323,10 +325,10 @@ mrb_search_method_owner(mrb_state *mrb, struct RClass *c, mrb_value obj, mrb_sym
     if (unbound) {
       goto name_error;
     }
-    if (!mrb_respond_to(mrb, obj, mrb_intern_lit(mrb, "respond_to_missing?"))) {
+    if (!mrb_respond_to(mrb, obj, MRB_SYM_Q(respond_to_missing))) {
       goto name_error;
     }
-    ret = mrb_funcall(mrb, obj, "respond_to_missing?", 2, mrb_symbol_value(name), mrb_true_value());
+    ret = mrb_funcall_id(mrb, obj, MRB_SYM_Q(respond_to_missing), 2, mrb_symbol_value(name), mrb_true_value());
     if (!mrb_test(ret)) {
       goto name_error;
     }
@@ -355,11 +357,11 @@ mrb_kernel_method(mrb_state *mrb, mrb_value self)
   mrb_search_method_owner(mrb, mrb_class(mrb, self), self, name, &owner, &proc, FALSE);
 
   me = method_object_alloc(mrb, mrb_class_get(mrb, "Method"));
-  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_owner"), mrb_obj_value(owner));
-  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_recv"), self);
-  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_name"), mrb_symbol_value(name));
-  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_proc"), proc ? mrb_obj_value(proc) : mrb_nil_value());
-  mrb_obj_iv_set(mrb, me, mrb_intern_lit(mrb, "_klass"), mrb_obj_value(mrb_class(mrb, self)));
+  mrb_obj_iv_set(mrb, me, MRB_SYM(_owner), mrb_obj_value(owner));
+  mrb_obj_iv_set(mrb, me, MRB_SYM(_recv), self);
+  mrb_obj_iv_set(mrb, me, MRB_SYM(_name), mrb_symbol_value(name));
+  mrb_obj_iv_set(mrb, me, MRB_SYM(_proc), proc ? mrb_obj_value(proc) : mrb_nil_value());
+  mrb_obj_iv_set(mrb, me, MRB_SYM(_klass), mrb_obj_value(mrb_class(mrb, self)));
 
   return mrb_obj_value(me);
 }
@@ -377,11 +379,11 @@ mrb_module_instance_method(mrb_state *mrb, mrb_value self)
   mrb_search_method_owner(mrb, mrb_class_ptr(self), self, name, &owner, &proc, TRUE);
 
   ume = method_object_alloc(mrb, mrb_class_get(mrb, "UnboundMethod"));
-  mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_owner"), mrb_obj_value(owner));
-  mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_recv"), mrb_nil_value());
-  mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_name"), mrb_symbol_value(name));
-  mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_proc"), proc ? mrb_obj_value(proc) : mrb_nil_value());
-  mrb_obj_iv_set(mrb, ume, mrb_intern_lit(mrb, "_klass"), self);
+  mrb_obj_iv_set(mrb, ume, MRB_SYM(_owner), mrb_obj_value(owner));
+  mrb_obj_iv_set(mrb, ume, MRB_SYM(_recv), mrb_nil_value());
+  mrb_obj_iv_set(mrb, ume, MRB_SYM(_name), mrb_symbol_value(name));
+  mrb_obj_iv_set(mrb, ume, MRB_SYM(_proc), proc ? mrb_obj_value(proc) : mrb_nil_value());
+  mrb_obj_iv_set(mrb, ume, MRB_SYM(_klass), self);
 
   return mrb_obj_value(ume);
 }
@@ -389,19 +391,19 @@ mrb_module_instance_method(mrb_state *mrb, mrb_value self)
 static mrb_value
 method_owner(mrb_state *mrb, mrb_value self)
 {
-  return mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_owner"));
+  return mrb_iv_get(mrb, self, MRB_SYM(_owner));
 }
 
 static mrb_value
 method_receiver(mrb_state *mrb, mrb_value self)
 {
-  return mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_recv"));
+  return mrb_iv_get(mrb, self, MRB_SYM(_recv));
 }
 
 static mrb_value
 method_name(mrb_state *mrb, mrb_value self)
 {
-  return mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_name"));
+  return mrb_iv_get(mrb, self, MRB_SYM(_name));
 }
 
 void