puppet 4.7.1-x86-mingw32 → 4.8.0-x86-mingw32

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

@@ -0,0 +1,69 @@
+module Puppet::Pops
+module Types
+  class PTimestampType < PAbstractTimeDataType
+    def self.register_ptype(loader, ir)
+      create_ptype(loader, ir, 'ScalarType',
+        'from' => { KEY_TYPE => PTimestampType::DEFAULT, KEY_VALUE => :default },
+        'to' => { KEY_TYPE => PTimestampType::DEFAULT, KEY_VALUE => :default }
+      )
+    end
+
+    def self.new_function(_, loader)
+      @new_function ||= Puppet::Functions.create_loaded_function(:new_timestamp, loader) do
+        local_types do
+          type 'Formats = Variant[String[2],Array[String[2]], 1]'
+        end
+
+        dispatch :now do
+        end
+
+        dispatch :from_seconds do
+          param 'Variant[Integer,Float]', :seconds
+        end
+
+        dispatch :from_string do
+          param           'String[1]', :string
+          optional_param  'Formats',   :format
+          optional_param  'String[1]', :timezone
+        end
+
+        dispatch :from_string_hash do
+          param <<-TYPE, :hash_arg
+            Struct[{
+              string => String[1],
+              Optional[format] => Formats,
+              Optional[timezone] => String[1]
+            }]
+          TYPE
+        end
+
+        def now
+          Time::Timestamp.now
+        end
+
+        def from_string(string, format = :default, timezone = nil)
+          Time::Timestamp.parse(string, format, timezone)
+        end
+
+        def from_string_hash(args_hash)
+          Time::Timestamp.from_hash(args_hash)
+        end
+
+        def from_seconds(seconds)
+          Time::Timestamp.new((seconds * Time::NSECS_PER_SEC).to_i)
+        end
+      end
+    end
+
+    def generalize
+      DEFAULT
+    end
+
+    def impl_class
+      Time::Timestamp
+    end
+
+    DEFAULT = PTimestampType.new(nil, nil)
+  end
+end
+end

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

@@ -279,6 +279,7 @@ class StringConverter
     PNumericType::DEFAULT  => Format.new('%d').freeze,    # decimal number
     PArrayType::DEFAULT    => DEFAULT_ARRAY_FORMAT.freeze,
     PHashType::DEFAULT     => DEFAULT_HASH_FORMAT.freeze,
+    PBinaryType::DEFAULT   => Format.new('%B').freeze,    # strict base64 string unquoted
     PAnyType::DEFAULT      => Format.new('%s').freeze,    # unquoted string
   }.freeze
 
@@ -385,6 +386,21 @@ class StringConverter
   # | s         | same as d
   # | p         | same as d
   #
+  # ### Binary (value)
+  #
+  # | Format    | Default formats
+  # | ------    | ---------------
+  # | s         | binary as unquoted characters
+  # | p         | 'Binary("<base64strict>")'
+  # | b         | '<base64>' - base64 string with newlines inserted
+  # | B         | '<base64strict>' - base64 strict string (without newlines inserted)
+  # | u         | '<base64urlsafe>' - base64 urlsafe string
+  # | t         | 'Binary' - outputs the name of the type only
+  # | T         | 'BINARY' - output the name of the type in all caps only
+  #
+  # The alternate form flag `#` will quote the binary or base64 text output
+  # The width and precision values are applied to the text part only in `%p` format.
+  #
   # ### Array & Tuple
   #
   # | Format    | Array/Tuple Formats
@@ -696,6 +712,52 @@ class StringConverter
     end
   end
 
