puppet 3.4.3 → 3.5.0.rc1

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

@@ -0,0 +1,95 @@
+# This module is an integral part of the Lexer.
+# It defines the string slurping behavior - finding the string and non string parts in interpolated
+# strings, translating escape sequences in strings to their single character equivalence.
+#
+# PERFORMANCE NOTE: The various kinds of slurping could be made even more generic, but requires
+# additional parameter passing and evaluation of conditional logic.
+# TODO: More detailed performance analysis of excessive character escaping and interpolation.
+#
+module Puppet::Pops::Parser::SlurpSupport
+
+  SLURP_SQ_PATTERN  = /(?:[^\\]|^|[^\\])(?:[\\]{2})*[']/
+  SLURP_DQ_PATTERN  = /(?:[^\\]|^|[^\\])(?:[\\]{2})*(["]|[$]\{?)/
+  SLURP_UQ_PATTERN  = /(?:[^\\]|^|[^\\])(?:[\\]{2})*([$]\{?|\z)/
+  SLURP_ALL_PATTERN = /.*(\z)/m
+  SQ_ESCAPES = %w{ \\ ' }
+  DQ_ESCAPES = %w{ \\  $ ' " r n t s u}+["\r\n", "\n"]
+  UQ_ESCAPES = %w{ \\  $ r n t s u}+["\r\n", "\n"]
+
+  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[0..-2] # strip closing "'" from result
+  end
+
+  def slurp_dqstring
+    scn = @scanner
+    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}'")
+    end
+
+    # Terminator may be a single char '"', '$', or two characters '${' group match 1 (scn[1]) from the last slurp holds this
+    terminator = scn[1]
+    [str[0..(-1 - terminator.length)], terminator]
+  end
+
+   # Copy from old lexer - can do much better
+   def slurp_uqstring
+     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.
+     # Group match 1 holds this.
+     # The exceptional case is found by looking at the subgroup 1 of the most recent match made by the scanner (i.e. @scanner[1]).
+     # This is the last match made by the slurp method (having called scan_until on the scanner).
+     # If there is a terminating character is must be stripped and returned separately.
+     #
+     terminator = scn[1]
+     [str[0..(-1 - terminator.length)], terminator]
+   end
+
+  # Slurps a string from the given scanner until the given pattern and then replaces any escaped
+  # characters given by escapes into their control-character equivalent or in case of line breaks, replaces the
+  # pattern \r?\n with an empty string.
+  # The returned string contains the terminating character. Returns nil if the scanner can not scan until the given
+  # pattern.
+  #
+  def slurp(scanner, pattern, escapes, ignore_invalid_escapes)
+    str = scanner.scan_until(pattern) || return
+
+    # 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")
+      }
+    end
+
+    str.gsub!(/\\([^\r\n]|(?:\r?\n))/m) {
+      ch = $1
+      if escapes.include? ch
+        case ch
+        when 'r'   ; "\r"
+        when 'n'   ; "\n"
+        when 't'   ; "\t"
+        when 's'   ; " "
+        when 'u'
+          Puppet.warning(positioned_message("Unicode escape '\\u' was not followed by 4 hex digits"))
+          "\\u"
+        when "\n"  ; ''
+        when "\r\n"; ''
+        else      ch
+        end
+      else
+        Puppet.warning(positioned_message("Unrecognized escape sequence '\\#{ch}'")) unless ignore_invalid_escapes
+        "\\#{ch}"
+      end
+    }
+    str
+  end
+end

data/lib/puppet/pops/patterns.rb

@@ -17,19 +17,28 @@ module Puppet::Pops::Patterns
   ILLEGAL_HOSTNAME_CHARS = %r{[^-\w.]}
 
   # NAME matches a name the same way as the lexer.
-  # This name includes hyphen, which may be illegal in variables, and names in general.
-  NAME = %r{\A((::)?[a-z0-9]\w*)(::[a-z0-9]\w*)*\z}
+  NAME = %r{\A((::)?[a-z]\w*)(::[a-z]\w*)*\z}
 
   # CLASSREF_EXT matches a class reference the same way as the lexer - i.e. the external source form
   # where each part must start with a capital letter A-Z.
   # This name includes hyphen, which may be illegal in some cases.
   #
-  CLASSREF_EXT = %r{\A((::){0,1}[A-Z][-\w]*)+\z}
+  CLASSREF_EXT = %r{\A((::){0,1}[A-Z][\w]*)+\z}
 
   # CLASSREF matches a class reference the way it is represented internally in the
   # model (i.e. in lower case).
   # This name includes hyphen, which may be illegal in some cases.
   #
-  CLASSREF = %r{\A((::){0,1}[a-z][-\w]*)+\z}
+  CLASSREF = %r{\A((::){0,1}[a-z][\w]*)+\z}
+
+  # DOLLAR_VAR matches a variable name including the initial $ character
+  DOLLAR_VAR     = %r{\$(::)?(\w+::)*\w+}
+
+  # 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}
+
+  # 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}
 
 end

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

@@ -52,7 +52,7 @@ class Puppet::Pops::Types::ClassLoader
     #
     when Puppet::Pops::Types::PArrayType   ; Array
     when Puppet::Pops::Types::PHashType    ; Hash
-    when Puppet::Pops::Types::PPatternType ; Regexp
+    when Puppet::Pops::Types::PRegexpType ; Regexp
     when Puppet::Pops::Types::PIntegerType ; Integer
     when Puppet::Pops::Types::PStringType  ; String
     when Puppet::Pops::Types::PFloatType   ; Float
@@ -115,4 +115,4 @@ class Puppet::Pops::Types::ClassLoader
     downcase
   end
 
-end
+end

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

@@ -0,0 +1,34 @@
+# The Enumeration class provides default Enumerable::Enumerator creation for Puppet Programming Language
+# runtime objects that supports the concept of enumeration.
+#
+class Puppet::Pops::Types::Enumeration
+  # Produces an Enumerable::Enumerator for Array, Hash, Integer, Integer Range, and String.
+  #
+  def self.enumerator(o)
+    @@singleton ||= new
+    @@singleton.enumerator(o)
+  end
+
+  # Produces an Enumerator for Array, Hash, Integer, Integer Range, and String.
+  #
+  def enumerator(o)
+    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
+      x.is_a?(Array) ? x.each : x
+    when Integer
+      o.times
+    when Array
+      o.each
+    when Hash
+      o.each
+    when Puppet::Pops::Types::PIntegerType
+      # Not enumerable if representing an infinite range
+      return nil if o.to.nil? || o.from.nil?
+      o.each
+    else
+      nil
+    end
+  end
+end

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

@@ -3,13 +3,28 @@
 # The Puppet type system is primarily based on sub-classing. When asking the type calculator to infer types from Ruby in general, it
 # may not provide the wanted answer; it does not for instance take module inclusions and extensions into account. In general the type
 # system should be unsurprising for anyone being exposed to the notion of type. The type `Data` may require a bit more explanation; this
-# is an abstract type that includes all literal types, as well as Array with an element type compatible with Data, and Hash with key
-# compatible with Literal and elements compatible with Data. Expressed differently; Data is what you typically express using JSON (with
-# the exception that the Puppet type system also includes Pattern (regular expression) as a literal.
+# is an abstract type that includes all scalar types, as well as Array with an element type compatible with Data, and Hash with key
+# compatible with scalar and elements compatible with Data. Expressed differently; Data is what you typically express using JSON (with
+# the exception that the Puppet type system also includes Pattern (regular expression) as a scalar.
 #
 # Inference
 # ---------
-# The `infer(o)` method infers a Puppet type for literal Ruby objects, and for Arrays and Hashes.
+# The `infer(o)` method infers a Puppet type for scalar Ruby objects, and for Arrays and Hashes.
+# The inference result is instance specific for single typed collections
+# and allows answering questions about its embedded type. It does not however preserve multiple types in
+# a collection, and can thus not answer questions like `[1,a].infer() =~ Array[Integer, String]` since the inference
+# computes the common type Scalar when combining Integer and String.
+#
+# The `infer_generic(o)` method infers a generic Puppet type for scalar Ruby object, Arrays and Hashes.
+# This inference result does not contain instance specific information; e.g. Array[Integer] where the integer
+# range is the generic default. Just `infer` it also combines types into a common type.
+#
+# The `infer_set(o)` method works like `infer` but preserves all type information. It does not do any
+# reduction into common types or ranges. This method of inference is best suited for answering questions
+# about an object being an instance of a type. It correctly answers: `[1,a].infer_set() =~ Array[Integer, String]`
+#
+# The `generalize!(t)` method modifies an instance specific inference result to a generic. The method mutates
+# the given argument. Basically, this removes string instances from String, and range from Integer and Float.
 #
 # Assignability
 # -------------
@@ -35,6 +50,9 @@
 #   instance, such as if it may be nil, be empty, contain a certain count etc. Or put differently, the puppet types are not
 #   singletons.
 #
+# All types support `copy` which should be used when assigning a type where it is unknown if it is bound or not
+# to a parent type. A check can be made with `t.eContainer().nil?`
+#
 # Equality and Hash
 # -----------------
 # Type instances are equal in terms of Ruby eql? and `==` if they describe the same type, but they are not `equal?` if they are not
@@ -45,7 +63,7 @@
 # In general, the type calculator should be used to answer questions if a type is a subtype of another (using {#assignable?}, or
 # {#instance?} if the question is if a given object is an instance of a given type (or is a subtype thereof).
 # Many of the types also have a Ruby subtype relationship; e.g. PHashType and PArrayType are both subtypes of PCollectionType, and
-# PIntegerType, PFloatType, PStringType,... are subtypes of PLiteralType. Even if it is possible to answer certain questions about
+# PIntegerType, PFloatType, PStringType,... are subtypes of PScalarType. Even if it is possible to answer certain questions about
 # type by looking at the Ruby class of the types this is considered an implementation detail, and such checks should in general
 # be performed by the type_calculator which implements the type system semantics.
 #
@@ -64,18 +82,73 @@
 # @see Puppet::Pops::Types::TypeParser TypeParser how to construct a type instance from a String
 # @see Puppet::Pops::Types Types for details about the type model
 #
+# Using the Type Calculator
+# -----
+# The type calculator can be directly used via its class methods. If doing time critical work and doing many
+# calls to the type calculator, it is more performant to create an instance and invoke the corresponding
+# instance methods. Note that inference is an expensive operation, rather than infering the same thing
+# several times, it is in general better to infer once and then copy the result if mutation to a more generic form is
+# required.
+#
 # @api public
 #
 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)
+    singleton.assignable?(t1,t2)
+  end
+
+  # @api public
+  def self.string(t)
+    singleton.string(t)
+  end
+
+  # @api public
+  def self.infer(o)
+    singleton.infer(o)
+  end
+
+  # @api public
+  def self.generalize!(o)
+    singleton.generalize!(o)
+  end
+
+  # @api public
+  def self.infer_set(o)
+    singleton.infer_set(o)
+  end
+
+  # @api public
+  def self.debug_string(t)
+    singleton.debug_string(t)
+  end
+
+  # @api public
+  def self.enumerable(t)
+    singleton.enumerable(t)
+  end
+
+  # @api private
+  def self.singleton()
+    @tc_instance ||= new
+  end
 
   # @api public
   #
   def initialize
     @@assignable_visitor ||= Puppet::Pops::Visitor.new(nil,"assignable",1,1)
     @@infer_visitor ||= Puppet::Pops::Visitor.new(nil,"infer",0,0)
+    @@infer_set_visitor ||= Puppet::Pops::Visitor.new(nil,"infer_set",0,0)
+    @@instance_of_visitor ||= Puppet::Pops::Visitor.new(nil,"instance_of",1,1)
     @@string_visitor ||= Puppet::Pops::Visitor.new(nil,"string",0,0)
+    @@inspect_visitor ||= Puppet::Pops::Visitor.new(nil,"debug_string",0,0)
+    @@enumerable_visitor ||= Puppet::Pops::Visitor.new(nil,"enumerable",0,0)
+    @@extract_visitor ||= Puppet::Pops::Visitor.new(nil,"extract",0,0)
+    @@generalize_visitor ||= Puppet::Pops::Visitor.new(nil,"generalize",0,0)
 
     da = Types::PArrayType.new()
     da.element_type = Types::PDataType.new()
@@ -83,13 +156,41 @@ class Puppet::Pops::Types::TypeCalculator
 
     h = Types::PHashType.new()
     h.element_type = Types::PDataType.new()
-    h.key_type = Types::PLiteralType.new()
+    h.key_type = Types::PScalarType.new()
     @data_hash = h
 
     @data_t = Types::PDataType.new()
-    @literal_t = Types::PLiteralType.new()
+    @scalar_t = Types::PScalarType.new()
     @numeric_t = Types::PNumericType.new()
     @t = Types::PObjectType.new()
+
+    # Data accepts a Tuple that has 0-infinity Data compatible entries (e.g. a Tuple equivalent to Array).
+    data_tuple = Types::PTupleType.new()
+    data_tuple.addTypes(Types::PDataType.new())
+    data_tuple.size_type = Types::PIntegerType.new()
+    data_tuple.size_type.from = 0
+    data_tuple.size_type.to = nil # infinity
+    @data_tuple_t = data_tuple
+
+    # Variant type compatible with Data
+    data_variant = Types::PVariantType.new()
+    data_variant.addTypes(@data_hash.copy)
+    data_variant.addTypes(@data_array.copy)
+    data_variant.addTypes(Types::PScalarType.new)
+    data_variant.addTypes(Types::PNilType.new)
+    data_variant.addTypes(@data_tuple_t.copy)
+    @data_variant_t = data_variant
+
+    collection_default_size = Types::PIntegerType.new()
+    collection_default_size.from = 0
+    collection_default_size.to = nil # infinity
+    @collection_default_size_t = collection_default_size
+
+    non_empty_string = Types::PStringType.new
+    non_empty_string.size_type = Types::PIntegerType.new()
+    non_empty_string.size_type.from = 1
+    non_empty_string.size_type.to = nil # infinity
+    @non_empty_string_t = non_empty_string
   end
 
   # Convenience method to get a data type for comparisons
@@ -99,6 +200,17 @@ class Puppet::Pops::Types::TypeCalculator
     @data_t
   end
 
+  # Convenience method to get a variant compatible with the Data type.
+  # @api private the returned value may not be contained in another element
+  #
+  def data_variant
+    @data_variant_t
+  end
+
+  def self.data_variant
+    singleton.data_variant
+  end
+
   # Answers the question 'is it possible to inject an instance of the given class'
   # A class is injectable if it has a special *assisted inject* class method called `inject` taking
   # an injector and a scope as argument, or if it has a zero args `initialize` method.
@@ -126,10 +238,8 @@ class Puppet::Pops::Types::TypeCalculator
   # @api public
   #
   def assignable?(t, t2)
-    # nil is assignable to anything
-    if is_pnil?(t2)
-      return true
-    end
+    # nil is assignable to anything except to required types
+    return true if is_pnil?(t2)
 
     if t.is_a?(Class)
       t = type(t)
@@ -139,11 +249,25 @@ class Puppet::Pops::Types::TypeCalculator
       t2 = type(t2)
     end
 
-    @@assignable_visitor.visit_this(self, t, t2)
+    @@assignable_visitor.visit_this_1(self, t, t2)
  end
 
+  # Returns an enumerable if the t represents something that can be iterated
+  def enumerable(t)
+    @@enumerable_visitor.visit_this_0(self, t)
+  end
+
+  # Answers if the two given types describe the same type
+  def equals(left, right)
+    return false unless left.is_a?(Types::PAbstractType) && right.is_a?(Types::PAbstractType)
+    # Types compare per class only - an extra test must be made if the are mutually assignable
+    # to find all types that represent the same type of instance
+    #
+    left  == right || (assignable?(right, left) && assignable?(left, right))
+  end
+
   # Answers 'what is the Puppet Type corresponding to the given Ruby class'
- # @param c [Class] the class for which a puppet type is wanted
+  # @param c [Class] the class for which a puppet type is wanted
   # @api public
   #
   def type(c)
@@ -160,7 +284,7 @@ class Puppet::Pops::Types::TypeCalculator
     when c == String
       type = Types::PStringType.new()
     when c == Regexp
-      type = Types::PPatternType.new()
+      type = Types::PRegexpType.new()
     when c == NilClass
       type = Types::PNilType.new()
     when c == FalseClass, c == TrueClass
@@ -172,9 +296,9 @@ class Puppet::Pops::Types::TypeCalculator
       type = Types::PArrayType.new()
       type.element_type = Types::PDataType.new()
     when c == Hash
-      # Assume hash with literal keys and data values
+      # Assume hash with scalar keys and data values
       type = Types::PHashType.new()
-      type.key_type = Types::PLiteralType.new()
+      type.key_type = Types::PScalarType.new()
       type.element_type = Types::PDataType.new()
     else
       type = Types::PRubyType.new()
@@ -183,25 +307,149 @@ class Puppet::Pops::Types::TypeCalculator
     type
   end
 
-  # Answers 'what is the Puppet Type of o'
+  # Generalizes value specific types. The given type is mutated and returned.
+  # @api public
+  def generalize!(o)
+    @@generalize_visitor.visit_this_0(self, o)
+    o.eAllContents.each { |x| @@generalize_visitor.visit_this_0(self, x) }
+    o
+  end
+
+  def generalize_Object(o)
+    # do nothing, there is nothing to change for most types
+  end
+
+  def generalize_PStringType(o)
+    o.values = []
+    o.size_type = nil
+    []
+  end
+
+  def generalize_PCollectionType(o)
+    # erase the size constraint from Array and Hash (if one exists, it is transformed to -Infinity - + Infinity, which is
+    # not desirable.
+    o.size_type = nil
+  end
+
+  def generalize_PFloatType(o)
+    o.to = nil
+    o.from = nil
+  end
+
+  def generalize_PIntegerType(o)
+    o.to = nil
+    o.from = nil
+  end
+
+  # Answers 'what is the single common Puppet Type describing o', or if o is an Array or Hash, what is the
+  # single common type of the elements (or keys and elements for a Hash).
   # @api public
   #
   def infer(o)
-    @@infer_visitor.visit_this(self, o)
+    @@infer_visitor.visit_this_0(self, o)
+  end
+
+  def infer_generic(o)
+    result = generalize!(infer(o))
+    result
+  end
+
+  # Answers 'what is the set of Puppet Types of o'
+  # @api public
+  #
+  def infer_set(o)
+    @@infer_set_visitor.visit_this_0(self, o)
+  end
+
+  def instance_of(t, o)
+#    return true if o.nil? && !t.is_a?(Types::PRequiredType)
+    @@instance_of_visitor.visit_this_1(self, t, o)
+  end
+
+  def instance_of_Object(t, o)
+    # Undef is Undef and Object, but nothing else when checking instance?
+    return false if (o.nil? || o == :undef) && t.class != Types::PObjectType
+    assignable?(t, infer(o))
+  end
+
+  def instance_of_PArrayType(t, o)
+    return false unless o.is_a?(Array)
+    return false unless o.all? {|element| instance_of(t.element_type, element) }
+    size_t = t.size_type || @collection_default_size_t
+    size_t2 = size_as_type(o)
+    assignable?(size_t, size_t2)
+  end
+
+  def instance_of_PTupleType(t, o)
+    return false unless o.is_a?(Array)
+    # compute the tuple's min/max size, and check if that size matches
+    from, to = size_range(t.size_type)
+    size_t = Types::PIntegerType.new()
+    size_t.from = t.types.size - 1 + from
+    size_t.to = t.types.size - 1 + to
+    # compute the array's size as type
+    size_t2 = size_as_type(o)
+    return false unless assignable?(size_t, size_t2)
+    o.each_with_index do |element, index|
+       return false unless instance_of(t.types[index] || t.types[-1], element)
+    end
+    true
+  end
+
+  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]) }
+  end
+
+  def instance_of_PHashType(t, o)
+    return false unless o.is_a?(Hash)
+    key_t = t.key_type
+    element_t = t.element_type
+    return false unless o.keys.all? {|key| instance_of(key_t, key) } && o.values.all? {|value| instance_of(element_t, value) }
+    size_t = t.size_type || @collection_default_size_t
+    size_t2 = size_as_type(o)
+    assignable?(size_t, size_t2)
+  end
+
+  def instance_of_PDataType(t, o)
+    instance_of(@data_variant_t, o)
+  end
+
+  def instance_of_PNilType(t, o)
+    return o.nil? || o == :undef
+  end
+
+  def instance_of_POptionalType(t, o)
+    return true if (o.nil? || o == :undef)
+    instance_of(t.optional_type, o)
+  end
+
+  def instance_of_PVariantType(t, o)
+    # instance of variant if o is instance? of any of variant's types
+    t.types.any? { |option_t| instance_of(option_t, o) }
+  end
+
+  # Answers 'is o an instance of type t'
+  # @api public
+  #
+  def self.instance?(t, o)
+    singleton.instance_of(t,o)
   end
 
   # Answers 'is o an instance of type t'
   # @api public
   #
   def instance?(t, o)
