puppet 4.10.12-universal-darwin → 5.0.0-universal-darwin

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

@@ -7,17 +7,17 @@ KEY_ANNOTATIONS = 'annotations'.freeze
 #
 # @api public
 module Annotatable
-  TYPE_ANNOTATION_KEY_TYPE = PType::DEFAULT # TBD
-  TYPE_ANNOTATION_VALUE_TYPE = PStructType::DEFAULT #TBD
-  TYPE_ANNOTATIONS = PHashType.new(TYPE_ANNOTATION_KEY_TYPE, TYPE_ANNOTATION_VALUE_TYPE)
+  TYPE_ANNOTATIONS = PHashType.new(PType.new(PTypeReferenceType.new('Annotation')), PHashType::DEFAULT)
 
   # @return [{PType => PStructType}] the map of annotations
   # @api public
-  attr_reader :annotations
+  def annotations
+    @annotations.nil? ? EMPTY_HASH : @annotations
+  end
 
   # @api private
-  def init_annotatable(i12n_hash)
-    @annotations = i12n_hash[KEY_ANNOTATIONS].freeze
+  def init_annotatable(init_hash)
+    @annotations = init_hash[KEY_ANNOTATIONS].freeze
   end
 
   # @api private
@@ -26,7 +26,7 @@ module Annotatable
   end
 
   # @api private
-  def i12n_hash
+  def _pcore_init_hash
     result = {}
     result[KEY_ANNOTATIONS] = @annotations unless @annotations.nil?
     result

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

@@ -0,0 +1,71 @@
+module Puppet::Pops
+module Types
+  # Pcore variant of the Adaptable::Adapter. Uses a Pcore Object type instead of a Class
+  class Annotation < Adaptable::Adapter
+    include Types::PuppetObject
+
+    CLEAR = 'clear'.freeze
+
+    # Register the Annotation type. This is the type that all custom Annotations will inherit from.
+    def self.register_ptype(loader, ir)
+      @type = Pcore::create_object_type(loader, ir, self, 'Annotation', nil, EMPTY_HASH)
+    end
+
+    def self._pcore_type
+      @type
+    end
+
+    # Finds an existing annotation for the given object and returns it.
+    # If no annotation was found, and a block is given, a new annotation is created from the
+    # initializer hash that must be returned from the block.
+    # If no annotation was found and no block is given, this method returns `nil`
+    #
+    # @param o [Object] object to annotate
+    # @param block [Proc] optional, evaluated when a new annotation must be created. Should return the i12n hash
+    # @return [Annotation<self>] an annotation of the same class as the receiver of the call
+    #
+    def self.annotate(o)
+      adapter = get(o)
+      if adapter.nil?
+        if o.is_a?(Annotatable)
+          i12n = o.annotations[_pcore_type]
+          i12n = yield if i12n.nil? && block_given?
+        else
+          i12n = yield if block_given?
+        end
+        adapter = associate_adapter(_pcore_type.from_hash(i12n), o) unless i12n.nil?
+      end
+      adapter
+    end
+
+    # Forces the creation or removal of an annotation of this type.
+    # If `i21n` is a hash, a new annotation is created and returned
+    # If `i12n` is `nil`, then the annotation is cleared and the previous annotation is returned.
+    #
+    # @param o [Object] object to annotate
+    # @param i12n [Hash{String,Object},nil] the initializer for the annotation or `nil` to clear the annotation
+    # @return [Annotation<self>] an annotation of the same class as the receiver of the call
+    #
+    def self.annotate_new(o, init_hash)
+      if o.is_a?(Annotatable) && o.annotations.include?(_pcore_type)
+        # Prevent clear or redefine of annotations declared on type
+        action = init_hash == CLEAR ? 'clear' : 'redefine'
+        raise ArgumentError, "attempt to #{action} #{type_name} annotation declared on #{o.label}"
+      end
+
+      if init_hash == CLEAR
+        clear(o)
+      else
+        associate_adapter(_pcore_type.from_hash(init_hash), o)
+      end
+    end
+
+    # Uses name of type instead of name of the class (the class is likely dynamically generated and as such,
+    # has no name)
+    # @return [String] the name of the type
+    def self.type_name
+      _pcore_type.name
+    end
+  end
+end
+end

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

