puppet 4.3.2-x64-mingw32 → 4.4.0-x64-mingw32

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

@@ -0,0 +1,82 @@
+module Puppet::Pops
+module Types
+# Keeps track of self recursion of conceptual 'this' and 'that' instances using two separate maps and
+# a state. The class is used when tracking self recursion in two objects ('this' and 'that') simultaneously.
+# A typical example of when this is needed is when testing if 'that' Puppet Type is assignable to 'this'
+# Puppet Type since both types may contain self references.
+#
+# All comparisons are made using the `object_id` of the instance rather than the instance itself.
+#
+# @api private
+class RecursionGuard
+  attr_reader :state
+
+  NO_SELF_RECURSION = 0
+  SELF_RECURSION_IN_THIS = 1
+  SELF_RECURSION_IN_THAT = 2
+  SELF_RECURSION_IN_BOTH = 3
+
+  def initialize
+    @state = NO_SELF_RECURSION
+  end
+
+  # Checks if recursion was detected for the given argument in the 'this' context
+  # @param instance [Object] the instance to check
+  # @return [Integer] the resulting state
+  def recursive_this?(instance)
+    this_map[instance.object_id] == true
+  end
+
+  # Checks if recursion was detected for the given argument in the 'that' context
+  # @param instance [Object] the instance to check
+  # @return [Integer] the resulting state
+  def recursive_that?(instance)
+    that_map[instance.object_id] == true
+  end
+
+  # Add the given argument as 'this' and return the resulting state
+  # @param instance [Object] the instance to add
+  # @return [Integer] the resulting state
+  def add_this(instance)
+    if (@state & SELF_RECURSION_IN_THIS) == 0
+      @state = @state | SELF_RECURSION_IN_THIS if map_put(this_map, instance)
+    end
+    @state
+  end
+
+  # Add the given argument as 'that' and return the resulting state
+  # @param instance [Object] the instance to add
+  # @return [Integer] the resulting state
+  def add_that(instance)
+    if (@state & SELF_RECURSION_IN_THAT) == 0
+      @state = @state | SELF_RECURSION_IN_THAT if map_put(that_map, instance)
+    end
+    @state
+  end
+
+  private
+
+  def map_put(map, o)
+    id = o.object_id
+    case map[id]
+    when true
+      true # Recursion already detected
+    when false
+      map[id] = true
+      true # Recursion occured. This was the second time this entry was added
+    else
+      map[id] = false
+      false # First time add. No recursion
+    end
+  end
+
+  def this_map
+    @this_map ||= {}
+  end
+
+  def that_map
+    @that_map ||= {}
+  end
+end
+end
+end

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

@@ -0,0 +1,25 @@
+module Puppet::Pops
+module Types
+# Implements a standard visitor patter for the Puppet Type system.
+
+#
+# An instance of this module is passed as an argument to the {PAnyType#accept}
+# method of a Type instance. That type will then use the {TypeAcceptor#visit} callback
+# on the acceptor and then pass the acceptor to the `accept` method of all contained
+# type instances so that the it gets a visit from each one recursively.
+#
+module TypeAcceptor
+  # @param type [PAnyType] the type that we accept a visit from
+  # @param quard [RecursionGuard] the guard against self recursion
+  def visit(type, guard)
+  end
+end
+
+# An acceptor that does nothing
+class NoopTypeAcceptor
+  include TypeAcceptor
+
+  INSTANCE = NoopTypeAcceptor.new
+end
+end
+end

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

@@ -5,13 +5,14 @@ module 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 subject [String,Array] String to be prepended to the exception message or Array where the first element is
+  #   a format string and the rest are arguments to that format string
   # @param expected_type [PAnyType] Expected type
   # @param type_to_check [PAnyType] Type to check against the required type
   # @return The type_to_check argument
   #
   # @api public
-  def self.assert_assignable(subject, expected_type, type_to_check)
+  def self.assert_assignable(subject, expected_type, type_to_check, &block)
     report_type_mismatch(subject, expected_type, type_to_check) unless expected_type.assignable?(type_to_check)
     type_to_check
   end
@@ -19,26 +20,26 @@ module TypeAsserter
   # 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 subject [String,Array] String to be prepended to the exception message or Array where the first element is
+  #                               a format string and the rest are arguments to that format string
   # @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
   #
   # @api public