-    assignable?(t, infer(o))
+    instance_of(t,o)
   end
 
   # Answers if t is a puppet type
   # @api public
   #
   def is_ptype?(t)
-    return t.is_a?(Types::PObjectType)
+    return t.is_a?(Types::PAbstractType)
   end
 
   # Answers if t represents the puppet type PNilType
@@ -212,6 +460,9 @@ class Puppet::Pops::Types::TypeCalculator
   end
 
   # Answers, 'What is the common type of t1 and t2?'
+  #
+  # TODO: The current implementation should be optimized for performance
+  #
   # @api public
   #
   def common_type(t1, t2)
@@ -246,19 +497,97 @@ class Puppet::Pops::Types::TypeCalculator
       return type
     end
 
+    # when both are host-classes, reduce to PHostClass[] (since one was not assignable to the other)
+    if t1.is_a?(Types::PHostClassType) && t2.is_a?(Types::PHostClassType)
+      return Types::PHostClassType.new()
+    end
+
+    # when both are resources, reduce to Resource[T] or Resource[] (since one was not assignable to the other)
+    if t1.is_a?(Types::PResourceType) && t2.is_a?(Types::PResourceType)
+      result = Types::PResourceType.new()
+      # only Resource[] unless the type name is the same
+      if t1.type_name == t2.type_name then result.type_name = t1.type_name end
+      # the cross assignability test above has already determined that they do not have the same type and title
+      return result
+    end
+
+    # Integers have range, expand the range to the common range
+    if t1.is_a?(Types::PIntegerType) && t2.is_a?(Types::PIntegerType)
+      t1range = from_to_ordered(t1.from, t1.to)
+      t2range = from_to_ordered(t2.from, t2.to)
+      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
+      return t
+    end
+
+    # Floats have range, expand the range to the common range
+    if t1.is_a?(Types::PFloatType) && t2.is_a?(Types::PFloatType)
+      t1range = from_to_ordered(t1.from, t1.to)
+      t2range = from_to_ordered(t2.from, t2.to)
+      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
+      return t
+    end
+
+    if t1.is_a?(Types::PStringType) && t2.is_a?(Types::PStringType)
+      t = Types::PStringType.new()
+      t.values = t1.values | t2.values
+      return t
+    end
+
+    if t1.is_a?(Types::PPatternType) && t2.is_a?(Types::PPatternType)
+      t = Types::PPatternType.new()
+      # must make copies since patterns are contained types, not data-types
+      t.patterns = (t1.patterns | t2.patterns).map {|p| p.copy }
+      return t
+    end
+
+    if t1.is_a?(Types::PEnumType) && t2.is_a?(Types::PEnumType)
+      # The common type is one that complies with either set
+      t = Types::PEnumType.new
+      t.values = t1.values | t2.values
+      return t
+    end
+
+    if t1.is_a?(Types::PVariantType) && t2.is_a?(Types::PVariantType)
+      # The common type is one that complies with either set
+      t = Types::PVariantType.new
+      t.types = (t1.types | t2.types).map {|opt_t| opt_t.copy }
+      return t
+    end
+
+    if t1.is_a?(Types::PRegexpType) && t2.is_a?(Types::PRegexpType)
+      # if they were identical, the general rule would return a parameterized regexp
+      # since they were not, the result is a generic regexp type
+      return Types::PPatternType.new()
+    end
+
     # Common abstract types, from most specific to most general
     if common_numeric?(t1, t2)
       return Types::PNumericType.new()
     end
 
