puppet 4.3.2-x64-mingw32 → 4.4.0-x64-mingw32

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

@@ -1,3 +1,5 @@
+module Puppet::Pops
+module Evaluator
 # A Closure represents logic bound to a particular scope.
 # As long as the runtime (basically the scope implementation) has the behavior of Puppet 3x it is not
 # safe to return and later use this closure.
@@ -11,7 +13,7 @@
 # Note that this class is a CallableSignature, and the methods defined there should be used
 # as the API for obtaining information in a callable-implementation agnostic way.
 #
-class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignature
+class Closure < CallableSignature
   attr_reader :evaluator
   attr_reader :model
   attr_reader :enclosing_scope
@@ -25,22 +27,7 @@ class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignat
   # Evaluates a closure in its enclosing scope after having matched given arguments with parameters (from left to right)
   # @api public
   def call(*args)
-    variable_bindings = combine_values_with_parameters(args)
-
-    tc = Puppet::Pops::Types::TypeCalculator.singleton
-    final_args = tc.infer_set(parameters.reduce([]) do |tmp_args, param|
-      if param.captures_rest
-        tmp_args.concat(variable_bindings[param.name])
-      else
-        tmp_args << variable_bindings[param.name]
-      end
-    end)
-
-    if type.callable?(final_args)
-      @evaluator.evaluate_block_with_bindings(@enclosing_scope, variable_bindings, @model.body)
-    else
-      raise ArgumentError, Puppet::Pops::Types::TypeMismatchDescriber.describe_signatures(closure_name, [self], final_args)
-    end
+    call_with_scope(@enclosing_scope, args)
   end
 
   # This method makes a Closure compatible with a Dispatch. This is used when the closure is wrapped in a Function
@@ -48,20 +35,29 @@ class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignat
   # checks of the argument type/arity validity).
   # @api private
   def invoke(instance, calling_scope, args, &block)
-    call(*args, &block)
+    @enclosing_scope.with_global_scope do |global_scope|
+      call_with_scope(global_scope, args, &block)
+    end
   end
 
   # Call closure with argument assignment by name
   def call_by_name(args_hash, enforce_parameters)
     if enforce_parameters
-      args_hash = args_hash.dup
-      parameters.each do |p|
-        name = p.name
-        # only set result of default expr if it is defined (it is otherwise not possible to differentiate
-        # between explicit undef and no default expression
-        args_hash[name] = @evaluator.evaluate(p.value, @enclosing_scope) if args_hash[name].nil? && !p.value.nil?
+      # Push a temporary parameter scope used while resolving the parameter defaults
+      @enclosing_scope.with_parameter_scope(parameter_names) do |param_scope|
+        args_hash.each { |k, v| param_scope[k] = v unless v.nil? && parameter_names.include?(k) }
+        parameters.each do |p|
+          name = p.name
+          # only set result of default expr if it is defined (it is otherwise not possible to differentiate
+          # between explicit undef and no default expression
+          arg = args_hash[name]
+          if arg.nil? && !p.value.nil?
+            param_scope[name] = param_scope.evaluate(name, p.value, @enclosing_scope, @evaluator)
+          end
+        end
+        args_hash = param_scope.to_hash
       end
-      Puppet::Pops::Types::TypeMismatchDescriber.validate_parameters(closure_name, params_struct, args_hash)
+      Types::TypeMismatchDescriber.validate_parameters(closure_name, params_struct, args_hash)
     end
 
     @evaluator.evaluate_block_with_bindings(@enclosing_scope, args_hash, @model.body)
@@ -112,7 +108,7 @@ class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignat
     CLOSURE_NAME
   end
 
-  class Named < Puppet::Pops::Evaluator::Closure
+  class Named < Closure
     def initialize(name, evaluator, model, scope)
       @name = name
       super(evaluator, model, scope)
@@ -125,52 +121,70 @@ class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignat
 
   private
 
-  def combine_values_with_parameters(args)
-    variable_bindings = {}
+  def call_with_scope(scope, args)
+    variable_bindings = combine_values_with_parameters(scope, args)
+
+    tc = Types::TypeCalculator.singleton
+    final_args = tc.infer_set(parameters.reduce([]) do |tmp_args, param|
+      if param.captures_rest
+        tmp_args.concat(variable_bindings[param.name])
+      else
+        tmp_args << variable_bindings[param.name]
+      end
+    end)
 
-    parameters.each_with_index do |parameter, index|
-      param_captures     = parameter.captures_rest
-      default_expression = parameter.value
+    if type.callable?(final_args)
+      @evaluator.evaluate_block_with_bindings(scope, variable_bindings, @model.body)
+    else
+      raise ArgumentError, Types::TypeMismatchDescriber.describe_signatures(closure_name, [self], final_args)
+    end
+  end
 
