puppet 4.4.1-universal-darwin → 4.4.2-universal-darwin

data/lib/puppet/pops/types/types.rb

@@ -64,7 +64,7 @@ class PAnyType < TypedModelObject
   # @api public
   def assignable?(o, guard = nil)
     case o
-      when Class
+    when Class
       # Safe to call _assignable directly since a Class never is a Unit or Variant
       _assignable?(TypeCalculator.singleton.type(o), guard)
     when PUnitType
@@ -177,11 +177,22 @@ class PAnyType < TypedModelObject
   end
 
   # Returns true if the given argument _o_ is an instance of this type
+  # @param guard [RecursionGuard] guard against recursion. Only used by internal calls
   # @return [Boolean]
-  def instance?(o)
+  # @api public
+  def instance?(o, guard = nil)
     true
   end
 
+  # An object is considered to really be an instance of a type when something other than a
+  # TypeAlias or a Variant responds true to a call to {#instance?}.
+  #
+  # @return [Integer] -1 = is not instance, 0 = recursion detected, 1 = is instance
+  # @api private
+  def really_instance?(o, guard = nil)
+    instance?(o, guard) ? 1 : -1
+  end
+
   def eql?(o)
     self.class == o.class
   end
@@ -238,7 +249,7 @@ class PAnyType < TypedModelObject
   #
   # @api private
   #
-  def tuple_entry_at(tuple_t, from, to, index)
+  def tuple_entry_at(tuple_t, to, index)
     regular = (tuple_t.types.size - 1)
     if index < regular
       tuple_t.types[index]
@@ -336,11 +347,11 @@ end
 # @api public
 #
 class PType < PTypeWithContainedType
-  def instance?(o)
+  def instance?(o, guard = nil)
     if o.is_a?(PAnyType)
-      type.nil? || type.assignable?(o)
+      type.nil? || type.assignable?(o, guard)
     else
-      assignable?(TypeCalculator.infer(o))
+      assignable?(TypeCalculator.infer(o), guard)
     end
   end
 
@@ -398,8 +409,8 @@ class PNotUndefType < PTypeWithContainedType
     super(type.class == PAnyType ? nil : type)
   end
 
-  def instance?(o)
-    !(o.nil? || o == :undef) && (@type.nil? || @type.instance?(o))
+  def instance?(o, guard = nil)
+    !(o.nil? || o == :undef) && (@type.nil? || @type.instance?(o, guard))
   end
 
   def normalize(guard = nil)
@@ -409,7 +420,7 @@ class PNotUndefType < PTypeWithContainedType
     else
       if n.type.is_a?(POptionalType)
         # No point in having an optional in a NotUndef
-        PNotUndef.new(n.type.type).normalize
+        PNotUndefType.new(n.type.type).normalize
       elsif !n.type.assignable?(PUndefType::DEFAULT)
         # THe type is NotUndef anyway, so it can be stripped of
         n.type
@@ -432,7 +443,7 @@ end
 # @api public
 #
 class PUndefType < PAnyType
-  def instance?(o)
+  def instance?(o, guard = nil)
     o.nil? || o == :undef
   end
 
@@ -455,7 +466,7 @@ end
 # @api private
 #
 class PUnitType < PAnyType
-  def instance?(o)
+  def instance?(o, guard = nil)
     true
   end
 
@@ -471,7 +482,7 @@ end
 # @api public
 #
 class PDefaultType < PAnyType
-  def instance?(o)
+  def instance?(o, guard = nil)
     o == :default
   end
 
@@ -493,8 +504,8 @@ class PDataType < PAnyType
     self.class == o.class || o == PVariantType::DATA
   end
 
-  def instance?(o)
-    PVariantType::DATA.instance?(o)
+  def instance?(o, guard = nil)
+    PVariantType::DATA.instance?(o, guard)
   end
 
   DEFAULT = PDataType.new
@@ -521,8 +532,8 @@ end
 #
 class PScalarType < PAnyType
 
-  def instance?(o)
-    assignable?(TypeCalculator.infer(o))
+  def instance?(o, guard = nil)
+    assignable?(TypeCalculator.infer(o), guard)
   end
 
   DEFAULT = PScalarType.new
@@ -609,7 +620,7 @@ class PNumericType < PScalarType
   # @return [Boolean] `true` if this range intersects with the other range
   # @api public
   def intersect?(o)
-    self.class == o.class && !(@to < o.from || o.to < @from)
+    self.class == o.class && !(@to < o.numeric_from || o.numeric_to < @from)
   end
 
   # Returns the lower bound of the numeric range or `nil` if no lower bound is set.
