puppet 4.4.0 → 4.5.0

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

@@ -4,6 +4,7 @@ require_relative 'recursion_guard'
 require_relative 'type_acceptor'
 require_relative 'type_asserter'
 require_relative 'type_assertion_error'
+require_relative 'type_conversion_error'
 require_relative 'type_formatter'
 require_relative 'type_calculator'
 require_relative 'type_factory'
@@ -11,10 +12,10 @@ require_relative 'type_parser'
 require_relative 'class_loader'
 require_relative 'type_mismatch_describer'
 
-require 'rgen/metamodel_builder'
-
 module Puppet::Pops
 module Types
+
+EMPTY_HASH = {}.freeze
 # The Types model is a model of Puppet Language types.
 #
 # The exact relationship between types is not visible in this model wrt. the PDataType which is an abstraction
@@ -64,7 +65,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
@@ -115,6 +116,14 @@ class PAnyType < TypedModelObject
     false
   end
 
+  # Called from the `PTypeAliasType` when it detects self recursion. The default is to do nothing
+  # but some self recursive constructs are illegal such as when a `PObjectType` somehow inherits itself
+  # @param originator [PTypeAliasType] the starting point for the check
+  # @raise Puppet::Error if an illegal self recursion is detected
+  # @api private
+  def check_self_recursion(originator)
+  end
+
   # Generalizes value specific types. Types that are not value specific will return `self` otherwise
   # the generalized type is returned.
   #
@@ -136,6 +145,18 @@ class PAnyType < TypedModelObject
     self
   end
 
+  # Called from the TypeParser once it has found a type using the Loader to enable that this type can
+  # resolve internal type expressions using a loader. Presently, this method is a no-op for all types
+  # except the {{PTypeAliasType}}.
+  #
+  # @param type_parser [TypeParser] type parser
+  # @param loader [Loader::Loader] loader to use
+  # @return [PTypeAliasType] the receiver of the call, i.e. `self`
+  # @api private
+  def resolve(type_parser, loader)
+    self
+  end
+
   # Responds `true` for all callables, variants of callables and unless _optional_ is
   # false, all optional callables.
   # @param optional [Boolean]
@@ -177,11 +198,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
@@ -206,6 +238,29 @@ class PAnyType < TypedModelObject
     TypeFormatter.string(self)
   end
 
+  # Returns the name of the type, without parameters
+  # @return [String] the name of the type
+  # @api public
+  def name
+    simple_name
+  end
+
+  def new_function(loader)
+    self.class.new_function(self, loader)
+  end
+
+  # This default implementation of of a new_function raises an Argument Error.
+  # Types for which creating a new instance is supported, should create and return
+  # a Puppet Function class by using Puppet:Loaders.create_loaded_function(:new, loader)
+  # and return that result.
+  #
+  # @raises ArgumentError
+  #
+  def self.new_function(instance, loader)
+    raise ArgumentError.new("Creation of new instance of type '#{instance.to_s}' is not supported")
+  end
+
+
   # The default instance of this type. Each type in the type system has this constant
   # declared.
   #
@@ -218,19 +273,6 @@ class PAnyType < TypedModelObject
     o.is_a?(PAnyType)
   end
 
-  NAME_SEGMENT_SEPARATOR = '::'.freeze
-
-  # @api private
-  def class_from_string(str)
-    begin
-      str.split(NAME_SEGMENT_SEPARATOR).reduce(Object) do |memo, name_segment|
-        memo.const_get(name_segment)
-      end
-    rescue NameError
-      return nil
-    end
-  end
-
   # Produces the tuple entry at the given index given a tuple type, its from/to constraints on the last
   # type, and an index.
   # Produces nil if the index is out of bounds
@@ -238,7 +280,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]
@@ -324,7 +366,7 @@ class PTypeWithContainedType < PAnyType
   end
 
   def hash
-    self.class.hash * 31 * @type.hash
+    self.class.hash ^ @type.hash
   end
 
   def eql?(o)
