puppet 3.6.2 → 3.7.0

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

@@ -18,8 +18,9 @@ module Puppet::Pops::Types::TypeFactory
   #
   def self.range(from, to)
     t = Types::PIntegerType.new()
-    t.from = from unless (from == :default || from == 'default')
-    t.to = to unless (to == :default || to == 'default')
+    # optimize eq with symbol (faster when it is left)
+    t.from = from unless (:default == from || from == 'default')
+    t.to = to unless (:default == to || to == 'default')
     t
   end
 
@@ -28,8 +29,9 @@ module Puppet::Pops::Types::TypeFactory
   #
   def self.float_range(from, to)
     t = Types::PFloatType.new()
-    t.from = Float(from) unless from == :default || from.nil?
-    t.to = Float(to) unless to == :default || to.nil?
+    # optimize eq with symbol (faster when it is left)
+    t.from = Float(from) unless :default == from || from.nil?
+    t.to = Float(to) unless :default == to || to.nil?
     t
   end
 
@@ -70,11 +72,6 @@ module Puppet::Pops::Types::TypeFactory
     t
   end
 
-  # Convenience method to produce an Optional[Object] type
-  def self.optional_object()
-    optional(object())
-  end
-
   # Produces the Enum type, optionally with specific string values
   # @api public
   #
@@ -93,9 +90,10 @@ module Puppet::Pops::Types::TypeFactory
     t
   end
 
-  # Produces the Struct type, either a non parameterized instance representing all structs (i.e. all hashes)
-  # or a hash with a given set of keys of String type (names), bound to a value of a given type. Type may be
-  # a Ruby Class, a Puppet Type, or an instance from which the type is inferred.
+  # Produces the Struct type, either a non parameterized instance representing
+  # all structs (i.e. all hashes) or a hash with a given set of keys of String
+  # type (names), bound to a value of a given type. Type may be a Ruby Class, a
+  # Puppet Type, or an instance from which the type is inferred.
   #
   def self.struct(name_type_hash = {})
     t = Types::PStructType.new
@@ -124,15 +122,16 @@ module Puppet::Pops::Types::TypeFactory
     Types::PBooleanType.new()
   end
 
-  # Produces the Object type
+  # Produces the Any type
   # @api public
   #
-  def self.object()
-    Types::PObjectType.new()
+  def self.any()
+    Types::PAnyType.new()
   end
 
   # Produces the Regexp type
-  # @param pattern [Regexp, String, nil] (nil) The regular expression object or a regexp source string, or nil for bare type
+  # @param pattern [Regexp, String, nil] (nil) The regular expression object or
+  #   a regexp source string, or nil for bare type
   # @api public
   #
   def self.regexp(pattern = nil)
@@ -198,20 +197,18 @@ module Puppet::Pops::Types::TypeFactory
   # use {#all_callables}.
   #
   # The params is a list of types, where the three last entries may be
-  # optionally followed by min, max count, and a Callable which is taken as the block_type.
+  # optionally followed by min, max count, and a Callable which is taken as the
+  # block_type.
   # If neither min or max are specified the parameters must match exactly.
   # A min < params.size means that the difference are optional.
   # If max > params.size means that the last type repeats.
   # if max is :default, the max value is unbound (infinity).
-  # 
+  #
   # Params are given as a sequence of arguments to {#type_of}.
   #
   def self.callable(*params)
-    case params.last
-    when Types::PCallableType
+    if Puppet::Pops::Types::TypeCalculator.is_kind_of_callable?(params.last)
       last_callable = true
-    when Types::POptionalType
-      last_callable = true if params.last.optional_type.is_a?(Types::PCallableType)
     end
     block_t = last_callable ? params.pop : nil
 
@@ -226,6 +223,10 @@ module Puppet::Pops::Types::TypeFactory
 
     types = params.map {|p| type_of(p) }
 
+    # If the specification requires types, and none were given, a Unit type is used
+    if types.empty? && !size_type.nil? && size_type.range[1] > 0
+      types << Types::PUnitType.new
+    end
     # create a signature
     callable_t = Types::PCallableType.new()
     tuple_t = tuple(*types)
@@ -266,27 +267,41 @@ module Puppet::Pops::Types::TypeFactory
     Types::PNilType.new()
   end
 
+  # Creates an instance of the Default type
+  # @api public
+  def self.default()
+    Types::PDefaultType.new()
+  end
+
   # Produces an instance of the abstract type PCatalogEntryType
   def self.catalog_entry()
     Types::PCatalogEntryType.new()
   end
 