@@ -644,7 +655,7 @@ class PNumericType < PScalarType
     self.class == o.class && @from == o.numeric_from && @to == o.numeric_to
   end
 
-  def instance?(o)
+  def instance?(o, guard = nil)
     o.is_a?(Numeric) && o >= @from && o <= @to
   end
 
@@ -678,7 +689,7 @@ class PIntegerType < PNumericType
     DEFAULT
   end
 
-  def instance?(o)
+  def instance?(o, guard = nil)
     o.is_a?(Integer) && o >= numeric_from && o <= numeric_to
   end
 
@@ -699,8 +710,8 @@ class PIntegerType < PNumericType
   # @api public
   def merge(o)
     if intersect?(o) || adjacent?(o)
-      min = @from <= o.from ? @from : o.from
-      max = @to >= o.to ? @to : o.to
+      min = @from <= o.numeric_from ? @from : o.numeric_from
+      max = @to >= o.numeric_to ? @to : o.numeric_to
       PIntegerType.new(min, max)
     else
       nil
@@ -752,7 +763,7 @@ class PFloatType < PNumericType
     DEFAULT
   end
 
-  def instance?(o)
+  def instance?(o, guard = nil)
     o.is_a?(Float) && o >= numeric_from && o <= numeric_to
   end
 
@@ -783,6 +794,9 @@ class PCollectionType < PAnyType
   def initialize(element_type, size_type = nil)
     @element_type = element_type
     @size_type = size_type
+    if has_empty_range? && !@element_type.is_a?(PUnitType)
+      raise ArgumentError, 'An empty collection may not specify an element type'
+    end
   end
 
   def accept(visitor, guard)
@@ -809,8 +823,8 @@ class PCollectionType < PAnyType
     end
   end
 
-  def instance?(o)
-    assignable?(TypeCalculator.infer(o))
+  def instance?(o, guard = nil)
+    assignable?(TypeCalculator.infer(o), guard)
   end
 
   # Returns an array with from (min) size to (max) size
@@ -818,6 +832,11 @@ class PCollectionType < PAnyType
     (@size_type || DEFAULT_SIZE).range
   end
 
+  def has_empty_range?
+    from, to = size_range
+    from == 0 && to == 0
+  end
+
   def hash
     @element_type.hash ^ @size_type.hash
   end
@@ -867,8 +886,8 @@ class PIterableType < PTypeWithContainedType
     @type
   end
 
-  def instance?(o)
-    if @type.nil? || @type.assignable?(PAnyType::DEFAULT)
+  def instance?(o, guard = nil)
+    if @type.nil? || @type.assignable?(PAnyType::DEFAULT, guard)
       # Any element_type will do
       case o
       when Iterable, String, Hash, Array, Range, PEnumType
@@ -881,7 +900,7 @@ class PIterableType < PTypeWithContainedType
         false
       end
     else
-      assignable?(TypeCalculator.infer(o))
+      assignable?(TypeCalculator.infer(o), guard)
     end
   end
 
@@ -916,8 +935,8 @@ class PIteratorType < PTypeWithContainedType
     @type
   end
 
-  def instance?(o)
-    o.is_a?(Iterable) && (@element_type.nil? || @element_type.assignable?(o.element_type))
+  def instance?(o, guard = nil)
+    o.is_a?(Iterable) && (@type.nil? || @type.assignable?(o.element_type, guard))
   end
 
   def iterable?(guard = nil)
@@ -925,7 +944,7 @@ class PIteratorType < PTypeWithContainedType
   end
 
   def iterable_type(guard = nil)
-    @type.nil? ? PIteratbleType::DEFAULT : PIterableType.new(@element_type)
+    @type.nil? ? PIterableType::DEFAULT : PIterableType.new(@type)
   end
 
   DEFAULT = PIteratorType.new(nil)
@@ -934,7 +953,7 @@ class PIteratorType < PTypeWithContainedType
 
   # @api private
   def _assignable?(o, guard)
-    o.is_a?(PIteratorType) && (@element_type.nil? || @element_type.assignable?(o.element_type, guard))
+    o.is_a?(PIteratorType) && (@type.nil? || @type.assignable?(o.element_type, guard))
   end
 end
 
@@ -973,9 +992,9 @@ class PStringType < PScalarType
     self.class == o.class && @size_type == o.size_type && @values == o.values
   end
 