@@ -336,11 +378,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 +440,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 +451,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
@@ -419,6 +461,15 @@ class PNotUndefType < PTypeWithContainedType
     end
   end
 
+  def new_function(loader)
+    # If only NotUndef, then use Unit's null converter
+    if type.nil?
+      PUnitType.new_function(self.class, loader)
+    else
+      type.new_function(loader)
+    end
+  end
+
   DEFAULT = PNotUndefType.new
 
   protected
@@ -432,7 +483,7 @@ end
 # @api public
 #
 class PUndefType < PAnyType
-  def instance?(o)
+  def instance?(o, guard = nil)
     o.nil? || o == :undef
   end
 
@@ -455,10 +506,23 @@ end
 # @api private
 #
 class PUnitType < PAnyType
-  def instance?(o)
+  def instance?(o, guard = nil)
     true
   end
 
+  # A "null" implementation - that simply returns the given argument
+  def self.new_function(_, loader)
+    @new_function ||= Puppet::Functions.create_loaded_function(:new_unit, loader) do
+      dispatch :from_args do
+        param          'Any',  :from
+      end
+
+      def from_args(from)
+        from
+      end
+    end
+  end
+
   DEFAULT = PUnitType.new
 
   protected
@@ -471,7 +535,7 @@ end
 # @api public
 #
 class PDefaultType < PAnyType
-  def instance?(o)
+  def instance?(o, guard = nil)
     o == :default
   end
 
@@ -493,8 +557,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 +585,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 +673,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.
@@ -637,14 +701,14 @@ class PNumericType < PScalarType
   end
 
   def hash
-    @from.hash * 31 + @to.hash
+    @from.hash ^ @to.hash
   end
 
   def eql?(o)
     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
 
@@ -652,6 +716,56 @@ class PNumericType < PScalarType
     @from == -Float::INFINITY && @to == Float::INFINITY
   end
 
+  def self.new_function(_, loader)
+    @new_function ||= Puppet::Functions.create_loaded_function(:new_numeric, loader) do
+      local_types do
+        type 'Convertible = Variant[Undef, Integer, Float, Boolean, String]'
+        type 'NamedArgs   = Struct[{from => Convertible}]'
+      end
+
+      dispatch :from_args do
+        param          'Convertible',  :from
+      end
+
+      dispatch :from_hash do
+        param          'NamedArgs',  :hash_args
+      end
+      def from_args(from)
+        case from
+        when NilClass
+          throw :undefined_value
+        when Float
+          from
+        when Integer
+          from
+        when TrueClass
+          1
+        when FalseClass
+          0
+        when String
+          begin
+            if from[0] == '0' && (from[1].downcase == 'b' || from[1].downcase == 'x')
+              Integer(from)
+            else
+              Puppet::Pops::Utils.to_n(from)
+            end
+          rescue TypeError => e
+            raise TypeConversionError.new(e.message)
+          rescue ArgumentError => e
+            raise TypeConversionError.new(e.message)
+          end
+        else
+          t = Puppet::Pops::Types::TypeCalculator.singleton.infer(from).generalize
+          raise TypeConversionError.new("Value of type '#{t}' cannot be converted to Numeric")
+        end
+      end
+
+      def from_hash(args_hash)
+        from_args(args_hash['from'])
+      end
+    end
+  end
+
   DEFAULT = PNumericType.new(-Float::INFINITY)
 
   protected
@@ -678,7 +792,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 +813,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
@@ -742,6 +856,67 @@ class PIntegerType < PNumericType
     @from >= 0 ? self : PIntegerType.new(0, @to < 0 ? 0 : @to)
   end
 
