diff --git a/lib/puppet/metatype/manager.rb b/lib/puppet/metatype/manager.rb
index af1379f0b..0cf1669f8 100644
--- a/lib/puppet/metatype/manager.rb
+++ b/lib/puppet/metatype/manager.rb
@@ -1,184 +1,184 @@
 require 'puppet'
 require 'puppet/util/classgen'
 require 'puppet/node/environment'
 
 # This module defines methods dealing with Type management.
 # This module gets included into the Puppet::Type class, it's just split out here for clarity.
 # @api public
 #
 module Puppet::MetaType
 module Manager
   include Puppet::Util::ClassGen
 
   # An implementation specific method that removes all type instances during testing.
   # @note Only use this method for testing purposes.
   # @api private
   #
   def allclear
     @types.each { |name, type|
       type.clear
     }
   end
 
   # Iterates over all already loaded Type subclasses.
   # @yield [t] a block receiving each type
   # @yieldparam t [Puppet::Type] each defined type
   # @yieldreturn [Object] the last returned object is also returned from this method
   # @return [Object] the last returned value from the block.
   def eachtype
     @types.each do |name, type|
       # Only consider types that have names
       #if ! type.parameters.empty? or ! type.validproperties.empty?
         yield type
       #end
     end
   end
 
   # Loads all types.
   # @note Should only be used for purposes such as generating documentation as this is potentially a very
   #  expensive operation.
   # @return [void]
   #
   def loadall
     typeloader.loadall
   end
 
   # Defines a new type or redefines an existing type with the given name.
   # A convenience method on the form `new<name>` where name is the name of the type is also created.
   # (If this generated method happens to clash with an existing method, a warning is issued and the original
   # method is kept).
   #
   # @param name [String] the name of the type to create or redefine.
   # @param options [Hash] options passed on to {Puppet::Util::ClassGen#genclass} as the option `:attributes`.
   # @option options [Puppet::Type]
   #   Puppet::Type. This option is not passed on as an attribute to genclass.
   # @yield [ ] a block evaluated in the context of the created class, thus allowing further detailing of
   #   that class.
   # @return [Class<inherits Puppet::Type>] the created subclass
   # @see Puppet::Util::ClassGen.genclass
   #
   # @dsl type
   # @api public
   def newtype(name, options = {}, &block)
     # Handle backward compatibility
     unless options.is_a?(Hash)
       Puppet.warning "Puppet::Type.newtype(#{name}) now expects a hash as the second argument, not #{options.inspect}"
     end
 
     # First make sure we don't have a method sitting around
     name = name.intern
     newmethod = "new#{name}"
 
     # Used for method manipulation.
     selfobj = singleton_class
 
     @types ||= {}
 
     if @types.include?(name)
       if self.respond_to?(newmethod)
         # Remove the old newmethod
         selfobj.send(:remove_method,newmethod)
       end
     end
 
     options = symbolize_options(options)
 
 
     if options.include?(:parent) 
       Puppet.deprecation_warning "option :parent is deprecated. It has no effect"
       options.delete(:parent)
     end
 
     # Then create the class.
 
     klass = genclass(
       name,
       :parent => Puppet::Type,
       :overwrite => true,
       :hash => @types,
       :attributes => options,
       &block
     )
 
     # Now define a "new<type>" method for convenience.
     if self.respond_to? newmethod
       # Refuse to overwrite existing methods like 'newparam' or 'newtype'.
       Puppet.warning "'new#{name.to_s}' method already exists; skipping"
     else
       selfobj.send(:define_method, newmethod) do |*args|
         klass.new(*args)
       end
     end
 
     # If they've got all the necessary methods defined and they haven't
     # already added the property, then do so now.
     klass.ensurable if klass.ensurable? and ! klass.validproperty?(:ensure)
 
     # Now set up autoload any providers that might exist for this type.
 
     klass.providerloader = Puppet::Util::Autoload.new(klass, "puppet/provider/#{klass.name.to_s}")
 
     # We have to load everything so that we can figure out the default provider.
