puppet 4.8.2-universal-darwin → 4.9.0-universal-darwin

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

@@ -292,6 +292,10 @@ class PAnyType < TypedModelObject
     simple_name
   end
 
+  def create(*args)
+    Loaders.find_loader(nil).load(:function, 'new').call({}, self, *args)
+  end
+
   def new_function(loader)
     self.class.new_function(self, loader)
   end
@@ -550,7 +554,7 @@ class PUndefType < PAnyType
   end
 
   def instance?(o, guard = nil)
-    o.nil? || o == :undef
+    o.nil? || :undef == o
   end
 
   # @api private
@@ -701,6 +705,16 @@ class PEnumType < PScalarType
     block_given? ? r.each(&block) : r
   end
 
+  def generalize
+    # General form of an Enum is a String
+    if @values.empty?
+      PStringType::DEFAULT
+    else
+      range = @values.map(&:size).minmax
+      PStringType.new(PIntegerType.new(range.min, range.max))
+    end
+  end
+
   def iterable?(guard = nil)
     true
   end
@@ -731,8 +745,9 @@ class PEnumType < PScalarType
     end
     case o
       when PStringType
-        # if the set of strings are all found in the set of enums
-        !o.values.empty? && o.values.all? { |s| svalues.any? { |e| e == s }}
+        # if the contained string is found in the set of enums
+        v = o.value
+        !v.nil? && svalues.any? { |e| e == v }
       when PEnumType
         !o.values.empty? && o.values.all? { |s| svalues.any? {|e| e == s }}
       else
@@ -807,8 +822,8 @@ end
 class PNumericType < PAbstractRangeType
   def self.register_ptype(loader, ir)
     create_ptype(loader, ir, 'ScalarType',
-      'from' => { KEY_TYPE => PNumericType::DEFAULT, KEY_VALUE => :default },
-      'to' => { KEY_TYPE => PNumericType::DEFAULT, KEY_VALUE => :default }
+      'from' => { KEY_TYPE => POptionalType.new(PNumericType::DEFAULT), KEY_VALUE => nil },
+      'to' => { KEY_TYPE => POptionalType.new(PNumericType::DEFAULT), KEY_VALUE => nil }
     )
   end
 