-  # Produces a PResourceType with a String type_name
-  # A PResourceType with a nil or empty name is compatible with any other PResourceType.
-  # A PResourceType with a given name is only compatible with a PResourceType with the same name.
-  # (There is no resource-type subtyping in Puppet (yet)).
+  # Produces a PResourceType with a String type_name A PResourceType with a nil
+  # or empty name is compatible with any other PResourceType.  A PResourceType
+  # with a given name is only compatible with a PResourceType with the same
+  # name.  (There is no resource-type subtyping in Puppet (yet)).
   #
   def self.resource(type_name = nil, title = nil)
     type = Types::PResourceType.new()
     type_name = type_name.type_name if type_name.is_a?(Types::PResourceType)
-    type.type_name = type_name.downcase unless type_name.nil?
+    type_name = type_name.downcase unless type_name.nil?
+    type.type_name = type_name
+    unless type_name.nil? || type_name =~ Puppet::Pops::Patterns::CLASSREF
+      raise ArgumentError, "Illegal type name '#{type.type_name}'"
+    end
+    if type_name.nil? && !title.nil?
+      raise ArgumentError, "The type name cannot be nil, if title is given"
+    end
     type.title = title
     type
   end
 
-  # Produces PHostClassType with a string class_name.
-  # A PHostClassType with nil or empty name is compatible with any other PHostClassType.
-  # A PHostClassType with a given name is only compatible with a PHostClassType with the same name.
+  # Produces PHostClassType with a string class_name.  A PHostClassType with
+  # nil or empty name is compatible with any other PHostClassType.  A
+  # PHostClassType with a given name is only compatible with a PHostClassType
+  # with the same name.
   #
   def self.host_class(class_name = nil)
     type = Types::PHostClassType.new()
@@ -296,7 +311,8 @@ module Puppet::Pops::Types::TypeFactory
     type
   end
 
-  # Produces a type for Array[o] where o is either a type, or an instance for which a type is inferred.
+  # Produces a type for Array[o] where o is either a type, or an instance for
+  # which a type is inferred.
   # @api public
   #
   def self.array_of(o)
@@ -305,7 +321,8 @@ module Puppet::Pops::Types::TypeFactory
     type
   end
 
-  # Produces a type for Hash[Scalar, o] where o is either a type, or an instance for which a type is inferred.
+  # Produces a type for Hash[Scalar, o] where o is either a type, or an
+  # instance for which a type is inferred.
   # @api public
   #
   def self.hash_of(value, key = scalar())
@@ -343,31 +360,33 @@ module Puppet::Pops::Types::TypeFactory
     type
   end
 
-  # Produce a type corresponding to the class of given unless given is a String, Class or a PAbstractType.
-  # When a String is given this is taken as a classname.
+  # Produce a type corresponding to the class of given unless given is a
+  # String, Class or a PAnyType.  When a String is given this is taken as
+  # a classname.
   #
   def self.type_of(o)
     if o.is_a?(Class)
       @type_calculator.type(o)
-    elsif o.is_a?(Types::PAbstractType)
+    elsif o.is_a?(Types::PAnyType)
       o
     elsif o.is_a?(String)
-      type = Types::PRubyType.new()
-      type.ruby_class = o
-      type
+      Types::PRuntimeType.new(:runtime => :ruby, :runtime_type_name => o)
     else
       @type_calculator.infer_generic(o)
     end
   end
 
-  # Produces a type for a class or infers a type for something that is not a class
+  # Produces a type for a class or infers a type for something that is not a
+  # class
   # @note
   #   To get the type for the class' class use `TypeCalculator.infer(c)`
   #
   # @overload ruby(o)
-  #   @param o [Class] produces the type corresponding to the class (e.g. Integer becomes PIntegerType)
+  #   @param o [Class] produces the type corresponding to the class (e.g.
+  #     Integer becomes PIntegerType)
   # @overload ruby(o)
-  #   @param o [Object] produces the type corresponding to the instance class (e.g. 3 becomes PIntegerType)
+  #   @param o [Object] produces the type corresponding to the instance class
+  #     (e.g. 3 becomes PIntegerType)
   #
   # @api public
   #
@@ -375,32 +394,39 @@ module Puppet::Pops::Types::TypeFactory
     if o.is_a?(Class)
       @type_calculator.type(o)
     else
-      type = Types::PRubyType.new()
-      type.ruby_class = o.class.name
-      type
+      Types::PRuntimeType.new(:runtime => :ruby, :runtime_type_name => o.class.name)
     end
   end
 
-  # Generic creator of a RubyType - allows creating the Ruby type with nil name, or String name.
-  # Also see ruby(o) which performs inference, or mapps a Ruby Class to its name.
+  # Generic creator of a RuntimeType["ruby"] - allows creating the Ruby type
+  # with nil name, or String name.  Also see ruby(o) which performs inference,
+  # or mapps a Ruby Class to its name.
   #
   def self.ruby_type(class_name = nil)