+  def new_function(loader)
+    @@new_function ||= Puppet::Functions.create_loaded_function(:new, loader) do
+      local_types do
+        type 'Radix       = Variant[Default, Integer[2,2], Integer[8,8], Integer[10,10], Integer[16,16]]'
+        type 'Convertible = Variant[Undef, Integer, Float, Boolean, String]'
+        type 'NamedArgs   = Struct[{from => Convertible, Optional[radix] => Radix}]'
+      end
+
+      dispatch :from_args do
+        param          'Convertible',  :from
+        optional_param 'Radix',   :radix
+      end
+
+      dispatch :from_hash do
+        param          'NamedArgs',  :hash_args
+      end
+
+      def from_args(from, radix = :default)
+        case from
+        when NilClass
+          throw :undefined_value
+        when Float
+          from.to_i
+        when Integer
+          from
+        when TrueClass
+          1
+        when FalseClass
+          0
+        when String
+          begin
+            radix == :default ? Integer(from) : Integer(from, assert_radix(radix))
+          rescue TypeError => e
+            raise TypeConversionError.new(e.message)
+          rescue ArgumentError => e
+            raise TypeConversionError.new(e.message)
+          end
+        else
+          t = Puppet::Pops::Types::TypeCalculator.singleton.infer(from).generalize
+          raise TypeConversionError.new("Value of type '#{t}' cannot be converted to an Integer")
+        end
+      end
+
+      def from_hash(args_hash)
+        from = args_hash['from']
+        radix = args_hash['radix'] || :default
+        from_args(from, radix)
+      end
+
+      def assert_radix(radix)
+        case radix
+        when 2, 8, 10, 16, :default
+        else
+          raise ArgumentError.new("Illegal radix: '#{radix}', expected 2, 8, 10, 16, or default")
+        end
+        radix
+      end
+
+    end
+  end
+
   DEFAULT = PIntegerType.new(-Float::INFINITY)
 end
 
@@ -752,7 +927,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
 
@@ -772,6 +947,59 @@ class PFloatType < PNumericType
     end
   end
 
+  # Returns a new function that produces a Float value
+  #
+  def self.new_function(_, loader)
+    @new_function ||= Puppet::Functions.create_loaded_function(:new_float, loader) do
+      local_types do
+        type 'Convertible = Variant[Undef, Integer, Float, Boolean, String]'
+        type 'NamedArgs   = Struct[{from => Convertible}]'
+      end
+
+      dispatch :from_args do
+        param          'Convertible',  :from
+      end
+
+      dispatch :from_hash do
+        param          'NamedArgs',  :hash_args
+      end
+
+      def from_args(from)
+        case from
+        when NilClass
+          throw :undefined_value
+        when Float
+          from
+        when Integer
+          Float(from)
+        when TrueClass
+          1.0
+        when FalseClass
+          0.0
+        when String
+          begin
+            # support a binary as float
+            if from[0] == '0' && from[1].downcase == 'b'
+              from = Integer(from)
+            end
+            Float(from)
+          rescue TypeError => e
+            raise TypeConversionError.new(e.message)
+          rescue ArgumentError => e
+            raise TypeConversionError.new(e.message)
+          end
+        else
+          t = Puppet::Pops::Types::TypeCalculator.singleton.infer(from).generalize
+          raise TypeConversionError.new("Value of type '#{t}' cannot be converted to Float")
+        end
+      end
+
+      def from_hash(args_hash)
+        from_args(args_hash['from'])
+      end
+    end
+  end
+
   DEFAULT = PFloatType.new(-Float::INFINITY)
 end
 
@@ -781,8 +1009,12 @@ class PCollectionType < PAnyType
   attr_reader :element_type, :size_type
 
   def initialize(element_type, size_type = nil)
-    @element_type = element_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)
@@ -809,8 +1041,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,8 +1050,13 @@ 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 * 31 + @size_type.hash
+    @element_type.hash ^ @size_type.hash
   end
 
   def iterable?(guard = nil)
@@ -867,8 +1104,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 +1118,7 @@ class PIterableType < PTypeWithContainedType
         false
       end
     else
-      assignable?(TypeCalculator.infer(o))
+      assignable?(TypeCalculator.infer(o), guard)
     end
   end
 
