puppet 4.8.2-universal-darwin → 4.9.0-universal-darwin

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

@@ -10,21 +10,21 @@ class PSemVerRangeType < PScalarType
   end
 
   # Check if a version is included in a version range. The version can be a string or
-  # a `Semantic::SemVer`
+  # a `SemanticPuppet::SemVer`
   #
-  # @param range [Semantic::VersionRange] the range to match against
-  # @param version [Semantic::Version,String] the version to match
+  # @param range [SemanticPuppet::VersionRange] the range to match against
+  # @param version [SemanticPuppet::Version,String] the version to match
   # @return [Boolean] `true` if the range includes the given version
   #
   # @api public
   def self.include?(range, version)
     case version
-    when Semantic::Version
+    when SemanticPuppet::Version
       range.include?(version)
     when String
       begin
-        range.include?(Semantic::Version.parse(version))
-      rescue Semantic::Version::ValidationFailure
+        range.include?(SemanticPuppet::Version.parse(version))
+      rescue SemanticPuppet::Version::ValidationFailure
         false
       end
     else
@@ -32,28 +32,28 @@ class PSemVerRangeType < PScalarType
     end
   end
 
-  # Creates a {Semantic::VersionRange} from the given _version_range_ argument. If the argument is `nil` or
-  # a {Semantic::VersionRange}, it is returned. If it is a {String}, it will be parsed into a
-  # {Semantic::VersionRange}. Any other class will raise an {ArgumentError}.
+  # Creates a {SemanticPuppet::VersionRange} from the given _version_range_ argument. If the argument is `nil` or
+  # a {SemanticPuppet::VersionRange}, it is returned. If it is a {String}, it will be parsed into a
+  # {SemanticPuppet::VersionRange}. Any other class will raise an {ArgumentError}.
   #
-  # @param version_range [Semantic::VersionRange,String,nil] the version range to convert
-  # @return [Semantic::VersionRange] the converted version range
+  # @param version_range [SemanticPuppet::VersionRange,String,nil] the version range to convert
+  # @return [SemanticPuppet::VersionRange] the converted version range
   # @raise [ArgumentError] when the argument cannot be converted into a version range
   #
   def self.convert(version_range)
     case version_range
-    when nil, Semantic::VersionRange
+    when nil, SemanticPuppet::VersionRange
       version_range
     when String
-      Semantic::VersionRange.parse(version_range)
+      SemanticPuppet::VersionRange.parse(version_range)
     else
       raise ArgumentError, "Unable to convert a #{version_range.class.name} to a SemVerRange"
     end
   end
 
   # Checks if range _a_ is a sub-range of (i.e. completely covered by) range _b_
-  # @param a [Semantic::VersionRange] the first range
-  # @param b [Semantic::VersionRange] the second range
+  # @param a [SemanticPuppet::VersionRange] the first range
+  # @param b [SemanticPuppet::VersionRange] the second range
   #
   # @return [Boolean] `true` if _a_ is completely covered by _b_
   def self.covered_by?(a, b)
@@ -63,9 +63,9 @@ class PSemVerRangeType < PScalarType
   # Merge two ranges so that the result matches all versions matched by both. A merge
   # is only possible when the ranges are either adjacent or have an overlap.
   #
-  # @param a [Semantic::VersionRange] the first range
-  # @param b [Semantic::VersionRange] the second range
-  # @return [Semantic::VersionRange,nil] the result of the merge
+  # @param a [SemanticPuppet::VersionRange] the first range
+  # @param b [SemanticPuppet::VersionRange] the second range
+  # @return [SemanticPuppet::VersionRange,nil] the result of the merge
   #
   # @api public
   def self.merge(a, b)
@@ -77,13 +77,13 @@ class PSemVerRangeType < PScalarType
       elsif b.exclude_end?
         exclude_end = max == b.end && (max > a.end || a.exclude_end?)
       end
-      Semantic::VersionRange.new([a.begin, b.begin].min, max, exclude_end)
+      SemanticPuppet::VersionRange.new([a.begin, b.begin].min, max, exclude_end)
     elsif a.exclude_end? && a.end == b.begin
       # Adjacent, a before b
