puppet 5.1.0-x64-mingw32 → 5.2.0-x64-mingw32

data/lib/puppet/pops/patterns.rb

@@ -48,7 +48,7 @@ module Puppet::Pops::Patterns
 
   # VAR_NAME matches the name part of a variable (The $ character is not included)
   # Note, that only the final segment may start with an underscore.
-  VAR_NAME = %r{\A(?:(::)?[a-z]\w*)*(?:(::)?[a-z_]\w*)\z}
+  VAR_NAME = %r{\A(?:((::)?[a-z]\w*)*(?:(::)?_\w*)?)\z}
 
   # PARAM_NAME matches the name part of a parameter (The $ character is not included)
   PARAM_NAME = %r{\A[a-z_]\w*\z}

data/lib/puppet/pops/serialization/from_data_converter.rb

@@ -160,7 +160,7 @@ module Serialization
       elsif value.is_a?(String)
         build(pcore_type.create(value))
       else
-        raise SerializationError, _('Cannot create a %{type_name} from a %{arg_class') %
+        raise SerializationError, _('Cannot create a %{type_name} from a %{arg_class}') %
             { :type_name => pcore_type.name, :arg_class => value.class.name }
       end
     end

data/lib/puppet/pops/serialization/json_path.rb

@@ -26,7 +26,7 @@ module JsonPath
   # with '$' which denotes the value that is passed into the parser. This parser can easily
   # be extended with more elaborate resolution mechanisms involving document sets.
   #
-  # The parser is limited to constructs generated by the {JsonPath#json_path_reference}
+  # The parser is limited to constructs generated by the {JsonPath#to_json_path}
   # method.
   #
   # @api private

data/lib/puppet/pops/serialization/to_data_converter.rb

@@ -71,11 +71,20 @@ module Serialization
     def to_data(value)
       if value.nil? || Types::PScalarDataType::DEFAULT.instance?(value)
         value
-      elsif value.is_a?(Symbol)
-        if value == :default
+      elsif :default == value
+        if @rich_data
           { PCORE_TYPE_KEY => PCORE_TYPE_DEFAULT }
         else
-          @symbol_as_string ? value.to_s : { PCORE_TYPE_KEY => PCORE_TYPE_SYMBOL, PCORE_VALUE_KEY => value.to_s }
+          serialization_issue(Issues::SERIALIZATION_DEFAULT_CONVERTED_TO_STRING, :path => path_to_s)
+          'default'
+        end
+      elsif value.is_a?(Symbol)
+        if @symbol_as_string
+          value.to_s
+        elsif @rich_data
+          { PCORE_TYPE_KEY => PCORE_TYPE_SYMBOL, PCORE_VALUE_KEY => value.to_s }
+        else
+          unknown_to_string_with_warning(value)
         end
       elsif value.instance_of?(Array)
         process(value) do

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

@@ -5,6 +5,7 @@ module Types
 
 KEY_ATTRIBUTES = 'attributes'.freeze
 KEY_CHECKS = 'checks'.freeze
+KEY_CONSTANTS = 'constants'.freeze
 KEY_EQUALITY = 'equality'.freeze
 KEY_EQUALITY_INCLUDE_TYPE = 'equality_include_type'.freeze
 KEY_FINAL = 'final'.freeze
@@ -32,6 +33,8 @@ class PObjectType < PMetaType
     KEY_VALUE => PAnyType::DEFAULT,
     TypeFactory.optional(KEY_ANNOTATIONS) => TYPE_ANNOTATIONS
   })
+
+  TYPE_CONSTANTS = TypeFactory.hash_kv(Pcore::TYPE_MEMBER_NAME, PAnyType::DEFAULT)
   TYPE_ATTRIBUTES = TypeFactory.hash_kv(Pcore::TYPE_MEMBER_NAME, TypeFactory.not_undef)
   TYPE_ATTRIBUTE_CALLABLE = TypeFactory.callable(0,0)
 
