puppet 4.2.3 → 4.3.0

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

@@ -4,49 +4,46 @@
 module Puppet::Pops::Types::TypeFactory
   Types = Puppet::Pops::Types
   @type_calculator = Types::TypeCalculator.singleton
-  @undef_t = Types::PUndefType.new
 
   # Produces the Integer type
   # @api public
   #
-  def self.integer()
-    Types::PIntegerType.new()
+  def self.integer
+    Types::PIntegerType::DEFAULT
   end
 
   # Produces an Integer range type
   # @api public
   #
   def self.range(from, to)
-    t = Types::PIntegerType.new()
     # optimize eq with symbol (faster when it is left)
-    t.from = from unless (:default == from || from == 'default')
-    t.to = to unless (:default == to || to == 'default')
-    t
+    from = :default == from if from == 'default'
+    to = :default if to == 'default'
+    Types::PIntegerType.new(from, to)
   end
 
   # Produces a Float range type
   # @api public
   #
   def self.float_range(from, to)
-    t = Types::PFloatType.new()
     # optimize eq with symbol (faster when it is left)
-    t.from = Float(from) unless :default == from || from.nil?
-    t.to = Float(to) unless :default == to || to.nil?
-    t
+    from = Float(from) unless :default == from || from.nil?
+    to = Float(to) unless :default == to || to.nil?
+    Types::PFloatType.new(from, to)
   end
 
   # Produces the Float type
   # @api public
   #
-  def self.float()
-    Types::PFloatType.new()
+  def self.float
+    Types::PFloatType::DEFAULT
   end
 
   # Produces the Numeric type
   # @api public
   #
-  def self.numeric()
-    Types::PNumericType.new()
+  def self.numeric
+    Types::PNumericType::DEFAULT
   end
 
   # Produces a string representation of the type
@@ -59,10 +56,8 @@ module Puppet::Pops::Types::TypeFactory
   # Produces the String type, optionally with specific string values
   # @api public
   #
-  def self.string(*values)
-    t = Types::PStringType.new()
-    values.each {|v| t.addValues(v) }
-    t
+  def self.string(size_type = nil, *values)
+    Types::PStringType.new(size_type, values)
   end
 
   # Produces the Optional type, i.e. a short hand for Variant[T, Undef]
@@ -75,27 +70,21 @@ module Puppet::Pops::Types::TypeFactory
   # @api public
   #
   def self.optional(optional_type = nil)
-    t = Types::POptionalType.new
-    t.optional_type = optional_type.is_a?(String) ? string(optional_type) : type_of(optional_type)
-    t
+    Types::POptionalType.new(type_of(optional_type.is_a?(String) ? string(nil, optional_type) : type_of(optional_type)))
   end
 
   # Produces the Enum type, optionally with specific string values
   # @api public
   #
   def self.enum(*values)
-    t = Types::PEnumType.new()
-    values.each {|v| t.addValues(v) }
-    t
+    Types::PEnumType.new(values)
   end
 
   # Produces the Variant type, optionally with the "one of" types
   # @api public
   #
   def self.variant(*types)
-    t = Types::PVariantType.new()
-    t.types = types.map {|v| type_of(v) }
-    t
+    Types::PVariantType.new(types.map {|v| type_of(v) })
   end
 
   # Produces the Struct type, either a non parameterized instance representing
@@ -111,17 +100,16 @@ module Puppet::Pops::Types::TypeFactory
   #
   def self.struct(hash = {})
     tc = @type_calculator
-    t = Types::PStructType.new
-    t.elements = hash.map do |key_type, value_type|
+    elements = hash.map do |key_type, value_type|
       value_type = type_of(value_type)
       raise ArgumentError, 'Struct element value_type must be a Type' unless value_type.is_a?(Types::PAnyType)
 
       # 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(key_type)
+        key_type = string(nil, key_type)
         # Must make key optional if the value can be Undef
-        key_type = optional(key_type) if tc.assignable?(value_type, @undef_t)
+        key_type = optional(key_type) if tc.assignable?(value_type, Types::PUndefType::DEFAULT)
       else
         # assert that the key type is one of String[1], NotUndef[String[1]] and Optional[String[1]]
         case key_type
