Support inference of ClassExact type

Author: st0012

zjit/src/hir.rs

@@ -5731,6 +5731,82 @@ mod opt_tests {
         "#]]);
     }
 
+    #[test]
+    fn normal_class_type_inference() {
+        eval("
+            class C; end
+            def test = C
+            test # Warm the constant cache
+        ");
+        assert_optimized_method_hir("test", expect![[r#"
+            fn test:
+            bb0(v0:BasicObject):
+              PatchPoint SingleRactorMode
+              PatchPoint StableConstantNames(0x1000, C)
+              v7:ClassExact[VALUE(0x1008)] = Const Value(VALUE(0x1008))
+              Return v7
+        "#]]);
+    }
+
+    #[test]
+    fn core_classes_type_inference() {
+        eval("
+            def test = [String, Class, BasicObject]
+            test # Warm the constant cache
+        ");
+        assert_optimized_method_hir("test", expect![[r#"
+            fn test:
+            bb0(v0:BasicObject):
+              PatchPoint SingleRactorMode
+              PatchPoint StableConstantNames(0x1000, String)
+              v13:ClassExact[VALUE(0x1008)] = Const Value(VALUE(0x1008))
+              PatchPoint SingleRactorMode
+              PatchPoint StableConstantNames(0x1010, Class)
+              v16:ClassExact[VALUE(0x1018)] = Const Value(VALUE(0x1018))
+              PatchPoint SingleRactorMode
+              PatchPoint StableConstantNames(0x1020, BasicObject)
+              v19:ClassExact[VALUE(0x1028)] = Const Value(VALUE(0x1028))
+              v9:ArrayExact = NewArray v13, v16, v19
+              Return v9
+        "#]]);
+    }
+
+    #[test]
+    fn normal_module_instances_not_class_exact() {
+        eval("
+            def test = [Enumerable, Kernel]
+            test # Warm the constant cache
+        ");
+        assert_optimized_method_hir("test", expect![[r#"
+            fn test:
+            bb0(v0:BasicObject):
+              PatchPoint SingleRactorMode
+              PatchPoint StableConstantNames(0x1000, Enumerable)
+              v11:BasicObject[VALUE(0x1008)] = Const Value(VALUE(0x1008))
+              PatchPoint SingleRactorMode
+              PatchPoint StableConstantNames(0x1010, Kernel)
+              v14:BasicObject[VALUE(0x1018)] = Const Value(VALUE(0x1018))
+              v7:ArrayExact = NewArray v11, v14
+              Return v7
+        "#]]);
+    }
+
+    #[test]
+    fn core_module_constant_not_class_exact() {
+        eval("
+            def test = Module
+            test # Warm the constant cache
+        ");
+        assert_optimized_method_hir("test", expect![[r#"
+            fn test:
+            bb0(v0:BasicObject):
+              PatchPoint SingleRactorMode
+              PatchPoint StableConstantNames(0x1000, Module)
+              v7:ClassExact[VALUE(0x1008)] = Const Value(VALUE(0x1008))
+              Return v7
+        "#]]);
+    }
+
     #[test]
     fn eliminate_array_size() {
         eval("
@@ -5880,7 +5956,7 @@ mod opt_tests {
             bb0(v0:BasicObject):
               PatchPoint SingleRactorMode
               PatchPoint StableConstantNames(0x1000, Foo::Bar::C)
-              v7:BasicObject[VALUE(0x1008)] = Const Value(VALUE(0x1008))
+              v7:ClassExact[VALUE(0x1008)] = Const Value(VALUE(0x1008))
               Return v7
         "#]]);
     }
@@ -5897,7 +5973,7 @@ mod opt_tests {
             bb0(v0:BasicObject):
               PatchPoint SingleRactorMode
               PatchPoint StableConstantNames(0x1000, C)
-              v20:BasicObject[VALUE(0x1008)] = Const Value(VALUE(0x1008))
+              v20:ClassExact[VALUE(0x1008)] = Const Value(VALUE(0x1008))
               v4:NilClassExact = Const Value(nil)
               v11:BasicObject = SendWithoutBlock v20, :new
               Return v11
@@ -5920,7 +5996,7 @@ mod opt_tests {
             bb0(v0:BasicObject):
               PatchPoint SingleRactorMode
               PatchPoint StableConstantNames(0x1000, C)
-              v22:BasicObject[VALUE(0x1008)] = Const Value(VALUE(0x1008))
+              v22:ClassExact[VALUE(0x1008)] = Const Value(VALUE(0x1008))
               v4:NilClassExact = Const Value(nil)
               v5:Fixnum[1] = Const Value(1)
               v13:BasicObject = SendWithoutBlock v22, :new, v5

zjit/src/hir_type/gen_hir_type.rb

@@ -74,6 +74,7 @@ def base_type name
 base_type "Range"
 base_type "Set"
 base_type "Regexp"
+base_type "Class"
 
 (integer, integer_exact) = base_type "Integer"
 # CRuby partitions Integer into immediate and non-immediate variants.

zjit/src/hir_type/hir_type.inc.rs

@@ -1,6 +1,6 @@
 #![allow(non_upper_case_globals)]
-use crate::cruby::{Qfalse, Qnil, Qtrue, VALUE, RUBY_T_ARRAY, RUBY_T_STRING, RUBY_T_HASH};
-use crate::cruby::{rb_cInteger, rb_cFloat, rb_cArray, rb_cHash, rb_cString, rb_cSymbol, rb_cObject, rb_cTrueClass, rb_cFalseClass, rb_cNilClass, rb_cRange, rb_cSet, rb_cRegexp};
+use crate::cruby::{Qfalse, Qnil, Qtrue, VALUE, RUBY_T_ARRAY, RUBY_T_STRING, RUBY_T_HASH, RUBY_T_CLASS};
+use crate::cruby::{rb_cInteger, rb_cFloat, rb_cArray, rb_cHash, rb_cString, rb_cSymbol, rb_cObject, rb_cTrueClass, rb_cFalseClass, rb_cNilClass, rb_cRange, rb_cSet, rb_cRegexp, rb_cClass, rb_cModule};
 use crate::cruby::ClassRelationship;
 use crate::cruby::get_class_name;
 use crate::cruby::ruby_sym_to_rust_string;
@@ -145,6 +145,30 @@ fn is_range_exact(val: VALUE) -> bool {
     val.class_of() == unsafe { rb_cRange }
 }
 
+fn is_class_exact(val: VALUE) -> bool {
+    // Only consider objects with RUBY_T_CLASS type
+    if val.builtin_type() != RUBY_T_CLASS {
+        return false;
+    }
+
+    // rb_mRubyVMFrozenCore is created with rb_class_new, so it has type RUBY_T_CLASS
+    // but zjit shouldn't treat it as a class
+    if val == unsafe { rb_mRubyVMFrozenCore } {
+        return false;
+    }
+
+    // Instances of Module (but not Class) should not be considered ClassExact
+    // This excludes things like Enumerable, Comparable, etc.
+    // But allows Module itself (which is an instance of Class)
+    if val.class_of() == unsafe { rb_cModule } {
+        return false;
+    }
+
+    // Since we've already excluded modules and special objects,
+    // any remaining RUBY_T_CLASS objects should be classes
+    true
+}
+
 impl Type {
     /// Create a `Type` from the given integer.
     pub const fn fixnum(val: i64) -> Type {
@@ -197,6 +221,9 @@ impl Type {
         else if is_string_exact(val) {
             Type { bits: bits::StringExact, spec: Specialization::Object(val) }
         }
+        else if is_class_exact(val) {
+            Type { bits: bits::ClassExact, spec: Specialization::Object(val) }
+        }
         else if val.class_of() == unsafe { rb_cRegexp } {
             Type { bits: bits::RegexpExact, spec: Specialization::Object(val) }
         }
@@ -288,6 +315,7 @@ impl Type {
 
     fn is_builtin(class: VALUE) -> bool {
         if class == unsafe { rb_cArray } { return true; }
+        if class == unsafe { rb_cClass } { return true; }
         if class == unsafe { rb_cFalseClass } { return true; }
         if class == unsafe { rb_cFloat } { return true; }
         if class == unsafe { rb_cHash } { return true; }
@@ -396,6 +424,7 @@ impl Type {
             return Some(val);
         }
         if self.is_subtype(types::ArrayExact) { return Some(unsafe { rb_cArray }); }
+        if self.is_subtype(types::ClassExact) { return Some(unsafe { rb_cClass }); }
         if self.is_subtype(types::FalseClassExact) { return Some(unsafe { rb_cFalseClass }); }
         if self.is_subtype(types::FloatExact) { return Some(unsafe { rb_cFloat }); }
         if self.is_subtype(types::HashExact) { return Some(unsafe { rb_cHash }); }