-  def self.assert_instance_of(subject, expected_type, value, nil_ok = false)
+  def self.assert_instance_of(subject, expected_type, value, nil_ok = false, &block)
     unless value.nil? && nil_ok
-      report_type_mismatch(subject, expected_type, TypeCalculator.singleton.infer_set(value).generalize) unless expected_type.instance?(value)
+      report_type_mismatch(subject, expected_type, TypeCalculator.singleton.infer_set(value).generalize, &block) unless expected_type.instance?(value)
     end
     value
   end
 
   def self.report_type_mismatch(subject, 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).
-    #
+    subject = yield(subject) if block_given?
+    subject = subject[0] % subject[1..-1] if subject.is_a?(Array)
     raise TypeAssertionError.new(
-        "#{subject} value has wrong type, expected #{expected_type}, actual #{actual_type}", expected_type, actual_type)
+      TypeMismatchDescriber.singleton.describe_mismatch("#{subject} has wrong type,", expected_type, actual_type), expected_type, actual_type)
   end
   private_class_method :report_type_mismatch
 end

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

@@ -1,3 +1,5 @@
+module Puppet::Pops
+module Types
 # The TypeCalculator can answer questions about puppet types.
 #
 # The Puppet type system is primarily based on sub-classing. When asking the type calculator to infer types from Ruby in general, it
@@ -41,8 +43,8 @@
 #
 # Creation of Type instances
 # --------------------------
-# Instance of the classes in the {Puppet::Pops::Types type model} are used to denote a specific type. It is most convenient
-# to use the {Puppet::Pops::Types::TypeFactory TypeFactory} when creating instances.
+# Instance of the classes in the {Types type model} are used to denote a specific type. It is most convenient
+# to use the {TypeFactory} when creating instances.
 #
 # @note
 #   In general, new instances of the wanted type should be created as they are assigned to models using containment, and a
@@ -82,9 +84,9 @@
 # no instances present in the first place. If however the classes are not present, the type
 # calculator will fall back and state that the two types at least have Any in common.
 #
-# @see Puppet::Pops::Types::TypeFactory TypeFactory for how to create instances of types
-# @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
+# @see TypeFactory for how to create instances of types
+# @see TypeParser how to construct a type instance from a String
+# @see Types for details about the type model
 #
 # Using the Type Calculator
 # -----
@@ -96,9 +98,7 @@
 #
 # @api public
 #
-class Puppet::Pops::Types::TypeCalculator
-
-  Types = Puppet::Pops::Types
+class TypeCalculator
 
   # @api public
   def self.assignable?(t1, t2)
@@ -106,8 +106,8 @@ class Puppet::Pops::Types::TypeCalculator
   end
 
   # Answers, does the given callable accept the arguments given in args (an array or a tuple)
-  # @param callable [Puppet::Pops::Types::PCallableType] - the callable
-  # @param args [Puppet::Pops::Types::PArrayType, Puppet::Pops::Types::PTupleType] args optionally including a lambda callable at the end
+  # @param callable [PCallableType] - the callable
+  # @param args [PArrayType, PTupleType] args optionally including a lambda callable at the end
   # @return [Boolan] true if the callable accepts the arguments
   #
   # @api public
@@ -116,13 +116,14 @@ class Puppet::Pops::Types::TypeCalculator
   end
 
   # Produces a String representation of the given type.
-  # @param t [Puppet::Pops::Types::PAnyType] the type to produce a string form
+  # @param t [PAnyType] the type to produce a string form
   # @return [String] the type in string form
   #
   # @api public
   #
   def self.string(t)
-    singleton.string(t)
+    Puppet.deprecation_warning('TypeCalculator.string is deprecated. Use TypeFormatter')
+    TypeFormatter.string(t)
   end
 
   # @api public
@@ -142,12 +143,19 @@ class Puppet::Pops::Types::TypeCalculator
 
   # @api public
   def self.debug_string(t)
-    singleton.debug_string(t)
+    Puppet.deprecation_warning('TypeCalculator.debug_string is deprecated. Use TypeFormatter')
+    TypeFormatter.debug_string(t)
   end
 
   # @api public
   def self.enumerable(t)
-    singleton.enumerable(t)
+    Puppet.deprecation_warning('TypeCalculator.enumerable is deprecated. Use iterable')
+    singleton.iterable(t)
+  end
+
+  # @api public
+  def self.iterable(t)
+    singleton.iterable(t)
   end
 
   # @return [TypeCalculator] the singleton instance
