puppet 4.3.2 → 4.4.0

data/lib/puppet/pops/binder/key_factory.rb

@@ -1,7 +1,9 @@
+module Puppet::Pops
+module Binder
 # The KeyFactory is responsible for creating keys used for lookup of bindings.
 # @api public
 #
-class Puppet::Pops::Binder::KeyFactory
+class KeyFactory
 
   # @api public
   def binding_key(binding)
@@ -10,12 +12,12 @@ class Puppet::Pops::Binder::KeyFactory
 
   # @api public
   def named_key(type, name)
-    [(Puppet::Pops::Types::PDataType::DEFAULT.assignable?(type) ? Puppet::Pops::Types::PDataType::DEFAULT : type), name]
+    [(Types::PDataType::DEFAULT.assignable?(type) ? Types::PDataType::DEFAULT : type), name]
   end
 
   # @api public
   def data_key(name)
-    [Puppet::Pops::Types::PDataType::DEFAULT, name]
+    [Types::PDataType::DEFAULT, name]
   end
 
   # @api public
@@ -42,13 +44,13 @@ class Puppet::Pops::Binder::KeyFactory
 
   # @api public
   def is_data?(key)
-    return false unless key.is_a?(Array) && key[0].is_a?(Puppet::Pops::Types::PAnyType)
-    Puppet::Pops::Types::PDataType::DEFAULT.assignable?(key[0])
+    return false unless key.is_a?(Array) && key[0].is_a?(Types::PAnyType)
+    Types::PDataType::DEFAULT.assignable?(key[0])
   end
 
   # @api public
   def is_ruby?(key)
-    key.is_a?(Array) && key[0].is_a?(Puppet::Pops::Types::PRuntimeType) && key[0].runtime == :ruby
+    key.is_a?(Array) && key[0].is_a?(Types::PRuntimeType) && key[0].runtime == :ruby
   end
 
   # Returns the type of the key
@@ -59,3 +61,5 @@ class Puppet::Pops::Binder::KeyFactory
     key[0]
   end
 end
+end
+end

data/lib/puppet/pops/binder/producers.rb

@@ -1,10 +1,13 @@
+module Puppet::Pops
+module Binder
 # This module contains the various producers used by Puppet Bindings.
-# The main (abstract) class is {Puppet::Pops::Binder::Producers::Producer} which documents the
+
+# The main (abstract) class is {Producers::Producer} which documents the
 # Producer API and serves as a base class for all other producers.
 # It is required that custom producers inherit from this producer (directly or indirectly).
 #
 # The selection of a Producer is typically performed by the Innjector when it configures itself
-# from a Bindings model where a {Puppet::Pops::Binder::Bindings::ProducerDescriptor} describes
+# from a Bindings model where a {Bindings::ProducerDescriptor} describes
 # which producer to use. The configuration uses this to create the concrete producer.
 # It is possible to describe that a particular producer class is to be used, and also to describe that
 # a custom producer (derived from Producer) should be used. This is available for both regular
@@ -13,7 +16,7 @@
 #
 # @api public
 #
-module Puppet::Pops::Binder::Producers
+module Producers
   # Producer is an abstract base class representing the base contract for a bound producer.
   # Typically, when a lookup is performed it is the value that is returned (via a producer), but
   # it is also possible to lookup the producer, and ask it to produce the value (the producer may
@@ -48,10 +51,10 @@ module Puppet::Pops::Binder::Producers
     # Creates a Producer.
     # Derived classes should call this constructor to get support for transformer lambda.
     #
-    # @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
-    # @param binding [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
+    # @param injector [Injector] The injector where the lookup originates
+    # @param binding [Bindings::Binding, nil] The binding using this producer
     # @param scope [Puppet::Parser::Scope] The scope to use for evaluation
-    # @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
+    # @option options [Model::LambdaExpression] :transformer (nil) a transformer of produced value
     # @api public
     #
     def initialize(injector, binding, scope, options)
@@ -60,9 +63,9 @@ module Puppet::Pops::Binder::Producers
           raise ArgumentError, "Transformer Proc must take one argument; value." unless transformer_lambda.arity == 1
           @transformer = transformer_lambda
         else
-          raise ArgumentError, "Transformer must be a LambdaExpression" unless transformer_lambda.is_a?(Puppet::Pops::Model::LambdaExpression)
+          raise ArgumentError, "Transformer must be a LambdaExpression" unless transformer_lambda.is_a?(Model::LambdaExpression)
           raise ArgumentError, "Transformer lambda must take one argument; value." unless transformer_lambda.parameters.size() == 1
-          @transformer = Puppet::Pops::Parser::EvaluatingParser.new.closure(transformer_lambda, scope)
+          @transformer = Parser::EvaluatingParser.new.closure(transformer_lambda, scope)
         end
       end
     end
@@ -81,9 +84,9 @@ module Puppet::Pops::Binder::Producers
     # This implementation returns `self`. A derived class may want to override this method
     # to perform initialization/refresh of its internal state. This method is called when
     # a producer is requested.
-    # @see Puppet::Pops::Binder::ProducerProducer for an example of implementation.
+    # @see ProducerProducer for an example of implementation.
     # @param scope [Puppet::Parser:Scope] the scope to use for evaluation
-    # @return [Puppet::Pops::Binder::Producer] the producer to use
+    # @return [Producer] the producer to use
     # @api public
     #
     def producer(scope)
@@ -123,11 +126,11 @@ module Puppet::Pops::Binder::Producers
     # @api public
     attr_reader :value
 