@@ -131,39 +119,36 @@ module Puppet::Pops::Types::TypeFactory
           s = key_type
         when Types::POptionalType
           s = key_type.optional_type
-        else
+        when Types::PStringType, Types::PEnumType
           s = key_type
+        else
+          raise ArgumentError, "Illegal Struct member key type. Expected NotUndef, Optional, String, or Enum. Got: #{key_type.class.name}"
         end
         unless (s.is_a?(Puppet::Pops::Types::PStringType) || s.is_a?(Puppet::Pops::Types::PEnumType)) && s.values.size == 1 && !s.values[0].empty?
-          raise ArgumentError, 'Unable to extract a non-empty literal string from Struct member key type' if key_type.empty?
+          raise ArgumentError, "Unable to extract a non-empty literal string from Struct member key type #{tc.string(key_type)}"
         end
       end
-      elem = Types::PStructElement.new
-      elem.key_type = key_type
-      elem.value_type = value_type
-      elem
+      Types::PStructElement.new(key_type, value_type)
     end
-    t
+    Types::PStructType.new(elements)
   end
 
-  def self.tuple(*types)
-    t = Types::PTupleType.new
-    t.types = types.map {|elem| type_of(elem) }
-    t
+  def self.tuple(types = [], size_type = nil)
+    Types::PTupleType.new(types.map {|elem| type_of(elem) }, size_type)
   end
 
   # Produces the Boolean type
   # @api public
   #
-  def self.boolean()
-    Types::PBooleanType.new()
+  def self.boolean
+    Types::PBooleanType::DEFAULT
   end
 
   # Produces the Any type
   # @api public
   #
-  def self.any()
-    Types::PAnyType.new()
+  def self.any
+    Types::PAnyType::DEFAULT
   end
 
   # Produces the Regexp type
@@ -172,59 +157,54 @@ module Puppet::Pops::Types::TypeFactory
   # @api public
   #
   def self.regexp(pattern = nil)
-    t = Types::PRegexpType.new()
     if pattern
-      t.pattern = pattern.is_a?(Regexp) ? pattern.inspect[1..-2] : pattern
+      t = Types::PRegexpType.new(pattern.is_a?(Regexp) ? pattern.inspect[1..-2] : pattern)
+      t.regexp unless pattern.nil? # compile pattern to catch errors
+      t
+    else
+      Types::PRegexpType::DEFAULT
     end
-    t.regexp() unless pattern.nil? # compile pattern to catch errors
-    t
   end
 
   def self.pattern(*regular_expressions)
-    t = Types::PPatternType.new()
-    regular_expressions.each do |re|
+    patterns = regular_expressions.map do |re|
       case re
       when String
-        re_T = Types::PRegexpType.new()
-        re_T.pattern = re
-        re_T.regexp()  # compile it to catch errors
-        t.addPatterns(re_T)
+        re_t = Types::PRegexpType.new(re)
+        re_t.regexp  # compile it to catch errors
+        re_t
 
       when Regexp
-        re_T = Types::PRegexpType.new()
         # Regep.to_s includes options user did not enter and does not escape source
         # to work either as a string or as a // regexp. The inspect method does a better
         # job, but includes the //
-        re_T.pattern = re.inspect[1..-2]
-        t.addPatterns(re_T)
+        Types::PRegexpType.new(re.inspect[1..-2])
 
       when Types::PRegexpType
-        t.addPatterns(re.copy)
+        re
 
       when Types::PPatternType
-        re.patterns.each do |p|
-          t.addPatterns(p.copy)
-        end
+        re.patterns
 
      else
        raise ArgumentError, "Only String, Regexp, Pattern-Type, and Regexp-Type are allowed: got '#{re.class}"
       end
-    end
-    t
+    end.flatten.uniq
+    Types::PPatternType.new(patterns)
   end
 
   # Produces the Literal type
   # @api public
   #
-  def self.scalar()
-    Types::PScalarType.new()
+  def self.scalar
+    Types::PScalarType::DEFAULT
   end
 
   # Produces a CallableType matching all callables
   # @api public
   #
-  def self.all_callables()
-    return Puppet::Pops::Types::PCallableType.new
+  def self.all_callables
+    return Puppet::Pops::Types::PCallableType::DEFAULT
   end
 
   # Produces a Callable type with one signature without support for a block