-      Semantic::VersionRange.new(a.begin, b.end, b.exclude_end?)
+      SemanticPuppet::VersionRange.new(a.begin, b.end, b.exclude_end?)
     elsif b.exclude_end? && b.end == a.begin
       # Adjacent, b before a
-      Semantic::VersionRange.new(b.begin, a.end, a.exclude_end?)
+      SemanticPuppet::VersionRange.new(b.begin, a.end, a.exclude_end?)
     else
       # No overlap
       nil
@@ -91,7 +91,7 @@ class PSemVerRangeType < PScalarType
   end
 
   def instance?(o, guard = nil)
-    o.is_a?(Semantic::VersionRange)
+    o.is_a?(SemanticPuppet::VersionRange)
   end
 
   def eql?(o)
@@ -115,7 +115,7 @@ class PSemVerRangeType < PScalarType
       # https://github.com/npm/node-semver#range-grammar
       #
       # The logical or || operator is not implemented since it effectively builds
-      # an array of ranges that may be disparate. The {{Semantic::VersionRange}} inherits
+      # an array of ranges that may be disparate. The {{SemanticPuppet::VersionRange}} inherits
       # from the standard ruby range. It must be possible to describe that range in terms
       # of min, max, and exclude max.
       #
@@ -144,13 +144,13 @@ class PSemVerRangeType < PScalarType
       end
 
       def from_string(str)
-        Semantic::VersionRange.parse(str)
+        SemanticPuppet::VersionRange.parse(str)
       end
 
       def from_versions(min, max = :default, exclude_max = false)
-        min = Semantic::Version::MIN if min == :default
-        max = Semantic::Version::MAX if max == :default
-        Semantic::VersionRange.new(min, max, exclude_max)
+        min = SemanticPuppet::Version::MIN if min == :default
+        max = SemanticPuppet::Version::MAX if max == :default
+        SemanticPuppet::VersionRange.new(min, max, exclude_max)
       end
 
       def from_hash(hash)

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

@@ -1,7 +1,7 @@
 module Puppet::Pops
 module Types
 
-# A Puppet Language Type that exposes the {{Semantic::Version}} and {{Semantic::VersionRange}}.
+# A Puppet Language Type that exposes the {{SemanticPuppet::Version}} and {{SemanticPuppet::VersionRange}}.
 # The version type is parameterized with version ranges.
 #
 # @api public
@@ -18,13 +18,13 @@ class PSemVerType < PScalarType
   attr_reader :ranges
 
   def initialize(ranges)
-    ranges = ranges.map { |range| range.is_a?(Semantic::VersionRange) ? range : Semantic::VersionRange.parse(range) }
+    ranges = ranges.map { |range| range.is_a?(SemanticPuppet::VersionRange) ? range : SemanticPuppet::VersionRange.parse(range) }
     ranges = merge_ranges(ranges) if ranges.size > 1
     @ranges = ranges
   end
 
   def instance?(o, guard = nil)
-    o.is_a?(Semantic::Version) && (@ranges.empty? || @ranges.any? {|range| range.include?(o) })
+    o.is_a?(SemanticPuppet::Version) && (@ranges.empty? || @ranges.any? {|range| range.include?(o) })
   end
 
   def eql?(o)
@@ -36,19 +36,19 @@ class PSemVerType < PScalarType
   end
 
   # Creates a SemVer version from the given _version_ argument. If the argument is `nil` or
-  # a {Semantic::Version}, it is returned. If it is a {String}, it will be parsed into a
-  # {Semantic::Version}. Any other class will raise an {ArgumentError}.
+  # a {SemanticPuppet::Version}, it is returned. If it is a {String}, it will be parsed into a
+  # {SemanticPuppet::Version}. Any other class will raise an {ArgumentError}.
   #