@@ -1,5 +1,3 @@
-require 'rgen/metamodel_builder'
-
 module Puppet::Pops
 module Types
 # The ClassLoader provides a Class instance given a class name or a meta-type.
@@ -86,24 +84,24 @@ class ClassLoader
     # If class is already loaded, try this first
     result = find_class(name_path)
 
-    unless result.is_a?(Class)
+    unless result.is_a?(Module)
       # Attempt to load it using the auto loader
       loaded_path = nil
       if paths_for_name(name_path).find {|path| loaded_path = path; @autoloader.load(path, Puppet.lookup(:current_environment)) }
         result = find_class(name_path)
-        unless result.is_a?(Class)
+        unless result.is_a?(Module)
           raise RuntimeError, "Loading of #{name} using relative path: '#{loaded_path}' did not create expected class"
         end
       end
     end
-    return nil unless result.is_a?(Class)
+    return nil unless result.is_a?(Module)
     result
   end
 
   def self.find_class(name_path)
     name_path.reduce(Object) do |ns, name|
       begin
-        ns.const_get(name)
+        ns.const_get(name, false) # don't search ancestors
       rescue NameError
         return nil
       end

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

@@ -4,12 +4,12 @@
 module Puppet::Pops::Types
   class Enumeration
     def self.enumerator(o)
-      Puppet.deprecation_warning('Enumeration.enumerator is deprecated. Use Iterable.on instead')
+      Puppet.deprecation_warning(_('Enumeration.enumerator is deprecated. Use Iterable.on instead'))
       Iterable.on(o)
     end
 
     def enumerator(o)
-      Puppet.deprecation_warning('Enumeration.enumerator is deprecated. Use Iterable.on instead')
+      Puppet.deprecation_warning(_('Enumeration.enumerator is deprecated. Use Iterable.on instead'))
       Iterable.on(o)
     end
   end

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

@@ -79,8 +79,6 @@ module Puppet::Pops::Types
         o.finite_range? ? IntegerRangeIterator.new(o) : nil
       when PEnumType
         Iterator.new(o, o.values.each)
-      when PTypeAliasType
-        on(o.resolved_type)
       when Range
         min = o.min
         max = o.max
@@ -134,13 +132,13 @@ module Puppet::Pops::Types
     def reverse_each(&block)
       # Default implementation cannot propagate reverse_each to a new enumerator so chained
       # calls must put reverse_each last.
-      raise ArgumentError 'Step is not implemented'
+      raise ArgumentError 'reverse_each() is not implemented'
     end
 
     def step(step, &block)
       # Default implementation cannot propagate step to a new enumerator so chained
       # calls must put stepping last.
-      raise ArgumentError 'Step is not implemented'
+      raise ArgumentError 'step() is not implemented'
     end
 
     def to_a

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

@@ -67,7 +67,7 @@ class PBinaryType < PAnyType
     def self.from_string(encoded_string)
       enc = encoded_string.encoding.name
       unless encoded_string.valid_encoding?
-        raise ArgumentError, "The given string in encoding '#{enc}' is invalid. Cannot create a Binary UTF-8 representation"
+        raise ArgumentError, _("The given string in encoding '%{enc}' is invalid. Cannot create a Binary UTF-8 representation") % { enc: enc }
       end
       # Convert to UTF-8 (if not already UTF-8), and then to binary
       encoded_string = (enc == "UTF-8") ? encoded_string.dup : encoded_string.encode('UTF-8')
@@ -137,6 +137,12 @@ class PBinaryType < PAnyType
     self.class == o.class
   end
 