+  # @api private
+  def string_PBinaryType(val_type, val, format_map, _)
+    f = get_format(val_type, format_map)
+    substitute = f.alt? ? 'p' : 's'
+    case f.format
+    when :s
+      val_to_convert = val.binary_buffer
+      if !f.alt?
+        # Assume it is valid UTF-8
+        val_to_convert = val_to_convert.dup.force_encoding('UTF-8')
+        # If it isn't
+        unless val_to_convert.valid_encoding?
+          # try to convert and fail with details about what is wrong
+          val_to_convert = val.binary_buffer.encode('UTF-8')
+        end
+      else
+        val_to_convert = val.binary_buffer
+      end
+      Kernel.format(f.orig_fmt.gsub('s', substitute), val_to_convert)
+
+    when :p
+      # width & precision applied to string, not the the name of the type
+      "Binary(\"#{Kernel.format(f.orig_fmt.gsub('p', 's'), val.to_s)}\")"
+
+    when :b
+      Kernel.format(f.orig_fmt.gsub('b', substitute), val.relaxed_to_s)
+
+    when :B
+      Kernel.format(f.orig_fmt.gsub('B', substitute), val.to_s)
+
+    when :u
+      Kernel.format(f.orig_fmt.gsub('u', substitute), val.urlsafe_to_s)
+
+    when :t
+      # Output as the type without any data
+      Kernel.format(f.orig_fmt.gsub('t', substitute), 'Binary')
+
+    when :T
+      # Output as the type without any data in all caps
+      Kernel.format(f.orig_fmt.gsub('T', substitute), 'BINARY')
+
+    else
+      raise FormatError.new('Binary', f.format, 'bButTsp')
+    end
+  end
+
   # @api private
   def string_PStringType(val_type, val, format_map, _)
     f = get_format(val_type, format_map)

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

@@ -39,7 +39,7 @@ module TypeAsserter
     subject = yield(subject) if block_given?
     subject = subject[0] % subject[1..-1] if subject.is_a?(Array)
     raise TypeAssertionError.new(
-      TypeMismatchDescriber.singleton.describe_mismatch("#{subject} had wrong type,", expected_type, actual_type), expected_type, actual_type)
+      TypeMismatchDescriber.singleton.describe_mismatch("#{subject} has wrong type,", expected_type, actual_type), expected_type, actual_type)
   end
   private_class_method :report_type_mismatch
 end

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

@@ -620,9 +620,8 @@ class TypeCalculator
       max += 1
       PAnyType::DEFAULT
     end
-    mapped_types << min
-    mapped_types << max
-    TypeFactory.callable(*mapped_types)
+    param_types = Types::PTupleType.new(mapped_types, Types::PIntegerType.new(min, max))
+    Types::PCallableType.new(param_types)
   end
 
   # @api private
@@ -648,6 +647,16 @@ class TypeCalculator
     PSensitiveType.new(infer(o.unwrap))
   end
 
+  # @api private
+  def infer_Timespan(o)
+    PTimespanType.new(o, o)
+  end
+
+  # @api private
+  def infer_Timestamp(o)
+    PTimestampType.new(o, o)
+  end
+
   # @api private
   def infer_TrueClass(o)
     PBooleanType::DEFAULT
@@ -678,6 +687,11 @@ class TypeCalculator
     end
   end
 
+  # @api private
+  def infer_Binary(o)
+    PBinaryType::DEFAULT
+  end
+
   # @api private
   def infer_Version(o)
     PSemVerType::DEFAULT

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

@@ -168,6 +168,28 @@ module TypeFactory
     hash.nil? || hash.empty? ? PTypeSetType::DEFAULT : PTypeSetType.new(hash)
   end
 
+  def self.timestamp(*args)
+    case args.size
+    when 0
+      PTimestampType::DEFAULT
+    when 1
+      PTimestampType.new(args[0], args[0])
+    else
+      PTimestampType.new(*args)
+    end
+  end
+
+  def self.timespan(*args)
+    case args.size
+    when 0
+      PTimespanType::DEFAULT
+    when 1
+      PTimespanType.new(args[0], args[0])
+    else
+      PTimespanType.new(*args)
+    end
+  end
+
   def self.tuple(types = [], size_type = nil)
     PTupleType.new(types.map {|elem| type_of(elem) }, size_type)
   end
@@ -250,6 +272,12 @@ module TypeFactory
   # Params are given as a sequence of arguments to {#type_of}.
   #
   def self.callable(*params)
+    if params.size == 2 && params[0].is_a?(Array)
+      return_t = type_of(params[1])
+      params = params[0]
+    else
+      return_t = nil
+    end
     last_callable = TypeCalculator.is_kind_of_callable?(params.last)
     block_t = last_callable ? params.pop : nil
 
