From: Yusuke Endoh Date: 2010-03-18T02:00:18+09:00 Subject: [ruby-core:28719] [Feature #2740] Extend const_missing to pass in the nesting Issue #2740 has been updated by Yusuke Endoh. Hi, Matz, do you accept Yehuda's suggestion? Current status: - Three persons (nobu, murphy and I) have approved. - There is no objection. - There is a patch written by nobu and murphy, though it has a little bug. I revised a patch below. 2010/2/15 Yehuda Katz : > class Module > def const_missing(name) > puts "#{self} is missing #{name}" > raise NoConstantError unless self == Object > end > end > *snip > > module Foo::Bar > Foo::Bar::Baz > end > > # Output > # Foo::Bar is missing Baz I'd like to make sure one thing; the above code should raise NoConstantError after the output, ok? This is because scoped constant reference does not check bindings of Object class. Instead of raising an error, nobu's patch leaks Qundef for the above code, which causes SEGV in RubySpec. It is clearly a problem. diff --git a/error.c b/error.c index 3fcd184..d0373fd 100644 --- a/error.c +++ b/error.c @@ -401,6 +401,8 @@ VALUE rb_eScriptError; VALUE rb_eSyntaxError; VALUE rb_eLoadError; +VALUE rb_eNoConstantError; + VALUE rb_eSystemCallError; VALUE rb_mErrno; static VALUE rb_eNOERROR; @@ -701,18 +703,34 @@ exit_success_p(VALUE exc) return Qfalse; } +static VALUE +new_name_error(VALUE klass, ID id, const char *fmt, va_list args) +{ + VALUE argv[2]; + argv[0] = rb_vsprintf(fmt, args); + argv[1] = ID2SYM(id); + return rb_class_new_instance(2, argv, klass); +} + void rb_name_error(ID id, const char *fmt, ...) { - VALUE exc, argv[2]; + VALUE exc; va_list args; - va_start(args, fmt); - argv[0] = rb_vsprintf(fmt, args); + exc = new_name_error(rb_eNameError, id, fmt, args); va_end(args); + rb_exc_raise(exc); +} - argv[1] = ID2SYM(id); - exc = rb_class_new_instance(2, argv, rb_eNameError); +void +rb_name_error_with_class(VALUE klass, ID id, const char *fmt, ...) +{ + VALUE exc; + va_list args; + va_start(args, fmt); + exc = new_name_error(klass, id, fmt, args); + va_end(args); rb_exc_raise(exc); } @@ -1142,6 +1160,7 @@ Init_Exception(void) rb_eNoMethodError = rb_define_class("NoMethodError", rb_eNameError); rb_define_method(rb_eNoMethodError, "initialize", nometh_err_initialize, -1); rb_define_method(rb_eNoMethodError, "args", nometh_err_args, 0); + rb_eNoConstantError = rb_define_class("NoConstantError", rb_eNameError); rb_eRuntimeError = rb_define_class("RuntimeError", rb_eStandardError); rb_eSecurityError = rb_define_class("SecurityError", rb_eException); diff --git a/test/rake/test_top_level_functions.rb b/test/rake/test_top_level_functions.rb index 12a8cd1..7315f88 100644 --- a/test/rake/test_top_level_functions.rb +++ b/test/rake/test_top_level_functions.rb @@ -86,6 +86,6 @@ class Rake::TestTopLevelFunctions < Test::Unit::TestCase end def test_missing_other_constant - assert_raise(NameError) do Object.const_missing(:Xyz) end + assert_raise(NoConstantError) do Object.const_missing(:Xyz) end end end diff --git a/test/ruby/test_basicinstructions.rb b/test/ruby/test_basicinstructions.rb index ff14e4a..eb985ef 100644 --- a/test/ruby/test_basicinstructions.rb +++ b/test/ruby/test_basicinstructions.rb @@ -271,25 +271,25 @@ class TestBasicInstructions < Test::Unit::TestCase Const::A::B._remove_const :C assert_equal 'Const::C', Const::C assert_equal 'Const::A::C', Const::A::C - assert_raise(NameError) { Const::A::B::C } + assert_raise(NoConstantError) { Const::A::B::C } Const::A._remove_const :C assert_equal 'Const::C', Const::C - assert_raise(NameError) { Const::A::C } - assert_raise(NameError) { Const::A::B::C } + assert_raise(NoConstantError) { Const::A::C } + assert_raise(NoConstantError) { Const::A::B::C } Const._remove_const :C - assert_raise(NameError) { Const::C } - assert_raise(NameError) { Const::A::C } - assert_raise(NameError) { Const::A::B::C } + assert_raise(NoConstantError) { Const::C } + assert_raise(NoConstantError) { Const::A::C } + assert_raise(NoConstantError) { Const::A::B::C } Const::A.const_set :C, 'Const::A::C' - assert_raise(NameError) { Const::C } + assert_raise(NoConstantError) { Const::C } assert_equal 'Const::A::C', Const::A::C - assert_raise(NameError) { Const::A::B::C } + assert_raise(NoConstantError) { Const::A::B::C } Const::A::B.const_set :C, 'Const::A::B::C' - assert_raise(NameError) { Const::C } + assert_raise(NoConstantError) { Const::C } assert_equal 'Const::A::C', Const::A::C assert_equal 'Const::A::B::C', Const::A::B::C diff --git a/test/ruby/test_module.rb b/test/ruby/test_module.rb index f905431..fbeb29b 100644 --- a/test/ruby/test_module.rb +++ b/test/ruby/test_module.rb @@ -451,13 +451,13 @@ class TestModule < Test::Unit::TestCase assert_equal(:foo, c1::Foo) assert_equal(:foo, c2::Foo) assert_equal(:foo, c2.const_get(:Foo)) - assert_raise(NameError) { c2.const_get(:Foo, false) } + assert_raise(NoConstantError) { c2.const_get(:Foo, false) } eval("c1::Foo = :foo") - assert_raise(NameError) { c1::Bar } - assert_raise(NameError) { c2::Bar } - assert_raise(NameError) { c2.const_get(:Bar) } - assert_raise(NameError) { c2.const_get(:Bar, false) } + assert_raise(NoConstantError) { c1::Bar } + assert_raise(NoConstantError) { c2::Bar } + assert_raise(NoConstantError) { c2.const_get(:Bar) } + assert_raise(NoConstantError) { c2.const_get(:Bar, false) } c1.instance_eval do def const_missing(x) diff --git a/test/ruby/test_object.rb b/test/ruby/test_object.rb index 0a49422..af91f75 100644 --- a/test/ruby/test_object.rb +++ b/test/ruby/test_object.rb @@ -437,7 +437,7 @@ class TestObject < Test::Unit::TestCase x = "foo".instance_exec("bar") {|a| self + a } assert_equal("foobar", x) - assert_raise(NameError) do + assert_raise(NoConstantError) do InstanceExec.new.instance_exec { INSTANCE_EXEC } end end diff --git a/variable.c b/variable.c index d7b99f1..4be8a8e 100644 --- a/variable.c +++ b/variable.c @@ -1341,23 +1341,49 @@ rb_obj_remove_instance_variable(VALUE obj, VALUE name) return Qnil; /* not reached */ } +extern VALUE rb_eNoConstantError; + +PRINTF_ARGS(NORETURN(void rb_name_error_with_class(VALUE, ID, const char*, ...)), 3, 4); NORETURN(static void uninitialized_constant(VALUE, ID)); static void uninitialized_constant(VALUE klass, ID id) { - if (klass && klass != rb_cObject) - rb_name_error(id, "uninitialized constant %s::%s", + if (klass && klass != rb_cObject){ + rb_name_error_with_class(rb_eNoConstantError, + id, "uninitialized constant %s::%s", rb_class2name(klass), rb_id2name(id)); + } else { - rb_name_error(id, "uninitialized constant %s", rb_id2name(id)); + rb_name_error_with_class(rb_eNoConstantError, + id, "uninitialized constant %s", rb_id2name(id)); } } static VALUE +const_missing_call(VALUE arg) +{ + VALUE *args = (VALUE *)arg; + ID const_missing_id; + CONST_ID(const_missing_id, "const_missing"); + return rb_check_funcall(args[0], const_missing_id, 1, &args[1]); +} + +static VALUE +const_missing_rescue(VALUE arg, VALUE errinfo) +{ + return arg; +} + +static VALUE const_missing(VALUE klass, ID id) { - return rb_funcall(klass, rb_intern("const_missing"), 1, ID2SYM(id)); + VALUE args[2]; + args[0] = klass; + args[1] = ID2SYM(id); + return rb_rescue2(const_missing_call, (VALUE)args, + const_missing_rescue, (VALUE)Qundef, + rb_eNoConstantError, (VALUE)0); } @@ -1597,7 +1623,27 @@ rb_const_get_0(VALUE klass, ID id, int exclude, int recurse) goto retry; } - value = const_missing(klass, id); + tmp = klass; + if ((value = const_missing(tmp, id)) == Qundef) { + NODE *rb_vm_cref(void); + NODE *cref = rb_vm_cref(); + cref = cref->nd_next; + while (cref && cref->nd_next && + ((cref->flags & NODE_FL_CREF_PUSHED_BY_EVAL) || + NIL_P(tmp = cref->nd_clss) || + (value = const_missing(tmp, id)) == Qundef)) { + cref = cref->nd_next; + } + if (value == Qundef) { + if (!exclude) { + value = const_missing(rb_cObject, id); + } + if (value == Qundef) { + uninitialized_constant(klass, id); + } + } + } + rb_vm_inc_const_missing_count(); return value; } @@ -1655,7 +1701,7 @@ rb_const_remove(VALUE mod, ID id) rb_name_error(id, "cannot remove %s::%s", rb_class2name(mod), rb_id2name(id)); } - rb_name_error(id, "constant %s::%s not defined", + rb_name_error_with_class(rb_eNoConstantError, id, "constant %s::%s not defined", rb_class2name(mod), rb_id2name(id)); } -- Yusuke ENDOH ---------------------------------------- http://redmine.ruby-lang.org/issues/show/2740 ---------------------------------------- http://redmine.ruby-lang.org