-  def instance?(o)
+  def instance?(o, guard = nil)
     # true if size compliant
-    if o.is_a?(String) && (@size_type.nil? || @size_type.instance?(o.size))
+    if o.is_a?(String) && (@size_type.nil? || @size_type.instance?(o.size, guard))
       @values.empty? || @values.include?(o)
     else
       false
@@ -1123,7 +1142,7 @@ end
 #
 class PBooleanType < PScalarType
 
-  def instance?(o)
+  def instance?(o, guard = nil)
     o == true || o == false
   end
 
@@ -1180,7 +1199,11 @@ class PStructElement < TypedModelObject
   end
 
   def eql?(o)
-     self.class == o.class && value_type == o.value_type && key_type == o.key_type
+    self == o
+  end
+
+  def ==(o)
+    self.class == o.class && value_type == o.value_type && key_type == o.key_type
   end
 end
 
@@ -1255,7 +1278,7 @@ class PStructType < PAnyType
     @elements
   end
 
-  def instance?(o)
+  def instance?(o, guard = nil)
     return false unless o.is_a?(Hash)
     matched = 0
     @elements.all? do |e|
@@ -1263,10 +1286,10 @@ class PStructType < PAnyType
       v = o[key]
       if v.nil? && !o.include?(key)
         # Entry is missing. Only OK when key is optional
-        e.key_type.assignable?(PUndefType::DEFAULT)
+        e.key_type.assignable?(PUndefType::DEFAULT, guard)
       else
         matched += 1
-        e.value_type.instance?(v)
+        e.value_type.instance?(v, guard)
       end
     end && matched == o.size
   end
@@ -1292,16 +1315,26 @@ class PStructType < PAnyType
     elsif o.is_a?(Types::PHashType)
       required = 0
       required_elements_assignable = elements.all? do |e|
-        if e.key_type.assignable?(PUndefType::DEFAULT)
+        key_type = e.key_type
+        if key_type.assignable?(PUndefType::DEFAULT)
+          # Element is optional so Hash does not need to provide it
           true
         else
           required += 1
-          e.value_type.assignable?(o.element_type, guard)
+          if e.value_type.assignable?(o.element_type, guard)
+            # Hash must have something that is assignable. We don't care about the name or size of the key though
+            # because we have no instance of a hash to compare against.
+            key_type.generalize.assignable?(o.key_type)
+          else
+            false
+          end
         end
       end
       if required_elements_assignable
-        size_o = o.size_type || collection_default_size_t
+        size_o = o.size_type || PCollectionType::DEFAULT_SIZE
         PIntegerType.new(required, elements.size).assignable?(size_o, guard)
+      else
+        false
       end
     else
       false
@@ -1391,14 +1424,14 @@ class PTupleType < PAnyType
     end
   end
 
-  def instance?(o)
+  def instance?(o, guard = nil)
     return false unless o.is_a?(Array)
     # compute the tuple's min/max size, and check if that size matches
     size_t = size_type || PIntegerType.new(*size_range)
 
-    return false unless size_t.instance?(o.size)
+    return false unless size_t.instance?(o.size, guard)
     o.each_with_index do |element, index|
-      return false unless (types[index] || types[-1]).instance?(element)
+      return false unless (types[index] || types[-1]).instance?(element, guard)
     end
     true
   end
@@ -1415,7 +1448,7 @@ class PTupleType < PAnyType
   def size_range
     if @size_type.nil?
       types_size = @types.size
-      [types_size, types_size]
+      types_size == 0 ? [0, Float::INFINITY] : [types_size, types_size]
     else
       @size_type.range
     end
@@ -1452,36 +1485,33 @@ class PTupleType < PAnyType
   # @api private
   def _assignable?(o, guard)
     return true if self == o
+    return false unless o.is_a?(PTupleType) || o.is_a?(PArrayType)
     s_types = types
-    return true if s_types.empty? && (o.is_a?(PArrayType))
     size_s = size_type || PIntegerType.new(*size_range)
 
     if o.is_a?(PTupleType)
       size_o = o.size_type || PIntegerType.new(*o.size_range)
-
-      # not assignable if the number of types in o is outside number of types in t1
-      if size_s.assignable?(size_o, guard)
+      return false unless size_s.assignable?(size_o, guard)
+      unless s_types.empty?
         o_types = o.types
+        return false if o_types.empty?
         o_types.size.times do |index|
           return false unless (s_types[index] || s_types[-1]).assignable?(o_types[index], guard)
         end
-        return true
-      else
-        return false
       end