@@ -916,8 +1153,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 +1162,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 +1171,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
 
@@ -958,7 +1195,7 @@ class PStringType < PScalarType
   end
 
   def hash
-    @size_type.hash * 31 + @values.hash
+    @size_type.hash ^ @values.hash
   end
 
   def iterable?(guard = nil)
@@ -973,15 +1210,41 @@ 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
     end
   end
 
+  def self.new_function(_, loader)
+    @new_function ||= Puppet::Functions.create_loaded_function(:new_string, loader) do
+      local_types do
+        type 'Format = Pattern[/^%([\s\+\-#0\[\{<\(\|]*)([1-9][0-9]*)?(?:\.([0-9]+))?([a-zA-Z])/]'
+        type 'ContainerFormat = Struct[{
+          Optional[format]         => String,
+          Optional[separator]      => String,
+          Optional[separator2]     => String,
+          Optional[string_formats] => Hash[Type, Format]
+        }]'
+        type 'TypeMap = Hash[Type, Variant[Format, ContainerFormat]]'
+        type 'Convertible = Any'
+        type 'Formats = Variant[Default, String[1], TypeMap]'
+      end
+
+      dispatch :from_args do
+        param           'Convertible',  :from
+        optional_param  'Formats',      :string_formats
+      end
+
+      def from_args(from, formats = :default)
+        StringConverter.singleton.convert(from, formats)
+      end
+    end
+  end
+
   DEFAULT = PStringType.new(nil)
   NON_EMPTY = PStringType.new(PIntegerType.new(1))
 
@@ -1040,7 +1303,12 @@ class PRegexpType < PScalarType
   attr_reader :pattern
 
   def initialize(pattern)
-    @pattern = pattern
+    if pattern.is_a?(Regexp)
+      @regexp = pattern
+      @pattern = pattern.source
+    else
+      @pattern = pattern
+    end
   end
 
   def regexp
@@ -1123,10 +1391,38 @@ end
 #
 class PBooleanType < PScalarType
 
-  def instance?(o)
+  def instance?(o, guard = nil)
     o == true || o == false
   end
 
+  def self.new_function(_, loader)
+    @new_function ||= Puppet::Functions.create_loaded_function(:new_boolean, loader) do
+      dispatch :from_args do
+        param          'Variant[Undef, Integer, Float, Boolean, String]',  :from
+      end
+
+      def from_args(from)
+        from = from.downcase if from.is_a?(String)
+        case from
+        when NilClass
+          throw :undefined_value
+        when Float
+          from != 0.0
+        when Integer
+          from != 0
+        when true, false
+          from
+        when 'false', 'no', 'n'
+          false
+        when 'true', 'yes', 'y'
+          true
+        else
+          raise TypeConversionError.new("Value '#{from}' of type '#{from.class}' cannot be converted to Boolean")
+        end
+      end
+    end
+  end
+
   DEFAULT = PBooleanType.new
 
   protected
@@ -1151,7 +1447,7 @@ class PStructElement < TypedModelObject
   end
 
   def hash
-    value_type.hash * 31 + key_type.hash
+    value_type.hash ^ key_type.hash
   end
 
   def name
@@ -1180,7 +1476,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
 
@@ -1241,8 +1541,8 @@ class PStructType < PAnyType
       tc = TypeCalculator.singleton
       PIterableType.new(
         PTupleType.new([
-          tc.unwrap_single_variant(PVariantType.new(@elements.map {|se| se.key_type })),
-          tc.unwrap_single_variant(PVariantType.new(@elements.map {|se| se.value_type }))],
+          PVariantType.maybe_create(@elements.map {|se| se.key_type }),
+          PVariantType.maybe_create(@elements.map {|se| se.value_type })],
           PHashType::KEY_PAIR_TUPLE_SIZE))
     end
   end
@@ -1255,7 +1555,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,14 +1563,20 @@ 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
 