-      if index >= args.size
-        if default_expression
-          # not given, has default
-          value = @evaluator.evaluate(default_expression, @enclosing_scope)
-          if param_captures && !value.is_a?(Array)
-            # correct non array default value
-            value = [value]
+  def combine_values_with_parameters(scope, args)
+    scope.with_parameter_scope(parameter_names) do |param_scope|
+      parameters.each_with_index do |parameter, index|
+        param_captures     = parameter.captures_rest
+        default_expression = parameter.value
+
+        if index >= args.size
+          if default_expression
+            # not given, has default
+            value = param_scope.evaluate(parameter.name, default_expression, scope, @evaluator)
+
+            if param_captures && !value.is_a?(Array)
+              # correct non array default value
+              value = [value]
+            end
+          else
+            # not given, does not have default
+            if param_captures
+              # default for captures rest is an empty array
+              value = []
+            else
+              @evaluator.fail(Issues::MISSING_REQUIRED_PARAMETER, parameter, { :param_name => parameter.name })
+            end
           end
         else
-          # not given, does not have default
+          given_argument = args[index]
           if param_captures
-            # default for captures rest is an empty array
-            value = []
+            # get excess arguments
+            value = args[(parameter_count-1)..-1]
+            # If the input was a single nil, or undef, and there is a default, use the default
+            # This supports :undef in case it was used in a 3x data structure and it is passed as an arg
+            #
+            if value.size == 1 && (given_argument.nil? || given_argument == :undef) && default_expression
+              value = param_scope.evaluate(parameter.name, default_expression, scope, @evaluator)
+              # and ensure it is an array
+              value = [value] unless value.is_a?(Array)
+            end
           else
-            @evaluator.fail(Puppet::Pops::Issues::MISSING_REQUIRED_PARAMETER, parameter, { :param_name => parameter.name })
+            value = given_argument
           end
         end
-      else
-        given_argument = args[index]
-        if param_captures
-          # get excess arguments
-          value = args[(parameter_count-1)..-1]
-          # If the input was a single nil, or undef, and there is a default, use the default
-          # This supports :undef in case it was used in a 3x data structure and it is passed as an arg
-          #
-          if value.size == 1 && (given_argument.nil? || given_argument == :undef) && default_expression
-            value = @evaluator.evaluate(default_expression, @enclosing_scope)
-            # and ensure it is an array
-            value = [value] unless value.is_a?(Array)
-          end
-        else
-          value = given_argument
-        end
+        param_scope[parameter.name] = value
       end
-
-      variable_bindings[parameter.name] = value
+      param_scope.to_hash
     end
-
-    variable_bindings
   end
 
   def create_callable_type()
@@ -185,7 +199,7 @@ class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignat
       if param_range[0] == 0
         in_optional_parameters = true
       elsif param_range[0] != 0 && in_optional_parameters
-        @evaluator.fail(Puppet::Pops::Issues::REQUIRED_PARAMETER_AFTER_OPTIONAL, param, { :param_name => param.name })
+        @evaluator.fail(Issues::REQUIRED_PARAMETER_AFTER_OPTIONAL, param, { :param_name => param.name })
       end
 
       range[0] += param_range[0]
@@ -196,11 +210,11 @@ class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignat
       range[1] = :default
     end
 
-    Puppet::Pops::Types::TypeFactory.callable(*(types + range))
+    Types::TypeFactory.callable(*(types + range))
   end
 
   def create_params_struct
-    type_factory = Puppet::Pops::Types::TypeFactory
+    type_factory = Types::TypeFactory
     members = {}
 
     parameters.each do |param|
@@ -216,10 +230,10 @@ class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignat
     type = if param.type_expr
              @evaluator.evaluate(param.type_expr, @enclosing_scope)
            else
-             Puppet::Pops::Types::PAnyType::DEFAULT
+             Types::PAnyType::DEFAULT
            end
 
-    if param.captures_rest && type.is_a?(Puppet::Pops::Types::PArrayType)
+    if param.captures_rest && type.is_a?(Types::PArrayType)
       # An array on a slurp parameter is how a size range is defined for a
       # slurp (Array[Integer, 1, 3] *$param). However, the callable that is
       # created can't have the array in that position or else type checking
@@ -228,7 +242,7 @@ class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignat
       # to be unpacked.
       param_range = type.size_range
       type = type.element_type
-    elsif param.captures_rest && !type.is_a?(Puppet::Pops::Types::PArrayType)
+    elsif param.captures_rest && !type.is_a?(Types::PArrayType)
       param_range = ANY_NUMBER_RANGE
     elsif param.value
       param_range = OPTIONAL_SINGLE_RANGE