-  # @param version [Semantic::Version,String,nil] the version to convert
-  # @return [Semantic::Version] the converted version
+  # @param version [SemanticPuppet::Version,String,nil] the version to convert
+  # @return [SemanticPuppet::Version] the converted version
   # @raise [ArgumentError] when the argument cannot be converted into a version
   #
   def self.convert(version)
     case version
-    when nil, Semantic::Version
+    when nil, SemanticPuppet::Version
       version
     when String
-      Semantic::Version.parse(version)
+      SemanticPuppet::Version.parse(version)
     else
       raise ArgumentError, "Unable to convert a #{version.class.name} to a SemVer"
     end
@@ -87,15 +87,15 @@ class PSemVerType < PScalarType
       end
 
       def from_string(str)
-        Semantic::Version.parse(str)
+        SemanticPuppet::Version.parse(str)
       end
 
       def from_args(major, minor, patch, prerelease = nil, build = nil)
-        Semantic::Version.new(major, minor, patch, prerelease, build)
+        SemanticPuppet::Version.new(major, minor, patch, prerelease, build)
       end
 
       def from_hash(hash)
-        Semantic::Version.new(hash['major'], hash['minor'], hash['patch'], hash['prerelease'], hash['build'])
+        SemanticPuppet::Version.new(hash['major'], hash['minor'], hash['patch'], hash['prerelease'], hash['build'])
       end
     end
   end

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

@@ -1,10 +1,10 @@
 module Puppet::Pops
 module Types
   class PAbstractTimeDataType < PAbstractRangeType
-    # @param [AbstractTime] min lower bound for this type. Nil or :default means unbounded
-    # @param [AbstractTime] max upper bound for this type. Nil or :default means unbounded
-    def initialize(min = nil, max = nil)
-      super(convert_arg(min, true), convert_arg(max, false))
+    # @param from [AbstractTime] lower bound for this type. Nil or :default means unbounded
+    # @param to [AbstractTime] upper bound for this type. Nil or :default means unbounded
+    def initialize(from = nil, to = nil)
+      super(convert_arg(from, true), convert_arg(to, false))
     end
 
     def convert_arg(arg, min)
@@ -51,8 +51,8 @@ module Types
   class PTimespanType < PAbstractTimeDataType
     def self.register_ptype(loader, ir)
       create_ptype(loader, ir, 'ScalarType',
-        'from' => { KEY_TYPE => PTimespanType::DEFAULT, KEY_VALUE => :default },
-        'to' => { KEY_TYPE => PTimespanType::DEFAULT, KEY_VALUE => :default }
+        'from' => { KEY_TYPE => POptionalType.new(PTimespanType::DEFAULT), KEY_VALUE => nil },
+        'to' => { KEY_TYPE => POptionalType.new(PTimespanType::DEFAULT), KEY_VALUE => nil }
       )
     end
 

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

@@ -3,8 +3,8 @@ module Types
   class PTimestampType < PAbstractTimeDataType
     def self.register_ptype(loader, ir)
       create_ptype(loader, ir, 'ScalarType',
-        'from' => { KEY_TYPE => PTimestampType::DEFAULT, KEY_VALUE => :default },
-        'to' => { KEY_TYPE => PTimestampType::DEFAULT, KEY_VALUE => :default }
+        'from' => { KEY_TYPE => POptionalType.new(PTimestampType::DEFAULT), KEY_VALUE => nil },
+        'to' => { KEY_TYPE => POptionalType.new(PTimestampType::DEFAULT), KEY_VALUE => nil }
       )
     end
 

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

@@ -216,27 +216,18 @@ class PTypeSetType < PMetaType
   # @return [String] the name by which the type is referenced within this type set
   #
   # @api private
-  def name_for(t)
+  def name_for(t, default_name)
     key = @types.key(t)
     if key.nil?
       qname = t.name
       if @references.empty?
-        qname
+        default_name
       else
-        segments = qname.split(TypeFormatter::NAME_SEGMENT_SEPARATOR)
-        first = segments[0]
-        type_set = @references[first]
-        if type_set.nil?
-          qname
-        else
-          if segments.size == 1
-            qname
-          else
-            sub_name = type_set.name_for(t)
-            sub_name = "#{first}::#{sub_name}" unless sub_name == qname
-            sub_name
-          end
+        @references.each_pair do |ref_key, ref|
+          ref_name = ref.type_set.name_for(t, nil)
+          return "#{ref_key}::#{ref_name}" unless ref_name.nil?
         end