+  def new_function(loader)
+    # Simply delegate to Hash type and let the higher level assertion deal with
+    # compliance with the Struct type regarding the produced result.
+    PHashType.new_function(self, loader)
+  end
+
   DEFAULT = PStructType.new(EMPTY_ARRAY)
 
   protected
@@ -1292,16 +1598,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 +1707,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
@@ -1408,14 +1724,14 @@ class PTupleType < PAnyType
   end
 
   def iterable_type(guard = nil)
-    PIterableType.new(TypeCalculator.singleton.unwrap_single_variant(PVariantType.new(types)))
+    PIterableType.new(PVariantType.maybe_create(types))
   end
 
   # Returns the number of elements accepted [min, max] in the tuple
   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
@@ -1437,13 +1753,19 @@ class PTupleType < PAnyType
   end
 
   def hash
-    @size_type.hash * 31 + @types.hash
+    @size_type.hash ^ @types.hash
   end
 
   def eql?(o)
     self.class == o.class && @types == o.types && @size_type == o.size_type
   end
 
+  def new_function(loader)
+    # Simply delegate to Array type and let the higher level assertion deal with
+    # compliance with the Tuple type regarding the produced result.
+    PArrayType.new_function(self, loader)
+  end
+
   DATA = PTupleType.new([PDataType::DEFAULT], PCollectionType::DEFAULT_SIZE)
   DEFAULT = PTupleType.new(EMPTY_ARRAY)
 
@@ -1452,36 +1774,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 +1850,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
@@ -1570,7 +1889,7 @@ class PCallableType < PAnyType
   end
 
   def hash
-    @param_types.hash * 31 + @block_type.hash
+    @param_types.hash ^ @block_type.hash
   end
 
   def eql?(o)
@@ -1589,7 +1908,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 +1947,50 @@ 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
+
+  # Returns a new function that produces an Array
+  #
+  def self.new_function(_, loader)
+    @new_function ||= Puppet::Functions.create_loaded_function(:new_array, loader) do
+
+      dispatch :from_args do
+        param           'Any',  :from
+        optional_param  'Boolean',      :wrap
+      end
+
+      def from_args(from, wrap = false)
+        case from
+        when NilClass
+          if wrap
+            [nil]
+          else
+            throw :undefined_value
+          end
+        when Array
+          from
+        when Hash
+          wrap ? [from] : from.to_a
+        else
+          if wrap
+            [from]
+          else
+            if PIterableType::DEFAULT.instance?(from)
+              Iterable.on(from).to_a
+            else
+              t = Puppet::Pops::Types::TypeCalculator.singleton.infer(from).generalize
+              raise TypeConversionError.new("Value of type '#{t}' cannot be converted to Array")
+            end
+          end
+        end
+      end
+    end
   end
 
   DATA = PArrayType.new(PDataType::DEFAULT, DEFAULT_SIZE)
@@ -1664,7 +2023,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
@@ -1684,7 +2043,11 @@ class PHashType < PCollectionType
 
   def initialize(key_type, value_type, size_type = nil)
     super(value_type, size_type)
-    @key_type = key_type
+    if !size_type.nil? && size_type.from == 0 && size_type.to == 0
+      @key_type = PUnitType::DEFAULT
+    else
+      @key_type = key_type
+    end
   end
 
   def accept(visitor, guard)
@@ -1717,17 +2080,17 @@ class PHashType < PCollectionType
   end
 
   def hash
-    @key_type.hash * 31 + super
+    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
@@ -1753,6 +2116,53 @@ class PHashType < PCollectionType
     self == EMPTY
   end
 
