script_core 0.1.1 → 0.2.0

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

@@ -1,17 +1,3 @@
-assert('Kernel#__send__', '15.3.1.3.4') do
-  # test with block
-  l = __send__(:lambda) do
-    true
-  end
-
-  assert_true l.call
-  assert_equal Proc, l.class
-  # test with argument
-  assert_true __send__(:respond_to?, :nil?)
-  # test without argument and without block
-  assert_equal String, __send__(:to_s).class
-end
-
 assert('Kernel#send', '15.3.1.3.44') do
   # test with block
   l = send(:lambda) do
@@ -58,6 +44,8 @@
   %w[@6 @% @@a @ a].each do |n|
     assert_raise(NameError) { o.instance_variable_set(n, 1) }
   end
+  assert_raise(FrozenError) { o.freeze.instance_variable_set(:@a, 2) }
+  assert_raise(FrozenError, ArgumentError) { nil.instance_variable_set(:@a, 2) }
 end
 
 assert('Kernel#instance_variables', '15.3.1.3.23') do
@@ -99,6 +87,21 @@ def foo
   assert_equal singleton_methods.class, Array
 end
 
+assert('Kernel.global_variables', '15.3.1.2.4') do
+  assert_equal Array, Kernel.global_variables.class
+end
+
+assert('Kernel#global_variables', '15.3.1.3.14') do
+  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
   a, b = 0, 1
   a += b
@@ -120,6 +123,24 @@ def foo
   end
   assert_equal :test_method, ret
   assert_equal :singleton_method_ok, o.test_method
+  assert_raise(TypeError) { 2.define_singleton_method(:f){} }
+  assert_raise(FrozenError) { [].freeze.define_singleton_method(:f){} }
+end
+
+assert('Kernel#singleton_class') do
+  o1 = Object.new
+  assert_same(o1.singleton_class, class << o1; self end)
+
+  o2 = Object.new
+  sc2 = class << o2; self end
+  assert_same(o2.singleton_class, sc2)
+
+  o3 = Object.new
+  sc3 = o3.singleton_class
+  o3.freeze
+  assert_predicate(sc3, :frozen?)
+
+  assert_predicate(Object.new.freeze.singleton_class, :frozen?)
 end
 
 def labeled_module(name, &block)
@@ -171,7 +192,6 @@ def foo
       @@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 +200,13 @@ def foo
   %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
@@ -261,6 +288,9 @@ class Test4RemoveClassVariable
   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
@@ -268,9 +298,9 @@ module Test4RemoveMethod
     class Parent
       def hello
       end
-     end
+    end
 
-     class Child < Parent
+    class Child < Parent
       def hello
       end
     end
@@ -280,6 +310,7 @@ def hello
   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

data/ext/enterprise_script_service/mruby/mrbgems/mruby-method/mrblib/method.rb

@@ -6,18 +6,6 @@ def to_proc
     }
   end
 
-  def owner
-    @owner
-  end
-
-  def receiver
-    @recv
-  end
-
-  def name
-    @name
-  end
-
   def <<(other)
     ->(*args, &block) { call(other.call(*args, &block)) }
   end

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

@@ -11,34 +11,38 @@ method_object_alloc(mrb_state *mrb, struct RClass *mclass)
   return (struct RObject*)mrb_obj_alloc(mrb, MRB_TT_OBJECT, mclass);
 }
 
+static void
+bind_check(mrb_state *mrb, mrb_value recv, mrb_value owner)
+{
+  if (!mrb_module_p(owner) &&
+      mrb_class_ptr(owner) != mrb_obj_class(mrb, recv) &&
+      !mrb_obj_is_kind_of(mrb, recv, mrb_class_ptr(owner))) {
+    if (mrb_sclass_p(owner)) {
+      mrb_raise(mrb, E_TYPE_ERROR, "singleton method called for a different object");
+    } else {
+      mrb_raisef(mrb, E_TYPE_ERROR, "bind argument must be an instance of %v", owner);
+    }
+  }
+}
+
 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 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_get_args(mrb, "o", &recv);
-
-  if (mrb_type(owner) != MRB_TT_MODULE &&
-      mrb_class_ptr(owner) != mrb_obj_class(mrb, recv) &&
-      !mrb_obj_is_kind_of(mrb, recv, mrb_class_ptr(owner))) {
-        if (mrb_type(owner) == MRB_TT_SCLASS) {
-          mrb_raise(mrb, E_TYPE_ERROR, "singleton method called for a different object");
-        } else {
-          const char *s = mrb_class_name(mrb, mrb_class_ptr(owner));
-          mrb_raisef(mrb, E_TYPE_ERROR, "bind argument must be an instance of %S", mrb_str_new_static(mrb, s, strlen(s)));
-        }
-  }
+  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);
+  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);
 
   return mrb_obj_value(me);
 }
@@ -58,22 +62,22 @@ method_eql(mrb_state *mrb, mrb_value self)
   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, "_klass"));