@@ -247,3 +261,5 @@ class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignat
   OPTIONAL_SINGLE_RANGE = [0, 1]
   REQUIRED_SINGLE_RANGE = [1, 1]
 end
+end
+end

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

@@ -1,16 +1,18 @@
-class Puppet::Pops::Evaluator::CollectorTransformer
+module Puppet::Pops
+module Evaluator
+class CollectorTransformer
 
   def initialize
-    @@query_visitor    ||= Puppet::Pops::Visitor.new(nil, "query", 1, 1)
-    @@match_visitor    ||= Puppet::Pops::Visitor.new(nil, "match", 1, 1)
-    @@evaluator        ||= Puppet::Pops::Evaluator::EvaluatorImpl.new
-    @@compare_operator ||= Puppet::Pops::Evaluator::CompareOperator.new()
+    @@query_visitor    ||= Visitor.new(nil, "query", 1, 1)
+    @@match_visitor    ||= Visitor.new(nil, "match", 1, 1)
+    @@evaluator        ||= EvaluatorImpl.new
+    @@compare_operator ||= CompareOperator.new()
   end
 
   def transform(o, scope)
-    raise ArgumentError, "Expected CollectExpression" unless o.is_a? Puppet::Pops::Model::CollectExpression
+    raise ArgumentError, "Expected CollectExpression" unless o.is_a? Model::CollectExpression
 
-    raise "LHS is not a type" unless o.type_expr.is_a? Puppet::Pops::Model::QualifiedReference
+    raise "LHS is not a type" unless o.type_expr.is_a? Model::QualifiedReference
     type = o.type_expr.value().downcase()
 
     if type == 'class'
@@ -20,7 +22,7 @@ class Puppet::Pops::Evaluator::CollectorTransformer
     resource_type = scope.find_resource_type(type)
     fail "Resource type #{type} doesn't exist" unless resource_type
 
-    adapter = Puppet::Pops::Adapters::SourcePosAdapter.adapt(o)
+    adapter = Adapters::SourcePosAdapter.adapt(o)
     line_num = adapter.line
     position = adapter.pos
     file_path = adapter.locator.file
@@ -38,11 +40,11 @@ class Puppet::Pops::Evaluator::CollectorTransformer
     code = query_unless_nop(o.query, scope)
 
     case o.query
-    when Puppet::Pops::Model::VirtualQuery
-      newcoll = Puppet::Pops::Evaluator::Collectors::CatalogCollector.new(scope, resource_type.name, code, overrides)
-    when Puppet::Pops::Model::ExportedQuery
+    when Model::VirtualQuery
+      newcoll = Collectors::CatalogCollector.new(scope, resource_type.name, code, overrides)
+    when Model::ExportedQuery
       match = match_unless_nop(o.query, scope)
-      newcoll = Puppet::Pops::Evaluator::Collectors::ExportedCollector.new(scope, resource_type.name, match, code, overrides)
+      newcoll = Collectors::ExportedCollector.new(scope, resource_type.name, match, code, overrides)
     end
 
     scope.compiler.add_collection(newcoll)
@@ -61,13 +63,13 @@ protected
   end
 
   def query_unless_nop(query, scope)
-    unless query.expr.nil? || query.expr.is_a?(Puppet::Pops::Model::Nop)
+    unless query.expr.nil? || query.expr.is_a?(Model::Nop)
       query(query.expr, scope)
     end
   end
 
   def match_unless_nop(query, scope)
-    unless query.expr.nil? || query.expr.is_a?(Puppet::Pops::Model::Nop)
+    unless query.expr.nil? || query.expr.is_a?(Model::Nop)
       match(query.expr, scope)
     end
   end
@@ -223,3 +225,5 @@ protected
     raise ArgumentError, "Cannot transform object of class #{o.class}"
   end
 end
+end
+end

data/lib/puppet/pops/evaluator/collectors/exported_collector.rb

@@ -19,7 +19,6 @@ class Puppet::Pops::Evaluator::Collectors::ExportedCollector < Puppet::Pops::Eva
   # evaluate method
   def evaluate
     if Puppet[:storeconfigs] != true
-      Puppet.warning "Not collecting exported resources without storeconfigs"
       return false
     end
 

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

@@ -1,3 +1,5 @@
+module Puppet::Pops
+module Evaluator
 # Compares the puppet DSL way
 #
 # ==Equality
@@ -6,20 +8,20 @@
 # Hashes  are equal to hashes if they have the same size and keys and values #equals.
 # All other objects are equal if they are ruby #== equal
 #