@@ -244,9 +224,7 @@ module Puppet::Pops::Types::TypeFactory
   # Params are given as a sequence of arguments to {#type_of}.
   #
   def self.callable(*params)
-    if Puppet::Pops::Types::TypeCalculator.is_kind_of_callable?(params.last)
-      last_callable = true
-    end
+    last_callable = Puppet::Pops::Types::TypeCalculator.is_kind_of_callable?(params.last)
     block_t = last_callable ? params.pop : nil
 
     # compute a size_type for the signature based on the two last parameters
@@ -256,63 +234,50 @@ module Puppet::Pops::Types::TypeFactory
     elsif is_range_parameter?(params[-1])
       size_type = range(params[-1], :default)
       params = params[0, params.size - 1]
+    else
+      size_type = nil
     end
 
     types = params.map {|p| type_of(p) }
 
     # If the specification requires types, and none were given, a Unit type is used
     if types.empty? && !size_type.nil? && size_type.range[1] > 0
-      types << Types::PUnitType.new
+      types << Types::PUnitType::DEFAULT
     end
     # create a signature
-    callable_t = Types::PCallableType.new()
-    tuple_t = tuple(*types)
-    tuple_t.size_type = size_type unless size_type.nil?
-    callable_t.param_types = tuple_t
-
-    callable_t.block_type = block_t
-    callable_t
-  end
-
-  def self.with_block(callable, *block_params)
-    callable.block_type = callable(*block_params)
-    callable
-  end
-
-  def self.with_optional_block(callable, *block_params)
-    callable.block_type = optional(callable(*block_params))
-    callable
+    tuple_t = tuple(types, size_type)
+    Types::PCallableType.new(tuple_t, block_t)
   end
 
   # Produces the abstract type Collection
   # @api public
   #
-  def self.collection()
-    Types::PCollectionType.new()
+  def self.collection(size_type = nil)
+    size_type.nil? ? Types::PCollectionType::DEFAULT : Types::PCollectionType.new(nil, size_type)
   end
 
   # Produces the Data type
   # @api public
   #
-  def self.data()
-    Types::PDataType.new()
+  def self.data
+    Types::PDataType::DEFAULT
   end
 
   # Creates an instance of the Undef type
   # @api public
-  def self.undef()
-    Types::PUndefType.new()
+  def self.undef
+    Types::PUndefType::DEFAULT
   end
 
   # Creates an instance of the Default type
   # @api public
-  def self.default()
-    Types::PDefaultType.new()
+  def self.default
+    Types::PDefaultType::DEFAULT
   end
 
   # Produces an instance of the abstract type PCatalogEntryType
-  def self.catalog_entry()
-    Types::PCatalogEntryType.new()
+  def self.catalog_entry
+    Types::PCatalogEntryType::DEFAULT
   end
 
   # Produces a PResourceType with a String type_name A PResourceType with a nil
@@ -321,18 +286,15 @@ module Puppet::Pops::Types::TypeFactory
   # name.  (There is no resource-type subtyping in Puppet (yet)).
   #
   def self.resource(type_name = nil, title = nil)
-    type = Types::PResourceType.new()
     type_name = type_name.type_name if type_name.is_a?(Types::PResourceType)
     type_name = type_name.downcase unless type_name.nil?
-    type.type_name = type_name
     unless type_name.nil? || type_name =~ Puppet::Pops::Patterns::CLASSREF
       raise ArgumentError, "Illegal type name '#{type.type_name}'"
     end
     if type_name.nil? && !title.nil?
-      raise ArgumentError, "The type name cannot be nil, if title is given"
+      raise ArgumentError, 'The type name cannot be nil, if title is given'
     end
-    type.title = title
-    type
+    Types::PResourceType.new(type_name, title)
   end
 
   # Produces PHostClassType with a string class_name.  A PHostClassType with
@@ -341,51 +303,41 @@ module Puppet::Pops::Types::TypeFactory
   # with the same name.
   #
   def self.host_class(class_name = nil)
-    type = Types::PHostClassType.new()
-    unless class_name.nil?
-      type.class_name = class_name.sub(/^::/, '')
+    if class_name.nil?
+      Types::PHostClassType::DEFAULT
+    else
+      Types::PHostClassType.new(class_name.sub(/^::/, ''))
     end
