Object* const_missing(STATE, Symbol* sym) {
Module* under;
CallFrame* call_frame = state->vm()->get_ruby_frame();
LexicalScope* scope = call_frame->lexical_scope();
if(scope->nil_p()) {
under = G(object);
} else {
under = scope->module();
}
Array* args = Array::create(state, 1);
args->set(state, 0, sym);
return under->send(state, G(sym_const_missing), args);
}
Object* const_get(STATE, Symbol* name, ConstantMissingReason* reason, Object* filter, bool replace_autoload) {
LexicalScope *cur;
Object* result;
*reason = vNonExistent;
CallFrame* frame = state->vm()->get_ruby_frame();
// Ok, this has to be explained or it will be considered black magic.
// The scope chain always ends with an entry at the top that contains
// a parent of nil, and a module of Object. This entry is put in
// regardless of lexical scoping, it's the fallback scope (the default
// scope). This is not case when deriving from BasicObject, which is
// explained later.
//
// When looking up a constant, we don't want to consider the fallback
// scope (ie, Object) initially because we need to lookup up
// the superclass chain first, because falling back on the default.
//
// The rub comes from the fact that if a user explicitly opens up
// Object in their code, we DO consider it. Like:
//
// class Idiot
// A = 2
// end
//
// class ::Object
// A = 1
// class Stupid < Idiot
// def foo
// p A
// end
// end
// end
//
// In this code, when A is looked up, Object must be considering during
// the scope walk, NOT during the superclass walk.
//
// So, in this case, foo would print "1", not "2".
//
// As indicated above, the fallback scope isn't used when the superclass
// chain directly rooted from BasicObject. To determine this is the
// case, we record whether Object is seen when looking up the superclass
// chain. If Object isn't seen, this means we are directly deriving from
// BasicObject.
cur = frame->lexical_scope();
while(!cur->nil_p()) {
// Detect the toplevel scope (the default) and get outta dodge.
if(cur->top_level_p(state)) break;
result = cur->module()->get_const(state, name, G(sym_private), reason, false, replace_autoload);
if(*reason == vFound) {
if(result != filter) return result;
*reason = vNonExistent;
}
cur = cur->parent();
}
// Now look up the superclass chain.
Module *fallback = G(object);
cur = frame->lexical_scope();
if(!cur->nil_p()) {
bool object_seen = false;
Module* mod = cur->module();
while(!mod->nil_p()) {
if(mod == G(object)) {
object_seen = true;
}
if(!object_seen && mod == G(basicobject)) {
fallback = NULL;
}
result = mod->get_const(state, name, G(sym_private), reason, false, replace_autoload);
if(*reason == vFound) {
if(result != filter) return result;
*reason = vNonExistent;
}
mod = mod->superclass();
}
}
// Lastly, check the fallback scope (=Object) specifically if needed
if(fallback) {
result = fallback->get_const(state, name, G(sym_private), reason, true, replace_autoload);
if(*reason == vFound) {
if(result != filter) return result;
*reason = vNonExistent;
}
}
return cNil;
}