-    type = Types::PRubyType.new()
-    type.ruby_class = class_name
-    type
+    Types::PRuntimeType.new(:runtime => :ruby, :runtime_type_name => class_name)
+  end
+
+  # Generic creator of a RuntimeType - allows creating the type with nil or
+  # String runtime_type_name.  Also see ruby_type(o) and ruby(o).
+  #
+  def self.runtime(runtime=nil, runtime_type_name = nil)
+    runtime = runtime.to_sym if runtime.is_a?(String)
+    Types::PRuntimeType.new(:runtime => runtime, :runtime_type_name => runtime_type_name)
   end
 
-  # Sets the accepted size range of a collection if something other than the default 0 to Infinity
-  # is wanted. The semantics for from/to are the same as for #range
+  # Sets the accepted size range of a collection if something other than the
+  # default 0 to Infinity is wanted. The semantics for from/to are the same as
+  # for #range
   #
   def self.constrain_size(collection_t, from, to)
     collection_t.size_type = range(from, to)
     collection_t
   end
 
-  # Returns true if the given type t is of valid range parameter type (integer or literal default).
+  # Returns true if the given type t is of valid range parameter type (integer
+  # or literal default).
   def self.is_range_parameter?(t)
-    t.is_a?(Integer) || t == 'default' || t == :default
+    t.is_a?(Integer) || t == 'default' || :default == t
   end
 
 end

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

@@ -24,7 +24,7 @@ class Puppet::Pops::Types::TypeParser
   #
   # @param string [String] a string with the type expressed in stringified form as produced by the 
   #   {Puppet::Pops::Types::TypeCalculator#string TypeCalculator#string} method.
-  # @return [Puppet::Pops::Types::PObjectType] a specialization of the PObjectType representing the type.
+  # @return [Puppet::Pops::Types::PAnyType] a specialization of the PAnyType representing the type.
   #
   # @api public
   #
@@ -47,7 +47,7 @@ class Puppet::Pops::Types::TypeParser
   def interpret(ast)
     result = @type_transformer.visit_this_0(self, ast)
     result = result.body if result.is_a?(Puppet::Pops::Model::Program)
-    raise_invalid_type_specification_error unless result.is_a?(Puppet::Pops::Types::PAbstractType)
+    raise_invalid_type_specification_error unless result.is_a?(Puppet::Pops::Types::PAnyType)
     result
   end
 
@@ -76,6 +76,10 @@ class Puppet::Pops::Types::TypeParser
     o.value
   end
 
+  def interpret_LiteralRegularExpression(o)
+    o.value
+  end
+
   # @api private
   def interpret_String(o)
     o
@@ -157,11 +161,13 @@ class Puppet::Pops::Types::TypeParser
       TYPES.catalog_entry()
 
     when "undef"
-      # Should not be interpreted as Resource type
       TYPES.undef()
 
-    when "object"
-      TYPES.object()
+    when "default"
+      TYPES.default()
+
+    when "any"
+      TYPES.any()
 
     when "variant"
       TYPES.variant()
@@ -169,8 +175,8 @@ class Puppet::Pops::Types::TypeParser
     when "optional"
       TYPES.optional()
 
-    when "ruby"
-      TYPES.ruby_type()
+    when "runtime"
+      TYPES.runtime()
 
     when "type"
       TYPES.type_type()
@@ -297,22 +303,22 @@ class Puppet::Pops::Types::TypeParser
 
     when "enum"
       # 1..m parameters being strings
-      raise_invalid_parameters_error("Enum", "1 or more", parameters.size) unless parameters.size > 1
+      raise_invalid_parameters_error("Enum", "1 or more", parameters.size) unless parameters.size >= 1
       TYPES.enum(*parameters)
 
     when "pattern"
       # 1..m parameters being strings or regular expressions
-      raise_invalid_parameters_error("Pattern", "1 or more", parameters.size) unless parameters.size > 1
+      raise_invalid_parameters_error("Pattern", "1 or more", parameters.size) unless parameters.size >= 1
       TYPES.pattern(*parameters)
 
     when "variant"
       # 1..m parameters being strings or regular expressions
-      raise_invalid_parameters_error("Variant", "1 or more", parameters.size) unless parameters.size > 1
+      raise_invalid_parameters_error("Variant", "1 or more", parameters.size) unless parameters.size >= 1
       TYPES.variant(*parameters)
 
     when "tuple"
       # 1..m parameters being types (last two optionally integer or literal default
-      raise_invalid_parameters_error("Tuple", "1 or more", parameters.size) unless parameters.size > 1
+      raise_invalid_parameters_error("Tuple", "1 or more", parameters.size) unless parameters.size >= 1
       length = parameters.size
       if TYPES.is_range_parameter?(parameters[-2])
         # min, max specification
