puppet 4.8.2-x64-mingw32 → 4.9.0-x64-mingw32

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

@@ -210,6 +210,16 @@ class RubyGenerator < TypeFormatter
     init_params.each { |a| bld << '    @' << a.name << ' = ' << a.name << "\n" if a.container.equal?(obj) }
     bld << "  end\n\n"
 
+    bld << "  def i12n_hash\n    result = "
+    bld << (obj.parent.nil? ? '{}' : 'super')
+    bld << "\n"
+    init_params.each { |a| bld << "    result['" << a.name << "'] = @" << a.name << "\n" if a.container.equal?(obj) }
+    bld << "    result\n  end\n\n"
+
+    bld << "  def to_s\n"
+    bld << "    " << namespace_relative(segments, TypeFormatter.name) << ".string(self)\n"
+    bld << "  end\n\n"
+
     # Output attr_readers
     others.each do |a|
       next unless a.container.equal?(obj)

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

@@ -312,7 +312,7 @@ class TypeCalculator
         infer_set_Array(o)
       when Hash
         infer_set_Hash(o)
-      when Semantic::Version
+      when SemanticPuppet::Version
         infer_set_Version(o)
       else
         infer_set_Object(o)
@@ -389,8 +389,8 @@ class TypeCalculator
     # when both are hashes, return a hash with common key- and element type
     if t1.is_a?(PHashType) && t2.is_a?(PHashType)
       key_type = common_type(t1.key_type, t2.key_type)
-      element_type = common_type(t1.element_type, t2.element_type)
-      return PHashType.new(key_type, element_type)
+      value_type = common_type(t1.value_type, t2.value_type)
+      return PHashType.new(key_type, value_type)
     end
 
     # when both are host-classes, reduce to PHostClass[] (since one was not assignable to the other)
@@ -414,19 +414,29 @@ class TypeCalculator
       return PFloatType.new([t1.numeric_from, t2.numeric_from].min, [t1.numeric_to, t2.numeric_to].max)
     end
 
-    if t1.is_a?(PStringType) && t2.is_a?(PStringType)
-      common_size_type = common_type(t1.size_type, t2.size_type) unless t1.size_type.nil? || t2.size_type.nil?
-      common_strings = t1.values.empty? || t2.values.empty? ? [] : t1.values | t2.values
-      return PStringType.new(common_size_type, common_strings)
+    if t1.is_a?(PStringType) && (t2.is_a?(PStringType) || t2.is_a?(PEnumType))
+      if(t2.is_a?(PEnumType))
+        return t1.value.nil? ? PEnumType::DEFAULT : PEnumType.new(t2.values | [t1.value])
+      end
+
+      if t1.size_type.nil? || t2.size_type.nil?
+        return t1.value.nil? || t2.value.nil? ? PStringType::DEFAULT : PEnumType.new([t1.value, t2.value])
+      end
+
+      return PStringType.new(common_type(t1.size_type, t2.size_type))
     end
 
     if t1.is_a?(PPatternType) && t2.is_a?(PPatternType)
       return PPatternType.new(t1.patterns | t2.patterns)
     end
 
-    if t1.is_a?(PEnumType) && t2.is_a?(PEnumType)
+    if t1.is_a?(PEnumType) && (t2.is_a?(PStringType) || t2.is_a?(PEnumType))
       # The common type is one that complies with either set
-      return PEnumType.new(t1.values | t2.values)
+      if t2.is_a?(PEnumType)
+        return PEnumType.new(t1.values | t2.values)
+      end
+
+      return t2.value.nil? ? PEnumType::DEFAULT : PEnumType.new(t1.values | [t2.value])
     end
 
     if t1.is_a?(PVariantType) && t2.is_a?(PVariantType)
@@ -437,7 +447,7 @@ class TypeCalculator
     if t1.is_a?(PRegexpType) && t2.is_a?(PRegexpType)
       # if they were identical, the general rule would return a parameterized regexp
       # since they were not, the result is a generic regexp type
