puppet 5.3.4 → 6.29.0

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

@@ -1,4 +1,12 @@
 module Puppet::Pops::Types
+
+  # Implemented by classes that can produce an iterator to iterate over their contents
+  module IteratorProducer
+    def iterator
+      raise ArgumentError, 'iterator() is not implemented'
+    end
+  end
+
   # The runtime Iterable type for an Iterable
   module Iterable
     # Produces an `Iterable` for one of the following types with the following characterstics:
@@ -15,17 +23,20 @@ module Puppet::Pops::Types
     #
     # An `ArgumentError` is raised for all other objects.
     #
-    # @param o [Object] The object to produce an `Iterable` for
+    # @param my_caller [Object] The calling object to reference in errors
+    # @param obj [Object] The object to produce an `Iterable` for
+    # @param infer_elements [Boolean] Whether or not to recursively infer all elements of obj. Optional
+    #
     # @return [Iterable,nil] The produced `Iterable`
     # @raise [ArgumentError] In case an `Iterable` cannot be produced
     # @api public
-    def self.asserted_iterable(caller, obj)
-      iter = self.on(obj)
-      raise ArgumentError, "#{caller.class}(): wrong argument type (#{obj.class}; is not Iterable." if iter.nil?
+    def self.asserted_iterable(my_caller, obj, infer_elements = false)
+      iter = self.on(obj, nil, infer_elements)
+      raise ArgumentError, "#{my_caller.class}(): wrong argument type (#{obj.class}; is not Iterable." if iter.nil?
       iter
     end
 
-    # Produces an `Iterable` for one of the following types with the following characterstics:
+    # Produces an `Iterable` for one of the following types with the following characteristics:
     #
     # `String`       - yields each character in the string
     # `Array`        - yields each element in the array
@@ -40,11 +51,17 @@ module Puppet::Pops::Types
     # The value `nil` is returned for all other objects.
     #
     # @param o [Object] The object to produce an `Iterable` for
+    # @param element_type [PAnyType] the element type for the iterator. Optional
+    # @param infer_elements [Boolean] if element_type is nil, whether or not to recursively
+    #   infer types for the entire collection. Optional
+    #
     # @return [Iterable,nil] The produced `Iterable` or `nil` if it couldn't be produced
     #
     # @api public
-    def self.on(o)
+    def self.on(o, element_type = nil, infer_elements = true)
       case o
+      when IteratorProducer
+        o.iterator
       when Iterable
         o
       when String
@@ -53,18 +70,24 @@ module Puppet::Pops::Types
         if o.empty?
           Iterator.new(PUnitType::DEFAULT, o.each)
         else
-          tc = TypeCalculator.singleton
-          Iterator.new(PVariantType.maybe_create(o.map {|e| tc.infer_set(e) }), o.each)
+          if element_type.nil? && infer_elements
+            tc = TypeCalculator.singleton
+            element_type = PVariantType.maybe_create(o.map {|e| tc.infer_set(e) })
+          end
+          Iterator.new(element_type, o.each)
         end
       when Hash
         # Each element is a two element [key, value] tuple.
         if o.empty?
-          Iterator.new(PHashType::DEFAULT_KEY_PAIR_TUPLE, o.each)
+          HashIterator.new(PHashType::DEFAULT_KEY_PAIR_TUPLE, o.each)
         else
-          tc = TypeCalculator.singleton
-          Iterator.new(PTupleType.new([
-            PVariantType.maybe_create(o.keys.map {|e| tc.infer_set(e) }),
-            PVariantType.maybe_create(o.values.map {|e| tc.infer_set(e) })], PHashType::KEY_PAIR_TUPLE_SIZE), o.each_pair)
+          if element_type.nil? && infer_elements
+            tc = TypeCalculator.singleton
+            element_type = PTupleType.new([
+              PVariantType.maybe_create(o.keys.map {|e| tc.infer_set(e) }),
+              PVariantType.maybe_create(o.values.map {|e| tc.infer_set(e) })], PHashType::KEY_PAIR_TUPLE_SIZE)
+          end
+          HashIterator.new(element_type, o.each_pair)
         end
       when Integer
         if o == 0