-    if common_literal?(t1, t2)
-      return Types::PLiteralType.new()
+    if common_scalar?(t1, t2)
+      return Types::PScalarType.new()
     end
 
     if common_data?(t1,t2)
       return Types::PDataType.new()
     end
 
+    # Meta types Type[Integer] + Type[String] => Type[Data]
+    if t1.is_a?(Types::PType) && t2.is_a?(Types::PType)
+      type = Types::PType.new()
+      type.type = common_type(t1.type, t2.type)
+      return type
+    end
+
     if t1.is_a?(Types::PRubyType) && t2.is_a?(Types::PRubyType)
       if t1.ruby_class == t2.ruby_class
         return t1
@@ -295,11 +624,19 @@ class Puppet::Pops::Types::TypeCalculator
     end
     result
   end
+
   # Produces a string representing the type
   # @api public
   #
   def string(t)
-    @@string_visitor.visit_this(self, t)
+    @@string_visitor.visit_this_0(self, t)
+  end
+
+  # Produces a debug string representing the type (possibly with more information that the regular string format)
+  # @api public
+  #
+  def debug_string(t)
+    @@inspect_visitor.visit_this_0(self, t)
   end
 
 
@@ -335,7 +672,9 @@ class Puppet::Pops::Types::TypeCalculator
   # @api private
   #
   def infer_PObjectType(o)