@@ -1153,58 +1168,36 @@ end
 class PCollectionType < PAnyType
   def self.register_ptype(loader, ir)
     create_ptype(loader, ir, 'AnyType',
-      'element_type' => {
-        KEY_TYPE => POptionalType.new(PType::DEFAULT),
+      'size_type' => {
+        KEY_TYPE => POptionalType.new(PType.new(PIntegerType::DEFAULT)),
         KEY_VALUE => nil
       }
     )
   end
 
-  attr_reader :element_type, :size_type
+  attr_reader :size_type
 
-  def initialize(element_type, size_type = nil)
+  def initialize(size_type)
     @size_type = size_type
-    if !size_type.nil? && size_type.from == 0 && size_type.to == 0
-      @element_type = PUnitType::DEFAULT
-    else
-      @element_type = element_type
-    end
   end
 
   def accept(visitor, guard)
     super
     @size_type.accept(visitor, guard) unless @size_type.nil?
-    @element_type.accept(visitor, guard) unless @element_type.nil?
   end
 
   def generalize
-    if @element_type.nil?
-      DEFAULT
-    else
-      ge_type = @element_type.generalize
-      @size_type.nil? && @element_type.equal?(ge_type) ? self : self.class.new(ge_type, nil)
-    end
+    DEFAULT
   end
 
   def normalize(guard = nil)
-    if @element_type.nil?
-      DEFAULT
-    else
-      ne_type = @element_type.normalize(guard)
-      @element_type.equal?(ne_type) ? self : self.class.new(ne_type, @size_type)
-    end
+    DEFAULT
   end
 
   def instance?(o, guard = nil)
     assignable?(TypeCalculator.infer(o), guard)
   end
 
-  def resolve(type_parser, loader)
-    relement_type = @element_type
-    relement_type = relement_type.resolve(type_parser, loader) unless relement_type.nil?
-    relement_type.equal?(@element_type) ? self : self.class.new(relement_type, @size_type)
-  end
-
   # Returns an array with from (min) size to (max) size
   def size_range
     (@size_type || DEFAULT_SIZE).range
@@ -1216,19 +1209,15 @@ class PCollectionType < PAnyType
   end
 
   def hash
-    @element_type.hash ^ @size_type.hash
+    @size_type.hash
   end
 
   def iterable?(guard = nil)
     true
   end
 
-  def iterable_type(guard = nil)
-    @element_type.nil? ? PIterableType::DEFAULT : PIterableType.new(@element_type)
-  end
-
   def eql?(o)
-    self.class == o.class && @element_type == o.element_type && @size_type == o.size_type
+    self.class == o.class && @size_type == o.size_type
   end
 
 
@@ -1266,7 +1255,7 @@ end
 class PIterableType < PTypeWithContainedType
   def self.register_ptype(loader, ir)
     create_ptype(loader, ir, 'AnyType',
-      'element_type' => {
+      'type' => {
         KEY_TYPE => POptionalType.new(PType::DEFAULT),
         KEY_VALUE => nil
       }
@@ -1324,7 +1313,7 @@ end
 class PIteratorType < PTypeWithContainedType
   def self.register_ptype(loader, ir)
     create_ptype(loader, ir, 'AnyType',
-      'element_type' => {
+      'type' => {
         KEY_TYPE => POptionalType.new(PType::DEFAULT),
         KEY_VALUE => nil
       }
@@ -1362,27 +1351,27 @@ end
 class PStringType < PScalarType
   def self.register_ptype(loader, ir)
     create_ptype(loader, ir, 'ScalarType',
-      'size_type' => {
-        KEY_TYPE => POptionalType.new(PType.new(PIntegerType::DEFAULT)),
-        KEY_VALUE => nil
-      },
-      'values' => {
-        KEY_TYPE => PArrayType.new(PStringType::DEFAULT),
-        KEY_VALUE => EMPTY_ARRAY
-      }
-    )
+      'size_type_or_value' => {
+        KEY_TYPE => POptionalType.new(PVariantType.new([PStringType::DEFAULT, PType.new(PIntegerType::DEFAULT)])),
+      KEY_VALUE => nil
+    })
   end
 
-  attr_reader :size_type, :values
+  attr_reader :size_type_or_value
 
-  def initialize(size_type, values = EMPTY_ARRAY)
-    @size_type = size_type
-    @values = values.sort.freeze
+  def initialize(size_type_or_value, deprecated_multi_args = EMPTY_ARRAY)
+    unless deprecated_multi_args.empty?
+      if Puppet[:strict] != :off
+        Puppet.warn_once(:deprecatation, "PStringType#initialize_multi_args", "Passing more than one argument to PStringType#initialize is deprecated")
+      end
+      size_type_or_value = deprecated_multi_args[0]
+    end
+    @size_type_or_value = size_type_or_value
   end
 
   def accept(visitor, guard)
     super
-    @size_type.accept(visitor, guard) unless @size_type.nil?
+    @size_type_or_value.accept(visitor, guard) if @size_type_or_value.is_a?(PIntegerType)
   end
 
   def generalize
@@ -1390,7 +1379,7 @@ class PStringType < PScalarType
   end
 
   def hash
-    @size_type.hash ^ @values.hash
+    @size_type_or_value.hash
   end
 
   def iterable?(guard = nil)
@@ -1402,18 +1391,54 @@ class PStringType < PScalarType
   end
 
   def eql?(o)
-    self.class == o.class && @size_type == o.size_type && @values == o.values
+    self.class == o.class && @size_type_or_value == o.size_type_or_value
   end
 
   def instance?(o, guard = nil)
     # true if size compliant
-    if o.is_a?(String) && (@size_type.nil? || @size_type.instance?(o.size, guard))
-      @values.empty? || @values.include?(o)
+    if o.is_a?(String)
+      if @size_type_or_value.is_a?(PIntegerType)
+        @size_type_or_value.instance?(o.size, guard)
+      else
+        @size_type_or_value.nil? ? true : o == value
+      end
     else
       false
     end
   end
 
+  def value
+    @size_type_or_value.is_a?(PIntegerType) ? nil : @size_type_or_value
+  end
+
+  # @deprecated
+  # @api private
+  def values
+    if Puppet[:strict] != :off
+      Puppet.warn_once(:deprecatation, "PStringType#values", "Method PStringType#values is deprecated. Use #value instead")
+    end
+    @value.is_a?(String) ? [@value] : EMPTY_ARRAY
+  end
+
+  def size_type
+    @size_type_or_value.is_a?(PIntegerType) ? @size_type_or_value : nil
+  end
+
+  def size_type
+    @size_type_or_value.is_a?(PIntegerType) ? @size_type_or_value : nil
+  end
+
+  def derived_size_type
+    if @size_type_or_value.is_a?(PIntegerType)
+      @size_type_or_value
+    elsif @size_type_or_value.is_a?(String)
+      sz = @size_type_or_value.size
+      PIntegerType.new(sz, sz)
+    else
+      PCollectionType::DEFAULT_SIZE
+    end
+  end
+
   def self.new_function(_, loader)
     @new_function ||= Puppet::Functions.create_loaded_function(:new_string, loader) do
       local_types do
@@ -1450,44 +1475,48 @@ class PStringType < PScalarType
 
   # @api private
   def _assignable?(o, guard)
-    if values.empty?
+    if @size_type_or_value.is_a?(PIntegerType)
       # A general string is assignable by any other string or pattern restricted string
       # if the string has a size constraint it does not match since there is no reasonable way
       # to compute the min/max length a pattern will match. For enum, it is possible to test that
       # each enumerator value is within range
       case o
-        when PStringType
-          # true if size compliant
-          (@size_type || PCollectionType::DEFAULT_SIZE).assignable?(
-            o.size_type || PCollectionType::DEFAULT_SIZE, guard)
-
-        when PPatternType
-          # true if size constraint is at least 0 to +Infinity (which is the same as the default)
-          @size_type.nil? || @size_type.assignable?(PCollectionType::DEFAULT_SIZE, guard)
-
-        when PEnumType
-          if o.values.empty?
-            # enum represents all enums, and thus all strings, a sized constrained string can thus not
-            # be assigned any enum (unless it is max size).
-            @size_type.nil? || @size_type.assignable?(PCollectionType::DEFAULT_SIZE, guard)
-          else
-            # true if all enum values are within range
-            orange = o.values.map(&:size).minmax
-            srange = (@size_type || PCollectionType::DEFAULT_SIZE).range
-            # If o min and max are within the range of t
-            srange[0] <= orange[0] && srange[1] >= orange[1]
-          end
+      when PStringType
+        @size_type_or_value.assignable?(o.derived_size_type, guard)
+
+      when PEnumType
+        if o.values.empty?
+          # enum represents all enums, and thus all strings, a sized constrained string can thus not
+          # be assigned any enum (unless it is max size).
+          @size_type_or_value.assignable?(PCollectionType::DEFAULT_SIZE, guard)
         else
-          # no other type matches string
-          false
+          # true if all enum values are within range
+          orange = o.values.map(&:size).minmax
+          srange = @size_type_or_value.range
+          # If o min and max are within the range of t
+          srange[0] <= orange[0] && srange[1] >= orange[1]
+        end
+
+      when PPatternType
+        # true if size constraint is at least 0 to +Infinity (which is the same as the default)
+        @size_type_or_value.assignable?(PCollectionType::DEFAULT_SIZE, guard)
+      else
+        # no other type matches string
+        false
       end
-    elsif o.is_a?(PStringType)
-      # A specific string acts as a set of strings - must have exactly the same strings
-      # In this case, size does not matter since the definition is very precise anyway
-      values == o.values
     else
-      # All others are false, since no other type describes the same set of specific strings
-      false
+      case o
+      when PStringType
+        # Must match exactly when value is a string
+        @size_type_or_value.nil? || @size_type_or_value == o.size_type_or_value
+      when PEnumType
+        @size_type_or_value.nil? ? true : o.values.size == 1 && @size_type_or_value == o.values[0]
+      when PPatternType
+        @size_type_or_value.nil?
+      else
+        # All others are false, since no other type describes the same set of specific strings
+        false
+      end
     end
   end
 end
@@ -1574,16 +1603,28 @@ class PPatternType < PScalarType
   def _assignable?(o, guard)
     return true if self == o
     case o
-    when PStringType, PEnumType
+    when PStringType
+      v = o.value
+      if v.nil?
+        # Strings cannot all match a pattern, but if there is no pattern it is ok
+        # (There should really always be a pattern, but better safe than sorry).
+        @patterns.empty?
+      else
+        # the string in String type must match one of the patterns in Pattern type,
+        # or Pattern represents all Patterns == all Strings
+        regexps = @patterns.map { |p| p.regexp }
+        regexps.empty? || regexps.any? { |re| re.match(v) }
+      end
+    when PEnumType
       if o.values.empty?
-        # Strings / Enums (unknown which ones) cannot all match a pattern, but if there is no pattern it is ok
+        # Enums (unknown which ones) cannot all match a pattern, but if there is no pattern it is ok
         # (There should really always be a pattern, but better safe than sorry).
         @patterns.empty?
       else
         # all strings in String/Enum type must match one of the patterns in Pattern type,
         # or Pattern represents all Patterns == all Strings
         regexps = @patterns.map { |p| p.regexp }
-        regexps.empty? || o.values.all? { |v| regexps.any? {|re| re.match(v) } }
+        regexps.empty? || o.values.all? { |s| regexps.any? {|re| re.match(s) } }
       end
     when PPatternType
       @patterns.empty?
@@ -1668,7 +1709,7 @@ class PStructElement < TypedModelObject
   def name
     k = key_type
     k = k.optional_type if k.is_a?(POptionalType)
-    k.values[0]
+    k.value
   end
 
   def initialize(key_type, value_type)
@@ -1841,7 +1882,7 @@ class PStructType < PAnyType
           true
         else
           required += 1
-          if e.value_type.assignable?(o.element_type, guard)
+          if e.value_type.assignable?(o.value_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)
@@ -2040,7 +2081,7 @@ class PTupleType < PAnyType
       return false unless size_s.assignable?(size_o, guard)
       unless s_types.empty?
         o_types = o.types
-        return false if o_types.empty?
+        return size_s.numeric_from == 0 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
@@ -2073,6 +2114,10 @@ class PCallableType < PAnyType
       'block_type' => {
         KEY_TYPE => POptionalType.new(PCallableType::DEFAULT),
         KEY_VALUE => nil
+      },
+      'return_type' => {
+        KEY_TYPE => POptionalType.new(PType::DEFAULT),
+        KEY_VALUE => PAnyType::DEFAULT
       }
     )
   end
@@ -2212,13 +2257,29 @@ class PArrayType < PCollectionType
 
   def self.register_ptype(loader, ir)
     create_ptype(loader, ir, 'CollectionType',
-      'size_type' => {
-        KEY_TYPE => POptionalType.new(PType.new(PIntegerType::DEFAULT)),
+      'element_type' => {
+        KEY_TYPE => POptionalType.new(PType::DEFAULT),
         KEY_VALUE => nil
       }
     )
   end
 
+  attr_reader :element_type
+
+  def initialize(element_type, size_type = nil)
+    super(size_type)
+    if !size_type.nil? && size_type.from == 0 && size_type.to == 0
+      @element_type = PUnitType::DEFAULT
+    else
+      @element_type = element_type
+    end
+  end
+
+  def accept(visitor, guard)
+    super
+    @element_type.accept(visitor, guard) unless @element_type.nil?
+  end
+
   # @api private
   def callable_args?(callable, guard = nil)
     param_t = callable.param_types
@@ -2230,19 +2291,39 @@ class PArrayType < PCollectionType
   def generalize
     if self == DATA
       self
+    elsif @element_type.nil?
+      DEFAULT
     else
-      super
+      ge_type = @element_type.generalize
+      @size_type.nil? && @element_type.equal?(ge_type) ? self : self.class.new(ge_type, nil)
     end
   end
 
+  def eql?(o)
+    super && @element_type == o.element_type
+  end
+
+  def hash
+    super ^ @element_type.hash
+  end
+
   def normalize(guard = nil)
     if self == DATA
       self
+    elsif @element_type.nil?
+      DEFAULT
     else
-      super
+      ne_type = @element_type.normalize(guard)
+      @element_type.equal?(ne_type) ? self : self.class.new(ne_type, @size_type)
     end
   end
 
+  def resolve(type_parser, loader)
+    relement_type = @element_type
+    relement_type = relement_type.resolve(type_parser, loader) unless relement_type.nil?
+    relement_type.equal?(@element_type) ? self : self.class.new(relement_type, @size_type)
+  end
+
   def instance?(o, guard = nil)
     return false unless o.is_a?(Array)
     element_t = element_type
@@ -2251,6 +2332,10 @@ class PArrayType < PCollectionType
     size_t.nil? || size_t.instance?(o.size, guard)
   end
 
+  def iterable_type(guard = nil)
+    @element_type.nil? ? PIterableType::DEFAULT : PIterableType.new(@element_type)
+  end
+
   # Returns a new function that produces an Array
   #
   def self.new_function(_, loader)
@@ -2335,33 +2420,38 @@ class PHashType < PCollectionType
         KEY_TYPE => POptionalType.new(PType::DEFAULT),
         KEY_VALUE => nil
       },
-      'element_type' => {
+      'value_type' => {
         KEY_TYPE => POptionalType.new(PType::DEFAULT),
         KEY_VALUE => nil,
-        KEY_OVERRIDE => true
-      },
-      'size_type' => {
-        KEY_TYPE => POptionalType.new(PType.new(PIntegerType::DEFAULT)),
-        KEY_VALUE => nil
       }
     )
   end
 
-  attr_accessor :key_type
-  alias value_type element_type
+  attr_accessor :key_type, :value_type
 
   def initialize(key_type, value_type, size_type = nil)
-    super(value_type, size_type)
+    super(size_type)
     if !size_type.nil? && size_type.from == 0 && size_type.to == 0
       @key_type = PUnitType::DEFAULT
+      @value_type = PUnitType::DEFAULT
     else
       @key_type = key_type
+      @value_type = value_type
     end
   end
 
   def accept(visitor, guard)
     super
     @key_type.accept(visitor, guard) unless @key_type.nil?
+    @value_type.accept(visitor, guard) unless @value_type.nil?
+  end
+
+  def element_type
+    if Puppet[:strict] != :off
+      Puppet.warn_once(:deprecation, 'Puppet::Pops::Types::PHashType#element_type',
+        'Puppet::Pops::Types::PHashType#element_type is deprecated, use #value_type instead')
+    end
+    @value_type
   end
 
   def generalize
@@ -2370,9 +2460,9 @@ class PHashType < PCollectionType
     else
       key_t = @key_type
       key_t = key_t.generalize unless key_t.nil?
-      value_t = @element_type
+      value_t = @value_type
       value_t = value_t.generalize unless value_t.nil?
-      @size_type.nil? && @key_type.equal?(key_t) && @element_type.equal?(value_t) ? self : PHashType.new(key_t, value_t, nil)
+      @size_type.nil? && @key_type.equal?(key_t) && @value_type.equal?(value_t) ? self : PHashType.new(key_t, value_t, nil)
     end
   end
 
@@ -2382,22 +2472,22 @@ class PHashType < PCollectionType
     else
       key_t = @key_type
       key_t = key_t.normalize(guard) unless key_t.nil?
-      value_t = @element_type
+      value_t = @value_type
       value_t = value_t.normalize(guard) unless value_t.nil?
-      @size_type.nil? && @key_type.equal?(key_t) && @element_type.equal?(value_t) ? self : PHashType.new(key_t, value_t, nil)
+      @size_type.nil? && @key_type.equal?(key_t) && @value_type.equal?(value_t) ? self : PHashType.new(key_t, value_t, nil)
     end
   end
 
   def hash
-    super ^ @key_type.hash
+    super ^ @key_type.hash ^ @value_type.hash
   end
 
   def instance?(o, guard = nil)
     return false unless o.is_a?(Hash)
     key_t = key_type
-    element_t = element_type
+    value_t = value_type
     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) })