-      return PPatternType::DEFAULT
+      return PRegexpType::DEFAULT
     end
 
     if t1.is_a?(PCallableType) && t2.is_a?(PCallableType)
@@ -581,7 +591,7 @@ class TypeCalculator
 
   # @api private
   def infer_String(o)
-    PStringType.new(size_as_type(o), [o])
+    PStringType.new(o)
   end
 
   # @api private
@@ -735,7 +745,7 @@ class TypeCalculator
     if o.empty?
       PHashType::EMPTY
     elsif o.keys.all? {|k| PStringType::NON_EMPTY.instance?(k) }
-      PStructType.new(o.each_pair.map { |k,v| PStructElement.new(PStringType.new(size_as_type(k), [k]), infer_set(v)) })
+      PStructType.new(o.each_pair.map { |k,v| PStructElement.new(PStringType.new(k), infer_set(v)) })
     else
       ktype = PVariantType.maybe_create(o.keys.map {|k| infer_set(k) })
       etype = PVariantType.maybe_create(o.values.map {|e| infer_set(e) })
@@ -745,7 +755,7 @@ class TypeCalculator
 
   # @api private
   def infer_set_Version(o)
-    PSemVerType.new([Semantic::VersionRange.new(o, o)])
+    PSemVerType.new([SemanticPuppet::VersionRange.new(o, o)])
   end
 
   def unwrap_single_variant(possible_variant)

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

@@ -75,11 +75,20 @@ module TypeFactory
     @type_calculator.string(t)
   end
 
-  # Produces the String type, optionally with specific string values
+  # Produces the String type based on nothing, a string value that becomes an exact match constraint, or a parameterized
+  # Integer type that constraints the size.
+  #
   # @api public
   #
-  def self.string(size_type = nil, *values)
-    PStringType.new(size_type, values)
+  def self.string(size_type_or_value = nil, *deprecated_second_argument)
+    if deprecated_second_argument.empty?
+      size_type_or_value.nil? ? PStringType::DEFAULT : PStringType.new(size_type_or_value)
+    else
+      if Puppet[:strict] != :off
+        Puppet.warn_once(:deprecatation, "TypeFactory#string_multi_args", "Passing more than one argument to TypeFactory#string is deprecated")
+      end
+      deprecated_second_argument.size == 1 ? PStringType.new(deprecated_second_argument[0]) : PEnumType.new(*deprecated_second_argument)
+    end
   end
 
   # Produces the Optional type, i.e. a short hand for Variant[T, Undef]
@@ -92,7 +101,7 @@ module TypeFactory
   # @api public
   #
   def self.optional(optional_type = nil)
-    POptionalType.new(type_of(optional_type.is_a?(String) ? string(nil, optional_type) : type_of(optional_type)))
+    POptionalType.new(type_of(optional_type.is_a?(String) ? string(optional_type) : type_of(optional_type)))
   end
 
   # Produces the Enum type, optionally with specific string values
@@ -129,7 +138,7 @@ module TypeFactory
       # TODO: Should have stricter name rule
       if key_type.is_a?(String)
         raise ArgumentError, 'Struct element key cannot be an empty String' if key_type.empty?
-        key_type = string(nil, key_type)
+        key_type = string(key_type)
         # Must make key optional if the value can be Undef
         key_type = optional(key_type) if tc.assignable?(value_type, PUndefType::DEFAULT)
       else
@@ -141,12 +150,14 @@ module TypeFactory
           s = key_type
         when POptionalType
           s = key_type.optional_type
-        when PStringType, PEnumType
+        when PStringType
           s = key_type
+        when PEnumType
+          s = key_type.values.size == 1 ? PStringType.new(key_type.values[0]) : nil
         else
           raise ArgumentError, "Illegal Struct member key type. Expected NotUndef, Optional, String, or Enum. Got: #{key_type.class.name}"
         end
