puppet 5.0.0 → 6.0.0

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

@@ -1,10 +1,12 @@
 require_relative 'ruby_generator'
+require_relative 'type_with_members'
 
 module Puppet::Pops
 module Types
 
 KEY_ATTRIBUTES = 'attributes'.freeze
 KEY_CHECKS = 'checks'.freeze
+KEY_CONSTANTS = 'constants'.freeze
 KEY_EQUALITY = 'equality'.freeze
 KEY_EQUALITY_INCLUDE_TYPE = 'equality_include_type'.freeze
 KEY_FINAL = 'final'.freeze
@@ -12,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
@@ -25,17 +29,25 @@ class PObjectType < PMetaType
   TYPE_OBJECT_NAME = Pcore::TYPE_QUALIFIED_REFERENCE
 
   TYPE_ATTRIBUTE = TypeFactory.struct({
-    KEY_TYPE => PType::DEFAULT,
+    KEY_TYPE => PTypeType::DEFAULT,
     TypeFactory.optional(KEY_FINAL) => PBooleanType::DEFAULT,
     TypeFactory.optional(KEY_OVERRIDE) => PBooleanType::DEFAULT,
     TypeFactory.optional(KEY_KIND) => TYPE_ATTRIBUTE_KIND,
     KEY_VALUE => PAnyType::DEFAULT,
     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 = PType.new(PCallableType::DEFAULT)
+  TYPE_FUNCTION_TYPE = PTypeType.new(PCallableType::DEFAULT)
 
   TYPE_FUNCTION = TypeFactory.struct({
     KEY_TYPE => TYPE_FUNCTION_TYPE,
@@ -43,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))
 
@@ -51,8 +63,10 @@ class PObjectType < PMetaType
 
   TYPE_OBJECT_I12N = TypeFactory.struct({
     TypeFactory.optional(KEY_NAME) => TYPE_OBJECT_NAME,
-    TypeFactory.optional(KEY_PARENT) => PType::DEFAULT,
+    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,
     TypeFactory.optional(KEY_EQUALITY) => TYPE_EQUALITY,
     TypeFactory.optional(KEY_EQUALITY_INCLUDE_TYPE) => PBooleanType::DEFAULT,
@@ -64,7 +78,7 @@ class PObjectType < PMetaType
     type = create_ptype(loader, ir, 'AnyType', '_pcore_init_hash' => TYPE_OBJECT_I12N)
 
     # Now, when the Object type exists, add annotations with keys derived from Annotation and freeze the types.
-    annotations = TypeFactory.optional(PHashType.new(PType.new(Annotation._pcore_type), TypeFactory.hash_kv(Pcore::TYPE_MEMBER_NAME, PAnyType::DEFAULT)))
+    annotations = TypeFactory.optional(PHashType.new(PTypeType.new(Annotation._pcore_type), TypeFactory.hash_kv(Pcore::TYPE_MEMBER_NAME, PAnyType::DEFAULT)))
     TYPE_ATTRIBUTE.hashed_elements[KEY_ANNOTATIONS].replace_value_type(annotations)
     TYPE_FUNCTION.hashed_elements[KEY_ANNOTATIONS].replace_value_type(annotations)
     TYPE_OBJECT_I12N.hashed_elements[KEY_ANNOTATIONS].replace_value_type(annotations)
@@ -77,6 +91,7 @@ class PObjectType < PMetaType
   # @api public
   class PAnnotatedMember
     include Annotatable
+    include InvocableMember
 
     # @return [PObjectType] the object type containing this member
     # @api public
@@ -96,7 +111,7 @@ class PObjectType < PMetaType
     # @option init_hash [PAnyType] 'type' The member type (required)
     # @option init_hash [Boolean] 'override' `true` if this feature must override an inherited feature. Default is `false`.
     # @option init_hash [Boolean] 'final' `true` if this feature cannot be overridden. Default is `false`.
-    # @option init_hash [Hash{PType => Hash}] 'annotations' Annotations hash. Default is `nil`.
+    # @option init_hash [Hash{PTypeType => Hash}] 'annotations' Annotations hash. Default is `nil`.
     # @api public
     def initialize(name, container, init_hash)
       @name = name
@@ -128,7 +143,10 @@ class PObjectType < PMetaType
     def assert_override(parent_members)
       parent_member = parent_members[@name]
       if parent_member.nil?
-        raise Puppet::ParseError, "expected #{label} to override an inherited #{feature_type}, but no such #{feature_type} was found" if @override
+        if @override
+          raise Puppet::ParseError, _("expected %{label} to override an inherited %{feature_type}, but no such %{feature_type} was found") %
+              { label: label, feature_type: feature_type }
+        end
         self
       else
         parent_member.assert_can_be_overridden(self)
@@ -142,13 +160,26 @@ class PObjectType < PMetaType
     # @raises [Puppet::ParseError] if the assertion fails
     # @api private
     def assert_can_be_overridden(member)
-      raise Puppet::ParseError, "#{member.label} attempts to override #{label}" unless self.class == member.class
-      raise Puppet::ParseError, "#{member.label} attempts to override final #{label}" if @final
-      raise Puppet::ParseError, "#{member.label} attempts to override #{label} without having override => true" unless member.override?
-      raise Puppet::ParseError, "#{member.label} attempts to override #{label} with a type that does not match" unless @type.assignable?(member.type)
+      unless self.class == member.class
+        raise Puppet::ParseError, _("%{member} attempts to override %{label}") % { member: member.label, label: label }
+      end
+      if @final && !(constant? && member.constant?)
+        raise Puppet::ParseError, _("%{member} attempts to override final %{label}") % { member: member.label, label: label }
+      end
+      unless member.override?
+        #TRANSLATOR 'override => true' is a puppet syntax and should not be translated
+        raise Puppet::ParseError, _("%{member} attempts to override %{label} without having override => true") % { member: member.label, label: label }
+      end
+      unless @type.assignable?(member.type)
+        raise Puppet::ParseError, _("%{member} attempts to override %{label} with a type that does not match") % { member: member.label, label: label }
+      end
       member
     end
 
+    def constant?
+      false
+    end
+
     # @return [Boolean] `true` if this feature cannot be overridden
     # @api public
     def final?
@@ -220,10 +251,10 @@ class PObjectType < PMetaType
       # TODO: Assumes Ruby implementation for now
       if(callable_type.is_a?(PVariantType))
         callable_type.types.map do |ct|
-          Functions::Dispatch.new(ct, name, [], false, ct.block_type.nil? ? nil : 'block')
+          Functions::Dispatch.new(ct, RubyGenerator.protect_reserved_name(name), [], false, ct.block_type.nil? ? nil : 'block')
         end
       else
-        [Functions::Dispatch.new(callable_type, name, [], false, callable_type.block_type.nil? ? nil : 'block')]
+        [Functions::Dispatch.new(callable_type, RubyGenerator.protect_reserved_name(name), [], false, callable_type.block_type.nil? ? nil : 'block')]
       end
     end
 
@@ -253,22 +284,26 @@ 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
-          raise Puppet::ParseError, "#{label} of kind 'constant' cannot be combined with final => false"
+          #TRANSLATOR 'final => false' is puppet syntax and should not be translated
+          raise Puppet::ParseError, _("%{label} of kind 'constant' cannot be combined with final => false") % { label: label }
         end
         @final = true
       end
 
       if init_hash.include?(KEY_VALUE)
         if @kind == ATTRIBUTE_KIND_DERIVED || @kind == ATTRIBUTE_KIND_GIVEN_OR_DERIVED
-          raise Puppet::ParseError, "#{label} of kind '#{@kind}' cannot be combined with an attribute value"
+          raise Puppet::ParseError, _("%{label} of kind '%{kind}' cannot be combined with an attribute value") % { label: label, kind: @kind }
         end
         v = init_hash[KEY_VALUE]
         @value = v == :default ? v : TypeAsserter.assert_instance_of(nil, type, v) {"#{label} #{KEY_VALUE}" }
       else
-        raise Puppet::ParseError, "#{label} of kind 'constant' requires a value" if @kind == ATTRIBUTE_KIND_CONSTANT
+        raise Puppet::ParseError, _("%{label} of kind 'constant' requires a value") % { label: label } if @kind == ATTRIBUTE_KIND_CONSTANT
         @value = :undef # Not to be confused with nil or :default
       end
     end
@@ -295,6 +330,10 @@ class PObjectType < PMetaType
       hash
     end
 
+    def constant?
+      @kind == ATTRIBUTE_KIND_CONSTANT
+    end
+
     # @return [Booelan] true if the given value equals the default value for this attribute
     def default_value?(value)
       @value == value
@@ -323,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
@@ -347,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
@@ -367,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)
@@ -385,6 +441,7 @@ class PObjectType < PMetaType
       assignable?(o._pcore_type, guard)
     else
       name = o.class.name
+      return false if name.nil? # anonymous class that doesn't implement PuppetObject is not an instance
       ir = Loaders.implementation_registry
       type = ir.nil? ? nil : ir.type_for_module(name)
       !type.nil? && assignable?(type, guard)
@@ -392,8 +449,8 @@ class PObjectType < PMetaType
   end
 
   # @api private
-  def new_function(loader)
-    @new_function ||= create_new_function(loader)
+  def new_function
+    @new_function ||= create_new_function
   end
 
   # Assign a new instance reader to this type
@@ -416,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
@@ -428,18 +485,15 @@ class PObjectType < PMetaType
   end
 
     # @api private
-  def create_new_function(loader)
+  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)
-    from_hash_type = TypeFactory.callable(i12n_type, 1, 1)
+    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.
     Puppet::Functions.create_loaded_function(:"new_#{name}", loader) do
@@ -482,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?
@@ -506,15 +560,47 @@ 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 = []
     non_opt_names = []
-    i12n_type.elements.each do |se|
+    init_hash_type.elements.each do |se|
       if se.key_type.is_a?(POptionalType)
         opt_names << se.name
         opt_types << se.value_type
@@ -531,7 +617,13 @@ class PObjectType < PMetaType
     init_non_opt_count = 0
     init_param_names = init.parameters.map do |p|
       init_non_opt_count += 1 if :req == p[0]
-      p[1].to_s
+      n = p[1].to_s
+      r = RubyGenerator.unprotect_reserved_name(n)
+      unless r.equal?(n)
+        # assert that the protected name wasn't a real name (names can start with underscore)
+        n = r unless param_names.index(r).nil?
+      end
+      n
     end
 
     if init_param_names != param_names
@@ -555,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
@@ -574,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
 
@@ -584,21 +679,65 @@ 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)
       rp = resolved_parent
+      raise Puppet::ParseError, _("reference to unresolved type '%{name}'") % { :name => rp.type_string } if rp.is_a?(PTypeReferenceType)
       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]