@@ -272,7 +300,7 @@ module TypeFactory
     end
     # create a signature
     tuple_t = tuple(types, size_type)
-    PCallableType.new(tuple_t, block_t)
+    PCallableType.new(tuple_t, block_t, return_t)
   end
 
   # Produces the abstract type Collection
@@ -301,6 +329,12 @@ module TypeFactory
     PDefaultType::DEFAULT
   end
 
+  # Creates an instance of the Binary type
+  # @api public
+  def self.binary
+    PBinaryType::DEFAULT
+  end
+
   # Produces an instance of the abstract type PCatalogEntryType
   def self.catalog_entry
     PCatalogEntryType::DEFAULT

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

@@ -69,6 +69,10 @@ class TypeFormatter
   end
 
 
+  def append_default
+    @bld << 'default'
+  end
+
   def append_string(t)
     if @ruby && t.is_a?(PAnyType)
       @ruby = false
@@ -129,6 +133,9 @@ class TypeFormatter
   # @api private
   def string_PNumericType(_) ; @bld << 'Numeric' ; end
 
+  # @api private
+  def string_PBinaryType(_)  ; @bld << 'Binary' ; end
+
   # @api private
   def string_PIntegerType(t)
     append_array('Integer', t.unbounded?) { append_elements(range_array_part(t)) }
@@ -193,6 +200,32 @@ class TypeFormatter
     @bld << 'SemVerRange'
   end
 
+  # @api private
+  def string_PTimestampType(t)
+    min = t.from
+    max = t.to
+    append_array('Timestamp', min.nil? && max.nil?) do
+      min.nil? ? append_default : append_string(min)
+      unless max.nil? || max == min
+        @bld << COMMA_SEP
+        append_string(max)
+      end
+    end
+  end
+
+  # @api private
+  def string_PTimespanType(t)
+    min = t.from
+    max = t.to
+    append_array('Timespan', min.nil? && max.nil?) do
+      min.nil? ? append_default : append_string(min)
+      unless max.nil? || max == min
+        @bld << COMMA_SEP
+        append_string(max)
+      end
+    end
+  end
+
   # @api private
   def string_PTupleType(t)
     append_array('Tuple', t.types.empty?) do
@@ -204,21 +237,35 @@ class TypeFormatter
 
   # @api private
   def string_PCallableType(t)
-    append_array('Callable', t.param_types.nil?) do
-      # translate to string, and skip Unit types
-      append_strings(t.param_types.types.reject {|t2| t2.class == PUnitType }, true)
-
-      if t.param_types.types.empty?
-        append_strings([0, 0], true)
+    if t.return_type.nil?
+      append_array('Callable', t.param_types.nil?) { append_callable_params(t) }
+    else
+      if t.param_types.nil?
+        append_array('Callable', false) { append_strings([[], t.return_type], false) }
       else
-        append_elements(range_array_part(t.param_types.size_type), true)
+        append_array('Callable', false) do
+          append_array('', false) { append_callable_params(t) }
+          @bld << COMMA_SEP
+          append_string(t.return_type)
+        end
       end
+    end
+  end
 
-      # Add block T last (after min, max) if present)
-      #
-      append_strings([t.block_type], true) unless t.block_type.nil?
-      chomp_list
+  def append_callable_params(t)
+    # translate to string, and skip Unit types
+    append_strings(t.param_types.types.reject {|t2| t2.class == PUnitType }, true)
+
+    if t.param_types.types.empty?
+      append_strings([0, 0], true)
+    else
+      append_elements(range_array_part(t.param_types.size_type), true)
     end
+
+    # Add block T last (after min, max) if present)
+    #
+    append_strings([t.block_type], true) unless t.block_type.nil?
+    chomp_list
   end
 
   # @api private
@@ -460,6 +507,12 @@ class TypeFormatter
   # @api private
   def string_VersionRange(t) ; @bld << "'#{t}'"  ; end
 
+  # @api private
+  def string_Timespan(t)    ; @bld << "'#{t}'"  ; end
+
+  # @api private
+  def string_Timestamp(t)    ; @bld << "'#{t}'"  ; end
+
   # Debugging to_s to reduce the amount of output
   def to_s
     '[a TypeFormatter]'

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