+  # Returns a new function that produces a  Hash
+  #
+  def self.new_function(_, loader)
+    @new_function ||= Puppet::Functions.create_loaded_function(:new_hash, loader) do
+      local_types do
+        type 'KeyValueArray = Array[Tuple[Any,Any],1]'
+      end
+
+      dispatch :from_tuples do
+        param           'KeyValueArray',  :from
+      end
+
+      dispatch :from_array do
+        param           'Any',  :from
+      end
+
+      def from_tuples(tuple_array)
+        Hash[tuple_array]
+      end
+
+      def from_array(from)
+        case from
+        when NilClass
+          throw :undefined_value
+        when Array
+          if from.size == 0
+            {}
+          else
+            unless from.size % 2 == 0
+              raise TypeConversionError.new("odd number of arguments for Hash")
+            end
+            Hash[*from]
+          end
+        when Hash
+          from
+        else
+          if PIterableType::DEFAULT.instance?(from)
+            Hash[*Iterable.on(from).to_a]
+          else
+            t = Puppet::Pops::Types::TypeCalculator.singleton.infer(from).generalize
+            raise TypeConversionError.new("Value of type '#{t}' cannot be converted to Hash")
+          end
+        end
+      end
+    end
+  end
+
   DEFAULT = PHashType.new(nil, nil)
   KEY_PAIR_TUPLE_SIZE = PIntegerType.new(2,2)
   DEFAULT_KEY_PAIR_TUPLE = PTupleType.new([PUnitType::DEFAULT, PUnitType::DEFAULT], KEY_PAIR_TUPLE_SIZE)
@@ -1775,8 +2185,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
@@ -1791,9 +2201,21 @@ class PVariantType < PAnyType
 
   attr_reader :types
 
+  # Checks if the number of unique types in the given array is greater than one, and if so
+  # creates a Variant with those types and returns it. If only one unique type is found,
+  # that type is instead returned.
+  #
+  # @param types [Array<PAnyType>] the variants
+  # @return [PAnyType] the resulting type
+  # @api public
+  def self.maybe_create(types)
+    types = types.uniq
+    types.size == 1 ? types[0] : new(types)
+  end
+
   # @param types [Array[PAnyType]] the variants
   def initialize(types)
-    @types = types.uniq.freeze
+    @types = types.freeze
   end
 
   def accept(visitor, guard)
@@ -1813,7 +2235,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.maybe_create(altered) }
     end
   end
 
@@ -1834,7 +2256,7 @@ class PVariantType < PAnyType
         types[0]
       elsif types.any? { |t| t.is_a?(PUndefType) }
         # Undef entry present. Use an OptionalType with a normalized Variant of all types that are not Undef
-        POptionalType.new(PVariantType.new(types.reject { |ot| ot.is_a?(PUndefType) }).normalize(guard)).normalize(guard)
+        POptionalType.new(PVariantType.maybe_create(types.reject { |ot| ot.is_a?(PUndefType) }).normalize(guard)).normalize(guard)
       else
         # Merge all variants into this one
         types = types.map do |t|
@@ -1854,11 +2276,12 @@ class PVariantType < PAnyType
         types = merge_patterns(types)
         types = merge_int_ranges(types)
         types = merge_float_ranges(types)
+        types = merge_version_ranges(types)
 
         if types.size == 1
           types[0]
         else
-          modified || types.size != size_before_merge ? PVariantType.new(types) : self
+          modified || types.size != size_before_merge ? PVariantType.maybe_create(types) : self
         end
       end
     end
@@ -1868,9 +2291,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)
@@ -1922,7 +2353,7 @@ class PVariantType < PAnyType
       optionals = parts[0]
       if optionals.size > 1
         others = parts[1]
-        others <<  POptionalType.new(PVariantType.new(optionals.map { |optional| optional.type }).normalize)
+        others <<  POptionalType.new(PVariantType.maybe_create(optionals.map { |optional| optional.type }).normalize)
         array = others
       end
     end
@@ -1936,7 +2367,7 @@ class PVariantType < PAnyType
       not_undefs = parts[0]
       if not_undefs.size > 1
         others = parts[1]
-        others <<  PNotUndefType.new(PVariantType.new(not_undefs.map { |not_undef| not_undef.type }).normalize)
+        others <<  PNotUndefType.new(PVariantType.maybe_create(not_undefs.map { |not_undef| not_undef.type }).normalize)
         array = others
       end
     end
