puppet 3.7.5-x64-mingw32 → 3.8.1-x64-mingw32

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

@@ -20,6 +20,8 @@ class Puppet::Pops::Parser::EvaluatingParser
     #
     begin
       assert_and_report(parser.parse_string(s))
+    rescue Puppet::ParseErrorWithIssue => e
+      raise e
     rescue Puppet::ParseError => e
       # TODO: This is not quite right, why does not the exception have the correct file?
       e.file = @file_source unless e.file.is_a?(String) && !e.file.empty?
@@ -56,12 +58,16 @@ class Puppet::Pops::Parser::EvaluatingParser
   end
 
   def evaluator
+    # Do not use the cached evaluator if this is a migration run
+    if (Puppet.lookup(:migration_checker) { nil })
+      return Puppet::Pops::Evaluator::EvaluatorImpl.new()
+    end
     @@evaluator ||= Puppet::Pops::Evaluator::EvaluatorImpl.new()
     @@evaluator
   end
 
   def convert_to_3x(object, scope)
-    val = @@evaluator.convert(object, scope, nil)
+    val = evaluator.convert(object, scope, nil)
   end
 
   def validate(parse_result)

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

@@ -1,4 +1,5 @@
 module Puppet::Pops::Parser::HeredocSupport
+  include Puppet::Pops::Parser::LexerSupport
 
   # Pattern for heredoc `@(endtag[:syntax][/escapes])
   # Produces groups for endtag (group 1), syntax (group 2), and escapes (group 3)
@@ -14,13 +15,12 @@ module Puppet::Pops::Parser::HeredocSupport
 
     # scanner is at position before @(
     # find end of the heredoc spec
-    str = scn.scan_until(/\)/) || lexer.lex_error("Unclosed parenthesis after '@(' followed by '#{followed_by}'")
+    str = scn.scan_until(/\)/) || lex_error(Puppet::Pops::Issues::HEREDOC_UNCLOSED_PARENTHESIS, :followed_by => followed_by)
     pos_after_heredoc = scn.pos
 
     # Note: allows '+' as separator in syntax, but this needs validation as empty segments are not allowed
-    unless md = str.match(PATTERN_HEREDOC)
-      lex_error("Invalid syntax in heredoc expected @(endtag[:syntax][/escapes])")
-    end
+    md = str.match(PATTERN_HEREDOC)
+    lex_error(Puppet::Pops::Issues::HEREDOC_INVALID_SYNTAX) unless md
     endtag = md[1]
     syntax = md[2] || ''
     escapes = md[3]
@@ -33,7 +33,7 @@ module Puppet::Pops::Parser::HeredocSupport
       endtag = $1.strip
     end
 
-    lexer.lex_error("Missing endtag in heredoc") unless endtag.length >= 1
+    lex_error(Puppet::Pops::Issues::HEREDOC_MISSING_ENDTAG) unless endtag.length >= 1
 
     resulting_escapes = []
     if escapes
@@ -41,7 +41,7 @@ module Puppet::Pops::Parser::HeredocSupport
 
       escapes = escapes.split('')
       unless escapes.length == escapes.uniq.length
-        lex_error("An escape char for @() may only appear once. Got '#{escapes.join(', ')}")
+        lex_error(Puppet::Pops::Issues::HEREDOC_MULTIPLE_AT_ESCAPES, :escapes => escapes)
       end
       resulting_escapes = ["\\"]
       escapes.each do |e|
@@ -51,7 +51,7 @@ module Puppet::Pops::Parser::HeredocSupport
         when "L"
           resulting_escapes += ["\n", "\r\n"]
         else
-          lex_error("Invalid heredoc escape char. Only t, r, n, s,  u, L, $ allowed. Got '#{e}'")
+          lex_error(Puppet::Pops::Issues::HEREDOC_INVALID_ESCAPE, :actual => e)
         end
       end
     end
@@ -66,14 +66,14 @@ module Puppet::Pops::Parser::HeredocSupport
     if ctx[:newline_jump]
       scn.pos = ctx[:newline_jump]
     else