+  # Binary uses the strict base64 format as its string representation
+  # @return [TrueClass] true
+  def roundtrip_with_string?
+    true
+  end
+
   # @api private
   def self.new_function(_, loader)
     @new_function ||= Puppet::Functions.create_loaded_function(:new_Binary, loader) do

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

@@ -19,6 +19,10 @@ class PMetaType < PAnyType
     super
   end
 
+  def instance?(o, guard = nil)
+    assignable?(TypeCalculator.infer(o), guard)
+  end
+
   # Called from the TypeParser once it has found a type using the Loader. The TypeParser will
   # interpret the contained expression and the resolved type is remembered. This method also
   # checks and remembers if the resolve type contains self recursion.
@@ -28,17 +32,17 @@ class PMetaType < PAnyType
   # @return [PTypeAliasType] the receiver of the call, i.e. `self`
   # @api private
   def resolve(type_parser, loader)
-    unless @i12n_hash_expression.nil?
+    unless @init_hash_expression.nil?
       @self_recursion = true # assumed while it being found out below
 
-      i12n_hash_expression = @i12n_hash_expression
-      @i12n_hash_expression = nil
-      if i12n_hash_expression.is_a?(Model::LiteralHash)
-        i12n_hash = resolve_literal_hash(type_parser, loader, i12n_hash_expression)
+      init_hash_expression = @init_hash_expression
+      @init_hash_expression = nil
+      if init_hash_expression.is_a?(Model::LiteralHash)
+        init_hash = resolve_literal_hash(type_parser, loader, init_hash_expression)
       else
-        i12n_hash = resolve_hash(type_parser, loader, i12n_hash_expression)
+        init_hash = resolve_hash(type_parser, loader, init_hash_expression)
       end
-      initialize_from_hash(i12n_hash)
+      _pcore_init_from_hash(init_hash)
 
       # Find out if this type is recursive. A recursive type has performance implications
       # on several methods and this knowledge is used to avoid that for non-recursive
@@ -50,12 +54,12 @@ class PMetaType < PAnyType
     self
   end
 
-  def resolve_literal_hash(type_parser, loader, i12n_hash_expression)
-    type_parser.interpret_LiteralHash(i12n_hash_expression, loader)
+  def resolve_literal_hash(type_parser, loader, init_hash_expression)
+    type_parser.interpret_LiteralHash(init_hash_expression, loader)
   end
 
-  def resolve_hash(type_parser, loader, i12n_hash)
-    resolve_type_refs(type_parser, loader, i12n_hash)
+  def resolve_hash(type_parser, loader, init_hash)
+    resolve_type_refs(type_parser, loader, init_hash)
   end
 
   def resolve_type_refs(type_parser, loader, o)
@@ -80,4 +84,4 @@ class PMetaType < PAnyType
   end
 end
 end
-end
+end

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

@@ -19,49 +19,58 @@ class PObjectType < PMetaType
   ATTRIBUTE_KIND_CONSTANT = 'constant'.freeze
   ATTRIBUTE_KIND_DERIVED = 'derived'.freeze
   ATTRIBUTE_KIND_GIVEN_OR_DERIVED = 'given_or_derived'.freeze
-  TYPE_ATTRIBUTE_KIND = TypeFactory.enum(ATTRIBUTE_KIND_CONSTANT, ATTRIBUTE_KIND_DERIVED, ATTRIBUTE_KIND_GIVEN_OR_DERIVED)
+  ATTRIBUTE_KIND_REFERENCE = 'reference'.freeze
+  TYPE_ATTRIBUTE_KIND = TypeFactory.enum(ATTRIBUTE_KIND_CONSTANT, ATTRIBUTE_KIND_DERIVED, ATTRIBUTE_KIND_GIVEN_OR_DERIVED, ATTRIBUTE_KIND_REFERENCE)
 
   TYPE_OBJECT_NAME = Pcore::TYPE_QUALIFIED_REFERENCE
