Very weird.

The same problem is on JRuby 9k too. I met with this issue in case of trying to pass tests of lotus-router on JRuby 9k.

git clone git@github.com:lotus/router.git lotus-router
cd lotus-router
bundle
rake test

Just stumbled on this one with jruby-9000-dev built yesterday. Inheriting from Object is fine, but any object that raises an error within a BasicObject subclass dies.

Ah yeah this is not an issue with 1.7.18 and is a problem with master/9k. #2267 is causing people to run specs against the wrong version of JRuby. I will update this issue and mark it against 9k.

@ntl do you happen to have a reduces snippet for this? My repros of making an object inherited from BasicObject so far have not been blowing up.

This will do it for me. I think you have to rescue an error within BasicObject.

class ExposesJRuby2417 < BasicObject                                               
  def blow_up                                                                      
    begin                                                                          
      ::Kernel.raise "error"                                                       
    rescue                                                                         
    end                                                                            
  end                                                                              
end                                                                                
ExposesJRuby2417.new.blow_up                                                       

@ntl Excellent! About as minimal as it probably gets...

@enebo glad it's helpful. I strongly resisted the urge to golf it down further :)

The problem is that 'StandardError' is not being found in the inheritance hierarchy when the class inherits BasicObject. So, maybe the bug is that in IR mode, we shouldn't be generating a lookup for StandardError but have it around. See the related FIXME in IRBuilder which talks of a different issue with having the class looked up. I think dealing with the FIXME will fix the issue. But, before I go ahead, it would be good to get some other eyes on it ( @enebo @headius ).

        // SSS FIXME:
        // rescue => e AND rescue implicitly EQQ the exception object with StandardError
        // We generate explicit IR for this test here.  But, this can lead to inconsistent
        // behavior (when compared to MRI) in certain scenarios.  See example:
        //
        //   self.class.const_set(:StandardError, 1)
        //   begin; raise TypeError.new; rescue; puts "AHA"; end
        //
        // MRI rescues the error, but we will raise an exception because of reassignment
        // of StandardError.  I am ignoring this for now and treating this as undefined behavior.
        //
        // Solution: Create a 'StandardError' operand type to eliminate this.
        Variable v = addResultInstr(s, new InheritanceSearchConstInstr(s.createTemporaryVariable(), s.getCurrentModuleVariable(), "StandardError", false));

I think shortest near term fix would be to change module<0> to Class:Object right? I guess we should figure out it overriding this particular constant will change rescue behavior or not too since manipulating StandardErrror to something else at runtime seems like a horrible idea :) Having an operand for either behavior would probably be the thing to do once we figure out which way it is supposed to work.

BB [6:LBL_2:10]
    %v_3 = recv_ruby_exc
    %v_4 = inheritance_search_const(module<0>)(module<0>, StandardError)
    %v_5 = rescue_eqq(%v_4, %v_3)
    b_true(LBL_5:16, %v_5)

Ok so I looked into @subbuss question:

Object.const_set :StandardError, 1

class ExposesJRuby2417 < BasicObject                                               
  def blow_up                                                                      
    begin                                                                          
      ::Kernel.raise "error"                                                       
    rescue 
       puts "rescued"                                                                        
    end                                                                            
  end                                                                              
end                                                                                
ExposesJRuby2417.new.blow_up   

In MRI this prints "rescued" and in JRuby we complain about StandardError being '1'.