-    elsif o.is_a?(PArrayType)
-      o_entry = o.element_type
-      # Array of anything can not be assigned (unless tuple is tuple of anything) - this case
-      # was handled at the top of this method.
-      #
-      return false if o_entry.nil?
+    else
       size_o = o.size_type || PCollectionType::DEFAULT_SIZE
       return false unless size_s.assignable?(size_o, guard)
-      [s_types.size, size_o.range[1]].min.times { |index| return false unless (s_types[index] || s_types[-1]).assignable?(o_entry, guard) }
-      true
-    else
-      false
+      unless s_types.empty?
+        o_entry = o.element_type
+        # Array of anything can not be assigned (unless tuple is tuple of anything) - this case
+        # was handled at the top of this method.
+        #
+        return false if o_entry.nil?
+        [s_types.size, size_o.range[1]].min.times { |index| return false unless (s_types[index] || s_types[-1]).assignable?(o_entry, guard) }
+      end
     end
+    true
   end
 end
 
@@ -1531,8 +1561,8 @@ class PCallableType < PAnyType
     end
   end
 
-  def instance?(o)
-    assignable?(TypeCalculator.infer(o))
+  def instance?(o, guard = nil)
+    assignable?(TypeCalculator.infer(o), guard)
   end
 
   # @api private
@@ -1589,7 +1619,9 @@ class PCallableType < PAnyType
 
     # NOTE: these tests are made in reverse as it is calling the callable that is constrained
     # (it's lower bound), not its upper bound
-    return false unless o.param_types.assignable?(@param_types, guard)
+    other_param_types = o.param_types
+
+    return false if other_param_types.nil? ||  !other_param_types.assignable?(@param_types, guard)
     # names are ignored, they are just information
     # Blocks must be compatible
     this_block_t = @block_type || PUndefType::DEFAULT
@@ -1626,12 +1658,12 @@ class PArrayType < PCollectionType
     end
   end
 
-  def instance?(o)
+  def instance?(o, guard = nil)
     return false unless o.is_a?(Array)
     element_t = element_type
-    return false unless element_t.nil? || o.all? {|element| element_t.instance?(element) }
+    return false unless element_t.nil? || o.all? {|element| element_t.instance?(element, guard) }
     size_t = size_type
-    size_t.nil? || size_t.instance?(o.size)
+    size_t.nil? || size_t.instance?(o.size, guard)
   end
 
   DATA = PArrayType.new(PDataType::DEFAULT, DEFAULT_SIZE)
@@ -1664,7 +1696,7 @@ class PArrayType < PCollectionType
       return false if o_regular.size + o_to > max
       # each tuple type must be assignable to the element type
       o_required.times do |index|
-        o_entry = tuple_entry_at(o, o_from, o_to, index)
+        o_entry = tuple_entry_at(o, o_to, index)
         return false unless s_entry.assignable?(o_entry, guard)
       end
       # ... and so must the last, possibly optional (ranged) type
@@ -1685,6 +1717,9 @@ class PHashType < PCollectionType
   def initialize(key_type, value_type, size_type = nil)
     super(value_type, size_type)
     @key_type = key_type
+    if has_empty_range? && !@key_type.is_a?(PUnitType)
+      raise ArgumentError, 'An empty hash may not specify a key type'
+    end
   end
 
   def accept(visitor, guard)
@@ -1720,14 +1755,14 @@ class PHashType < PCollectionType
     super ^ @key_type.hash
   end
 
-  def instance?(o)
+  def instance?(o, guard = nil)
     return false unless o.is_a?(Hash)
     key_t = key_type
     element_t = element_type
-    if (key_t.nil? || o.keys.all? {|key| key_t.instance?(key) }) &&
-        (element_t.nil? || o.values.all? {|value| element_t.instance?(value) })
+    if (key_t.nil? || o.keys.all? {|key| key_t.instance?(key, guard) }) &&
+        (element_t.nil? || o.values.all? {|value| element_t.instance?(value, guard) })
       size_t = size_type
-      size_t.nil? || size_t.instance?(o.size)
+      size_t.nil? || size_t.instance?(o.size, guard)
     else
       false
     end
@@ -1775,8 +1810,8 @@ class PHashType < PCollectionType
         # hash must accept all value types
         # hash must accept the size of the struct
         o_elements = o.elements