-  TYPE_MEMBER_NAME = PPatternType.new([PRegexpType.new(Patterns::PARAM_NAME)])
 
   TYPE_ATTRIBUTE = TypeFactory.struct({
     KEY_TYPE => PType::DEFAULT,
-    KEY_ANNOTATIONS => TypeFactory.optional(TYPE_ANNOTATIONS),
-    KEY_FINAL => TypeFactory.optional(PBooleanType::DEFAULT),
-    KEY_OVERRIDE => TypeFactory.optional(PBooleanType::DEFAULT),
-    KEY_KIND => TypeFactory.optional(TYPE_ATTRIBUTE_KIND),
-    KEY_VALUE => PAnyType::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_ATTRIBUTES = TypeFactory.hash_kv(TYPE_MEMBER_NAME, TypeFactory.not_undef)
+  TYPE_ATTRIBUTES = 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 = TypeFactory.struct({
     KEY_TYPE => TYPE_FUNCTION_TYPE,
-    KEY_ANNOTATIONS => TypeFactory.optional(TYPE_ANNOTATIONS),
-    KEY_FINAL => TypeFactory.optional(PBooleanType::DEFAULT),
-    KEY_OVERRIDE => TypeFactory.optional(PBooleanType::DEFAULT)
+    TypeFactory.optional(KEY_FINAL) => PBooleanType::DEFAULT,
+    TypeFactory.optional(KEY_OVERRIDE) => PBooleanType::DEFAULT,
+    TypeFactory.optional(KEY_ANNOTATIONS) => TYPE_ANNOTATIONS
   })
-  TYPE_FUNCTIONS = TypeFactory.hash_kv(TYPE_MEMBER_NAME, TypeFactory.not_undef)
+  TYPE_FUNCTIONS = TypeFactory.hash_kv(Pcore::TYPE_MEMBER_NAME, TypeFactory.not_undef)
 
-  TYPE_EQUALITY = TypeFactory.variant(TYPE_MEMBER_NAME, TypeFactory.array_of(TYPE_MEMBER_NAME))
+  TYPE_EQUALITY = TypeFactory.variant(Pcore::TYPE_MEMBER_NAME, TypeFactory.array_of(Pcore::TYPE_MEMBER_NAME))
 
   TYPE_CHECKS = PAnyType::DEFAULT # TBD
 
   TYPE_OBJECT_I12N = TypeFactory.struct({
-    KEY_NAME => TypeFactory.optional(TYPE_OBJECT_NAME),
-    KEY_PARENT => TypeFactory.optional(PType::DEFAULT),
-    KEY_ATTRIBUTES => TypeFactory.optional(TYPE_ATTRIBUTES),
-    KEY_FUNCTIONS => TypeFactory.optional(TYPE_FUNCTIONS),
-    KEY_EQUALITY => TypeFactory.optional(TYPE_EQUALITY),
-    KEY_EQUALITY_INCLUDE_TYPE => TypeFactory.optional(PBooleanType::DEFAULT),
-    KEY_CHECKS =>  TypeFactory.optional(TYPE_CHECKS),
-    KEY_ANNOTATIONS =>  TypeFactory.optional(TYPE_ANNOTATIONS)
+    TypeFactory.optional(KEY_NAME) => TYPE_OBJECT_NAME,
+    TypeFactory.optional(KEY_PARENT) => PType::DEFAULT,
+    TypeFactory.optional(KEY_ATTRIBUTES) => TYPE_ATTRIBUTES,
+    TypeFactory.optional(KEY_FUNCTIONS) => TYPE_FUNCTIONS,
+    TypeFactory.optional(KEY_EQUALITY) => TYPE_EQUALITY,
+    TypeFactory.optional(KEY_EQUALITY_INCLUDE_TYPE) => PBooleanType::DEFAULT,
+    TypeFactory.optional(KEY_CHECKS) =>  TYPE_CHECKS,
+    TypeFactory.optional(KEY_ANNOTATIONS) => TYPE_ANNOTATIONS
   })
 
   def self.register_ptype(loader, ir)
-    create_ptype(loader, ir, 'AnyType', 'i12n_hash' => TYPE_OBJECT_I12N)
+    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)))
+    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)
+    PTypeSetType::TYPE_TYPESET_I12N.hashed_elements[KEY_ANNOTATIONS].replace_value_type(annotations)
+    PTypeSetType::TYPE_TYPE_REFERENCE_I12N.hashed_elements[KEY_ANNOTATIONS].replace_value_type(annotations)
+    type
   end
 
   # @abstract Encapsulates behavior common to {PAttribute} and {PFunction}
