So, caller lies. I suspect this is true no matter what. It may also be 
the case that Method#id is wrong as well... it might not. There isn't a 
formal spec on this language, so I can only guess... Here's my problem. 
It's related to the RubyInline issue that came up a few days ago. Here 
is a brief (I hope) description of the problem, followed by some code 
to assert the case:

A user aliases a method that calls inline. Inline does it's thing and 
replaces (via alias) the old method with the new optimized method. But 
the user is calling the method through his alias. That is where caller 
lies. Caller says that the method one level up from inline is the 
original method, not the alias. This would be fine except that 
method(:oldm).id != method(:newm).id. So not only can I not optimize 
and replace the alias based on the name via caller, but I also can't 
iterate over the methods to see which ones are aliases of the original 
and replace them all.

#!/usr/local/bin/ruby -w

class CallerBug

   def whoami?
     return caller[0]
   end

   def oldcaller
     return self.whoami?
   end

   alias :newcaller :oldcaller

end

bug = CallerBug.new

p bug.method(:oldcaller).id == bug.method(:newcaller).id
p bug.oldcaller != bug.newcaller

# both tests at the end return false.

So, here are my questions:

1) What can I do to solve my problem with RubyInline, with current 
versions of ruby??
2) Are either of these a bug?
3) Does method(:name).id return the id of the method instance, or the 
name?
4) If #3=instance, what is the rationale for rb_alias to create a new 
method entirely via NEW_METHOD(NEW_FBODY(...))?