@@ -400,7 +406,7 @@ class Puppet::Pops::Types::TypeParser
       assert_type(parameters[0])
       TYPES.optional(parameters[0])
 
-    when "object", "data", "catalogentry", "boolean", "scalar", "undef", "numeric"
+    when "any", "data", "catalogentry", "boolean", "scalar", "undef", "numeric", "default"
       raise_unparameterized_type_error(parameterized_ast.left_expr)
 
     when "type"
@@ -410,9 +416,9 @@ class Puppet::Pops::Types::TypeParser
       assert_type(parameters[0])
       TYPES.type_type(parameters[0])
 
-    when "ruby"
-      raise_invalid_parameters_error("Ruby", "1", parameters.size) unless parameters.size == 1
-      TYPES.ruby_type(parameters[0])
+    when "runtime"
+      raise_invalid_parameters_error("Runtime", "2", parameters.size) unless parameters.size == 2
+      TYPES.runtime(*parameters)
 
     else
       # It is a resource such a File['/tmp/foo']
@@ -427,7 +433,7 @@ class Puppet::Pops::Types::TypeParser
   private
 
   def assert_type(t)
-    raise_invalid_type_specification_error unless t.is_a?(Puppet::Pops::Types::PObjectType)
+    raise_invalid_type_specification_error unless t.is_a?(Puppet::Pops::Types::PAnyType)
     true
   end
 

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

@@ -1,506 +1,397 @@
 require 'rgen/metamodel_builder'
 
 # The Types model is a model of Puppet Language types.
-#
-# The exact relationship between types is not visible in this model wrt. the PDataType which is an abstraction
-# of Scalar, Array[Data], and Hash[Scalar, Data] nested to any depth. This means it is not possible to
-# infer the type by simply looking at the inheritance hierarchy. The {Puppet::Pops::Types::TypeCalculator} should
-# be used to answer questions about types. The {Puppet::Pops::Types::TypeFactory} should be used to create an instance
-# of a type whenever one is needed.
-#
-# The implementation of the Types model contains methods that are required for the type objects to behave as
-# expected when comparing them and using them as keys in hashes. (No other logic is, or should be included directly in
-# the model's classes).
+# It consists of two parts; the meta-model expressed using RGen (in types_meta.rb) and this file which
+# mixes in the implementation.
 #
 # @api public
 #
-module Puppet::Pops::Types
-  # Used as end in a range
-  INFINITY = 1.0 / 0.0
-  NEGATIVE_INFINITY = -INFINITY
-
-  class PAbstractType < Puppet::Pops::Model::PopsObject
-    abstract
-    module ClassModule
-      # Produce a deep copy of the type
-      def copy
-        Marshal.load(Marshal.dump(self))
-      end
+module Puppet::Pops
+  require 'puppet/pops/types/types_meta'
 
-      def hash
-        self.class.hash
-      end
+  # TODO: See PUP-2978 for possible performance optimization
 
-      def ==(o)
-        self.class == o.class
-      end
+  # Mix in implementation part of the Bindings Module
+  module Types
+    # Used as end in a range
+    INFINITY = 1.0 / 0.0
+    NEGATIVE_INFINITY = -INFINITY
 
-      alias eql? ==
-
-      def to_s
-        Puppet::Pops::Types::TypeCalculator.string(self)
-      end
+    class TypeModelObject < RGen::MetamodelBuilder::MMBase
+      include Puppet::Pops::Visitable
+      include Puppet::Pops::Adaptable
+      include Puppet::Pops::Containment
     end
-  end
 
-  # The type of types.
-  # @api public
-  class PType < PAbstractType
-    contains_one_uni 'type', PAbstractType
-    module ClassModule
-      def hash
-        [self.class, type].hash
-      end
-
-      def ==(o)
-        self.class == o.class && type == o.type
-      end
-    end
-  end
-
-  # Base type for all types except {Puppet::Pops::Types::PType PType}, the type of types.
-  # @api public
-  class PObjectType < PAbstractType
+    class PAnyType < TypeModelObject
+      module ClassModule
+        # Produce a deep copy of the type
+        def copy
+          Marshal.load(Marshal.dump(self))
+        end
 
-    module ClassModule
-    end
+        def hash
+          self.class.hash
+        end
 
-  end
+        def ==(o)
+          self.class == o.class
+        end
 
-  # @api public
-  class PNilType < PObjectType
-  end
+        alias eql? ==
 
