puppet 4.4.2 → 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
@@ -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]
@@ -217,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.
   #
@@ -229,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
@@ -430,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
@@ -470,6 +510,19 @@ class PUnitType < PAnyType
     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
@@ -663,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
@@ -753,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
 
@@ -783,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
 
@@ -792,10 +1009,11 @@ 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 has_empty_range? && !@element_type.is_a?(PUnitType)
-      raise ArgumentError, 'An empty collection may not specify an element type'
+    if !size_type.nil? && size_type.from == 0 && size_type.to == 0
+      @element_type = PUnitType::DEFAULT
+    else
+      @element_type = element_type
     end
   end
 
@@ -1001,6 +1219,32 @@ class PStringType < PScalarType
     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))
 
@@ -1059,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
@@ -1146,6 +1395,34 @@ class PBooleanType < PScalarType
     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
@@ -1264,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
@@ -1294,6 +1571,12 @@ class PStructType < PAnyType
     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
@@ -1441,7 +1724,7 @@ 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
@@ -1477,6 +1760,12 @@ class PTupleType < PAnyType
     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)
 
@@ -1666,6 +1955,44 @@ class PArrayType < PCollectionType
     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)
   DEFAULT = PArrayType.new(nil)
   EMPTY = PArrayType.new(PUnitType::DEFAULT, ZERO_SIZE)
@@ -1716,9 +2043,10 @@ 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'
+    if !size_type.nil? && size_type.from == 0 && size_type.to == 0
+      @key_type = PUnitType::DEFAULT
+    else
+      @key_type = key_type
     end
   end
 
@@ -1788,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)
@@ -1826,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)
@@ -1848,7 +2235,7 @@ class PVariantType < PAnyType
     if self == DEFAULT || self == DATA
       self
     else
-      alter_type_array(@types, :generalize) { |altered| PVariantType.new(altered) }
+      alter_type_array(@types, :generalize) { |altered| PVariantType.maybe_create(altered) }
     end
   end
 
@@ -1869,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|
@@ -1889,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
@@ -1965,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
@@ -1979,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
@@ -2033,6 +2421,15 @@ 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 = []
@@ -2054,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 ^ @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, guard = nil)
-    assignable?(TypeCalculator.infer(o), guard)
-  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
 #
@@ -2130,6 +2475,8 @@ end
 class PHostClassType < PCatalogEntryType
   attr_reader :class_name
 
+  NAME = 'Class'.freeze
+
   def initialize(class_name)
     @class_name = class_name
   end
@@ -2141,6 +2488,10 @@ class PHostClassType < PCatalogEntryType
     self.class == o.class && @class_name == o.class_name
   end
 
+  def simple_name
+    NAME
+  end
+
   DEFAULT = PHostClassType.new(nil)
 
   protected
@@ -2159,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 ^ @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)
@@ -2180,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
 
@@ -2222,6 +2570,10 @@ class POptionalType < PTypeWithContainedType
     end
   end
 
+  def new_function(loader)
+    optional_type.new_function(loader)
+  end
+
   DEFAULT = POptionalType.new(nil)
 
   protected
@@ -2239,11 +2591,10 @@ 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)
@@ -2255,11 +2606,15 @@ class PTypeReferenceType < PAnyType
   end
 
   def hash
-    @name.hash ^ @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
@@ -2278,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
 
@@ -2313,6 +2669,10 @@ 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
@@ -2406,6 +2766,10 @@ class PTypeAliasType < PAnyType
         @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
@@ -2416,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
@@ -2459,6 +2823,10 @@ class PTypeAliasType < PAnyType
     resolved_type.assignable?(o, guard)
   end
 
+  def new_function(loader)
+    resolved_type.new_function(loader)
+  end
+
   private
 
   def guarded_recursion(guard, dflt)
@@ -2484,7 +2852,7 @@ class PTypeAliasType < PAnyType
         if real_types.size == 1
           @resolved_type = real_types[0]
         else
-          @resolved_type = PVariantType.new(real_types)
+          @resolved_type = PVariantType.maybe_create(real_types)
         end
         # Drop self recursion status in case it's not self recursive anymore
         guard = RecursionGuard.new
@@ -2492,9 +2860,19 @@ class PTypeAliasType < PAnyType
         @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'