-        unless (s.is_a?(PStringType) || s.is_a?(PEnumType)) && s.values.size == 1 && !s.values[0].empty?
+        unless s.is_a?(PStringType) && !s.value.nil?
           raise ArgumentError, "Unable to extract a non-empty literal string from Struct member key type #{tc.string(key_type)}"
         end
       end
@@ -307,7 +318,7 @@ module TypeFactory
   # @api public
   #
   def self.collection(size_type = nil)
-    size_type.nil? ? PCollectionType::DEFAULT : PCollectionType.new(nil, size_type)
+    size_type.nil? ? PCollectionType::DEFAULT : PCollectionType.new(size_type)
   end
 
   # Produces the Data type
@@ -435,7 +446,7 @@ module TypeFactory
   # @api public
   #
   def self.not_undef(inst_type = nil)
-    inst_type = string(nil, inst_type) if inst_type.is_a?(String)
+    inst_type = string(inst_type) if inst_type.is_a?(String)
     PNotUndefType.new(inst_type)
   end
 

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

@@ -42,17 +42,24 @@ class TypeFormatter
   #
   # @api public
   def indented_string(t, indent = 0, indent_width = 2)
+    @bld = ''
+    append_indented_string(t, indent, indent_width)
+    @bld
+  end
+
+  # @api private
+  def append_indented_string(t, indent = 0, indent_width = 2, skip_initial_indent = false)
+    save_indent = @indent
+    save_indent_width = @indent_width
     @indent = indent
     @indent_width = indent_width
     begin
-      @bld = ''
-      (@indent * @indent_width).times { @bld << ' ' }
+      (@indent * @indent_width).times { @bld << ' ' } unless skip_initial_indent
       append_string(t)
       @bld << "\n"
-      @bld
     ensure
-      @indent = nil
-      @indent_width = nil
+      @indent = save_indent
+      @indent_width = save_indent_width
     end
   end
 
@@ -169,11 +176,10 @@ class TypeFormatter
   # @api private
   def string_PStringType(t)
     range = range_array_part(t.size_type)
-    append_array('String', range.empty?) do
+    append_array('String', range.empty? && !(@debug && !t.value.nil?)) do
       if @debug
-        append_elements(range, true)
-        append_strings(t.values, true)
-        chomp_list
+        append_elements(range, !t.value.nil?)
+        append_string(t.value) unless t.value.nil?
       else
         append_elements(range)
       end
@@ -297,6 +303,14 @@ class TypeFormatter
     append_array('Collection', range.empty? ) { append_elements(range) }
   end
 
+  def string_PuppetObject(t)
+    @bld << t._ptype.name << '('
+    append_indented_string(t.i12n_hash, @indent || 0, @indent_width || 2, true)
+    @bld.chomp!
+    @bld << ')'
+    newline if @indent
+  end
+
   # @api private
   def string_PUnitType(_)
     @bld << 'Unit'
@@ -326,7 +340,7 @@ class TypeFormatter
       append_array('Hash') { append_strings([0, 0]) }
     else
       append_array('Hash', t == PHashType::DATA) do
-        append_strings([t.key_type, t.element_type], true)
+        append_strings([t.key_type, t.value_type], true)
         append_elements(range_array_part(t.size_type), true)
         chomp_list
       end
@@ -356,8 +370,8 @@ class TypeFormatter
   def string_PNotUndefType(t)
     contained_type = t.type
     append_array('NotUndef', contained_type.nil? || contained_type.class == PAnyType) do
-      if contained_type.is_a?(PStringType) && contained_type.values.size == 1
-        append_string(contained_type.values[0])
+      if contained_type.is_a?(PStringType) && !contained_type.value.nil?
+        append_string(contained_type.value)
       else
         append_string(contained_type)
       end
@@ -414,7 +428,7 @@ class TypeFormatter
     if @expanded
       append_object_hash(t.i12n_hash(@type_set.nil? || !@type_set.defines_type?(t)))
     else