-    Types::PType.new()
+    type = Types::PType.new()
+    type.type = o.copy
+    type
   end
 
   # The type of all types is PType
@@ -343,27 +682,40 @@ class Puppet::Pops::Types::TypeCalculator
   # @api private
   #
   def infer_PType(o)
-    Types::PType.new()
+    type = Types::PType.new()
+    type.type = o.copy
+    type
   end
 
   # @api private
   def infer_String(o)
-    Types::PStringType.new()
+    t = Types::PStringType.new()
+    t.addValues(o)
+    t.size_type = size_as_type(o)
+    t
   end
 
   # @api private
   def infer_Float(o)
-    Types::PFloatType.new()
+    t = Types::PFloatType.new()
+    t.from = o
+    t.to = o
+    t
   end
 
   # @api private
   def infer_Integer(o)
-    Types::PIntegerType.new()
+    t = Types::PIntegerType.new()
+    t.from = o
+    t.to = o
+    t
   end
 
   # @api private
   def infer_Regexp(o)
-    Types::PPatternType.new()
+    t = Types::PRegexpType.new()
+    t.pattern = o.source
+    t
   end
 
   # @api private
@@ -371,6 +723,12 @@ class Puppet::Pops::Types::TypeCalculator
     Types::PNilType.new()
   end
 