+        (value_t.nil? || o.values.all? {|value| value_t.instance?(value, guard) })
       size_t = size_type
       size_t.nil? || size_t.instance?(o.size, guard)
     else
@@ -2413,12 +2503,12 @@ class PHashType < PCollectionType
     if self == DEFAULT || self == EMPTY
       PIterableType.new(DEFAULT_KEY_PAIR_TUPLE)
     else
-      PIterableType.new(PTupleType.new([@key_type, @element_type], KEY_PAIR_TUPLE_SIZE))
+      PIterableType.new(PTupleType.new([@key_type, @value_type], KEY_PAIR_TUPLE_SIZE))
     end
   end
 
   def eql?(o)
-    super && @key_type == o.key_type
+    super && @key_type == o.key_type && @value_type == o.value_type
   end
 
   def is_the_empty_hash?
@@ -2428,9 +2518,9 @@ class PHashType < PCollectionType
   def resolve(type_parser, loader)
     rkey_type = @key_type
     rkey_type = rkey_type.resolve(type_parser, loader) unless rkey_type.nil?
-    rvalue_type = @element_type
+    rvalue_type = @value_type
     rvalue_type = rvalue_type.resolve(type_parser, loader) unless rvalue_type.nil?
-    rkey_type.equal?(@key_type) && rvalue_type.equal?(@element_type) ? self : self.class.new(rkey_type, rvalue_type, @size_type)
+    rkey_type.equal?(@key_type) && rvalue_type.equal?(@value_type) ? self : self.class.new(rkey_type, rvalue_type, @size_type)
   end
 
   # Returns a new function that produces a  Hash