-    # @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
-    # @param binding [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
+    # @param injector [Injector] The injector where the lookup originates
+    # @param binding [Bindings::Binding, nil] The binding using this producer
     # @param scope [Puppet::Parser::Scope] The scope to use for evaluation
-    # @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
-    # @option options [Puppet::Pops::Model::LambdaExpression, nil] :value (nil) the value to produce
+    # @option options [Model::LambdaExpression] :transformer (nil) a transformer of produced value
+    # @option options [Model::LambdaExpression, nil] :value (nil) the value to produce
     # @api public
     #
    def initialize(injector, binding, scope, options)
@@ -182,10 +185,10 @@ module Puppet::Pops::Binder::Producers
     # @api public
     attr_reader :binding
 
-    # @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
-    # @param binding [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
+    # @param injector [Injector] The injector where the lookup originates
+    # @param binding [Bindings::Binding, nil] The binding using this producer
     # @param scope [Puppet::Parser::Scope] The scope to use for evaluation
-    # @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
+    # @option options [Model::LambdaExpression] :transformer (nil) a transformer of produced value
     # @api public
     #
     def initialize(injector, binding, scope, options)
@@ -204,10 +207,10 @@ module Puppet::Pops::Binder::Producers
     # @api public
     attr_reader :init_args
 
-    # @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
-    # @param binding [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
+    # @param injector [Injector] The injector where the lookup originates
+    # @param binding [Bindings::Binding, nil] The binding using this producer
     # @param scope [Puppet::Parser::Scope] The scope to use for evaluation
-    # @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
+    # @option options [Model::LambdaExpression] :transformer (nil) a transformer of produced value
     # @option options [String] :class_name The name of the class to create instance of
     # @option options [Array<Object>] :init_args ([]) Optional arguments to class constructor
     # @api public
@@ -220,7 +223,7 @@ module Puppet::Pops::Binder::Producers
       class_name = options[:class_name]
       raise ArgumentError, "Option 'class_name' must be given for an InstantiatingProducer" unless class_name
       # get class by name
-      @the_class = Puppet::Pops::Types::ClassLoader.provide(class_name)
+      @the_class = Types::ClassLoader.provide(class_name)
       @init_args = options[:init_args] || []
       raise ArgumentError, "Can not load the class #{class_name} specified in binding named: '#{binding.name}'" unless @the_class
     end
@@ -255,11 +258,11 @@ module Puppet::Pops::Binder::Producers
     # @api public
     attr_reader :producers
 
-    # @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
-    # @param binding [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
+    # @param injector [Injector] The injector where the lookup originates
+    # @param binding [Bindings::Binding, nil] The binding using this producer
     # @param scope [Puppet::Parser::Scope] The scope to use for evaluation
-    # @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
-    # @option options [Array<Puppet::Pops::Binder::Producers::Producer>] :producers list of producers to consult. Required.
+    # @option options [Model::LambdaExpression] :transformer (nil) a transformer of produced value
+    # @option options [Array<Producers::Producer>] :producers list of producers to consult. Required.
     # @api public
     #
     def initialize(injector, binding, scope, options)
@@ -288,11 +291,11 @@ module Puppet::Pops::Binder::Producers
     #
     attr_reader :expression
 
-    # @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
-    # @param binding [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
+    # @param injector [Injector] The injector where the lookup originates
+    # @param binding [Bindings::Binding, nil] The binding using this producer
     # @param scope [Puppet::Parser::Scope] The scope to use for evaluation
-    # @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
-    # @option options [Array<Puppet::Pops::Model::Expression>] :expression The expression to evaluate
+    # @option options [Model::LambdaExpression] :transformer (nil) a transformer of produced value
+    # @option options [Array<Model::Expression>] :expression The expression to evaluate
     # @api public
     #
     def initialize(injector, binding, scope, options)
@@ -303,7 +306,7 @@ module Puppet::Pops::Binder::Producers
 
     # @api private
     def internal_produce(scope)
-      Puppet::Pops::Parser::EvaluatingParser.new.evaluate(scope, expression)
+      Parser::EvaluatingParser.new.evaluate(scope, expression)
     end
   end
 
@@ -316,11 +319,11 @@ module Puppet::Pops::Binder::Producers
     # @api public
     attr_reader :name
 
-    # @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
-    # @param binder [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
+    # @param injector [Injector] The injector where the lookup originates
+    # @param binder [Bindings::Binding, nil] The binding using this producer
     # @param scope [Puppet::Parser::Scope] The scope to use for evaluation
-    # @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
-    # @option options [Puppet::Pops::Types::PAnyType] :type The type to lookup
+    # @option options [Model::LambdaExpression] :transformer (nil) a transformer of produced value
+    # @option options [Types::PAnyType] :type The type to lookup
     # @option options [String] :name ('') The name to lookup
     # @api public
     #
@@ -345,13 +348,13 @@ module Puppet::Pops::Binder::Producers
     # @api public
     attr_reader :key
 
-    # @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
-    # @param binder [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
+    # @param injector [Injector] The injector where the lookup originates
+    # @param binder [Bindings::Binding, nil] The binding using this producer
     # @param scope [Puppet::Parser::Scope] The scope to use for evaluation
-    # @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
-    # @option options [Puppet::Pops::Types::PAnyType] :type The type to lookup
+    # @option options [Model::LambdaExpression] :transformer (nil) a transformer of produced value
+    # @option options [Types::PAnyType] :type The type to lookup
     # @option options [String] :name ('') The name to lookup