@@ -1,5 +1,6 @@
 module Puppet::Pops
 module Types
+  # @api private
   class TypePathElement
     attr_reader :key
 
@@ -20,30 +21,46 @@ module Types
     end
    end
 
+  # @api private
   class SubjectPathElement < TypePathElement
     def to_s
       key
     end
   end
 
+  # @api private
   class EntryValuePathElement < TypePathElement
     def to_s
       "entry '#{key}'"
     end
   end
 
+  # @api private
   class EntryKeyPathElement < TypePathElement
     def to_s
       "key of entry '#{key}'"
     end
   end
 
+  # @api private
   class ParameterPathElement < TypePathElement
     def to_s
       "parameter '#{key}'"
     end
   end
 
+  # @api private
+  class ReturnTypeElement < TypePathElement
+    def initialize(name = 'return')
+      super(name)
+    end
+
+    def to_s
+      key
+    end
+  end
+
+  # @api private
   class BlockPathElement < ParameterPathElement
     def initialize(name = 'block')
       super(name)
@@ -54,18 +71,21 @@ module Types
     end
   end
 
+  # @api private
   class ArrayPathElement < TypePathElement
     def to_s
       "index #{key}"
     end
   end
 
+  # @api private
   class VariantPathElement < TypePathElement
     def to_s
       "variant #{key}"
     end
   end
 
+  # @api private
   class SignaturePathElement < VariantPathElement
     def to_s
       "#{key+1}."
@@ -77,6 +97,8 @@ module Types
   # 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
@@ -115,8 +137,8 @@ module Types
     end
   end
 
+  # @api private
   class Mismatch
-    include TenseVariants
     attr_reader :path
 
     def initialize(path)
@@ -127,7 +149,7 @@ module Types
       @canonical_path ||= @path.reject { |e| e.is_a?(VariantPathElement) }
     end
 
-    def message(variant, position, tense = :present)
+    def message(variant, position)
       "#{variant}unknown mismatch#{position}"
     end
 
@@ -161,10 +183,10 @@ module Types
     end
 
     def to_s
-      format(:present)
+      format
     end
 
-    def format(tense)
+    def format
       p = @path
       variant = ''
       position = ''
@@ -176,11 +198,12 @@ module Types
         end
         position = " #{p.join(' ')}" unless p.empty?
       end
-      message(variant, position, tense)
+      message(variant, position)
     end
   end
 
   # @abstract
+  # @api private
   class KeyMismatch < Mismatch
     attr_reader :key
 
@@ -198,42 +221,49 @@ module Types
     end
   end
 
+  # @api private
   class MissingKey < KeyMismatch
-    def message(variant, position, tense = :present)
-      "#{variant}#{position} #{it_expects(tense)} a value for key '#{key}'"
+    def message(variant, position)
+      "#{variant}#{position} expects a value for key '#{key}'"
     end
   end
 
+  # @api private
   class MissingParameter < KeyMismatch
-    def message(variant, position, tense = :present)
-      "#{variant}#{position} #{it_expects(tense)} a value for parameter '#{key}'"
+    def message(variant, position)
+      "#{variant}#{position} expects a value for parameter '#{key}'"
     end
   end
 
+  # @api private
   class ExtraneousKey < KeyMismatch
-    def message(variant, position, tense = :present)
+    def message(variant, position)
       "#{variant}#{position} unrecognized key '#{@key}'"
     end
   end
 
+  # @api private
   class InvalidParameter < ExtraneousKey
-    def message(variant, position, tense = :present)
-      "#{variant}#{position} #{it_has_no(tense)} parameter named '#{@key}'"
+    def message(variant, position)
+      "#{variant}#{position} has no parameter named '#{@key}'"
     end
   end
 
+  # @api private
   class UnexpectedBlock < Mismatch
-    def message(variant, position, tense = :present)
-      "#{variant}#{position} #{it_does_not_expect(tense)} a block"
+    def message(variant, position)
+      "#{variant}#{position} does not expect a block"
     end
   end
 
+  # @api private
   class MissingRequiredBlock < Mismatch
-    def message(variant, position, tense = :present)
-      "#{variant}#{position} #{it_expects(tense)} a block"
+    def message(variant, position)
+      "#{variant}#{position} expects a block"
     end
   end
 
