puppet 3.8.7 → 4.0.0.rc1

data/lib/puppet/pops/parser/locator.rb

@@ -1,38 +1,14 @@
 # Helper class that keeps track of where line breaks are located and can answer questions about positions.
 #
 class Puppet::Pops::Parser::Locator
-
-  RUBY_1_9_3 = (1 << 16 | 9 << 8 | 3)
-  RUBY_2_0_0 = (2 << 16 | 0 << 8 | 0)
-  RUBYVER_ARRAY = RUBY_VERSION.split(".").collect {|s| s.to_i }
-  RUBYVER = (RUBYVER_ARRAY[0] << 16 | RUBYVER_ARRAY[1] << 8 | RUBYVER_ARRAY[2])
-
-  # Computes a symbol representing which ruby runtime this is running on
-  # This implementation will fail if there are more than 255 minor or micro versions of ruby
-  #
-  def self.locator_version
-    if RUBYVER >= RUBY_2_0_0
-      :ruby20
-    elsif RUBYVER >= RUBY_1_9_3
-      :ruby19
-    else
-      :ruby18
-    end
-  end
-  LOCATOR_VERSION = locator_version
-
-  # Constant set to true if multibyte is supported (includes multibyte extended regular expressions)
-  MULTIBYTE = !!(LOCATOR_VERSION == :ruby19 || LOCATOR_VERSION == :ruby20)
-
   # Creates, or recreates a Locator. A Locator is created if index is not given (a scan is then
   # performed of the given source string.
   #
-  def self.locator(string, file, index = nil)
-    case LOCATOR_VERSION
-    when :ruby20, :ruby19
-      Locator19.new(string, file, index)
+  def self.locator(string, file, index = nil, char_offsets = false)
+    if(char_offsets)
+      LocatorForChars.new(string, file, index);
     else
-      Locator18.new(string, file, index)
+      Locator19.new(string, file, index)
     end
   end
 
@@ -162,7 +138,7 @@ class Puppet::Pops::Parser::Locator
       @prev_offset = nil
       @prev_line = nil
       @line_index = index
-      compute_line_index unless !index.nil?
+      compute_line_index if index.nil?
     end
 
     # Returns the position on line (first position on a line is 1)
@@ -247,7 +223,7 @@ class Puppet::Pops::Parser::Locator
     end
   end
 
-  class Locator18 < AbstractLocator
+  class LocatorForChars < AbstractLocator
 
     def offset_on_line(offset)
       line_offset = line_index[ line_for_offset(offset)-1 ]

data/lib/puppet/pops/parser/parser_support.rb

@@ -93,8 +93,11 @@ class Puppet::Pops::Parser::Parser
     else
       value_at = "'#{value[:value]}'"
     end
-    error = Puppet::Pops::Issues::SYNTAX_ERROR.format(:where => value_at)
-    error = "#{error}, token: #{token}" if @yydebug
+    if @yydebug
+      error = "Syntax error at #{value_at}, token: #{token}"
+    else
+      error = "Syntax error at #{value_at}"
+    end
 
     # Note, old parser had processing of "expected token here" - do not try to reinstate:
     # The 'expected' is only of value at end of input, otherwise any parse error involving a
@@ -107,19 +110,19 @@ class Puppet::Pops::Parser::Parser
     # must be handled by the grammar. The lexer may have enqueued tokens far ahead - the lexer's opinion about this
     # is not trustworthy.
     #
-    file = nil
-    line = nil
-    pos  = nil
+
+    except = Puppet::ParseError.new(error)
     if token != 0
-      file = value[:file]
-      line = value[:line]
-      pos  = value[:pos]
+      path        = value[:file]
+      except.line = value[:line]
+      except.pos  = value[:pos]
     else
       # At end of input, use what the lexer thinks is the source file
-      file = lexer.file
+      path        = lexer.file
     end
-    file = nil unless file.is_a?(String) && !file.empty?
-    raise Puppet::ParseErrorWithIssue.new(error, file, line, pos, nil, issue_code = Puppet::Pops::Issues::SYNTAX_ERROR.issue_code)
+    except.file = path if path.is_a?(String) && !path.empty?
+
+    raise except
   end
 
   # Parses a String of pp DSL code.

data/lib/puppet/pops/parser/slurp_support.rb