-        (size_type || DEFAULT_SIZE).instance?(o_elements.size) &&
-            o_elements.all? {|e| (key_type.nil? || key_type.instance?(e.name)) && (element_type.nil? || element_type.assignable?(e.value_type, guard)) }
+        (size_type || DEFAULT_SIZE).instance?(o_elements.size, guard) &&
+            o_elements.all? {|e| (key_type.nil? || key_type.instance?(e.name, guard)) && (element_type.nil? || element_type.assignable?(e.value_type, guard)) }
       else
         false
     end
@@ -1813,7 +1848,7 @@ class PVariantType < PAnyType
     if self == DEFAULT || self == DATA
       self
     else
-      alter_type_array(@types, :generalize) { |altered| PVariantType.new(mod_types) }
+      alter_type_array(@types, :generalize) { |altered| PVariantType.new(altered) }
     end
   end
 
@@ -1868,9 +1903,17 @@ class PVariantType < PAnyType
     @types.hash
   end
 
-  def instance?(o)
+  def instance?(o, guard = nil)
     # instance of variant if o is instance? of any of variant's types
-    @types.any? { |type| type.instance?(o) }
+    @types.any? { |type| type.instance?(o, guard) }
+  end
+
+  def really_instance?(o, guard = nil)
+    @types.inject(-1) do |memo, type|
+      ri = type.really_instance?(o, guard)
+      memo = ri if ri > memo
+      memo
+    end
   end
 
   def kind_of_callable?(optional = true, guard = nil)
@@ -1993,7 +2036,7 @@ class PVariantType < PAnyType
   # @api private
   def merge_ranges(ranges)
     result = []
-    while !ranges.empty?
+    until ranges.empty?
       unmerged = []
       x = ranges.pop
       result << ranges.inject(x) do |memo, y|
@@ -2029,8 +2072,8 @@ class PRuntimeType < PAnyType
     self.class == o.class && @runtime == o.runtime && @runtime_type_name == o.runtime_type_name
   end
 
-  def instance?(o)
-    assignable?(TypeCalculator.infer(o))
+  def instance?(o, guard = nil)
+    assignable?(TypeCalculator.infer(o), guard)
   end
 
   def iterable?(guard = nil)
@@ -2070,8 +2113,8 @@ class PCatalogEntryType < PAnyType
 
   DEFAULT = PCatalogEntryType.new
 
-  def instance?(o)
-    assignable?(TypeCalculator.infer(o))
+  def instance?(o, guard = nil)
+    assignable?(TypeCalculator.infer(o), guard)
   end
 
   protected
@@ -2158,8 +2201,8 @@ class POptionalType < PTypeWithContainedType
       optional && !@type.nil? && @type.kind_of_callable?(optional, guard)
   end
 
-  def instance?(o)
-    PUndefType::DEFAULT.instance?(o) || (!@type.nil? && @type.instance?(o))
+  def instance?(o, guard = nil)
+    PUndefType::DEFAULT.instance?(o, guard) || (!@type.nil? && @type.instance?(o, guard))
   end
 
   def normalize(guard = nil)
@@ -2207,7 +2250,7 @@ class PTypeReferenceType < PAnyType
     false
   end
 
-  def instance?(o)
+  def instance?(o, guard = nil)
     false
   end
 
@@ -2248,6 +2291,14 @@ class PTypeAliasType < PAnyType
     @self_recursion = false
   end
 
+  def assignable?(o, guard = nil)
+    if @self_recursion
+      guard ||= RecursionGuard.new
+      return true if guard.add_this(self) == RecursionGuard::SELF_RECURSION_IN_BOTH
+    end
+    super(o, guard)
+  end
+
   # Returns the resolved type. The type must have been resolved by a call prior to calls to this
   # method or an error will be raised.
   #
@@ -2266,9 +2317,8 @@ class PTypeAliasType < PAnyType
     guarded_recursion(guard, false) { |g| resolved_type.kind_of_callable?(optional, g) }
   end
 
-  def instance?(o)
-    # No value can ever be recursive so no guard is needed here
-    resolved_type.instance?(o)
+  def instance?(o, guard = nil)
+    really_instance?(o, guard) == 1
   end
 
   def iterable?(guard = nil)
@@ -2283,6 +2333,44 @@ class PTypeAliasType < PAnyType
     @name.hash
   end
 