+  # @api private
   class UnresolvedTypeReference < Mismatch
     attr_reader :unresolved
 
@@ -250,11 +280,12 @@ module Types
       @unresolved.hash
     end
 
-    def message(variant, position, tense = :present)
-      "#{variant}#{position} #{it_references(tense)} an unresolved type '#{@unresolved}'"
+    def message(variant, position)
+      "#{variant}#{position} references an unresolved type '#{@unresolved}'"
     end
   end
 
+  # @api private
   class ExpectedActualMismatch < Mismatch
     attr_reader :expected, :actual
 
@@ -279,6 +310,7 @@ module Types
     end
   end
 
+  # @api private
   class TypeMismatch < ExpectedActualMismatch
     include LabelProvider
 
@@ -287,7 +319,7 @@ module Types
       self.class.new(path, [expected, o.expected].flatten.uniq, actual)
     end
 
-    def message(variant, position, tense = :present)
+    def message(variant, position)
       e = expected
       a = actual
       multi = false
@@ -321,9 +353,9 @@ module Types
         end
       end
       if multi
-        "#{variant}#{position} #{it_expects(tense)} a value of type #{e}, got #{label(a)}"
+        "#{variant}#{position} expects a value of type #{e}, got #{label(a)}"
       else
-        "#{variant}#{position} #{it_expects(tense)} #{a_an(e)} value, got #{label(a)}"
+        "#{variant}#{position} expects #{a_an(e)} value, got #{label(a)}"
       end
     end
 
@@ -424,9 +456,10 @@ module Types
     end
   end
 
+  # @api private
   class PatternMismatch < TypeMismatch
-    def message(variant, position, tense = :present)
-      "#{variant}#{position} #{it_expects(tense)} a match for #{expected.to_alias_expanded_s}, got #{actual_string}"
+    def message(variant, position)
+      "#{variant}#{position} expects a match for #{expected.to_alias_expanded_s}, got #{actual_string}"
     end
 
     def actual_string
@@ -435,6 +468,7 @@ module Types
     end
   end
 
+  # @api private
   class SizeMismatch < ExpectedActualMismatch
     def from
       @expected.from || 0
@@ -450,8 +484,8 @@ module Types
       self.class.new(path, range, @actual)
     end
 
-    def message(variant, position, tense = :present)
-      "#{variant}#{position} #{it_expects(tense)} size to be #{range_to_s(expected, '0')}, got #{range_to_s(actual, '0')}"
+    def message(variant, position)
+      "#{variant}#{position} expects size to be #{range_to_s(expected, '0')}, got #{range_to_s(actual, '0')}"
     end
 
     def range_to_s(range, zero_string)
@@ -469,22 +503,22 @@ module Types
     end
   end
 
+  # @api private
   class CountMismatch < SizeMismatch
     def initialize(path, expected, actual)
       super(path, expected, actual)
     end
 
-    def message(variant, position, tense = :present)
+    def message(variant, position)
       min = expected.from || 0
       max = expected.to || Float::INFINITY
       suffix = min == 1 && (max == 1 || max == Float::INFINITY) || min == 0 && max == 1 ? '' : 's'
-      "#{variant}#{position} #{it_expects(tense)} #{range_to_s(expected, 'no')} argument#{suffix}, got #{range_to_s(actual, 'none')}"
+      "#{variant}#{position} expects #{range_to_s(expected, 'no')} argument#{suffix}, got #{range_to_s(actual, 'none')}"
     end
   end
 
+  # @api private
   class TypeMismatchDescriber
-    include TenseVariants
-
     def self.validate_parameters(subject, params_struct, given_hash, missing_ok = false)
       singleton.validate_parameters(subject, params_struct, given_hash, missing_ok)
     end
@@ -501,6 +535,10 @@ module Types
       @singleton ||= new
     end
 
+    def tense_deprecated
+      Puppet.warn_once(:deprecation, 'typemismatch#tense', "Passing a 'tense' argument to the TypeMismatchDescriber is deprecated and ignored. Everything is now reported using present tense")
+    end
+
     # Validates that all entries in the give_hash exists in the given param_struct, that their type conforms
     # with the corresponding param_struct element and that all required values are provided.
     #
