module T::Utils::Nilable

def self.get_type_info(prop_type) 

def self.get_type_info(prop_type)
  if prop_type.is_a?(T::Types::Union)
    non_nilable_type = T::Utils.unwrap_nilable(prop_type)
    if non_nilable_type && non_nilable_type.is_a?(T::Types::Simple)
      non_nilable_type = non_nilable_type.raw_type
    end
    TypeInfo.new(true, non_nilable_type)
  else
    TypeInfo.new(false, nil)
  end
end

def self.get_underlying_type(prop_type)

- if the type is T.nilable(A), the function returns A
- if the type is A, the function returns A
Get the underlying type inside prop_type: 
def self.get_underlying_type(prop_type)
  type_info = get_type_info(prop_type)
  if type_info.is_union_type
    type_info.non_nilable_type || prop_type
  elsif prop_type.is_a?(T::Types::Simple)
    prop_type.raw_type
  else
    prop_type
  end
end

def self.get_underlying_type_object(prop_type)

is preserved.
The difference between this function and the above function is that the Sorbet type, like T::Types::Simple 
def self.get_underlying_type_object(prop_type)
  T::Utils.unwrap_nilable(prop_type) || prop_type
end

def self.is_union_with_nilclass(prop_type) 

def self.is_union_with_nilclass(prop_type)
  case prop_type
  when T::Types::Union
    prop_type.types.include?(NIL_TYPE)
  else
    false
  end
end