-      @bld << (@type_set ? @type_set.name_for(t) : t.label)
+      @bld << (@type_set ? @type_set.name_for(t, t.label) : t.label)
     end
   end
 
@@ -427,8 +441,8 @@ class TypeFormatter
   def string_POptionalType(t)
     optional_type = t.optional_type
     append_array('Optional', optional_type.nil?) do
-      if optional_type.is_a?(PStringType) && optional_type.values.size == 1
-        append_string(optional_type.values[0])
+      if optional_type.is_a?(PStringType) && !optional_type.value.nil?
+        append_string(optional_type.value)
       else
         append_string(optional_type)
       end
@@ -440,8 +454,14 @@ class TypeFormatter
     expand = @expanded
     if expand && t.self_recursion?
       @guard ||= RecursionGuard.new
-      expand = (@guard.add_this(t) & RecursionGuard::SELF_RECURSION_IN_THIS) == 0
+      @guard.with_this(t) { |state| format_type_alias_type(t, (state & RecursionGuard::SELF_RECURSION_IN_THIS) == 0) }
+    else
+      format_type_alias_type(t, expand)
     end
+  end
+
+  # @api private
+  def format_type_alias_type(t, expand)
     if @type_set.nil?
       @bld << t.name
       if expand
@@ -452,7 +472,7 @@ class TypeFormatter
       if expand && @type_set.defines_type?(t)
         append_string(t.resolved_type)
       else
-        @bld << @type_set.name_for(t)
+        @bld << @type_set.name_for(t, t.name)
       end
     end
   end

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

@@ -329,8 +329,7 @@ module Types
           a = detailed_actual_to_s(e, a)
           e = e.map { |t| t.to_alias_expanded_s }
         else
-          sns = e.map { |t| t.simple_name }.uniq
-          e = e.map { |t| s = t.simple_name; sns.count {|x| x == s } == 1 ? s : t.to_s }.uniq
+          e = e.map { |t| t.simple_name }.uniq
           a = a.simple_name
         end
         case e.size
@@ -464,7 +463,7 @@ module Types
 
     def actual_string
       a = actual
-      a.is_a?(PStringType) && a.values.size == 1 ? "'#{a.values[0]}'" : a.simple_name
+      a.is_a?(PStringType) && !a.value.nil? ? "'#{a.value}'" : a.simple_name
     end
   end
 
@@ -722,8 +721,10 @@ module Types
         arg_count.times do |index|
           adx = index >= etypes.size ? etypes.size - 1 : index
           etype = etypes[adx]
-          descriptions = describe(etype, atypes[index], path + [ParameterPathElement.new(enames[adx])])
-          return descriptions unless descriptions.empty?
+          unless etype.assignable?(atypes[index])
+            descriptions = describe(etype, atypes[index], path + [ParameterPathElement.new(enames[adx])])
+            return descriptions unless descriptions.empty?
+          end
         end
         EMPTY_ARRAY
       else
@@ -816,7 +817,7 @@ module Types
     def describe_PHashType(expected, actual, path)
       descriptions = []
       key_type = expected.key_type || PAnyType::DEFAULT
-      value_type = expected.element_type || PAnyType::DEFAULT
+      value_type = expected.value_type || PAnyType::DEFAULT
       if actual.is_a?(PStructType)
         elements = actual.elements
         expected_size = expected.size_type || PCollectionType::DEFAULT_SIZE

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

@@ -37,6 +37,12 @@ class TypeParser
     interpret(model.current.body, context)
   end
 
+  # @api private
+  def parse_literal(string, context = nil)
+    model = @parser.parse_string(string)
+    interpret_any(model.current.body, context)
+  end
+
   # @param ast [Puppet::Pops::Model::PopsObject] the ast to interpret
   # @param context [Puppet::Parser::Scope,Loader::Loader, nil] scope or loader to use when loading type aliases
   # @return [PAnyType] a specialization of the PAnyType representing the type.

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