-      scn.scan_until(/\n/) || lex_error("Heredoc without any following lines of text")
+      scn.scan_until(/\n/) || lex_error(Puppet::Pops::Issues::HEREDOC_WITHOUT_TEXT)
     end
     # offset 0 for the heredoc, and its line number
     heredoc_offset = scn.pos
     heredoc_line = locator.line_for_offset(heredoc_offset)-1
 
     # Compute message to emit if there is no end (to make it refer to the opening heredoc position).
-    eof_message = positioned_message("Heredoc without end-tagged line")
+    eof_error = create_lex_error(Puppet::Pops::Issues::HEREDOC_WITHOUT_END_TAGGED_LINE)
 
     # Text from this position (+ lexing contexts offset for any preceding heredoc) is heredoc until a line
     # that terminates the heredoc is found.
@@ -82,7 +82,8 @@ module Puppet::Pops::Parser::HeredocSupport
     endline_pattern = /([[:blank:]]*)(?:([|])[[:blank:]]*)?(?:(\-)[[:blank:]]*)?#{Regexp.escape(endtag)}[[:blank:]]*\r?(?:\n|\z)/
     lines = []
     while !scn.eos? do
-      one_line = scn.scan_until(/(?:\n|\z)/) || lexer.lex_error_without_pos(eof_message)
+      one_line = scn.scan_until(/(?:\n|\z)/)
+      raise eof_error unless one_line
       if md = one_line.match(endline_pattern)
         leading      = md[1]
         has_margin   = md[2] == '|'
@@ -116,7 +117,7 @@ module Puppet::Pops::Parser::HeredocSupport
         lines << one_line
       end
     end
-    lex_error_without_pos(eof_message)
+    raise eof_error
   end
 
   # Produces the heredoc text string given the individual (unprocessed) lines as an array.

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

@@ -193,9 +193,15 @@ module Puppet::Pops::Parser::InterpolationSupport
         token_name = token[0]
         ctx[:after] = token_name
         if token_name == :RBRACE && ctx[:brace_count] == brace_count
-          if queue.size - queue_size == 1
+          qlength = queue.size - queue_size
+          if qlength == 1
             # Single token is subject to replacement
             queue[-1] = transform_to_variable(queue[-1])
+          elsif qlength > 1 && [:DOT, :LBRACK].include?(queue[queue_size + 1][0])
+            # A first word, number of name token followed by '[' or '.' is subject to replacement
+            # But not for other operators such as ?, +, - etc. where user must use a $ before the name
+            # to get a variable
+            queue[queue_size] = transform_to_variable(queue[queue_size])
           end
           return
         end

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

@@ -213,7 +213,7 @@ class Puppet::Pops::Parser::Lexer2
     @scanner = StringScanner.new(string)
     @locator = locator || Puppet::Pops::Parser::Locator.locator(string, '')
     @lexing_context[:escapes] = escapes || UQ_ESCAPES
-    @lexing_context[:uq_slurp_pattern] = (interpolate || !escapes.empty?) ? SLURP_UQ_PATTERN : SLURP_ALL_PATTERN
+    @lexing_context[:uq_slurp_pattern] = interpolate ? (escapes.include?('$') ? SLURP_UQ_PATTERN : SLURP_UQNE_PATTERN) : SLURP_ALL_PATTERN
   end
 
   # Convenience method, and for compatibility with older lexer. Use the lex_file instead.
@@ -274,7 +274,7 @@ class Puppet::Pops::Parser::Lexer2
     ctx   = @lexing_context
     queue = @token_queue
 
-    lex_error_without_pos("Internal Error: No string or file given to lexer to process.") unless scn
+    lex_error_without_pos(Puppet::Pops::Issues::NO_INPUT_TO_LEXER) unless scn
 
     scn.skip(PATTERN_WS)
 
@@ -533,7 +533,7 @@ class Puppet::Pops::Parser::Lexer2
           else
             # move to faulty position ('::<uc-letter>' was ok)
             scn.pos = scn.pos + 3
-            lex_error("Illegal fully qualified class reference")
+            lex_error(Puppet::Pops::Issues::ILLEGAL_FULLY_QUALIFIED_CLASS_REFERENCE)
           end
         else
           value = scn.scan(PATTERN_BARE_WORD)
@@ -546,7 +546,7 @@ class Puppet::Pops::Parser::Lexer2
           else
             # move to faulty position ('::' was ok)
             scn.pos = scn.pos + 2