-    # @option options [Puppet::Pops::Types::PAnyType] :key The key to lookup in the hash
+    # @option options [Types::PAnyType] :key The key to lookup in the hash
     # @api public
     #
     def initialize(injector, binder, scope, options)
@@ -379,11 +382,11 @@ module Puppet::Pops::Binder::Producers
     # @api public
     attr_reader :value_producer
 
-    # @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
-    # @param binding [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
+    # @param injector [Injector] The injector where the lookup originates
+    # @param binding [Bindings::Binding, nil] The binding using this producer
     # @param scope [Puppet::Parser::Scope] The scope to use for evaluation
-    # @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
-    # @option options [Puppet::Pops::Model::LambdaExpression] :producer_producer a producer of a value producer (required)
+    # @option options [Model::LambdaExpression] :transformer (nil) a transformer of produced value
+    # @option options [Model::LambdaExpression] :producer_producer a producer of a value producer (required)
     # @api public
     #
     def initialize(injector, binding, scope, options)
@@ -420,11 +423,11 @@ module Puppet::Pops::Binder::Producers
 
     # Creates  new ProducerProducer given a producer.
     #
-    # @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
-    # @param binding [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
+    # @param injector [Injector] The injector where the lookup originates
+    # @param binding [Bindings::Binding, nil] The binding using this producer
     # @param scope [Puppet::Parser::Scope] The scope to use for evaluation
-    # @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
-    # @option options [Puppet::Pops::Binder::Producer] :producer_producer a producer of a value producer (required)
+    # @option options [Model::LambdaExpression] :transformer (nil) a transformer of produced value
+    # @option options [Producer] :producer_producer a producer of a value producer (required)
     #
     # @api public
     #
@@ -512,10 +515,10 @@ module Puppet::Pops::Binder::Producers
   class MultibindProducer < AbstractArgumentedProducer
     attr_reader :contributions_key
 
-    # @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
-    # @param binding [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
+    # @param injector [Injector] The injector where the lookup originates
+    # @param binding [Bindings::Binding, nil] The binding using this producer
     # @param scope [Puppet::Parser::Scope] The scope to use for evaluation
-    # @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
+    # @option options [Model::LambdaExpression] :transformer (nil) a transformer of produced value
     #
     # @api public
     #
@@ -524,8 +527,8 @@ module Puppet::Pops::Binder::Producers
       @contributions_key = injector.key_factory.multibind_contributions(binding.id)
     end
 
-    # @param expected [Array<Puppet::Pops::Types::PAnyType>, Puppet::Pops::Types::PAnyType] expected type or types
-    # @param actual [Object, Puppet::Pops::Types::PAnyType> the actual value (or its type)
+    # @param expected [Array<Types::PAnyType>, Types::PAnyType] expected type or types
+    # @param actual [Object, Types::PAnyType> the actual value (or its type)
     # @return [String] a formatted string for inclusion as detail in an error message
     # @api private
     #
@@ -533,8 +536,8 @@ module Puppet::Pops::Binder::Producers
       tc = injector.type_calculator
       expected = [expected] unless expected.is_a?(Array)
       actual_t = tc.is_ptype?(actual) ? actual : tc.infer(actual)
-      expstrs = expected.collect {|t| tc.string(t) }
-      "expected: #{expstrs.join(', or ')}, got: #{tc.string(actual_t)}"
+      expstrs = expected.collect {|t| t.to_s }
+      "expected: #{expstrs.join(', or ')}, got: #{actual_t}"
     end
   end
 
@@ -578,10 +581,10 @@ module Puppet::Pops::Binder::Producers
     # @api public
     attr_reader :priority_on_unnamed
 
-    # @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
-    # @param binding [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
+    # @param injector [Injector] The injector where the lookup originates
+    # @param binding [Bindings::Binding, nil] The binding using this producer
     # @param scope [Puppet::Parser::Scope] The scope to use for evaluation
-    # @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
+    # @option options [Model::LambdaExpression] :transformer (nil) a transformer of produced value
     # @option options [Boolean] :uniq (false) if collected result should be post-processed to contain only unique entries
     # @option options [Boolean, Integer] :flatten (false) if collected result should be post-processed so all contained arrays
     #   are flattened. May be set to an Integer value to indicate the level of recursion (-1 is endless, 0 is none).
@@ -680,10 +683,10 @@ module Puppet::Pops::Binder::Producers
     # By default, the hash is produced using `:priority` resolution - the highest entry is selected, the rest are
     # ignored unless they have the same priority which is an error.
     #
-    # @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
-    # @param binding [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
+    # @param injector [Injector] The injector where the lookup originates
+    # @param binding [Bindings::Binding, nil] The binding using this producer
     # @param scope [Puppet::Parser::Scope] The scope to use for evaluation
-    # @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
+    # @option options [Model::LambdaExpression] :transformer (nil) a transformer of produced value
     # @option options [Symbol, String] :conflict_resolution (:priority) One of `:error`, `:merge`, `:append`, `:priority`, `:ignore`
     #   <ul><li> `ignore` the first found highest priority contribution is used, the rest are ignored</li>
     #   <li>`error` any duplicate key is an error</li>
@@ -720,13 +723,13 @@ module Puppet::Pops::Binder::Producers
 
       if uniq || flatten || conflict_resolution.to_s == 'append'
         etype = binding.type.element_type