@@ -83,21 +92,21 @@ class PObjectType < PMetaType
 
     # @param name [String] The name of the member
     # @param container [PObjectType] The containing object type
-    # @param i12n_hash [Hash{String=>Object}] Hash containing feature options
-    # @option i12n_hash [PAnyType] 'type' The member type (required)
-    # @option i12n_hash [Boolean] 'override' `true` if this feature must override an inherited feature. Default is `false`.
-    # @option i12n_hash [Boolean] 'final' `true` if this feature cannot be overridden. Default is `false`.
-    # @option i12n_hash [Hash{PType => Hash}] 'annotations' Annotations hash. Default is `nil`.
+    # @param init_hash [Hash{String=>Object}] Hash containing feature options
+    # @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`.
     # @api public
-    def initialize(name, container, i12n_hash)
+    def initialize(name, container, init_hash)
       @name = name
       @container = container
-      @type = i12n_hash[KEY_TYPE]
-      @override = i12n_hash[KEY_OVERRIDE]
+      @type = init_hash[KEY_TYPE]
+      @override = init_hash[KEY_OVERRIDE]
       @override = false if @override.nil?
-      @final = i12n_hash[KEY_FINAL]
+      @final = init_hash[KEY_FINAL]
       @final = false if @final.nil?
-      init_annotatable(i12n_hash)
+      init_annotatable(init_hash)
     end
 
     # Delegates to the contained type
@@ -170,7 +179,7 @@ class PObjectType < PMetaType
     # Returns the member as a hash suitable as an argument for constructor. Name is excluded
     # @return [Hash{String=>Object}] the initialization hash
     # @api private
-    def i12n_hash
+    def _pcore_init_hash
       hash = { KEY_TYPE => @type }
       hash[KEY_FINAL] = true if @final
       hash[KEY_OVERRIDE] = true if @override
@@ -232,32 +241,31 @@ class PObjectType < PMetaType
   # @api public
   class PAttribute < PAnnotatedMember
 
-    # @return [String,nil] The attribute kind as defined by #TYPE_ATTRIBUTE_KIND, or `nil` to
-    #   indicate that
+    # @return [String,nil] The attribute kind as defined by #TYPE_ATTRIBUTE_KIND, or `nil`
     attr_reader :kind
 
     # @param name [String] The name of the attribute
     # @param container [PObjectType] The containing object type
-    # @param i12n_hash [Hash{String=>Object}] Hash containing attribute options
-    # @option i12n_hash [PAnyType] 'type' The attribute type (required)
-    # @option i12n_hash [Object] 'value' The default value, must be an instanceof the given `type` (optional)
-    # @option i12n_hash [String] 'kind' The attribute kind, matching #TYPE_ATTRIBUTE_KIND
+    # @param init_hash [Hash{String=>Object}] Hash containing attribute options
+    # @option init_hash [PAnyType] 'type' The attribute type (required)
+    # @option init_hash [Object] 'value' The default value, must be an instanceof the given `type` (optional)
+    # @option init_hash [String] 'kind' The attribute kind, matching #TYPE_ATTRIBUTE_KIND
     # @api public
-    def initialize(name, container, i12n_hash)
-      super(name, container, TypeAsserter.assert_instance_of(nil, TYPE_ATTRIBUTE, i12n_hash) { "initializer for #{self.class.label(container, name)}" })
-      @kind = i12n_hash[KEY_KIND]
+    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)}" })
+      @kind = init_hash[KEY_KIND]
       if @kind == ATTRIBUTE_KIND_CONSTANT # final is implied