+  if (klass != mrb_class_ptr(IV_GET(other, "_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, "_owner"));
+  if (owner != mrb_class_ptr(IV_GET(other, "_owner")))
     return mrb_false_value();
 
-  receiver = IV_GET(self, "@recv");
-  if (!mrb_obj_equal(mrb, receiver, IV_GET(other, "@recv")))
+  receiver = IV_GET(self, "_recv");
+  if (!mrb_obj_equal(mrb, receiver, IV_GET(other, "_recv")))
     return mrb_false_value();
 
-  orig_proc = IV_GET(self, "proc");
-  other_proc = IV_GET(other, "proc");
+  orig_proc = IV_GET(self, "_proc");
+  other_proc = IV_GET(other, "_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, "_name")) == mrb_symbol(IV_GET(other, "_name")))
       return mrb_true_value();
     else
       return mrb_false_value();
@@ -105,18 +109,12 @@ method_eql(mrb_state *mrb, mrb_value self)
 #undef IV_GET
 
 static mrb_value
-method_call(mrb_state *mrb, mrb_value self)
+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_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_int argc;
-  mrb_value *argv, ret, block;
-  mrb_sym orig_mid;
+  mrb_value ret;
+  mrb_sym orig_mid = mrb->c->ci->mid;
 
-  mrb_get_args(mrb, "*&", &argv, &argc, &block);
-  orig_mid = mrb->c->ci->mid;
   mrb->c->ci->mid = mrb_symbol(name);
   if (mrb_nil_p(proc)) {
     mrb_value missing_argv = mrb_ary_new_from_values(mrb, argc, argv);
@@ -137,21 +135,50 @@ method_call(mrb_state *mrb, mrb_value self)
   return ret;
 }
 
+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_int argc;
+  mrb_value *argv, block;
+
+  mrb_get_args(mrb, "*&", &argv, &argc, &block);
+  return mcall(mrb, recv, proc, name, owner, argc, argv, block);
+}
+
+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_int argc;
+  mrb_value *argv, block;
+
+  mrb_get_args(mrb, "o*&", &recv, &argv, &argc, &block);
+  bind_check(mrb, recv, owner);
+  return mcall(mrb, recv, proc, name, mrb_class_ptr(owner), argc, argv, block);
+}
+
 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_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"));
 
   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_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);
 
   return mrb_obj_value(ume);
 }
@@ -170,10 +197,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_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"));
   struct RClass *super, *rklass;
   struct RProc *proc;
   struct RObject *me;
@@ -199,11 +226,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_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));
 
   return mrb_obj_value(me);
 }
@@ -211,26 +238,15 @@ 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"));
-  struct RProc *rproc;
-  struct RClass *orig;
-  mrb_value ret;
-
-  if (mrb_nil_p(proc))
-    return mrb_fixnum_value(-1);
-
-  rproc = mrb_proc_ptr(proc);
-  orig = rproc->c;
-  rproc->c = mrb->proc_class;
-  ret = mrb_funcall(mrb, proc, "arity", 0);
-  rproc->c = orig;
-  return ret;
+  mrb_value proc = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_proc"));
+  mrb_int arity = mrb_nil_p(proc) ? -1 : mrb_proc_arity(mrb_proc_ptr(proc));
+  return mrb_fixnum_value(arity);
 }
 
 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_intern_lit(mrb, "_proc"));
   struct RProc *rproc;
   struct RClass *orig;
   mrb_value ret;
@@ -249,7 +265,7 @@ 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_intern_lit(mrb, "_proc"));
   struct RProc *rproc;
   struct RClass *orig;
   mrb_value ret;
@@ -271,9 +287,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_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 str = mrb_str_new_lit(mrb, "#<");
   struct RClass *rklass;
 
@@ -281,16 +297,16 @@ method_to_s(mrb_state *mrb, mrb_value self)
   mrb_str_cat_lit(mrb, str, ": ");
   rklass = mrb_class_ptr(klass);
   if (mrb_class_ptr(owner) == rklass) {
-    mrb_str_cat_str(mrb, str, mrb_funcall(mrb, owner, "to_s", 0));
+    mrb_str_concat(mrb, str, owner);
     mrb_str_cat_lit(mrb, str, "#");
-    mrb_str_cat_str(mrb, str, mrb_funcall(mrb, name, "to_s", 0));
+    mrb_str_concat(mrb, str, name);
   }
   else {
     mrb_str_cat_cstr(mrb, str, mrb_class_name(mrb, rklass));
     mrb_str_cat_lit(mrb, str, "(");
-    mrb_str_cat_str(mrb, str, mrb_funcall(mrb, owner, "to_s", 0));
+    mrb_str_concat(mrb, str, owner);
     mrb_str_cat_lit(mrb, str, ")#");
-    mrb_str_cat_str(mrb, str, mrb_funcall(mrb, name, "to_s", 0));
+    mrb_str_concat(mrb, str, name);
   }
   mrb_str_cat_lit(mrb, str, ">");
   return str;