+        default_name
       end
     else
       key
@@ -332,7 +323,7 @@ class PTypeSetType < PMetaType
     KEY_NAME_AUTHORITY => Pcore::RUNTIME_NAME_AUTHORITY,
     Pcore::KEY_PCORE_URI => Pcore::PCORE_URI,
     Pcore::KEY_PCORE_VERSION => Pcore::PCORE_VERSION,
-    KEY_VERSION => Semantic::Version.new(0,0,0)
+    KEY_VERSION => SemanticPuppet::Version.new(0,0,0)
   })
 
   protected

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

@@ -24,14 +24,54 @@ class RecursionGuard
   # @param instance [Object] the instance to check
   # @return [Integer] the resulting state
   def recursive_this?(instance)
-    this_map[instance.object_id] == true
+    instance_variable_defined?(:@recursive_this_map) && @recursive_this_map.has_key?(instance.object_id)
   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
+    instance_variable_defined?(:@recursive_that_map) && @recursive_that_map.has_key?(instance.object_id)
+  end
+
+  # Add the given argument as 'this' invoke the given block with the resulting state
+  # @param instance [Object] the instance to add
+  # @return [Object] the result of yielding
+  def with_this(instance)
+    if (@state & SELF_RECURSION_IN_THIS) == 0
+      tc = this_count
+      @state = @state | SELF_RECURSION_IN_THIS if this_put(instance)
+      if tc < this_count
+        # recursive state detected
+        result = yield(@state)
+
+        # pop state
+        @state &= ~SELF_RECURSION_IN_THIS
+        @this_map.delete(instance.object_id)
+        return result
+      end
+    end
+    yield(@state)
+  end
+
+  # Add the given argument as 'that' invoke the given block with the resulting state
+  # @param instance [Object] the instance to add
+  # @return [Object] the result of yielding
+  def with_that(instance)
+    if (@state & SELF_RECURSION_IN_THAT) == 0
+      tc = that_count
+      @state = @state | SELF_RECURSION_IN_THAT if that_put(instance)
+      if tc < that_count
+        # recursive state detected
+        result = yield(@state)
+
+        # pop state
+        @state &= ~SELF_RECURSION_IN_THAT
+        @that_map.delete(instance.object_id)
+        return result
+      end
+    end
+    yield(@state)
   end
 
   # Add the given argument as 'this' and return the resulting state
@@ -39,7 +79,7 @@ class RecursionGuard
   # @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)
+      @state = @state | SELF_RECURSION_IN_THIS if this_put(instance)
     end
     @state
   end
@@ -49,43 +89,47 @@ class RecursionGuard
   # @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)
+      @state = @state | SELF_RECURSION_IN_THAT if that_put(instance)
     end
     @state
   end
 
   # @return the number of objects added to the `this` map
   def this_count
-    this_map.size
+    instance_variable_defined?(:@this_map) ? @this_map.size : 0
   end
 
   # @return the number of objects added to the `that` map
   def that_count
-    that_map.size
+    instance_variable_defined?(:@that_map) ? @that_map.size : 0
   end
 
   private
 