-class Puppet::Pops::Evaluator::CompareOperator
-  include Puppet::Pops::Utils
+class CompareOperator
+  include Utils
 
   # 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
 
   def initialize
-    @@equals_visitor  ||= Puppet::Pops::Visitor.new(self, "equals", 1, 1)
-    @@compare_visitor ||= Puppet::Pops::Visitor.new(self, "cmp", 1, 1)
-    @@match_visitor ||= Puppet::Pops::Visitor.new(self, "match", 2, 2)
-    @@include_visitor ||= Puppet::Pops::Visitor.new(self, "include", 2, 2)
-    @type_calculator = Puppet::Pops::Types::TypeCalculator.new()
+    @@equals_visitor  ||= Visitor.new(self, "equals", 1, 1)
+    @@compare_visitor ||= Visitor.new(self, "cmp", 1, 1)
+    @@match_visitor ||= Visitor.new(self, "match", 2, 2)
+    @@include_visitor ||= Visitor.new(self, "include", 2, 2)
+    @type_calculator = Types::TypeCalculator.new()
   end
 
   def equals (a, b)
@@ -143,7 +145,7 @@ class Puppet::Pops::Evaluator::CompareOperator
       # Always set match data, a "not found" should not keep old match data visible
       set_match_data(matched, scope) # creates ephemeral
       return !!matched
-    when Puppet::Pops::Types::PAnyType
+    when Types::PAnyType
       a.each {|element| return true if @type_calculator.instance?(b, element) }
       return false
     else
@@ -193,3 +195,5 @@ class Puppet::Pops::Evaluator::CompareOperator
     equals(left, default, scope)
   end
 end
+end
+end

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

@@ -66,18 +66,19 @@ class Puppet::Pops::Evaluator::EppEvaluator
 
     parameters_specified = body.body.parameters_specified
     if parameters_specified || template_args_set
-      # no epp params or user provided arguments in a hash, epp() logic
-      # only sees global + what was given
-      closure_scope = scope.find_global_scope
       enforce_parameters = parameters_specified
     else
-      # no epp params and no arguments were given => inline_epp() logic
-      # sees all local variables, epp() all global
-      closure_scope =  use_global_scope_only ? scope.find_global_scope : scope
       enforce_parameters = true
     end
-    evaluated_result = parser.closure(body, closure_scope).call_by_name(template_args, enforce_parameters)
-    evaluated_result
+
+    # inline_epp() logic sees all local variables, epp() all global
+    if use_global_scope_only
+      scope.with_global_scope do |global_scope|
+        parser.closure(body, global_scope).call_by_name(template_args, enforce_parameters)
+      end
+    else
+      parser.closure(body, scope).call_by_name(template_args, enforce_parameters)
+    end
   end
 
   def self.handle_template_args(func_name, template_args)

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

@@ -1,11 +1,15 @@
 require 'rgen/ecore/ecore'
+require 'puppet/parser/scope'
 require 'puppet/pops/evaluator/compare_operator'
 require 'puppet/pops/evaluator/relationship_operator'
 require 'puppet/pops/evaluator/access_operator'
 require 'puppet/pops/evaluator/closure'
 require 'puppet/pops/evaluator/external_syntax_support'
+require 'puppet/pops/types/iterable'
 
-# This implementation of {Puppet::Pops::Evaluator} performs evaluation using the puppet 3.x runtime system
+module Puppet::Pops
+module Evaluator
+# This implementation of {Evaluator} performs evaluation using the puppet 3.x runtime system
 # in a manner largely compatible with Puppet 3.x, but adds new features and introduces constraints.
 #
 # The evaluation uses _polymorphic dispatch_ which works by dispatching to the first found method named after
@@ -18,17 +22,17 @@ require 'puppet/pops/evaluator/external_syntax_support'
 # either the actual class, or one of its super classes). The _scope_ parameter is always the scope in which
 # the evaluation takes place. If nothing else is mentioned, the return is always the result of evaluation.
 #
-# See {Puppet::Pops::Visitable} and {Puppet::Pops::Visitor} for more information about
+# See {Visitable} and {Visitor} for more information about
 # polymorphic calling.
 #
-class Puppet::Pops::Evaluator::EvaluatorImpl
-  include Puppet::Pops::Utils
+class EvaluatorImpl
+  include Utils
 
   # 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 Puppet::Pops::Evaluator::ExternalSyntaxSupport
+  include Runtime3Support
+  include ExternalSyntaxSupport
 
   EMPTY_STRING = ''.freeze
   COMMA_SEPARATOR = ', '.freeze
@@ -36,22 +40,22 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   # Reference to Issues name space makes it easier to refer to issues
   # (Issues are shared with the validator).
   #
-  Issues = Puppet::Pops::Issues
+  Issues = Issues
 
   def initialize