-    unless attr_specs.nil? || attr_specs.empty?
+    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)
+          raise Puppet::ParseError, _("attribute %{label}[%{key}] is defined as both a constant and an attribute") % { label: label, key: key }
+        end
+        attr_spec = {
+          # Type must be generic here, or overrides would become impossible
+          KEY_TYPE => TypeCalculator.infer(value).generalize,
+          KEY_VALUE => value,
+          KEY_KIND => ATTRIBUTE_KIND_CONSTANT
+        }
+        # Indicate override if parent member exists. Type check etc. will take place later on.
+        attr_spec[KEY_OVERRIDE] = parent_members.include?(key)
+        attr_specs[key] = attr_spec
+      end
+    end
+
+    unless attr_specs.empty?
       @attributes = Hash[attr_specs.map do |key, attr_spec|
         unless attr_spec.is_a?(Hash)
-          attr_type = TypeAsserter.assert_instance_of(nil, PType::DEFAULT, attr_spec) { "attribute #{label}[#{key}]" }
+          attr_type = TypeAsserter.assert_instance_of(nil, PTypeType::DEFAULT, attr_spec) { "attribute #{label}[#{key}]" }
           attr_spec = { KEY_TYPE => attr_type }
           attr_spec[KEY_VALUE] = nil if attr_type.is_a?(POptionalType)
         end
@@ -613,7 +752,7 @@ class PObjectType < PMetaType
         func_spec = { KEY_TYPE => TypeAsserter.assert_instance_of(nil, TYPE_FUNCTION_TYPE, func_spec) { "function #{label}[#{key}]" } } unless func_spec.is_a?(Hash)
         func = PFunction.new(key, self, func_spec)
         name = func.name
-        raise Puppet::ParseError, "#{func.label} conflicts with attribute with the same name" if @attributes.include?(name)
+        raise Puppet::ParseError, _("%{label} conflicts with attribute with the same name") % { label: func.label } if @attributes.include?(name)
         [name, func.assert_override(parent_members)]
       end].freeze
     end