-        if i12n_hash.include?(KEY_FINAL) && !@final
+        if init_hash.include?(KEY_FINAL) && !@final
           raise Puppet::ParseError, "#{label} of kind 'constant' cannot be combined with final => false"
         end
         @final = true
       end
 
-      if i12n_hash.include?(KEY_VALUE)
+      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"
         end
-        v = i12n_hash[KEY_VALUE]
+        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
@@ -277,7 +285,7 @@ class PObjectType < PMetaType
     # Returns the member as a hash suitable as an argument for constructor. Name is excluded
     # @return [Hash{String=>Object}] the hash
     # @api private
-    def i12n_hash
+    def _pcore_init_hash
       hash = super
       unless @kind.nil?
         hash[KEY_KIND] = @kind
@@ -287,6 +295,11 @@ class PObjectType < PMetaType
       hash
     end
 
+    # @return [Booelan] true if the given value equals the default value for this attribute
+    def default_value?(value)
+      @value == value
+    end
+
     # @return [Boolean] `true` if a value has been defined for this attribute.
     def value?
       @value != :undef
@@ -316,10 +329,10 @@ class PObjectType < PMetaType
 
     # @param name [String] The name of the attribute
     # @param container [PObjectType] The containing object type
-    # @param i12n_hash [Hash{String=>Object}] Hash containing function options
+    # @param init_hash [Hash{String=>Object}] Hash containing function options
     # @api public
-    def initialize(name, container, i12n_hash)
-      super(name, container, TypeAsserter.assert_instance_of(["initializer for function '%s'", name], TYPE_FUNCTION, i12n_hash))
+    def initialize(name, container, init_hash)
+      super(name, container, TypeAsserter.assert_instance_of(["initializer for function '%s'", name], TYPE_FUNCTION, init_hash))
     end
 
     def callable_type
@@ -343,28 +356,38 @@ class PObjectType < PMetaType
   # Initialize an Object Type instance. The initialization will use either a name and an initialization
   # hash expression, or a fully resolved initialization hash.
   #
-  # @overload initialize(name, i12n_hash_expression)
+  # @overload initialize(name, init_hash_expression)
   #   Used when the Object type is loaded using a type alias expression. When that happens, it is important that
   #   the actual resolution of the expression is deferred until all definitions have been made known to the current
   #   loader. The object will then be resolved when it is loaded by the {TypeParser}. "resolved" here, means that
-  #   the hash expression is fully resolved, and then passed to the {#initialize_from_hash} method.
+  #   the hash expression is fully resolved, and then passed to the {#_pcore_init_from_hash} method.
   #   @param name [String] The name of the object
-  #   @param i12n_hash_expression [Model::LiteralHash] The hash describing the Object features
+  #   @param init_hash_expression [Model::LiteralHash] The hash describing the Object features
   #
-  # @overload initialize(i12n_hash)
-  #   Used when the object is created by the {TypeFactory}. The i12n_hash must be fully resolved.
-  #   @param i12n_hash [Hash{String=>Object}] The hash describing the Object features
+  # @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
   #
   # @api private
-  def initialize(i12n_hash, i12n_hash_expression = nil)
-    @attributes = EMPTY_HASH
-    @functions = EMPTY_HASH
+  def initialize(_pcore_init_hash, init_hash_expression = nil)
+    if _pcore_init_hash.is_a?(Hash)
+      _pcore_init_from_hash(_pcore_init_hash)
+    else
+      @attributes = EMPTY_HASH
+      @functions = EMPTY_HASH
+      @name = TypeAsserter.assert_instance_of('object name', TYPE_OBJECT_NAME, _pcore_init_hash)
+      @init_hash_expression = init_hash_expression
+    end
+  end
 
