diff --git a/lib/puppet/parser/compiler.rb b/lib/puppet/parser/compiler.rb
index c7387f225..651b2ce53 100644
--- a/lib/puppet/parser/compiler.rb
+++ b/lib/puppet/parser/compiler.rb
@@ -1,598 +1,598 @@
 require 'forwardable'
 
 require 'puppet/node'
 require 'puppet/resource/catalog'
 require 'puppet/util/errors'
 
 require 'puppet/resource/type_collection_helper'
 
 # Maintain a graph of scopes, along with a bunch of data
 # about the individual catalog we're compiling.
 class Puppet::Parser::Compiler
   extend Forwardable
 
   include Puppet::Util
   include Puppet::Util::Errors
   include Puppet::Util::MethodHelper
   include Puppet::Resource::TypeCollectionHelper
 
   def self.compile(node)
     $env_module_directories = nil
     node.environment.check_for_reparse
 
     new(node).compile.to_resource
   rescue => detail
     message = "#{detail} on node #{node.name}"
     Puppet.log_exception(detail, message)
     raise Puppet::Error, message, detail.backtrace
  end
 
   attr_reader :node, :facts, :collections, :catalog, :resources, :relationships, :topscope
 
   # The injector that provides lookup services, or nil if accessed before the compiler has started compiling and
   # bootstrapped. The injector is initialized and available before any manifests are evaluated.
   #
   # @return [Puppet::Pops::Binder::Injector, nil] The injector that provides lookup services for this compiler/environment
   # @api public
   #
   attr_accessor :injector
 
   # Access to the configured loaders for 4x
   # @return [Puppet::Pops::Loader::Loaders] the configured loaders
   # @api private
   attr_reader :loaders
 
   # The injector that provides lookup services during the creation of the {#injector}.
   # @return [Puppet::Pops::Binder::Injector, nil] The injector that provides lookup services during injector creation
   #   for this compiler/environment
   #
   # @api private
   #
   attr_accessor :boot_injector
 
   # Add a collection to the global list.
   def_delegator :@collections,   :<<, :add_collection
   def_delegator :@relationships, :<<, :add_relationship
 
   # Store a resource override.
   def add_override(override)
     # If possible, merge the override in immediately.
     if resource = @catalog.resource(override.ref)
       resource.merge(override)
     else
       # Otherwise, store the override for later; these
       # get evaluated in Resource#finish.
       @resource_overrides[override.ref] << override
     end
   end
 
   def add_resource(scope, resource)
     @resources << resource
 
     # Note that this will fail if the resource is not unique.
     @catalog.add_resource(resource)
 
     if not resource.class? and resource[:stage]
       raise ArgumentError, "Only classes can set 'stage'; normal resources like #{resource} cannot change run stage"
     end
 
     # Stages should not be inside of classes.  They are always a
     # top-level container, regardless of where they appear in the
     # manifest.
     return if resource.stage?
 
     # This adds a resource to the class it lexically appears in in the
     # manifest.
     unless resource.class?
       return @catalog.add_edge(scope.resource, resource)
     end
   end
 
   # Do we use nodes found in the code, vs. the external node sources?
   def_delegator :known_resource_types, :nodes?, :ast_nodes?
 
   # Store the fact that we've evaluated a class
   def add_class(name)
     @catalog.add_class(name) unless name == ""
   end
 
 
   # Return a list of all of the defined classes.
   def_delegator :@catalog, :classes, :classlist
 
   # Compiler our catalog.  This mostly revolves around finding and evaluating classes.
   # This is the main entry into our catalog.
   def compile
     Puppet.override( @context_overrides , "For compiling #{node.name}") do
       # Set the client's parameters into the top scope.
       Puppet::Util::Profiler.profile("Compile: Set node parameters") { set_node_parameters }
 
       Puppet::Util::Profiler.profile("Compile: Created settings scope") { create_settings_scope }
 
       if is_binder_active?
         # create injector, if not already created - this is for 3x that does not trigger
         # lazy loading of injector via context
         Puppet::Util::Profiler.profile("Compile: Created injector") { injector }
       end
 
       Puppet::Util::Profiler.profile("Compile: Evaluated main") { evaluate_main }
 
       Puppet::Util::Profiler.profile("Compile: Evaluated AST node") { evaluate_ast_node }
 
       Puppet::Util::Profiler.profile("Compile: Evaluated node classes") { evaluate_node_classes }
 
       Puppet::Util::Profiler.profile("Compile: Evaluated generators") { evaluate_generators }
 
       Puppet::Util::Profiler.profile("Compile: Finished catalog") { finish }
 
       fail_on_unevaluated
 
       @catalog
     end
   end
 
   # Constructs the overrides for the context
   def context_overrides()
     if Puppet[:parser] == 'future'
       require 'puppet/loaders'
       {
         :current_environment => environment,
         :global_scope => @topscope,             # 4x placeholder for new global scope
         :loaders  => lambda {|| loaders() },    # 4x loaders
         :injector => lambda {|| injector() }    # 4x API - via context instead of via compiler
       }
     else
       {
         :current_environment => environment,
       }
     end
   end
 
   def_delegator :@collections, :delete, :delete_collection
 
   # Return the node's environment.
   def environment
     unless node.environment.is_a? Puppet::Node::Environment
       raise Puppet::DevError, "node #{node} has an invalid environment!"
     end
     node.environment
   end
 
   # Evaluate all of the classes specified by the node.
   # Classes with parameters are evaluated as if they were declared.
   # Classes without parameters or with an empty set of parameters are evaluated
   # as if they were included. This means classes with an empty set of
   # parameters won't conflict even if the class has already been included.
   def evaluate_node_classes
     if @node.classes.is_a? Hash
       classes_with_params, classes_without_params = @node.classes.partition {|name,params| params and !params.empty?}
 
       # The results from Hash#partition are arrays of pairs rather than hashes,
       # so we have to convert to the forms evaluate_classes expects (Hash, and
       # Array of class names)
       classes_with_params = Hash[classes_with_params]
       classes_without_params.map!(&:first)
     else
       classes_with_params = {}
       classes_without_params = @node.classes
     end
 
     evaluate_classes(classes_without_params, @node_scope || topscope)
 
     evaluate_classes(classes_with_params, @node_scope || topscope)
   end
 
   # Evaluate each specified class in turn.  If there are any classes we can't
   # find, raise an error.  This method really just creates resource objects
   # that point back to the classes, and then the resources are themselves
   # evaluated later in the process.
   #
   # Sometimes we evaluate classes with a fully qualified name already, in which
   # case, we tell scope.find_hostclass we've pre-qualified the name so it
   # doesn't need to search its namespaces again.  This gets around a weird
   # edge case of duplicate class names, one at top scope and one nested in our
   # namespace and the wrong one (or both!) getting selected. See ticket #13349
   # for more detail.  --jeffweiss 26 apr 2012
   def evaluate_classes(classes, scope, lazy_evaluate = true, fqname = false)
     raise Puppet::DevError, "No source for scope passed to evaluate_classes" unless scope.source
     class_parameters = nil
     # if we are a param class, save the classes hash
     # and transform classes to be the keys
     if classes.class == Hash
       class_parameters = classes
       classes = classes.keys
     end
     classes.each do |name|
       # If we can find the class, then make a resource that will evaluate it.
       if klass = scope.find_hostclass(name, :assume_fqname => fqname)
 
         # If parameters are passed, then attempt to create a duplicate resource
         # so the appropriate error is thrown.
         if class_parameters
           resource = klass.ensure_in_catalog(scope, class_parameters[name] || {})
         else
           next if scope.class_scope(klass)
           resource = klass.ensure_in_catalog(scope)
         end
 
         # If they've disabled lazy evaluation (which the :include function does),
         # then evaluate our resource immediately.
         resource.evaluate unless lazy_evaluate
       else
         raise Puppet::Error, "Could not find class #{name} for #{node.name}"
       end
     end
   end
 
   def evaluate_relationships
     @relationships.each { |rel| rel.evaluate(catalog) }
   end
 
   # Return a resource by either its ref or its type and title.
   def_delegator :@catalog, :resource, :findresource
 
   def initialize(node, options = {})
     @node = node
     set_options(options)
     initvars
   end
 
   # Create a new scope, with either a specified parent scope or
   # using the top scope.
   def newscope(parent, options = {})
     parent ||= topscope
     scope = Puppet::Parser::Scope.new(self, options)
     scope.parent = parent
     scope
   end
 
   # Return any overrides for the given resource.
   def resource_overrides(resource)
     @resource_overrides[resource.ref]
   end
 
   def injector
     create_injector if @injector.nil?
     @injector
   end
 
   def loaders