@@ -2495,7 +2585,7 @@ class PHashType < PCollectionType
       when PHashType
         size_s = size_type
         return true if (size_s.nil? || size_s.from == 0) && o.is_the_empty_hash?
-        return false unless (key_type.nil? || key_type.assignable?(o.key_type, guard)) && (element_type.nil? || element_type.assignable?(o.element_type, guard))
+        return false unless (key_type.nil? || key_type.assignable?(o.key_type, guard)) && (value_type.nil? || value_type.assignable?(o.value_type, guard))
         super
       when PStructType
         # hash must accept String as key type
@@ -2503,7 +2593,7 @@ class PHashType < PCollectionType
         # hash must accept the size of the struct
         o_elements = o.elements
         (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)) }
+            o_elements.all? {|e| (key_type.nil? || key_type.instance?(e.name, guard)) && (value_type.nil? || value_type.assignable?(e.value_type, guard)) }
       else
         false
     end
@@ -2700,11 +2790,11 @@ class PVariantType < PAnyType
   # @api private
   def merge_enums(array)
     if array.size > 1
-      parts = array.partition {|t| t.is_a?(PEnumType) || t.is_a?(PStringType) && !t.values.empty? }
+      parts = array.partition {|t| t.is_a?(PEnumType) && !t.values.empty? || t.is_a?(PStringType) && !t.value.nil? }
       enums = parts[0]
       if enums.size > 1
         others = parts[1]