+  # Inference of :undef as PNilType, all other are Ruby[Symbol]
+  # @api private
+  def infer_Symbol(o)
+    o == :undef ? infer_NilClass(o) : infer_Object(o)
+  end
+
   # @api private
   def infer_TrueClass(o)
     Types::PBooleanType.new()
@@ -381,14 +739,26 @@ class Puppet::Pops::Types::TypeCalculator
     Types::PBooleanType.new()
   end
 
+  # @api private
+  # A Puppet::Parser::Resource, or Puppet::Resource
+  #
+  def infer_Resource(o)
+    t = Types::PResourceType.new()
+    t.type_name = o.type.to_s
+    t.title = o.title
+    t
+  end
+
   # @api private
   def infer_Array(o)
     type = Types::PArrayType.new()
-    type.element_type = if o.empty?
+    type.element_type =
+    if o.empty?
       Types::PNilType.new()
     else
       infer_and_reduce_type(o)
     end
+    type.size_type = size_as_type(o)
     type
   end
 
@@ -404,9 +774,60 @@ class Puppet::Pops::Types::TypeCalculator
     end
     type.key_type = ktype
     type.element_type = etype
+    type.size_type = size_as_type(o)
     type
   end
 
+  def size_as_type(collection)
+    size = collection.size
+    t = Types::PIntegerType.new()
+    t.from = size
+    t.to = size
+    t
+  end
+
+  # Common case for everything that intrinsically only has a single type
+  def infer_set_Object(o)
+    infer(o)
+  end
+
+  def infer_set_Array(o)
+    type = Types::PArrayType.new()
+    type.element_type = if o.empty?
+      Types::PNilType.new()
+    else
+      t = Types::PVariantType.new()
+      t.types = o.map() {|x| infer_set(x) }
+      t.types.size == 1 ? t.types[0] : t
+    end
+    type.size_type = size_as_type(o)
+    type
+  end
+
+  def infer_set_Hash(o)
+    type = Types::PHashType.new()
+    if o.empty?
+      ktype = Types::PNilType.new()
+      etype = Types::PNilType.new()
+    else
+      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) }
+    end
+    type.key_type = unwrap_single_variant(ktype)
+    type.element_type = unwrap_single_variant(vtype)
+    type.size_type = size_as_type(o)
+    type
+  end
+
+  def unwrap_single_variant(possible_variant)
+    if possible_variant.is_a?(Types::PVariantType) && possible_variant.types.size == 1
+      possible_variant.types[0]
+    else
+      possible_variant
+    end
+  end
   # False in general type calculator
   # @api private
   def assignable_Object(t, t2)
@@ -419,8 +840,14 @@ class Puppet::Pops::Types::TypeCalculator
   end
 
   # @api private
-  def assignable_PLiteralType(t, t2)
-    t2.is_a?(Types::PLiteralType)
+  def assignable_PNilType(t, t2)
+    # Only undef/nil is assignable to nil type
+    t2.is_a?(Types::PNilType)
+  end
+
+  # @api private
+  def assignable_PScalarType(t, t2)
+    t2.is_a?(Types::PScalarType)
   end
 
   # @api private
@@ -430,17 +857,250 @@ class Puppet::Pops::Types::TypeCalculator
 
   # @api private
   def assignable_PIntegerType(t, t2)