-            lex_error("Illegal fully qualified name")
+            lex_error(Puppet::Pops::Issues::ILLEGAL_FULLY_QUALIFIED_NAME)
           end
         end
       else
@@ -578,7 +578,7 @@ class Puppet::Pops::Parser::Lexer2
       else
         # move to faulty position ([0-9] was ok)
         scn.pos = scn.pos + 1
-        lex_error("Illegal number")
+        lex_error(Puppet::Pops::Issues::ILLEGAL_NUMBER)
       end
 
     when 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
@@ -594,9 +594,9 @@ class Puppet::Pops::Parser::Lexer2
         scn.pos = scn.pos + 1
         fully_qualified = scn.match?(/::/)
         if fully_qualified
-          lex_error("Illegal fully qualified name")
+          lex_error(Puppet::Pops::Issues::ILLEGAL_FULLY_QUALIFIED_NAME)
         else
-          lex_error("Illegal name or bare word")
+          lex_error(Puppet::Pops::Issues::ILLEGAL_NAME_OR_BARE_WORD)
         end
       end
 
@@ -608,7 +608,7 @@ class Puppet::Pops::Parser::Lexer2
       else
         # move to faulty position ([A-Z] was ok)
         scn.pos = scn.pos + 1
-        lex_error("Illegal class reference")
+        lex_error(Puppet::Pops::Issues::ILLEGAL_CLASS_REFERENCE)
       end
 
     when "\n"

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

@@ -3,18 +3,6 @@
 #
 module Puppet::Pops::Parser::LexerSupport
 
-  # Formats given message by appending file, line and position if available.
-  def positioned_message(msg, pos = nil)
-    result = [msg]
-    file = @locator.file
-    line = @locator.line_for_offset(pos || @scanner.pos)
-    pos =  @locator.pos_on_line(pos || @scanner.pos)
-
-    result << "in file #{file}" if file && file.is_a?(String) && !file.empty?
-    result << "at line #{line}:#{pos}"
-    result.join(" ")
-  end
-
   # Returns "<eof>" if at end of input, else the following 5 characters with \n \r \t escaped
   def followed_by
     return "<eof>" if @scanner.eos?
@@ -35,13 +23,51 @@ module Puppet::Pops::Parser::LexerSupport
   end
 
   # Raises a Puppet::LexError with the given message
-  def lex_error_without_pos msg
-    raise Puppet::LexError.new(msg)
+  def lex_error_without_pos(issue, args = {})
+    raise Puppet::ParseErrorWithIssue.new(issue.format(args), nil, nil, nil, nil, issue.issue_code)
   end
 
-  # Raises a Puppet::LexError with the given message
-  def lex_error(msg, pos=nil)
-    raise Puppet::LexError.new(positioned_message(msg, pos))
+  # Raises a Puppet::ParserErrorWithIssue with the given issue and arguments
+  def lex_error(issue, args = {}, pos=nil)
+    raise create_lex_error(issue, args, pos)
+  end
+
+  def filename
+    file = @locator.file
+    file.is_a?(String) && !file.empty? ? file : nil
+  end
+
+  def line(pos)
+    @locator.line_for_offset(pos || @scanner.pos)
+  end
+
+  def position(pos)
+    @locator.pos_on_line(pos || @scanner.pos)
+  end
+
+  def lex_warning(issue, args = {}, pos=nil)
+    Puppet::Util::Log.create({
+        :level => :warning,
+        :message => issue.format(args),
+        :issue_code => issue.issue_code,
+        :file => filename,
+        :line => line(pos),
+        :pos => position(pos),
+      })
+  end
+
+  # @param issue [Puppet::Pops::Issues::Issue] the issue
+  # @param args [Hash<Symbol,String>] Issue arguments
+  # @param pos [Integer]
+  # @return [Puppet::ParseErrorWithIssue] the created error
+  def create_lex_error(issue, args = {}, pos = nil)
+    Puppet::ParseErrorWithIssue.new(
+        issue.format(args),
+        filename,
+        line(pos),
+        position(pos),
+        nil,
+        issue.issue_code)
   end
 
   # Asserts that the given string value is a float, or an integer in decimal, octal or hex form.