@@ -53,6 +56,7 @@ class PObjectType < PMetaType
     TypeFactory.optional(KEY_NAME) => TYPE_OBJECT_NAME,
     TypeFactory.optional(KEY_PARENT) => PTypeType::DEFAULT,
     TypeFactory.optional(KEY_ATTRIBUTES) => TYPE_ATTRIBUTES,
+    TypeFactory.optional(KEY_CONSTANTS) => TYPE_CONSTANTS,
     TypeFactory.optional(KEY_FUNCTIONS) => TYPE_FUNCTIONS,
     TypeFactory.optional(KEY_EQUALITY) => TYPE_EQUALITY,
     TypeFactory.optional(KEY_EQUALITY_INCLUDE_TYPE) => PBooleanType::DEFAULT,
@@ -143,12 +147,16 @@ class PObjectType < PMetaType
     # @api private
     def assert_can_be_overridden(member)
       raise Puppet::ParseError, "#{member.label} attempts to override #{label}" unless self.class == member.class
-      raise Puppet::ParseError, "#{member.label} attempts to override final #{label}" if @final
+      raise Puppet::ParseError, "#{member.label} attempts to override final #{label}" if @final && !(constant? && member.constant?)
       raise Puppet::ParseError, "#{member.label} attempts to override #{label} without having override => true" unless member.override?
       raise Puppet::ParseError, "#{member.label} attempts to override #{label} with a type that does not match" unless @type.assignable?(member.type)
       member
     end
 
+    def constant?
+      false
+    end
+
     # @return [Boolean] `true` if this feature cannot be overridden
     # @api public
     def final?
@@ -295,6 +303,10 @@ class PObjectType < PMetaType
       hash
     end
 
+    def constant?
+      @kind == ATTRIBUTE_KIND_CONSTANT
+    end
+
     # @return [Booelan] true if the given value equals the default value for this attribute
     def default_value?(value)
       @value == value
@@ -594,8 +606,24 @@ class PObjectType < PMetaType
       end
     end
 