-    klass.providerloader.loadall
+    klass.providerloader.loadall Puppet.lookup(:current_environment)
     klass.providify unless klass.providers.empty?
 
     klass
   end
 
   # Removes an existing type.
   # @note Only use this for testing.
   # @api private
   def rmtype(name)
     # Then create the class.
 
     rmclass(name, :hash => @types)
 
     singleton_class.send(:remove_method, "new#{name}") if respond_to?("new#{name}")
   end
 
   # Returns a Type instance by name.
   # This will load the type if not already defined.
   # @param [String, Symbol] name of the wanted Type
   # @return [Puppet::Type, nil] the type or nil if the type was not defined and could not be loaded
   #
   def type(name)
     # Avoid loading if name obviously is not a type name
     if name.to_s.include?(':')
       return nil
     end
 
     @types ||= {}
 
     # We are overwhelmingly symbols here, which usually match, so it is worth
     # having this special-case to return quickly.  Like, 25K symbols vs. 300
     # strings in this method. --daniel 2012-07-17
     return @types[name] if @types[name]
 
     # Try mangling the name, if it is a string.
     if name.is_a? String
       name = name.downcase.intern
       return @types[name] if @types[name]
     end
     # Try loading the type.
     if typeloader.load(name, Puppet.lookup(:current_environment))
       Puppet.warning "Loaded puppet/type/#{name} but no class was created" unless @types.include? name
     end
 
     # ...and I guess that is that, eh.
     return @types[name]
   end
 
   # Creates a loader for Puppet types.
   # Defaults to an instance of {Puppet::Util::Autoload} if no other auto loader has been set.
   # @return [Puppet::Util::Autoload] the loader to use.
   # @api private
   def typeloader
     unless defined?(@typeloader)
       @typeloader = Puppet::Util::Autoload.new(self, "puppet/type", :wrap => false)
     end
 
     @typeloader
   end
 end
 end
 
diff --git a/lib/puppet/util/autoload.rb b/lib/puppet/util/autoload.rb
index 7173fe906..88f0852c3 100644
--- a/lib/puppet/util/autoload.rb
+++ b/lib/puppet/util/autoload.rb
@@ -1,231 +1,231 @@
 require 'pathname'
 require 'puppet/util/rubygems'
 require 'puppet/util/warnings'
 require 'puppet/util/methodhelper'
 
 # Autoload paths, either based on names or all at once.
 class Puppet::Util::Autoload
   include Puppet::Util::MethodHelper
 
   @autoloaders = {}
   @loaded = {}
 
   class << self
     attr_reader :autoloaders
     attr_accessor :loaded
     private :autoloaders, :loaded
 
     def gem_source
       @gem_source ||= Puppet::Util::RubyGems::Source.new
     end
 
     # Has a given path been loaded?  This is used for testing whether a
     # changed file should be loaded or just ignored.  This is only
     # used in network/client/master, when downloading plugins, to
     # see if a given plugin is currently loaded and thus should be
     # reloaded.
     def loaded?(path)
       path = cleanpath(path).chomp('.rb')
       loaded.include?(path)
     end
 
     # Save the fact that a given path has been loaded.  This is so
     # we can load downloaded plugins if they've already been loaded
     # into memory.
     def mark_loaded(name, file)
       name = cleanpath(name).chomp('.rb')
       ruby_file = name + ".rb"
       $LOADED_FEATURES << ruby_file unless $LOADED_FEATURES.include?(ruby_file)
       loaded[name] = [file, File.mtime(file)]
     end
 
     def changed?(name)
       name = cleanpath(name).chomp('.rb')
       return true unless loaded.include?(name)
       file, old_mtime = loaded[name]
       environment = Puppet.lookup(:current_environment)
       return true unless file == get_file(name, environment)
       begin
         old_mtime.to_i != File.mtime(file).to_i
       rescue Errno::ENOENT
         true
       end
     end
 
     # Load a single plugin by name.  We use 'load' here so we can reload a
     # given plugin.
     def load_file(name, env)
       file = get_file(name.to_s, env)
       return false unless file
       begin
         mark_loaded(name, file)
         Kernel.load file, @wrap
         return true
       rescue SystemExit,NoMemoryError
         raise
       rescue Exception => detail
         message = "Could not autoload #{name}: #{detail}"
         Puppet.log_exception(detail, message)
         raise Puppet::Error, message, detail.backtrace
       end
     end
 
-    def loadall(path)
+    def loadall(path, env = nil)
       # Load every instance of everything we can find.
-      files_to_load(path).each do |file|
+      files_to_load(path, env).each do |file|
         name = file.chomp(".rb")
-        load_file(name, nil) unless loaded?(name)
+        load_file(name, env) unless loaded?(name)
       end
     end
 
     def reload_changed
       loaded.keys.each { |file| load_file(file, nil) if changed?(file) }
     end
 
     # Get the correct file to load for a given path
     # returns nil if no file is found
     def get_file(name, env)
       name = name + '.rb' unless name =~ /\.rb$/
       path = search_directories(env).find { |dir| Puppet::FileSystem.exist?(File.join(dir, name)) }
       path and File.join(path, name)
     end
 