@@ -1990,10 +2421,19 @@ class PVariantType < PAnyType
     array
   end
 
+  def merge_version_ranges(array)
+    if array.size > 1
+      parts = array.partition {|t| t.is_a?(PSemVerType) }
+      ranges = parts[0]
+      array = [PSemVerType.new(*ranges.map(&:ranges).flatten)] + parts[1] if ranges.size > 1
+    end
+    array
+  end
+
   # @api private
   def merge_ranges(ranges)
     result = []
-    while !ranges.empty?
+    until ranges.empty?
       unmerged = []
       x = ranges.pop
       result << ranges.inject(x) do |memo, y|
@@ -2011,58 +2451,6 @@ class PVariantType < PAnyType
   end
 end
 
-# @api public
-#
-class PRuntimeType < PAnyType
-  attr_reader :runtime, :runtime_type_name
-
-  def initialize(runtime, runtime_type_name = nil)
-    @runtime = runtime
-    @runtime_type_name = runtime_type_name
-  end
-
-  def hash
-    @runtime.hash * 31 + @runtime_type_name.hash
-  end
-
-  def eql?(o)
-    self.class == o.class && @runtime == o.runtime && @runtime_type_name == o.runtime_type_name
-  end
-
-  def instance?(o)
-    assignable?(TypeCalculator.infer(o))
-  end
-
-  def iterable?(guard = nil)
-    c = class_from_string(@runtime_type_name)
-    c.nil? ? false : c < Iterable
-  end
-
-  def iterable_type(guard = nil)
-    iterable?(guard) ? PIterableType.new(self) : nil
-  end
-
-  DEFAULT = PRuntimeType.new(nil)
-
-  protected
-
-  # Assignable if o's has the same runtime and the runtime name resolves to
-  # a class that is the same or subclass of t1's resolved runtime type name
-  # @api private
-  def _assignable?(o, guard)
-    return false unless o.is_a?(PRuntimeType)
-    return false unless @runtime == o.runtime
-    return true if @runtime_type_name.nil?   # t1 is wider
-    return false if o.runtime_type_name.nil?  # t1 not nil, so o can not be wider
-
-    # NOTE: This only supports Ruby, must change when/if the set of runtimes is expanded
-    c1 = class_from_string(@runtime_type_name)
-    c2 = class_from_string(o.runtime_type_name)
-    return false unless c1.is_a?(Module) && c2.is_a?(Module)
-    !!(c2 <= c1)
-  end
-end
-
 # Abstract representation of a type that can be placed in a Catalog.
 # @api public
 #
@@ -2070,8 +2458,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
@@ -2087,17 +2475,23 @@ end
 class PHostClassType < PCatalogEntryType
   attr_reader :class_name
 
+  NAME = 'Class'.freeze
+
   def initialize(class_name)
     @class_name = class_name
   end
 
   def hash
-    11 * @class_name.hash
+    11 ^ @class_name.hash
   end
   def eql?(o)
     self.class == o.class && @class_name == o.class_name
   end
 
+  def simple_name
+    NAME
+  end
+
   DEFAULT = PHostClassType.new(nil)
 
   protected
@@ -2116,19 +2510,20 @@ end
 # @api public
 #
 class PResourceType < PCatalogEntryType
-  attr_reader :type_name, :title
+  attr_reader :type_name, :title, :downcased_name
 
   def initialize(type_name, title = nil)
-    @type_name = type_name
-    @title = title
+    @type_name = type_name.freeze
+    @title = title.freeze
+    @downcased_name = type_name.nil? ? nil : @type_name.downcase.freeze
   end
 
-  def hash
-    @type_name.hash * 31 + @title.hash
+  def eql?(o)
+    self.class == o.class && @downcased_name == o.downcased_name && @title == o.title
   end
 