-    @loaders ||= Puppet::Pops::Loaders.new()
+    @loaders ||= Puppet::Pops::Loaders.new(environment)
   end
 
   def boot_injector
     create_boot_injector(nil) if @boot_injector.nil?
     @boot_injector
   end
 
   # Creates the boot injector from registered system, default, and injector config.
   # @return [Puppet::Pops::Binder::Injector] the created boot injector
   # @api private Cannot be 'private' since it is called from the BindingsComposer.
   #
   def create_boot_injector(env_boot_bindings)
     assert_binder_active()
     pb = Puppet::Pops::Binder
     boot_contribution = pb::SystemBindings.injector_boot_contribution(env_boot_bindings)
     final_contribution = pb::SystemBindings.final_contribution
     binder = pb::Binder.new(pb::BindingsFactory.layered_bindings(final_contribution, boot_contribution))
     @boot_injector = pb::Injector.new(binder)
   end
 
   # Answers if Puppet Binder should be active or not, and if it should and is not active, then it is activated.
   # @return [Boolean] true if the Puppet Binder should be activated
   def is_binder_active?
     should_be_active = Puppet[:binder] || Puppet[:parser] == 'future'
     if should_be_active
       # TODO: this should be in a central place, not just for ParserFactory anymore...
       Puppet::Parser::ParserFactory.assert_rgen_installed()
       @@binder_loaded ||= false
       unless @@binder_loaded
         require 'puppet/pops'
         require 'puppetx'
         @@binder_loaded = true
       end
     end
     should_be_active
   end
 
   private
 
   # If ast nodes are enabled, then see if we can find and evaluate one.
   def evaluate_ast_node
     return unless ast_nodes?
 
     # Now see if we can find the node.
     astnode = nil
     @node.names.each do |name|
       break if astnode = known_resource_types.node(name.to_s.downcase)
     end
 
     unless (astnode ||= known_resource_types.node("default"))
       raise Puppet::ParseError, "Could not find default node or by name with '#{node.names.join(", ")}'"
     end
 
     # Create a resource to model this node, and then add it to the list
     # of resources.
     resource = astnode.ensure_in_catalog(topscope)
 
     resource.evaluate
 
     @node_scope = topscope.class_scope(astnode)
   end
 
   # Evaluate our collections and return true if anything returned an object.
   # The 'true' is used to continue a loop, so it's important.
   def evaluate_collections
     return false if @collections.empty?
 
     exceptwrap do
       # We have to iterate over a dup of the array because
       # collections can delete themselves from the list, which
       # changes its length and causes some collections to get missed.
       Puppet::Util::Profiler.profile("Evaluated collections") do
         found_something = false
         @collections.dup.each do |collection|
           found_something = true if collection.evaluate
         end
         found_something
       end
     end
   end
 
   # Make sure all of our resources have been evaluated into native resources.
   # We return true if any resources have, so that we know to continue the
   # evaluate_generators loop.
   def evaluate_definitions
     exceptwrap do
       Puppet::Util::Profiler.profile("Evaluated definitions") do
         !unevaluated_resources.each do |resource|
           Puppet::Util::Profiler.profile("Evaluated resource #{resource}") do
             resource.evaluate
           end
         end.empty?
       end
     end
   end
 
   # Iterate over collections and resources until we're sure that the whole
   # compile is evaluated.  This is necessary because both collections
   # and defined resources can generate new resources, which themselves could
   # be defined resources.
   def evaluate_generators
     count = 0
     loop do
       done = true
 
       Puppet::Util::Profiler.profile("Iterated (#{count + 1}) on generators") do
         # Call collections first, then definitions.
         done = false if evaluate_collections
         done = false if evaluate_definitions
       end
 
       break if done
 
       count += 1
 
       if count > 1000
         raise Puppet::ParseError, "Somehow looped more than 1000 times while evaluating host catalog"
       end
     end
   end
 
   # Find and evaluate our main object, if possible.
   def evaluate_main
     @main = known_resource_types.find_hostclass([""], "") || known_resource_types.add(Puppet::Resource::Type.new(:hostclass, ""))
     @topscope.source = @main
     @main_resource = Puppet::Parser::Resource.new("class", :main, :scope => @topscope, :source => @main)
     @topscope.resource = @main_resource
 
     add_resource(@topscope, @main_resource)
 
     @main_resource.evaluate
   end
 
   # Make sure the entire catalog is evaluated.
   def fail_on_unevaluated
     fail_on_unevaluated_overrides
     fail_on_unevaluated_resource_collections
   end
 
   # If there are any resource overrides remaining, then we could
   # not find the resource they were supposed to override, so we
   # want to throw an exception.
   def fail_on_unevaluated_overrides
     remaining = @resource_overrides.values.flatten.collect(&:ref)
 
     if !remaining.empty?
       fail Puppet::ParseError,
         "Could not find resource(s) #{remaining.join(', ')} for overriding"
     end
   end
 
   # Make sure we don't have any remaining collections that specifically
   # look for resources, because we want to consider those to be
   # parse errors.
   def fail_on_unevaluated_resource_collections
     remaining = @collections.collect(&:resources).flatten.compact
 
     if !remaining.empty?
       raise Puppet::ParseError, "Failed to realize virtual resources #{remaining.join(', ')}"
     end
   end
 
   # Make sure all of our resources and such have done any last work
   # necessary.
   def finish
     evaluate_relationships
 
     resources.each do |resource|
       # Add in any resource overrides.
       if overrides = resource_overrides(resource)
         overrides.each do |over|
           resource.merge(over)
         end
 
         # Remove the overrides, so that the configuration knows there
         # are none left.
         overrides.clear
       end
 
       resource.finish if resource.respond_to?(:finish)
     end
 
     add_resource_metaparams
   end
 
   def add_resource_metaparams
     unless main = catalog.resource(:class, :main)
       raise "Couldn't find main"
     end
 
     names = Puppet::Type.metaparams.select do |name|
       !Puppet::Parser::Resource.relationship_parameter?(name)
     end
 
     data = {}
     catalog.walk(main, :out) do |source, target|
       if source_data = data[source] || metaparams_as_data(source, names)
         # only store anything in the data hash if we've actually got
         # data
         data[source] ||= source_data
         source_data.each do |param, value|
           target[param] = value if target[param].nil?
         end
         data[target] = source_data.merge(metaparams_as_data(target, names))
       end
 
       target.tag(*(source.tags))
     end
   end
 
   def metaparams_as_data(resource, params)
     data = nil
     params.each do |param|
       unless resource[param].nil?
         # Because we could be creating a hash for every resource,
         # and we actually probably don't often have any data here at all,
         # we're optimizing a bit by only creating a hash if there's
         # any data to put in it.
         data ||= {}
         data[param] = resource[param]
       end
     end
     data
   end
 
   # Set up all of our internal variables.
   def initvars
     # The list of overrides.  This is used to cache overrides on objects
     # that don't exist yet.  We store an array of each override.
     @resource_overrides = Hash.new do |overs, ref|
       overs[ref] = []
     end
 
     # The list of collections that have been created.  This is a global list,
     # but they each refer back to the scope that created them.
     @collections = []
 
     # The list of relationships to evaluate.
     @relationships = []
 
     # For maintaining the relationship between scopes and their resources.
     @catalog = Puppet::Resource::Catalog.new(@node.name)
 
     # MOVED HERE - SCOPE IS NEEDED (MOVE-SCOPE)
     # Create the initial scope, it is needed early
     @topscope = Puppet::Parser::Scope.new(self)
 
     # Need to compute overrides here, and remember them, because we are about to
     # enter the magic zone of known_resource_types and intial import.
     # Expensive entries in the context are bound lazily.
     @context_overrides = context_overrides()
 
     # This construct ensures that initial import (triggered by instantiating
     # the structure 'known_resource_types') has a configured context
     # It cannot survive the initvars method, and is later reinstated
     # as part of compiling...
     #
     Puppet.override( @context_overrides , "For initializing compiler") do
       # THE MAGIC STARTS HERE ! This triggers parsing, loading etc.
       @catalog.version = known_resource_types.version
     end
 
     @catalog.environment = @node.environment.to_s
 
     @catalog.add_resource(Puppet::Parser::Resource.new("stage", :main, :scope => @topscope))
 
     # local resource array to maintain resource ordering
     @resources = []
 
     # Make sure any external node classes are in our class list
     if @node.classes.class == Hash
       @catalog.add_class(*@node.classes.keys)
     else
       @catalog.add_class(*@node.classes)
     end
   end
 
   # Set the node's parameters into the top-scope as variables.
   def set_node_parameters
     node.parameters.each do |param, value|
       @topscope[param.to_s] = value
     end
     # These might be nil.
     catalog.client_version = node.parameters["clientversion"]
     catalog.server_version = node.parameters["serverversion"]
     if Puppet[:trusted_node_data]
       @topscope.set_trusted(node.trusted_data)
     end
     if(Puppet[:immutable_node_data])
       facts_hash = node.facts.nil? ? {} : node.facts.values
       @topscope.set_facts(facts_hash)
     end
   end
 
   def create_settings_scope
     unless settings_type = environment.known_resource_types.hostclass("settings")
       settings_type = Puppet::Resource::Type.new :hostclass, "settings"
       environment.known_resource_types.add(settings_type)
     end
 
     settings_resource = Puppet::Parser::Resource.new("class", "settings", :scope => @topscope)
 
     @catalog.add_resource(settings_resource)
 
     settings_type.evaluate_code(settings_resource)
 
     scope = @topscope.class_scope(settings_type)
 
     Puppet.settings.each do |name, setting|
       next if name.to_s == "name"
       scope[name.to_s] = environment[name]
     end
   end
 
   # Return an array of all of the unevaluated resources.  These will be definitions,
   # which need to get evaluated into native resources.
   def unevaluated_resources
     # The order of these is significant for speed due to short-circuting
     resources.reject { |resource| resource.evaluated? or resource.virtual? or resource.builtin_type? }
   end
 
   # Creates the injector from bindings found in the current environment.
   # @return [void]
   # @api private
   #
   def create_injector
     assert_binder_active()
     composer = Puppet::Pops::Binder::BindingsComposer.new()
     layered_bindings = composer.compose(topscope)
     @injector = Puppet::Pops::Binder::Injector.new(Puppet::Pops::Binder::Binder.new(layered_bindings))
   end
 
   def assert_binder_active
     unless is_binder_active?
       raise ArgumentError, "The Puppet Binder is only available when either '--binder true' or '--parser future' is used"
     end
   end
 end