@@ -49,13 +75,13 @@ module Puppet::Pops::Parser::LexerSupport
   #
   def assert_numeric(value, length)
     if value =~ /^0[xX].*$/
-      lex_error("Not a valid hex number #{value}", length)     unless value =~ /^0[xX][0-9A-Fa-f]+$/
+      lex_error(Puppet::Pops::Issues::INVALID_HEX_NUMBER, {:value => value}, length)     unless value =~ /^0[xX][0-9A-Fa-f]+$/
 
     elsif value =~ /^0[^.].*$/
-      lex_error("Not a valid octal number #{value}", length)   unless value =~ /^0[0-7]+$/
+      lex_error(Puppet::Pops::Issues::INVALID_OCTAL_NUMBER, {:value => value}, length)   unless value =~ /^0[0-7]+$/
 
     else
-      lex_error("Not a valid decimal number #{value}", length) unless value =~ /0?\d+(?:\.\d+)?(?:[eE]-?\d+)?/
+      lex_error(Puppet::Pops::Issues::INVALID_DECIMAL_NUMBER, {:value => value}, length) unless value =~ /0?\d+(?:\.\d+)?(?:[eE]-?\d+)?/
     end
   end
 

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

@@ -93,11 +93,8 @@ class Puppet::Pops::Parser::Parser
     else
       value_at = "'#{value[:value]}'"
     end
-    if @yydebug
-      error = "Syntax error at #{value_at}, token: #{token}"
-    else
-      error = "Syntax error at #{value_at}"
-    end
+    error = Puppet::Pops::Issues::SYNTAX_ERROR.format(:where => value_at)
+    error = "#{error}, token: #{token}" if @yydebug
 
     # 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
@@ -110,19 +107,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.
     #
-
-    except = Puppet::ParseError.new(error)
+    file = nil
+    line = nil
+    pos  = nil
     if token != 0
-      path        = value[:file]
-      except.line = value[:line]
-      except.pos  = value[:pos]
+      file = value[:file]
+      line = value[:line]
+      pos  = value[:pos]
     else
       # At end of input, use what the lexer thinks is the source file
-      path        = lexer.file
+      file = lexer.file
     end
-    except.file = path if path.is_a?(String) && !path.empty?
-
-    raise except
+    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)
   end
 
   # Parses a String of pp DSL code.

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

@@ -7,10 +7,13 @@
 # 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"]
@@ -19,7 +22,8 @@ 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("Unclosed quote after \"'\" followed by '#{followed_by}'")
+    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[0..-2] # strip closing "'" from result
   end
 
@@ -28,7 +32,7 @@ module Puppet::Pops::Parser::SlurpSupport
     last = scn.matched
     str = slurp(scn, SLURP_DQ_PATTERN, DQ_ESCAPES, false)
     unless str
-      lex_error("Unclosed quote after #{format_quote(last)} followed by '#{followed_by}'")
+      lex_error(Puppet::Pops::Issues::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
@@ -41,6 +45,7 @@ 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.
@@ -65,11 +70,12 @@ 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})/m) {
-        [$1.hex].pack("U")
+      str.gsub!(/\\u(?:([\da-fA-F]{4})|\{([\da-fA-F]{1,6})\})/m) {
+        [($1 || $2).hex].pack("U")
       }
     end
 
+    begin
     str.gsub!(/\\([^\r\n]|(?:\r?\n))/m) {
       ch = $1
       if escapes.include? ch
@@ -79,17 +85,27 @@ module Puppet::Pops::Parser::SlurpSupport
         when 't'   ; "\t"
         when 's'   ; " "
         when 'u'
-          Puppet.warning(positioned_message("Unicode escape '\\u' was not followed by 4 hex digits"))
+          lex_warning(Puppet::Pops::Issues::ILLEGAL_UNICODE_ESCAPE)
           "\\u"
         when "\n"  ; ''
         when "\r\n"; ''
         else      ch
         end
       else
-        Puppet.warning(positioned_message("Unrecognized escape sequence '\\#{ch}'")) unless ignore_invalid_escapes
+        lex_warning(Puppet::Pops::Issues::UNRECOGNIZED_ESCAPE, :ch => 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/types/type_calculator.rb

@@ -269,14 +269,21 @@ 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
-      @@assignable_visitor.visit_this_1(self, t, t2)
+      # 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
     end
  end
 
@@ -354,10 +361,23 @@ 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)
-    o.values = []
-    o.size_type = nil
-    []
+    # Skip generalization if the string is contained in a PStructElement key.
+    unless is_struct_element_key?(o)
+      o.values = []
+      o.size_type = nil
+    end
   end
 
   def generalize_PCollectionType(o)
@@ -434,8 +454,13 @@ 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 || @collection_default_size_t
-    instance_of_PIntegerType(size_t, o.size)
+    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
   end
 
   def instance_of_PTupleType(t, o)
@@ -452,9 +477,18 @@ class Puppet::Pops::Types::TypeCalculator
 
   def instance_of_PStructType(t, o)
     return false unless o.is_a?(Hash)
-    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]) }
+    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
   end
 
   def instance_of_PHashType(t, o)