@@ -160,10 +168,8 @@ class Puppet::Pops::Types::TypeCalculator
   # @api public
   #
   def initialize
-    @@infer_visitor ||= Puppet::Pops::Visitor.new(nil, 'infer',0,0)
-    @@string_visitor ||= Puppet::Pops::Visitor.new(nil, 'string',0,0)
-    @@inspect_visitor ||= Puppet::Pops::Visitor.new(nil, 'debug_string',0,0)
-    @@extract_visitor ||= Puppet::Pops::Visitor.new(nil, 'extract',0,0)
+    @@infer_visitor ||= Visitor.new(nil, 'infer',0,0)
+    @@extract_visitor ||= Visitor.new(nil, 'extract',0,0)
   end
 
   # Answers the question 'is it possible to inject an instance of the given class'
@@ -176,12 +182,12 @@ class Puppet::Pops::Types::TypeCalculator
   #
   def injectable_class(klazz)
     # Handle case when we get a PType instead of a class
-    if klazz.is_a?(Types::PRuntimeType)
-      klazz = Puppet::Pops::Types::ClassLoader.provide(klazz)
+    if klazz.is_a?(PRuntimeType)
+      klazz = ClassLoader.provide(klazz)
     end
 
     # data types can not be injected (check again, it is not safe to assume that given RubyRuntime klazz arg was ok)
-    return false unless type(klazz).is_a?(Types::PRuntimeType)
+    return false unless type(klazz).is_a?(PRuntimeType)
     if (klazz.respond_to?(:inject) && klazz.method(:inject).arity == -4) || klazz.instance_method(:initialize).arity == 0
       klazz
     else
@@ -198,24 +204,30 @@ class Puppet::Pops::Types::TypeCalculator
     if t.is_a?(Module)
       t = type(t)
     end
-    t.is_a?(Types::PAnyType) ? t.assignable?(t2) : false
+    t.is_a?(PAnyType) ? t.assignable?(t2) : false
  end
 
-  # Returns an enumerable if the t represents something that can be iterated
+  # Returns an iterable if the t represents something that can be iterated
   def enumerable(t)
-    # Only PIntegerTypes are enumerable and only if not representing an infinite range
-    t.is_a?(Types::PIntegerType) && t.size < Float::INFINITY ? t : nil
+    Puppet.deprecation_warning('TypeCalculator.enumerable is deprecated. Use iterable')
+    iterable(t)
+  end
+
+  # Returns an iterable if the t represents something that can be iterated
+  def iterable(t)
+    # Create an iterable on the type if possible
+    Iterable.on(t)
   end
 
   # Answers, does the given callable accept the arguments given in args (an array or a tuple)
   #
   def callable?(callable, args)
-    callable.is_a?(Types::PAnyType) && callable.callable?(args)
+    callable.is_a?(PAnyType) && callable.callable?(args)
   end
 
   # Answers if the two given types describe the same type
   def equals(left, right)
-    return false unless left.is_a?(Types::PAnyType) && right.is_a?(Types::PAnyType)
+    return false unless left.is_a?(PAnyType) && right.is_a?(PAnyType)
     # 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
     #
@@ -232,29 +244,29 @@ class Puppet::Pops::Types::TypeCalculator
     # Can't use a visitor here since we don't have an instance of the class
     case
     when c <= Integer
-      type = Types::PIntegerType::DEFAULT
+      type = PIntegerType::DEFAULT
     when c == Float
-      type = Types::PFloatType::DEFAULT
+      type = PFloatType::DEFAULT
     when c == Numeric
-      type = Types::PNumericType::DEFAULT
+      type = PNumericType::DEFAULT
     when c == String
-      type = Types::PStringType::DEFAULT
+      type = PStringType::DEFAULT
     when c == Regexp
-      type = Types::PRegexpType::DEFAULT
+      type = PRegexpType::DEFAULT
     when c == NilClass
-      type = Types::PUndefType::DEFAULT
+      type = PUndefType::DEFAULT
     when c == FalseClass, c == TrueClass
-      type = Types::PBooleanType::DEFAULT
+      type = PBooleanType::DEFAULT
     when c == Class
-      type = Types::PType::DEFAULT
+      type = PType::DEFAULT
     when c == Array
       # Assume array of data values
-      type = Types::PArrayType::DATA
+      type = PArrayType::DATA
     when c == Hash
       # Assume hash with scalar keys and data values