-  def eql?(o)
-    self.class == o.class && @type_name == o.type_name && @title == o.title
+  def hash
+    @downcased_name.hash ^ @title.hash
   end
 
   DEFAULT = PResourceType.new(nil)
@@ -2137,11 +2532,7 @@ class PResourceType < PCatalogEntryType
 
   # @api private
   def _assignable?(o, guard)
-    return false unless o.is_a?(PResourceType)
-    return true if @type_name.nil?
-    return false if @type_name != o.type_name
-    return true if @title.nil?
-    @title == o.title
+    o.is_a?(PResourceType) && (@downcased_name.nil? || @downcased_name == o.downcased_name && (@title.nil? || @title == o.title))
   end
 end
 
@@ -2158,8 +2549,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)
@@ -2179,6 +2570,10 @@ class POptionalType < PTypeWithContainedType
     end
   end
 
+  def new_function(loader)
+    optional_type.new_function(loader)
+  end
+
   DEFAULT = POptionalType.new(nil)
 
   protected
@@ -2196,27 +2591,30 @@ class POptionalType < PTypeWithContainedType
 end
 
 class PTypeReferenceType < PAnyType
-  attr_reader :name, :parameters
+  attr_reader :type_string
 
-  def initialize(name, parameters = nil)
-    @name = name
-    @parameters = parameters.nil? ? EMPTY_ARRAY : parameters
+  def initialize(type_string)
+    @type_string = type_string
   end
 
   def callable?(args)
     false
   end
 
-  def instance?(o)
+  def instance?(o, guard = nil)
     false
   end
 
   def hash
-    @name.hash * 31 + @parameters.hash
+    @type_string.hash
   end
 
   def eql?(o)
-    super && o.name == @name && o.parameters == @parameters
+    super && o.type_string == @type_string
+  end
+
+  def resolve(type_parser, loader)
+    type_parser.parse(@type_string, loader)
   end
 
   protected
@@ -2235,6 +2633,7 @@ end
 # might contain self recursion. Whether or not that is the case is computed and remembered when the alias
 # is resolved since guarding against self recursive constructs is relatively expensive.
 #
+# @api public
 class PTypeAliasType < PAnyType
   attr_reader :name
 
@@ -2248,6 +2647,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.
   #
@@ -2262,13 +2669,16 @@ class PTypeAliasType < PAnyType
     guarded_recursion(guard, false) { |g| resolved_type.callable_args?(callable, g) }
   end
 
+  def check_self_recursion(originator)
+    resolved_type.check_self_recursion(originator) unless originator.equal?(self)
+  end
+
   def kind_of_callable?(optional=true, guard = nil)
     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 +2693,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,12 +2751,25 @@ 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
       end
+    else
+      # An alias may appoint an Object type that isn't resolved yet. The default type
+      # reference is used to prevent endless recursion and should not be resolved here.
+      @resolved_type.resolve(type_parser, loader) unless @resolved_type.equal?(PTypeReferenceType::DEFAULT)
     end
     self
   end
@@ -2319,7 +2780,7 @@ class PTypeAliasType < PAnyType
 
   def accept(visitor, guard)
     guarded_recursion(guard, nil) do |g|
-      super
+      super(visitor, g)
       resolved_type.accept(visitor, g)
     end
   end
@@ -2328,17 +2789,42 @@ 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
+
+  def new_function(loader)
+    resolved_type.new_function(loader)
   end
 
   private
@@ -2352,7 +2838,41 @@ 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.maybe_create(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
+    @resolved_type.check_self_recursion(self) if @self_recursion
+  end
+
   DEFAULT = PTypeAliasType.new('UnresolvedAlias', nil, PTypeReferenceType::DEFAULT)
 end
 end
 end
+
+require 'puppet/pops/pcore'
+
+require_relative 'puppet_object'
+require_relative 'p_object_type'
+require_relative 'p_runtime_type'
+require_relative 'p_sem_ver_type'
+require_relative 'p_sem_ver_range_type'
+require_relative 'implementation_registry'