@@ -7,13 +7,10 @@
 # TODO: More detailed performance analysis of excessive character escaping and interpolation.
 #
 module Puppet::Pops::Parser::SlurpSupport
-  include Puppet::Pops::Parser::LexerSupport
 
   SLURP_SQ_PATTERN  = /(?:[^\\]|^|[^\\])(?:[\\]{2})*[']/
   SLURP_DQ_PATTERN  = /(?:[^\\]|^|[^\\])(?:[\\]{2})*(["]|[$]\{?)/
   SLURP_UQ_PATTERN  = /(?:[^\\]|^|[^\\])(?:[\\]{2})*([$]\{?|\z)/
-  # unquoted, no escapes
-  SLURP_UQNE_PATTERN  = /(\$\{?|\z)/m
   SLURP_ALL_PATTERN = /.*(\z)/m
   SQ_ESCAPES = %w{ \\ ' }
   DQ_ESCAPES = %w{ \\  $ ' " r n t s u}+["\r\n", "\n"]
@@ -22,8 +19,7 @@ module Puppet::Pops::Parser::SlurpSupport
   def slurp_sqstring
     # skip the leading '
     @scanner.pos += 1
-    str = slurp(@scanner, SLURP_SQ_PATTERN, SQ_ESCAPES, :ignore_invalid_escapes)
-    lex_error(Puppet::Pops::Issues::UNCLOSED_QUOTE, :after => "\"'\"", :followed_by => followed_by) unless str
+    str = slurp(@scanner, SLURP_SQ_PATTERN, SQ_ESCAPES, :ignore_invalid_escapes) || lex_error("Unclosed quote after \"'\" followed by '#{followed_by}'")
     str[0..-2] # strip closing "'" from result
   end
 
@@ -32,7 +28,7 @@ module Puppet::Pops::Parser::SlurpSupport
     last = scn.matched
     str = slurp(scn, SLURP_DQ_PATTERN, DQ_ESCAPES, false)
     unless str
-      lex_error(Puppet::Pops::Issues::UNCLOSED_QUOTE, :after => format_quote(last), :followed_by => followed_by)
+      lex_error("Unclosed quote after #{format_quote(last)} followed by '#{followed_by}'")
     end
 
     # Terminator may be a single char '"', '$', or two characters '${' group match 1 (scn[1]) from the last slurp holds this
@@ -45,7 +41,6 @@ module Puppet::Pops::Parser::SlurpSupport
      scn = @scanner
      last = scn.matched
      ignore = true
-
      str = slurp(scn, @lexing_context[:uq_slurp_pattern], @lexing_context[:escapes], :ignore_invalid_escapes)
 
      # Terminator may be a single char '$', two characters '${', or empty string '' at the end of intput.
@@ -70,12 +65,11 @@ module Puppet::Pops::Parser::SlurpSupport
     # Process unicode escapes first as they require getting 4 hex digits
     # If later a \u is found it is warned not to be a unicode escape
     if escapes.include?('u')
-      str.gsub!(/\\u(?:([\da-fA-F]{4})|\{([\da-fA-F]{1,6})\})/m) {
-        [($1 || $2).hex].pack("U")
+      str.gsub!(/\\u([\da-fA-F]{4})/m) {
+        [$1.hex].pack("U")
       }
     end
 
-    begin
     str.gsub!(/\\([^\r\n]|(?:\r?\n))/m) {
       ch = $1
       if escapes.include? ch
@@ -85,27 +79,17 @@ module Puppet::Pops::Parser::SlurpSupport
         when 't'   ; "\t"
         when 's'   ; " "
         when 'u'
-          lex_warning(Puppet::Pops::Issues::ILLEGAL_UNICODE_ESCAPE)
+          Puppet.warning(positioned_message("Unicode escape '\\u' was not followed by 4 hex digits"))
           "\\u"
         when "\n"  ; ''
         when "\r\n"; ''
         else      ch
         end
       else
-        lex_warning(Puppet::Pops::Issues::UNRECOGNIZED_ESCAPE, :ch => ch) unless ignore_invalid_escapes
+        Puppet.warning(positioned_message("Unrecognized escape sequence '\\#{ch}'")) unless ignore_invalid_escapes
         "\\#{ch}"
       end
     }
-    rescue ArgumentError => e
-      # A invalid byte sequence may be the result of faulty input as well, but that could not possibly
-      # have reached this far... Unfortunately there is no more specific error and a match on message is
-      # required to differentiate from other internal problems.
-      if e.message =~ /invalid byte sequence/
-        lex_error(Puppet::Pops::Issues::ILLEGAL_UNICODE_ESCAPE)
-      else
-        raise e
-      end
-    end
     str
   end
 end

data/lib/puppet/pops/patterns.rb

@@ -38,9 +38,6 @@ module Puppet::Pops::Patterns
   # Note, that only the final segment may start with an underscore.
   VAR_NAME = %r{\A(:?(::)?[a-z]\w*)*(:?(::)?[a-z_]\w*)\z}
 
-  # PARAM_NAME matches the name part of a parameter (The $ character is not included)
-  PARAM_NAME = %r{\A[a-z_]\w*\z}
-
   # A Numeric var name must be the decimal number 0, or a decimal number not starting with 0
   NUMERIC_VAR_NAME = %r{\A(?:0|(?:[1-9][0-9]*))\z}
 

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

@@ -5,7 +5,7 @@ require 'rgen/metamodel_builder'
 # This means it can load a class from a gem, or from puppet modules.
 #
 class Puppet::Pops::Types::ClassLoader
-  @autoloader = Puppet::Util::Autoload.new("ClassLoader", "", :wrap => false)
+  @autoloader = Puppet::Util::Autoload.new("ClassLoader", "")
 
   # Returns a Class given a fully qualified class name.
   # Lookup of class is never relative to the calling namespace.
@@ -89,7 +89,7 @@ class Puppet::Pops::Types::ClassLoader
     unless result.is_a?(Class)
       # Attempt to load it using the auto loader
       loaded_path = nil
-      if paths_for_name(name).find {|path| loaded_path = path; @autoloader.load(path) }
+      if paths_for_name(name_path).find {|path| loaded_path = path; @autoloader.load(path, Puppet.lookup(:current_environment)) }
         result = find_class(name_path)
         unless result.is_a?(Class)
           raise RuntimeError, "Loading of #{name} using relative path: '#{loaded_path}' did not create expected class"
@@ -110,12 +110,12 @@ class Puppet::Pops::Types::ClassLoader
     end
   end
 
-  def self.paths_for_name(fq_name)
-    [de_camel(fq_name), downcased_path(fq_name)]
-  end
-
-  def self.downcased_path(fq_name)
-    fq_name.to_s.gsub(/::/, '/').downcase
+  def self.paths_for_name(fq_named_parts)
+    # search two entries, one where all parts are decamelized, and one with names just downcased
+    # TODO:this is not perfect - it will not produce the correct mix if a mix of styles are used
+    # The alternative is to test many additional paths.
+    #
+    [fq_named_parts.map {|part| de_camel(part)}.join('/'), fq_named_parts.join('/').downcase ]
   end
 
   def self.de_camel(fq_name)

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

@@ -15,7 +15,7 @@ class Puppet::Pops::Types::Enumeration
     case o
     when String
       x = o.chars
-      # Ruby 1.8.7 returns Enumerable::Enumerator, Ruby 1.8.9 Enumerator, and 2.0.0 an Array
+      # Ruby 1.9.3 returns an Enumerator, and 2.0.0 an Array
       x.is_a?(Array) ? x.each : x
     when Integer
       o.times

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

@@ -0,0 +1,45 @@
+# Utility module for type assertion
+#
+module Puppet::Pops::Types::TypeAsserter
+  # Asserts that a type_to_check is assignable to required_type and raises
+  # a {Puppet::ParseError} if that's not the case
+  #
+  # @param subject [String] String to be prepended to the exception message
+  # @param expected_type [PAnyType] Expected type
+  # @param type_to_check [PAnyType] Type to check against the required type
+  # @return The type_to_check argument
+  #
+  def self.assert_assignable(subject, expected_type, type_to_check)
+    check_assignability(Puppet::Pops::Types::TypeCalculator.singleton, subject, expected_type, type_to_check)
+    type_to_check
+  end
+
+  # Asserts that a value is an instance of a given type and raises
+  # a {Puppet::ParseError} if that's not the case
+  #
+  # @param subject [String] String to be prepended to the exception message
+  # @param expected_type [PAnyType] Expected type for the value
+  # @param value [Object] Value to check
+  # @param nil_ok [Boolean] Can be true to allow nil value. Optional and defaults to false
+  # @return The value argument
+  #
+  def self.assert_instance_of(subject, expected_type, value, nil_ok = false)
+    if !(value.nil? && nil_ok)
+      tc = Puppet::Pops::Types::TypeCalculator.singleton
+      check_assignability(tc, subject, expected_type, tc.infer_set(value), true)
+    end
+    value
+  end
+
+  def self.check_assignability(tc, subject, expected_type, actual_type, inferred = false)
+    unless tc.assignable?(expected_type, actual_type)
+      # Do not give all the details for inferred types - i.e. format as Integer, instead of Integer[n, n] for exact
+      # value, which is just confusing. (OTOH: may need to revisit, or provide a better "type diff" output).
+      #
+      actual_type = Puppet::Pops::Types::TypeCalculator.generalize!(actual_type) if inferred
+      raise Puppet::Pops::Types::TypeAssertionError.new(
+        "#{subject} value has wrong type, expected #{tc.string(expected_type)}, actual #{tc.string(actual_type)}", expected_type, actual_type)
+    end
+  end
+  private_class_method :check_assignability
+end

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

@@ -0,0 +1,26 @@
+module Puppet::Pops::Types
+  # Raised when an assertion of actual type against an expected type fails.
+  #
+  class TypeAssertionError < Puppet::Error
+
+    # Returns the expected type
+    # @return [PAnyType] expected type
+    attr_reader :expected_type
+
+    # Returns the actual type
+    # @return [PAnyType] actual type
+    attr_reader :actual_type
+
+    # Creates a new instance with a default message, expected, and actual types,
+    #
+    # @param message [String] The default message
+    # @param expected_type [PAnyType] The expected type
+    # @param actual_type [PAnyType] The actual type
+    #
+    def initialize(message, expected_type, actual_type)
+      super(message)
+      @expected_type = expected_type
+      @actual_type = actual_type
+    end
+  end
+end

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

@@ -99,7 +99,6 @@
 class Puppet::Pops::Types::TypeCalculator
 
   Types = Puppet::Pops::Types
-  TheInfinity = 1.0 / 0.0 # because the Infinity symbol is not defined
 
   # @api public
   def self.assignable?(t1, t2)
@@ -269,21 +268,14 @@ class Puppet::Pops::Types::TypeCalculator
     if t2.is_a?(Class)
       t2 = type(t2)
     end
-    t2_class = t2.class
-
     # Unit can be assigned to anything
-    return true if t2_class == Types::PUnitType
+    return true if t2.class == Types::PUnitType
 
-    if t2_class == Types::PVariantType
+    if t2.class == Types::PVariantType
       # Assignable if all contained types are assignable
       t2.types.all? { |vt| @@assignable_visitor.visit_this_1(self, t, vt) }
     else
-      # Turn NotUndef[T] into T when T is not assignable from Undef
-      if t2_class == Types::PNotUndefType && !(t2.type.nil? || assignable?(t2.type, @nil_t))
-        assignable?(t, t2.type)
-      else
-        @@assignable_visitor.visit_this_1(self, t, t2)
-      end
+      @@assignable_visitor.visit_this_1(self, t, t2)
     end
  end
 
@@ -361,23 +353,10 @@ class Puppet::Pops::Types::TypeCalculator
     # do nothing, there is nothing to change for most types
   end
 
-  # @return [Boolean] true if the given argument is contained in a struct element key
-  def is_struct_element_key?(o)
-    c = o.eContainer
-    if c.is_a?(Types::POptionalType)
-      o = c
-      c = c.eContainer
-    end
-    c.is_a?(Types::PStructElement) && c.key_type.equal?(o)
-  end
-  private :is_struct_element_key?
-
   def generalize_PStringType(o)
-    # Skip generalization if the string is contained in a PStructElement key.
-    unless is_struct_element_key?(o)
-      o.values = []
-      o.size_type = nil
-    end
+    o.values = []
+    o.size_type = nil
+    []
   end
 
   def generalize_PCollectionType(o)
@@ -454,13 +433,8 @@ class Puppet::Pops::Types::TypeCalculator
   def instance_of_PStringType(t, o)
     return false unless o.is_a?(String)
     # true if size compliant
-    size_t = t.size_type
-    if size_t.nil? || instance_of_PIntegerType(size_t, o.size)
-      values = t.values
-      values.empty? || values.include?(o)
-    else
-      false
-    end
+    size_t = t.size_type || @collection_default_size_t
+    instance_of_PIntegerType(size_t, o.size)
   end
 
   def instance_of_PTupleType(t, o)
@@ -477,18 +451,9 @@ class Puppet::Pops::Types::TypeCalculator
 
   def instance_of_PStructType(t, o)
     return false unless o.is_a?(Hash)
-    matched = 0
-    t.elements.all? do |e|
-      key = e.name
-      v = o[key]
-      if v.nil? && !o.include?(key)
-        # Entry is missing. Only OK when key is optional
-        assignable?(e.key_type, @nil_t)
-      else
-        matched += 1
-        instance_of(e.value_type, v)
-      end
-    end && matched == o.size
+    h = t.hashed_elements
+    # all keys must be present and have a value (even if nil/undef)
+    (o.keys - h.keys).empty? && h.all? { |k,v| instance_of(v, o[k]) }
   end
 
   def instance_of_PHashType(t, o)
@@ -505,10 +470,6 @@ class Puppet::Pops::Types::TypeCalculator
     instance_of(@data_variant_t, o)
   end
 
-  def instance_of_PNotUndefType(t, o)
-    !(o.nil? || o == :undef) && (t.type.nil? || instance_of(t.type, o))
-  end
-
   def instance_of_PUndefType(t, o)
     o.nil? || o == :undef
   end
@@ -617,8 +578,8 @@ class Puppet::Pops::Types::TypeCalculator
       t = Types::PIntegerType.new()
       from = [t1range[0], t2range[0]].min
       to = [t1range[1], t2range[1]].max
-      t.from = from unless from == TheInfinity
-      t.to = to unless to == TheInfinity
+      t.from = from unless from == Float::INFINITY
+      t.to = to unless to == Float::INFINITY
       return t
     end
 
@@ -629,15 +590,14 @@ class Puppet::Pops::Types::TypeCalculator
       t = Types::PFloatType.new()
       from = [t1range[0], t2range[0]].min
       to = [t1range[1], t2range[1]].max
-      t.from = from unless from == TheInfinity
-      t.to = to unless to == TheInfinity
+      t.from = from unless from == Float::INFINITY
+      t.to = to unless to == Float::INFINITY
       return t
     end
 
     if t1.is_a?(Types::PStringType) && t2.is_a?(Types::PStringType)
       t = Types::PStringType.new()
-      t.values = t1.values | t2.values unless t1.values.empty? || t2.values.empty?
-      t.size_type = common_type(t1.size_type, t2.size_type) unless t1.size_type.nil? || t2.size_type.nil?
+      t.values = t1.values | t2.values
       return t
     end
 
@@ -842,36 +802,19 @@ class Puppet::Pops::Types::TypeCalculator
   def infer_Proc(o)
     min = 0
     max = 0
-    if o.respond_to?(:parameters)
-      mapped_types = o.parameters.map do |p|
-        param_t = Types::PAnyType.new
-        case p[0]
-        when :rest
-          max = :default
-          break param_t
-        when :req
-          min += 1
-        end
-        max += 1
-      	param_t
-      end
-    else
-      # Cannot correctly compute the signature in Ruby 1.8.7 because arity for
-      # optional values is screwed up (there is no way to get the upper limit),
-      # an optional looks the same as a varargs.
-      arity = o.arity
-      if arity < 0
-        min = -arity - 1
-        max = :default # i.e. infinite (which is wrong when there are optional - flaw in 1.8.7)
-      else
-        min = max = arity
+    mapped_types = o.parameters.map do |p|
+      case p[0]
+      when :rest
+        max = :default
+        break @t
+      when :req
+        min += 1
       end
-      mapped_types = Array.new(min) { Types::PAnyType.new }
-    end
-    if min == 0 || min != max
-      mapped_types << min
-      mapped_types << max
+      max += 1
+      @t
     end
+    mapped_types << min
+    mapped_types << max
     Types::TypeFactory.callable(*mapped_types)
   end
 
@@ -886,8 +829,6 @@ class Puppet::Pops::Types::TypeCalculator
     case o
     when :default
       Types::PDefaultType.new()
-    when :undef
-      Types::PUndefType.new()
     else
       infer_Object(o)
     end
@@ -978,23 +919,27 @@ class Puppet::Pops::Types::TypeCalculator
       type.key_type = Types::PUndefType.new
       type.element_type = Types::PUndefType.new
       type.size_type = size_as_type(o)
-    elsif o.keys.all? {|k| instance_of_PStringType(@non_empty_string_t, k) }
-      type = Types::PStructType.new
-      type.elements = o.map do |k,v|
-        element = Types::PStructElement.new
-        element.key_type = infer_String(k)
-        element.value_type = infer_set(v)
-        element
-      end
     else
-      type = Types::PHashType.new
-      ktype = Types::PVariantType.new
-      ktype.types = o.keys.map {|k| infer_set(k) }
-      etype = Types::PVariantType.new
-      etype.types = o.values.map {|e| infer_set(e) }
-      type.key_type = unwrap_single_variant(ktype)
-      type.element_type = unwrap_single_variant(etype)
-      type.size_type = size_as_type(o)
+      if o.keys.find {|k| !instance_of_PStringType(@non_empty_string_t, k) }
+        type = Types::PHashType.new
+        ktype = Types::PVariantType.new
+        ktype.types = o.keys.map {|k| infer_set(k) }
+        etype = Types::PVariantType.new
+        etype.types = o.values.map {|e| infer_set(e) }
+        type.key_type = unwrap_single_variant(ktype)
+        type.element_type = unwrap_single_variant(etype)
+        type.size_type = size_as_type(o)
+      else
+        elements = []
+        o.each_pair do |k,v|
+          element = Types::PStructElement.new
+          element.name = k
+          element.type = infer_set(v)
+          elements << element
+        end
+        type = Types::PStructType.new
+        type.elements = elements
+      end
     end
     type
   end
@@ -1018,11 +963,6 @@ class Puppet::Pops::Types::TypeCalculator
     t2.is_a?(Types::PAnyType)
   end
 
-  # @api private
-  def assignable_PNotUndefType(t, t2)
-    !assignable?(t2, @nil_t) && (t.type.nil? || assignable?(t.type, t2))
-  end
-
   # @api private
   def assignable_PUndefType(t, t2)
     # Only undef/nil is assignable to nil type
@@ -1070,14 +1010,18 @@ class Puppet::Pops::Types::TypeCalculator
     from = range.from
     to = range.to
     x = from.nil? ? 1 : from
-    y = to.nil? ? TheInfinity : to
-    [x, y]
+    y = to.nil? ? Float::INFINITY : to
+    if x < y
+      [x, y]
+    else
+      [y, x]
+    end
   end
 
   # @api private
   def from_to_ordered(from, to)
-    x = (from.nil? || from == :default) ? -TheInfinity : from
-    y = (to.nil? || to == :default) ? TheInfinity : to
+    x = (from.nil? || from == :default) ? -Float::INFINITY : from
+    y = (to.nil? || to == :default) ? Float::INFINITY : to
     if x < y
       [x, y]
     else
@@ -1116,22 +1060,33 @@ class Puppet::Pops::Types::TypeCalculator
     if args_tuple.size_type
       raise ArgumentError, "Callable tuple may not have a size constraint when used as args"
     end
-    # Assume no block was given - i.e. it is nil, and its type is PUndefType
-    block_t = @nil_t
-    if self.class.is_kind_of_callable?(args_tuple.types.last)
-      # a split is needed to make it possible to use required, optional, and varargs semantics
-      # of the tuple type.
-      #
-      args_tuple = args_tuple.copy
-      # to drop the callable, it must be removed explicitly since this is an rgen array
-      args_tuple.removeTypes(block_t = args_tuple.types.last())
-    else
-      # no block was given, if it is required, the below will fail
+
+    params_tuple = callable_t.param_types
+    param_block_t = callable_t.block_type
+    arg_types = args_tuple.types
+    arg_block_t = arg_types.last()
+    if self.class.is_kind_of_callable?(arg_block_t)
+      # Can't pass a block to a callable that doesn't accept one
+      return false if param_block_t.nil?
+
+      # Check that the block is of the right tyṕe
+      return false unless assignable?(param_block_t, arg_block_t)
+
+      # Check other arguments
+      arg_count = arg_types.size - 1
+      params_size_t = params_tuple.size_type || Types::TypeFactory.range(*params_tuple.size_range)
+      return false unless assignable?(params_size_t, Types::TypeFactory.range(arg_count, arg_count))
+
+      ctypes = params_tuple.types
+      args_assignable = false
+      arg_count.times do |index|
+        return false unless assignable?((ctypes[index] || ctypes[-1]), arg_types[index])
+      end
+      return true
     end
-    # unless argument types match parameter types
-    return false unless assignable?(callable_t.param_types, args_tuple)
-    # can the given block be *called* with a signature requirement specified by callable_t?
-    assignable?(callable_t.block_type || @nil_t, block_t)
+
+    # Check that tuple is assignable and that the block (if declared) is optional
+    assignable?(params_tuple, args_tuple) &&  (param_block_t.nil? || assignable?(param_block_t, @nil_t))
   end
 
   # @api private
@@ -1148,17 +1103,6 @@ class Puppet::Pops::Types::TypeCalculator
     end
   end
 
-  # @api private
-  def self.is_kind_of_optional?(t, optional = true)
-    case t
-    when Types::POptionalType
-      true
-    when Types::PVariantType
-      t.types.all? {|t2| is_kind_of_optional?(t2, optional) }
-    else
-      false
-    end
-  end
 
   def callable_PArrayType(args_array, callable_t)
     return false unless assignable?(callable_t.param_types, args_array)
@@ -1242,34 +1186,22 @@ class Puppet::Pops::Types::TypeCalculator
   #
   def assignable_PStructType(t, t2)
     if t2.is_a?(Types::PStructType)
+      h = t.hashed_elements
       h2 = t2.hashed_elements
-      matched = 0
-      t.elements.all? do |e1|
-        e2 = h2[e1.name]
-        if e2.nil?
-          assignable?(e1.key_type, @nil_t)
-        else
-          matched += 1
-          assignable?(e1.key_type, e2.key_type) && assignable?(e1.value_type, e2.value_type)
-        end
-      end && matched == h2.size
+      (h2.keys - h.keys).empty? && h.all? {|k, v| v2 = h2[k]; assignable?(v, v2.nil? ? @nil_t : v2) }
     elsif t2.is_a?(Types::PHashType)
-      required = 0
-      required_elements_assignable = t.elements.all? do |e|
-        if assignable?(e.key_type, @nil_t)
-          true
-        else
-          required += 1
-          assignable?(e.value_type, t2.element_type)
-        end
-      end
-      if required_elements_assignable
-        size_t2 = t2.size_type || @collection_default_size_t
-        size_t = Types::PIntegerType.new
-        size_t.from = required
-        size_t.to = t.elements.size
-        assignable_PIntegerType(size_t, size_t2)
-      end
+      size_t2 = t2.size_type || @collection_default_size_t
+      size_t = Types::PIntegerType.new
+      elements = t.elements
+      size_t.from = elements.count {|e| !assignable?(e.type, @nil_t) }
+      size_t.to = elements.size
+      # compatible size
+      # hash key type must be string of min 1 size
+      # hash value t must be assignable to each key
+      element_type = t2.element_type
+      assignable_PIntegerType(size_t, size_t2) &&
+        (size_t2.to == 0 || assignable?(@non_empty_string_t, t2.key_type)) &&
+          elements.all? {|e| assignable?(e.type, element_type) }
     else
       false
     end
@@ -1278,9 +1210,8 @@ class Puppet::Pops::Types::TypeCalculator
   # @api private
   def assignable_POptionalType(t, t2)
     return true if t2.is_a?(Types::PUndefType)
-    return true if t.optional_type.nil?
     if t2.is_a?(Types::POptionalType)
-      assignable?(t.optional_type, t2.optional_type || @t)
+      assignable?(t.optional_type, t2.optional_type)
     else
       assignable?(t.optional_type, t2)
     end
@@ -1447,15 +1378,14 @@ class Puppet::Pops::Types::TypeCalculator
   end
 
   # Array is assignable if t2 is an Array and t2's element type is assignable, or if t2 is a Tuple
-  # where 
   # @api private
   def assignable_PArrayType(t, t2)
     if t2.is_a?(Types::PArrayType)
-      return false unless t.element_type.nil? || assignable?(t.element_type, t2.element_type || @t)
+      return false unless assignable?(t.element_type, t2.element_type)
       assignable_PCollectionType(t, t2)
 
     elsif t2.is_a?(Types::PTupleType)
-      return false unless t.element_type.nil? || t2.types.all? {|t2_element| assignable?(t.element_type, t2_element) }
+      return false unless t2.types.all? {|t2_element| assignable?(t.element_type, t2_element) }
       t2_regular = t2.types[0..-2]
       t2_ranged = t2.types[-1]
       t2_from, t2_to = size_range(t2.size_type)
@@ -1493,8 +1423,7 @@ class Puppet::Pops::Types::TypeCalculator
     case t2
     when Types::PHashType
       return true if (t.size_type.nil? || t.size_type.from == 0) && t2.is_the_empty_hash?
-      return false unless t.key_type.nil? || assignable?(t.key_type, t2.key_type || @t)
-      return false unless t.element_type.nil? || assignable?(t.element_type, t2.element_type || @t)
+      return false unless assignable?(t.key_type, t2.key_type) && assignable?(t.element_type, t2.element_type)
       assignable_PCollectionType(t, t2)
     when Types::PStructType
       # hash must accept String as key type
@@ -1506,7 +1435,7 @@ class Puppet::Pops::Types::TypeCalculator
       key_type = t.key_type
       element_type = t.element_type
       ( struct_size >= min && struct_size <= max &&
-        t2.elements.all? {|e| (key_type.nil? || instance_of(key_type, e.name)) && (element_type.nil? || assignable?(element_type, e.value_type)) })
+        t2.elements.all? {|e| instance_of(key_type, e.name) && assignable?(element_type, e.type) })
     else
       false
     end
@@ -1538,15 +1467,7 @@ class Puppet::Pops::Types::TypeCalculator
   # Data is assignable by other Data and by Array[Data] and Hash[Scalar, Data]
   # @api private
   def assignable_PDataType(t, t2)
-    # We cannot put the NotUndefType[Data] in the @data_variant_t since that causes an endless recursion
-    case t2
-    when Types::PDataType
-      true
-    when Types::PNotUndefType
-      assignable?(t, t2.type || @t)
-    else
-      assignable?(@data_variant_t, t2)
-    end
+    t2.is_a?(Types::PDataType) || assignable?(@data_variant_t, t2)
   end
 
   # Assignable if t2's has the same runtime and the runtime name resolves to
@@ -1717,16 +1638,7 @@ class Puppet::Pops::Types::TypeCalculator
   end
 
   def string_PStructElement(t)
-    k = t.key_type
-    value_optional = assignable?(t.value_type, @nil_t)
-    key_string =
-      if k.is_a?(Types::POptionalType)
-        # Output as literal String
-        value_optional ? "'#{t.name}'" : string(k)
-      else
-        value_optional ? "NotUndef['#{t.name}']" : "'#{t.name}'"
-      end
-    "#{key_string}=>#{string(t.value_type)}"
+    "'#{t.name}'=>#{string(t.type)}"
   end
 
   # @api private
@@ -1792,30 +1704,11 @@ class Puppet::Pops::Types::TypeCalculator
     end
   end
 
-  # @api private
-  def string_PNotUndefType(t)
-    contained_type = t.type
-    if contained_type.nil? || contained_type.class == Puppet::Pops::Types::PAnyType
-      'NotUndef'
-    else
-      if contained_type.is_a?(Puppet::Pops::Types::PStringType) && contained_type.values.size == 1
-        "NotUndef['#{contained_type.values[0]}']"
-      else
-        "NotUndef[#{string(contained_type)}]"
-      end
-    end
-  end
-
   def string_POptionalType(t)
-    optional_type = t.optional_type
-    if optional_type.nil?
+    if t.optional_type.nil?
       "Optional"
     else
-      if optional_type.is_a?(Puppet::Pops::Types::PStringType) && optional_type.values.size == 1
-        "Optional['#{optional_type.values[0]}']"
-      else
-        "Optional[#{string(optional_type)}]"
-      end
+      "Optional[#{string(t.optional_type)}]"
     end
   end
 
@@ -1828,7 +1721,7 @@ class Puppet::Pops::Types::TypeCalculator
   # @api private
   def enumerable_PIntegerType(t)
     # Not enumerable if representing an infinite range
-    return nil if t.size == TheInfinity
+    return nil if t.size == Float::INFINITY
     t
   end
 
@@ -1847,6 +1740,11 @@ class Puppet::Pops::Types::TypeCalculator
     end
   end
 
+  # Debugging to_s to reduce the amount of output
+  def to_s
+    '[a TypeCalculator]'
+  end
+
   private
 
   NAME_SEGMENT_SEPARATOR = '::'.freeze