-      type = Types::PHashType::DATA
+      type = PHashType::DATA
    else
-      type = Types::PRuntimeType.new(:ruby, c.name)
+      type = PRuntimeType.new(:ruby, c.name)
     end
     type
   end
@@ -262,7 +274,7 @@ class Puppet::Pops::Types::TypeCalculator
   # Generalizes value specific types. The generalized type is returned.
   # @api public
   def generalize(o)
-    o.is_a?(Types::PAnyType) ? o.generalize : o
+    o.is_a?(PAnyType) ? o.generalize : o
   end
 
   # Answers 'what is the single common Puppet Type describing o', or if o is an Array or Hash, what is the
@@ -280,7 +292,7 @@ class Puppet::Pops::Types::TypeCalculator
       infer_Array(o)
     when Hash
       infer_Hash(o)
-    when Puppet::Pops::Evaluator::PuppetProc
+    when Evaluator::PuppetProc
       infer_PuppetProc(o)
     else
       @@infer_visitor.visit_this_0(self, o)
@@ -319,21 +331,21 @@ class Puppet::Pops::Types::TypeCalculator
     if t.is_a?(Module)
       t = type(t)
     end
-    t.is_a?(Types::PAnyType) ? t.instance?(o) : false
+    t.is_a?(PAnyType) ? t.instance?(o) : false
   end
 
   # Answers if t is a puppet type
   # @api public
   #
   def is_ptype?(t)
-    t.is_a?(Types::PAnyType)
+    t.is_a?(PAnyType)
   end
 
   # Answers if t represents the puppet type PUndefType
   # @api public
   #
   def is_pnil?(t)
-    t.nil? || t.is_a?(Types::PUndefType)
+    t.nil? || t.is_a?(PUndefType)
   end
 
   # Answers, 'What is the common type of t1 and t2?'
@@ -354,9 +366,9 @@ class Puppet::Pops::Types::TypeCalculator
     end
 
     # If either side is Unit, it is the other type
-    if t1.is_a?(Types::PUnitType)
+    if t1.is_a?(PUnitType)
       return t2
-    elsif t2.is_a?(Types::PUnitType)
+    elsif t2.is_a?(PUnitType)
       return t1
     end
 
@@ -368,103 +380,103 @@ class Puppet::Pops::Types::TypeCalculator
     end
 
     # when both are arrays, return an array with common element type
-    if t1.is_a?(Types::PArrayType) && t2.is_a?(Types::PArrayType)
-      return Types::PArrayType.new(common_type(t1.element_type, t2.element_type))
+    if t1.is_a?(PArrayType) && t2.is_a?(PArrayType)
+      return PArrayType.new(common_type(t1.element_type, t2.element_type))
     end
 
     # when both are hashes, return a hash with common key- and element type
-    if t1.is_a?(Types::PHashType) && t2.is_a?(Types::PHashType)
+    if t1.is_a?(PHashType) && t2.is_a?(PHashType)
       key_type = common_type(t1.key_type, t2.key_type)
       element_type = common_type(t1.element_type, t2.element_type)
-      return Types::PHashType.new(key_type, element_type)
+      return PHashType.new(key_type, element_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::DEFAULT
+    if t1.is_a?(PHostClassType) && t2.is_a?(PHostClassType)
+      return PHostClassType::DEFAULT
     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)
+    if t1.is_a?(PResourceType) && t2.is_a?(PResourceType)
       # only Resource[] unless the type name is the same
-      return t1.type_name == t2.type_name ?  Types::PResourceType.new(t1.type_name, nil) : Types::PResourceType::DEFAULT
+      return t1.type_name == t2.type_name ?  PResourceType.new(t1.type_name, nil) : PResourceType::DEFAULT
     end
 
     # Integers have range, expand the range to the common range
-    if t1.is_a?(Types::PIntegerType) && t2.is_a?(Types::PIntegerType)
-      return Types::PIntegerType.new([t1.numeric_from, t2.numeric_from].min, [t1.numeric_to, t2.numeric_to].max)
+    if t1.is_a?(PIntegerType) && t2.is_a?(PIntegerType)
+      return PIntegerType.new([t1.numeric_from, t2.numeric_from].min, [t1.numeric_to, t2.numeric_to].max)
     end
 
     # Floats have range, expand the range to the common range
