github
diff --git a/‎zjit/src/cruby_methods.rs‎
Lines changed: 112 additions & 0 deletions b/‎zjit/src/cruby_methods.rs‎
Lines changed: 112 additions & 0 deletions
@@ -205,6 +205,7 @@ pub fn init() -> Annotations {
     annotate!(rb_cHash, "empty?", types::BoolExact, no_gc, leaf, elidable);
     annotate!(rb_cNilClass, "nil?", types::TrueClass, no_gc, leaf, elidable);
     annotate!(rb_mKernel, "nil?", types::FalseClass, no_gc, leaf, elidable);
+    annotate!(rb_mKernel, "respond_to?", inline_kernel_respond_to_p);
     annotate!(rb_cBasicObject, "==", types::BoolExact, no_gc, leaf, elidable);
     annotate!(rb_cBasicObject, "!", types::BoolExact, no_gc, leaf, elidable);
     annotate!(rb_cBasicObject, "initialize", inline_basic_object_initialize);
@@ -290,3 +291,114 @@ fn inline_basic_object_initialize(fun: &mut hir::Function, block: hir::BlockId,
     let result = fun.push_insn(block, hir::Insn::Const { val: hir::Const::Value(Qnil) });
     Some(result)
 }
+
+fn inline_kernel_respond_to_p(
+    fun: &mut hir::Function,
+    block: hir::BlockId,
+    recv: hir::InsnId,
+    args: &[hir::InsnId],
+    state: hir::InsnId,
+) -> Option<hir::InsnId> {
+    // Parse arguments: respond_to?(method_name, allow_priv = false)
+    let (method_name, allow_priv) = match *args {
+        [method_name] => (method_name, false),
+        [method_name, arg] => match fun.type_of(arg) {
+            t if t.is_known_truthy() => (method_name, true),
+            t if t.is_known_falsy() => (method_name, false),
+            // Unknown type; bail out
+            _ => return None,
+        },
+        // Unknown args; bail out
+        _ => return None,
+    };
+
+    // Method name must be a static symbol
+    let method_name = fun.type_of(method_name).ruby_object()?;
+    if !method_name.static_sym_p() {
+        return None;
+    }
+
+    // The receiver must have a known class to call `respond_to?` on
+    // TODO: This is technically overly strict. This would also work if all of the
+    // observed objects at this point agree on `respond_to?` and we can add many patchpoints.
+    let recv_class = fun.type_of(recv).runtime_exact_ruby_class()?;
+
+    // Get the method ID and its corresponding callable method entry
+    let mid = unsafe { rb_sym2id(method_name) };
+    let target_cme = unsafe { rb_callable_method_entry_or_negative(recv_class, mid) };
+    assert!(
+        !target_cme.is_null(),
+        "Should never be null, as in that case we will be returned a \"negative CME\""
+    );
+
+    let cme_def_type = unsafe { get_cme_def_type(target_cme) };
+
+    // Cannot inline a refined method, since their refinement depends on lexical scope
+    if cme_def_type == VM_METHOD_TYPE_REFINED {
+        return None;
+    }
+
+    let visibility = match cme_def_type {
+        VM_METHOD_TYPE_UNDEF => METHOD_VISI_UNDEF,
+        _ => unsafe { METHOD_ENTRY_VISI(target_cme) },
+    };
+
+    let result = match (visibility, allow_priv) {
+        // Method undefined; check `respond_to_missing?`
+        (METHOD_VISI_UNDEF, _) => {
+            let respond_to_missing = ID!(respond_to_missing);
+            if unsafe { rb_method_basic_definition_p(recv_class, respond_to_missing) } == 0 {
+                return None; // Custom definition of respond_to_missing?, so cannot inline
+            }
+            let respond_to_missing_cme =
+                unsafe { rb_callable_method_entry(recv_class, respond_to_missing) };
+            // Protect against redefinition of `respond_to_missing?`
+            fun.push_insn(
+                block,
+                hir::Insn::PatchPoint {
+                    invariant: hir::Invariant::NoTracePoint,
+                    state,
+                },
+            );
+            fun.push_insn(
+                block,
+                hir::Insn::PatchPoint {
+                    invariant: hir::Invariant::MethodRedefined {
+                        klass: recv_class,
+                        method: respond_to_missing,
+                        cme: respond_to_missing_cme,
+                    },
+                    state,
+                },
+            );
+            Qfalse
+        }
+        // Private method with allow priv=false, so `respond_to?` returns false
+        (METHOD_VISI_PRIVATE, false) => Qfalse,
+        // Public method or allow_priv=true: check if implemented
+        (METHOD_VISI_PUBLIC, _) | (_, true) => {
+            if cme_def_type == VM_METHOD_TYPE_NOTIMPLEMENTED {
+                // C method with rb_f_notimplement(). `respond_to?` returns false
+                // without consulting `respond_to_missing?`. See also: rb_add_method_cfunc()
+                Qfalse
+            } else {
+                Qtrue
+            }
+        }
+        (_, _) => return None, // not public and include_all not known, can't compile
+    };
+    fun.push_insn(block, hir::Insn::PatchPoint { invariant: hir::Invariant::NoTracePoint, state });
+    fun.push_insn(block, hir::Insn::PatchPoint {
+        invariant: hir::Invariant::MethodRedefined {
+            klass: recv_class,
+            method: mid,
+            cme: target_cme
+        }, state
+    });
+    if recv_class.instance_can_have_singleton_class() {
+        fun.push_insn(block, hir::Insn::PatchPoint {
+            invariant: hir::Invariant::NoSingletonClass { klass: recv_class }, state
+        });
+    }
+    Some(fun.push_insn(block, hir::Insn::Const { val: hir::Const::Value(result) }))
+}