@@ -625,7 +764,8 @@ class PObjectType < PMetaType
     equality = [equality] if equality.is_a?(String)
     if equality.is_a?(Array)
       unless equality.empty?
-        raise Puppet::ParseError, 'equality_include_type = false cannot be combined with non empty equality specification' unless @equality_include_type
+        #TRANSLATORS equality_include_type = false should not be translated
+        raise Puppet::ParseError, _('equality_include_type = false cannot be combined with non empty equality specification') unless @equality_include_type
         parent_eq_attrs = nil
         equality.each do |attr_name|
 
@@ -637,16 +777,21 @@ class PObjectType < PMetaType
             parent_eq_attrs ||= parent_object_type.equality_attributes
             if parent_eq_attrs.include?(attr_name)
               including_parent = find_equality_definer_of(attr)
-              raise Puppet::ParseError, "#{label} equality is referencing #{attr.label} which is included in equality of #{including_parent.label}"
+              raise Puppet::ParseError, _("%{label} equality is referencing %{attribute} which is included in equality of %{including_parent}") %
+                  { label: label, attribute: attr.label, including_parent: including_parent.label }
             end
           end
 
           unless attr.is_a?(PAttribute)
-            raise Puppet::ParseError, "#{label} equality is referencing non existent attribute '#{attr_name}'" if attr.nil?
-            raise Puppet::ParseError, "#{label} equality is referencing #{attr.label}. Only attribute references are allowed"
+            if attr.nil?
+              raise Puppet::ParseError, _("%{label} equality is referencing non existent attribute '%{attribute}'") % { label: label, attribute: attr_name }
+            end
+            raise Puppet::ParseError, _("%{label} equality is referencing %{attribute}. Only attribute references are allowed") %
+                { label: label, attribute: attr.label }
           end
           if attr.kind == ATTRIBUTE_KIND_CONSTANT