-    if i12n_hash.is_a?(Hash)
-      initialize_from_hash(i12n_hash)
+  def instance?(o, guard = nil)
+    if o.is_a?(PuppetObject)
+      assignable?(o._pcore_type, guard)
     else
-      @name = TypeAsserter.assert_instance_of('object name', TYPE_OBJECT_NAME, i12n_hash)
-      @i12n_hash_expression = i12n_hash_expression
+      name = o.class.name
+      ir = Loaders.implementation_registry
+      type = ir.nil? ? nil : ir.type_for_module(name)
+      !type.nil? && assignable?(type, guard)
     end
   end
 
@@ -456,9 +479,10 @@ class PObjectType < PMetaType
   end
 
   # @api private
-  def implementation_class
-    if @implementation_class.nil?
-      impl_name = Loaders.implementation_registry.module_name_for_type(self)
+  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?
         # Use generator to create a default implementation
         @implementation_class = RubyGenerator.new.create_class(self)
@@ -476,9 +500,15 @@ class PObjectType < PMetaType
     @implementation_class
   end
 
+  # @api private
+  def implementation_class=(cls)
+    raise ArgumentError, "attempt to redefine implementation class for #{label}" unless @implementation_class.nil?
+    @implementation_class = cls
+  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, attr_readers = false)
+  def parameter_info(impl_class)
     # Create a types and a names array where optional entries ends up last
     opt_types = []
     opt_names = []
@@ -486,10 +516,10 @@ class PObjectType < PMetaType
     non_opt_names = []
     i12n_type.elements.each do |se|
       if se.key_type.is_a?(POptionalType)
-        opt_names << (attr_readers ? attr_reader_name(se) : se.name)
+        opt_names << se.name
         opt_types << se.value_type
       else
-        non_opt_names << (attr_readers ? attr_reader_name(se) : se.name)
+        non_opt_names << se.name
         non_opt_types << se.value_type
       end
     end
@@ -537,20 +567,21 @@ class PObjectType < PMetaType
     end
   end
 
-  # @api private
-  def include_class_in_equality?
-    @equality_include_type && !(@parent.is_a?(PObjectType) && parent.include_class_in_equality?)
+  def self.from_hash(hash)
+    new(hash, nil)
   end
 
   # @api private
-  def initialize_from_hash(i12n_hash)
-    TypeAsserter.assert_instance_of('object initializer', TYPE_OBJECT_I12N, i12n_hash)
+  def _pcore_init_from_hash(init_hash)
+    TypeAsserter.assert_instance_of('object initializer', TYPE_OBJECT_I12N, init_hash)
+    @attributes = EMPTY_HASH
+    @functions = EMPTY_HASH
 
     # Name given to the loader have higher precedence than a name declared in the type
-    @name ||= i12n_hash[KEY_NAME]
+    @name ||= init_hash[KEY_NAME]
     @name.freeze unless @name.nil?
 
-    @parent = i12n_hash[KEY_PARENT]
+    @parent = init_hash[KEY_PARENT]
 
     parent_members = EMPTY_HASH
     parent_object_type = nil
@@ -563,16 +594,20 @@ class PObjectType < PMetaType
       end
     end
 
-    attr_specs = i12n_hash[KEY_ATTRIBUTES]
+    attr_specs = init_hash[KEY_ATTRIBUTES]
     unless attr_specs.nil? || attr_specs.empty?
       @attributes = Hash[attr_specs.map do |key, attr_spec|
-        attr_spec = { KEY_TYPE => TypeAsserter.assert_instance_of(nil, PType::DEFAULT, attr_spec) { "attribute #{label}[#{key}]" } } unless attr_spec.is_a?(Hash)
+        unless attr_spec.is_a?(Hash)
+          attr_type = TypeAsserter.assert_instance_of(nil, PType::DEFAULT, attr_spec) { "attribute #{label}[#{key}]" }
+          attr_spec = { KEY_TYPE => attr_type }
+          attr_spec[KEY_VALUE] = nil if attr_type.is_a?(POptionalType)
+        end
         attr = PAttribute.new(key, self, attr_spec)
         [attr.name, attr.assert_override(parent_members)]
       end].freeze
     end
 