-  # A flexible data type, being assignable to its subtypes as well as PArrayType and PHashType with element type assignable to PDataType.
-  #
-  # @api public
-  class PDataType < PObjectType
-    module ClassModule
-      def ==(o)
-        self.class == o.class ||
-          o.class == PVariantType && o == Puppet::Pops::Types::TypeCalculator.data_variant()
+        def to_s
+          Puppet::Pops::Types::TypeCalculator.string(self)
+        end
       end
     end
-  end
 
-  # A flexible type describing an any? of other types
-  # @api public
-  class PVariantType < PObjectType
-    contains_many_uni 'types', PAbstractType, :lowerBound => 1
-
-    module ClassModule
+    class PType < PAnyType
+      module ClassModule
+        def hash
+          [self.class, type].hash
+        end
 
-      def hash
-        [self.class, Set.new(self.types)].hash
+        def ==(o)
+          self.class == o.class && type == o.type
+        end
       end
+    end
 
-      def ==(o)
-        (self.class == o.class && Set.new(types) == Set.new(o.types)) ||
-          (o.class == PDataType && self == Puppet::Pops::Types::TypeCalculator.data_variant())
+    class PDataType < PAnyType
+      module ClassModule
+        def ==(o)
+          self.class == o.class ||
+            o.class == PVariantType && o == Puppet::Pops::Types::TypeCalculator.data_variant()
+        end
       end
     end
-  end
-
-  # Type that is PDataType compatible, but is not a PCollectionType.
-  # @api public
-  class PScalarType < PObjectType
-  end
 
-  # A string type describing the set of strings having one of the given values
-  #
-  class PEnumType < PScalarType
-    has_many_attr 'values', String, :lowerBound => 1
+    class PVariantType < PAnyType
+      module ClassModule
 
-    module ClassModule
-      def hash
-        [self.class, Set.new(self.values)].hash
-      end
+        def hash
+          [self.class, Set.new(self.types)].hash
+        end
 
-      def ==(o)
-        self.class == o.class && Set.new(values) == Set.new(o.values)
+        def ==(o)
+          (self.class == o.class && Set.new(types) == Set.new(o.types)) ||
+            (o.class == PDataType && self == Puppet::Pops::Types::TypeCalculator.data_variant())
+        end
       end
     end
-  end
 
-  # @api public
-  class PNumericType < PScalarType
-  end
+    class PEnumType < PScalarType
+      module ClassModule
+        def hash
+          [self.class, Set.new(self.values)].hash
+        end
 
-  # @api public
-  class PIntegerType < PNumericType
-    has_attr 'from', Integer, :lowerBound => 0
-    has_attr 'to', Integer, :lowerBound => 0
+        def ==(o)
+          self.class == o.class && Set.new(values) == Set.new(o.values)
+        end
+      end
+    end
 
-    module ClassModule
-      # The integer type is enumerable when it defines a range
-      include Enumerable
+    class PIntegerType < PNumericType
+      module ClassModule
+        # The integer type is enumerable when it defines a range
+        include Enumerable
 
-      # Returns Float.Infinity if one end of the range is unbound
-      def size
-        return INFINITY if from.nil? || to.nil?
-        1+(to-from).abs
-      end
+        # Returns Float.Infinity if one end of the range is unbound
+        def size
+          return INFINITY if from.nil? || to.nil?
+          1+(to-from).abs
+        end
 
-      # Returns the range as an array ordered so the smaller number is always first.
-      # The number may be Infinity or -Infinity.
-      def range
-        f = from || NEGATIVE_INFINITY
-        t = to || INFINITY
-        if f < t
-          [f, t]
-        else
-          [t,f]
+        # Returns the range as an array ordered so the smaller number is always first.
+        # The number may be Infinity or -Infinity.
+        def range
+          f = from || NEGATIVE_INFINITY
+          t = to || INFINITY
+          if f < t
+            [f, t]
+          else
+            [t,f]
+          end
         end
-      end
 
-      # Returns Enumerator if no block is given
-      # Returns self if size is infinity (does not yield)
-      def each
-        return self.to_enum unless block_given?
-        return nil if from.nil? || to.nil?
-        if to < from
-          from.downto(to) {|x| yield x }
-        else
-          from.upto(to) {|x| yield x }
+        # Returns Enumerator if no block is given
+        # Returns self if size is infinity (does not yield)
+        def each
+          return self.to_enum unless block_given?
+          return nil if from.nil? || to.nil?
+          if to < from
+            from.downto(to) {|x| yield x }
+          else
+            from.upto(to) {|x| yield x }
+          end
         end
-      end
 
-      def hash
-        [self.class, from, to].hash
-      end
+        def hash
+          [self.class, from, to].hash
+        end
 
-      def ==(o)
-        self.class == o.class && from == o.from && to == o.to
+        def ==(o)
+          self.class == o.class && from == o.from && to == o.to
+        end
       end
     end
