attr_reader on constant

Author: XrXr

zjit/src/hir.rs

@@ -3234,25 +3234,34 @@ impl Function {
                                         is_t_object: recv_type.flags().is_t_object(),
                                         is_embedded: recv_type.flags().is_embedded()
                                     });
-                                    self.push_insn(block, Insn::GetIvar { self_val: refined_recv, id, ic: std::ptr::null(), state })
+                                    self.push_insn(block, Insn::GetIvar { self_val: refined_recv, id, ic: ptr::null(), state })
                                 } else {
-                                    self.push_insn(block, Insn::GetIvar { self_val: recv, id, ic: std::ptr::null(), state })
+                                    self.push_insn(block, Insn::GetIvar { self_val: recv, id, ic: ptr::null(), state })
                                 }
                             } else if let Some(val) = self.type_of(recv).ruby_object() {
                                 // Constant receiver: get shape info from the VALUE directly
-                                let recv_shape = val.shape_id_of();
-                                if recv_shape.is_valid() && !recv_shape.is_too_complex() {
-                                    let shape = self.load_shape(block, recv);
-                                    self.guard_shape(block, shape, recv_shape, state);
-                                    let is_t_object = unsafe { RB_TYPE_P(val, RUBY_T_OBJECT) };
-                                    let is_embedded = is_t_object && val.embedded_p();
-                                    let refined_recv = self.push_insn(block, Insn::RefineShape { val: recv, shape: recv_shape, is_t_object, is_embedded });
-                                    self.push_insn(block, Insn::GetIvar { self_val: refined_recv, id, ic: std::ptr::null(), state })
+                                // TODO missing snapshot test: attr reader on special const. Also
+                                // missing: fallback reason
+                                if !val.special_const_p() {
+                                    let recv_shape = val.shape_id_of();
+                                    if recv_shape.is_valid() && !recv_shape.is_too_complex() {
+                                        // load_shape is valid here without guard because type says recv is on-heap.
+                                        let shape = self.load_shape(block, recv);
+                                        self.guard_shape(block, shape, recv_shape, state);
+                                        let is_t_object = unsafe { RB_TYPE_P(val, RUBY_T_OBJECT) };
+                                        let is_embedded = is_t_object && val.embedded_p();
+                                        let refined_recv = self.push_insn(block, Insn::RefineShape { val: recv, shape: recv_shape, is_t_object, is_embedded });
+                                        self.push_insn(block, Insn::GetIvar { self_val: refined_recv, id, ic: ptr::null(), state })
+                                    } else {
+                                        self.push_insn(block, Insn::GetIvar { self_val: recv, id, ic: ptr::null(), state })
+                                    }
                                 } else {
-                                    self.push_insn(block, Insn::GetIvar { self_val: recv, id, ic: std::ptr::null(), state })
+                                    // attr_reader on immediates always return nil
+                                    self.push_insn(block, Insn::Const { val: Const::Value(Qnil) })
                                 }
                             } else {
-                                self.push_insn(block, Insn::GetIvar { self_val: recv, id, ic: std::ptr::null(), state })
+                                // No profile and no static type info
+                                self.push_insn(block, Insn::GetIvar { self_val: recv, id, ic: ptr::null(), state })
                             };
                             self.make_equal_to(insn_id, getivar);
                         } else if let (false, VM_METHOD_TYPE_ATTRSET, &[val]) = (has_block, def_type, args.as_slice()) {

zjit/src/hir/opt_tests.rs

@@ -6905,6 +6905,38 @@ mod hir_opt_tests {
         ");
     }
 
+    #[test]
+    fn test_inline_attr_reader_special_const() {
+        eval("
+            class Integer
+              attr_reader :ivar
+            end
+
+            X = 42
+            def test = X.ivar
+            test
+            test
+        ");
+        assert_snapshot!(hir_string("test"), @"
+        fn test@<compiled>:7:
+        bb0():
+          EntryPoint interpreter
+          v1:BasicObject = LoadSelf
+          Jump bb2(v1)
+        bb1(v4:BasicObject):
+          EntryPoint JIT(0)
+          Jump bb2(v4)
+        bb2(v6:BasicObject):
+          PatchPoint SingleRactorMode
+          PatchPoint StableConstantNames(0x1000, X)
+          v20:Fixnum[42] = Const Value(42)
+          PatchPoint MethodRedefined(Integer@0x1008, ivar@0x1010, cme:0x1018)
+          v22:NilClass = Const Value(nil)
+          CheckInterrupts
+          Return v22
+        ");
+    }
+
     #[test]
     fn test_inline_attr_accessor_constant() {
         eval("