-    t2.is_a?(Types::PIntegerType)
+    return false unless t2.is_a?(Types::PIntegerType)
+    trange =  from_to_ordered(t.from, t.to)
+    t2range = from_to_ordered(t2.from, t2.to)
+    # If t2 min and max are within the range of t
+    trange[0] <= t2range[0] && trange[1] >= t2range[1]
+  end
+
+  # Transform int range to a size constraint
+  # if range == nil the constraint is 1,1
+  # if range.from == nil min size = 1
+  # if range.to == nil max size == Infinity
+  #
+  def size_range(range)
+    return [1,1] if range.nil?
+    from = range.from
+    to = range.to
+    x = from.nil? ? 1 : from
+    y = to.nil? ? TheInfinity : 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
+    if x < y
+      [x, y]
+    else
+      [y, x]
+    end
+  end
+
+  # @api private
+  def assignable_PVariantType(t, t2)
+    # Data is a specific variant
+    t2 = @data_variant_t if t2.is_a?(Types::PDataType)
+    if t2.is_a?(Types::PVariantType)
+      # A variant is assignable if all of its options are assignable to one of this type's options
+      return true if t == t2
+      t2.types.all? do |other|
+        # if the other is a Variant, all if its options, but be assignable to one of this type's options
+        other = other.is_a?(Types::PDataType) ? @data_variant_t : other
+        if other.is_a?(Types::PVariantType)
+          assignable?(t, other)
+        else
+          t.types.any? {|option_t| assignable?(option_t, other) }
+        end
+      end
+    else
+      # A variant is assignable if t2 is assignable to any of its types
+      t.types.any? { |option_t| assignable?(option_t, t2) }
+    end
+  end
+
+  def assignable_PTupleType(t, t2)
+    return true if t == t2 || t.types.empty? && (t2.is_a?(Types::PArrayType))
+    t_regular = t.types[0..-2]
+    t_ranged = t.types[-1]
+    t_from, t_to = size_range(t.size_type)
+    t_required = t_regular.size + t_from
+
+    if t2.is_a?(Types::PTupleType)
+      t2_regular = t2.types[0..-2]
+      t2_ranged = t2.types[-1]
+      t2_from, t2_to = size_range(t2.size_type)
+      t2_required = t2_regular.size + t2_from
+
+      # tuples with fewer required entries can not be assigned
+      return false if t_required > t2_required
+      # tuples with more optionally available entries can not be assigned
+      return false if t_regular.size + t_to < t2_regular.size + t2_to
+
+      t_required.times do |index|
+        t_entry = tuple_entry_at(t, t_from, t_to, index)
+        t2_entry = tuple_entry_at(t2, t2_from, t2_to, index)
+        return false if t2_entry.nil? || !assignable?(t_entry, t2_entry)
+      end
+      # Handle remainder in t2's required
+      (t2_required - t_required).times do |index|
+        t_entry = tuple_entry_at(t, t_from, t_to, t_required + index)
+        t2_entry = tuple_entry_at(t2, t2_from, t2_to, t_required + index)
+        return false if t2_entry.nil? || !assignable?(t_entry, t2_entry)
+      end
+      # Now only a trailing optional type remains - the last type must always be compatible
+      # irrespective of optionality and count
+      #
+      return assignable?(t_ranged, t2_ranged)
+
+    elsif t2.is_a?(Types::PArrayType)
+      t2_entry = t2.element_type
+
+      # Array of anything can not be assigned (unless tuple is tuple of anything) - this case
+      # was handled at the top of this method.
+      #
+      return false if t2_entry.nil?
+
+      # array type may be size constrained
+      size_t = t2.size_type || @collection_default_size_t
+      min, max = size_t.range
+      # Array with fewer min entries can not be assigned
+      return false if t_required > min
+      # Array with more optionally available entries can not be assigned
+      return false if t_regular.size + t_to < max
+      # each tuple type must be assignable to the element type
+      t_required.times do |index|
+        t_entry = tuple_entry_at(t, t_from, t_to, index)
+        return false unless assignable?(t_entry, t2_entry)
+      end
+      # ... and so must the last, possibly optional (ranged) type
+      return assignable?(t_ranged, t2_entry)
+    end
+  end
+
+  # Produces the tuple entry at the given index given a tuple type, its from/to constraints on the last
+  # type, and an index.
+  # Produces nil if the index is out of bounds
+  # from must be less than to, and from may not be less than 0
+  #
+  # @api private
+  #
+  def tuple_entry_at(tuple_t, from, to, index)
+    regular = (tuple_t.types.size - 1)
+    if index < regular
+      tuple_t.types[index]
+    elsif index < regular + to
+      # in the varargs part
+      tuple_t.types[-1]
+    else
+      nil
+    end
+  end
+
+  # @api private
+  #
+  def assignable_PStructType(t, t2)
+    return true if t == t2 || t.elements.empty? && (t2.is_a?(Types::PHashType))
+    h = t.hashed_elements
+    if t2.is_a?(Types::PStructType)
+      h2 = t2.hashed_elements
+      h.size == h2.size && h.all? {|k, v| assignable?(v, h2[k]) }
+    elsif t2.is_a?(Types::PHashType)
+      size_t2 = t2.size_type || @collection_default_size_t
+      size_t = Types::PIntegerType.new
+      size_t.from = size_t.to = h.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?(size_t, size_t2) &&
+        assignable?(@non_empty_string_t, t2.key_type) &&
+        h.all? {|k,v| assignable?(v, element_type) }
+    else
+      false
+    end
+  end
+
+  # @api private
+  def assignable_POptionalType(t, t2)
+    return true if t2.is_a?(Types::PNilType)
+    if t2.is_a?(Types::POptionalType)
+      assignable?(t.optional_type, t2.optional_type)
+    else
+      assignable?(t.optional_type, t2)
+    end
+  end
+
+  # @api private
+  def assignable_PEnumType(t, t2)
+    return true if t == t2 || (t.values.empty? && (t2.is_a?(Types::PStringType) || t2.is_a?(Types::PEnumType)))
+    if t2.is_a?(Types::PStringType)
+      # if the set of strings are all found in the set of enums
+      t2.values.all? { |s| t.values.any? { |e| e == s }}
+    else
+      false
+    end
   end
 
   # @api private
   def assignable_PStringType(t, t2)
-    t2.is_a?(Types::PStringType)
+    if t.values.empty?
+      # A general string is assignable by any other string or pattern restricted string
+      # if the string has a size constraint it does not match since there is no reasonable way
+      # to compute the min/max length a pattern will match. For enum, it is possible to test that
+      # each enumerator value is within range
+      size_t = t.size_type || @collection_default_size_t
+      case t2
+      when Types::PStringType
+        # true if size compliant
+        size_t2 = t2.size_type || @collection_default_size_t
+        assignable?(size_t, size_t2)
+
+      when Types::PPatternType
+        # true if size constraint is at least 0 to +Infinity (which is the same as the default)
+        assignable?(size_t, @collection_default_size_t)
+
+      when Types::PEnumType
+        if t2.values
+          # true if all enum values are within range
+          min, max = t2.values.map(&:size).minmax
+          trange =  from_to_ordered(size_t.from, size_t.to)
+          t2range = [min, max]
+          # If t2 min and max are within the range of t
+          trange[0] <= t2range[0] && trange[1] >= t2range[1]
+        else
+          # no string can match this enum anyway since it does not accept anything
+          false
+        end
+      end
+    elsif t2.is_a?(Types::PStringType)
+      # A specific string acts as a set of strings - must have exactly the same strings
+      # In this case, size does not matter since the definition is very precise anyway
+      Set.new(t.values) == Set.new(t2.values)
+    else
+      # All others are false, since no other type describes the same set of specific strings
+      false
+    end
+  end
+
+  # @api private
+  def assignable_PPatternType(t, t2)
+    return true if t == t2
+    return false unless t2.is_a?(Types::PStringType) || t2.is_a?(Types::PEnumType)
+
+    if t2.values.empty?
+      # Strings / Enums (unknown which ones) cannot all match a pattern, but if there is no pattern it is ok
+      # (There should really always be a pattern, but better safe than sorry).
+      return t.patterns.empty? ? true : false
+    end
+    # all strings in String/Enum type must match one of the patterns in Pattern type
+    regexps = t.patterns.map {|p| p.regexp }
+    t2.values.all? { |v| regexps.any? {|re| re.match(v) } }
   end
 
   # @api private
   def assignable_PFloatType(t, t2)