-  end
 
-  # @api public
-  class PFloatType < PNumericType
-    has_attr 'from', Float, :lowerBound => 0
-    has_attr 'to', Float, :lowerBound => 0
-
-    module ClassModule
-      def hash
-        [self.class, from, to].hash
-      end
+    class PFloatType < PNumericType
+      module ClassModule
+        def hash
+          [self.class, from, to].hash
+        end
 
-      def ==(o)
-        self.class == o.class && from == o.from && to == o.to
+        def ==(o)
+          self.class == o.class && from == o.from && to == o.to
+        end
       end
     end
-  end
-
-  # @api public
-  class PStringType < PScalarType
-    has_many_attr 'values', String, :lowerBound => 0, :upperBound => -1, :unique => true
-    contains_one_uni 'size_type', PIntegerType
 
-    module ClassModule
+    class PStringType < PScalarType
+      module ClassModule
 
-      def hash
-        [self.class, self.size_type, Set.new(self.values)].hash
-      end
+        def hash
+          [self.class, self.size_type, Set.new(self.values)].hash
+        end
 
-      def ==(o)
-        self.class == o.class && self.size_type == o.size_type && Set.new(values) == Set.new(o.values)
+        def ==(o)
+          self.class == o.class && self.size_type == o.size_type && Set.new(values) == Set.new(o.values)
+        end
       end
     end
-  end
-
-  # @api public
-  class PRegexpType < PScalarType
-    has_attr 'pattern', String, :lowerBound => 1
-    has_attr 'regexp', Object, :derived => true
 
-    module ClassModule
-      def regexp_derived
-        @_regexp = Regexp.new(pattern) unless @_regexp && @_regexp.source == pattern
-        @_regexp
-      end
+    class PRegexpType < PScalarType
+      module ClassModule
+        def regexp_derived
+          @_regexp = Regexp.new(pattern) unless @_regexp && @_regexp.source == pattern
+          @_regexp
+        end
 
-      def hash
-        [self.class, pattern].hash
-      end
+        def hash
+          [self.class, pattern].hash
+        end
 
-      def ==(o)
-        self.class == o.class && pattern == o.pattern
+        def ==(o)
+          self.class == o.class && pattern == o.pattern
+        end
       end
     end
-  end
 
-  # Represents a subtype of String that narrows the string to those matching the patterns
-  # If specified without a pattern it is basically the same as the String type.
-  #
-  # @api public
-  class PPatternType < PScalarType
-    contains_many_uni 'patterns', PRegexpType
+    class PPatternType < PScalarType
+      module ClassModule
 
-    module ClassModule
-
-      def hash
-        [self.class, Set.new(patterns)].hash
-      end
+        def hash
+          [self.class, Set.new(patterns)].hash
+        end
 
-      def ==(o)
-        self.class == o.class && Set.new(patterns) == Set.new(o.patterns)
+        def ==(o)
+          self.class == o.class && Set.new(patterns) == Set.new(o.patterns)
+        end
       end
     end
-  end
-
-  # @api public
-  class PBooleanType < PScalarType
-  end
 
-  # @api public
-  class PCollectionType < PObjectType
-    contains_one_uni 'element_type', PAbstractType
-    contains_one_uni 'size_type', PIntegerType
-
-    module ClassModule
-      # Returns an array with from (min) size to (max) size
-      # A negative range value in from is 
-      def size_range
-        return [0, INFINITY] if size_type.nil?
-        f = size_type.from || 0
-        t = size_type.to || INFINITY
-        if f < t
-          [f, t]
-        else
-          [t,f]
+    class PCollectionType < PAnyType
+      module ClassModule
+        # Returns an array with from (min) size to (max) size
+        def size_range
+          return [0, INFINITY] if size_type.nil?
+          f = size_type.from || 0
+          t = size_type.to || INFINITY
+          if f < t
+            [f, t]
+          else
+            [t,f]
+          end
         end
-      end
 
-      def hash
-        [self.class, element_type, size_type].hash
-      end
+        def hash
+          [self.class, element_type, size_type].hash
+        end
 
-      def ==(o)
-        self.class == o.class && element_type == o.element_type && size_type == o.size_type
+        def ==(o)
+          self.class == o.class && element_type == o.element_type && size_type == o.size_type
+        end
       end
     end
-  end
-
-  class PStructElement < Puppet::Pops::Model::PopsObject
-    has_attr 'name', String, :lowerBound => 1
-    contains_one_uni 'type', PAbstractType
 
-    module ClassModule
-      def hash
-        [self.class, type, name].hash
-      end
+    class PStructElement < TypeModelObject
+      module ClassModule
+        def hash
+          [self.class, type, name].hash
+        end
 