@@ -300,7 +316,6 @@ static void
 mrb_search_method_owner(mrb_state *mrb, struct RClass *c, mrb_value obj, mrb_sym name, struct RClass **owner, struct RProc **proc, mrb_bool unbound)
 {
   mrb_value ret;
-  const char *s;
 
   *owner = c;
   *proc = method_search_vm(mrb, owner, name);
@@ -324,13 +339,7 @@ mrb_search_method_owner(mrb_state *mrb, struct RClass *c, mrb_value obj, mrb_sym
   return;
 
 name_error:
-  s = mrb_class_name(mrb, c);
-  mrb_raisef(
-    mrb, E_NAME_ERROR,
-    "undefined method '%S' for class '%S'",
-    mrb_sym2str(mrb, name),
-    mrb_str_new_static(mrb, s, strlen(s))
-  );
+  mrb_raisef(mrb, E_NAME_ERROR, "undefined method '%n' for class '%C'", name, c);
 }
 
 static mrb_value
@@ -346,11 +355,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_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)));
 
   return mrb_obj_value(me);
 }
@@ -368,15 +377,33 @@ 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_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);
 
   return mrb_obj_value(ume);
 }
 
+static mrb_value
+method_owner(mrb_state *mrb, mrb_value self)
+{
+  return mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_owner"));
+}
+
+static mrb_value
+method_receiver(mrb_state *mrb, mrb_value self)
+{
+  return mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_recv"));
+}
+
+static mrb_value
+method_name(mrb_state *mrb, mrb_value self)
+{
+  return mrb_iv_get(mrb, self, mrb_intern_lit(mrb, "_name"));
+}
+
 void
 mrb_mruby_method_gem_init(mrb_state* mrb)
 {
@@ -387,25 +414,31 @@ mrb_mruby_method_gem_init(mrb_state* mrb)
   mrb_define_method(mrb, unbound_method, "bind", unbound_method_bind, MRB_ARGS_REQ(1));
   mrb_define_method(mrb, unbound_method, "super_method", method_super_method, MRB_ARGS_NONE());
   mrb_define_method(mrb, unbound_method, "==", method_eql, MRB_ARGS_REQ(1));
-  mrb_define_alias(mrb,  unbound_method, "eql?", "==");
+  mrb_define_method(mrb, unbound_method, "eql?", method_eql, MRB_ARGS_REQ(1));
   mrb_define_method(mrb, unbound_method, "to_s", method_to_s, MRB_ARGS_NONE());
   mrb_define_method(mrb, unbound_method, "inspect", method_to_s, MRB_ARGS_NONE());
   mrb_define_method(mrb, unbound_method, "arity", method_arity, MRB_ARGS_NONE());
   mrb_define_method(mrb, unbound_method, "source_location", method_source_location, MRB_ARGS_NONE());
   mrb_define_method(mrb, unbound_method, "parameters", method_parameters, MRB_ARGS_NONE());
+  mrb_define_method(mrb, unbound_method, "bind_call", method_bcall, MRB_ARGS_REQ(1)|MRB_ARGS_ANY());
+  mrb_define_method(mrb, unbound_method, "owner", method_owner, MRB_ARGS_NONE());
+  mrb_define_method(mrb, unbound_method, "name", method_name, MRB_ARGS_NONE());
 
   mrb_undef_class_method(mrb, method, "new");
   mrb_define_method(mrb, method, "==", method_eql, MRB_ARGS_REQ(1));
-  mrb_define_alias(mrb,  method, "eql?", "==");
+  mrb_define_method(mrb, method, "eql?", method_eql, MRB_ARGS_REQ(1));
   mrb_define_method(mrb, method, "to_s", method_to_s, MRB_ARGS_NONE());
   mrb_define_method(mrb, method, "inspect", method_to_s, MRB_ARGS_NONE());
   mrb_define_method(mrb, method, "call", method_call, MRB_ARGS_ANY());
-  mrb_define_alias(mrb,  method, "[]", "call");
+  mrb_define_method(mrb, method, "[]", method_call, MRB_ARGS_ANY());
   mrb_define_method(mrb, method, "unbind", method_unbind, MRB_ARGS_NONE());
   mrb_define_method(mrb, method, "super_method", method_super_method, MRB_ARGS_NONE());
   mrb_define_method(mrb, method, "arity", method_arity, MRB_ARGS_NONE());
   mrb_define_method(mrb, method, "source_location", method_source_location, MRB_ARGS_NONE());
   mrb_define_method(mrb, method, "parameters", method_parameters, MRB_ARGS_NONE());
+  mrb_define_method(mrb, method, "owner", method_owner, MRB_ARGS_NONE());
+  mrb_define_method(mrb, method, "receiver", method_receiver, MRB_ARGS_NONE());
+  mrb_define_method(mrb, method, "name", method_name, MRB_ARGS_NONE());
 
   mrb_define_method(mrb, mrb->kernel_module, "method", mrb_kernel_method, MRB_ARGS_REQ(1));