+  # Acceptor used when checking for self recursion and that a type contains
+  # something other than aliases or type references
+  #
+  # @api private
+  class AssertOtherTypeAcceptor
+    def initialize
+      @other_type_detected = false
+    end
+
+    def visit(type, _)
+      unless type.is_a?(PTypeAliasType) || type.is_a?(PVariantType) || type.is_a?(PTypeReferenceType)
+        @other_type_detected = true
+      end
+    end
+
+    def other_type_detected?
+      @other_type_detected
+    end
+  end
+
+  # Acceptor used when re-checking for self recursion after a self recursion has been detected
+  #
+  # @api private
+  class AssertSelfRecursionStatusAcceptor
+    def visit(type, _)
+      type.set_self_recursion_status if type.is_a?(PTypeAliasType)
+    end
+  end
+
+  def set_self_recursion_status
+    return if @self_recursion || @resolved_type.is_a?(PTypeReferenceType)
+    @self_recursion = true
+    guard = RecursionGuard.new
+    accept(NoopTypeAcceptor::INSTANCE, guard)
+    @self_recursion = guard.recursive_this?(self)
+    when_self_recursion_detected if @self_recursion # no difference
+  end
+
   # Called from the TypeParser once it has found a type using the Loader. The TypeParser will
   # interpret the contained expression and the resolved type is remembered. This method also
   # checks and remembers if the resolve type contains self recursion.
@@ -2303,8 +2391,17 @@ class PTypeAliasType < PAnyType
         # on several methods and this knowledge is used to avoid that for non-recursive
         # types.
         guard = RecursionGuard.new
-        accept(NoopTypeAcceptor::INSTANCE, guard)
+        real_type_asserter = AssertOtherTypeAcceptor.new
+        accept(real_type_asserter, guard)
+        unless real_type_asserter.other_type_detected?
+          raise ArgumentError, "Type alias '#{name}' cannot be resolved to a real type"
+        end
         @self_recursion = guard.recursive_this?(self)
+        # All aliases involved must re-check status since this alias is now resolved
+        if @self_recursion
+          accept(AssertSelfRecursionStatusAcceptor.new, RecursionGuard.new)
+          when_self_recursion_detected
+        end
       rescue
         @resolved_type = nil
         raise
@@ -2328,17 +2425,38 @@ class PTypeAliasType < PAnyType
     @self_recursion
   end
 
+  # Returns the expanded string the form of the alias, e.g. <alias name> = <resolved type>
+  #
+  # @return [String] the expanded form of this alias
+  # @api public
+  def to_s
+    TypeFormatter.singleton.alias_expanded_string(self)
+  end
+
+  # Delegates to resolved type
+  def respond_to_missing?(name, include_private)
+    resolved_type.respond_to?(name, include_private)
+  end
+
+  # Delegates to resolved type
+  def method_missing(name, *arguments, &block)
+    resolved_type.send(name, *arguments, &block)
+  end
+
+  # @api private
+  def really_instance?(o, guard = nil)
+    if @self_recursion
+      guard ||= RecursionGuard.new
+      guard.add_that(o)
+      return 0 if guard.add_this(self) == RecursionGuard::SELF_RECURSION_IN_BOTH
+    end
+    resolved_type.really_instance?(o, guard)
+  end
+
   protected
 
   def _assignable?(o, guard)
-    guard ||= RecursionGuard.new
-    if guard.add_this(self) == RecursionGuard::SELF_RECURSION_IN_BOTH
-      # Recursion detected both in self and other. This means that other is assignable
-      # to self. This point would not have been reached otherwise
-      true
-    else
-      resolved_type.assignable?(o, guard)
-    end
+    resolved_type.assignable?(o, guard)
   end
 
   private
@@ -2352,6 +2470,30 @@ class PTypeAliasType < PAnyType
     end
   end
 
+  def when_self_recursion_detected
+    if @resolved_type.is_a?(PVariantType)
+      # Drop variants that are not real types
+      resolved_types = @resolved_type.types
+      real_types = resolved_types.select do |type|
+        next false if type == self
+        real_type_asserter = AssertOtherTypeAcceptor.new
+        accept(real_type_asserter, RecursionGuard.new)
+        real_type_asserter.other_type_detected?
+      end
+      if real_types.size != resolved_types.size
+        if real_types.size == 1
+          @resolved_type = real_types[0]
+        else
+          @resolved_type = PVariantType.new(real_types)
+        end
+        # Drop self recursion status in case it's not self recursive anymore
+        guard = RecursionGuard.new
+        accept(NoopTypeAcceptor::INSTANCE, guard)
+        @self_recursion = guard.recursive_this?(self)
+      end
+    end
+  end
+
   DEFAULT = PTypeAliasType.new('UnresolvedAlias', nil, PTypeReferenceType::DEFAULT)
 end
 end