diff --git a/lib/puppet/pops/loaders.rb b/lib/puppet/pops/loaders.rb
index c5a6340ed..7c824edff 100644
--- a/lib/puppet/pops/loaders.rb
+++ b/lib/puppet/pops/loaders.rb
@@ -1,260 +1,259 @@
 class Puppet::Pops::Loaders
   class LoaderError < Puppet::Error; end
 
   attr_reader :static_loader
   attr_reader :puppet_system_loader
   attr_reader :public_environment_loader
   attr_reader :private_environment_loader
 
-  def initialize()
+  def initialize(environment)
     # The static loader can only be changed after a reboot
     @@static_loader ||= Puppet::Pops::Loader::StaticLoader.new()
 
     # Create the set of loaders
     # 1. Puppet, loads from the "running" puppet - i.e. bundled functions, types, extension points and extensions
     #    Does not change without rebooting the service running puppet.
     #
     @@puppet_system_loader ||= create_puppet_system_loader()
 
     # 2. Environment loader - i.e. what is bound across the environment, may change for each setup
     #    TODO: loaders need to work when also running in an agent doing catalog application. There is no
     #    concept of environment the same way as when running as a master (except when doing apply).
     #    The creation mechanisms should probably differ between the two.
     #
-    @private_environment_loader = create_environment_loader()
+    @private_environment_loader = create_environment_loader(environment)
 
     # 3. module loaders are set up from the create_environment_loader, they register themselves
   end
 
   # Clears the cached static and puppet_system loaders (to enable testing)
   #
   def self.clear
     @@static_loader = nil
     @@puppet_system_loader = nil
   end
 
   def static_loader
     @@static_loader
   end
 
   def puppet_system_loader
     @@puppet_system_loader
   end
 
   def self.create_loaders()
     self.new()
   end
 
   def public_loader_for_module(module_name)
     md = @module_resolver[module_name] || (return nil)
     # Note, this loader is not resolved until there is interest in the visibility of entities from the
     # perspective of something contained in the module. (Many request may pass through a module loader
     # without it loading anything.
     # See {#private_loader_for_module}, and not in {#configure_loaders_for_modules}
     md.public_loader
   end
 
   def private_loader_for_module(module_name)
     md = @module_resolver[module_name] || (return nil)
     # Since there is interest in the visibility from the perspective of entities contained in the
     # module, it must be resolved (to provide this visibility).
     # See {#configure_loaders_for_modules}
     unless md.resolved?
       @module_resolver.resolve(md)
     end
     md.private_loader
   end
 
   private
 
   def create_puppet_system_loader()
     module_name = nil
     loader_name = 'puppet_system'
 
     # Puppet system may be installed in a fixed location via RPM, installed as a Gem, via source etc.
     # The only way to find this across the different ways puppet can be installed is
     # to search up the path from this source file's __FILE__ location until it finds the parent of
     # lib/puppet... e.g.. dirname(__FILE__)/../../..  (i.e. <somewhere>/lib/puppet/pops/loaders.rb).
     #
     puppet_lib = File.join(File.dirname(__FILE__), '../../..')
     Puppet::Pops::Loader::ModuleLoaders::FileBased.new(static_loader, module_name, puppet_lib, loader_name)
   end
 
-  def create_environment_loader()
+  def create_environment_loader(environment)
     # This defines where to start parsing/evaluating - the "initial import" (to use 3x terminology)
     # Is either a reference to a single .pp file, or a directory of manifests. If the environment becomes
     # a module and can hold functions, types etc. then these are available across all other modules without
     # them declaring this dependency - it is however valuable to be able to treat it the same way
     # bindings and other such system related configuration.
 
     # This is further complicated by the many options available:
     # - The environment may not have a directory, the code comes from one appointed 'manifest' (site.pp)
     # - The environment may have a directory and also point to a 'manifest'
     # - The code to run may be set in settings (code)
 
     # Further complication is that there is nothing specifying what the visibility is into
     # available modules. (3x is everyone sees everything).
     # Puppet binder currently reads confdir/bindings - that is bad, it should be using the new environment support.
 
-    current_environment = Puppet.lookup(:current_environment)
     # The environment is not a namespace, so give it a nil "module_name"
     module_name = nil
-    loader_name = "environment:#{current_environment.name}"
+    loader_name = "environment:#{environment.name}"
     env_dir = Puppet[:environmentdir]
     if env_dir.nil?
       # Use an environment loader that can be populated externally
       loader = Puppet::Pops::Loader::SimpleEnvironmentLoader.new(puppet_system_loader, loader_name)
     else
-      envdir_path = File.join(env_dir, current_environment.name.to_s)
+      envdir_path = File.join(env_dir, environment.name.to_s)
       # TODO: Representing Environment as a Module - needs something different (not all types are supported),
       # and it must be able to import .pp code from 3x manifest setting, or from code setting as well as from
       # a manifests directory under the environment's root. The below is cheating...
       #
       loader = Puppet::Pops::Loader::ModuleLoaders::FileBased(puppet_system_loader, module_name, envdir_path, loader_name)
     end
     # An environment has a module path even if it has a null loader
-    configure_loaders_for_modules(loader, current_environment)
+    configure_loaders_for_modules(loader, environment)
     # modules should see this loader
     @public_environment_loader = loader
 
     # Code in the environment gets to see all modules (since there is no metadata for the environment)
     # but since this is not given to the module loaders, they can not load global code (since they can not
     # have prior knowledge about this
     loader = Puppet::Pops::Loader::DependencyLoader.new(loader, "environment", @module_resolver.all_module_loaders())
 
     # The module loader gets the private loader via a lazy operation to look up the module's private loader.
     # This does not work for an environment since it is not resolved the same way.
     # TODO: The EnvironmentLoader could be a specialized loader instead of using a ModuleLoader to do the work.
     #       This is subject to future design - an Environment may move more in the direction of a Module.
     @public_environment_loader.private_loader = loader
     loader
   end
 
-  def configure_loaders_for_modules(parent_loader, current_environment)
+  def configure_loaders_for_modules(parent_loader, environment)
     @module_resolver = mr = ModuleResolver.new()