-    @@eval_visitor     ||= Puppet::Pops::Visitor.new(self, "eval", 1, 1)
-    @@lvalue_visitor   ||= Puppet::Pops::Visitor.new(self, "lvalue", 1, 1)
-    @@assign_visitor   ||= Puppet::Pops::Visitor.new(self, "assign", 3, 3)
-    @@string_visitor   ||= Puppet::Pops::Visitor.new(self, "string", 1, 1)
+    @@eval_visitor     ||= Visitor.new(self, "eval", 1, 1)
+    @@lvalue_visitor   ||= Visitor.new(self, "lvalue", 1, 1)
+    @@assign_visitor   ||= Visitor.new(self, "assign", 3, 3)
+    @@string_visitor   ||= Visitor.new(self, "string", 1, 1)
 
-    @@type_calculator  ||= Puppet::Pops::Types::TypeCalculator.new()
-    @@type_parser      ||= Puppet::Pops::Types::TypeParser.new()
+    @@type_calculator  ||= Types::TypeCalculator.new()
+    @@type_parser      ||= Types::TypeParser.new()
 
-    @@compare_operator     ||= Puppet::Pops::Evaluator::CompareOperator.new()
-    @@relationship_operator ||= Puppet::Pops::Evaluator::RelationshipOperator.new()
+    @@compare_operator     ||= CompareOperator.new()
+    @@relationship_operator ||= RelationshipOperator.new()
 
     # Use null migration checker unless given in context
-    @migration_checker = (Puppet.lookup(:migration_checker) { Puppet::Pops::Migration::MigrationChecker.new() })
+    @migration_checker = (Puppet.lookup(:migration_checker) { Migration::MigrationChecker.new() })
   end
 
   # @api private
@@ -72,7 +76,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     begin
       @@eval_visitor.visit_this_1(self, target, scope)
 
-    rescue Puppet::Pops::SemanticError => e
+    rescue SemanticError => e
       # A raised issue may not know the semantic target, use errors call stack, but fill in the 
       # rest from a supplied semantic object, or the target instruction if there is not semantic
       # object.
@@ -119,7 +123,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   #
   # @param target [Object] assignment target - see methods on the pattern assign_TYPE for actual supported types.
   # @param value [Object] the value to assign to `target`
-  # @param o [Puppet::Pops::Model::PopsObject] originating instruction
+  # @param o [Model::PopsObject] originating instruction
   # @param scope [Object] the runtime specific scope where evaluation should take place
   #
   # @api private
@@ -153,12 +157,12 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   #
   # @param scope [Puppet::Parser::Scope] the parent scope
   # @param variable_bindings [Hash{String => Object}] the variable names and values to bind (names are keys, bound values are values)
-  # @param block [Puppet::Pops::Model::BlockExpression] the sequence of expressions to evaluate in the new scope
+  # @param block [Model::BlockExpression] the sequence of expressions to evaluate in the new scope
   #
   # @api private
   #
   def evaluate_block_with_bindings(scope, variable_bindings, block_expr)
-    with_guarded_scope(scope) do
+    scope.with_guarded_scope do
       # change to create local scope_from - cannot give it file and line -
       # that is the place of the call, not "here"
       create_local_scope_from(variable_bindings, scope)
@@ -190,7 +194,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   #   $name = value
   # @param name [String] name of variable without $
   # @param value [Object] value to assign to the variable
-  # @param o [Puppet::Pops::Model::PopsObject] originating instruction
+  # @param o [Model::PopsObject] originating instruction
   # @param scope [Object] the runtime specific scope where evaluation should take place
   # @return [value<Object>]
   #
@@ -257,7 +261,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   #
   def eval_ReservedWord(o, scope)
     if !o.future
-      fail(Puppet::Pops::Issues::RESERVED_WORD, o, {:word => o.word})
+      fail(Issues::RESERVED_WORD, o, {:word => o.word})
     else
       o.word
     end
@@ -274,7 +278,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   # A QualifiedReference (i.e. a  capitalized qualified name such as Foo, or Foo::Bar) evaluates to a PType
   #
   def eval_QualifiedReference(o, scope)
-    @@type_parser.interpret(o)
+    @@type_parser.interpret(o, scope)
   end
 
   def eval_NotExpression(o, scope)
@@ -294,6 +298,8 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
       candidate
     when Hash
       candidate.to_a
+    when Puppet::Pops::Types::Iterator
+      candidate.to_a
     else
       # turns anything else into an array (so result can be unfolded)
       [candidate]
@@ -419,7 +425,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   def eval_AccessExpression(o, scope)
     left = evaluate(o.left_expr, scope)
     keys = o.keys.nil? ? [] : o.keys.collect {|key| evaluate(key, scope) }