-    if t1.is_a?(Types::PFloatType) && t2.is_a?(Types::PFloatType)
-      return Types::PFloatType.new([t1.numeric_from, t2.numeric_from].min, [t1.numeric_to, t2.numeric_to].max)
+    if t1.is_a?(PFloatType) && t2.is_a?(PFloatType)
+      return PFloatType.new([t1.numeric_from, t2.numeric_from].min, [t1.numeric_to, t2.numeric_to].max)
     end
 
-    if t1.is_a?(Types::PStringType) && t2.is_a?(Types::PStringType)
+    if t1.is_a?(PStringType) && t2.is_a?(PStringType)
       common_size_type = common_type(t1.size_type, t2.size_type) unless t1.size_type.nil? || t2.size_type.nil?
       common_strings = t1.values.empty? || t2.values.empty? ? [] : t1.values | t2.values
-      return Types::PStringType.new(common_size_type, common_strings)
+      return PStringType.new(common_size_type, common_strings)
     end
 
-    if t1.is_a?(Types::PPatternType) && t2.is_a?(Types::PPatternType)
-      return Types::PPatternType.new(t1.patterns | t2.patterns)
+    if t1.is_a?(PPatternType) && t2.is_a?(PPatternType)
+      return PPatternType.new(t1.patterns | t2.patterns)
     end
 
-    if t1.is_a?(Types::PEnumType) && t2.is_a?(Types::PEnumType)
+    if t1.is_a?(PEnumType) && t2.is_a?(PEnumType)
       # The common type is one that complies with either set
-      return Types::PEnumType.new(t1.values | t2.values)
+      return PEnumType.new(t1.values | t2.values)
     end
 
-    if t1.is_a?(Types::PVariantType) && t2.is_a?(Types::PVariantType)
+    if t1.is_a?(PVariantType) && t2.is_a?(PVariantType)
       # The common type is one that complies with either set
-      return Types::PVariantType.new(t1.types | t2.types)
+      return PVariantType.new(t1.types | t2.types)
     end
 