-    current_environment.modules.each do |puppet_module|
+    environment.modules.each do |puppet_module|
       # Create data about this module
       md = LoaderModuleData.new(puppet_module)
       mr[puppet_module.name] = md
       md.public_loader = Puppet::Pops::Loader::ModuleLoaders::FileBased.new(parent_loader, md.name, md.path, md.name)
     end
     # NOTE: Do not resolve all modules here - this is wasteful if only a subset of modules / functions are used
     #       The resolution is triggered by asking for a module's private loader, since this means there is interest
     #       in the visibility from that perspective.
     #       If later, it is wanted that all resolutions should be made up-front (to capture errors eagerly, this
     #       can be introduced (better for production), but may be irritating in development mode.
   end
 
   # =LoaderModuleData
   # Information about a Module and its loaders.
   # TODO: should have reference to real model element containing all module data; this is faking it
   # TODO: Should use Puppet::Module to get the metadata (as a hash) - a somewhat blunt instrument, but that is
   #       what is available with a reasonable API.
   #
   class LoaderModuleData
 
     attr_accessor :state
     attr_accessor :public_loader
     attr_accessor :private_loader
     attr_accessor :resolutions
 
     # The Puppet::Module this LoaderModuleData represents in the loader configuration
     attr_reader :puppet_module
 
     # @param puppet_module [Puppet::Module] the module instance for the module being represented
     #
     def initialize(puppet_module)
       @state = :initial
       @puppet_module = puppet_module
       @resolutions = []
       @public_loader = nil
       @private_loader = nil
     end
 
     def name
       @puppet_module.name
     end
 
     def version
       @puppet_module.version
     end
 
     def path
       @puppet_module.path
     end
 
     # TODO: UNUSED? Remove this
     def requirements
       nil # FAKE: this says "wants to see everything"
     end
 
     def resolved?
       @state == :resolved
     end
 
     def restrict_to_dependencies?
       @puppet_module.has_metadata?
     end
 
     def unmet_dependencies?
       @puppet_module.unmet_dependencies.any?
     end
 
     def dependency_names
       @puppet_module.dependencies_as_modules.collect(&:name)
     end
   end
 
   # Resolves module loaders - resolution of model dependencies is done by Puppet::Module
   #
   class ModuleResolver
 
     def initialize()
       @index = {}
       @all_module_loaders = nil
     end
 
     def [](name)
       @index[name]
     end
 
     def []=(name, module_data)
       @index[name] = module_data
     end
 
     def all_module_loaders
       @all_module_loaders ||= @index.values.map {|md| md.public_loader }
     end
 
     def resolve(module_data)
       if module_data.resolved?
         return
       else
         module_data.private_loader =
           if module_data.restrict_to_dependencies?
             create_loader_with_only_dependencies_visible(module_data)
           else
             create_loader_with_all_modules_visible(module_data)
           end
       end
     end
 
     private
 
     def create_loader_with_all_modules_visible(from_module_data)
       Puppet.debug("ModuleLoader: module '#{from_module_data.name}' has unknown dependencies - it will have all other modules visible")
 
       Puppet::Pops::Loader::DependencyLoader.new(from_module_data.public_loader, from_module_data.name, all_module_loaders())
     end
 
     def create_loader_with_only_dependencies_visible(from_module_data)
       if from_module_data.unmet_dependencies?
         Puppet.warning("ModuleLoader: module '#{from_module_data.name}' has unresolved dependencies"+
           " - it will only see those that are resolved."+
           " Use 'puppet module list --tree' to see information about modules")
       end
       dependency_loaders = from_module_data.dependency_names.collect { |name| @index[name].loader }
       Puppet::Pops::Loader::DependencyLoader.new(from_module_data.public_loader, from_module_data.name, dependency_loaders)
     end
   end
 end
diff --git a/spec/unit/functions/assert_type_spec.rb b/spec/unit/functions/assert_type_spec.rb
index f4bd72162..d47f47e30 100644
--- a/spec/unit/functions/assert_type_spec.rb
+++ b/spec/unit/functions/assert_type_spec.rb
@@ -1,59 +1,59 @@
 require 'spec_helper'
 require 'puppet/pops'
 require 'puppet/loaders'
 
 describe 'the assert_type function' do
 
   after(:all) { Puppet::Pops::Loaders.clear }
 
   around(:each) do |example|