-    Puppet::Pops::Evaluator::AccessOperator.new(o).access(left, scope, *keys)
+    AccessOperator.new(o).access(left, scope, *keys)
   end
 
   # Evaluates <, <=, >, >=, and ==
@@ -430,7 +436,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
 
     begin
     # Left is a type
-    if left.is_a?(Puppet::Pops::Types::PAnyType)
+    if left.is_a?(Types::PAnyType)
       case o.operator
       when :'=='
         @@type_calculator.equals(left,right)
@@ -503,7 +509,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     pattern = evaluate(o.right_expr, scope)
 
     # matches RHS types as instance of for all types except a parameterized Regexp[R]
-    if pattern.is_a?(Puppet::Pops::Types::PAnyType)
+    if pattern.is_a?(Types::PAnyType)
       # evaluate as instance? of type check
       matched = @@type_calculator.instance?(pattern, left)
       # convert match result to Boolean true, or false
@@ -584,7 +590,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     # memo scope level before evaluating test - don't want a match in the case test to leak $n match vars
     # to expressions after the case expression.
     #
-    with_guarded_scope(scope) do
+    scope.with_guarded_scope do
       test = evaluate(o.test, scope)
 
       result = nil
@@ -594,10 +600,10 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
         if co.values.find do |c|
           c = unwind_parentheses(c)
           case c
-          when Puppet::Pops::Model::LiteralDefault
+          when Model::LiteralDefault
             the_default = co.then_expr
             next false
-          when Puppet::Pops::Model::UnfoldExpression
+          when Model::UnfoldExpression
             # not ideal for error reporting, since it is not known which unfolded result
             # that caused an error - the entire unfold expression is blamed (i.e. the var c, passed to is_match?)
             evaluate(c, scope).any? {|v| is_match?(test, v, c, co, scope) }
@@ -621,7 +627,10 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   # to the compiler to collect the resources specified by the query.
   #
   def eval_CollectExpression o, scope
-    Puppet::Pops::Evaluator::CollectorTransformer.new().transform(o,scope)
+    if o.query.is_a?(Model::ExportedQuery)
+      optionally_fail(Issues::RT_NO_STORECONFIGS, o);
+    end
+    CollectorTransformer.new().transform(o,scope)
   end
 
   def eval_ParenthesizedExpression(o, scope)
@@ -652,47 +661,47 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
 
     # Get the type name
     type_name =
-    if (tmp_name = o.type_name).is_a?(Puppet::Pops::Model::QualifiedName)
+    if (tmp_name = o.type_name).is_a?(Model::QualifiedName)
       tmp_name.value # already validated as a name
     else
       type_name_acceptable =
       case o.type_name
-      when Puppet::Pops::Model::QualifiedReference
+      when Model::QualifiedReference
         true
-      when Puppet::Pops::Model::AccessExpression
-        o.type_name.left_expr.is_a?(Puppet::Pops::Model::QualifiedReference)
+      when Model::AccessExpression
+        o.type_name.left_expr.is_a?(Model::QualifiedReference)
       end
 
       evaluated_name = evaluate(tmp_name, scope)
       unless type_name_acceptable
         actual = type_calculator.generalize(type_calculator.infer(evaluated_name)).to_s
-        fail(Puppet::Pops::Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual => actual})
+        fail(Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual => actual})
       end
 
       # must be a CatalogEntry subtype
       case evaluated_name
-      when Puppet::Pops::Types::PHostClassType
+      when Types::PHostClassType
         unless evaluated_name.class_name.nil?
-          fail(Puppet::Pops::Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual=> evaluated_name.to_s})
+          fail(Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual=> evaluated_name.to_s})
         end
         'class'
 
-      when Puppet::Pops::Types::PResourceType
+      when Types::PResourceType
         unless evaluated_name.title().nil?
-          fail(Puppet::Pops::Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual=> evaluated_name.to_s})
+          fail(Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual=> evaluated_name.to_s})
         end
         evaluated_name.type_name # assume validated
 
       else
         actual = type_calculator.generalize(type_calculator.infer(evaluated_name)).to_s
-        fail(Puppet::Pops::Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual=>actual})
+        fail(Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual=>actual})
       end
     end
 
     # This is a runtime check - the model is valid, but will have runtime issues when evaluated
     # and storeconfigs is not set.
     if(o.exported)
-      optionally_fail(Puppet::Pops::Issues::RT_NO_STORECONFIGS_EXPORT, o);
+      optionally_fail(Issues::RT_NO_STORECONFIGS_EXPORT, o);
     end
 
     titles_to_body = {}