@@ -508,16 +546,17 @@ module Types
     # @param params_struct [PStructType] Struct to use for validation
     # @param given_hash [Hash<String,Object>] the parameters to validate
     # @param missing_ok [Boolean] Do not generate errors on missing parameters
-    # @param tense [Symbol] the symbol :present or :past
+    # @param tense [Symbol] deprecated and ignored
     #
-    def validate_parameters(subject, params_struct, given_hash, missing_ok = false, tense = :present)
+    def validate_parameters(subject, params_struct, given_hash, missing_ok = false, tense = :ignored)
+      tense_deprecated unless tense == :ignored
       errors = describe_struct_signature(params_struct, given_hash, missing_ok).flatten
       case errors.size
       when 0
       when 1
-        raise Puppet::ParseError.new("#{subject}:#{errors[0].format(tense)}")
+        raise Puppet::ParseError.new("#{subject}:#{errors[0].format}")
       else
-        errors_str = errors.map { |error| error.format(tense) }.join("\n ")
+        errors_str = errors.map { |error| error.format }.join("\n ")
         raise Puppet::ParseError.new("#{subject}:\n #{errors_str}")
       end
     end
@@ -527,17 +566,18 @@ module Types
     # @param name [String] name of mismatch
     # @param expected [PAnyType] expected type
     # @param actual [PAnyType] actual type
-    # @param tense [Symbol] the symbol :present or :past
+    # @param tense [Symbol] deprecated and ignored
     #
-    def describe_mismatch(name, expected, actual, tense = :past)
+    def describe_mismatch(name, expected, actual, tense = :ignored)
+      tense_deprecated unless tense == :ignored
       errors = describe(expected, actual, [SubjectPathElement.new(name)])
       case errors.size
       when 0
         ''
       when 1
-        errors[0].format(tense).strip
+        errors[0].format.strip
       else
-        errors.map { |error| error.format(tense) }.join("\n ")
+        errors.map { |error| error.format }.join("\n ")
       end
     end
 
@@ -545,17 +585,18 @@ module Types
     # @param param_name [String] parameter name
     # @param param_type [PAnyType] parameter type
     # @param value [Object] value to be validated against the given type
-    # @param tense [Symbol] the symbol :present or :past
+    # @param tense [Symbol] deprecated and ignored
     #
-    def validate_default_parameter(subject, param_name, param_type, value, tense = :present)
+    def validate_default_parameter(subject, param_name, param_type, value, tense = :ignored)
+      tense_deprecated unless tense == :ignored
       unless param_type.instance?(value)
         errors = describe(param_type, TypeCalculator.singleton.infer_set(value).generalize, [ParameterPathElement.new(param_name)])
         case errors.size
         when 0
         when 1
-          raise Puppet::ParseError.new("#{subject}:#{errors[0].format(tense)}")
+          raise Puppet::ParseError.new("#{subject}:#{errors[0].format}")
         else
-          errors_str = errors.map { |error| error.format(tense) }.join("\n ")
+          errors_str = errors.map { |error| error.format }.join("\n ")
           raise Puppet::ParseError.new("#{subject}:\n #{errors_str}")
         end
       end
@@ -578,7 +619,7 @@ module Types
         value = param_hash[name]
         value_type = elem.value_type
         if param_hash.include?(name)
-          result << describe(value_type, TypeCalculator.singleton.infer_set(value).generalize, [ParameterPathElement.new(name)]) unless value_type.instance?(value)
+          result << describe(value_type, TypeCalculator.singleton.infer_set(value), [ParameterPathElement.new(name)]) unless value_type.instance?(value)
         else
           result << MissingParameter.new(nil, name) unless elem.key_type.assignable?(PUndefType::DEFAULT) unless missing_ok
         end
@@ -586,7 +627,8 @@ module Types
       result
     end
 
-    def describe_signatures(closure, signatures, args_tuple, tense = :present)
+    def describe_signatures(closure, signatures, args_tuple, tense = :ignored)
+      tense_deprecated unless tense == :ignored
       error_arrays = []
       signatures.each_with_index do |signature, index|
         error_arrays << describe_signature_arguments(signature, args_tuple, [SignaturePathElement.new(index)])