@@ -471,6 +505,10 @@ 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
@@ -598,7 +636,8 @@ class Puppet::Pops::Types::TypeCalculator
 
     if t1.is_a?(Types::PStringType) && t2.is_a?(Types::PStringType)
       t = Types::PStringType.new()
-      t.values = t1.values | t2.values
+      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?
       return t
     end
 
@@ -937,27 +976,23 @@ class Puppet::Pops::Types::TypeCalculator
       type.key_type = Types::PUndefType.new
       type.element_type = Types::PUndefType.new
       type.size_type = size_as_type(o)
-    else
-      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
+    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)
     end
     type
   end
@@ -981,6 +1016,11 @@ 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
@@ -1110,6 +1150,17 @@ 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)
@@ -1193,22 +1244,34 @@ class Puppet::Pops::Types::TypeCalculator
   #
   def assignable_PStructType(t, t2)
     if t2.is_a?(Types::PStructType)
-      h = t.hashed_elements
       h2 = t2.hashed_elements
-      (h2.keys - h.keys).empty? && h.all? {|k, v| v2 = h2[k]; assignable?(v, v2.nil? ? @nil_t : v2) }
+      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
     elsif t2.is_a?(Types::PHashType)
-      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) }
+      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
     else
       false
     end
@@ -1217,8 +1280,9 @@ 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)
+      assignable?(t.optional_type, t2.optional_type || @t)
     else
       assignable?(t.optional_type, t2)
     end
@@ -1389,11 +1453,11 @@ class Puppet::Pops::Types::TypeCalculator
   # @api private
   def assignable_PArrayType(t, t2)
     if t2.is_a?(Types::PArrayType)
-      return false unless assignable?(t.element_type, t2.element_type)
+      return false unless t.element_type.nil? || assignable?(t.element_type, t2.element_type || @t)
       assignable_PCollectionType(t, t2)
 
     elsif t2.is_a?(Types::PTupleType)
-      return false unless t2.types.all? {|t2_element| assignable?(t.element_type, t2_element) }
+      return false unless t.element_type.nil? || 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)
@@ -1431,7 +1495,8 @@ 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 assignable?(t.key_type, t2.key_type) && assignable?(t.element_type, t2.element_type)
+      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)
       assignable_PCollectionType(t, t2)
     when Types::PStructType
       # hash must accept String as key type
@@ -1443,7 +1508,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| instance_of(key_type, e.name) && assignable?(element_type, e.type) })
+        t2.elements.all? {|e| (key_type.nil? || instance_of(key_type, e.name)) && (element_type.nil? || assignable?(element_type, e.value_type)) })
     else
       false
     end
@@ -1475,7 +1540,15 @@ 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)
-    t2.is_a?(Types::PDataType) || assignable?(@data_variant_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
   end
 
   # Assignable if t2's has the same runtime and the runtime name resolves to
@@ -1646,7 +1719,16 @@ class Puppet::Pops::Types::TypeCalculator
   end
 
   def string_PStructElement(t)
-    "'#{t.name}'=>#{string(t.type)}"
+    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)}"
   end
 
   # @api private
@@ -1712,11 +1794,30 @@ 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)
-    if t.optional_type.nil?
+    optional_type = t.optional_type
+    if optional_type.nil?
       "Optional"
     else
-      "Optional[#{string(t.optional_type)}]"
+      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
     end
   end