-    t2.is_a?(Types::PFloatType)
+    return false unless t2.is_a?(Types::PFloatType)
+    trange =  from_to_ordered(t.from, t.to)
+    t2range = from_to_ordered(t2.from, t2.to)
+    # If t2 min and max are within the range of t
+    trange[0] <= t2range[0] && trange[1] >= t2range[1]
   end
 
   # @api private
@@ -449,39 +1109,142 @@ class Puppet::Pops::Types::TypeCalculator
   end
 
   # @api private
-  def assignable_PPatternType(t, t2)
-    t2.is_a?(Types::PPatternType)
+  def assignable_PRegexpType(t, t2)
+    t2.is_a?(Types::PRegexpType) && (t.pattern.nil? || t.pattern == t2.pattern)
   end
 
   # @api private
   def assignable_PCollectionType(t, t2)
-    t2.is_a?(Types::PCollectionType)
+    size_t = t.size_type || @collection_default_size_t
+    case t2
+    when Types::PCollectionType
+      size_t2 = t2.size_type || @collection_default_size_t
+      assignable?(size_t, size_t2)
+    when Types::PTupleType
+      # compute the tuple's min/max size, and check if that size matches
+      from, to = size_range(t2.size_type)
+      t2s = Types::PIntegerType.new()
+      t2s.from = t2.types.size - 1 + from
+      t2s.to = t2.types.size - 1 + to
+      assignable?(size_t, t2s)
+    when Types::PStructType
+      from = to = t2.elements.size
+      t2s = Types::PIntegerType.new()
+      t2s.from = from
+      t2s.to = to
+      assignable?(size_t, t2s)
+    else
+      false
+    end
+  end
+
+  # @api private
+  def assignable_PType(t, t2)
+    return false unless t2.is_a?(Types::PType)
+    return true if t.type.nil? # wide enough to handle all types
+    return false if t2.type.nil? # wider than t
+    assignable?(t.type, t2.type)
   end
 
-  # Array is assignable if t2 is an Array and t2's element type is assignable
+  # 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)
-    return false unless t2.is_a?(Types::PArrayType)
-    assignable?(t.element_type, t2.element_type)
+    if t2.is_a?(Types::PArrayType)
+      return false unless assignable?(t.element_type, t2.element_type)
+      assignable_PCollectionType(t, t2)
+
+    elsif t2.is_a?(Types::PTupleType)
+      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)
+      t2_required = t2_regular.size + t2_from
+
+      t_entry = t.element_type
+
+      # Tuple of anything can not be assigned (unless array is tuple of anything) - this case
+      # was handled at the top of this method.
+      #
+      return false if t_entry.nil?
+
+      # array type may be size constrained
+      size_t = t.size_type || @collection_default_size_t
+      min, max = size_t.range
+      # Tuple with fewer min entries can not be assigned
+      return false if t2_required < min
+      # Tuple with more optionally available entries can not be assigned
+      return false if t2_regular.size + t2_to > max
+      # each tuple type must be assignable to the element type
+      t2_required.times do |index|
+        t2_entry = tuple_entry_at(t2, t2_from, t2_to, index)
+        return false unless assignable?(t_entry, t2_entry)
+      end
+      # ... and so must the last, possibly optional (ranged) type
+      return assignable?(t_entry, t2_ranged)
+    else
+      false
+    end
   end
 
   # Hash is assignable if t2 is a Hash and t2's key and element types are assignable
   # @api private
   def assignable_PHashType(t, t2)
-    return false unless t2.is_a?(Types::PHashType)
-    assignable?(t.key_type, t2.key_type) && assignable?(t.element_type, t2.element_type)
+    case t2
+    when Types::PHashType
+      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
+      # hash must accept all value types
+      # hash must accept the size of the struct
+      size_t = t.size_type || @collection_default_size_t
+      min, max = size_t.range
+      struct_size = t2.elements.size
+      element_type = t.element_type
+      ( struct_size >= min && struct_size <= max &&
+        assignable?(t.key_type, @non_emptry_string_t)  &&
+        t2.hashed_elements.all? {|k,v| assignable?(element_type, v) })
+    else
+      false
+    end
   end
 
-  # Data is assignable by other Data and by Array[Data] and Hash[Literal, Data]
+  # @api private
+  def assignable_PCatalogEntryType(t1, t2)
+    t2.is_a?(Types::PCatalogEntryType)
+  end
+
+  # @api private
+  def assignable_PHostClassType(t1, t2)
+    return false unless t2.is_a?(Types::PHostClassType)
+    # Class = Class[name}, Class[name] != Class
+    return true if t1.class_name.nil?
+    # Class[name] = Class[name]
+    return t1.class_name == t2.class_name
+  end
+
+  # @api private
+  def assignable_PResourceType(t1, t2)
+    return false unless t2.is_a?(Types::PResourceType)
+    return true if t1.type_name.nil?
+    return false if t1.type_name != t2.type_name
+    return true if t1.title.nil?
+    return t1.title == t2.title
+  end
+
+  # 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_array, t2) || assignable?(@data_hash, t2)
+    t2.is_a?(Types::PDataType) || assignable?(@data_variant_t, t2)
   end
 
   # Assignable if t2's ruby class is same or subclass of t1's ruby class
   # @api private
   def assignable_PRubyType(t1, t2)
     return false unless t2.is_a?(Types::PRubyType)
+    return true if t1.ruby_class.nil?   # t1 is wider
+    return false if t2.ruby_class.nil?  # t1 not nil, so t2 can not be wider
     c1 = class_from_string(t1.ruby_class)
     c2 = class_from_string(t2.ruby_class)
     return false unless c1.is_a?(Class) && c2.is_a?(Class)
@@ -489,16 +1252,36 @@ class Puppet::Pops::Types::TypeCalculator
   end
 
   # @api private
-  def string_PType(t)        ; "Type"    ; end
+  def debug_string_Object(t)
+    string(t)
+  end
+
+  # @api private
+  def string_PType(t)
+    if t.type.nil?
+      "Type"
+    else
+      "Type[#{string(t.type)}]"
+    end
+  end
+
+  # @api private
+  def string_NilClass(t)     ; '?'       ; end
+
+  # @api private
+  def string_String(t)       ; t         ; end
 
   # @api private
   def string_PObjectType(t)  ; "Object"  ; end
 