-        unless etype.class == Puppet::Pops::Types::PDataType || etype.is_a?(Puppet::Pops::Types::PArrayType)
+        unless etype.class == Types::PDataType || etype.is_a?(Types::PArrayType)
           detail = []
           detail << ":uniq" if uniq
           detail << ":flatten" if flatten
           detail << ":conflict_resolution => :append" if conflict_resolution.to_s == 'append'
           raise ArgumentError, ["Options #{detail.join(', and ')} cannot be used with a Multibind ",
-            "of type #{injector.type_calculator.string(binding.type)}"].join()
+            "of type #{binding.type}"].join()
         end
       end
     end
@@ -824,3 +827,5 @@ module Puppet::Pops::Binder::Producers
   end
 
 end
+end
+end

data/lib/puppet/pops/evaluator/access_operator.rb

@@ -1,24 +1,24 @@
+module Puppet::Pops
+module Evaluator
 # AccessOperator handles operator []
 # This operator is part of evaluation.
 #
-class Puppet::Pops::Evaluator::AccessOperator
+class AccessOperator
   # Provides access to the Puppet 3.x runtime (scope, etc.)
   # This separation has been made to make it easier to later migrate the evaluator to an improved runtime.
   #
-  include Puppet::Pops::Evaluator::Runtime3Support
+  include Runtime3Support
 
-  Issues = Puppet::Pops::Issues
-  TYPEFACTORY = Puppet::Pops::Types::TypeFactory
   EMPTY_STRING = ''.freeze
 
   attr_reader :semantic
 
   # Initialize with AccessExpression to enable reporting issues
-  # @param access_expression [Puppet::Pops::Model::AccessExpression] the semantic object being evaluated
+  # @param access_expression [Model::AccessExpression] the semantic object being evaluated
   # @return [void]
   #
   def initialize(access_expression)
-    @@access_visitor ||= Puppet::Pops::Visitor.new(self, "access", 2, nil)
+    @@access_visitor ||= Visitor.new(self, "access", 2, nil)
     @semantic = access_expression
   end
 
@@ -36,7 +36,7 @@ class Puppet::Pops::Evaluator::AccessOperator
     keys.flatten!
     result = case keys.size
     when 0