@@ -612,17 +654,17 @@ module Types
       label = closure == 'lambda' ? 'block' : "'#{closure}'"
       errors = merge_descriptions(0, CountMismatch, error_arrays)
       if errors.size == 1
-        "#{label}#{errors[0].format(tense)}"
+        "#{label}#{errors[0].format}"
       else
         if signatures.size == 1
           sig = signatures[0]
-          result = ["#{label} #{it_expects(tense)} (#{signature_string(sig)})"]
-          result.concat(error_arrays[0].map { |e| "  rejected:#{e.chop_path(0).format(tense)}" })
+          result = ["#{label} expects (#{signature_string(sig)})"]
+          result.concat(error_arrays[0].map { |e| "  rejected:#{e.chop_path(0).format}" })
         else
-          result = ["#{label} #{it_expects(tense)} one of:"]
+          result = ["#{label} expects one of:"]
           signatures.each_with_index do |sg, index|
             result << "  (#{signature_string(sg)})"
-            result.concat(error_arrays[index].map { |e| "    rejected:#{e.chop_path(0).format(tense)}" })
+            result.concat(error_arrays[index].map { |e| "    rejected:#{e.chop_path(0).format}" })
           end
         end
         result.join("\n")
@@ -840,7 +882,7 @@ module Types
     end
 
     def describe_tuple(expected, actual, path, size_mismatch_class)
-      return if expected == actual || expected.types.empty? && (actual.is_a?(PArrayType))
+      return EMPTY_ARRAY if expected == actual || expected.types.empty? && (actual.is_a?(PArrayType))
       expected_size = expected.size_type || TypeFactory.range(*expected.size_range)
 
       if actual.is_a?(PTupleType)
@@ -850,10 +892,11 @@ module Types
         if expected_size.assignable?(actual_size)
           etypes = expected.types
           descriptions = []
-          actual.types.each_with_index do |atype, index|
-            adx = index >= etypes.size ? etypes.size - 1 : index
-            etype = etypes[adx]
-            descriptions.concat(describe(etypes[adx], atype, path + [ArrayPathElement.new(adx)]))
+          unless etypes.empty?
+            actual.types.each_with_index do |atype, index|
+              adx = index >= etypes.size ? etypes.size - 1 : index
+              descriptions.concat(describe(etypes[adx], atype, path + [ArrayPathElement.new(adx)]))
+            end
           end
           descriptions
         else
@@ -888,21 +931,27 @@ module Types
     def describe_PCallableType(expected, actual, path)
       if actual.is_a?(PCallableType)
         # nil param_types means, any other Callable is assignable
-        if expected.param_types.nil?
+        if expected.param_types.nil? && expected.return_type.nil?
           EMPTY_ARRAY
         else
           # NOTE: these tests are made in reverse as it is calling the callable that is constrained
           # (it's lower bound), not its upper bound
           param_errors = describe_argument_tuple(expected.param_types, actual.param_types, path)
           if param_errors.empty?
-            # names are ignored, they are just information
-            # Blocks must be compatible
-            this_block_t = expected.block_type || PUndefType::DEFAULT
-            that_block_t = actual.block_type || PUndefType::DEFAULT
-            if that_block_t.assignable?(this_block_t)
-              EMPTY_ARRAY
+            this_return_t = expected.return_type || PAnyType::DEFAULT
+            that_return_t = actual.return_type || PAnyType::DEFAULT
+            unless this_return_t.assignable?(that_return_t)
+              [TypeMismatch.new(path + [ReturnTypeElement.new], this_return_t, that_return_t)]
             else
-              [TypeMismatch.new(path + BlockPathElement.new, this_block_t, that_block_t)]
+              # names are ignored, they are just information
+              # Blocks must be compatible
+              this_block_t = expected.block_type || PUndefType::DEFAULT
+              that_block_t = actual.block_type || PUndefType::DEFAULT
+              if that_block_t.assignable?(this_block_t)
+                EMPTY_ARRAY
+              else
+                [TypeMismatch.new(path + [BlockPathElement.new], this_block_t, that_block_t)]
+              end
             end
           else
             param_errors