+  # @api private
+  def string_PNilType(t)     ; 'Undef'   ; end
+
   # @api private
   def string_PBooleanType(t) ; "Boolean" ; end
 
   # @api private
-  def string_PLiteralType(t) ; "Literal" ; end
+  def string_PScalarType(t) ; "Scalar" ; end
 
   # @api private
   def string_PDataType(t)    ; "Data"    ; end
@@ -507,35 +1290,177 @@ class Puppet::Pops::Types::TypeCalculator
   def string_PNumericType(t) ; "Numeric" ; end
 
   # @api private
-  def string_PIntegerType(t) ; "Integer" ; end
+  def string_PIntegerType(t)
+    range = range_array_part(t)
+    unless range.empty?
+      "Integer[#{range.join(', ')}]"
+    else
+      "Integer"
+    end
+  end
 
+  # Produces a string from an Integer range type that is used inside other type strings
   # @api private
-  def string_PFloatType(t)   ; "Float"   ; end
+  def range_array_part(t)
+    return [] if t.nil? || (t.from.nil? && t.to.nil?)
+    [t.from.nil? ? 'default' : t.from , t.to.nil? ? 'default' : t.to ]
+  end
 
   # @api private
-  def string_PPatternType(t) ; "Pattern" ; end
+  def string_PFloatType(t)
+    range = range_array_part(t)
+    unless range.empty?
+      "Float[#{range.join(', ')}]"
+    else
+      "Float"
+    end
+  end
 
   # @api private
-  def string_PStringType(t)  ; "String"  ; end
+  def string_PRegexpType(t)
+    t.pattern.nil? ? "Regexp" : "Regexp[#{t.regexp.inspect}]"
+  end
+
+  # @api private
+  def string_PStringType(t)
+    # skip values in regular output - see debug_string
+    range = range_array_part(t.size_type)
+    unless range.empty?
+      "String[#{range.join(', ')}]"
+    else
+      "String"
+    end
+  end
 
   # @api private
-  def string_PRubyType(t)   ; "Ruby[#{t.ruby_class}]"  ; end
+  def debug_string_PStringType(t)
+    range = range_array_part(t.size_type)
+    range_part = range.empty? ? '' : '[' << range.join(' ,') << '], '
+    "String[" << range_part << (t.values.map {|s| "'#{s}'" }).join(', ') << ']'
+  end
+
+  # @api private
+  def string_PEnumType(t)
+    return "Enum" if t.values.empty?
+    "Enum[" << t.values.map {|s| "'#{s}'" }.join(', ') << ']'
+  end
+
+  # @api private
+  def string_PVariantType(t)
+    return "Variant" if t.types.empty?
+    "Variant[" << t.types.map {|t2| string(t2) }.join(', ') << ']'
+  end
+
+  # @api private
+  def string_PTupleType(t)
+    range = range_array_part(t.size_type)
+    return "Tuple" if t.types.empty?
+    s = "Tuple[" << t.types.map {|t2| string(t2) }.join(', ')
+    unless range.empty?
+      s << ", " << range.join(', ')
+    end
+    s << "]"
+    s
+  end
+
+  # @api private
+  def string_PStructType(t)
+    return "Struct" if t.elements.empty?
+    "Struct[{" << t.elements.map {|element| string(element) }.join(', ') << "}]"
+  end
+
+  def string_PStructElement(t)
+    "'#{t.name}'=>#{string(t.type)}"
+  end
+
+  # @api private
+  def string_PPatternType(t)
+    return "Pattern" if t.patterns.empty?
+    "Pattern[" << t.patterns.map {|s| "#{s.regexp.inspect}" }.join(', ') << ']'
+  end
+
+  # @api private
+  def string_PCollectionType(t)
+    range = range_array_part(t.size_type)
+    unless range.empty?
+      "Collection[#{range.join(', ')}]"
+    else
+      "Collection"
+    end
+  end
+
+  # @api private
+  def string_PRubyType(t)   ; "Ruby[#{string(t.ruby_class)}]"  ; end
 
   # @api private
   def string_PArrayType(t)
-    "Array[#{string(t.element_type)}]"
+    parts = [string(t.element_type)] + range_array_part(t.size_type)
+    "Array[#{parts.join(', ')}]"
   end
 
   # @api private
   def string_PHashType(t)
-    "Hash[#{string(t.key_type)}, #{string(t.element_type)}]"
+    parts = [string(t.key_type), string(t.element_type)] + range_array_part(t.size_type)
+    "Hash[#{parts.join(', ')}]"
+  end
+
+  # @api private
+  def string_PCatalogEntryType(t)
+    "CatalogEntry"
+  end
+
+  # @api private
+  def string_PHostClassType(t)
+    if t.class_name
+      "Class[#{t.class_name}]"
+    else
+      "Class"
+    end
+  end
+
+  # @api private
+  def string_PResourceType(t)
+    if t.type_name
+      if t.title
+        "#{t.type_name.capitalize}['#{t.title}']"
+      else
+        "#{t.type_name.capitalize}"
+      end
+    else
+      "Resource"
+    end
+  end
+
+  def string_POptionalType(t)
+    if t.optional_type.nil?
+      "Optional"
+    else
+      "Optional[#{string(t.optional_type)}]"
+    end
+  end
+
+  # Catches all non enumerable types
+  # @api private
+  def enumerable_Object(o)
+    nil
+  end
+
+  # @api private
+  def enumerable_PIntegerType(t)
+    # Not enumerable if representing an infinite range
+    return nil if t.size == TheInfinity
+    t
   end
 
   private
 
   def class_from_string(str)
-    str.split('::').inject(Object) do |memo, name_segment|
-      memo.const_get(name_segment)
+    begin
+      str.split('::').inject(Object) do |memo, name_segment|
+        memo.const_get(name_segment)
+      end
+    rescue NameError
+      return nil
     end
   end
 
@@ -543,8 +1468,8 @@ class Puppet::Pops::Types::TypeCalculator
     assignable?(@data_t, t1) && assignable?(@data_t, t2)
   end
 
-  def common_literal?(t1, t2)
-    assignable?(@literal_t, t1) && assignable?(@literal_t, t2)
+  def common_scalar?(t1, t2)
+    assignable?(@scalar_t, t1) && assignable?(@scalar_t, t2)
   end
 
   def common_numeric?(t1, t2)