-    func_specs = i12n_hash[KEY_FUNCTIONS]
+    func_specs = init_hash[KEY_FUNCTIONS]
     unless func_specs.nil? || func_specs.empty?
       @functions = Hash[func_specs.map do |key, func_spec|
         func_spec = { KEY_TYPE => TypeAsserter.assert_instance_of(nil, TYPE_FUNCTION_TYPE, func_spec) { "function #{label}[#{key}]" } } unless func_spec.is_a?(Hash)
@@ -583,10 +618,10 @@ class PObjectType < PMetaType
       end].freeze
     end
 
-    @equality_include_type = i12n_hash[KEY_EQUALITY_INCLUDE_TYPE]
+    @equality_include_type = init_hash[KEY_EQUALITY_INCLUDE_TYPE]
     @equality_include_type = true if @equality_include_type.nil?
 
-    equality = i12n_hash[KEY_EQUALITY]
+    equality = init_hash[KEY_EQUALITY]
     equality = [equality] if equality.is_a?(String)
     if equality.is_a?(Array)
       unless equality.empty?
@@ -619,8 +654,8 @@ class PObjectType < PMetaType
     end
     @equality = equality
 
-    @checks = i12n_hash[KEY_CHECKS]
-    init_annotatable(i12n_hash)
+    @checks = init_hash[KEY_CHECKS]
+    init_annotatable(init_hash)
   end
 
   def [](name)
@@ -653,6 +688,10 @@ class PObjectType < PMetaType
     @i12n_type ||= create_i12n_type
   end
 
+  def allocate
+    implementation_class.allocate
+  end
+
   def create(*args)
     implementation_class.create(*args)
   end
@@ -679,12 +718,12 @@ class PObjectType < PMetaType
     TypeFactory.struct(struct_elems)
   end
 
-  # The i12n_hash is primarily intended for serialization and string representation purposes. It creates a hash
-  # suitable for passing to {PObjectType#new(i12n_hash)}
+  # The init_hash is primarily intended for serialization and string representation purposes. It creates a hash
+  # suitable for passing to {PObjectType#new(init_hash)}
   #
   # @return [Hash{String=>Object}] the features hash
   # @api public
-  def i12n_hash(include_name = true)
+  def _pcore_init_hash(include_name = true)
     result = super()
     result[KEY_NAME] = @name if include_name && !@name.nil?
     result[KEY_PARENT] = @parent unless @parent.nil?
@@ -713,10 +752,6 @@ class PObjectType < PMetaType
     @parent.nil? ? false : @parent.kind_of_callable?(optional, guard)
   end
 
-  def instance?(o, guard = nil)
-    assignable?(TypeCalculator.infer(o), guard)
-  end
-
   def iterable?(guard = nil)
     @parent.nil? ? false : @parent.iterable?(guard)
   end
@@ -795,20 +830,24 @@ class PObjectType < PMetaType
     parent
   end
 
+  def simple_name
+    label.split(DOUBLE_COLON).last
+  end
+
   protected
 
   # An Object type is only assignable from another Object type. The other type
   # or one of its parents must be equal to this type.
   def _assignable?(o, guard)
-    if self == o
-      true
-    else
-      if o.is_a?(PObjectType)
+    if o.is_a?(PObjectType)
+      if DEFAULT == self || self == o
+        true
+      else
         op = o.parent
         op.nil? ? false : assignable?(op, guard)
-      else
-        false
       end
+    else
+      false
     end
   end
 
@@ -844,7 +883,7 @@ class PObjectType < PMetaType
 
   def compressed_members_hash(features)
     Hash[features.values.map do |feature|
-      fh = feature.i12n_hash
+      fh = feature._pcore_init_hash
       if fh.size == 1
         type = fh[KEY_TYPE]
         fh = type unless type.nil?