-    def files_to_load(path)
-      search_directories(nil).map {|dir| files_in_dir(dir, path) }.flatten.uniq
+    def files_to_load(path, env = nil)
+      search_directories(env).map {|dir| files_in_dir(dir, path) }.flatten.uniq
     end
 
     def files_in_dir(dir, path)
       dir = Pathname.new(File.expand_path(dir))
       Dir.glob(File.join(dir, path, "*.rb")).collect do |file|
         Pathname.new(file).relative_path_from(dir).to_s
       end
     end
 
     def module_directories(env)
       # We're using a per-thread cache of module directories so that we don't
       # scan the filesystem each time we try to load something. This is reset
       # at the beginning of compilation and at the end of an agent run.
       $env_module_directories ||= {}
 
 
       # This is a little bit of a hack.  Basically, the autoloader is being
       # called indirectly during application bootstrapping when we do things
       # such as check "features".  However, during bootstrapping, we haven't
       # yet parsed all of the command line parameters nor the config files,
       # and thus we don't yet know with certainty what the module path is.
       # This should be irrelevant during bootstrapping, because anything that
       # we are attempting to load during bootstrapping should be something
       # that we ship with puppet, and thus the module path is irrelevant.
       #
       # In the long term, I think the way that we want to handle this is to
       # have the autoloader ignore the module path in all cases where it is
       # not specifically requested (e.g., by a constructor param or
       # something)... because there are very few cases where we should
       # actually be loading code from the module path.  However, until that
       # happens, we at least need a way to prevent the autoloader from
       # attempting to access the module path before it is initialized.  For
       # now we are accomplishing that by calling the
       # "app_defaults_initialized?" method on the main puppet Settings object.
       # --cprice 2012-03-16
       if Puppet.settings.app_defaults_initialized?
         env ||= Puppet.lookup(:environments).get(Puppet[:environment])
 
         if env
           # if the app defaults have been initialized then it should be safe to access the module path setting.
           $env_module_directories[env] ||= env.modulepath.collect do |dir|
             Dir.entries(dir).reject { |f| f =~ /^\./ }.collect { |f| File.join(dir, f, "lib") }
           end.flatten.find_all do |d|
             FileTest.directory?(d)
           end
         else
           []
         end
       else
         # if we get here, the app defaults have not been initialized, so we basically use an empty module path.
         []
       end
     end
 
     def libdirs()
       # See the comments in #module_directories above.  Basically, we need to be careful not to try to access the
       # libdir before we know for sure that all of the settings have been initialized (e.g., during bootstrapping).
       if (Puppet.settings.app_defaults_initialized?)
         Puppet[:libdir].split(File::PATH_SEPARATOR)
       else
         []
       end
     end
 
     def gem_directories
       gem_source.directories
     end
 
     def search_directories(env)
       [gem_directories, module_directories(env), libdirs(), $LOAD_PATH].flatten
     end
 
     # Normalize a path. This converts ALT_SEPARATOR to SEPARATOR on Windows
     # and eliminates unnecessary parts of a path.
     def cleanpath(path)
       # There are two cases here because cleanpath does not handle absolute
       # paths correctly on windows (c:\ and c:/ are treated as distinct) but
       # we don't want to convert relative paths to absolute
       if Puppet::Util.absolute_path?(path)
         File.expand_path(path)
       else
         Pathname.new(path).cleanpath.to_s
       end
     end
   end
 
   # Send [] and []= to the @autoloaders hash
   Puppet::Util.classproxy self, :autoloaders, "[]", "[]="
 
   attr_accessor :object, :path, :objwarn, :wrap
 
   def initialize(obj, path, options = {})
     @path = path.to_s
     raise ArgumentError, "Autoload paths cannot be fully qualified" if Puppet::Util.absolute_path?(@path)
     @object = obj
 
     self.class[obj] = self
 
     set_options(options)
 
     @wrap = true unless defined?(@wrap)
   end
 
   def load(name, env = nil)
     self.class.load_file(expand(name), env)
   end
 
   # Load all instances from a path of Autoload.search_directories matching the
   # relative path this Autoloader was initialized with.  For example, if we
   # have created a Puppet::Util::Autoload for Puppet::Type::User with a path of
   # 'puppet/provider/user', the search_directories path will be searched for
   # all ruby files matching puppet/provider/user/*.rb and they will then be
   # loaded from the first directory in the search path providing them.  So
   # earlier entries in the search path may shadow later entries.
   #
   # This uses require, rather than load, so that already-loaded files don't get
   # reloaded unnecessarily.
-  def loadall
-    self.class.loadall(@path)
+  def loadall(env = nil)
+    self.class.loadall(@path, env)
   end
 
   def loaded?(name)
     self.class.loaded?(expand(name))
   end
 
   def changed?(name)
     self.class.changed?(expand(name))
   end
 
   def files_to_load
     self.class.files_to_load(@path)
   end
 
   def expand(name)
     ::File.join(@path, name.to_s)
   end
 end