@@ -148,6 +171,10 @@ module Puppet::Pops::Types
       super
     end
 
+    def hash_style?
+      false
+    end
+
     def unbounded?
       true
     end
@@ -181,6 +208,26 @@ module Puppet::Pops::Types
       @enumeration.send(name, *arguments, &block)
     end
 
+    def next
+      @enumeration.next
+    end
+
+    def map(*args, &block)
+      @enumeration.map(*args, &block)
+    end
+
+    def reduce(*args, &block)
+      @enumeration.reduce(*args, &block)
+    end
+
+    def all?(&block)
+      @enumeration.all?(&block)
+    end
+
+    def any?(&block)
+      @enumeration.any?(&block)
+    end
+
     def step(step, &block)
       raise ArgumentError if step <= 0
       r = self
@@ -220,6 +267,14 @@ module Puppet::Pops::Types
     end
   end
 
+  # Special iterator used when iterating over hashes. Returns `true` for `#hash_style?` so that
+  # it is possible to differentiate between two element arrays and key => value associations
+  class HashIterator < Iterator
+    def hash_style?
+      true
+    end
+  end
+
   # @api private
   class StepIterator < Iterator
     include Enumerable

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

@@ -91,8 +91,7 @@ class PBinaryType < PAnyType
     # @api private
     #
     def initialize(bin)
-      # TODO: When Ruby 1.9.3 support is dropped change this to `bin.b` for binary encoding instead of force_encoding
-      @binary_buffer = (bin.encoding.name == "ASCII-8BIT" ? bin : bin.dup.force_encoding("ASCII-8BIT")).freeze
+      @binary_buffer = (bin.encoding.name == "ASCII-8BIT" ? bin : bin.b).freeze
     end
 
     # Presents the binary content as a string base64 encoded string (without line breaks).

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

@@ -156,7 +156,7 @@ class PInitType < PTypeWithContainedType
     rescue ArgumentError
       raise ArgumentError, _("Creation of new instance of type '%{type_name}' is not supported") % { type_name: @type.to_s }
     end
-    param_tuples = new_func.dispatcher.dispatchers.map { |closure| closure.type.param_types }
+    param_tuples = new_func.dispatcher.signatures.map { |closure| closure.type.param_types }
 
     # An instance of the contained type is always a match to this type.
     single_types = [@type]

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

@@ -22,7 +22,7 @@ class PMetaType < PAnyType
   end
 
   def instance?(o, guard = nil)
-    assignable?(TypeCalculator.infer(o), guard)
+    raise NotImplementedError, "Subclass of PMetaType should implement 'instance?'"
   end
 
   # Called from the TypeParser once it has found a type using the Loader. The TypeParser will
@@ -78,6 +78,10 @@ class PMetaType < PAnyType
     end
   end
 
+  def resolved?
+    @init_hash_expression.nil?
+  end
+
   # Returns the expanded string the form of the alias, e.g. <alias name> = <resolved type>
   #
   # @return [String] the expanded form of this alias

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

@@ -1,4 +1,5 @@
 require_relative 'ruby_generator'
+require_relative 'type_with_members'
 
 module Puppet::Pops
 module Types
@@ -13,9 +14,11 @@ KEY_FUNCTIONS = 'functions'.freeze
 KEY_KIND = 'kind'.freeze
 KEY_OVERRIDE = 'override'.freeze
 KEY_PARENT = 'parent'.freeze
+KEY_TYPE_PARAMETERS = 'type_parameters'.freeze
 
 # @api public
 class PObjectType < PMetaType
+  include TypeWithMembers
 
   ATTRIBUTE_KIND_CONSTANT = 'constant'.freeze
   ATTRIBUTE_KIND_DERIVED = 'derived'.freeze
@@ -34,8 +37,14 @@ class PObjectType < PMetaType
     TypeFactory.optional(KEY_ANNOTATIONS) => TYPE_ANNOTATIONS
   })
 
