lib/tapioca/runtime/reflection.rb in tapioca-0.11.6 vs lib/tapioca/runtime/reflection.rb in tapioca-0.11.7

@@ -50,11 +50,11 @@
         namespace.const_get(symbol, inherit)
       rescue NameError, LoadError, RuntimeError, ArgumentError, TypeError
         UNDEFINED_CONSTANT
       end
 
-      sig { params(object: BasicObject).returns(Class).checked(:never) }
+      sig { params(object: BasicObject).returns(T::Class[T.anything]).checked(:never) }
       def class_of(object)
         CLASS_METHOD.bind_call(object)
       end
 
       sig { params(constant: Module).returns(T::Array[Symbol]) }
@@ -66,21 +66,21 @@
       def name_of(constant)
         name = NAME_METHOD.bind_call(constant)
         name&.start_with?("#<") ? nil : name
       end
 
-      sig { params(constant: Module).returns(Class) }
+      sig { params(constant: Module).returns(T::Class[T.anything]) }
       def singleton_class_of(constant)
         SINGLETON_CLASS_METHOD.bind_call(constant)
       end
 
       sig { params(constant: Module).returns(T::Array[Module]) }
       def ancestors_of(constant)
         ANCESTORS_METHOD.bind_call(constant)
       end
 
-      sig { params(constant: Class).returns(T.nilable(Class)) }
+      sig { params(constant: T::Class[T.anything]).returns(T.nilable(T::Class[T.anything])) }
       def superclass_of(constant)
         SUPERCLASS_METHOD.bind_call(constant)
       end
 
       sig { params(object: BasicObject).returns(Integer).checked(:never) }
@@ -111,11 +111,11 @@
       sig { params(constant: Module).returns(T::Array[Module]) }
       def inherited_ancestors_of(constant)
         if Class === constant
           ancestors_of(superclass_of(constant) || Object)
         else
-          Module.ancestors
+          Module.new.ancestors
         end
       end
 
       sig { params(constant: Module).returns(T.nilable(String)) }
       def qualified_name_of(constant)
@@ -159,11 +159,11 @@
       #
       #   class D < C; end
       #   descendants_of(C) # => [B, A, D]
       sig do
         type_parameters(:U)
-          .params(klass: T.all(Class, T.type_parameter(:U)))
+          .params(klass: T.all(T::Class[T.anything], T.type_parameter(:U)))
           .returns(T::Array[T.type_parameter(:U)])
       end
       def descendants_of(klass)
         result = ObjectSpace.each_object(klass.singleton_class).reject do |k|
           T.cast(k, Module).singleton_class? || T.unsafe(k) == klass
@@ -188,9 +188,25 @@
       sig { params(constant: Module).returns(T::Set[String]) }
       def file_candidates_for(constant)
         relevant_methods_for(constant).filter_map do |method|
           method.source_location&.first
         end.to_set
+      end
+
+      sig { params(constant: Module).returns(T.untyped) }
+      def abstract_type_of(constant)
+        T::Private::Abstract::Data.get(constant, :abstract_type) ||
+          T::Private::Abstract::Data.get(singleton_class_of(constant), :abstract_type)
+      end
+
+      sig { params(constant: Module).returns(T::Boolean) }
+      def final_module?(constant)
+        T::Private::Final.final_module?(constant)
+      end
+
+      sig { params(constant: Module).returns(T::Boolean) }
+      def sealed_module?(constant)
+        T::Private::Sealed.sealed_module?(constant)
       end
 
       private
 
       sig { params(constant: Module).returns(T::Array[UnboundMethod]) }