-    type
   end
 
   # Produces a type for Array[o] where o is either a type, or an instance for
   # which a type is inferred.
   # @api public
   #
-  def self.array_of(o)
-    type = Types::PArrayType.new()
-    type.element_type = type_of(o)
-    type
+  def self.array_of(o, size_type = nil)
+    Types::PArrayType.new(type_of(o), size_type)
   end
 
   # Produces a type for Hash[Scalar, o] where o is either a type, or an
   # instance for which a type is inferred.
   # @api public
   #
-  def self.hash_of(value, key = scalar())
-    type = Types::PHashType.new()
-    type.key_type = type_of(key)
-    type.element_type = type_of(value)
-    type
+  def self.hash_of(value, key = scalar, size_type = nil)
+    Types::PHashType.new(type_of(key), type_of(value), size_type)
   end
 
   # Produces a type for Array[Data]
   # @api public
   #
-  def self.array_of_data()
-    type = Types::PArrayType.new()
-    type.element_type = data()
-    type
+  def self.array_of_data
+    Types::PArrayType::DATA
   end
 
   # Produces a type for Hash[Scalar, Data]
   # @api public
   #
-  def self.hash_of_data()
-    type = Types::PHashType.new()
-    type.key_type = scalar()
-    type.element_type = data()
-    type
+  def self.hash_of_data
+    Types::PHashType::DATA
   end
 
   # Produces a type for NotUndef[T]
@@ -398,19 +350,15 @@ module Puppet::Pops::Types::TypeFactory
   # @api public
   #
   def self.not_undef(inst_type = nil)
-    type = Types::PNotUndefType.new()
-    inst_type = string(inst_type) if inst_type.is_a?(String)
-    type.type = inst_type
-    type
+    inst_type = string(nil, inst_type) if inst_type.is_a?(String)
+    Types::PNotUndefType.new(inst_type)
   end
 
   # Produces a type for Type[T]
   # @api public
   #
   def self.type_type(inst_type = nil)
-    type = Types::PType.new()
-    type.type = inst_type
-    type
+    inst_type.nil? ? Types::PType::DEFAULT : Types::PType.new(inst_type)
   end
 
   # Produce a type corresponding to the class of given unless given is a
@@ -423,7 +371,7 @@ module Puppet::Pops::Types::TypeFactory
     elsif o.is_a?(Types::PAnyType)
       o
     elsif o.is_a?(String)
-      Types::PRuntimeType.new(:runtime => :ruby, :runtime_type_name => o)
+      Types::PRuntimeType.new(:ruby, o)
     else
       @type_calculator.infer_generic(o)
     end
@@ -447,7 +395,7 @@ module Puppet::Pops::Types::TypeFactory
     if o.is_a?(Class)
       @type_calculator.type(o)
     else
-      Types::PRuntimeType.new(:runtime => :ruby, :runtime_type_name => o.class.name)
+      Types::PRuntimeType.new(:ruby, o.class.name)
     end
   end
 
@@ -456,7 +404,7 @@ module Puppet::Pops::Types::TypeFactory
   # or mapps a Ruby Class to its name.
   #
   def self.ruby_type(class_name = nil)
-    Types::PRuntimeType.new(:runtime => :ruby, :runtime_type_name => class_name)
+    Types::PRuntimeType.new(:ruby, class_name)
   end
 
   # Generic creator of a RuntimeType - allows creating the type with nil or
@@ -464,16 +412,7 @@ module Puppet::Pops::Types::TypeFactory
   #
   def self.runtime(runtime=nil, runtime_type_name = nil)
     runtime = runtime.to_sym if runtime.is_a?(String)
-    Types::PRuntimeType.new(:runtime => runtime, :runtime_type_name => runtime_type_name)
-  end
-
-  # Sets the accepted size range of a collection if something other than the
-  # default 0 to Infinity is wanted. The semantics for from/to are the same as
-  # for #range
-  #
-  def self.constrain_size(collection_t, from, to)
-    collection_t.size_type = range(from, to)
-    collection_t
+    Types::PRuntimeType.new(runtime, runtime_type_name)
   end
 
   # Returns true if the given type t is of valid range parameter type (integer