@@ -710,24 +719,24 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
       # There may be a :default entry, its entries apply with lower precedence
       #
       if titles.nil?
-        fail(Puppet::Pops::Issues::MISSING_TITLE, body.title)
+        fail(Issues::MISSING_TITLE, body.title)
       end
       titles = [titles].flatten
 
       # Check types of evaluated titles and duplicate entries
       titles.each_with_index do |title, index|
         if title.nil?
-          fail(Puppet::Pops::Issues::MISSING_TITLE_AT, body.title, {:index => index})
+          fail(Issues::MISSING_TITLE_AT, body.title, {:index => index})
 
         elsif !title.is_a?(String) && title != :default
           actual = type_calculator.generalize(type_calculator.infer(title)).to_s
-          fail(Puppet::Pops::Issues::ILLEGAL_TITLE_TYPE_AT, body.title, {:index => index, :actual => actual})
+          fail(Issues::ILLEGAL_TITLE_TYPE_AT, body.title, {:index => index, :actual => actual})
 
         elsif title == EMPTY_STRING
-         fail(Puppet::Pops::Issues::EMPTY_STRING_TITLE_AT, body.title, {:index => index})
+         fail(Issues::EMPTY_STRING_TITLE_AT, body.title, {:index => index})
 
         elsif titles_to_body[title]
-          fail(Puppet::Pops::Issues::DUPLICATE_TITLE, o, {:title => title})
+          fail(Issues::DUPLICATE_TITLE, o, {:title => title})
         end
         titles_to_body[title] = body
       end
@@ -744,7 +753,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
         params = [params] unless params.is_a?(Array)
         params.each do |p|
           if param_memo.include? p.name
-            fail(Puppet::Pops::Issues::DUPLICATE_ATTRIBUTE, o, {:attribute => p.name})
+            fail(Issues::DUPLICATE_ATTRIBUTE, o, {:attribute => p.name})
           end
           param_memo[p.name] = p
         end
@@ -780,7 +789,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     hashed_params = evaluate(o.expr, scope)
     unless hashed_params.is_a?(Hash)
       actual = type_calculator.generalize(type_calculator.infer(hashed_params)).to_s
-      fail(Puppet::Pops::Issues::TYPE_MISMATCH, o.expr, {:expected => 'Hash', :actual => actual})
+      fail(Issues::TYPE_MISMATCH, o.expr, {:expected => 'Hash', :actual => actual})
     end
     hashed_params.map { |k,v| create_resource_parameter(o, scope, k, v, :'=>') }
   end
@@ -790,7 +799,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   def eval_ResourceDefaultsExpression(o, scope)
     type = evaluate(o.type_ref, scope)
     type_name =
-    if type.is_a?(Puppet::Pops::Types::PResourceType) && !type.type_name.nil? && type.title.nil?
+    if type.is_a?(Types::PResourceType) && !type.type_name.nil? && type.title.nil?
       type.type_name # assume it is a valid name
     else
       actual = type_calculator.generalize(type_calculator.infer(type))
@@ -808,9 +817,9 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     # The functor expression is not evaluated, it is not possible to select the function to call
     # via an expression like $a()
     case o.functor_expr
-    when Puppet::Pops::Model::QualifiedName
+    when Model::QualifiedName
       # ok
-    when Puppet::Pops::Model::RenderStringExpression
+    when Model::RenderStringExpression
       # helpful to point out this easy to make Epp error
       fail(Issues::ILLEGAL_EPP_PARAMETERS, o)
     else
@@ -823,12 +832,12 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   # Evaluation of CallMethodExpression handles a NamedAccessExpression functor (receiver.function_name)
   #
   def eval_CallMethodExpression(o, scope)
-    unless o.functor_expr.is_a? Puppet::Pops::Model::NamedAccessExpression
+    unless o.functor_expr.is_a? Model::NamedAccessExpression
       fail(Issues::ILLEGAL_EXPRESSION, o.functor_expr, {:feature=>'function accessor', :container => o})
     end
     receiver = unfold([], [o.functor_expr.left_expr], scope)
     name = o.functor_expr.right_expr
-    unless name.is_a? Puppet::Pops::Model::QualifiedName
+    unless name.is_a? Model::QualifiedName
       fail(Issues::ILLEGAL_EXPRESSION, o.functor_expr, {:feature=>'function name', :container => o})
     end
     name = name.value # the string function name
@@ -839,8 +848,8 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     if o.lambda.nil?
       call_function(name, evaluated_arguments, o, scope)
     else