-    attr_specs = init_hash[KEY_ATTRIBUTES]
-    unless attr_specs.nil? || attr_specs.empty?
+    constants = init_hash[KEY_CONSTANTS]
+    attr_specs = init_hash[KEY_ATTRIBUTES] || {}
+    unless constants.nil? || constants.empty?
+      constants.each do |key, value|
+        raise Puppet::ParseError, "attribute #{label}[#{key}] is defined as both a constant and an attribute" if attr_specs.include?(key)
+        attr_spec = {
+          # Type must be generic here, or overrides would become impossible
+          KEY_TYPE => TypeCalculator.infer(value).generalize,
+          KEY_VALUE => value,
+          KEY_KIND => ATTRIBUTE_KIND_CONSTANT
+        }
+        # Indicate override if parent member exists. Type check etc. will take place later on.
+        attr_spec[KEY_OVERRIDE] = true if parent_members.include?(key)
+        attr_specs[key] = attr_spec
+      end
+    end
+
+    unless attr_specs.empty?
       @attributes = Hash[attr_specs.map do |key, attr_spec|
         unless attr_spec.is_a?(Hash)
           attr_type = TypeAsserter.assert_instance_of(nil, PTypeType::DEFAULT, attr_spec) { "attribute #{label}[#{key}]" }

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

@@ -111,7 +111,7 @@ class PSemVerRangeType < PAnyType
     @new_function ||= Puppet::Functions.create_loaded_function(:new_VersionRange, type.loader) do
       local_types do
         type 'SemVerRangeString = String[1]'
-        type 'SemVerRangeHash = Struct[{min=>Variant[default,SemVer],Optional[max]=>Variant[default,SemVer],Optional[exclude_max]=>Boolean}]'
+        type 'SemVerRangeHash = Struct[{min=>Variant[Default,SemVer],Optional[max]=>Variant[Default,SemVer],Optional[exclude_max]=>Boolean}]'
       end
 
       # Constructs a VersionRange from a String with a format specified by
@@ -136,8 +136,8 @@ class PSemVerRangeType < PAnyType
       # default.
       #
       dispatch :from_versions do
-        param 'Variant[default,SemVer]', :min
-        param 'Variant[default,SemVer]', :max
+        param 'Variant[Default,SemVer]', :min
+        param 'Variant[Default,SemVer]', :max
         optional_param 'Boolean', :exclude_max
       end
 

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

@@ -106,7 +106,7 @@ module Types
     def self.new_function(type)
       @new_function ||= Puppet::Functions.create_loaded_function(:new_timespan, type.loader) do
         local_types do
-          type 'Formats = Variant[String[2],Array[String[2]], 1]'
+          type 'Formats = Variant[String[2],Array[String[2], 1]]'
         end
 
         dispatch :from_seconds do

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

@@ -11,7 +11,7 @@ module Types
     def self.new_function(type)
       @new_function ||= Puppet::Functions.create_loaded_function(:new_timestamp, type.loader) do
         local_types do
-          type 'Formats = Variant[String[2],Array[String[2]], 1]'
+          type 'Formats = Variant[String[2],Array[String[2], 1]]'
         end
 
         dispatch :now do

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

@@ -85,7 +85,8 @@ class StringConverter
 
     attr_reader :orig_fmt
 
-    FMT_PATTERN = /^%([\s\+\-#0\[\{<\(\|]*)([1-9][0-9]*)?(?:\.([0-9]+))?([a-zA-Z])/
+    FMT_PATTERN_STR = '^%([\s\[+#0{<(|-]*)([1-9][0-9]*)?(?:\.([0-9]+))?([a-zA-Z])$'
+    FMT_PATTERN = Regexp.compile(FMT_PATTERN_STR)
     DELIMITERS  = [ '[', '{', '(', '<', '|',]
     DELIMITER_MAP = {
       '[' => ['[', ']'],
@@ -265,13 +266,13 @@ class StringConverter
   }.freeze
 
   DEFAULT_ARRAY_FORMAT                          = Format.new('%a')
-  DEFAULT_ARRAY_FORMAT.separator                = ','.freeze
-  DEFAULT_ARRAY_FORMAT.separator2               = ','.freeze
+  DEFAULT_ARRAY_FORMAT.separator                = ', '.freeze
+  DEFAULT_ARRAY_FORMAT.separator2               = ', '.freeze
   DEFAULT_ARRAY_FORMAT.container_string_formats = DEFAULT_CONTAINER_FORMATS
   DEFAULT_ARRAY_FORMAT.freeze
 
   DEFAULT_HASH_FORMAT                           = Format.new('%h')
-  DEFAULT_HASH_FORMAT.separator                 = ','.freeze
+  DEFAULT_HASH_FORMAT.separator                 = ', '.freeze
   DEFAULT_HASH_FORMAT.separator2                = ' => '.freeze
   DEFAULT_HASH_FORMAT.container_string_formats  = DEFAULT_CONTAINER_FORMATS
   DEFAULT_HASH_FORMAT.freeze
@@ -541,7 +542,7 @@ class StringConverter
 
   def validate_container_input(fmt)
     if (fmt.keys - FMT_KEYS).size > 0
-      raise ArgumentError, "only #{FMT_KEYS}.map {|k| "'#{k}'"}.join(', ')} are allowed in a container format, got #{fmt}"
+      raise ArgumentError, "only #{FMT_KEYS.map {|k| "'#{k}'"}.join(', ')} are allowed in a container format, got #{fmt}"
     end
     result                          = Format.new(fmt['format'])
     result.separator                = fmt['separator']
@@ -901,12 +902,10 @@ class StringConverter
     f = get_format(val_type, format_map)
     case f.format
     when :p
-      rx_s = val.options == 0 ? val.source : val.to_s
-      rx_s = rx_s.gsub(/\//, '\/') unless Gem::Version.new(RUBY_VERSION.dup) < Gem::Version.new('2.0.0')
-      str_regexp = "/#{rx_s}/"
+      str_regexp = PRegexpType.regexp_to_s_with_delimiters(val)
       f.orig_fmt == '%p' ? str_regexp : Kernel.format(f.orig_fmt.gsub('p', 's'), str_regexp)
     when :s
-      str_regexp = val.options == 0 ? val.source : val.to_s
+      str_regexp = PRegexpType.regexp_to_s(val)
       str_regexp = puppet_quote(str_regexp) if f.alt?
       f.orig_fmt == '%s' ? str_regexp : Kernel.format(f.orig_fmt, str_regexp)
     else
@@ -976,12 +975,13 @@ class StringConverter
           # or, if indenting, and previous was an array or hash, then break and continue on next line
           # indented.
           if (sz_break && !is_a_or_h?(v)) || (format.alt? && i > 0 && is_a_or_h?(val[i-1]) && !is_a_or_h?(v))
+            buf.rstrip! unless buf[-1] == "\n"
             buf << "\n"
             buf << children_indentation.padding
-          elsif !(format.alt? && is_a_or_h?(v))
-            buf << ' '
           end
         end
+        # remove trailing space added by separator if followed by break
+        buf.rstrip! if buf[-1] == ' ' && str_val[0] == "\n"
         buf << str_val
       end
       buf << delims[1]
@@ -1023,7 +1023,10 @@ class StringConverter
     string_formats = format.container_string_formats || DEFAULT_CONTAINER_FORMATS
     delims         = format.delimiter_pair(DEFAULT_HASH_DELIMITERS)
 
-    sep = format.alt? ? "#{sep}\n" : "#{sep} "
+    if format.alt? 
+      sep = sep.rstrip unless sep[-1] == "\n"
+      sep = "#{sep}\n"
+    end
 
     cond_break     = ''
     padding        = ''

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

@@ -550,7 +550,7 @@ class TypeCalculator
 
   # @api private
   def infer_Regexp(o)
-    PRegexpType.new(o.source)
+    PRegexpType.new(o)
   end
 
   # @api private

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

@@ -361,6 +361,13 @@ module TypeFactory
     @rich_data_t ||= TypeParser.singleton.parse('RichData', Loaders.static_loader)
   end
 
+  # Produces the RichData type
+  # @api public
+  #
+  def self.rich_data_key
+    @rich_data_key_t ||= TypeParser.singleton.parse('RichDataKey', Loaders.static_loader)
+  end
+
   # Creates an instance of the Undef type
   # @api public
   def self.undef

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

@@ -545,7 +545,7 @@ class TypeFormatter
   def string_Numeric(t)      ; @bld << t.to_s    ; end
 
   # @api private
-  def string_Regexp(t)       ; @bld << t.inspect; end
+  def string_Regexp(t)       ; @bld << PRegexpType.regexp_to_s_with_delimiters(t); end
 
   # @api private
   def string_String(t)

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

@@ -92,51 +92,6 @@ module Types
     end
   end
 
-  # Module to handle present/past tense.
-  #
-  # All method names prefixed with "it_" to avoid conflict with Mocha expectations. Adding a method
-  # named 'expects' just doesn't work.
-  #
-  # @deprecated Will be removed in Puppet 5
-  # @api private
-  module TenseVariants
-    def it_expects(tense)
-      case tense
-      when :present
-        'expects'
-      else
-        'expected'
-      end
-    end
-
-    def it_does_not_expect(tense)
-      case tense
-      when :present
-        'does not expect'
-      else
-        'did not expect'
-      end
-    end
-
-    def it_has_no(tense)
-      case tense
-      when :present
-        'has no'
-      else
-        'did not have a'
-      end
-    end
-
-    def it_references(tense)
-      case tense
-        when :present
-          'references'
-        else
-          'referenced'
-      end
-    end
-  end
-
   # @api private
   class Mismatch
     attr_reader :path
@@ -293,11 +248,6 @@ module Types
       super(path)
       @expected = (expected.is_a?(Array) ? PVariantType.maybe_create(expected) : expected).normalize
       @actual = actual.normalize
-      @optional = false
-    end
-
-    def set_optional
-      @optional = true
     end
 
     def ==(o)
@@ -307,12 +257,6 @@ module Types
     def hash
       [canonical_path, expected, actual].hash
     end
-
-    def swap_expected(expected)
-      copy = self.clone
-      copy.instance_variable_set(:@expected, expected)
-      copy
-    end
   end
 
   # @api private
@@ -328,15 +272,12 @@ module Types
       e = expected
       a = actual
       multi = false
-      if @optional
-        if e.is_a?(PVariantType)
-          e = e.types
-          e = [PUndefType::DEFAULT] + e unless e.include?(PUndefType::DEFAULT)
-        else
-          er = all_resolved(e)
-          e = [PUndefType::DEFAULT, e] unless er.is_a?(PVariantType) && er.types.include?(PUndefType::DEFAULT)
-        end
-      elsif e.is_a?(PVariantType)
+      if e.is_a?(POptionalType)
+        e = e.optional_type
+        optional = true
+      end
+
+      if e.is_a?(PVariantType)
         e = e.types
       end
 
@@ -348,6 +289,7 @@ module Types
           e = e.map { |t| t.simple_name }.uniq
           a = a.simple_name
         end
+        e.insert(0, 'Undef') if optional
         case e.size
         when 1
           e = e[0]
@@ -366,6 +308,10 @@ module Types
           e = e.simple_name
           a = a.simple_name
         end
+        if optional
+          e = "Undef or #{e}"
+          multi = true
+        end
       end
       if multi
         "#{variant}#{position} expects a value of type #{e}, got #{label(a)}"
@@ -473,7 +419,13 @@ module Types
   # @api private
   class PatternMismatch < TypeMismatch
     def message(variant, position)
-      "#{variant}#{position} expects a match for #{expected.to_alias_expanded_s}, got #{actual_string}"
+      e = expected
+      value_pfx = ''
+      if e.is_a?(POptionalType)
+        e = e.optional_type
+        value_pfx = 'an undef value or '
+      end
+      "#{variant}#{position} expects #{value_pfx}a match for #{e.to_alias_expanded_s}, got #{actual_string}"
     end
 
     def actual_string
@@ -747,14 +699,23 @@ module Types
       end
     end
 
-    def describe_PVariantType(expected, actual, path)
+    def describe_PVariantType(expected, original, actual, path)
       variant_descriptions = []
-      expected.types.each_with_index do |vt, index|
+      types = expected.types
+      types = [PUndefType::DEFAULT] + types if original.is_a?(POptionalType)
+      types.each_with_index do |vt, index|
         d = describe(vt, actual, path + [VariantPathElement.new(index)])
         return EMPTY_ARRAY if d.empty?
         variant_descriptions << d
       end
-      merge_descriptions(path.length, SizeMismatch, variant_descriptions)
+      descriptions = merge_descriptions(path.length, SizeMismatch, variant_descriptions)
+      if original.is_a?(PTypeAliasType) && descriptions.size == 1
+        # All variants failed in this alias so we report it as a mismatch on the alias
+        # rather than reporting individual failures of the variants
+        [TypeMismatch.new(path, original, actual)]
+      else
+        descriptions
+      end
     end
 
     def merge_descriptions(varying_path_position, size_mismatch_class, variant_descriptions)
@@ -778,33 +739,24 @@ module Types
       descriptions.size == 1 ? [descriptions[0].chop_path(varying_path_position)] : descriptions
     end
 
-    def describe_POptionalType(expected, actual, path)
+    def describe_POptionalType(expected, original, actual, path)
       return EMPTY_ARRAY if actual.is_a?(PUndefType)
-      descriptions = describe(expected.optional_type, actual, path)
-      descriptions.each { |description| description.set_optional }
-      descriptions
+      internal_describe(expected.optional_type, original.is_a?(PTypeAliasType) ? original : expected, actual, path)
     end
 
-    def describe_PEnumType(expected, actual, path)
-      [PatternMismatch.new(path, expected, actual)]
+    def describe_PEnumType(expected, original, actual, path)
+      [PatternMismatch.new(path, original, actual)]
     end
 
-    def describe_PPatternType(expected, actual, path)
-      [PatternMismatch.new(path, expected, actual)]
+    def describe_PPatternType(expected, original, actual, path)
+      [PatternMismatch.new(path, original, actual)]
     end
 
-    def describe_PTypeAliasType(expected, actual, path)
-      resolved_type = expected.resolved_type
-      describe(resolved_type, actual, path).map do |description|
-        if description.is_a?(ExpectedActualMismatch)
-          description.swap_expected(expected)
-        else
-          description
-        end
-      end
+    def describe_PTypeAliasType(expected, original, actual, path)
+      internal_describe(expected.resolved_type.normalize, expected, actual, path)
     end
 
-    def describe_PArrayType(expected, actual, path)
+    def describe_PArrayType(expected, original, actual, path)
       descriptions = []
       element_type = expected.element_type || PAnyType::DEFAULT
       if actual.is_a?(PTupleType)
@@ -822,17 +774,17 @@ module Types
         expected_size = expected.size_type
         actual_size = actual.size_type || PCollectionType::DEFAULT_SIZE
         if expected_size.nil? || expected_size.assignable?(actual_size)
-          descriptions << TypeMismatch.new(path, expected, PArrayType.new(actual.element_type))
+          descriptions << TypeMismatch.new(path, original, PArrayType.new(actual.element_type))
         else
           descriptions << SizeMismatch.new(path, expected_size, actual_size)
         end
       else
-        descriptions << TypeMismatch.new(path, expected, actual)
+        descriptions << TypeMismatch.new(path, original, actual)
       end
       descriptions
     end
 
-    def describe_PHashType(expected, actual, path)
+    def describe_PHashType(expected, original, actual, path)
       descriptions = []
       key_type = expected.key_type || PAnyType::DEFAULT
       value_type = expected.value_type || PAnyType::DEFAULT
@@ -852,17 +804,17 @@ module Types
         expected_size = expected.size_type
         actual_size = actual.size_type || PCollectionType::DEFAULT_SIZE
         if expected_size.nil? || expected_size.assignable?(actual_size)
-          descriptions << TypeMismatch.new(path, expected, PHashType.new(actual.key_type, actual.value_type))
+          descriptions << TypeMismatch.new(path, original, PHashType.new(actual.key_type, actual.value_type))
         else
           descriptions << SizeMismatch.new(path, expected_size, actual_size)
         end
       else
-        descriptions << TypeMismatch.new(path, expected, actual)
+        descriptions << TypeMismatch.new(path, original, actual)
       end
       descriptions
     end
 
-    def describe_PStructType(expected, actual, path)
+    def describe_PStructType(expected, original, actual, path)
       elements = expected.elements
       descriptions = []
       if actual.is_a?(PStructType)
@@ -882,25 +834,25 @@ module Types
         actual_size = actual.size_type || PCollectionType::DEFAULT_SIZE
         expected_size = PIntegerType.new(elements.count { |e| !e.key_type.assignable?(PUndefType::DEFAULT) }, elements.size)
         if expected_size.assignable?(actual_size)
-          descriptions << TypeMismatch.new(path, expected, PHashType.new(actual.key_type, actual.value_type))
+          descriptions << TypeMismatch.new(path, original, PHashType.new(actual.key_type, actual.value_type))
         else
           descriptions << SizeMismatch.new(path, expected_size, actual_size)
         end
       else
-        descriptions << TypeMismatch.new(path, expected, actual)
+        descriptions << TypeMismatch.new(path, original, actual)
       end
       descriptions
     end
 
-    def describe_PTupleType(expected, actual, path)
-      describe_tuple(expected, actual, path, SizeMismatch)
+    def describe_PTupleType(expected, original, actual, path)
+      describe_tuple(expected, original, actual, path, SizeMismatch)
     end
 
     def describe_argument_tuple(expected, actual, path)
-      describe_tuple(expected, actual, path, CountMismatch)
+      describe_tuple(expected, expected, actual, path, CountMismatch)
     end
 
-    def describe_tuple(expected, actual, path, size_mismatch_class)
+    def describe_tuple(expected, original, actual, path, size_mismatch_class)
       return EMPTY_ARRAY if expected == actual || expected.types.empty? && (actual.is_a?(PArrayType))
       expected_size = expected.size_type || TypeFactory.range(*expected.size_range)
 
@@ -928,7 +880,7 @@ module Types
           # Array of anything can not be assigned (unless tuple is tuple of anything) - this case
           # was handled at the top of this method.
           #
-          [TypeMismatch.new(path, expected, actual)]
+          [TypeMismatch.new(path, original, actual)]
         else
           expected_size = expected.size_type || TypeFactory.range(*expected.size_range)
           actual_size = actual.size_type || PCollectionType::DEFAULT_SIZE
@@ -943,11 +895,11 @@ module Types
           end
         end
       else
-        [TypeMismatch.new(path, expected, actual)]
+        [TypeMismatch.new(path, original, actual)]
       end
     end
 
-    def describe_PCallableType(expected, actual, path)
+    def describe_PCallableType(expected, original, actual, path)
       if actual.is_a?(PCallableType)
         # nil param_types means, any other Callable is assignable
         if expected.param_types.nil? && expected.return_type.nil?
@@ -977,12 +929,12 @@ module Types
           end
         end
       else
-        [TypeMismatch.new(path, expected, actual)]
+        [TypeMismatch.new(path, original, actual)]
       end
     end
 
-    def describe_PAnyType(expected, actual, path)
-      expected.assignable?(actual) ? EMPTY_ARRAY : [TypeMismatch.new(path, expected, actual)]
+    def describe_PAnyType(expected, original, actual, path)
+      expected.assignable?(actual) ? EMPTY_ARRAY : [TypeMismatch.new(path, original, actual)]
     end
 
     class UnresolvedTypeFinder
@@ -1008,33 +960,37 @@ module Types
       if unresolved
         [UnresolvedTypeReference.new(path, unresolved)]
       else
-        expected = expected.normalize
-        case expected
-        when PVariantType
-          describe_PVariantType(expected, actual, path)
-        when PStructType
-          describe_PStructType(expected, actual, path)
-        when PHashType
-          describe_PHashType(expected, actual, path)
-        when PTupleType
-          describe_PTupleType(expected, actual, path)
-        when PArrayType
-          describe_PArrayType(expected, actual, path)
-        when PCallableType
-          describe_PCallableType(expected, actual, path)
-        when POptionalType
-          describe_POptionalType(expected, actual, path)
-        when PPatternType
-          describe_PPatternType(expected, actual, path)
-        when PEnumType
-          describe_PEnumType(expected, actual, path)
-        when PTypeAliasType
-          describe_PTypeAliasType(expected, actual, path)
-        else
-          describe_PAnyType(expected, actual, path)
-        end
+        internal_describe(expected.normalize, expected, actual, path)
+      end
+    end
+
+    def internal_describe(expected, original, actual, path)
+      case expected
+      when PVariantType
+        describe_PVariantType(expected, original, actual, path)
+      when PStructType
+        describe_PStructType(expected, original, actual, path)
+      when PHashType
+        describe_PHashType(expected, original, actual, path)
+      when PTupleType
+        describe_PTupleType(expected, original, actual, path)
+      when PArrayType
+        describe_PArrayType(expected, original, actual, path)
+      when PCallableType
+        describe_PCallableType(expected, original, actual, path)
+      when POptionalType
+        describe_POptionalType(expected, original, actual, path)
+      when PPatternType
+        describe_PPatternType(expected, original, actual, path)
+      when PEnumType
+        describe_PEnumType(expected, original, actual, path)
+      when PTypeAliasType
+        describe_PTypeAliasType(expected, original, actual, path)
+      else
+        describe_PAnyType(expected, original, actual, path)
       end
     end
+    private :internal_describe
 
     # Produces a string for the signature(s)
     #