+  TYPE_PARAMETER = TypeFactory.struct({
+    KEY_TYPE => PTypeType::DEFAULT,
+    TypeFactory.optional(KEY_ANNOTATIONS) => TYPE_ANNOTATIONS
+  })
+
   TYPE_CONSTANTS = TypeFactory.hash_kv(Pcore::TYPE_MEMBER_NAME, PAnyType::DEFAULT)
   TYPE_ATTRIBUTES = TypeFactory.hash_kv(Pcore::TYPE_MEMBER_NAME, TypeFactory.not_undef)
+  TYPE_PARAMETERS = TypeFactory.hash_kv(Pcore::TYPE_MEMBER_NAME, TypeFactory.not_undef)
   TYPE_ATTRIBUTE_CALLABLE = TypeFactory.callable(0,0)
 
   TYPE_FUNCTION_TYPE = PTypeType.new(PCallableType::DEFAULT)
@@ -46,7 +55,7 @@ class PObjectType < PMetaType
     TypeFactory.optional(KEY_OVERRIDE) => PBooleanType::DEFAULT,
     TypeFactory.optional(KEY_ANNOTATIONS) => TYPE_ANNOTATIONS
   })
-  TYPE_FUNCTIONS = TypeFactory.hash_kv(Pcore::TYPE_MEMBER_NAME, TypeFactory.not_undef)
+  TYPE_FUNCTIONS = TypeFactory.hash_kv(PVariantType.new([Pcore::TYPE_MEMBER_NAME, PStringType.new('[]')]), TypeFactory.not_undef)
 
   TYPE_EQUALITY = TypeFactory.variant(Pcore::TYPE_MEMBER_NAME, TypeFactory.array_of(Pcore::TYPE_MEMBER_NAME))
 