-      def ==(o)
-        self.class == o.class && type == o.type && name == o.name
+        def ==(o)
+          self.class == o.class && type == o.type && name == o.name
+        end
       end
     end
-  end
 
-  # @api public
-  class PStructType < PObjectType
-    contains_many_uni 'elements', PStructElement, :lowerBound => 1
-    has_attr 'hashed_elements', Object, :derived => true
 
-    module ClassModule
-      def hashed_elements_derived
-        @_hashed ||= elements.reduce({}) {|memo, e| memo[e.name] = e.type; memo }
-        @_hashed
-      end
+    class PStructType < PAnyType
+      module ClassModule
+        def hashed_elements_derived
+          @_hashed ||= elements.reduce({}) {|memo, e| memo[e.name] = e.type; memo }
+          @_hashed
+        end
 
-      def clear_hashed_elements
-        @_hashed = nil
-      end
+        def clear_hashed_elements
+          @_hashed = nil
+        end
 
-      def hash
-        [self.class, Set.new(elements)].hash
-      end
+        def hash
+          [self.class, Set.new(elements)].hash
+        end
 
-      def ==(o)
-        self.class == o.class && hashed_elements == o.hashed_elements
+        def ==(o)
+          self.class == o.class && hashed_elements == o.hashed_elements
+        end
       end
     end
-  end
 
-  # @api public
-  class PTupleType < PObjectType
-    contains_many_uni 'types', PAbstractType, :lowerBound => 1
-    # If set, describes min and max required of the given types - if max > size of
-    # types, the last type entry repeats
-    #
-    contains_one_uni 'size_type', PIntegerType, :lowerBound => 0
-
-    module ClassModule
-      # Returns the number of elements accepted [min, max] in the tuple
-      def size_range
-        types_size = types.size
-        size_type.nil? ? [types_size, types_size] : size_type.range
-      end
+    class PTupleType < PAnyType
+      module ClassModule
+        # Returns the number of elements accepted [min, max] in the tuple
+        def size_range
+          types_size = types.size
+          size_type.nil? ? [types_size, types_size] : size_type.range
+        end
 
-      # Returns the number of accepted occurrences [min, max] of the last type in the tuple
-      # The defaults is [1,1]
-      #
-      def repeat_last_range
-        types_size = types.size
-        if size_type.nil?
-          return [1, 1]
-        end
-        from, to = size_type.range()
-        min = from - (types_size-1)
-        min = min <= 0 ? 0 : min
-        max = to - (types_size-1)
-        [min, max]
-      end
+        # Returns the number of accepted occurrences [min, max] of the last type in the tuple
+        # The defaults is [1,1]
+        #
+        def repeat_last_range
+          types_size = types.size
+          if size_type.nil?
+            return [1, 1]
+          end
+          from, to = size_type.range()
+          min = from - (types_size-1)
+          min = min <= 0 ? 0 : min
+          max = to - (types_size-1)
+          [min, max]
+        end
 
-      def hash
-        [self.class, size_type, Set.new(types)].hash
-      end
+        def hash
+          [self.class, size_type, Set.new(types)].hash
+        end
 
-      def ==(o)
-        self.class == o.class && types == o.types && size_type == o.size_type
+        def ==(o)
+          self.class == o.class && types == o.types && size_type == o.size_type
+        end
       end
     end
-  end
-
-  class PCallableType < PObjectType
-    # Types of parameters and required/optional count
-    contains_one_uni 'param_types', PTupleType, :lowerBound => 1
 
-    # Although being an abstract type reference, only PAbstractCallable, and Optional[Callable] are supported
-    # If not set, the meaning is that block is not supported.
-    #
-    contains_one_uni 'block_type', PAbstractType, :lowerBound => 0
-
-    module ClassModule
-      # Returns the number of accepted arguments [min, max]
-      def size_range
-        param_types.size_range
-      end
+    class PCallableType < PAnyType
+      module ClassModule
+        # Returns the number of accepted arguments [min, max]
+        def size_range
+          param_types.size_range
+        end
 
-      # Returns the number of accepted arguments for the last parameter type [min, max]
-      #
-      def last_range
-        param_types.repeat_last_range
-      end
+        # Returns the number of accepted arguments for the last parameter type [min, max]
+        #
+        def last_range
+          param_types.repeat_last_range
+        end
 
-      # Range [0,0], [0,1], or [1,1] for the block
-      #
-      def block_range
-        case block_type
-        when Puppet::Pops::Types::POptionalType
-          [0,1]
-        when Puppet::Pops::Types::PVariantType, Puppet::Pops::Types::PCallableType
-          [1,1]
-        else
-          [0,0]
+        # Range [0,0], [0,1], or [1,1] for the block
+        #
+        def block_range
+          case block_type
+          when Puppet::Pops::Types::POptionalType
+            [0,1]
+          when Puppet::Pops::Types::PVariantType, Puppet::Pops::Types::PCallableType
+            [1,1]
+          else
+            [0,0]
+          end
         end