-            raise Puppet::ParseError, "#{label} equality is referencing constant #{attr.label}. Reference to constant is not allowed in equality"
+            raise Puppet::ParseError, _("%{label} equality is referencing constant %{attribute}.") % { label: label, attribute: attr.label } + ' ' +
+                _("Reference to constant is not allowed in equality")
           end
         end
       end
@@ -671,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
@@ -684,8 +830,8 @@ class PObjectType < PMetaType
   #
   # @return [PStructType] the initialization hash type
   # @api public
-  def i12n_type
-    @i12n_type ||= create_i12n_type
+  def init_hash_type
+    @init_hash_type ||= create_init_hash_type
   end
 
   def allocate
@@ -704,7 +850,7 @@ class PObjectType < PMetaType
   #
   # @return [PStructType] the initialization hash type
   # @api private
-  def create_i12n_type
+  def create_init_hash_type
     struct_elems = {}
     attributes(true).values.each do |attr|
       unless attr.kind == ATTRIBUTE_KIND_CONSTANT || attr.kind == ATTRIBUTE_KIND_DERIVED
@@ -727,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?
@@ -738,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 &&
@@ -745,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)
@@ -760,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`.
   #
@@ -818,7 +987,7 @@ class PObjectType < PMetaType
 
   # @api private
   def label
-    @name || '<anonymous object type>'
+    @name || 'Object'
   end
 
   # @api private
@@ -834,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
@@ -846,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
@@ -879,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)