@@ -55,6 +64,7 @@ class PObjectType < PMetaType
   TYPE_OBJECT_I12N = TypeFactory.struct({
     TypeFactory.optional(KEY_NAME) => TYPE_OBJECT_NAME,
     TypeFactory.optional(KEY_PARENT) => PTypeType::DEFAULT,
+    TypeFactory.optional(KEY_TYPE_PARAMETERS) => TYPE_PARAMETERS,
     TypeFactory.optional(KEY_ATTRIBUTES) => TYPE_ATTRIBUTES,
     TypeFactory.optional(KEY_CONSTANTS) => TYPE_CONSTANTS,
     TypeFactory.optional(KEY_FUNCTIONS) => TYPE_FUNCTIONS,
@@ -81,6 +91,7 @@ class PObjectType < PMetaType
   # @api public
   class PAnnotatedMember
     include Annotatable
+    include InvocableMember
 
     # @return [PObjectType] the object type containing this member
     # @api public
@@ -273,6 +284,9 @@ class PObjectType < PMetaType
     # @api public
     def initialize(name, container, init_hash)
       super(name, container, TypeAsserter.assert_instance_of(nil, TYPE_ATTRIBUTE, init_hash) { "initializer for #{self.class.label(container, name)}" })
+      if name == Serialization::PCORE_TYPE_KEY || name == Serialization::PCORE_VALUE_KEY
+        raise Puppet::ParseError, _("The attribute '%{name}' is reserved and cannot be used") % { name: name}
+      end
       @kind = init_hash[KEY_KIND]
       if @kind == ATTRIBUTE_KIND_CONSTANT # final is implied
         if init_hash.include?(KEY_FINAL) && !@final
@@ -348,6 +362,22 @@ class PObjectType < PMetaType
     end
   end
 
+  class PTypeParameter < PAttribute
+    # @return [Hash{String=>Object}] the hash
+    # @api private
+    def _pcore_init_hash
+      hash = super
+      hash[KEY_TYPE] = hash[KEY_TYPE].type
+      hash.delete(KEY_VALUE) if hash.include?(KEY_VALUE) && hash[KEY_VALUE].nil?
+      hash
+    end
+
+    # @api private
+    def self.feature_type
+      'type_parameter'
+    end
+  end
+
   # Describes a named Function in an Object type
   # @api public
   class PFunction < PAnnotatedMember
@@ -372,8 +402,6 @@ class PObjectType < PMetaType
 
   attr_reader :name
   attr_reader :parent
-  attr_reader :attributes
-  attr_reader :functions
   attr_reader :equality
   attr_reader :checks
   attr_reader :annotations
@@ -392,12 +420,15 @@ class PObjectType < PMetaType
   # @overload initialize(init_hash)
   #   Used when the object is created by the {TypeFactory}. The init_hash must be fully resolved.
   #   @param _pcore_init_hash [Hash{String=>Object}] The hash describing the Object features
+  #   @param loader [Loaders::Loader,nil] the loader that loaded the type
   #
   # @api private
   def initialize(_pcore_init_hash, init_hash_expression = nil)
     if _pcore_init_hash.is_a?(Hash)
       _pcore_init_from_hash(_pcore_init_hash)
+      @loader = init_hash_expression unless init_hash_expression.nil?
     else
+      @type_parameters = EMPTY_HASH
       @attributes = EMPTY_HASH
       @functions = EMPTY_HASH
       @name = TypeAsserter.assert_instance_of('object name', TYPE_OBJECT_NAME, _pcore_init_hash)
@@ -442,7 +473,7 @@ class PObjectType < PMetaType
   # @return [Object] the created instance
   # @api private
   def read(value_count, deserializer)
-    reader.read(implementation_class, value_count, deserializer)
+    reader.read(self, implementation_class, value_count, deserializer)
   end
 
   # Write an instance of this type using a serializer
@@ -456,15 +487,12 @@ class PObjectType < PMetaType
     # @api private
   def create_new_function
     impl_class = implementation_class
-    class_name = impl_class.name || "Anonymous Ruby class for #{name}"
+    return impl_class.create_new_function(self) if impl_class.respond_to?(:create_new_function)
 
     (param_names, param_types, required_param_count) = parameter_info(impl_class)
 
     # Create the callable with a size that reflects the required and optional parameters
-    param_types << required_param_count
-    param_types << param_names.size
-
-    create_type = TypeFactory.callable(*param_types)
+    create_type = TypeFactory.callable(*param_types, required_param_count, param_names.size)
     from_hash_type = TypeFactory.callable(init_hash_type, 1, 1)
 
     # Create and return a #new_XXX function where the dispatchers are added programmatically.
@@ -508,13 +536,13 @@ class PObjectType < PMetaType
   def implementation_class(create = true)
     if @implementation_class.nil? && create
       ir = Loaders.implementation_registry
-      impl_name = ir.nil? ? nil : ir.module_name_for_type(self)
-      if impl_name.nil?
+      class_name = ir.nil? ? nil : ir.module_name_for_type(self)
+      if class_name.nil?
         # Use generator to create a default implementation
         @implementation_class = RubyGenerator.new.create_class(self)
+        @implementation_class.class_eval(&@implementation_override) if instance_variable_defined?(:@implementation_override)
       else
         # Can the mapping be loaded?
-        class_name = impl_name[0]
         @implementation_class = ClassLoader.provide(class_name)
 
         raise Puppet::Error, "Unable to load class #{class_name}" if @implementation_class.nil?
@@ -532,10 +560,42 @@ class PObjectType < PMetaType
     @implementation_class = cls
   end
 
+  # The block passed to this method will be passed in a call to `#class_eval` on the dynamically generated
+  # class for this data type. It's indended use is to complement or redefine the generated methods and
+  # attribute readers.
+  #
+  # The method is normally called with the block passed to `#implementation` when a data type is defined using
+  # {Puppet::DataTypes::create_type}.
+  #
+  # @api private
+  def implementation_override=(block)
+    if !@implementation_class.nil? || instance_variable_defined?(:@implementation_override)
+      raise ArgumentError, "attempt to redefine implementation override for #{label}"
+    end
+    @implementation_override = block
+  end
+
+  def extract_init_hash(o)
+    return o._pcore_init_hash if o.respond_to?(:_pcore_init_hash)
+
+    result = {}
+    pic = parameter_info(o.class)
+    attrs = attributes(true)
+    pic[0].each do |name|
+      v = o.send(name)
+      result[name] = v unless attrs[name].default_value?(v)
+    end
+    result
+  end
+
   # @api private
   # @return [(Array<String>, Array<PAnyType>, Integer)] array of parameter names, array of parameter types, and a count reflecting the required number of parameters
   def parameter_info(impl_class)
     # Create a types and a names array where optional entries ends up last
+    @parameter_info ||= {}
+    pic = @parameter_info[impl_class]
+    return pic if pic
+
     opt_types = []
     opt_names = []
     non_opt_types = []
@@ -587,7 +647,9 @@ class PObjectType < PMetaType
       end
     end
 
-    [param_names, param_types, non_opt_types.size]
+    pic = [param_names.freeze, param_types.freeze, non_opt_types.size].freeze
+    @parameter_info[impl_class] = pic
+    pic
   end
 
   # @api private
@@ -606,6 +668,7 @@ class PObjectType < PMetaType
   # @api private
   def _pcore_init_from_hash(init_hash)
     TypeAsserter.assert_instance_of('object initializer', TYPE_OBJECT_I12N, init_hash)
+    @type_parameters = EMPTY_HASH
     @attributes = EMPTY_HASH
     @functions = EMPTY_HASH
 
@@ -616,6 +679,7 @@ class PObjectType < PMetaType
     @parent = init_hash[KEY_PARENT]
 
     parent_members = EMPTY_HASH
+    parent_type_params = EMPTY_HASH
     parent_object_type = nil
     unless @parent.nil?
       check_self_recursion(self)
@@ -624,11 +688,35 @@ class PObjectType < PMetaType
       if rp.is_a?(PObjectType)
         parent_object_type = rp
         parent_members = rp.members(true)
+        parent_type_params = rp.type_parameters(true)
+      end
+    end
+
+    type_parameters = init_hash[KEY_TYPE_PARAMETERS]
+    unless type_parameters.nil? || type_parameters.empty?
+      @type_parameters = {}
+      type_parameters.each do |key, param_spec|
+        param_value = :undef
+        if param_spec.is_a?(Hash)
+          param_type = param_spec[KEY_TYPE]
+          param_value = param_spec[KEY_VALUE] if param_spec.include?(KEY_VALUE)
+        else
+          param_type = TypeAsserter.assert_instance_of(nil, PTypeType::DEFAULT, param_spec) { "type_parameter #{label}[#{key}]" }
+        end
+        param_type = POptionalType.new(param_type) unless param_type.is_a?(POptionalType)
+        type_param = PTypeParameter.new(key, self, KEY_TYPE => param_type, KEY_VALUE => param_value).assert_override(parent_type_params)
+        @type_parameters[key] = type_param
       end
     end
 
     constants = init_hash[KEY_CONSTANTS]
-    attr_specs = init_hash[KEY_ATTRIBUTES] || {}
+    attr_specs = init_hash[KEY_ATTRIBUTES]
+    if attr_specs.nil?
+      attr_specs = {}
+    else
+      # attr_specs might be frozen
+      attr_specs = Hash[attr_specs]
+    end
     unless constants.nil? || constants.empty?
       constants.each do |key, value|
         if attr_specs.include?(key)
@@ -641,7 +729,7 @@ class PObjectType < PMetaType
           KEY_KIND => ATTRIBUTE_KIND_CONSTANT
         }
         # Indicate override if parent member exists. Type check etc. will take place later on.
-        attr_spec[KEY_OVERRIDE] = true if parent_members.include?(key)
+        attr_spec[KEY_OVERRIDE] = parent_members.include?(key)
         attr_specs[key] = attr_spec
       end
     end
@@ -728,6 +816,7 @@ class PObjectType < PMetaType
     guarded_recursion(guard, nil) do |g|
       super(visitor, g)
       @parent.accept(visitor, g) unless parent.nil?
+      @type_parameters.values.each { |p| p.accept(visitor, g) }
       @attributes.values.each { |a| a.accept(visitor, g) }
       @functions.values.each { |f| f.accept(visitor, g) }
     end
@@ -784,7 +873,21 @@ class PObjectType < PMetaType
     result = super()
     result[KEY_NAME] = @name if include_name && !@name.nil?
     result[KEY_PARENT] = @parent unless @parent.nil?
-    result[KEY_ATTRIBUTES] = compressed_members_hash(@attributes) unless @attributes.empty?
+    result[KEY_TYPE_PARAMETERS] = compressed_members_hash(@type_parameters) unless @type_parameters.empty?
+    unless @attributes.empty?
+      # Divide attributes into constants and others
+      tc = TypeCalculator.singleton
+      constants, others = @attributes.partition do |_, a|
+        a.kind == ATTRIBUTE_KIND_CONSTANT && a.type == tc.infer(a.value).generalize
+      end.map { |ha| Hash[ha] }
+
+      result[KEY_ATTRIBUTES] = compressed_members_hash(others) unless others.empty?
+      unless constants.empty?
+        # { kind => 'constant', type => <type of value>, value => <value> } becomes just <value>
+        constants.each_pair { |key, a| constants[key] = a.value }
+        result[KEY_CONSTANTS] = constants
+      end
+    end
     result[KEY_FUNCTIONS] = compressed_members_hash(@functions) unless @functions.empty?
     result[KEY_EQUALITY] = @equality unless @equality.nil?
     result[KEY_CHECKS] = @checks unless @checks.nil?
@@ -795,6 +898,7 @@ class PObjectType < PMetaType
     self.class == o.class &&
       @name == o.name &&
       @parent == o.parent &&
+      @type_parameters == o.type_parameters &&
       @attributes == o.attributes &&
       @functions == o.functions &&
       @equality == o.equality &&
@@ -802,7 +906,7 @@ class PObjectType < PMetaType
   end
 
   def hash
-    @name.nil? ? [@parent, @attributes, @functions].hash : @name.hash
+    @name.nil? ? [@parent, @type_parameters, @attributes, @functions].hash : @name.hash
   end
 
   def kind_of_callable?(optional=true, guard = nil)
@@ -817,6 +921,14 @@ class PObjectType < PMetaType
     @parent.nil? ? false : @parent.iterable_type(guard)
   end
 
+  def parameterized?
+    if @type_parameters.empty?
+      @parent.is_a?(PObjectType) ? @parent.parameterized? : false
+    else
+      true
+    end
+  end
+
   # Returns the members (attributes and functions) of this `Object` type. If _include_parent_ is `true`, then all
   # inherited members will be included in the returned `Hash`.
   #
@@ -891,6 +1003,18 @@ class PObjectType < PMetaType
     label.split(DOUBLE_COLON).last
   end
 
+  # Returns the type_parameters of this `Object` type. If _include_parent_ is `true`, then all
+  # inherited type_parameters will be included in the returned `Hash`.
+  #
+  # @param include_parent [Boolean] `true` if inherited type_parameters should be included
+  # @return [Hash{String=>PTypeParameter}] a hash with the type_parameters
+  # @api public
+  def type_parameters(include_parent = false)
+    all = {}
+    collect_type_parameters(all, include_parent)
+    all
+  end
+
   protected
 
   # An Object type is only assignable from another Object type. The other type
@@ -903,6 +1027,8 @@ class PObjectType < PMetaType
         op = o.parent
         op.nil? ? false : assignable?(op, guard)
       end
+    elsif o.is_a?(PObjectTypeExtension)
+      assignable?(o.base_type, guard)
     else
       false
     end
@@ -936,6 +1062,15 @@ class PObjectType < PMetaType
     nil
   end
 
+  def collect_type_parameters(collector, include_parent)
+    if include_parent
+      parent = resolved_parent
+      parent.collect_type_parameters(collector, include_parent) if parent.is_a?(PObjectType)
+    end
+    collector.merge!(@type_parameters)
+    nil
+  end
+
   private
 
   def compressed_members_hash(features)