puppet 4.10.0 → 5.0.0

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?

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

@@ -94,7 +94,7 @@ class PRuntimeType < PAnyType
   # @api private
   def _assignable?(o, guard)
     return false unless o.is_a?(PRuntimeType)
-    return false unless @runtime == o.runtime
+    return false unless @runtime.nil? || @runtime == o.runtime
     return true if @name_or_pattern.nil? # t1 is wider
 
     onp = o.name_or_pattern

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

@@ -4,9 +4,9 @@ module Types
 # An unparameterized type that represents all VersionRange instances
 #
 # @api public
-class PSemVerRangeType < PScalarType
+class PSemVerRangeType < PAnyType
   def self.register_ptype(loader, ir)
-    create_ptype(loader, ir, 'ScalarType')
+    create_ptype(loader, ir, 'AnyType')
   end
 
   # Check if a version is included in a version range. The version can be a string or
@@ -90,6 +90,10 @@ class PSemVerRangeType < PScalarType
     end
   end
 
+  def roundtrip_with_string?
+    true
+  end
+
   def instance?(o, guard = nil)
     o.is_a?(SemanticPuppet::VersionRange)
   end

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

@@ -1,10 +1,61 @@
 module Puppet::Pops
 module Types
-  class PAbstractTimeDataType < PAbstractRangeType
+  class PAbstractTimeDataType < PScalarType
     # @param from [AbstractTime] lower bound for this type. Nil or :default means unbounded
     # @param to [AbstractTime] upper bound for this type. Nil or :default means unbounded
-    def initialize(from = nil, to = nil)
-      super(convert_arg(from, true), convert_arg(to, false))
+    def initialize(from, to)
+      @from = convert_arg(from, true)
+      @to = convert_arg(to, false)
+      raise ArgumentError, "'from' must be less or equal to 'to'. Got (#{@from}, #{@to}" unless @from <= @to
+    end
+
+    # Checks if this numeric range intersects with another
+    #
+    # @param o [PNumericType] the range to compare with
+    # @return [Boolean] `true` if this range intersects with the other range
+    # @api public
+    def intersect?(o)
+      self.class == o.class && !(@to < o.numeric_from || o.numeric_to < @from)
+    end
+
+    # Returns the lower bound of the numeric range or `nil` if no lower bound is set.
+    # @return [Float,Integer]
+    def from
+      @from == -Float::INFINITY ? nil : @from
+    end
+
+    # Returns the upper bound of the numeric range or `nil` if no upper bound is set.
+    # @return [Float,Integer]
+    def to
+      @to == Float::INFINITY ? nil : @to
+    end
+
+    # Same as #from but will return `-Float::Infinity` instead of `nil` if no lower bound is set.
+    # @return [Float,Integer]
+    def numeric_from
+      @from
+    end
+
+    # Same as #to but will return `Float::Infinity` instead of `nil` if no lower bound is set.
+    # @return [Float,Integer]
+    def numeric_to
+      @to
+    end
+
+    def hash
+      @from.hash ^ @to.hash
+    end
+
+    def eql?(o)
+      self.class == o.class && @from == o.numeric_from && @to == o.numeric_to
+    end
+
+    def instance?(o, guard = nil)
+      o.is_a?(Numeric) && o >= @from && o <= @to
+    end
+
+    def unbounded?
+      @from == -Float::INFINITY && @to == Float::INFINITY
     end
 
     def convert_arg(arg, min)
@@ -14,7 +65,7 @@ module Types
       when Hash
         impl_class.from_hash(arg)
       when nil, :default
-        nil
+        min ? -Float::INFINITY : Float::INFINITY
       when String
         impl_class.parse(arg)
       when Integer