-      closure = Puppet::Pops::Evaluator::Closure.new(self, o.lambda, scope)
-      call_function(name, evaluated_arguments, o, scope, &Puppet::Pops::Evaluator::PuppetProc.new(closure) { |*args| closure.call(*args) })
+      closure = Closure.new(self, o.lambda, scope)
+      call_function(name, evaluated_arguments, o, scope, &PuppetProc.new(closure) { |*args| closure.call(*args) })
     end
   end
   private :call_function_with_block
@@ -852,17 +861,17 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     # memo scope level before evaluating test - don't want a match in the case test to leak $n match vars
     # to expressions after the selector expression.
     #
-    with_guarded_scope(scope) do
+    scope.with_guarded_scope do
       test = evaluate(o.left_expr, scope)
 
       the_default = nil
       selected = o.selectors.find do |s|
         me = unwind_parentheses(s.matching_expr)
         case me
-        when Puppet::Pops::Model::LiteralDefault
+        when Model::LiteralDefault
           the_default = s.value_expr
           false
-        when Puppet::Pops::Model::UnfoldExpression
+        when Model::UnfoldExpression
           # not ideal for error reporting, since it is not known which unfolded result
           # that caused an error - the entire unfold expression is blamed (i.e. the var c, passed to is_match?)
           evaluate(me, scope).any? {|v| is_match?(test, v, me, s, scope) }
@@ -894,7 +903,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
 
   # Evaluates Puppet DSL `if`
   def eval_IfExpression o, scope
-    with_guarded_scope(scope) do
+    scope.with_guarded_scope do
       if is_true?(evaluate(o.test, scope), o.test)
         evaluate(o.then_expr, scope)
       else
@@ -905,7 +914,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
 
   # Evaluates Puppet DSL `unless`
   def eval_UnlessExpression o, scope
-    with_guarded_scope(scope) do
+    scope.with_guarded_scope do
       unless is_true?(evaluate(o.test, scope), o.test)
         evaluate(o.then_expr, scope)
       else
@@ -953,7 +962,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   # @return [String] the interpolated result
   #
   def eval_TextExpression o, scope
-    if o.expr.is_a?(Puppet::Pops::Model::QualifiedName)
+    if o.expr.is_a?(Model::QualifiedName)
       string(get_variable_value(o.expr.value, o, scope), scope)
     else
       string(evaluate(o.expr, scope), scope)
@@ -985,7 +994,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   end
 
   def string_PAnyType(o, scope)
-    @@type_calculator.string(o)
+    o.to_s
   end
 
   # Produces concatenation / merge of x and y.
@@ -1057,7 +1066,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
         # Use type calcultor to determine if array is Array[Array[?]], and if so use second form
         # of call
         t = @@type_calculator.infer(y)
-        if t.element_type.is_a? Puppet::Pops::Types::PArrayType
+        if t.element_type.is_a? Types::PArrayType
           Hash[y]
         else
           Hash[*y]
@@ -1113,7 +1122,7 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
       matched = right.match(left)
       set_match_data(matched, scope) # creates or clears ephemeral
       !!matched # convert to boolean
-    elsif right.is_a?(Puppet::Pops::Types::PAnyType)
+    elsif right.is_a?(Types::PAnyType)
       # right is a type and left is not - check if left is an instance of the given type
       # (The reverse is not terribly meaningful - computing which of the case options that first produces
       # an instance of a given type).
@@ -1126,26 +1135,17 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
     @@compare_operator.match(left, right, scope)
   end
 
-  def with_guarded_scope(scope)
-    scope_memo = get_scope_nesting_level(scope)
-    begin
-      yield
-    ensure
-      set_scope_nesting_level(scope, scope_memo)
-    end
-  end
-
   # Maps the expression in the given array to their product except for UnfoldExpressions which are first unfolded.
   # The result is added to the given result Array.
   # @param result [Array] Where to add the result (may contain information to add to)
-  # @param array [Array[Puppet::Pops::Model::Expression] the expressions to map
+  # @param array [Array[Model::Expression] the expressions to map
   # @param scope [Puppet::Parser::Scope] the scope to evaluate in
   # @return [Array] the given result array with content added from the operation
   #
   def unfold(result, array, scope)
     array.each do |x|
       x = unwind_parentheses(x)
-      if x.is_a?(Puppet::Pops::Model::UnfoldExpression)
+      if x.is_a?(Model::UnfoldExpression)
         result.concat(evaluate(x, scope))
       else
         result << evaluate(x, scope)
@@ -1156,8 +1156,10 @@ class Puppet::Pops::Evaluator::EvaluatorImpl
   private :unfold
 
   def unwind_parentheses(o)
-    return o unless o.is_a?(Puppet::Pops::Model::ParenthesizedExpression)
+    return o unless o.is_a?(Model::ParenthesizedExpression)
     unwind_parentheses(o.expr)
   end
   private :unwind_parentheses
 end
+end
+end