-  def map_put(map, o)
+  def this_put(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
+    @this_map ||= {}
+    if @this_map.has_key?(id)
+      @recursive_this_map ||= {}
+      @recursive_this_map[id] = true
+      true
     else
-      map[id] = false
-      false # First time add. No recursion
+      @this_map[id] = true
+      false
     end
   end
 
-  def this_map
-    @this_map ||= {}
-  end
-
-  def that_map
+  def that_put(o)
+    id = o.object_id
     @that_map ||= {}
+    if @that_map.has_key?(id)
+      @recursive_that_map ||= {}
+      @recursive_that_map[id] = true
+      true
+    else
+      @that_map[id] = true
+      false
+    end
   end
 end
 end

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

@@ -210,6 +210,16 @@ class RubyGenerator < TypeFormatter
     init_params.each { |a| bld << '    @' << a.name << ' = ' << a.name << "\n" if a.container.equal?(obj) }
     bld << "  end\n\n"
 
+    bld << "  def i12n_hash\n    result = "
+    bld << (obj.parent.nil? ? '{}' : 'super')
+    bld << "\n"
+    init_params.each { |a| bld << "    result['" << a.name << "'] = @" << a.name << "\n" if a.container.equal?(obj) }
+    bld << "    result\n  end\n\n"
+
+    bld << "  def to_s\n"
+    bld << "    " << namespace_relative(segments, TypeFormatter.name) << ".string(self)\n"
+    bld << "  end\n\n"
+
     # Output attr_readers
     others.each do |a|
       next unless a.container.equal?(obj)

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

@@ -312,7 +312,7 @@ class TypeCalculator
         infer_set_Array(o)
       when Hash
         infer_set_Hash(o)
-      when Semantic::Version
+      when SemanticPuppet::Version
         infer_set_Version(o)
       else
         infer_set_Object(o)
@@ -389,8 +389,8 @@ class TypeCalculator
     # when both are hashes, return a hash with common key- and element type
     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 PHashType.new(key_type, element_type)
+      value_type = common_type(t1.value_type, t2.value_type)
+      return PHashType.new(key_type, value_type)
     end
 
     # when both are host-classes, reduce to PHostClass[] (since one was not assignable to the other)
@@ -414,19 +414,29 @@ class TypeCalculator
       return PFloatType.new([t1.numeric_from, t2.numeric_from].min, [t1.numeric_to, t2.numeric_to].max)
     end
 
-    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 PStringType.new(common_size_type, common_strings)
+    if t1.is_a?(PStringType) && (t2.is_a?(PStringType) || t2.is_a?(PEnumType))
+      if(t2.is_a?(PEnumType))
+        return t1.value.nil? ? PEnumType::DEFAULT : PEnumType.new(t2.values | [t1.value])
+      end
+
+      if t1.size_type.nil? || t2.size_type.nil?
+        return t1.value.nil? || t2.value.nil? ? PStringType::DEFAULT : PEnumType.new([t1.value, t2.value])
+      end
+
+      return PStringType.new(common_type(t1.size_type, t2.size_type))
     end
 
     if t1.is_a?(PPatternType) && t2.is_a?(PPatternType)
       return PPatternType.new(t1.patterns | t2.patterns)
     end
 
-    if t1.is_a?(PEnumType) && t2.is_a?(PEnumType)
+    if t1.is_a?(PEnumType) && (t2.is_a?(PStringType) || t2.is_a?(PEnumType))
       # The common type is one that complies with either set
-      return PEnumType.new(t1.values | t2.values)
+      if t2.is_a?(PEnumType)
+        return PEnumType.new(t1.values | t2.values)
+      end
+
+      return t2.value.nil? ? PEnumType::DEFAULT : PEnumType.new(t1.values | [t2.value])
     end
 
     if t1.is_a?(PVariantType) && t2.is_a?(PVariantType)
@@ -437,7 +447,7 @@ class TypeCalculator
     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 PPatternType::DEFAULT
+      return PRegexpType::DEFAULT
     end
 
     if t1.is_a?(PCallableType) && t2.is_a?(PCallableType)
@@ -581,7 +591,7 @@ class TypeCalculator
 
   # @api private
   def infer_String(o)
-    PStringType.new(size_as_type(o), [o])
+    PStringType.new(o)
   end
 
   # @api private
@@ -735,7 +745,7 @@ class TypeCalculator
     if o.empty?
       PHashType::EMPTY
     elsif o.keys.all? {|k| PStringType::NON_EMPTY.instance?(k) }
-      PStructType.new(o.each_pair.map { |k,v| PStructElement.new(PStringType.new(size_as_type(k), [k]), infer_set(v)) })
+      PStructType.new(o.each_pair.map { |k,v| PStructElement.new(PStringType.new(k), infer_set(v)) })
     else
       ktype = PVariantType.maybe_create(o.keys.map {|k| infer_set(k) })
       etype = PVariantType.maybe_create(o.values.map {|e| infer_set(e) })
@@ -745,7 +755,7 @@ class TypeCalculator
 
   # @api private
   def infer_set_Version(o)
-    PSemVerType.new([Semantic::VersionRange.new(o, o)])
+    PSemVerType.new([SemanticPuppet::VersionRange.new(o, o)])
   end
 
   def unwrap_single_variant(possible_variant)

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

@@ -75,11 +75,20 @@ module TypeFactory
     @type_calculator.string(t)
   end
 
-  # Produces the String type, optionally with specific string values
+  # Produces the String type based on nothing, a string value that becomes an exact match constraint, or a parameterized
+  # Integer type that constraints the size.
+  #
   # @api public
   #
-  def self.string(size_type = nil, *values)
-    PStringType.new(size_type, values)
+  def self.string(size_type_or_value = nil, *deprecated_second_argument)
+    if deprecated_second_argument.empty?
+      size_type_or_value.nil? ? PStringType::DEFAULT : PStringType.new(size_type_or_value)
+    else
+      if Puppet[:strict] != :off
+        Puppet.warn_once(:deprecatation, "TypeFactory#string_multi_args", "Passing more than one argument to TypeFactory#string is deprecated")
+      end
+      deprecated_second_argument.size == 1 ? PStringType.new(deprecated_second_argument[0]) : PEnumType.new(*deprecated_second_argument)
+    end
   end
 
   # Produces the Optional type, i.e. a short hand for Variant[T, Undef]
@@ -92,7 +101,7 @@ module TypeFactory
   # @api public
   #
   def self.optional(optional_type = nil)
-    POptionalType.new(type_of(optional_type.is_a?(String) ? string(nil, optional_type) : type_of(optional_type)))
+    POptionalType.new(type_of(optional_type.is_a?(String) ? string(optional_type) : type_of(optional_type)))
   end
 
   # Produces the Enum type, optionally with specific string values
@@ -129,7 +138,7 @@ module TypeFactory
       # TODO: Should have stricter name rule
       if key_type.is_a?(String)
         raise ArgumentError, 'Struct element key cannot be an empty String' if key_type.empty?
-        key_type = string(nil, key_type)
+        key_type = string(key_type)
         # Must make key optional if the value can be Undef
         key_type = optional(key_type) if tc.assignable?(value_type, PUndefType::DEFAULT)
       else
@@ -141,12 +150,14 @@ module TypeFactory
           s = key_type
         when POptionalType
           s = key_type.optional_type
-        when PStringType, PEnumType
+        when PStringType
           s = key_type
+        when PEnumType
+          s = key_type.values.size == 1 ? PStringType.new(key_type.values[0]) : nil
         else
           raise ArgumentError, "Illegal Struct member key type. Expected NotUndef, Optional, String, or Enum. Got: #{key_type.class.name}"
         end
-        unless (s.is_a?(PStringType) || s.is_a?(PEnumType)) && s.values.size == 1 && !s.values[0].empty?
+        unless s.is_a?(PStringType) && !s.value.nil?
           raise ArgumentError, "Unable to extract a non-empty literal string from Struct member key type #{tc.string(key_type)}"
         end
       end
@@ -307,7 +318,7 @@ module TypeFactory
   # @api public
   #
   def self.collection(size_type = nil)
-    size_type.nil? ? PCollectionType::DEFAULT : PCollectionType.new(nil, size_type)
+    size_type.nil? ? PCollectionType::DEFAULT : PCollectionType.new(size_type)
   end
 
   # Produces the Data type
@@ -435,7 +446,7 @@ module TypeFactory
   # @api public
   #
   def self.not_undef(inst_type = nil)
-    inst_type = string(nil, inst_type) if inst_type.is_a?(String)
+    inst_type = string(inst_type) if inst_type.is_a?(String)
     PNotUndefType.new(inst_type)
   end