-      end
 
-      def hash
-        [self.class, Set.new(param_types), block_type].hash
-      end
+        def hash
+          [self.class, Set.new(param_types), block_type].hash
+        end
 
-      def ==(o)
-        self.class == o.class && args_type == o.args_type && block_type == o.block_type
+        def ==(o)
+          self.class == o.class && args_type == o.args_type && block_type == o.block_type
+        end
       end
     end
-  end
 
-  # @api public
-  class PArrayType < PCollectionType
-    module ClassModule
-      def hash
-        [self.class, self.element_type, self.size_type].hash
-      end
+    class PArrayType < PCollectionType
+      module ClassModule
+        def hash
+          [self.class, self.element_type, self.size_type].hash
+        end
 
-      def ==(o)
-        self.class == o.class && self.element_type == o.element_type && self.size_type == o.size_type
+        def ==(o)
+          self.class == o.class && self.element_type == o.element_type && self.size_type == o.size_type
+        end
       end
     end
-  end
 
-  # @api public
-  class PHashType < PCollectionType
-    contains_one_uni 'key_type', PAbstractType
-    module ClassModule
-      def hash
-        [self.class, key_type, self.element_type, self.size_type].hash
-      end
+    class PHashType < PCollectionType
+      module ClassModule
+        def hash
+          [self.class, key_type, self.element_type, self.size_type].hash
+        end
 
-      def ==(o)
-        self.class        == o.class         &&
-        key_type          == o.key_type      &&
-        self.element_type == o.element_type  &&
-        self.size_type    == o.size_type
+        def ==(o)
+          self.class        == o.class         &&
+          key_type          == o.key_type      &&
+          self.element_type == o.element_type  &&
+          self.size_type    == o.size_type
+        end
       end
     end
-  end
 
-  # @api public
-  class PRubyType < PObjectType
-    has_attr 'ruby_class', String
-    module ClassModule
-      def hash
-        [self.class, ruby_class].hash
-      end
 
-      def ==(o)
-        self.class == o.class && ruby_class == o.ruby_class
+    class PRuntimeType < PAnyType
+      module ClassModule
+        def hash
+          [self.class, runtime, runtime_type_name].hash
+        end
+
+        def ==(o)
+          self.class == o.class && runtime == o.runtime && runtime_type_name == o.runtime_type_name 
+        end
       end
     end
-  end
-
-  # Abstract representation of a type that can be placed in a Catalog.
-  # @api public
-  #
-  class PCatalogEntryType < PObjectType
-  end
 
-  # Represents a (host-) class in the Puppet Language.
-  # @api public
-  #
-  class PHostClassType < PCatalogEntryType
-    has_attr 'class_name', String
-    # contains_one_uni 'super_type', PHostClassType
-    module ClassModule
-      def hash
-        [self.class, class_name].hash
-      end
-      def ==(o)
-        self.class == o.class && class_name == o.class_name
+    class PHostClassType < PCatalogEntryType
+      module ClassModule
+        def hash
+          [self.class, class_name].hash
+        end
+        def ==(o)
+          self.class == o.class && class_name == o.class_name
+        end
       end
     end
-  end
 
-  # Represents a Resource Type in the Puppet Language
-  # @api public
-  #
-  class PResourceType < PCatalogEntryType
-    has_attr 'type_name', String
-    has_attr 'title', String
-    module ClassModule
-      def hash
-        [self.class, type_name, title].hash
-      end
-      def ==(o)
-        self.class == o.class && type_name == o.type_name && title == o.title
+    class PResourceType < PCatalogEntryType
+      module ClassModule
+        def hash
+          [self.class, type_name, title].hash
+        end
+        def ==(o)
+          self.class == o.class && type_name == o.type_name && title == o.title
+        end
       end
     end
-  end
 
-  # Represents a type that accept PNilType instead of the type parameter
-  # required_type - is a short hand for Variant[T, Undef]
-  #
-  class POptionalType < PAbstractType
-    contains_one_uni 'optional_type', PAbstractType
-    module ClassModule
-      def hash
-        [self.class, optional_type].hash
-      end
+    class POptionalType < PAnyType
+      module ClassModule
+        def hash
+          [self.class, optional_type].hash
+        end
 
-      def ==(o)
-        self.class == o.class && optional_type == o.optional_type
+        def ==(o)
+          self.class == o.class && optional_type == o.optional_type
+        end
       end
     end
   end
-
 end