-    if t1.is_a?(Types::PRegexpType) && t2.is_a?(Types::PRegexpType)
+    if t1.is_a?(PRegexpType) && t2.is_a?(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::DEFAULT
+      return PPatternType::DEFAULT
     end
 
-    if t1.is_a?(Types::PCallableType) && t2.is_a?(Types::PCallableType)
+    if t1.is_a?(PCallableType) && t2.is_a?(PCallableType)
       # They do not have the same signature, and one is not assignable to the other,
       # what remains is the most general form of Callable
-      return Types::PCallableType::DEFAULT
+      return PCallableType::DEFAULT
     end
 
     # Common abstract types, from most specific to most general
     if common_numeric?(t1, t2)
-      return Types::PNumericType::DEFAULT
+      return PNumericType::DEFAULT
     end
 
     if common_scalar?(t1, t2)
-      return Types::PScalarType::DEFAULT
+      return PScalarType::DEFAULT
     end
 
     if common_data?(t1,t2)
-      return Types::PDataType::DEFAULT
+      return PDataType::DEFAULT
     end
 
     # Meta types Type[Integer] + Type[String] => Type[Data]
-    if t1.is_a?(Types::PType) && t2.is_a?(Types::PType)
-      return Types::PType.new(common_type(t1.type, t2.type))
+    if t1.is_a?(PType) && t2.is_a?(PType)
+      return PType.new(common_type(t1.type, t2.type))
     end
 
     # If both are Runtime types
-    if t1.is_a?(Types::PRuntimeType) && t2.is_a?(Types::PRuntimeType)
+    if t1.is_a?(PRuntimeType) && t2.is_a?(PRuntimeType)
       if t1.runtime == t2.runtime && t1.runtime_type_name == t2.runtime_type_name
         return t1
       end
       # finding the common super class requires that names are resolved to class
       # NOTE: This only supports runtime type of :ruby
-      c1 = Types::ClassLoader.provide_from_type(t1)
-      c2 = Types::ClassLoader.provide_from_type(t2)
+      c1 = ClassLoader.provide_from_type(t1)
+      c2 = ClassLoader.provide_from_type(t2)
       if c1 && c2
         c2_superclasses = superclasses(c2)
         superclasses(c1).each do|c1_super|
           c2_superclasses.each do |c2_super|
             if c1_super == c2_super
-              return Types::PRuntimeType.new(:ruby, c1_super.name)
+              return PRuntimeType.new(:ruby, c1_super.name)
             end
           end
         end
@@ -472,7 +484,7 @@ class Puppet::Pops::Types::TypeCalculator
     end
 
     # They better both be Any type, or the wrong thing was asked and nil is returned
-    t1.is_a?(Types::PAnyType) && t2.is_a?(Types::PAnyType) ? Types::PAnyType::DEFAULT : nil
+    t1.is_a?(PAnyType) && t2.is_a?(PAnyType) ? PAnyType::DEFAULT : nil
   end
 
   # Produces the superclasses of the given class, including the class
@@ -489,20 +501,16 @@ class Puppet::Pops::Types::TypeCalculator
   # @api public
   #
   def string(t)
-    if t.is_a?(Module)
-      t = type(t)
-    end
-    @@string_visitor.visit_this_0(self, t)
+    Puppet.deprecation_warning('TypeCalculator.string is deprecated. Use TypeFormatter')
+    TypeFormatter.singleton.string(t)
   end
 
   # Produces a debug string representing the type (possibly with more information that the regular string format)
   # @api public
   #
   def debug_string(t)
-    if t.is_a?(Module)
-      t = type(t)
-    end
-    @@inspect_visitor.visit_this_0(self, t)
+    Puppet.deprecation_warning('TypeCalculator.debug_string is deprecated. Use TypeFormatter')
+    TypeFormatter.singleton.debug_string(t)
   end
 
 
@@ -524,7 +532,7 @@ class Puppet::Pops::Types::TypeCalculator
   # @api private
   #
   def infer_Module(o)
-    Types::PType::new(Types::PRuntimeType.new(:ruby, o.name))
+    PType::new(PRuntimeType.new(:ruby, o.name))
   end
 
   # @api private
@@ -532,6 +540,11 @@ class Puppet::Pops::Types::TypeCalculator
     o.type
   end
 
+  # @api private
+  def infer_Iterator(o)
+    PIteratorType.new(o.element_type)
+  end
+
   # @api private
   def infer_Function(o)
     o.class.dispatcher.to_type
@@ -539,14 +552,14 @@ class Puppet::Pops::Types::TypeCalculator
 
   # @api private
   def infer_Object(o)
-    Types::PRuntimeType.new(:ruby, o.class.name)
+    PRuntimeType.new(:ruby, o.class.name)
   end
 
   # The type of all types is PType
   # @api private
   #
   def infer_PAnyType(o)
-    Types::PType.new(o)
+    PType.new(o)
   end
 
   # The type of all types is PType
@@ -554,32 +567,32 @@ class Puppet::Pops::Types::TypeCalculator
   # @api private
   #
   def infer_PType(o)
-    Types::PType.new(o)
+    PType.new(o)
   end
 
   # @api private
   def infer_String(o)
-    Types::PStringType.new(size_as_type(o), [o])
+    PStringType.new(size_as_type(o), [o])
   end
 
   # @api private
   def infer_Float(o)
-    Types::PFloatType.new(o, o)
+    PFloatType.new(o, o)
   end
 
   # @api private
   def infer_Integer(o)
-    Types::PIntegerType.new(o, o)
+    PIntegerType.new(o, o)
   end
 
   # @api private
   def infer_Regexp(o)
-    Types::PRegexpType.new(o.source)
+    PRegexpType.new(o.source)
   end
 
   # @api private
   def infer_NilClass(o)
-    Types::PUndefType::DEFAULT
+    PUndefType::DEFAULT
   end
 
   # @api private
@@ -591,16 +604,16 @@ class Puppet::Pops::Types::TypeCalculator
       case p[0]
       when :rest
         max = :default
-        break Types::PAnyType::DEFAULT
+        break PAnyType::DEFAULT
       when :req
         min += 1
       end
       max += 1
-      Types::PAnyType::DEFAULT
+      PAnyType::DEFAULT
     end
     mapped_types << min
     mapped_types << max
-    Types::TypeFactory.callable(*mapped_types)
+    TypeFactory.callable(*mapped_types)
   end
 
   # @api private
@@ -613,7 +626,9 @@ class Puppet::Pops::Types::TypeCalculator
   def infer_Symbol(o)
     case o
     when :default
-      Types::PDefaultType::DEFAULT
+      PDefaultType::DEFAULT
+    when :undef
+      PUndefType::DEFAULT
     else
       infer_Object(o)
     end
@@ -621,12 +636,12 @@ class Puppet::Pops::Types::TypeCalculator
 
   # @api private
   def infer_TrueClass(o)
-    Types::PBooleanType::DEFAULT
+    PBooleanType::DEFAULT
   end
 
   # @api private
   def infer_FalseClass(o)
-    Types::PBooleanType::DEFAULT
+    PBooleanType::DEFAULT
   end
 
   # @api private
@@ -637,32 +652,32 @@ class Puppet::Pops::Types::TypeCalculator
     # A mapping must be made to empty string. A nil value will result in an error later
     title = o.title
     title = '' if :undef == title
-    Types::PType.new(Types::PResourceType.new(o.type.to_s.downcase, title))
+    PType.new(PResourceType.new(o.type.to_s.downcase, title))
   end
 
   # @api private
   def infer_Array(o)
     if o.empty?
-      Types::PArrayType::EMPTY
+      PArrayType::EMPTY
     else
-      Types::PArrayType.new(infer_and_reduce_type(o), size_as_type(o))
+      PArrayType.new(infer_and_reduce_type(o), size_as_type(o))
     end
   end
 
   # @api private
   def infer_Hash(o)
     if o.empty?
-      Types::PHashType::EMPTY
+      PHashType::EMPTY
     else
       ktype = infer_and_reduce_type(o.keys)
       etype = infer_and_reduce_type(o.values)
-      Types::PHashType.new(ktype, etype, size_as_type(o))
+      PHashType.new(ktype, etype, size_as_type(o))
     end
   end
 
   def size_as_type(collection)
     size = collection.size
-    Types::PIntegerType.new(size, size)
+    PIntegerType.new(size, size)
   end
 
   # Common case for everything that intrinsically only has a single type
@@ -672,26 +687,26 @@ class Puppet::Pops::Types::TypeCalculator
 
   def infer_set_Array(o)
     if o.empty?
-      Types::PArrayType::EMPTY
+      PArrayType::EMPTY
     else
-      Types::PTupleType.new(o.map {|x| infer_set(x) })
+      PTupleType.new(o.map {|x| infer_set(x) })
     end
   end
 
   def infer_set_Hash(o)
     if o.empty?
-      Types::PHashType::EMPTY
-    elsif o.keys.all? {|k| Types::PStringType::NON_EMPTY.instance?(k) }
-      Types::PStructType.new(o.each_pair.map { |k,v| Types::PStructElement.new(Types::PStringType.new(nil, [k]), infer_set(v)) })
+      PHashType::EMPTY
+    elsif o.keys.all? {|k| PStringType::NON_EMPTY.instance?(k) }
+      PStructType.new(o.each_pair.map { |k,v| PStructElement.new(PStringType.new(nil, [k]), infer_set(v)) })
     else
-      ktype = Types::PVariantType.new(o.keys.map {|k| infer_set(k) })
-      etype = Types::PVariantType.new(o.values.map {|e| infer_set(e) })
-      Types::PHashType.new(unwrap_single_variant(ktype), unwrap_single_variant(etype), size_as_type(o))
+      ktype = PVariantType.new(o.keys.map {|k| infer_set(k) })
+      etype = PVariantType.new(o.values.map {|e| infer_set(e) })
+      PHashType.new(unwrap_single_variant(ktype), unwrap_single_variant(etype), size_as_type(o))
     end
   end
 
   def unwrap_single_variant(possible_variant)
-    if possible_variant.is_a?(Types::PVariantType) && possible_variant.types.size == 1
+    if possible_variant.is_a?(PVariantType) && possible_variant.types.size == 1
       possible_variant.types[0]
     else
       possible_variant
@@ -714,7 +729,7 @@ class Puppet::Pops::Types::TypeCalculator
 
   # @api private
   def self.is_kind_of_callable?(t, optional = true)
-    t.is_a?(Types::PAnyType) && t.kind_of_callable?(optional)
+    t.is_a?(PAnyType) && t.kind_of_callable?(optional)
   end
 
   def max(a,b)
@@ -744,260 +759,6 @@ class Puppet::Pops::Types::TypeCalculator
     end
   end
 
-  # @api private
-  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_Symbol(t)       ; t.to_s    ; end
-
-  def string_PAnyType(t)     ; 'Any'; end
-
-  # @api private
-  def string_PUndefType(t)     ; 'Undef'   ; end
-
-  # @api private
-  def string_PDefaultType(t) ; 'Default' ; end
-
-  # @api private
-  def string_PBooleanType(t) ; 'Boolean'; end
-
-  # @api private
-  def string_PScalarType(t)  ; 'Scalar'; end
-
-  # @api private
-  def string_PDataType(t)    ; 'Data'; end
-
-  # @api private
-  def string_PNumericType(t) ; 'Numeric'; end
-
-  # @api private
-  def string_PIntegerType(t)
-    range = range_array_part(t)
-    if range.empty?
-      'Integer'
-    else
-      "Integer[#{range.join(', ')}]"
-    end
-  end
-
-  # Produces a string from an Integer range type that is used inside other type strings
-  # @api private
-  def range_array_part(t)
-    return [] if t.nil? || t.unbounded?
-    [t.from.nil? ? 'default' : t.from , t.to.nil? ? 'default' : t.to ]
-  end
-
-  # @api private
-  def string_PFloatType(t)
-    range = range_array_part(t)
-    if range.empty?
-      'Float'
-    else
-      "Float[#{range.join(', ')}]"
-    end
-  end
-
-  # @api private
-  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)
-    if range.empty?
-      'String'
-    else
-      "String[#{range.join(', ')}]"
-    end
-  end
-
-  # @api private
-  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_PCallableType(t)
-    # generic
-    return 'Callable' if t.param_types.nil?
-
-    if t.param_types.types.empty?
-      range = [0, 0]
-    else
-      range = range_array_part(t.param_types.size_type)
-    end
-    # translate to string, and skip Unit types
-    types = t.param_types.types.map {|t2| string(t2) unless t2.class == Types::PUnitType }.compact
-
-    s = 'Callable[' << types.join(', ')
-    unless range.empty?
-      (s << ', ') unless types.empty?
-      s << range.join(', ')
-    end
-    # Add block T last (after min, max) if present)
-    #
-    unless t.block_type.nil?
-      (s << ', ') unless types.empty? && range.empty?
-      s << string(t.block_type)
-    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)
-    k = t.key_type
-    value_optional = t.value_type.assignable?(Types::PUndefType::DEFAULT)
-    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
-  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)
-    if range.empty?
-      'Collection'
-    else
-      "Collection[#{range.join(', ')}]"
-    end
-  end
-
-  # @api private
-  def string_PUnitType(t)
-    'Unit'
-  end
-
-  # @api private
-  def string_PRuntimeType(t)   ; "Runtime[#{string(t.runtime)}, #{string(t.runtime_type_name)}]"  ; end
-
-  # @api private
-  def string_PArrayType(t)
-    parts = [string(t.element_type)] + range_array_part(t.size_type)
-    "Array[#{parts.join(', ')}]"
-  end
-
-  # @api private
-  def string_PHashType(t)
-    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
-        "#{capitalize_segments(t.type_name)}['#{t.title}']"
-      else
-        capitalize_segments(t.type_name)
-      end
-    else
-      'Resource'
-    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?
-      '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
-    end
-  end
-
   # Debugging to_s to reduce the amount of output
   def to_s
     '[a TypeCalculator]'
@@ -1005,22 +766,18 @@ class Puppet::Pops::Types::TypeCalculator
 
   private
 
-  NAME_SEGMENT_SEPARATOR = '::'.freeze
-
-  def capitalize_segments(s)
-    s.split(NAME_SEGMENT_SEPARATOR).map(&:capitalize).join(NAME_SEGMENT_SEPARATOR)
-  end
-
   def common_data?(t1, t2)
-    Types::PDataType::DEFAULT.assignable?(t1) && Types::PDataType::DEFAULT.assignable?(t2)
+    PDataType::DEFAULT.assignable?(t1) && PDataType::DEFAULT.assignable?(t2)
   end
 
   def common_scalar?(t1, t2)
-    Types::PScalarType::DEFAULT.assignable?(t1) && Types::PScalarType::DEFAULT.assignable?(t2)
+    PScalarType::DEFAULT.assignable?(t1) && PScalarType::DEFAULT.assignable?(t2)
   end
 
   def common_numeric?(t1, t2)
-    Types::PNumericType::DEFAULT.assignable?(t1) && Types::PNumericType::DEFAULT.assignable?(t2)
+    PNumericType::DEFAULT.assignable?(t1) && PNumericType::DEFAULT.assignable?(t2)
   end
 
 end
+end
+end