-    loaders = Puppet::Pops::Loaders.new()
+    loaders = Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, []))
     Puppet.override({:loaders => loaders}, "test-example") do
       example.run
     end
   end
 
   let(:func) do
     Puppet.lookup(:loaders).puppet_system_loader.load(:function, 'assert_type')
   end
 
   it 'asserts compliant type by returning the value' do
     expect(func.call({}, type(String), 'hello world')).to eql('hello world')
   end
 
   it 'accepts type given as a String' do
     expect(func.call({}, 'String', 'hello world')).to eql('hello world')
   end
 
   it 'asserts non compliant type by raising an error' do
     expect do
       func.call({}, type(Integer), 'hello world')
     end.to raise_error(Puppet::ParseError, /does not match actual/)
   end
 
   it 'checks that first argument is a type' do
     expect do
       func.call({}, 10, 10)
     end.to raise_error(ArgumentError, Regexp.new(Regexp.escape(
 "function 'assert_type' called with mis-matched arguments
 expected one of:
   assert_type(Type type, Optional[Object] value) - arg count {2}
   assert_type(String type_string, Optional[Object] value) - arg count {2}
 actual:
   assert_type(Integer, Integer) - arg count {2}")))
   end
 
   it 'allows the second arg to be undef/nil)' do
     expect do
       func.call({}, optional(String), nil)
     end.to_not raise_error(ArgumentError)
   end
 
   def optional(type_ref)
     Puppet::Pops::Types::TypeFactory.optional(type(type_ref))
   end
 
   def type(type_ref)
     Puppet::Pops::Types::TypeFactory.type_of(type_ref)
   end
 end
diff --git a/spec/unit/functions4_spec.rb b/spec/unit/functions4_spec.rb
index 9c82e98f4..a5404cc1e 100644
--- a/spec/unit/functions4_spec.rb
+++ b/spec/unit/functions4_spec.rb
@@ -1,671 +1,671 @@
 require 'spec_helper'
 require 'puppet/pops'
 require 'puppet/loaders'
 require 'puppet_spec/pops'
 require 'puppet_spec/scope'
 
 module FunctionAPISpecModule
   class TestDuck
   end
 
   class TestFunctionLoader < Puppet::Pops::Loader::StaticLoader
     def initialize
       @functions = {}
     end
 
     def add_function(name, function)
       typed_name = Puppet::Pops::Loader::Loader::TypedName.new(:function, name)
       entry = Puppet::Pops::Loader::Loader::NamedEntry.new(typed_name, function, __FILE__)
       @functions[typed_name] = entry
     end
 
     # override StaticLoader
     def load_constant(typed_name)
       @functions[typed_name]
     end
   end
 end
 
 describe 'the 4x function api' do
   include FunctionAPISpecModule
   include PuppetSpec::Pops
   include PuppetSpec::Scope
 
   let(:loader) { FunctionAPISpecModule::TestFunctionLoader.new }
 
   it 'allows a simple function to be created without dispatch declaration' do
     f = Puppet::Functions.create_function('min') do
       def min(x,y)
         x <= y ? x : y
       end
     end
 
     # the produced result is a Class inheriting from Function
     expect(f.class).to be(Class)
     expect(f.superclass).to be(Puppet::Functions::Function)
     # and this class had the given name (not a real Ruby class name)
     expect(f.name).to eql('min')
   end
 
   it 'refuses to create functions that are not based on the Function class' do
     expect do
       Puppet::Functions.create_function('testing', Object) {}
     end.to raise_error(ArgumentError, 'Functions must be based on Puppet::Pops::Functions::Function. Got Object')
   end
 
   it 'a function without arguments can be defined and called without dispatch declaration' do
     f = create_noargs_function_class()
     func = f.new(:closure_scope, :loader)
     expect(func.call({})).to eql(10)
   end
 
   it 'an error is raised when calling a no arguments function with arguments' do
     f = create_noargs_function_class()
     func = f.new(:closure_scope, :loader)
     expect{func.call({}, 'surprise')}.to raise_error(ArgumentError, "function 'test' called with mis-matched arguments
 expected:
   test() - arg count {0}
 actual:
   test(String) - arg count {1}")
   end
 
   it 'a simple function can be called' do
     f = create_min_function_class()
     # TODO: Bogus parameters, not yet used
     func = f.new(:closure_scope, :loader)
     expect(func.is_a?(Puppet::Functions::Function)).to be_true
     expect(func.call({}, 10,20)).to eql(10)
   end
 
   it 'an error is raised if called with too few arguments' do
     f = create_min_function_class()
     # TODO: Bogus parameters, not yet used
     func = f.new(:closure_scope, :loader)
     expect(func.is_a?(Puppet::Functions::Function)).to be_true
     signature = if RUBY_VERSION =~ /^1\.8/
       'Object{2}'
     else
       'Object x, Object y'
     end
     expect do
       func.call({}, 10)
     end.to raise_error(ArgumentError, "function 'min' called with mis-matched arguments
 expected:
   min(#{signature}) - arg count {2}
 actual:
   min(Integer) - arg count {1}")
   end
 
   it 'an error is raised if called with too many arguments' do
     f = create_min_function_class()
     # TODO: Bogus parameters, not yet used
     func = f.new(:closure_scope, :loader)
     expect(func.is_a?(Puppet::Functions::Function)).to be_true
     signature = if RUBY_VERSION =~ /^1\.8/
       'Object{2}'
     else
       'Object x, Object y'
     end
     expect do
       func.call({}, 10, 10, 10)
     end.to raise_error(ArgumentError, Regexp.new(Regexp.escape(
 "function 'min' called with mis-matched arguments
 expected:
   min(#{signature}) - arg count {2}
 actual:
   min(Integer, Integer, Integer) - arg count {3}")))
   end
 
   it 'an error is raised if simple function-name and method are not matched' do
     expect do
       f = create_badly_named_method_function_class()
     end.to raise_error(ArgumentError, /Function Creation Error, cannot create a default dispatcher for function 'mix', no method with this name found/)
   end
 
   it 'the implementation separates dispatchers for different functions' do
     # this tests that meta programming / construction puts class attributes in the correct class
     f1 = create_min_function_class()
     f2 = create_max_function_class()
 
     d1 = f1.dispatcher
     d2 = f2.dispatcher
 
     expect(d1).to_not eql(d2)
     expect(d1.dispatchers[0]).to_not eql(d2.dispatchers[0])
   end
 
   context 'when using regular dispatch' do
     it 'a function can be created using dispatch and called' do
       f = create_min_function_class_using_dispatch()
       func = f.new(:closure_scope, :loader)
       expect(func.call({}, 3,4)).to eql(3)
     end
 
     it 'an error is raised with reference to given parameter names when called with mis-matched arguments' do
       f = create_min_function_class_using_dispatch()
       # TODO: Bogus parameters, not yet used
       func = f.new(:closure_scope, :loader)
       expect(func.is_a?(Puppet::Functions::Function)).to be_true
       expect do
         func.call({}, 10, 10, 10)
       end.to raise_error(ArgumentError, Regexp.new(Regexp.escape(
 "function 'min' called with mis-matched arguments
 expected:
   min(Numeric a, Numeric b) - arg count {2}
 actual:
   min(Integer, Integer, Integer) - arg count {3}")))
     end
 
     it 'an error includes optional indicators and count for last element' do
       f = create_function_with_optionals_and_varargs()
       # TODO: Bogus parameters, not yet used
       func = f.new(:closure_scope, :loader)
       expect(func.is_a?(Puppet::Functions::Function)).to be_true
       signature = if RUBY_VERSION =~ /^1\.8/
         'Object{2,}'
       else
         'Object x, Object y, Object a?, Object b?, Object c{0,}'
       end
       expect do
         func.call({}, 10)
       end.to raise_error(ArgumentError,
 "function 'min' called with mis-matched arguments
 expected:
   min(#{signature}) - arg count {2,}
 actual:
   min(Integer) - arg count {1}")
     end
 
     it 'an error includes optional indicators and count for last element when defined via dispatch' do
       f = create_function_with_optionals_and_varargs_via_dispatch()
       # TODO: Bogus parameters, not yet used
       func = f.new(:closure_scope, :loader)
       expect(func.is_a?(Puppet::Functions::Function)).to be_true
       expect do
         func.call({}, 10)
       end.to raise_error(ArgumentError,
 "function 'min' called with mis-matched arguments
 expected:
   min(Numeric x, Numeric y, Numeric a?, Numeric b?, Numeric c{0,}) - arg count {2,}
 actual:
   min(Integer) - arg count {1}")
     end
 
     it 'a function can be created using dispatch and called' do
       f = create_min_function_class_disptaching_to_two_methods()
       func = f.new(:closure_scope, :loader)
       expect(func.call({}, 3,4)).to eql(3)
       expect(func.call({}, 'Apple', 'Banana')).to eql('Apple')
     end
 
     it 'an error is raised with reference to multiple methods when called with mis-matched arguments' do
       f = create_min_function_class_disptaching_to_two_methods()
       # TODO: Bogus parameters, not yet used
       func = f.new(:closure_scope, :loader)
       expect(func.is_a?(Puppet::Functions::Function)).to be_true
       expect do
         func.call({}, 10, 10, 10)
       end.to raise_error(ArgumentError,
 "function 'min' called with mis-matched arguments
 expected one of:
   min(Numeric a, Numeric b) - arg count {2}
   min(String s1, String s2) - arg count {2}
 actual:
   min(Integer, Integer, Integer) - arg count {3}")
     end
 
     context 'can use injection' do
       before :all do
         injector = Puppet::Pops::Binder::Injector.create('test') do
           bind.name('a_string').to('evoe')
           bind.name('an_int').to(42)
         end
         Puppet.push_context({:injector => injector}, "injector for testing function API")
       end
 
       after :all do
         Puppet.pop_context()
       end
 
       it 'attributes can be injected' do
         f1 = create_function_with_class_injection()
         f = f1.new(:closure_scope, :loader)
         expect(f.test_attr2()).to eql("evoe")
         expect(f.serial().produce(nil)).to eql(42)
         expect(f.test_attr().class.name).to eql("FunctionAPISpecModule::TestDuck")
       end
 
       it 'parameters can be injected and woven with regular dispatch' do
         f1 = create_function_with_param_injection_regular()
         f = f1.new(:closure_scope, :loader)
         expect(f.call(nil, 10, 20)).to eql("evoe! 10, and 20 < 42 = true")
         expect(f.call(nil, 50, 20)).to eql("evoe! 50, and 20 < 42 = false")
       end
     end
 
     context 'when requesting a type' do
       it 'responds with a Callable for a single signature' do
         tf = Puppet::Pops::Types::TypeFactory
         fc = create_min_function_class_using_dispatch()
         t = fc.dispatcher.to_type
         expect(t.class).to be(Puppet::Pops::Types::PCallableType)
         expect(t.param_types.class).to be(Puppet::Pops::Types::PTupleType)
         expect(t.param_types.types).to eql([tf.numeric(), tf.numeric()])
         expect(t.block_type).to be_nil
       end
 
       it 'responds with a Variant[Callable...] for multiple signatures' do
         tf = Puppet::Pops::Types::TypeFactory
         fc = create_min_function_class_disptaching_to_two_methods()
         t = fc.dispatcher.to_type
         expect(t.class).to be(Puppet::Pops::Types::PVariantType)
         expect(t.types.size).to eql(2)
         t1 = t.types[0]
         expect(t1.param_types.class).to be(Puppet::Pops::Types::PTupleType)
         expect(t1.param_types.types).to eql([tf.numeric(), tf.numeric()])
         expect(t1.block_type).to be_nil
         t2 = t.types[1]
         expect(t2.param_types.class).to be(Puppet::Pops::Types::PTupleType)
         expect(t2.param_types.types).to eql([tf.string(), tf.string()])
         expect(t2.block_type).to be_nil
       end
     end
 
     context 'supports lambdas' do
       it 'such that, a required block can be defined and given as an argument' do
         # use a Function as callable
         the_callable = create_min_function_class().new(:closure_scope, :loader)
         the_function = create_function_with_required_block_all_defaults().new(:closure_scope, :loader)
         result = the_function.call({}, 10, the_callable)
         expect(result).to be(the_callable)
       end
 
       it 'such that, a missing required block when called raises an error' do
         # use a Function as callable
         the_function = create_function_with_required_block_all_defaults().new(:closure_scope, :loader)
         expect do
           the_function.call({}, 10)
         end.to raise_error(ArgumentError,
 "function 'test' called with mis-matched arguments
 expected:
   test(Integer x, Callable block) - arg count {2}
 actual:
   test(Integer) - arg count {1}")
       end
 
       it 'such that, an optional block can be defined and given as an argument' do
         # use a Function as callable
         the_callable = create_min_function_class().new(:closure_scope, :loader)
         the_function = create_function_with_optional_block_all_defaults().new(:closure_scope, :loader)
         result = the_function.call({}, 10, the_callable)
         expect(result).to be(the_callable)
       end
 
       it 'such that, an optional block can be omitted when called and gets the value nil' do
         # use a Function as callable
         the_function = create_function_with_optional_block_all_defaults().new(:closure_scope, :loader)
         expect(the_function.call({}, 10)).to be_nil
       end
     end
 
     context 'provides signature information' do
       it 'about capture rest (varargs)' do
         fc = create_function_with_optionals_and_varargs
         signatures = fc.signatures
         expect(signatures.size).to eql(1)
         signature = signatures[0]
         expect(signature.last_captures_rest?).to be_true
       end
 
       it 'about optional and required parameters' do
         fc = create_function_with_optionals_and_varargs
         signature = fc.signatures[0]
         expect(signature.args_range).to eql( [2, Puppet::Pops::Types::INFINITY ] )
         expect(signature.infinity?(signature.args_range[1])).to be_true
       end
 
       it 'about block not being allowed' do
         fc = create_function_with_optionals_and_varargs
         signature = fc.signatures[0]
         expect(signature.block_range).to eql( [ 0, 0 ] )
         expect(signature.block_type).to be_nil
       end
 
       it 'about required block' do
         fc = create_function_with_required_block_all_defaults
         signature = fc.signatures[0]
         expect(signature.block_range).to eql( [ 1, 1 ] )
         expect(signature.block_type).to_not be_nil
       end
 
       it 'about optional block' do
         fc = create_function_with_optional_block_all_defaults
         signature = fc.signatures[0]
         expect(signature.block_range).to eql( [ 0, 1 ] )
         expect(signature.block_type).to_not be_nil
       end
 
       it 'about the type' do
         fc = create_function_with_optional_block_all_defaults
         signature = fc.signatures[0]
         expect(signature.type.class).to be(Puppet::Pops::Types::PCallableType)
       end
 
       # conditional on Ruby 1.8.7 which does not do parameter introspection
       if Method.method_defined?(:parameters)
         it 'about parameter names obtained from ruby introspection' do
           fc = create_min_function_class
           signature = fc.signatures[0]
           expect(signature.parameter_names).to eql(['x', 'y'])
         end
       end
 
       it 'about parameter names specified with dispatch' do
         fc = create_min_function_class_using_dispatch
         signature = fc.signatures[0]
         expect(signature.parameter_names).to eql(['a', 'b'])
       end
 
       it 'about block_name when it is *not* given in the definition' do
         # neither type, nor name
         fc = create_function_with_required_block_all_defaults
         signature = fc.signatures[0]
         expect(signature.block_name).to eql('block')
         # no name given, only type
         fc = create_function_with_required_block_given_type
         signature = fc.signatures[0]
         expect(signature.block_name).to eql('block')
       end
 
       it 'about block_name when it *is* given in the definition' do
         # neither type, nor name
         fc = create_function_with_required_block_default_type
         signature = fc.signatures[0]
         expect(signature.block_name).to eql('the_block')
         # no name given, only type
         fc = create_function_with_required_block_fully_specified
         signature = fc.signatures[0]
         expect(signature.block_name).to eql('the_block')
       end
     end
 
     context 'supports calling other functions' do
       before(:all) do
-        Puppet.push_context( {:loaders => Puppet::Pops::Loaders.new()})
+        Puppet.push_context( {:loaders => Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, []))})
       end
 
       after(:all) do
         Puppet.pop_context()
       end
 
       it 'such that, other functions are callable by name' do
         fc = Puppet::Functions.create_function(:test) do
           def test()
             # Call a function available in the puppet system
             call_function('assert_type', 'Integer', 10)
           end
         end
         # initiate the function the same way the loader initiates it
         f = fc.new(:closure_scope, Puppet.lookup(:loaders).puppet_system_loader)
         expect(f.call({})).to eql(10)
       end
 
       it 'such that, calling a non existing function raises an error' do
         fc = Puppet::Functions.create_function(:test) do
           def test()
             # Call a function not available in the puppet system
             call_function('no_such_function', 'Integer', 'hello')
           end
         end
         # initiate the function the same way the loader initiates it
         f = fc.new(:closure_scope, Puppet.lookup(:loaders).puppet_system_loader)
         expect{f.call({})}.to raise_error(ArgumentError, "Function test(): cannot call function 'no_such_function' - not found")
       end
     end
 
     context 'supports calling ruby functions with lambda from puppet' do
       before(:all) do
-        Puppet.push_context( {:loaders => Puppet::Pops::Loaders.new()})
+        Puppet.push_context( {:loaders => Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, []))})
       end
 
       after(:all) do
         Puppet.pop_context()
       end
 
       before(:each) do
         Puppet[:strict_variables] = true
 
         # These must be set since the is 3x logic that triggers on these even if the tests are explicit
         # about selection of parser and evaluator
         #
         Puppet[:parser] = 'future'
         Puppet[:evaluator] = 'future'
         # Puppetx cannot be loaded until the correct parser has been set (injector is turned off otherwise)
         require 'puppetx'
       end
 
       let(:parser) {  Puppet::Pops::Parser::EvaluatingParser::Transitional.new }
       let(:node) { 'node.example.com' }
       let(:scope) { s = create_test_scope_for_node(node); s }
 
       it 'function with required block can be called' do
         # construct ruby function to call
         fc = Puppet::Functions.create_function('testing::test') do
           dispatch :test do
             param 'Integer', 'x'
             # block called 'the_block', and using "all_callables"
             required_block_param #(all_callables(), 'the_block')
           end
           def test(x, block)
             # call the block with x
             block.call(closure_scope, x)
           end
         end
         # add the function to the loader (as if it had been loaded from somewhere)
         the_loader = loader()
         f = fc.new({}, the_loader)
         loader.add_function('testing::test', f)
         # evaluate a puppet call
         source = "testing::test(10) |$x| { $x+1 }"
         program = parser.parse_string(source, __FILE__)
         Puppet::Pops::Adapters::LoaderAdapter.adapt(program.model).loader = the_loader
         expect(parser.evaluate(scope, program)).to eql(11)
       end
     end
 
   end
 
   def create_noargs_function_class
     f = Puppet::Functions.create_function('test') do
       def test()
         10
       end
     end
   end
 
   def create_min_function_class
     f = Puppet::Functions.create_function('min') do
       def min(x,y)
         x <= y ? x : y
       end
     end
   end
 
   def create_max_function_class
     f = Puppet::Functions.create_function('max') do
       def max(x,y)
         x >= y ? x : y
       end
     end
   end
 
   def create_badly_named_method_function_class
     f = Puppet::Functions.create_function('mix') do
       def mix_up(x,y)
         x <= y ? x : y
       end
     end
   end
 
   def create_min_function_class_using_dispatch
     f = Puppet::Functions.create_function('min') do
         dispatch :min do
           param 'Numeric', 'a'
           param 'Numeric', 'b'
         end
       def min(x,y)
         x <= y ? x : y
       end
     end
   end
 
   def create_min_function_class_disptaching_to_two_methods
     f = Puppet::Functions.create_function('min') do
       dispatch :min do
         param 'Numeric', 'a'
         param 'Numeric', 'b'
       end
 
       dispatch :min_s do
         param 'String', 's1'
         param 'String', 's2'
       end
 
       def min(x,y)
         x <= y ? x : y
       end
 
       def min_s(x,y)
         cmp = (x.downcase <=> y.downcase)
         cmp <= 0 ? x : y
       end
     end
   end
 
   def create_function_with_optionals_and_varargs
     f = Puppet::Functions.create_function('min') do
       def min(x,y,a=1, b=1, *c)
         x <= y ? x : y
       end
     end
   end
 
   def create_function_with_optionals_and_varargs_via_dispatch
     f = Puppet::Functions.create_function('min') do
       dispatch :min do
         param 'Numeric', 'x'
         param 'Numeric', 'y'
         param 'Numeric', 'a'
         param 'Numeric', 'b'
         param 'Numeric', 'c'
         arg_count 2, :default
       end
       def min(x,y,a=1, b=1, *c)
         x <= y ? x : y
       end
     end
   end
 
   def create_function_with_class_injection
     f = Puppet::Functions.create_function('test', Puppet::Functions::InternalFunction) do
       attr_injected Puppet::Pops::Types::TypeFactory.type_of(FunctionAPISpecModule::TestDuck), :test_attr
       attr_injected Puppet::Pops::Types::TypeFactory.string(), :test_attr2, "a_string"
       attr_injected_producer Puppet::Pops::Types::TypeFactory.integer(), :serial, "an_int"
 
       def test(x,y,a=1, b=1, *c)
         x <= y ? x : y
       end
     end
   end
 
   def create_function_with_param_injection_regular
     f = Puppet::Functions.create_function('test', Puppet::Functions::InternalFunction) do
       attr_injected Puppet::Pops::Types::TypeFactory.type_of(FunctionAPISpecModule::TestDuck), :test_attr
       attr_injected Puppet::Pops::Types::TypeFactory.string(), :test_attr2, "a_string"
       attr_injected_producer Puppet::Pops::Types::TypeFactory.integer(), :serial, "an_int"
 
       dispatch :test do
         injected_param Puppet::Pops::Types::TypeFactory.string, 'x', 'a_string'
         injected_producer_param Puppet::Pops::Types::TypeFactory.integer, 'y', 'an_int'
         param 'Scalar', 'a'
         param 'Scalar', 'b'
       end
 
       def test(x,y,a,b)
         y_produced = y.produce(nil)
         "#{x}! #{a}, and #{b} < #{y_produced} = #{ !!(a < y_produced && b < y_produced)}"
       end
     end
   end
 
   def create_function_with_required_block_all_defaults
     f = Puppet::Functions.create_function('test') do
       dispatch :test do
         param 'Integer', 'x'
         # use defaults, any callable, name is 'block'
         required_block_param
       end
       def test(x, block)
         # returns the block to make it easy to test what it got when called
         block
       end
     end
   end
 
   def create_function_with_required_block_default_type
     f = Puppet::Functions.create_function('test') do
       dispatch :test do
         param 'Integer', 'x'
         # use defaults, any callable, name is 'block'
         required_block_param 'the_block'
       end
       def test(x, block)
         # returns the block to make it easy to test what it got when called
         block
       end
     end
   end
 
   def create_function_with_required_block_given_type
     f = Puppet::Functions.create_function('test') do
       dispatch :test do
         param 'Integer', 'x'
         required_block_param
       end
       def test(x, block)
         # returns the block to make it easy to test what it got when called
         block
       end
     end
   end
 
   def create_function_with_required_block_fully_specified
     f = Puppet::Functions.create_function('test') do
       dispatch :test do
         param 'Integer', 'x'
         # use defaults, any callable, name is 'block'
         required_block_param('Callable', 'the_block')
       end
       def test(x, block)
         # returns the block to make it easy to test what it got when called
         block
       end
     end
   end
 
   def create_function_with_optional_block_all_defaults
     f = Puppet::Functions.create_function('test') do
       dispatch :test do
         param 'Integer', 'x'
         # use defaults, any callable, name is 'block'
         optional_block_param
       end
       def test(x, block=nil)
         # returns the block to make it easy to test what it got when called
         # a default of nil must be used or the call will fail with a missing parameter
         block
       end
     end
   end
 
 end
diff --git a/spec/unit/pops/loaders/dependency_loader_spec.rb b/spec/unit/pops/loaders/dependency_loader_spec.rb
index 9f6dc90fd..ca396b837 100644
--- a/spec/unit/pops/loaders/dependency_loader_spec.rb
+++ b/spec/unit/pops/loaders/dependency_loader_spec.rb
@@ -1,51 +1,50 @@
 require 'spec_helper'
 require 'puppet_spec/files'
 require 'puppet/pops'
 require 'puppet/loaders'
 
 describe 'dependency loader' do
   include PuppetSpec::Files
 
   let(:static_loader) { Puppet::Pops::Loader::StaticLoader.new() }
 
-
   describe 'FileBased module loader' do
     around(:each) do |example|
-      loaders = Puppet::Pops::Loaders.new()
+      loaders = Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, []))
       Puppet.override({:loaders => loaders}, "test-example") do
         example.run
       end
     end
 
     it 'load something in global name space raises an error' do
       module_dir = dir_containing('testmodule', {
       'lib' => { 'puppet' => { 'functions' => { 'testmodule' => {
         'foo.rb' => 'Puppet::Functions.create_function("foo") { def foo; end; }'
       }}}}})
 
       module_loader = Puppet::Pops::Loader::ModuleLoaders::FileBased.new(static_loader, 'testmodule', module_dir, 'test1')
       dep_loader = Puppet::Pops::Loader::DependencyLoader.new(static_loader, 'test-dep', [module_loader])
       expect do
         dep_loader.load_typed(typed_name(:function, 'testmodule::foo')).value
       end.to raise_error(ArgumentError, /produced mis-matched name, expected 'testmodule::foo', got foo/)
     end
 
     it 'can load something in a qualified name space' do
       module_dir = dir_containing('testmodule', {
       'lib' => { 'puppet' => { 'functions' => { 'testmodule' => {
         'foo.rb' => 'Puppet::Functions.create_function("testmodule::foo") { def foo; end; }'
       }}}}})
       module_loader = Puppet::Pops::Loader::ModuleLoaders::FileBased.new(static_loader, 'testmodule', module_dir, 'test1')
       dep_loader = Puppet::Pops::Loader::DependencyLoader.new(static_loader, 'test-dep', [module_loader])
 
       function = dep_loader.load_typed(typed_name(:function, 'testmodule::foo')).value
 
       expect(function.class.name).to eq('testmodule::foo')
       expect(function.is_a?(Puppet::Functions::Function)).to eq(true)
     end
   end
 
   def typed_name(type, name)
     Puppet::Pops::Loader::Loader::TypedName.new(type, name)
   end
 end
diff --git a/spec/unit/pops/loaders/loaders_spec.rb b/spec/unit/pops/loaders/loaders_spec.rb
index 810bb59dd..86ab3a440 100644
--- a/spec/unit/pops/loaders/loaders_spec.rb
+++ b/spec/unit/pops/loaders/loaders_spec.rb
@@ -1,133 +1,112 @@
 require 'spec_helper'
 require 'puppet_spec/files'
 
 require 'puppet/pops'
 require 'puppet/loaders'
 
 describe 'loaders' do
   include PuppetSpec::Files
 
+  let(:empty_test_env) { Puppet::Node::Environment.create(:testing, []) }
+
   def config_dir(config_name)
     my_fixture(config_name)
   end
 
   # Loaders caches the puppet_system_loader, must reset between tests
   #
   before(:each) { Puppet::Pops::Loaders.clear() }
 
   it 'creates a puppet_system loader' do
-    loaders = Puppet::Pops::Loaders.new()
+    loaders = Puppet::Pops::Loaders.new(empty_test_env)
     expect(loaders.puppet_system_loader().class).to be(Puppet::Pops::Loader::ModuleLoaders::FileBased)
   end
 
   it 'creates an environment loader' do
-    loaders = Puppet::Pops::Loaders.new()
-    # When this test is running, there is no environments dir configured, and a NullLoader is therefore used a.t.m
-    expect(loaders.public_environment_loader().class).to be(Puppet::Pops::Loader::SimpleEnvironmentLoader)
-    # The default name of the enironment is '*root*', and the loader should identify itself that way
-    expect(loaders.public_environment_loader().to_s).to eql("(SimpleEnvironmentLoader 'environment:*root*')")
+    loaders = Puppet::Pops::Loaders.new(empty_test_env)
 
+    expect(loaders.public_environment_loader().class).to be(Puppet::Pops::Loader::SimpleEnvironmentLoader)
+    expect(loaders.public_environment_loader().to_s).to eql("(SimpleEnvironmentLoader 'environment:testing')")
     expect(loaders.private_environment_loader().class).to be(Puppet::Pops::Loader::DependencyLoader)
     expect(loaders.private_environment_loader().to_s).to eql("(DependencyLoader 'environment' [])")
   end
 
   context 'when delegating 3x to 4x' do
     before(:each) { Puppet[:biff] = true }
 
     it 'the puppet system loader can load 3x functions' do
-      loaders = Puppet::Pops::Loaders.new()
+      loaders = Puppet::Pops::Loaders.new(empty_test_env)
       puppet_loader = loaders.puppet_system_loader()
       function = puppet_loader.load_typed(typed_name(:function, 'sprintf')).value
       expect(function.class.name).to eq('sprintf')
       expect(function.is_a?(Puppet::Functions::Function)).to eq(true)
     end
   end
 
   context 'loading from path with single module' do
-    before do
-      env = Puppet::Node::Environment.create(:'*test*', [File.join(config_dir('single_module'), 'modules')], '')
-      overrides = {
-        :current_environment => env
-      }
-      Puppet.push_context(overrides, "single-module-test-loaders")
-    end
-
-    after do
-      Puppet.pop_context()
-    end
+    let(:env) { Puppet::Node::Environment.create(:'*test*', [File.join(config_dir('single_module'), 'modules')], '') }
 
     it 'can load from a module path' do
-      loaders = Puppet::Pops::Loaders.new()
+      loaders = Puppet::Pops::Loaders.new(env)
       Puppet.override({:loaders => loaders}, 'testcase') do
         modulea_loader = loaders.public_loader_for_module('modulea')
         expect(modulea_loader.class).to eql(Puppet::Pops::Loader::ModuleLoaders::FileBased)
 
         function = modulea_loader.load_typed(typed_name(:function, 'rb_func_a')).value
         expect(function.is_a?(Puppet::Functions::Function)).to eq(true)
         expect(function.class.name).to eq('rb_func_a')
 
         function = modulea_loader.load_typed(typed_name(:function, 'modulea::rb_func_a')).value
         expect(function.is_a?(Puppet::Functions::Function)).to eq(true)
         expect(function.class.name).to eq('modulea::rb_func_a')
       end
     end
   end
 
   context 'loading from path with two module, one without meta-data' do
-    before do
-      module_path = [File.join(config_dir('single_module'), 'modules'), File.join(config_dir('wo_metadata_module'), 'modules')]
-      env = Puppet::Node::Environment.create(:'*test*', module_path, '')
-      overrides = {
-        :current_environment => env,
-      }
-      Puppet.push_context(overrides, "two-modules-test-loaders")
-    end
-
-    after do
-      Puppet.pop_context()
-    end
+    let(:env) { Puppet::Node::Environment.create(:'*test*', [File.join(config_dir('single_module'), 'modules'), File.join(config_dir('wo_metadata_module'), 'modules')], '')}
 
     it 'can load from module with metadata' do
-      loaders = Puppet::Pops::Loaders.new
+      loaders = Puppet::Pops::Loaders.new(env)
       Puppet.override({:loaders => loaders}, 'testcase') do
         modulea_loader = loaders.public_loader_for_module('modulea')
         expect(modulea_loader.class).to eql(Puppet::Pops::Loader::ModuleLoaders::FileBased)
 
         function = modulea_loader.load_typed(typed_name(:function, 'rb_func_a')).value
         expect(function.is_a?(Puppet::Functions::Function)).to eq(true)
         expect(function.class.name).to eq('rb_func_a')
 
         function = modulea_loader.load_typed(typed_name(:function, 'modulea::rb_func_a')).value
         expect(function.is_a?(Puppet::Functions::Function)).to eq(true)
         expect(function.class.name).to eq('modulea::rb_func_a')
       end
     end
 
     it 'can load from module with metadata' do
-      loaders = Puppet::Pops::Loaders.new
+      loaders = Puppet::Pops::Loaders.new(env)
       Puppet.override({:loaders => loaders}, 'testcase') do
         moduleb_loader = loaders.public_loader_for_module('moduleb')
         expect(moduleb_loader.class).to eql(Puppet::Pops::Loader::ModuleLoaders::FileBased)
 
         function = moduleb_loader.load_typed(typed_name(:function, 'moduleb::rb_func_b')).value
         expect(function.is_a?(Puppet::Functions::Function)).to eq(true)
         expect(function.class.name).to eq('moduleb::rb_func_b')
       end
     end
 
     it 'module without metadata has all modules visible' do
-      loaders = Puppet::Pops::Loaders.new
+      loaders = Puppet::Pops::Loaders.new(env)
       Puppet.override({:loaders => loaders}, 'testcase') do
         moduleb_loader = loaders.private_loader_for_module('moduleb')
 
         function = moduleb_loader.load_typed(typed_name(:function, 'moduleb::rb_func_b')).value
         result = function.call({})
         expect(result).to eql("I am modulea::rb_func_a() + I am moduleb::rb_func_b()")
       end
     end
   end
 
   def typed_name(type, name)
     Puppet::Pops::Loader::Loader::TypedName.new(type, name)
   end
 end
diff --git a/spec/unit/pops/loaders/module_loaders_spec.rb b/spec/unit/pops/loaders/module_loaders_spec.rb
index a5eba200c..8a2b5c600 100644
--- a/spec/unit/pops/loaders/module_loaders_spec.rb
+++ b/spec/unit/pops/loaders/module_loaders_spec.rb
@@ -1,124 +1,125 @@
 require 'spec_helper'
 require 'puppet_spec/files'
 require 'puppet/pops'
 require 'puppet/loaders'
 
 describe 'FileBased module loader' do
   include PuppetSpec::Files
 
   let(:static_loader) { Puppet::Pops::Loader::StaticLoader.new() }
+
   around(:each) do |example|
-    loaders = Puppet::Pops::Loaders.new()
+    loaders = Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, []))
     Puppet.override({:loaders => loaders}, "test-example") do
       example.run
     end
   end
 
   it 'can load a 4x function API ruby function in global name space' do
     module_dir = dir_containing('testmodule', {
       'lib' => {
         'puppet' => {
           'functions' => {
             'foo4x.rb' => <<-CODE
                Puppet::Functions.create_function(:foo4x) do
                  def foo4x()
                    'yay'
                  end
                end
             CODE
           }
             }
           }
         })
 
     module_loader = Puppet::Pops::Loader::ModuleLoaders::FileBased.new(static_loader, 'testmodule', module_dir, 'test1')
     function = module_loader.load_typed(typed_name(:function, 'foo4x')).value
     expect(function.class.name).to eq('foo4x')
     expect(function.is_a?(Puppet::Functions::Function)).to eq(true)
   end
 
   it 'can load a 4x function API ruby function in qualified name space' do
     module_dir = dir_containing('testmodule', {
       'lib' => {
         'puppet' => {
           'functions' => {
             'testmodule' => {
               'foo4x.rb' => <<-CODE
                  Puppet::Functions.create_function('testmodule::foo4x') do
                    def foo4x()
                      'yay'
                    end
                  end
               CODE
               }
             }
           }
       }})
 
     module_loader = Puppet::Pops::Loader::ModuleLoaders::FileBased.new(static_loader, 'testmodule', module_dir, 'test1')
     function = module_loader.load_typed(typed_name(:function, 'testmodule::foo4x')).value
     expect(function.class.name).to eq('testmodule::foo4x')
     expect(function.is_a?(Puppet::Functions::Function)).to eq(true)
   end
 
   it 'makes parent loader win over entries in child' do
     module_dir = dir_containing('testmodule', {
       'lib' => { 'puppet' => { 'functions' => { 'testmodule' => {
         'foo.rb' => <<-CODE
            Puppet::Functions.create_function('testmodule::foo') do
              def foo()
                'yay'
              end
            end
         CODE
       }}}}})
     module_loader = Puppet::Pops::Loader::ModuleLoaders::FileBased.new(static_loader, 'testmodule', module_dir, 'test1')
 
     module_dir2 = dir_containing('testmodule2', {
       'lib' => { 'puppet' => { 'functions' => { 'testmodule2' => {
         'foo.rb' => <<-CODE
            raise "should not get here"
         CODE
       }}}}})
     module_loader2 = Puppet::Pops::Loader::ModuleLoaders::FileBased.new(module_loader, 'testmodule2', module_dir2, 'test2')
 
     function = module_loader2.load_typed(typed_name(:function, 'testmodule::foo')).value
 
     expect(function.class.name).to eq('testmodule::foo')
     expect(function.is_a?(Puppet::Functions::Function)).to eq(true)
   end
 
   context 'when delegating 3x to 4x' do
     before(:each) { Puppet[:biff] = true }
 
     it 'can load a 3x function API ruby function in global name space' do
       module_dir = dir_containing('testmodule', {
         'lib' => {
           'puppet' => {
             'parser' => {
               'functions' => {
                 'foo3x.rb' => <<-CODE
                   Puppet::Parser::Functions::newfunction(
                     :foo3x, :type => :rvalue,
                     :arity => 1
                   ) do |args|
                     args[0]
                   end
                 CODE
               }
               }
             }
         }})
 
      module_loader = Puppet::Pops::Loader::ModuleLoaders::FileBased.new(static_loader, 'testmodule', module_dir, 'test1')
      function = module_loader.load_typed(typed_name(:function, 'foo3x')).value
      expect(function.class.name).to eq('foo3x')
      expect(function.is_a?(Puppet::Functions::Function)).to eq(true)
     end
   end
 
 
   def typed_name(type, name)
     Puppet::Pops::Loader::Loader::TypedName.new(type, name)
   end
 end