-      fail(Puppet::Pops::Issues::BAD_STRING_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
+      fail(Issues::BAD_STRING_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
     when 1
       # Note that Ruby 1.8.7 requires a length of 1 to produce a String
       k1 = coerce_numeric(keys[0], @semantic.keys[0], scope)
@@ -63,7 +63,7 @@ class Puppet::Pops::Evaluator::AccessOperator
       end
       o[ k1, k2 ]
     else
-      fail(Puppet::Pops::Issues::BAD_STRING_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
+      fail(Issues::BAD_STRING_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
     end
     # Specified as: an index outside of range, or empty result == empty string
     (result.nil? || result.empty?) ? EMPTY_STRING : result
@@ -75,10 +75,10 @@ class Puppet::Pops::Evaluator::AccessOperator
     keys.flatten!
     unless keys.size == 1
       blamed = keys.size == 0 ? @semantic : @semantic.keys[1]
-      fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, blamed, :base_type => o, :min=>1, :actual => keys.size)
+      fail(Issues::BAD_TYPE_SLICE_ARITY, blamed, :base_type => o, :min=>1, :actual => keys.size)
     end
     assert_keys(keys, o, 1, 1, String, Regexp)
-    Puppet::Pops::Types::TypeFactory.regexp(*keys)
+    Types::TypeFactory.regexp(*keys)
   end
 
   # Evaluates <ary>[] with 1 or 2 arguments. One argument is an index lookup, two arguments is a slice from/to.
@@ -87,7 +87,7 @@ class Puppet::Pops::Evaluator::AccessOperator
     keys.flatten!
     case keys.size
     when 0
-      fail(Puppet::Pops::Issues::BAD_ARRAY_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
+      fail(Issues::BAD_ARRAY_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
     when 1
       key = coerce_numeric(keys[0], @semantic.keys[0], scope)
       unless key.is_a?(Integer)
@@ -114,7 +114,7 @@ class Puppet::Pops::Evaluator::AccessOperator
       result = o[ k1, k2 ]
       result.nil? ? [] : result
     else
-      fail(Puppet::Pops::Issues::BAD_ARRAY_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
+      fail(Issues::BAD_ARRAY_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
     end
   end
 
@@ -132,7 +132,7 @@ class Puppet::Pops::Evaluator::AccessOperator
     end
     case result.size
     when 0
-      fail(Puppet::Pops::Issues::BAD_HASH_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
+      fail(Issues::BAD_HASH_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
     when 1
       result.pop
     else
@@ -145,35 +145,35 @@ class Puppet::Pops::Evaluator::AccessOperator
   def access_PEnumType(o, scope, keys)
     keys.flatten!
     assert_keys(keys, o, 1, Float::INFINITY, String)
-    Puppet::Pops::Types::TypeFactory.enum(*keys)
+    Types::TypeFactory.enum(*keys)
   end
 
   def access_PVariantType(o, scope, keys)
     keys.flatten!
-    assert_keys(keys, o, 1, Float::INFINITY, Puppet::Pops::Types::PAnyType)
-    Puppet::Pops::Types::TypeFactory.variant(*keys)
+    assert_keys(keys, o, 1, Float::INFINITY, Types::PAnyType)
+    Types::TypeFactory.variant(*keys)
   end
 
   def access_PTupleType(o, scope, keys)
     keys.flatten!
-    if TYPEFACTORY.is_range_parameter?(keys[-2]) && TYPEFACTORY.is_range_parameter?(keys[-1])
-      size_type = TYPEFACTORY.range(keys[-2], keys[-1])
+    if Types::TypeFactory.is_range_parameter?(keys[-2]) && Types::TypeFactory.is_range_parameter?(keys[-1])
+      size_type = Types::TypeFactory.range(keys[-2], keys[-1])
       keys = keys[0, keys.size - 2]
-    elsif TYPEFACTORY.is_range_parameter?(keys[-1])
-      size_type = TYPEFACTORY.range(keys[-1], :default)
+    elsif Types::TypeFactory.is_range_parameter?(keys[-1])
+      size_type = Types::TypeFactory.range(keys[-1], :default)
       keys = keys[0, keys.size - 1]
     end
-    assert_keys(keys, o, 1, Float::INFINITY, Puppet::Pops::Types::PAnyType)
-    Puppet::Pops::Types::TypeFactory.tuple(keys, size_type)
+    assert_keys(keys, o, 1, Float::INFINITY, Types::PAnyType)
+    Types::TypeFactory.tuple(keys, size_type)
   end
 
   def access_PCallableType(o, scope, keys)
-    TYPEFACTORY.callable(*keys)
+    Types::TypeFactory.callable(*keys)
   end
 
   def access_PStructType(o, scope, keys)
     assert_keys(keys, o, 1, 1, Hash)
-    TYPEFACTORY.struct(keys[0])
+    Types::TypeFactory.struct(keys[0])
   end
 
   def access_PStringType(o, scope, keys)
@@ -184,9 +184,9 @@ class Puppet::Pops::Evaluator::AccessOperator
     when 2
       size_t = collection_size_t(0, keys[0], keys[1])
     else
-      fail(Puppet::Pops::Issues::BAD_STRING_SLICE_ARITY, @semantic, {:actual => keys.size})
+      fail(Issues::BAD_STRING_SLICE_ARITY, @semantic, {:actual => keys.size})
     end
-    TYPEFACTORY.string(size_t)
+    Types::TypeFactory.string(size_t)
   end
 
   # Asserts type of each key and calls fail with BAD_TYPE_SPECIFICATION
@@ -200,7 +200,7 @@ class Puppet::Pops::Evaluator::AccessOperator
   def assert_keys(keys, o, min, max, *allowed_classes)
     size = keys.size
     unless size.between?(min, max || Float::INFINITY)
-      fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic, :base_type => o, :min=>1, :max => max, :actual => keys.size)
+      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, :base_type => o, :min=>1, :max => max, :actual => keys.size)
     end
     keys.each_with_index do |k, i|
       unless allowed_classes.any? {|clazz| k.is_a?(clazz) }
@@ -210,7 +210,7 @@ class Puppet::Pops::Evaluator::AccessOperator
   end
 
   def bad_access_key_type(lhs, key_index, actual, *expected_classes)
-    fail(Puppet::Pops::Issues::BAD_SLICE_KEY_TYPE, @semantic.keys[key_index], {
+    fail(Issues::BAD_SLICE_KEY_TYPE, @semantic.keys[key_index], {
       :left_value => lhs,
       :actual => bad_key_type_name(actual),
       :expected_classes => expected_classes
@@ -224,14 +224,14 @@ class Puppet::Pops::Evaluator::AccessOperator
     when :default
       'Default'
     else
-      Puppet::Pops::Types::TypeCalculator.generalize(Puppet::Pops::Types::TypeCalculator.infer(actual)).to_s
+      Types::TypeCalculator.generalize(Types::TypeCalculator.infer(actual)).to_s
     end
   end
 
   def bad_type_specialization_key_type(type, key_index, actual, *expected_classes)
-    label_provider = Puppet::Pops::Model::ModelLabelProvider.new()
+    label_provider = Model::ModelLabelProvider.new()
     expected = expected_classes.map {|c| label_provider.label(c) }.join(' or ')
-    fail(Puppet::Pops::Issues::BAD_TYPE_SPECIALIZATION, @semantic.keys[key_index], {
+    fail(Issues::BAD_TYPE_SPECIALIZATION, @semantic.keys[key_index], {
       :type => type,
       :message => "Cannot use #{bad_key_type_name(actual)} where #{expected} is expected"
     })
@@ -239,24 +239,24 @@ class Puppet::Pops::Evaluator::AccessOperator
 
   def access_PPatternType(o, scope, keys)
     keys.flatten!
-    assert_keys(keys, o, 1, Float::INFINITY, String, Regexp, Puppet::Pops::Types::PPatternType, Puppet::Pops::Types::PRegexpType)
-    Puppet::Pops::Types::TypeFactory.pattern(*keys)
+    assert_keys(keys, o, 1, Float::INFINITY, String, Regexp, Types::PPatternType, Types::PRegexpType)
+    Types::TypeFactory.pattern(*keys)
   end
 
   def access_POptionalType(o, scope, keys)
     keys.flatten!
     if keys.size == 1
       type = keys[0]
-      unless type.is_a?(Puppet::Pops::Types::PAnyType)
+      unless type.is_a?(Types::PAnyType)
         if type.is_a?(String)
-          type = TYPEFACTORY.string(nil, type)
+          type = Types::TypeFactory.string(nil, type)
         else
-          fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Optional-Type', :actual => type.class})
+          fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Optional-Type', :actual => type.class})
         end
       end
-      Puppet::Pops::Types::POptionalType.new(type)
+      Types::POptionalType.new(type)
     else
-      fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Optional-Type', :min => 1, :actual => keys.size})
+      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Optional-Type', :min => 1, :actual => keys.size})
     end
   end
 
@@ -264,32 +264,32 @@ class Puppet::Pops::Evaluator::AccessOperator
     keys.flatten!
     case keys.size
     when 0
-      TYPEFACTORY.not_undef
+      Types::TypeFactory.not_undef
     when 1
       type = keys[0]
       case type
       when String
-        type = TYPEFACTORY.string(nil, type)
-      when Puppet::Pops::Types::PAnyType
-        type = nil if type.class == Puppet::Pops::Types::PAnyType
+        type = Types::TypeFactory.string(nil, type)
+      when Types::PAnyType
+        type = nil if type.class == Types::PAnyType
       else
-        fail(Puppet::Pops::Issues::BAD_NOT_UNDEF_SLICE_TYPE, @semantic.keys[0], {:base_type => 'NotUndef-Type', :actual => type.class})
+        fail(Issues::BAD_NOT_UNDEF_SLICE_TYPE, @semantic.keys[0], {:base_type => 'NotUndef-Type', :actual => type.class})
       end
-      TYPEFACTORY.not_undef(type)
+      Types::TypeFactory.not_undef(type)
     else
-      fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'NotUndef-Type', :min => 0, :max => 1, :actual => keys.size})
+      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'NotUndef-Type', :min => 0, :max => 1, :actual => keys.size})
     end
   end
 
   def access_PType(o, scope, keys)
     keys.flatten!
     if keys.size == 1
-      unless keys[0].is_a?(Puppet::Pops::Types::PAnyType)
-        fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Type-Type', :actual => keys[0].class})
+      unless keys[0].is_a?(Types::PAnyType)
+        fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Type-Type', :actual => keys[0].class})
       end
-      Puppet::Pops::Types::PType.new(keys[0])
+      Types::PType.new(keys[0])
     else
-      fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Type-Type', :min => 1, :actual => keys.size})
+      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Type-Type', :min => 1, :actual => keys.size})
     end
   end
 
@@ -297,34 +297,34 @@ class Puppet::Pops::Evaluator::AccessOperator
     keys.flatten!
     assert_keys(keys, o, 2, 2, String, String)
     # create runtime type based on runtime and name of class, (not inference of key's type)
-    Puppet::Pops::Types::TypeFactory.runtime(*keys)
+    Types::TypeFactory.runtime(*keys)
   end
 
   def access_PIntegerType(o, scope, keys)
     keys.flatten!
     unless keys.size.between?(1, 2)
-      fail(Puppet::Pops::Issues::BAD_INTEGER_SLICE_ARITY, @semantic, {:actual => keys.size})
+      fail(Issues::BAD_INTEGER_SLICE_ARITY, @semantic, {:actual => keys.size})
     end
     keys.each_with_index do |x, index|
-      fail(Puppet::Pops::Issues::BAD_INTEGER_SLICE_TYPE, @semantic.keys[index],
+      fail(Issues::BAD_INTEGER_SLICE_TYPE, @semantic.keys[index],
         {:actual => x.class}) unless (x.is_a?(Integer) || x == :default)
     end
-    Puppet::Pops::Types::PIntegerType.new(*keys)
+    Types::PIntegerType.new(*keys)
   end
 
   def access_PFloatType(o, scope, keys)
     keys.flatten!
     unless keys.size.between?(1, 2)
-      fail(Puppet::Pops::Issues::BAD_FLOAT_SLICE_ARITY, @semantic, {:actual => keys.size})
+      fail(Issues::BAD_FLOAT_SLICE_ARITY, @semantic, {:actual => keys.size})
     end
     keys.each_with_index do |x, index|
-      fail(Puppet::Pops::Issues::BAD_FLOAT_SLICE_TYPE, @semantic.keys[index],
+      fail(Issues::BAD_FLOAT_SLICE_TYPE, @semantic.keys[index],
         {:actual => x.class}) unless (x.is_a?(Float) || x.is_a?(Integer) || x == :default)
     end
     from, to = keys
     from = from == :default || from.nil? ? nil : Float(from)
     to = to == :default || to.nil? ? nil : Float(to)
-    Puppet::Pops::Types::PFloatType.new(from, to)
+    Types::PFloatType.new(from, to)
   end
 
   # A Hash can create a new Hash type, one arg sets value type, two args sets key and value type in new type.
@@ -334,21 +334,21 @@ class Puppet::Pops::Evaluator::AccessOperator
   def access_PHashType(o, scope, keys)
     keys.flatten!
     keys[0,2].each_with_index do |k, index|
-      unless k.is_a?(Puppet::Pops::Types::PAnyType)
-        fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[index], {:base_type => 'Hash-Type', :actual => k.class})
+      unless k.is_a?(Types::PAnyType)
+        fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[index], {:base_type => 'Hash-Type', :actual => k.class})
       end
     end
     case keys.size
     when 2
-      Puppet::Pops::Types::PHashType.new(keys[0], keys[1], nil)
+      Types::PHashType.new(keys[0], keys[1], nil)
     when 3
       size_t = keys[2]
-      size_t = Puppet::Pops::Types::PIntegerType.new(size_t) unless size_t.is_a?(Puppet::Pops::Types::PIntegerType)
-      Puppet::Pops::Types::PHashType.new(keys[0], keys[1], size_t)
+      size_t = Types::PIntegerType.new(size_t) unless size_t.is_a?(Types::PIntegerType)
+      Types::PHashType.new(keys[0], keys[1], size_t)
     when 4
-      Puppet::Pops::Types::PHashType.new(keys[0], keys[1], collection_size_t(1, keys[2], keys[3]))
+      Types::PHashType.new(keys[0], keys[1], collection_size_t(1, keys[2], keys[3]))
     else
-      fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic, {
+      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic, {
         :base_type => 'Hash-Type', :min => 2, :max => 4, :actual => keys.size
       })
     end
@@ -363,10 +363,10 @@ class Puppet::Pops::Evaluator::AccessOperator
     when 2
       size_t = collection_size_t(1, keys[0], keys[1])
     else
-      fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic,
+      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic,
         {:base_type => 'Collection-Type', :min => 1, :max => 2, :actual => keys.size})
     end
-    Puppet::Pops::Types::PCollectionType.new(size_t)
+    Types::PCollectionType.new(size_t)
   end
 
   # An Array can create a new Array type. It is not possible to create a collection of Array types.
@@ -381,25 +381,25 @@ class Puppet::Pops::Evaluator::AccessOperator
     when 3
       size_t = collection_size_t(1, keys[1], keys[2])
     else
-      fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic,
+      fail(Issues::BAD_TYPE_SLICE_ARITY, @semantic,
         {:base_type => 'Array-Type', :min => 1, :max => 3, :actual => keys.size})
     end
-    unless keys[0].is_a?(Puppet::Pops::Types::PAnyType)
-      fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Array-Type', :actual => keys[0].class})
+    unless keys[0].is_a?(Types::PAnyType)
+      fail(Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Array-Type', :actual => keys[0].class})
     end
-    Puppet::Pops::Types::PArrayType.new(keys[0], size_t)
+    Types::PArrayType.new(keys[0], size_t)
   end
 
   # Produces an PIntegerType (range) given one or two keys.
   def collection_size_t(start_index, *keys)
-    if keys.size == 1 && keys[0].is_a?(Puppet::Pops::Types::PIntegerType)
+    if keys.size == 1 && keys[0].is_a?(Types::PIntegerType)
       keys[0]
     else
       keys.each_with_index do |x, index|
-        fail(Puppet::Pops::Issues::BAD_COLLECTION_SLICE_TYPE, @semantic.keys[start_index + index],
+        fail(Issues::BAD_COLLECTION_SLICE_TYPE, @semantic.keys[start_index + index],
           {:actual => x.class}) unless (x.is_a?(Integer) || x == :default)
       end
-      Puppet::Pops::Types::PIntegerType.new(*keys)
+      Types::PIntegerType.new(*keys)
     end
   end
 
@@ -408,7 +408,7 @@ class Puppet::Pops::Evaluator::AccessOperator
   def access_Resource(o, scope, keys)
     # To access a Puppet::Resource as if it was a PResourceType, simply infer it, and take the type of
     # the parameterized meta type (i.e. Type[Resource[the_resource_type, the_resource_title]])
-    t = Puppet::Pops::Types::TypeCalculator.infer(o).type
+    t = Types::TypeCalculator.infer(o).type
     # must map "undefined title" from resource to nil
     t.title = nil if t.title == EMPTY_STRING
     access(t, scope, *keys)
@@ -430,8 +430,8 @@ class Puppet::Pops::Evaluator::AccessOperator
     blamed = keys.size == 0 ? @semantic : @semantic.keys[0]
 
     if keys.size == 0
-      fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, blamed,
-        :base_type => Puppet::Pops::Types::TypeCalculator.new().string(o), :min => 1, :max => -1, :actual => 0)
+      fail(Issues::BAD_TYPE_SLICE_ARITY, blamed,
+        :base_type => o.to_s, :min => 1, :max => -1, :actual => 0)
     end
 
     # Must know which concrete resource type to operate on in all cases.
@@ -439,19 +439,19 @@ class Puppet::Pops::Evaluator::AccessOperator
     # type_name is LHS type_name if set, else the first given arg
     type_name = o.type_name || keys.shift
     type_name = case type_name
-    when Puppet::Pops::Types::PResourceType
+    when Types::PResourceType
       type_name.type_name
     when String
       type_name.downcase
     else
       # blame given left expression if it defined the type, else the first given key expression
       blame = o.type_name.nil? ? @semantic.keys[0] : @semantic.left_expr
-      fail(Puppet::Pops::Issues::ILLEGAL_RESOURCE_SPECIALIZATION, blame, {:actual => bad_key_type_name(type_name)})
+      fail(Issues::ILLEGAL_RESOURCE_SPECIALIZATION, blame, {:actual => bad_key_type_name(type_name)})
     end
 
     # type name must conform
-    if type_name !~ Puppet::Pops::Patterns::CLASSREF
-      fail(Puppet::Pops::Issues::ILLEGAL_CLASSREF, blamed, {:name=>type_name})
+    if type_name !~ Patterns::CLASSREF
+      fail(Issues::ILLEGAL_CLASSREF, blamed, {:name=>type_name})
     end
 
     # The result is an array if multiple titles are given, or if titles are specified with an array
@@ -467,7 +467,7 @@ class Puppet::Pops::Evaluator::AccessOperator
     # Return an empty array
     #
     if keys.empty? && keys_orig_size > 0
-      optionally_fail(Puppet::Pops::Issues::EMPTY_RESOURCE_SPECIALIZATION, blamed)
+      optionally_fail(Issues::EMPTY_RESOURCE_SPECIALIZATION, blamed)
       return result_type_array ? [] : nil
     end
 
@@ -475,12 +475,12 @@ class Puppet::Pops::Evaluator::AccessOperator
       # lookup resource and return one or more parameter values
       resource = find_resource(scope, o.type_name, o.title)
       unless resource
-        fail(Puppet::Pops::Issues::UNKNOWN_RESOURCE, @semantic, {:type_name => o.type_name, :title => o.title})
+        fail(Issues::UNKNOWN_RESOURCE, @semantic, {:type_name => o.type_name, :title => o.title})
       end
 
       result = keys.map do |k|
         unless is_parameter_of_resource?(scope, resource, k)
-          fail(Puppet::Pops::Issues::UNKNOWN_RESOURCE_PARAMETER, @semantic,
+          fail(Issues::UNKNOWN_RESOURCE_PARAMETER, @semantic,
             {:type_name => o.type_name, :title => o.title, :param_name=>k})
         end
         get_resource_parameter_value(scope, resource, k)
@@ -493,13 +493,13 @@ class Puppet::Pops::Evaluator::AccessOperator
     result = keys.each_with_index.map do |t, i|
       unless t.is_a?(String) || t == :no_title
         index = keys_orig_size != keys.size ? i+1 : i
-        fail(Puppet::Pops::Issues::BAD_TYPE_SPECIALIZATION, @semantic.keys[index], {
+        fail(Issues::BAD_TYPE_SPECIALIZATION, @semantic.keys[index], {
           :type => o,
           :message => "Cannot use #{bad_key_type_name(t)} where a resource title String is expected"
         })
       end
 
-      Puppet::Pops::Types::PResourceType.new(type_name, t == :no_title ? nil : t)
+      Types::PResourceType.new(type_name, t == :no_title ? nil : t)
     end
     # returns single type if request was for a single entity, else an array of types (possibly empty)
     return result_type_array ? result : result.pop
@@ -510,8 +510,8 @@ class Puppet::Pops::Evaluator::AccessOperator
     keys_orig_size = keys.size
 
     if keys_orig_size == 0
-      fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, blamed,
-        :base_type => Puppet::Pops::Types::TypeCalculator.new().string(o), :min => 1, :max => -1, :actual => 0)
+      fail(Issues::BAD_TYPE_SLICE_ARITY, blamed,
+        :base_type => o.to_s, :min => 1, :max => -1, :actual => 0)
     end
 
     # The result is an array if multiple classnames are given, or if classnames are specified with an array
@@ -526,7 +526,7 @@ class Puppet::Pops::Evaluator::AccessOperator
     # Return an empty array
     #
     if keys.empty? && keys_orig_size > 0
-      optionally_fail(Puppet::Pops::Issues::EMPTY_RESOURCE_SPECIALIZATION, blamed)
+      optionally_fail(Issues::EMPTY_RESOURCE_SPECIALIZATION, blamed)
       return result_type_array ? [] : nil
     end
 
@@ -536,18 +536,18 @@ class Puppet::Pops::Evaluator::AccessOperator
       # does not have a title. This should probably be deprecated.
       #
       result = keys.each_with_index.map do |c, i|
-        name = if c.is_a?(Puppet::Pops::Types::PResourceType) && !c.type_name.nil? && c.title.nil?
+        name = if c.is_a?(Types::PResourceType) && !c.type_name.nil? && c.title.nil?
                  # type_name is already downcase. Don't waste time trying to downcase again
                  c.type_name
                elsif c.is_a?(String)
                  c.downcase
                else
-                 fail(Puppet::Pops::Issues::ILLEGAL_HOSTCLASS_NAME, @semantic.keys[i], {:name => c})
+                 fail(Issues::ILLEGAL_HOSTCLASS_NAME, @semantic.keys[i], {:name => c})
                end
 
-        if name =~ Puppet::Pops::Patterns::NAME
+        if name =~ Patterns::NAME
           # Remove leading '::' since all references are global, and 3x runtime does the wrong thing
-          Puppet::Pops::Types::PHostClassType.new(name.sub(/^::/, EMPTY_STRING))
+          Types::PHostClassType.new(name.sub(/^::/, EMPTY_STRING))
         else
           fail(Issues::ILLEGAL_NAME, @semantic.keys[i], {:name=>c})
         end
@@ -560,12 +560,12 @@ class Puppet::Pops::Evaluator::AccessOperator
           if is_parameter_of_resource?(scope, resource, k)
             get_resource_parameter_value(scope, resource, k)
           else
-            fail(Puppet::Pops::Issues::UNKNOWN_RESOURCE_PARAMETER, @semantic,
+            fail(Issues::UNKNOWN_RESOURCE_PARAMETER, @semantic,
               {:type_name => 'Class', :title => o.class_name, :param_name=>k})
           end
         end
       else
-        fail(Puppet::Pops::Issues::UNKNOWN_RESOURCE, @semantic, {:type_name => 'Class', :title => o.class_name})
+        fail(Issues::UNKNOWN_RESOURCE, @semantic, {:type_name => 'Class', :title => o.class_name})
       end
     end
 
@@ -573,3 +573,5 @@ class Puppet::Pops::Evaluator::AccessOperator
     return result_type_array ? result : result.pop
   end
 end
+end
+end