-        others <<  PEnumType.new(enums.map { |enum| enum.values }.flatten.uniq)
+        others <<  PEnumType.new(enums.map { |enum| enum.is_a?(PStringType) ? enum.value : enum.values }.flatten.uniq)
         array = others
       end
     end
@@ -2883,7 +2973,7 @@ end
 class POptionalType < PTypeWithContainedType
 
   def self.register_ptype(loader, ir)
-    create_ptype(loader, ir, 'CatalogEntryType',
+    create_ptype(loader, ir, 'AnyType',
       'type' => {
         KEY_TYPE => POptionalType.new(PType::DEFAULT),
         KEY_VALUE => nil
@@ -3017,9 +3107,10 @@ class PTypeAliasType < PAnyType
   def assignable?(o, guard = nil)
     if @self_recursion
       guard ||= RecursionGuard.new
-      return true if guard.add_this(self) == RecursionGuard::SELF_RECURSION_IN_BOTH
+      guard.with_this(self) { |state| state == RecursionGuard::SELF_RECURSION_IN_BOTH ? true : super(o, guard) }
+    else
+      super(o, guard)
     end
-    super(o, guard)
   end
 
   # Returns the resolved type. The type must have been resolved by a call prior to calls to this
@@ -3070,7 +3161,7 @@ class PTypeAliasType < PAnyType
     end
 
     def visit(type, _)
-      unless type.is_a?(PTypeAliasType) || type.is_a?(PVariantType) || type.is_a?(PTypeReferenceType)
+      unless type.is_a?(PTypeAliasType) || type.is_a?(PVariantType)
         @other_type_detected = true
       end
     end
@@ -3183,10 +3274,12 @@ class PTypeAliasType < PAnyType
   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
+      guard.with_that(o) do
+        guard.with_this(self) { |state| state == RecursionGuard::SELF_RECURSION_IN_BOTH ? 0 : resolved_type.really_instance?(o, guard) }
+      end
+    else
+      resolved_type.really_instance?(o, guard)
     end
-    resolved_type.really_instance?(o, guard)
   end
 
   # @return `nil` to prevent serialization of the type_expr used when first initializing this instance
@@ -3210,7 +3303,7 @@ class PTypeAliasType < PAnyType
   def guarded_recursion(guard, dflt)
     if @self_recursion
       guard ||= RecursionGuard.new
-      (guard.add_this(self) & RecursionGuard::SELF_RECURSION_IN_THIS) == 0 ? yield(guard) : dflt
+      guard.with_this(self) { |state| (state & RecursionGuard::SELF_RECURSION_IN_THIS) == 0 ? yield(guard) : dflt }
     else
       yield(guard)
     end
@@ -3223,7 +3316,7 @@ class PTypeAliasType < PAnyType
       real_types = resolved_types.select do |type|
         next false if type == self
         real_type_asserter = AssertOtherTypeAcceptor.new
-        accept(real_type_asserter, RecursionGuard.new)
+        type.accept(real_type_asserter, RecursionGuard.new)
         real_type_asserter.other_type_detected?
       end
       if real_types.size != resolved_types.size