diff --git a/lib/puppet/environments.rb b/lib/puppet/environments.rb
index 03d3e8968..a56e55c0d 100644
--- a/lib/puppet/environments.rb
+++ b/lib/puppet/environments.rb
@@ -1,397 +1,397 @@
 # @api private
 module Puppet::Environments
 
   class EnvironmentNotFound < Puppet::Error
     def initialize(environment_name, original = nil)
       environmentpath = Puppet[:environmentpath]
       super("Could not find a directory environment named '#{environment_name}' anywhere in the path: #{environmentpath}. Does the directory exist?", original)
     end
   end
 
   # @api private
   module EnvironmentCreator
     # Create an anonymous environment.
     #
     # @param module_path [String] A list of module directories separated by the
     #   PATH_SEPARATOR
     # @param manifest [String] The path to the manifest
     # @return A new environment with the `name` `:anonymous`
     #
     # @api private
     def for(module_path, manifest)
       Puppet::Node::Environment.create(:anonymous,
                                        module_path.split(File::PATH_SEPARATOR),
                                        manifest)
     end
   end
 
   # Provide any common methods that loaders should have. It requires that any
   # classes that include this module implement get
   # @api private
   module EnvironmentLoader
     # @!macro loader_get_or_fail
     def get!(name)
       environment = get(name)
       if environment
         environment
       else
         raise EnvironmentNotFound, name
       end
     end
   end
 
   # @!macro [new] loader_search_paths
   #   A list of indicators of where the loader is getting its environments from.
   #   @return [Array<String>] The URIs of the load locations
   #
   # @!macro [new] loader_list
   #   @return [Array<Puppet::Node::Environment>] All of the environments known
   #     to the loader
   #
   # @!macro [new] loader_get
   #   Find a named environment
   #
   #   @param name [String,Symbol] The name of environment to find
   #   @return [Puppet::Node::Environment, nil] the requested environment or nil
   #     if it wasn't found
   #
   # @!macro [new] loader_get_conf
   #   Attempt to obtain the initial configuration for the environment.  Not all
   #   loaders can provide this.
   #
   #   @param name [String,Symbol] The name of the environment whose configuration
   #     we are looking up
   #   @return [Puppet::Setting::EnvironmentConf, nil] the configuration for the
   #     requested environment, or nil if not found or no configuration is available
   #
   # @!macro [new] loader_get_or_fail
   #   Find a named environment or raise
   #   Puppet::Environments::EnvironmentNotFound when the named environment is
   #   does not exist.
   #
   #   @param name [String,Symbol] The name of environment to find
   #   @return [Puppet::Node::Environment] the requested environment
 
   # A source of pre-defined environments.
   #
   # @api private
   class Static
     include EnvironmentCreator
     include EnvironmentLoader
 
     def initialize(*environments)
       @environments = environments
     end
 
     # @!macro loader_search_paths
     def search_paths
       ["data:text/plain,internal"]
     end
 
     # @!macro loader_list
     def list
       @environments
     end
 
     # @!macro loader_get
     def get(name)
       @environments.find do |env|
         env.name == name.intern
       end
     end
 
     # Returns a basic environment configuration object tied to the environment's
     # implementation values.  Will not interpolate.
     #
     # @!macro loader_get_conf
     def get_conf(name)
       env = get(name)
       if env
         Puppet::Settings::EnvironmentConf.static_for(env)
       else
         nil
       end
     end
   end
 
   # A source of unlisted pre-defined environments.
   #
   # Used only for internal bootstrapping environments which are not relevant
   # to an end user (such as the fall back 'configured' environment).
   #
   # @api private
   class StaticPrivate < Static
 
     # Unlisted
     #
     # @!macro loader_list
     def list
       []
     end
   end
 
   # Reads environments from a directory on disk. Each environment is
   # represented as a sub-directory. The environment's manifest setting is the
   # `manifest` directory of the environment directory. The environment's
   # modulepath setting is the global modulepath (from the `[master]` section
   # for the master) prepended with the `modules` directory of the environment
   # directory.
   #
   # @api private
   class Directories
     include EnvironmentLoader
 
     def initialize(environment_dir, global_module_path)
       @environment_dir = environment_dir
       @global_module_path = global_module_path
     end
 
     # Generate an array of directory loaders from a path string.
     # @param path [String] path to environment directories
     # @param global_module_path [Array<String>] the global modulepath setting
     # @return [Array<Puppet::Environments::Directories>] An array
     #   of configured directory loaders.
     def self.from_path(path, global_module_path)
       environments = path.split(File::PATH_SEPARATOR)
       environments.map do |dir|
         Puppet::Environments::Directories.new(dir, global_module_path)
       end
     end
 
     # @!macro loader_search_paths
     def search_paths
       ["file://#{@environment_dir}"]
     end
 
     # @!macro loader_list
     def list
       valid_directories.collect do |envdir|
         name = Puppet::FileSystem.basename_string(envdir).intern
 
         create_environment(name)
       end
     end
 
     # @!macro loader_get
     def get(name)
       if valid_directory?(File.join(@environment_dir, name.to_s))
         create_environment(name)
       end
     end
 
     # @!macro loader_get_conf
     def get_conf(name)
       envdir = File.join(@environment_dir, name.to_s)
       if valid_directory?(envdir)
         return Puppet::Settings::EnvironmentConf.load_from(envdir, @global_module_path)
       end
       nil
     end
 
     private
 
     def create_environment(name, setting_values = nil)
       env_symbol = name.intern
       setting_values = Puppet.settings.values(env_symbol, Puppet.settings.preferred_run_mode)
       Puppet::Node::Environment.create(
         env_symbol,
         Puppet::Node::Environment.split_path(setting_values.interpolate(:modulepath)),
         setting_values.interpolate(:manifest),
         setting_values.interpolate(:config_version)
       )
     end
 
     def valid_directory?(envdir)
       name = Puppet::FileSystem.basename_string(envdir)
       Puppet::FileSystem.directory?(envdir) &&
          Puppet::Node::Environment.valid_name?(name)
     end
 
     def valid_directories
       if Puppet::FileSystem.directory?(@environment_dir)
         Puppet::FileSystem.children(@environment_dir).select do |child|
           valid_directory?(child)
         end
       else
         []
       end
     end
   end
 
   # Combine together multiple loaders to act as one.
   # @api private
   class Combined
     include EnvironmentLoader
 
     def initialize(*loaders)
       @loaders = loaders
     end
 
     # @!macro loader_search_paths
     def search_paths
       @loaders.collect(&:search_paths).flatten
     end
 
     # @!macro loader_list
     def list
       @loaders.collect(&:list).flatten
     end
 
     # @!macro loader_get
     def get(name)
       @loaders.each do |loader|
         if env = loader.get(name)
           return env
         end
       end
       nil
     end
 
     # @!macro loader_get_conf
     def get_conf(name)
       @loaders.each do |loader|
         if conf = loader.get_conf(name)
           return conf
         end
       end
       nil
     end
 
   end
 
   class Cached
     include EnvironmentLoader
 
     class DefaultCacheExpirationService
       def created(env)
       end
 
       def expired?(env_name)
         false
       end
 
       def evicted(env_name)
       end
     end
 
     def self.cache_expiration_service=(service)
       @cache_expiration_service = service
     end
 
     def self.cache_expiration_service
       @cache_expiration_service || DefaultCacheExpirationService.new
     end
 
     def initialize(loader)
       @loader = loader
       @cache = {}
       @cache_expiration_service = Puppet::Environments::Cached.cache_expiration_service
     end
 
     # @!macro loader_list
     def list
       @loader.list
     end
 
     # @!macro loader_search_paths
     def search_paths
       @loader.search_paths
     end
 
     # @!macro loader_get
     def get(name)
       evict_if_expired(name)
       if result = @cache[name]
         return result.value
       elsif (result = @loader.get(name))
         @cache[name] = entry(result)
         result
       end
     end
 
     # Clears the cache of the environment with the given name.
     # (The intention is that this could be used from a MANUAL cache eviction command (TBD)
     def clear(name)
       @cache.delete(name)
     end
 
     # Clears all cached environments.
     # (The intention is that this could be used from a MANUAL cache eviction command (TBD)
     def clear_all()
       @cache = {}
     end
 
     # This implementation evicts the cache, and always gets the current
     # configuration of the environment
     #
     # TODO: While this is wasteful since it
     # needs to go on a search for the conf, it is too disruptive to optimize
     # this.
     #
     # @!macro loader_get_conf
     def get_conf(name)
       evict_if_expired(name)
       @loader.get_conf(name)
     end
 
     # Creates a suitable cache entry given the time to live for one environment
     #
     def entry(env)
       @cache_expiration_service.created(env)
       ttl = (conf = get_conf(env.name)) ? conf.environment_timeout : Puppet.settings.value(:environment_timeout)
-      Puppet.debug {"Caching environment '#{env.name}' (cache ttl: #{ttl})"}
+      Puppet.debug("Caching environment '#{env.name}' (cache ttl: #{ttl})")
       case ttl
       when 0
         NotCachedEntry.new(env)     # Entry that is always expired (avoids syscall to get time)
       when Float::INFINITY
         Entry.new(env)              # Entry that never expires (avoids syscall to get time)
       else
         TTLEntry.new(env, ttl)
       end
     end
 
     # Evicts the entry if it has expired
     # Also clears caches in Settings that may prevent the entry from being updated
     def evict_if_expired(name)
       if (result = @cache[name]) && (result.expired? || @cache_expiration_service.expired?(name))
-      Puppet.debug {"Evicting cache entry for environment '#{name}'"}
+        Puppet.debug("Evicting cache entry for environment '#{name}'")
         @cache.delete(name)
         @cache_expiration_service.evicted(name)
 
         Puppet.settings.clear_environment_settings(name)
       end
     end
 
     # Never evicting entry
     class Entry
       attr_reader :value
 
       def initialize(value)
         @value = value
       end
 
       def expired?
         false
       end
     end
 
     # Always evicting entry
     class NotCachedEntry < Entry
       def expired?
         true
       end
     end
 
     # Time to Live eviction policy entry
     class TTLEntry < Entry
       def initialize(value, ttl_seconds)
         super value
         @ttl = Time.now + ttl_seconds
       end
 
       def expired?
         Time.now > @ttl
       end
     end
   end
 end
diff --git a/lib/puppet/face/node/clean.rb b/lib/puppet/face/node/clean.rb
index 6ed5bf22a..bfd88feb3 100644
--- a/lib/puppet/face/node/clean.rb
+++ b/lib/puppet/face/node/clean.rb
@@ -1,96 +1,96 @@
 Puppet::Face.define(:node, '0.0.1') do
   action(:clean) do
 
     summary "Clean up signed certs, cached facts, node objects, and reports for a node stored by the puppetmaster"
     arguments "<host1> [<host2> ...]"
     description <<-'EOT'
       Cleans up the following information a puppet master knows about a node:
 
       <Signed certificates> - ($vardir/ssl/ca/signed/node.domain.pem)
 
       <Cached facts> - ($vardir/yaml/facts/node.domain.yaml)
 
       <Cached node objects> - ($vardir/yaml/node/node.domain.yaml)
 
       <Reports> - ($vardir/reports/node.domain)
 
     EOT
 
     when_invoked do |*args|
       nodes = args[0..-2]
       options = args.last
       raise "At least one node should be passed" if nodes.empty? || nodes == options
 
       # This seems really bad; run_mode should be set as part of a class
       # definition, and should not be modifiable beyond that.  This is one of
       # the only places left in the code that tries to manipulate it. Other
       # parts of code that handle certificates behave differently if the
       # run_mode is master. Those other behaviors are needed for cleaning the
       # certificates correctly.
       Puppet.settings.preferred_run_mode = "master"
 
       if Puppet::SSL::CertificateAuthority.ca?
         Puppet::SSL::Host.ca_location = :local
       else
         Puppet::SSL::Host.ca_location = :none
       end
 
       Puppet::Node::Facts.indirection.terminus_class = :yaml
       Puppet::Node::Facts.indirection.cache_class = :yaml
       Puppet::Node.indirection.terminus_class = :yaml
       Puppet::Node.indirection.cache_class = :yaml
 
       nodes.each { |node| cleanup(node.downcase) }
     end
   end
 
   def cleanup(node)
     clean_cert(node)
     clean_cached_facts(node)
     clean_cached_node(node)
     clean_reports(node)
   end
 
   # clean signed cert for +host+
   def clean_cert(node)
     if Puppet::SSL::CertificateAuthority.ca?
       Puppet::Face[:ca, :current].revoke(node)
       Puppet::Face[:ca, :current].destroy(node)
       Puppet.info "#{node} certificates removed from ca"
     else
       Puppet.info "Not managing #{node} certs as this host is not a CA"
     end
   end
 
   # clean facts for +host+
   def clean_cached_facts(node)
     Puppet::Node::Facts.indirection.destroy(node)
     Puppet.info "#{node}'s facts removed"
   end
 
   # clean cached node +host+
   def clean_cached_node(node)
     Puppet::Node.indirection.destroy(node)
     Puppet.info "#{node}'s cached node removed"
   end
 
   # clean node reports for +host+
   def clean_reports(node)
     Puppet::Transaction::Report.indirection.destroy(node)
     Puppet.info "#{node}'s reports removed"
   end
 
   def environment
     @environment ||= Puppet.lookup(:current_environment)
   end
 
   def type_is_ensurable(resource)
     if (type = Puppet::Type.type(resource.restype)) && type.validattr?(:ensure)
       return true
     else
-      type = environment.known_resource_types.find_definition(resource.restype)
+      type = environment.known_resource_types.find_definition('', resource.restype)
       return true if type && type.arguments.keys.include?('ensure')
     end
     return false
   end
 end
diff --git a/lib/puppet/indirector/resource_type/parser.rb b/lib/puppet/indirector/resource_type/parser.rb
index f9cbad817..884fd2f03 100644
--- a/lib/puppet/indirector/resource_type/parser.rb
+++ b/lib/puppet/indirector/resource_type/parser.rb
@@ -1,101 +1,101 @@
 require 'puppet/resource/type'
 require 'puppet/indirector/code'
 require 'puppet/indirector/resource_type'
 
 # The main terminus for Puppet::Resource::Type
 #
 # This exposes the known resource types from within Puppet. Only find
 # and search are supported. When a request is received, Puppet will
 # attempt to load all resource types (by parsing manifests and modules) and
 # returns a description of the resource types found. The format of these
 # objects is documented at {Puppet::Resource::Type}.
 #
 # @api public
 class Puppet::Indirector::ResourceType::Parser < Puppet::Indirector::Code
   desc "Return the data-form of a resource type."
 
   # Find will return the first resource_type with the given name. It is
   # not possible to specify the kind of the resource type.
   #
   # @param request [Puppet::Indirector::Request] The request object.
   #   The only parameters used from the request are `environment` and
   #   `key`, which corresponds to the resource type's `name` field.
   # @return [Puppet::Resource::Type, nil]
   # @api public
   def find(request)
     Puppet.override(:squelch_parse_errors => true) do
       krt = resource_types_in(request.environment)
 
       # This is a bit ugly.
       [:hostclass, :definition, :node].each do |type|
         # We have to us 'find_<type>' here because it will
         # load any missing types from disk, whereas the plain
         # '<type>' method only returns from memory.
-        if r = krt.send("find_#{type}", request.key)
+        if r = krt.send("find_#{type}", [""], request.key)
           return r
         end
       end
       nil
     end
   end
 
   # Search for resource types using a regular expression. Unlike `find`, this
   # allows you to filter the results by the "kind" of the resource type
   # ("class", "defined_type", or "node"). All three are searched if no
   # `kind` filter is given. This also accepts the special string "`*`"
   # to return all resource type objects.
   #
   # @param request [Puppet::Indirector::Request] The request object. The
   #   `key` field holds the regular expression used to search, and
   #   `options[:kind]` holds the kind query parameter to filter the
   #   result as described above. The `environment` field specifies the
   #   environment used to load resources.
   #
   # @return [Array<Puppet::Resource::Type>, nil]
   #
   # @api public
   def search(request)
     Puppet.override(:squelch_parse_errors => true) do
 
       krt = resource_types_in(request.environment)
       # Make sure we've got all of the types loaded.
       krt.loader.import_all
 
       result_candidates = case request.options[:kind]
           when "class"
             krt.hostclasses.values
           when "defined_type"
             krt.definitions.values
           when "node"
             krt.nodes.values
           when nil
             result_candidates = [krt.hostclasses.values, krt.definitions.values, krt.nodes.values]
           else
             raise ArgumentError, "Unrecognized kind filter: " +
                       "'#{request.options[:kind]}', expected one " +
                       " of 'class', 'defined_type', or 'node'."
         end
 
       result = result_candidates.flatten.reject { |t| t.name == "" }
       return nil if result.empty?
       return result if request.key == "*"
 
       # Strip the regex of any wrapping slashes that might exist
       key = request.key.sub(/^\//, '').sub(/\/$/, '')
       begin
         regex = Regexp.new(key)
       rescue => detail
         raise ArgumentError, "Invalid regex '#{request.key}': #{detail}", detail.backtrace
       end
 
       result.reject! { |t| t.name.to_s !~ regex }
       return nil if result.empty?
       result
     end
   end
 
   def resource_types_in(environment)
     environment.check_for_reparse
     environment.known_resource_types
   end
 end
diff --git a/lib/puppet/parser/ast/pops_bridge.rb b/lib/puppet/parser/ast/pops_bridge.rb
index 97385c24c..a248f8b41 100644
--- a/lib/puppet/parser/ast/pops_bridge.rb
+++ b/lib/puppet/parser/ast/pops_bridge.rb
@@ -1,243 +1,243 @@
 require 'puppet/parser/ast/top_level_construct'
 require 'puppet/pops'
 
 # The AST::Bridge contains classes that bridges between the new Pops based model
 # and the 3.x AST. This is required to be able to reuse the Puppet::Resource::Type which is
 # fundamental for the rest of the logic.
 #
 class Puppet::Parser::AST::PopsBridge
 
   # Bridges to one Pops Model Expression
   # The @value is the expression
   # This is used to represent the body of a class, definition, or node, and for each parameter's default value
   # expression.
   #
   class Expression < Puppet::Parser::AST::Leaf
 
     def initialize args
       super
       @@evaluator ||= Puppet::Pops::Parser::EvaluatingParser.new()
     end
 
     def to_s
       Puppet::Pops::Model::ModelTreeDumper.new.dump(@value)
     end
 
     def evaluate(scope)
       object = @@evaluator.evaluate(scope, @value)
       @@evaluator.convert_to_3x(object, scope)
     end
 
     # Adapts to 3x where top level constructs needs to have each to iterate over children. Short circuit this
     # by yielding self. By adding this there is no need to wrap a pops expression inside an AST::BlockExpression
     #
     def each
       yield self
     end
 
     def sequence_with(other)
       if value.nil?
         # This happens when testing and not having a complete setup
         other
       else
         # When does this happen ? Ever ?
         raise "sequence_with called on Puppet::Parser::AST::PopsBridge::Expression - please report use case"
         # What should be done if the above happens (We don't want this to happen).
         # Puppet::Parser::AST::BlockExpression.new(:children => [self] + other.children)
       end
     end
 
     # The 3x requires code plugged in to an AST to have this in certain positions in the tree. The purpose
     # is to either print the content, or to look for things that needs to be defined. This implementation
     # cheats by always returning an empty array. (This allows simple files to not require a "Program" at the top.
     #
     def children
       []
     end
   end
 
   # Bridges the top level "Program" produced by the pops parser.
   # Its main purpose is to give one point where all definitions are instantiated (actually defined since the
   # Puppet 3x terminology is somewhat misleading - the definitions are instantiated, but instances of the created types
   # are not created, that happens when classes are included / required, nodes are matched and when resources are instantiated
   # by a resource expression (which is also used to instantiate a host class).
   #
   class Program < Puppet::Parser::AST::TopLevelConstruct
     attr_reader :program_model, :context
 
     def initialize(program_model, context = {})
       @program_model = program_model
       @context = context
       @ast_transformer ||= Puppet::Pops::Model::AstTransformer.new(@context[:file])
       @@evaluator ||= Puppet::Pops::Parser::EvaluatingParser.new()
     end
 
     # This is the 3x API, the 3x AST searches through all code to find the instructions that can be instantiated.
     # This Pops-model based instantiation relies on the parser to build this list while parsing (which is more
     # efficient as it avoids one full scan of all logic via recursive enumeration/yield)
     #
     def instantiate(modname)
       @program_model.definitions.collect do |d|
         case d
         when Puppet::Pops::Model::HostClassDefinition
           instantiate_HostClassDefinition(d, modname)
         when Puppet::Pops::Model::ResourceTypeDefinition
           instantiate_ResourceTypeDefinition(d, modname)
         when Puppet::Pops::Model::NodeDefinition
           instantiate_NodeDefinition(d, modname)
         else
           raise Puppet::ParseError, "Internal Error: Unknown type of definition - got '#{d.class}'"
         end
       end.flatten().compact() # flatten since node definition may have returned an array
                               # Compact since functions are not understood by compiler
     end
 
     def evaluate(scope)
       @@evaluator.evaluate(scope, program_model)
     end
 
     # Adapts to 3x where top level constructs needs to have each to iterate over children. Short circuit this
     # by yielding self. This means that the HostClass container will call this bridge instance with `instantiate`.
     #
     def each
       yield self
     end
 
     private
 
     def instantiate_Parameter(o)
       # 3x needs parameters as an array of `[name]` or `[name, value_expr]`
       if o.value
         [o.name, Expression.new(:value => o.value)]
       else
         [o.name]
       end
     end
 
     def create_type_map(definition)
       result = {}
       # No need to do anything if there are no parameters
       return result unless definition.parameters.size > 0
 
       # No need to do anything if there are no typed parameters
       typed_parameters = definition.parameters.select {|p| p.type_expr }
       return result if typed_parameters.empty?
 
       # If there are typed parameters, they need to be evaluated to produce the corresponding type
       # instances. This evaluation requires a scope. A scope is not available when doing deserialization
       # (there is also no initialized evaluator). When running apply and test however, the environment is
       # reused and we may reenter without a scope (which is fine). A debug message is then output in case
       # there is the need to track down the odd corner case. See {#obtain_scope}.
       #
       if scope = obtain_scope
         typed_parameters.each do |p|
           result[p.name] =  @@evaluator.evaluate(scope, p.type_expr)
         end
       end
       result
     end
 
     # Obtains the scope or issues a warning if :global_scope is not bound
     def obtain_scope
       scope = Puppet.lookup(:global_scope) do
         # This occurs when testing and when applying a catalog (there is no scope available then), and
         # when running tests that run a partial setup.
         # This is bad if the logic is trying to compile, but a warning can not be issues since it is a normal
         # use case that there is no scope when requesting the type in order to just get the parameters.
-        Puppet.debug {"Instantiating Resource with type checked parameters - scope is missing, skipping type checking."}
+        Puppet.debug("Instantiating Resource with type checked parameters - scope is missing, skipping type checking.")
         nil
       end
       scope
     end
 
     # Produces a hash with data for Definition and HostClass
     def args_from_definition(o, modname)
       args = {
        :arguments => o.parameters.collect {|p| instantiate_Parameter(p) },
        :argument_types => create_type_map(o),
        :module_name => modname
       }
       unless is_nop?(o.body)
         args[:code] = Expression.new(:value => o.body)
       end
       @ast_transformer.merge_location(args, o)
     end
 
     def instantiate_HostClassDefinition(o, modname)
       args = args_from_definition(o, modname)
       args[:parent] = absolute_reference(o.parent_class)
       Puppet::Resource::Type.new(:hostclass, o.name, @context.merge(args))
     end
 
     def instantiate_ResourceTypeDefinition(o, modname)
       Puppet::Resource::Type.new(:definition, o.name, @context.merge(args_from_definition(o, modname)))
     end
 
     def instantiate_NodeDefinition(o, modname)
       args = { :module_name => modname }
 
       unless is_nop?(o.body)
         args[:code] = Expression.new(:value => o.body)
       end
 
       unless is_nop?(o.parent)
         args[:parent] = @ast_transformer.hostname(o.parent)
       end
 
       host_matches = @ast_transformer.hostname(o.host_matches)
       @ast_transformer.merge_location(args, o)
       host_matches.collect do |name|
         Puppet::Resource::Type.new(:node, name, @context.merge(args))
       end
     end
 
     # Propagates a found Function to the appropriate loader.
     # This is for 4x evaluator/loader
     #
     def instantiate_FunctionDefinition(function_definition, modname)
       loaders = (Puppet.lookup(:loaders) { nil })
       unless loaders
         raise Puppet::ParseError, "Internal Error: Puppet Context ':loaders' missing - cannot define any functions"
       end
       loader =
       if modname.nil? || modname == ""
         # TODO : Later when functions can be private, a decision is needed regarding what that means.
         #        A private environment loader could be used for logic outside of modules, then only that logic
         #        would see the function.
         #
         # Use the private loader, this function may see the environment's dependencies (currently, all modules)
         loaders.private_environment_loader()
       else
         # TODO : Later check if function is private, and then add it to
         #        private_loader_for_module
         #
         loaders.public_loader_for_module(modname)
       end
       unless loader
         raise Puppet::ParseError, "Internal Error: did not find public loader for module: '#{modname}'"
       end
 
       # Instantiate Function, and store it in the environment loader
       typed_name, f = Puppet::Pops::Loader::PuppetFunctionInstantiator.create_from_model(function_definition, loader)
       loader.set_entry(typed_name, f, Puppet::Pops::Adapters::SourcePosAdapter.adapt(function_definition).to_uri)
 
       nil # do not want the function to inadvertently leak into 3x
     end
 
     def code()
       Expression.new(:value => @value)
     end
 
     def is_nop?(o)
       @ast_transformer.is_nop?(o)
     end
 
     def absolute_reference(ref)
       if ref.nil? || ref.empty? || ref.start_with?('::')
         ref
       else
         "::#{ref}"
       end
     end
   end
 end
diff --git a/lib/puppet/parser/ast/resource.rb b/lib/puppet/parser/ast/resource.rb
index 848cec68f..a175f6541 100644
--- a/lib/puppet/parser/ast/resource.rb
+++ b/lib/puppet/parser/ast/resource.rb
@@ -1,61 +1,61 @@
 # Instruction for Resource instantiation.
 # Instantiates resources of both native and user defined types.
 #
 class Puppet::Parser::AST::Resource < Puppet::Parser::AST::Branch
 
   attr_accessor :type, :instances, :exported, :virtual
 
   # Evaluates resources by adding them to the compiler for lazy evaluation
   # and returning the produced resource references.
   #
   def evaluate(scope)
     # We want virtual to be true if exported is true.  We can't
     # just set :virtual => self.virtual in the initialization,
     # because sometimes the :virtual attribute is set *after*
     # :exported, in which case it clobbers :exported if :exported
     # is true.  Argh, this was a very tough one to track down.
     virt = self.virtual || self.exported
 
     # First level of implicit iteration: build a resource for each
     # instance.  This handles things like:
     # file { '/foo': owner => blah; '/bar': owner => blah }
     @instances.map do |instance|
 
       # Evaluate all of the specified params.
       paramobjects = instance.parameters.map { |param| param.safeevaluate(scope) }
 
       resource_titles = instance.title.safeevaluate(scope)
 
       # it's easier to always use an array, even for only one name
       resource_titles = [resource_titles] unless resource_titles.is_a?(Array)
 
       fully_qualified_type, resource_titles = scope.resolve_type_and_titles(type, resource_titles)
 
       # Second level of implicit iteration; build a resource for each
       # title.  This handles things like:
       # file { ['/foo', '/bar']: owner => blah }
       resource_titles.flatten.map do |resource_title|
         exceptwrap :type => Puppet::ParseError do
           resource = Puppet::Parser::Resource.new(
           fully_qualified_type, resource_title,
             :parameters => paramobjects,
             :file => self.file,
             :line => self.line,
             :exported => self.exported,
             :virtual => virt,
             :source => scope.source,
             :scope => scope,
             :strict => true
           )
 
           if resource.resource_type.is_a? Puppet::Resource::Type
             resource.resource_type.instantiate_resource(scope, resource)
           end
           scope.compiler.add_resource(scope, resource)
-          scope.compiler.evaluate_classes([resource_title], scope, false) if fully_qualified_type == 'class'
+          scope.compiler.evaluate_classes([resource_title], scope, false, true) if fully_qualified_type == 'class'
           resource
         end
       end
     end.flatten.reject { |resource| resource.nil? }
   end
 end
diff --git a/lib/puppet/parser/compiler.rb b/lib/puppet/parser/compiler.rb
index 1bfa017c8..3a048082c 100644
--- a/lib/puppet/parser/compiler.rb
+++ b/lib/puppet/parser/compiler.rb
@@ -1,601 +1,607 @@
 require 'forwardable'
 
 require 'puppet/node'
 require 'puppet/resource/catalog'
 require 'puppet/util/errors'
 
 require 'puppet/resource/type_collection_helper'
 require 'puppet/loaders'
 
 # 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
 
     errors = node.environment.validation_errors
     if !errors.empty?
       errors.each { |e| Puppet.err(e) } if errors.size > 1
       errmsg = [
         "Compilation has been halted because: #{errors.first}",
         "For more information, see http://docs.puppetlabs.com/puppet/latest/reference/environments.html",
       ]
       raise(Puppet::Error, errmsg.join(' '))
     end
 
     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
       @catalog.environment_instance = environment
 
       # Set the client's parameters into the top scope.
       Puppet::Util::Profiler.profile("Compile: Set node parameters", [:compiler, :set_node_params]) { set_node_parameters }
 
       Puppet::Util::Profiler.profile("Compile: Created settings scope", [:compiler, :create_settings_scope]) { create_settings_scope }
 
       activate_binder
 
       Puppet::Util::Profiler.profile("Compile: Evaluated main", [:compiler, :evaluate_main]) { evaluate_main }
 
       Puppet::Util::Profiler.profile("Compile: Evaluated AST node", [:compiler, :evaluate_ast_node]) { evaluate_ast_node }
 
       Puppet::Util::Profiler.profile("Compile: Evaluated node classes", [:compiler, :evaluate_node_classes]) { evaluate_node_classes }
 
       Puppet::Util::Profiler.profile("Compile: Evaluated generators", [:compiler, :evaluate_generators]) { evaluate_generators }
 
       Puppet::Util::Profiler.profile("Compile: Finished catalog", [:compiler, :finish_catalog]) { finish }
 
       fail_on_unevaluated
 
       @catalog
     end
   end
 
   # Constructs the overrides for the context
   def context_overrides()
     {
       :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
     }
   end
 
   def_delegator :@collections, :delete, :delete_collection
 
   # Return the node's environment.
   def environment
     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_with_params, @node_scope || topscope)
     evaluate_classes(classes_without_params, @node_scope || topscope)
   end
 
-  # Evaluates each specified class in turn. If there are any classes that 
-  # can't be found, an error is raised. This method really just creates resource objects
+  # 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.
   #
-  def evaluate_classes(classes, scope, lazy_evaluate = true)
+  # 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
 
     hostclasses = classes.collect do |name|
-      scope.find_hostclass(name) or raise Puppet::Error, "Could not find class #{name} for #{node.name}"
+      scope.find_hostclass(name, :assume_fqname => fqname) or raise Puppet::Error, "Could not find class #{name} for #{node.name}"
     end
 
     if class_parameters
       resources = ensure_classes_with_parameters(scope, hostclasses, class_parameters)
       if !lazy_evaluate
         resources.each(&:evaluate)
       end
 
       resources
     else
       already_included, newly_included = ensure_classes_without_parameters(scope, hostclasses)
       if !lazy_evaluate
         newly_included.each(&:evaluate)
       end
 
       already_included + newly_included
     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(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 activate_binder
     # TODO: this should be in a central place
     Puppet::Parser::ParserFactory.assert_rgen_installed()
     @@binder_loaded ||= false
     unless @@binder_loaded
       require 'puppet/pops'
       require 'puppet/plugins/configuration'
       @@binder_loaded = true
     end
     true
   end
 
   private
 
   def ensure_classes_with_parameters(scope, hostclasses, parameters)
     hostclasses.collect do |klass|
       klass.ensure_in_catalog(scope, parameters[klass.name] || {})
     end
   end
 
   def ensure_classes_without_parameters(scope, hostclasses)
     already_included = []
     newly_included = []
     hostclasses.each do |klass|
       class_scope = scope.class_scope(klass)
       if class_scope
         already_included << class_scope.resource
       else
         newly_included << klass.ensure_in_catalog(scope)
       end
     end
 
     [already_included, newly_included]
   end
 
   # 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", [:compiler, :evaluate_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", [:compiler, :evaluate_definitions]) do
         !unevaluated_resources.each do |resource|
           Puppet::Util::Profiler.profile("Evaluated resource #{resource}", [:compiler, :evaluate_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", [:compiler, :iterate_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, ""))
+    @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 there are no remaining collections that are waiting for
   # resources that have not yet been instantiated. If this occurs it
   # is an error (missing resource - it could not be realized).
   #
   def fail_on_unevaluated_resource_collections
     remaining = @collections.collect(&:unresolved_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, @node.environment)
 
     # 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 initial 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.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"]
     @topscope.set_trusted(node.trusted_data)
     facts_hash = node.facts.nil? ? {} : node.facts.values
     @topscope.set_facts(facts_hash)
   end
 
   def create_settings_scope
     settings_type = Puppet::Resource::Type.new :hostclass, "settings"
     environment.known_resource_types.add(settings_type)
 
     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)
 
     env = environment
     Puppet.settings.each do |name, setting|
       next if name == :name
       scope[name.to_s] = env[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 activate_binder()
       raise Puppet::DevError, "The Puppet Binder was not activated"
     end
   end
 end
diff --git a/lib/puppet/parser/relationship.rb b/lib/puppet/parser/relationship.rb
index e4e1d08b3..f27949d09 100644
--- a/lib/puppet/parser/relationship.rb
+++ b/lib/puppet/parser/relationship.rb
@@ -1,54 +1,54 @@
 class Puppet::Parser::Relationship
   attr_accessor :source, :target, :type
 
   PARAM_MAP = {:relationship => :before, :subscription => :notify}
 
   def arrayify(resources)
     case resources
     when Puppet::Pops::Evaluator::Collectors::AbstractCollector
       resources.collected.values
     when Array
       resources
     else
       [resources]
     end
   end
 
   def evaluate(catalog)
     arrayify(source).each do |s|
       arrayify(target).each do |t|
         mk_relationship(s, t, catalog)
       end
     end
   end
 
   def initialize(source, target, type)
     @source, @target, @type = source, target, type
   end
 
   def param_name
     PARAM_MAP[type] || raise(ArgumentError, "Invalid relationship type #{type}")
   end
 
   def mk_relationship(source, target, catalog)
     # There was once an assumption that this could be an array. These raise
     # assertions are here as a sanity check for 4.0 and can be removed after
     # a release or two
     raise ArgumentError, "source shouldn't be an array" if source.is_a?(Array)
     raise ArgumentError, "target shouldn't be an array" if target.is_a?(Array)
     source = source.to_s
     target = target.to_s
 
     unless source_resource = catalog.resource(source)
       raise ArgumentError, "Could not find resource '#{source}' for relationship on '#{target}'"
     end
     unless catalog.resource(target)
       raise ArgumentError, "Could not find resource '#{target}' for relationship from '#{source}'"
     end
-    Puppet.debug {"Adding relationship from #{source} to #{target} with '#{param_name}'"}
+    Puppet.debug "Adding relationship from #{source} to #{target} with '#{param_name}'"
     if source_resource[param_name].class != Array
       source_resource[param_name] = [source_resource[param_name]].compact
     end
     source_resource[param_name] << target
   end
 end
diff --git a/lib/puppet/parser/scope.rb b/lib/puppet/parser/scope.rb
index 7419f655b..dfbadd54c 100644
--- a/lib/puppet/parser/scope.rb
+++ b/lib/puppet/parser/scope.rb
@@ -1,845 +1,854 @@
 # The scope class, which handles storing and retrieving variables and types and
 # such.
 require 'forwardable'
 
 require 'puppet/parser'
 require 'puppet/parser/templatewrapper'
 
 require 'puppet/resource/type_collection_helper'
 require 'puppet/util/methodhelper'
 
 # This class is part of the internal parser/evaluator/compiler functionality of Puppet.
 # It is passed between the various classes that participate in evaluation.
 # None of its methods are API except those that are clearly marked as such.
 #
 # @api public
 class Puppet::Parser::Scope
   extend Forwardable
   include Puppet::Util::MethodHelper
 
   include Puppet::Resource::TypeCollectionHelper
   require 'puppet/parser/resource'
 
   AST = Puppet::Parser::AST
 
   Puppet::Util.logmethods(self)
 
   include Puppet::Util::Errors
   attr_accessor :source, :resource
   attr_accessor :compiler
   attr_accessor :parent
   attr_reader :namespaces
 
   # Hash of hashes of default values per type name
   attr_reader :defaults
 
   # Add some alias methods that forward to the compiler, since we reference
   # them frequently enough to justify the extra method call.
   def_delegators :compiler, :catalog, :environment
 
 
   # Abstract base class for LocalScope and MatchScope
   #
   class Ephemeral
 
     attr_reader :parent
 
     def initialize(parent = nil)
       @parent = parent
     end
 
     def is_local_scope?
       false
     end
 
     def [](name)
       if @parent
         @parent[name]
       end
     end
 
     def include?(name)
       (@parent and @parent.include?(name))
     end
 
     def bound?(name)
       false
     end
 
     def add_entries_to(target = {})
       @parent.add_entries_to(target) unless @parent.nil?
       # do not include match data ($0-$n)
       target
     end
   end
 
   class LocalScope < Ephemeral
 
     def initialize(parent=nil)
       super parent
       @symbols = {}
     end
 
     def [](name)
       if @symbols.include?(name)
         @symbols[name]
       else
         super
       end
     end
 
     def is_local_scope?
       true
     end
 
     def []=(name, value)
       @symbols[name] = value
     end
 
     def include?(name)
       bound?(name) || super
     end
 
     def delete(name)
       @symbols.delete(name)
     end
 
     def bound?(name)
       @symbols.include?(name)
     end
 
     def add_entries_to(target = {})
       super
       @symbols.each do |k, v|
         if v == :undef || v.nil?
           target.delete(k)
         else
           target[ k ] = v
         end
       end
       target
     end
   end
 
   class MatchScope < Ephemeral
 
     attr_accessor :match_data
 
     def initialize(parent = nil, match_data = nil)
       super parent
       @match_data = match_data
     end
 
     def is_local_scope?
       false
     end
 
     def [](name)
       if bound?(name)
         @match_data[name.to_i]
       else
         super
       end
     end
 
     def include?(name)
       bound?(name) or super
     end
 
     def bound?(name)
       # A "match variables" scope reports all numeric variables to be bound if the scope has
       # match_data. Without match data the scope is transparent.
       #
       @match_data && name =~ /^\d+$/
     end
 
     def []=(name, value)
       # TODO: Bad choice of exception
       raise Puppet::ParseError, "Numerical variables cannot be changed. Attempt to set $#{name}"
     end
 
     def delete(name)
       # TODO: Bad choice of exception
       raise Puppet::ParseError, "Numerical variables cannot be deleted: Attempt to delete: $#{name}"
     end
 
     def add_entries_to(target = {})
       # do not include match data ($0-$n)
       super
     end
 
   end
 
   # Returns true if the variable of the given name has a non nil value.
   # TODO: This has vague semantics - does the variable exist or not?
   #       use ['name'] to get nil or value, and if nil check with exist?('name')
   #       this include? is only useful because of checking against the boolean value false.
   #
   def include?(name)
     ! self[name].nil?
   end
 
   # Returns true if the variable of the given name is set to any value (including nil)
   #
   def exist?(name)
     next_scope = inherited_scope || enclosing_scope
     effective_symtable(true).include?(name) || next_scope && next_scope.exist?(name)
   end
 
   # Returns true if the given name is bound in the current (most nested) scope for assignments.
   #
   def bound?(name)
     # Do not look in ephemeral (match scope), the semantics is to answer if an assignable variable is bound
     effective_symtable(false).bound?(name)
   end
 
   # Is the value true?  This allows us to control the definition of truth
   # in one place.
   def self.true?(value)
     case value
     when ''
       false
     when :undef
       false
     else
       !!value
     end
   end
 
   # Coerce value to a number, or return `nil` if it isn't one.
   def self.number?(value)
     case value
     when Numeric
       value
     when /^-?\d+(:?\.\d+|(:?\.\d+)?e\d+)$/
       value.to_f
     when /^0x[0-9a-f]+$/i
       value.to_i(16)
     when /^0[0-7]+$/
       value.to_i(8)
     when /^-?\d+$/
       value.to_i
     else
       nil
     end
   end
 
-  def find_hostclass(name)
-    known_resource_types.find_hostclass(name)
+  # Add to our list of namespaces.
+  def add_namespace(ns)
+    return false if @namespaces.include?(ns)
+    if @namespaces == [""]
+      @namespaces = [ns]
+    else
+      @namespaces << ns
+    end
+  end
+
+  def find_hostclass(name, options = {})
+    known_resource_types.find_hostclass(namespaces, name, options)
   end
 
   def find_definition(name)
-    known_resource_types.find_definition(name)
+    known_resource_types.find_definition(namespaces, name)
   end
 
   def find_global_scope()
     # walk upwards until first found node_scope or top_scope
     if is_nodescope? || is_topscope?
       self
     else
       next_scope = inherited_scope || enclosing_scope
       if next_scope.nil?
         # this happens when testing, and there is only a single test scope and no link to any
         # other scopes
         self
       else
         next_scope.find_global_scope()
       end
     end
   end
 
   # This just delegates directly.
   def_delegator :compiler, :findresource
 
   # Initialize our new scope.  Defaults to having no parent.
   def initialize(compiler, options = {})
     if compiler.is_a? Puppet::Parser::Compiler
       self.compiler = compiler
     else
       raise Puppet::DevError, "you must pass a compiler instance to a new scope object"
     end
 
     if n = options.delete(:namespace)
-      @namespaces = [n.freeze].freeze
+      @namespaces = [n]
     else
-      @namespaces = ["".freeze].freeze
+      @namespaces = [""]
     end
 
     raise Puppet::DevError, "compiler passed in options" if options.include? :compiler
     set_options(options)
 
     extend_with_functions_module
 
     # The symbol table for this scope.  This is where we store variables.
     #    @symtable = Ephemeral.new(nil, true)
     @symtable = LocalScope.new(nil)
 
     @ephemeral = [ MatchScope.new(@symtable, nil) ]
 
     # All of the defaults set for types.  It's a hash of hashes,
     # with the first key being the type, then the second key being
     # the parameter.
     @defaults = Hash.new { |dhash,type|
       dhash[type] = {}
     }
 
     # The table for storing class singletons.  This will only actually
     # be used by top scopes and node scopes.
     @class_scopes = {}
   end
 
   # Store the fact that we've evaluated a class, and store a reference to
   # the scope in which it was evaluated, so that we can look it up later.
   def class_set(name, scope)
     if parent
       parent.class_set(name, scope)
     else
       @class_scopes[name] = scope
     end
   end
 
   # Return the scope associated with a class.  This is just here so
   # that subclasses can set their parent scopes to be the scope of
   # their parent class, and it's also used when looking up qualified
   # variables.
   def class_scope(klass)
     # They might pass in either the class or class name
     k = klass.respond_to?(:name) ? klass.name : klass
     @class_scopes[k] || (parent && parent.class_scope(k))
   end
 
   # Collect all of the defaults set at any higher scopes.
   # This is a different type of lookup because it's
   # additive -- it collects all of the defaults, with defaults
   # in closer scopes overriding those in later scopes.
   #
   # The lookupdefaults searches in the the order:
   #
   #   * inherited
   #   * contained (recursive)
   #   * self
   #
   def lookupdefaults(type)
     values = {}
 
     # first collect the values from the parents
     if parent
       parent.lookupdefaults(type).each { |var,value|
         values[var] = value
       }
     end
 
     # then override them with any current values
     # this should probably be done differently
     if @defaults.include?(type)
       @defaults[type].each { |var,value|
         values[var] = value
       }
     end
 
     values
   end
 
   # Look up a defined type.
   def lookuptype(name)
-    # This happens a lot, avoid making a call to make a call
-    known_resource_types.find_definition(name) || known_resource_types.find_hostclass(name)
+    find_definition(name) || find_hostclass(name)
   end
 
   def undef_as(x,v)
     if v.nil? or v == :undef
       x
     else
       v
     end
   end
 
   # Lookup a variable within this scope using the Puppet language's
   # scoping rules. Variables can be qualified using just as in a
   # manifest.
   #
   # @param [String] name the variable name to lookup
   #
   # @return Object the value of the variable, or nil if it's not found
   #
   # @api public
   def lookupvar(name, options = {})
     unless name.is_a? String
       raise Puppet::ParseError, "Scope variable name #{name.inspect} is a #{name.class}, not a string"
     end
 
     table = @ephemeral.last
 
     if name =~ /^(.*)::(.+)$/
       class_name = $1
       variable_name = $2
       lookup_qualified_variable(class_name, variable_name, options)
 
     # TODO: optimize with an assoc instead, this searches through scopes twice for a hit
     elsif table.include?(name)
       table[name]
     else
       next_scope = inherited_scope || enclosing_scope
       if next_scope
         next_scope.lookupvar(name, options)
       else
         variable_not_found(name)
       end
     end
   end
 
   def variable_not_found(name, reason=nil)
     if Puppet[:strict_variables]
         throw :undefined_variable
     else
       nil
     end
   end
 
   # Retrieves the variable value assigned to the name given as an argument. The name must be a String,
   # and namespace can be qualified with '::'. The value is looked up in this scope, its parent scopes,
   # or in a specific visible named scope.
   #
   # @param varname [String] the name of the variable (may be a qualified name using `(ns'::')*varname`
   # @param options [Hash] Additional options, not part of api.
   # @return [Object] the value assigned to the given varname
   # @see #[]=
   # @api public
   #
   def [](varname, options={})
     lookupvar(varname, options)
   end
 
   # The scope of the inherited thing of this scope's resource. This could
   # either be a node that was inherited or the class.
   #
   # @return [Puppet::Parser::Scope] The scope or nil if there is not an inherited scope
   def inherited_scope
     if has_inherited_class?
       qualified_scope(resource.resource_type.parent)
     else
       nil
     end
   end
 
   # The enclosing scope (topscope or nodescope) of this scope.
   # The enclosing scopes are produced when a class or define is included at
   # some point. The parent scope of the included class or define becomes the
   # scope in which it was included. The chain of parent scopes is followed
   # until a node scope or the topscope is found
   #
   # @return [Puppet::Parser::Scope] The scope or nil if there is no enclosing scope
   def enclosing_scope
     if has_enclosing_scope?
       if parent.is_topscope? or parent.is_nodescope?
         parent
       else
         parent.enclosing_scope
       end
     else
       nil
     end
   end
 
   def is_classscope?
     resource and resource.type == "Class"
   end
 
   def is_nodescope?
     resource and resource.type == "Node"
   end
 
   def is_topscope?
     compiler and self == compiler.topscope
   end
 
   def lookup_qualified_variable(class_name, variable_name, position)
     begin
       if lookup_as_local_name?(class_name, variable_name)
         self[variable_name]
       else
         qualified_scope(class_name).lookupvar(variable_name, position)
       end
     rescue RuntimeError => e
       unless Puppet[:strict_variables]
         # Do not issue warning if strict variables are on, as an error will be raised by variable_not_found
         location = if position[:lineproc]
                      " at #{position[:lineproc].call}"
                    elsif position[:file] && position[:line]
                      " at #{position[:file]}:#{position[:line]}"
                    else
                      ""
                    end
         warning "Could not look up qualified variable '#{class_name}::#{variable_name}'; #{e.message}#{location}"
       end
       variable_not_found("#{class_name}::#{variable_name}", e.message)
     end
   end
 
   # Handles the special case of looking up fully qualified variable in not yet evaluated top scope
   # This is ok if the lookup request originated in topscope (this happens when evaluating
   # bindings; using the top scope to provide the values for facts.
   # @param class_name [String] the classname part of a variable name, may be special ""
   # @param variable_name [String] the variable name without the absolute leading '::'
   # @return [Boolean] true if the given variable name should be looked up directly in this scope
   #
   def lookup_as_local_name?(class_name, variable_name)
     # not a local if name has more than one segment
     return nil if variable_name =~ /::/
     # partial only if the class for "" cannot be found
     return nil unless class_name == "" && klass = find_hostclass(class_name) && class_scope(klass).nil?
     is_topscope?
   end
 
   def has_inherited_class?
     is_classscope? and resource.resource_type.parent
   end
   private :has_inherited_class?
 
   def has_enclosing_scope?
     not parent.nil?
   end
   private :has_enclosing_scope?
 
   def qualified_scope(classname)
     raise "class #{classname} could not be found"     unless klass = find_hostclass(classname)
     raise "class #{classname} has not been evaluated" unless kscope = class_scope(klass)
     kscope
   end
   private :qualified_scope
 
   # Returns a Hash containing all variables and their values, optionally (and
   # by default) including the values defined in parent. Local values
   # shadow parent values. Ephemeral scopes for match results ($0 - $n) are not included.
   #
   def to_hash(recursive = true)
     if recursive and has_enclosing_scope?
       target = enclosing_scope.to_hash(recursive)
       if !(inherited = inherited_scope).nil?
         target.merge!(inherited.to_hash(recursive))
       end
     else
       target = Hash.new
     end
 
     # add all local scopes
     @ephemeral.last.add_entries_to(target)
     target
   end
 
   def namespaces
-    @namespaces
+    @namespaces.dup
   end
 
   # Create a new scope and set these options.
   def newscope(options = {})
     compiler.newscope(self, options)
   end
 
   def parent_module_name
     return nil unless @parent
     return nil unless @parent.source
     @parent.source.module_name
   end
 
   # Set defaults for a type.  The typename should already be downcased,
   # so that the syntax is isolated.  We don't do any kind of type-checking
   # here; instead we let the resource do it when the defaults are used.
   def define_settings(type, params)
     table = @defaults[type]
 
     # if we got a single param, it'll be in its own array
     params = [params] unless params.is_a?(Array)
 
     params.each { |param|
       if table.include?(param.name)
         raise Puppet::ParseError.new("Default already defined for #{type} { #{param.name} }; cannot redefine", param.line, param.file)
       end
       table[param.name] = param
     }
   end
 
   RESERVED_VARIABLE_NAMES = ['trusted', 'facts'].freeze
 
   # Set a variable in the current scope.  This will override settings
   # in scopes above, but will not allow variables in the current scope
   # to be reassigned.
   #   It's preferred that you use self[]= instead of this; only use this
   # when you need to set options.
   def setvar(name, value, options = {})
     if name =~ /^[0-9]+$/
       raise Puppet::ParseError.new("Cannot assign to a numeric match result variable '$#{name}'") # unless options[:ephemeral]
     end
     unless name.is_a? String
       raise Puppet::ParseError, "Scope variable name #{name.inspect} is a #{name.class}, not a string"
     end
 
     # Check for reserved variable names
     if !options[:privileged] && RESERVED_VARIABLE_NAMES.include?(name)
       raise Puppet::ParseError, "Attempt to assign to a reserved variable name: '#{name}'"
     end
 
     table = effective_symtable(options[:ephemeral])
     if table.bound?(name)
       if options[:append]
         error = Puppet::ParseError.new("Cannot append, variable #{name} is defined in this scope")
       else
         error = Puppet::ParseError.new("Cannot reassign variable #{name}")
       end
       error.file = options[:file] if options[:file]
       error.line = options[:line] if options[:line]
       raise error
     end
 
     if options[:append]
       # produced result (value) is the resulting appended value, note: the table[]= does not return the value
       table[name] = (value = append_value(undef_as('', self[name]), value))
     else
       table[name] = value
     end
     value
   end
 
   def set_trusted(hash)
     setvar('trusted', deep_freeze(hash), :privileged => true)
   end
 
   def set_facts(hash)
     setvar('facts', deep_freeze(hash), :privileged => true)
   end
 
   # Deeply freezes the given object. The object and its content must be of the types:
   # Array, Hash, Numeric, Boolean, Symbol, Regexp, NilClass, or String. All other types raises an Error.
   # (i.e. if they are assignable to Puppet::Pops::Types::Data type).
   #
   def deep_freeze(object)
     case object
     when Array
       object.each {|v| deep_freeze(v) }
       object.freeze
     when Hash
       object.each {|k, v| deep_freeze(k); deep_freeze(v) }
       object.freeze
     when NilClass, Numeric, TrueClass, FalseClass
       # do nothing
     when String
       object.freeze
     else
       raise Puppet::Error, "Unsupported data type: '#{object.class}'"
     end
     object
   end
   private :deep_freeze
 
   # Return the effective "table" for setting variables.
   # This method returns the first ephemeral "table" that acts as a local scope, or this
   # scope's symtable. If the parameter `use_ephemeral` is true, the "top most" ephemeral "table"
   # will be returned (irrespective of it being a match scope or a local scope).
   #
   # @param use_ephemeral [Boolean] whether the top most ephemeral (of any kind) should be used or not
   def effective_symtable(use_ephemeral)
     s = @ephemeral.last
     if use_ephemeral
       return s || @symtable
     else
       while s && !s.is_local_scope?()
         s = s.parent
       end
       s || @symtable
     end
   end
 
   # Sets the variable value of the name given as an argument to the given value. The value is
   # set in the current scope and may shadow a variable with the same name in a visible outer scope.
   # It is illegal to re-assign a variable in the same scope. It is illegal to set a variable in some other
   # scope/namespace than the scope passed to a method.
   #
   # @param varname [String] The variable name to which the value is assigned. Must not contain `::`
   # @param value [String] The value to assign to the given variable name.
   # @param options [Hash] Additional options, not part of api.
   #
   # @api public
   #
   def []=(varname, value, options = {})
     setvar(varname, value, options = {})
   end
 
   def append_value(bound_value, new_value)
     case new_value
     when Array
       bound_value + new_value
     when Hash
       bound_value.merge(new_value)
     else
       if bound_value.is_a?(Hash)
         raise ArgumentError, "Trying to append to a hash with something which is not a hash is unsupported"
       end
       bound_value + new_value
     end
   end
   private :append_value
 
   # Return the tags associated with this scope.
   def_delegator :resource, :tags
 
   # Used mainly for logging
   def to_s
     "Scope(#{@resource})"
   end
 
   # remove ephemeral scope up to level
   # TODO: Who uses :all ? Remove ??
   #
   def unset_ephemeral_var(level=:all)
     if level == :all
       @ephemeral = [ MatchScope.new(@symtable, nil)]
     else
       @ephemeral.pop(@ephemeral.size - level)
     end
   end
 
   def ephemeral_level
     @ephemeral.size
   end
 
   # TODO: Who calls this?
   def new_ephemeral(local_scope = false)
     if local_scope
       @ephemeral.push(LocalScope.new(@ephemeral.last))
     else
       @ephemeral.push(MatchScope.new(@ephemeral.last, nil))
     end
   end
 
   # Sets match data in the most nested scope (which always is a MatchScope), it clobbers match data already set there
   #
   def set_match_data(match_data)
     @ephemeral.last.match_data = match_data
   end
 
   # Nests a match data scope
   def new_match_scope(match_data)
     @ephemeral.push(MatchScope.new(@ephemeral.last, match_data))
   end
 
   def ephemeral_from(match, file = nil, line = nil)
     case match
     when Hash
       # Create local scope ephemeral and set all values from hash
       new_ephemeral(true)
       match.each {|k,v| setvar(k, v, :file => file, :line => line, :ephemeral => true) }
       # Must always have an inner match data scope (that starts out as transparent)
       # In 3x slightly wasteful, since a new nested scope is created for a match 
       # (TODO: Fix that problem)
       new_ephemeral(false)
     else
       raise(ArgumentError,"Invalid regex match data. Got a #{match.class}") unless match.is_a?(MatchData)
       # Create a match ephemeral and set values from match data
       new_match_scope(match)
     end
   end
 
   def find_resource_type(type)
     # It still works fine without the type == 'class' short-cut, but it is a lot slower.
     return nil if ["class", "node"].include? type.to_s.downcase
     find_builtin_resource_type(type) || find_defined_resource_type(type)
   end
 
   def find_builtin_resource_type(type)
     Puppet::Type.type(type.to_s.downcase.to_sym)
   end
 
   def find_defined_resource_type(type)
-    known_resource_types.find_definition(type.to_s.downcase)
+    known_resource_types.find_definition(namespaces, type.to_s.downcase)
   end
 
 
   def method_missing(method, *args, &block)
     method.to_s =~ /^function_(.*)$/
     name = $1
     super unless name
     super unless Puppet::Parser::Functions.function(name)
     # In odd circumstances, this might not end up defined by the previous
     # method, so we might as well be certain.
     if respond_to? method
       send(method, *args)
     else
       raise Puppet::DevError, "Function #{name} not defined despite being loaded!"
     end
   end
 
   def resolve_type_and_titles(type, titles)
     raise ArgumentError, "titles must be an array" unless titles.is_a?(Array)
 
     case type.downcase
     when "class"
       # resolve the titles
       titles = titles.collect do |a_title|
         hostclass = find_hostclass(a_title)
         hostclass ?  hostclass.name : a_title
       end
     when "node"
       # no-op
     else
       # resolve the type
       resource_type = find_resource_type(type)
       type = resource_type.name if resource_type
     end
 
     return [type, titles]
   end
 
   # Transforms references to classes to the form suitable for
   # lookup in the compiler.
   #
   # Makes names passed in the names array absolute if they are relative.
   #
   # Transforms Class[] and Resource[] type references to class name
   # or raises an error if a Class[] is unspecific, if a Resource is not
   # a 'class' resource, or if unspecific (no title).
   #
   #
   # @param names [Array<String>] names to (optionally) make absolute
   # @return [Array<String>] names after transformation
   #
   def transform_and_assert_classnames(names)
     names.map do |name|
       case name
       when String
         name.sub(/^([^:]{1,2})/, '::\1')
 
       when Puppet::Resource
         assert_class_and_title(name.type, name.title)
         name.title.sub(/^([^:]{1,2})/, '::\1')
 
       when Puppet::Pops::Types::PHostClassType
         raise ArgumentError, "Cannot use an unspecific Class[] Type" unless name.class_name
         name.class_name.sub(/^([^:]{1,2})/, '::\1')
 
       when Puppet::Pops::Types::PResourceType
         assert_class_and_title(name.type_name, name.title)
         name.title.sub(/^([^:]{1,2})/, '::\1')
       end
     end
   end
 
   private
 
   def assert_class_and_title(type_name, title)
     if type_name.nil? || type_name == ''
       raise ArgumentError, "Cannot use an unspecific Resource[] where a Resource['class', name] is expected"
     end
     unless type_name =~ /^[Cc]lass$/
       raise ArgumentError, "Cannot use a Resource[#{type_name}] where a Resource['class', name] is expected"
     end
     if title.nil?
       raise ArgumentError, "Cannot use an unspecific Resource['class'] where a Resource['class', name] is expected"
     end
   end
 
   def extend_with_functions_module
     root = Puppet.lookup(:root_environment)
     extend Puppet::Parser::Functions.environment_module(root)
     extend Puppet::Parser::Functions.environment_module(environment) if environment != root
   end
 end
diff --git a/lib/puppet/parser/type_loader.rb b/lib/puppet/parser/type_loader.rb
index 489d1fbb1..5c8db0575 100644
--- a/lib/puppet/parser/type_loader.rb
+++ b/lib/puppet/parser/type_loader.rb
@@ -1,149 +1,149 @@
 require 'find'
 require 'forwardable'
 require 'puppet/parser/parser_factory'
 
 class Puppet::Parser::TypeLoader
   extend  Forwardable
 
-  class TypeLoaderError < StandardError; end
-
   # Import manifest files that match a given file glob pattern.
   #
   # @param pattern [String] the file glob to apply when determining which files
   #   to load
   # @param dir [String] base directory to use when the file is not
   #   found in a module
   # @api private
   def import(pattern, dir)
     modname, files = Puppet::Parser::Files.find_manifests_in_modules(pattern, environment)
     if files.empty?
       abspat = File.expand_path(pattern, dir)
       file_pattern = abspat + (File.extname(abspat).empty? ? '.pp' : '' )
 
       files = Dir.glob(file_pattern).uniq.reject { |f| FileTest.directory?(f) }
       modname = nil
 
       if files.empty?
         raise_no_files_found(pattern)
       end
     end
 
     load_files(modname, files)
   end
 
   # Load all of the manifest files in all known modules.
   # @api private
   def import_all
     # And then load all files from each module, but (relying on system
     # behavior) only load files from the first module of a given name.  E.g.,
     # given first/foo and second/foo, only files from first/foo will be loaded.
     environment.modules.each do |mod|
       load_files(mod.name, mod.all_manifests)
     end
   end
 
   def_delegator :environment, :known_resource_types
 
   def initialize(env)
     self.environment = env
   end
 
   def environment
     @environment
   end
 
   def environment=(env)
     if env.is_a?(String) or env.is_a?(Symbol)
       @environment = Puppet.lookup(:environments).get!(env)
     else
       @environment = env
     end
   end
 
   # Try to load the object with the given fully qualified name.
   def try_load_fqname(type, fqname)
     return nil if fqname == "" # special-case main.
     files_to_try_for(fqname).each do |filename|
       begin
         imported_types = import_from_modules(filename)
         if result = imported_types.find { |t| t.type == type and t.name == fqname }
-          Puppet.debug {"Automatically imported #{fqname} from #{filename} into #{environment}"}
+          Puppet.debug "Automatically imported #{fqname} from #{filename} into #{environment}"
           return result
         end
-      rescue TypeLoaderError => detail
+      rescue Puppet::ImportError => detail
         # I'm not convienced we should just drop these errors, but this
         # preserves existing behaviours.
       end
     end
     # Nothing found.
     return nil
   end
 
   def parse_file(file)
     Puppet.debug("importing '#{file}' in environment #{environment}")
     parser = Puppet::Parser::ParserFactory.parser
     parser.file = file
     return parser.parse
   end
 
   private
 
   def import_from_modules(pattern)
     modname, files = Puppet::Parser::Files.find_manifests_in_modules(pattern, environment)
     if files.empty?
       raise_no_files_found(pattern)
     end
 
     load_files(modname, files)
   end
 
   def raise_no_files_found(pattern)
-    raise TypeLoaderError, "No file(s) found for import of '#{pattern}'"
+    raise Puppet::ImportError, "No file(s) found for import of '#{pattern}'"
   end
 
   def load_files(modname, files)
     @loaded ||= {}
     loaded_asts = []
     files.reject { |file| @loaded[file] }.each do |file|
-    # The squelch_parse_errors use case is for parsing for the purpose of searching
-    # for information and it should not abort.
-    # There is currently one user in indirector/resourcetype/parser
-    #
+      # NOTE: This ugly implementation will be replaced in Puppet 3.5.
+      # The implementation now makes use of a global variable because the context support is
+      # not available until Puppet 3.5.
+      # The use case is that parsing for the purpose of searching for information
+      # should not abort. There is currently one such use case in indirector/resourcetype/parser
+      #
     if Puppet.lookup(:squelch_parse_errors) {|| false }
         begin
           loaded_asts << parse_file(file)
         rescue => e
-          # Resume from errors so that all parseable files may
+          # Resume from errors so that all parseable files would
           # still be parsed. Mark this file as loaded so that
           # it would not be parsed next time (handle it as if
           # it was successfully parsed).
           Puppet.debug("Unable to parse '#{file}': #{e.message}")
         end
       else
         loaded_asts << parse_file(file)
       end
 
       @loaded[file] = true
     end
 
     loaded_asts.collect do |ast|
       known_resource_types.import_ast(ast, modname)
     end.flatten
   end
 
   # Return a list of all file basenames that should be tried in order
   # to load the object with the given fully qualified name.
   def files_to_try_for(qualified_name)
     qualified_name.split('::').inject([]) do |paths, name|
       add_path_for_name(paths, name)
     end
   end
 
   def add_path_for_name(paths, name)
     if paths.empty?
       [name]
     else
       paths.unshift(File.join(paths.first, name))
     end
   end
 end
diff --git a/lib/puppet/pops/evaluator/runtime3_support.rb b/lib/puppet/pops/evaluator/runtime3_support.rb
index 9595c6ec1..690f70926 100644
--- a/lib/puppet/pops/evaluator/runtime3_support.rb
+++ b/lib/puppet/pops/evaluator/runtime3_support.rb
@@ -1,601 +1,601 @@
 # A module with bindings between the new evaluator and the 3x runtime.
 # The intention is to separate all calls into scope, compiler, resource, etc. in this module
 # to make it easier to later refactor the evaluator for better implementations of the 3x classes.
 #
 # @api private
 module Puppet::Pops::Evaluator::Runtime3Support
 
   NAME_SPACE_SEPARATOR = '::'.freeze
 
   # Fails the evaluation of _semantic_ with a given issue.
   #
   # @param issue [Puppet::Pops::Issue] the issue to report
   # @param semantic [Puppet::Pops::ModelPopsObject] the object for which evaluation failed in some way. Used to determine origin.
   # @param options [Hash] hash of optional named data elements for the given issue
   # @return [!] this method does not return
   # @raise [Puppet::ParseError] an evaluation error initialized from the arguments (TODO: Change to EvaluationError?)
   #
   def fail(issue, semantic, options={}, except=nil)
     optionally_fail(issue, semantic, options, except)
     # an error should have been raised since fail always fails
     raise ArgumentError, "Internal Error: Configuration of runtime error handling wrong: should have raised exception"
   end
 
   # Optionally (based on severity) Fails the evaluation of _semantic_ with a given issue
   # If the given issue is configured to be of severity < :error it is only reported, and the function returns.
   #
   # @param issue [Puppet::Pops::Issue] the issue to report
   # @param semantic [Puppet::Pops::ModelPopsObject] the object for which evaluation failed in some way. Used to determine origin.
   # @param options [Hash] hash of optional named data elements for the given issue
   # @return [!] this method does not return
   # @raise [Puppet::ParseError] an evaluation error initialized from the arguments (TODO: Change to EvaluationError?)
   #
   def optionally_fail(issue, semantic, options={}, except=nil)
     if except.nil?
       # Want a stacktrace, and it must be passed as an exception
       begin
        raise EvaluationError.new()
       rescue EvaluationError => e
         except = e
       end
     end
     diagnostic_producer.accept(issue, semantic, options, except)
   end
 
   # Binds the given variable name to the given value in the given scope.
   # The reference object `o` is intended to be used for origin information - the 3x scope implementation
   # only makes use of location when there is an error. This is now handled by other mechanisms; first a check
   # is made if a variable exists and an error is raised if attempting to change an immutable value. Errors
   # in name, numeric variable assignment etc. have also been validated prior to this call. In the event the
   # scope.setvar still raises an error, the general exception handling for evaluation of the assignment
   # expression knows about its location. Because of this, there is no need to extract the location for each
   # setting (extraction is somewhat expensive since 3x requires line instead of offset).
   #
   def set_variable(name, value, o, scope)
     # Scope also checks this but requires that location information are passed as options.
     # Those are expensive to calculate and a test is instead made here to enable failing with better information.
     # The error is not specific enough to allow catching it - need to check the actual message text.
     # TODO: Improve the messy implementation in Scope.
     #
     if scope.bound?(name)
       if Puppet::Parser::Scope::RESERVED_VARIABLE_NAMES.include?(name)
         fail(Puppet::Pops::Issues::ILLEGAL_RESERVED_ASSIGNMENT, o, {:name => name} )
       else
         fail(Puppet::Pops::Issues::ILLEGAL_REASSIGNMENT, o, {:name => name} )
       end
     end
     scope.setvar(name, value)
   end
 
   # Returns the value of the variable (nil is returned if variable has no value, or if variable does not exist)
   #
   def get_variable_value(name, o, scope)
     # Puppet 3x stores all variables as strings (then converts them back to numeric with a regexp... to see if it is a match variable)
     # Not ideal, scope should support numeric lookup directly instead.
     # TODO: consider fixing scope
     catch(:undefined_variable) {
       x = scope.lookupvar(name.to_s)
       # Must convert :undef back to nil - this can happen when an undefined variable is used in a
       # parameter's default value expression - there nil must be :undef to work with the rest of 3x.
       # Now that the value comes back to 4x it is changed to nil.
       return (x == :undef) ? nil : x
     }
     # It is always ok to reference numeric variables even if they are not assigned. They are always undef
     # if not set by a match expression.
     #
     unless name =~ Puppet::Pops::Patterns::NUMERIC_VAR_NAME
       fail(Puppet::Pops::Issues::UNKNOWN_VARIABLE, o, {:name => name})
     end
   end
 
   # Returns true if the variable of the given name is set in the given most nested scope. True is returned even if
   # variable is bound to nil.
   #
   def variable_bound?(name, scope)
     scope.bound?(name.to_s)
   end
 
   # Returns true if the variable is bound to a value or nil, in the scope or it's parent scopes.
   #
   def variable_exists?(name, scope)
     scope.exist?(name.to_s)
   end
 
   def set_match_data(match_data, scope)
     # See set_variable for rationale for not passing file and line to ephemeral_from.
     # NOTE: The 3x scope adds one ephemeral(match) to its internal stack per match that succeeds ! It never
     # clears anything. Thus a context that performs many matches will get very deep (there simply is no way to
     # clear the match variables without rolling back the ephemeral stack.)
     # This implementation does not attempt to fix this, it behaves the same bad way.
     unless match_data.nil?
       scope.ephemeral_from(match_data)
     end
   end
 
   # Creates a local scope with vairalbes set from a hash of variable name to value
   #
   def create_local_scope_from(hash, scope)
     # two dummy values are needed since the scope tries to give an error message (can not happen in this
     # case - it is just wrong, the error should be reported by the caller who knows in more detail where it
     # is in the source.
     #
     raise ArgumentError, "Internal error - attempt to create a local scope without a hash" unless hash.is_a?(Hash)
     scope.ephemeral_from(hash)
   end
 
   # Creates a nested match scope
   def create_match_scope_from(scope)
     # Create a transparent match scope (for future matches)
     scope.new_match_scope(nil)
   end
 
   def get_scope_nesting_level(scope)
     scope.ephemeral_level
   end
 
   def set_scope_nesting_level(scope, level)
     # Yup, 3x uses this method to reset the level, it also supports passing :all to destroy all 
     # ephemeral/local scopes - which is a sure way to create havoc.
     #
     scope.unset_ephemeral_var(level)
   end
 
   # Adds a relationship between the given `source` and `target` of the given `relationship_type`
   # @param source [Puppet:Pops::Types::PCatalogEntryType] the source end of the relationship (from)
   # @param target [Puppet:Pops::Types::PCatalogEntryType] the target end of the relationship (to)
   # @param relationship_type [:relationship, :subscription] the type of the relationship
   #
   def add_relationship(source, target, relationship_type, scope)
     # The 3x way is to record a Puppet::Parser::Relationship that is evaluated at the end of the compilation.
     # This means it is not possible to detect any duplicates at this point (and signal where an attempt is made to
     # add a duplicate. There is also no location information to signal the original place in the logic. The user will have
     # to go fish.
     # The 3.x implementation is based on Strings :-o, so the source and target must be transformed. The resolution is
     # done by Catalog#resource(type, title). To do that, it creates a Puppet::Resource since it is responsible for
     # translating the name/type/title and create index-keys used by the catalog. The Puppet::Resource has bizarre parsing of
     # the type and title (scan for [] that is interpreted as type/title (but it gets it wrong).
     # Moreover if the type is "" or "component", the type is Class, and if the type is :main, it is :main, all other cases
     # undergo capitalization of name-segments (foo::bar becomes Foo::Bar). (This was earlier done in the reverse by the parser).
     # Further, the title undergoes the same munging !!!
     #
     # That bug infested nest of messy logic needs serious Exorcism!
     #
     # Unfortunately it is not easy to simply call more intelligent methods at a lower level as the compiler evaluates the recorded
     # Relationship object at a much later point, and it is responsible for invoking all the messy logic.
     #
     # TODO: Revisit the below logic when there is a sane implementation of the catalog, compiler and resource. For now
     # concentrate on transforming the type references to what is expected by the wacky logic.
     #
     # HOWEVER, the Compiler only records the Relationships, and the only method it calls is @relationships.each{|x| x.evaluate(catalog) }
     # Which means a smarter Relationship class could do this right. Instead of obtaining the resource from the catalog using
     # the borked resource(type, title) which creates a resource for the purpose of looking it up, it needs to instead
     # scan the catalog's resources
     #
     # GAAAH, it is even worse!
     # It starts in the parser, which parses "File['foo']" into an AST::ResourceReference with type = File, and title = foo
     # This AST is evaluated by looking up the type/title in the scope - causing it to be loaded if it exists, and if not, the given
     # type name/title is used. It does not search for resource instances, only classes and types. It returns symbolic information
     # [type, [title, title]]. From this, instances of Puppet::Resource are created and returned. These only have type/title information
     # filled out. One or an array of resources are returned.
     # This set of evaluated (empty reference) Resource instances are then passed to the relationship operator. It creates a
     # Puppet::Parser::Relationship giving it a source and a target that are (empty reference) Resource instances. These are then remembered
     # until the relationship is evaluated by the compiler (at the end). When evaluation takes place, the (empty reference) Resource instances
     # are converted to String (!?! WTF) on the simple format "#{type}[#{title}]", and the catalog is told to find a resource, by giving
     # it this string. If it cannot find the resource it fails, else the before/notify parameter is appended with the target.
     # The search for the resource begin with (you guessed it) again creating an (empty reference) resource from type and title (WTF?!?!).
     # The catalog now uses the reference resource to compute a key [r.type, r.title.to_s] and also gets a uniqueness key from the
     # resource (This is only a reference type created from title and type). If it cannot find it with the first key, it uses the
     # uniqueness key to lookup.
     #
     # This is probably done to allow a resource type to munge/translate the title in some way (but it is quite unclear from the long
     # and convoluted path of evaluation.
     # In order to do this in a way that is similar to 3.x two resources are created to be used as keys.
     #
     # And if that is not enough, a source/target may be a Collector (a baked query that will be evaluated by the
     # compiler - it is simply passed through here for processing by the compiler at the right time).
     #
     if source.is_a?(Puppet::Pops::Evaluator::Collectors::AbstractCollector)
       # use verbatim - behavior defined by 3x
       source_resource = source
     else
       # transform into the wonderful String representation in 3x
       type, title = catalog_type_to_split_type_title(source)
       source_resource = Puppet::Resource.new(type, title)
     end
     if target.is_a?(Puppet::Pops::Evaluator::Collectors::AbstractCollector)
       # use verbatim - behavior defined by 3x
       target_resource = target
     else
       # transform into the wonderful String representation in 3x
       type, title = catalog_type_to_split_type_title(target)
       target_resource = Puppet::Resource.new(type, title)
     end
     # Add the relationship to the compiler for later evaluation.
     scope.compiler.add_relationship(Puppet::Parser::Relationship.new(source_resource, target_resource, relationship_type))
   end
 
   # Coerce value `v` to numeric or fails.
   # The given value `v` is coerced to Numeric, and if that fails the operation
   # calls {#fail}.
   # @param v [Object] the value to convert
   # @param o [Object] originating instruction
   # @param scope [Object] the (runtime specific) scope where evaluation of o takes place
   # @return [Numeric] value `v` converted to Numeric.
   #
   def coerce_numeric(v, o, scope)
     unless n = Puppet::Pops::Utils.to_n(v)
       fail(Puppet::Pops::Issues::NOT_NUMERIC, o, {:value => v})
     end
     n
   end
 
   def call_function(name, args, o, scope)
     Puppet::Util::Profiler.profile("Called #{name}", [:functions, name]) do
       # Call via 4x API if the function exists there
       loaders = scope.compiler.loaders
       # find the loader that loaded the code, or use the private_environment_loader (sees env + all modules)
       adapter = Puppet::Pops::Utils.find_adapter(o, Puppet::Pops::Adapters::LoaderAdapter)
       loader = adapter.nil? ? loaders.private_environment_loader : adapter.loader
       if loader && func = loader.load(:function, name)
         return func.call(scope, *args)
       end
 
       # Call via 3x API if function exists there
       fail(Puppet::Pops::Issues::UNKNOWN_FUNCTION, o, {:name => name}) unless Puppet::Parser::Functions.function(name)
 
       # Arguments must be mapped since functions are unaware of the new and magical creatures in 4x.
       # NOTE: Passing an empty string last converts nil/:undef to empty string
       mapped_args = args.map {|a| convert(a, scope, '') }
       result = scope.send("function_#{name}", mapped_args)
       # Prevent non r-value functions from leaking their result (they are not written to care about this)
       Puppet::Parser::Functions.rvalue?(name) ? result : nil
     end
   end
 
   # The o is used for source reference
   def create_resource_parameter(o, scope, name, value, operator)
     file, line = extract_file_line(o)
     Puppet::Parser::Resource::Param.new(
       :name   => name,
       :value  => convert(value, scope, nil), # converted to 3x since 4x supports additional objects / types
       :source => scope.source, :line => line, :file => file,
       :add    => operator == :'+>'
     )
   end
 
   CLASS_STRING = 'class'.freeze
 
   def create_resources(o, scope, virtual, exported, type_name, resource_titles, evaluated_parameters)
 
     # TODO: Unknown resource causes creation of Resource to fail with ArgumentError, should give
     # a proper Issue. Now the result is "Error while evaluating a Resource Statement" with the message
     # from the raised exception. (It may be good enough).
 
     # resolve in scope.
     fully_qualified_type, resource_titles = scope.resolve_type_and_titles(type_name, resource_titles)
 
     # Not 100% accurate as this is the resource expression location and each title is processed separately
     # The titles are however the result of evaluation and they have no location at this point (an array
     # of positions for the source expressions are required for this to work).
     # TODO: Revisit and possible improve the accuracy.
     #
     file, line = extract_file_line(o)
     # Build a resource for each title
     resource_titles.map do |resource_title|
         resource = Puppet::Parser::Resource.new(
           fully_qualified_type, resource_title,
           :parameters => evaluated_parameters,
           :file => file,
           :line => line,
           :exported => exported,
           :virtual => virtual,
           # WTF is this? Which source is this? The file? The name of the context ?
           :source => scope.source,
           :scope => scope,
           :strict => true
         )
 
         if resource.resource_type.is_a? Puppet::Resource::Type
           resource.resource_type.instantiate_resource(scope, resource)
         end
         scope.compiler.add_resource(scope, resource)
-        scope.compiler.evaluate_classes([resource_title], scope, false) if fully_qualified_type == CLASS_STRING
+        scope.compiler.evaluate_classes([resource_title], scope, false, true) if fully_qualified_type == CLASS_STRING
         # Turn the resource into a PType (a reference to a resource type)
         # weed out nil's
         resource_to_ptype(resource)
     end
   end
 
   # Defines default parameters for a type with the given name.
   #
   def create_resource_defaults(o, scope, type_name, evaluated_parameters)
     # Note that name must be capitalized in this 3x call
     # The 3x impl creates a Resource instance with a bogus title and then asks the created resource
     # for the type of the name.
     # Note, locations are available per parameter.
     #
     scope.define_settings(capitalize_qualified_name(type_name), evaluated_parameters)
   end
 
   # Capitalizes each segment of a qualified name
   #
   def capitalize_qualified_name(name)
     name.split(/::/).map(&:capitalize).join(NAME_SPACE_SEPARATOR)
   end
 
   # Creates resource overrides for all resource type objects in evaluated_resources. The same set of
   # evaluated parameters are applied to all.
   #
   def create_resource_overrides(o, scope, evaluated_resources, evaluated_parameters)
     # Not 100% accurate as this is the resource expression location and each title is processed separately
     # The titles are however the result of evaluation and they have no location at this point (an array
     # of positions for the source expressions are required for this to work.
     # TODO: Revisit and possible improve the accuracy.
     #
     file, line = extract_file_line(o)
 
     evaluated_resources.each do |r|
       unless r.is_a?(Puppet::Pops::Types::PResourceType) && r.type_name != 'class'
         fail(Puppet::Pops::Issues::ILLEGAL_OVERRIDEN_TYPE, o, {:actual => r} )
       end
       resource = Puppet::Parser::Resource.new(
       r.type_name, r.title,
         :parameters => evaluated_parameters,
         :file => file,
         :line => line,
         # WTF is this? Which source is this? The file? The name of the context ?
         :source => scope.source,
         :scope => scope
       )
 
       scope.compiler.add_override(resource)
     end
   end
 
   # Finds a resource given a type and a title.
   #
   def find_resource(scope, type_name, title)
     scope.compiler.findresource(type_name, title)
   end
 
   # Returns the value of a resource's parameter by first looking up the parameter in the resource
   # and then in the defaults for the resource. Since the resource exists (it must in order to look up its
   # parameters, any overrides have already been applied). Defaults are not applied to a resource until it
   # has been finished (which typically has not taken place when this is evaluated; hence the dual lookup).
   #
   def get_resource_parameter_value(scope, resource, parameter_name)
     # This gets the parameter value, or nil (for both valid parameters and parameters that do not exist).
     val = resource[parameter_name]
 
     # Sometimes the resource is a Puppet::Parser::Resource and sometimes it is
     # a Puppet::Resource. The Puppet::Resource case occurs when puppet language
     # is evaluated against an already completed catalog (where all instances of
     # Puppet::Parser::Resource are converted to Puppet::Resource instances).
     # Evaluating against an already completed catalog is really only found in
     # the language specification tests, where the puppet language is used to
     # test itself.
     if resource.is_a?(Puppet::Parser::Resource)
       # The defaults must be looked up in the scope where the resource was created (not in the given
       # scope where the lookup takes place.
       resource_scope = resource.scope
       if val.nil? && resource_scope && defaults = resource_scope.lookupdefaults(resource.type)
         # NOTE: 3x resource keeps defaults as hash using symbol for name as key to Parameter which (again) holds
         # name and value.
         # NOTE: meta parameters that are unset ends up here, and there are no defaults for those encoded
         # in the defaults, they may receive hardcoded defaults later (e.g. 'tag').
         param = defaults[parameter_name.to_sym]
         # Some parameters (meta parameters like 'tag') does not return a param from which the value can be obtained
         # at all times. Instead, they return a nil param until a value has been set.
         val = param.nil? ? nil : param.value
       end
     end
     val
   end
 
   # Returns true, if the given name is the name of a resource parameter.
   #
   def is_parameter_of_resource?(scope, resource, name)
     return false unless name.is_a?(String)
     resource.valid_parameter?(name)
   end
 
   def resource_to_ptype(resource)
     nil if resource.nil?
     # inference returns the meta type since the 3x Resource is an alternate way to describe a type
     type_calculator.infer(resource).type
   end
 
   # This is the same type of "truth" as used in the current Puppet DSL.
   #
   def is_true? o
     # Is the value true?  This allows us to control the definition of truth
     # in one place.
     case o
     # Support :undef since it may come from a 3x structure
     when :undef
       false
     else
       !!o
     end
   end
 
   # Utility method for TrueClass || FalseClass
   # @param x [Object] the object to test if it is instance of TrueClass or FalseClass
   def is_boolean? x
     x.is_a?(TrueClass) || x.is_a?(FalseClass)
   end
 
   def initialize
     @@convert_visitor   ||= Puppet::Pops::Visitor.new(self, "convert", 2, 2)
     @@convert2_visitor   ||= Puppet::Pops::Visitor.new(self, "convert2", 2, 2)
   end
 
   # Converts 4x supported values to 3x values. This is required because
   # resources and other objects do not know about the new type system, and does not support
   # regular expressions. Unfortunately this has to be done for array and hash as well.
   # A complication is that catalog types needs to be resolved against the scope.
   #
   def convert(o, scope, undef_value)
     @@convert_visitor.visit_this_2(self, o, scope, undef_value)
   end
 
   # Converts nested 4x supported values to 3x values. This is required because
   # resources and other objects do not know about the new type system, and does not support
   # regular expressions. Unfortunately this has to be done for array and hash as well.
   # A complication is that catalog types needs to be resolved against the scope.
   #
   def convert2(o, scope, undef_value)
     @@convert2_visitor.visit_this_2(self, o, scope, undef_value)
   end
 
 
   def convert_NilClass(o, scope, undef_value)
     undef_value
   end
 
   def convert2_NilClass(o, scope, undef_value)
     :undef
   end
 
   def convert_String(o, scope, undef_value)
     # although wasteful, needed because user code may mutate these strings in Resources
     o.frozen? ? o.dup : o
   end
   alias convert2_String :convert_String
 
   def convert_Object(o, scope, undef_value)
     o
   end
   alias :convert2_Object :convert_Object
 
   def convert_Array(o, scope, undef_value)
     o.map {|x| convert2(x, scope, undef_value) }
   end
   alias :convert2_Array :convert_Array
 
   def convert_Hash(o, scope, undef_value)
     result = {}
     o.each {|k,v| result[convert2(k, scope, undef_value)] = convert2(v, scope, undef_value) }
     result
   end
   alias :convert2_Hash :convert_Hash
 
   def convert_Regexp(o, scope, undef_value)
     # Puppet 3x cannot handle parameter values that are reqular expressions. Turn into regexp string in
     # source form
     o.inspect
   end
   alias :convert2_Regexp :convert_Regexp
 
   def convert_Symbol(o, scope, undef_value)
     case o
     # Support :undef since it may come from a 3x structure
     when :undef
       undef_value  # 3x wants undef as either empty string or :undef
     else
       o   # :default, and all others are verbatim since they are new in future evaluator
     end
   end
 
   # The :undef symbol should not be converted when nested in arrays or hashes
   def convert2_Symbol(o, scope, undef_value)
     o
   end
 
   def convert_PAnyType(o, scope, undef_value)
     o
   end
   alias :convert2_PAnyType :convert_PAnyType
 
   def convert_PCatalogEntryType(o, scope, undef_value)
     # Since 4x does not support dynamic scoping, all names are absolute and can be
     # used as is (with some check/transformation/mangling between absolute/relative form
     # due to Puppet::Resource's idiosyncratic behavior where some references must be
     # absolute and others cannot be.
     # Thus there is no need to call scope.resolve_type_and_titles to do dynamic lookup.
 
     Puppet::Resource.new(*catalog_type_to_split_type_title(o))
   end
   alias :convert2_PCatalogEntryType :convert_PCatalogEntryType
 
   private
 
   # Produces an array with [type, title] from a PCatalogEntryType
   # This method is used to produce the arguments for creation of reference resource instances
   # (used when 3x is operating on a resource).
   # Ensures that resources are *not* absolute.
   #
   def catalog_type_to_split_type_title(catalog_type)
     split_type = catalog_type.is_a?(Puppet::Pops::Types::PType) ? catalog_type.type : catalog_type
     case split_type
     when Puppet::Pops::Types::PHostClassType
       class_name = split_type.class_name
       ['class', class_name.nil? ? nil : class_name.sub(/^::/, '')]
     when Puppet::Pops::Types::PResourceType
       type_name = split_type.type_name
       title = split_type.title
       if type_name =~ /^(::)?[Cc]lass/
         ['class', title.nil? ? nil : title.sub(/^::/, '')]
       else
         # Ensure that title is '' if nil
         # Resources with absolute name always results in error because tagging does not support leading ::
         [type_name.nil? ? nil : type_name.sub(/^::/, ''), title.nil? ? '' : title]
       end
     else
       raise ArgumentError, "Cannot split the type #{catalog_type.class}, it represents neither a PHostClassType, nor a PResourceType."
     end
   end
 
   def extract_file_line(o)
     source_pos = Puppet::Pops::Utils.find_closest_positioned(o)
     return [nil, -1] unless source_pos
     [source_pos.locator.file, source_pos.line]
   end
 
   def find_closest_positioned(o)
     return nil if o.nil? || o.is_a?(Puppet::Pops::Model::Program)
     o.offset.nil? ? find_closest_positioned(o.eContainer) : Puppet::Pops::Adapters::SourcePosAdapter.adapt(o)
   end
 
   # Creates a diagnostic producer
   def diagnostic_producer
     Puppet::Pops::Validation::DiagnosticProducer.new(
       ExceptionRaisingAcceptor.new(),                   # Raises exception on all issues
       SeverityProducer.new(), # All issues are errors
       Puppet::Pops::Model::ModelLabelProvider.new())
   end
 
   # Configure the severity of failures
   class SeverityProducer < Puppet::Pops::Validation::SeverityProducer
     Issues = Puppet::Pops::Issues
 
     def initialize
       super
       p = self
       # Issues triggering warning only if --debug is on
       if Puppet[:debug]
         p[Issues::EMPTY_RESOURCE_SPECIALIZATION] = :warning
       else
         p[Issues::EMPTY_RESOURCE_SPECIALIZATION] = :ignore
       end
 
       # Store config issues, ignore or warning
       p[Issues::RT_NO_STORECONFIGS_EXPORT]    = Puppet[:storeconfigs] ? :ignore : :warning
       p[Issues::RT_NO_STORECONFIGS]           = Puppet[:storeconfigs] ? :ignore : :warning
     end
   end
 
   # An acceptor of diagnostics that immediately raises an exception.
   class ExceptionRaisingAcceptor < Puppet::Pops::Validation::Acceptor
     def accept(diagnostic)
       super
       Puppet::Pops::IssueReporter.assert_and_report(self, {:message => "Evaluation Error:", :emit_warnings => true })
       if errors?
         raise ArgumentError, "Internal Error: Configuration of runtime error handling wrong: should have raised exception"
       end
     end
   end
 
   class EvaluationError < StandardError
   end
 end
diff --git a/lib/puppet/pops/loaders.rb b/lib/puppet/pops/loaders.rb
index a07761bc7..6109fcb13 100644
--- a/lib/puppet/pops/loaders.rb
+++ b/lib/puppet/pops/loaders.rb
@@ -1,238 +1,238 @@
 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(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(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 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()
     Puppet::Pops::Loader::ModuleLoaders.system_loader_from(static_loader, self)
   end
 
   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.
 
     # The environment is not a namespace, so give it a nil "module_name"
     module_name = nil
     loader_name = "environment:#{environment.name}"
     env_conf = Puppet.lookup(:environments).get_conf(environment.name)
     if env_conf.nil? || !env_conf.is_a?(Puppet::Settings::EnvironmentConf)
       # Not a real directory environment, cannot work as a module TODO: Drop when legacy env are dropped?
       loader = Puppet::Pops::Loader::SimpleEnvironmentLoader.new(puppet_system_loader, loader_name)
     else
       # View the environment as a module to allow loading from it - this module is always called 'environment'
       loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(puppet_system_loader, self, 'environment', env_conf.path_to_env)
     end
 
     # An environment has a module path even if it has a null loader
     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, environment)
     @module_resolver = mr = ModuleResolver.new()
     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.module_loader_from(parent_loader, self, md.name, md.path)
     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
 
     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.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].public_loader }
       Puppet::Pops::Loader::DependencyLoader.new(from_module_data.public_loader, from_module_data.name, dependency_loaders)
     end
   end
 end
diff --git a/lib/puppet/resource/type.rb b/lib/puppet/resource/type.rb
index d59ad446e..e60fd1167 100644
--- a/lib/puppet/resource/type.rb
+++ b/lib/puppet/resource/type.rb
@@ -1,372 +1,395 @@
 require 'puppet/parser'
 require 'puppet/util/warnings'
 require 'puppet/util/errors'
 require 'puppet/parser/ast/leaf'
 
 # Puppet::Resource::Type represents nodes, classes and defined types.
 #
 # It has a standard format for external consumption, usable from the
 # resource_type indirection via rest and the resource_type face. See the
 # {file:api_docs/http_resource_type.md#Schema resource type schema
 # description}.
 #
 # @api public
 class Puppet::Resource::Type
   Puppet::ResourceType = self
   include Puppet::Util::Warnings
   include Puppet::Util::Errors
 
   RESOURCE_KINDS = [:hostclass, :node, :definition]
 
   # Map the names used in our documentation to the names used internally
   RESOURCE_KINDS_TO_EXTERNAL_NAMES = {
       :hostclass => "class",
       :node => "node",
       :definition => "defined_type",
   }
   RESOURCE_EXTERNAL_NAMES_TO_KINDS = RESOURCE_KINDS_TO_EXTERNAL_NAMES.invert
 
   attr_accessor :file, :line, :doc, :code, :parent, :resource_type_collection
   attr_reader :namespace, :arguments, :behaves_like, :module_name
 
   # Map from argument (aka parameter) names to Puppet Type
   # @return [Hash<Symbol, Puppet::Pops::Types::PAnyType] map from name to type
   #
   attr_reader :argument_types
 
   # This should probably be renamed to 'kind' eventually, in accordance with the changes
   #  made for serialization and API usability (#14137).  At the moment that seems like
   #  it would touch a whole lot of places in the code, though.  --cprice 2012-04-23
   attr_reader :type
 
   RESOURCE_KINDS.each do |t|
     define_method("#{t}?") { self.type == t }
   end
 
   require 'puppet/indirector'
   extend Puppet::Indirector
   indirects :resource_type, :terminus_class => :parser
 
   def self.from_data_hash(data)
     name = data.delete('name') or raise ArgumentError, "Resource Type names must be specified"
     kind = data.delete('kind') || "definition"
 
     unless type = RESOURCE_EXTERNAL_NAMES_TO_KINDS[kind]
       raise ArgumentError, "Unsupported resource kind '#{kind}'"
     end
 
     data = data.inject({}) { |result, ary| result[ary[0].intern] = ary[1]; result }
 
     # External documentation uses "parameters" but the internal name
     # is "arguments"
     data[:arguments] = data.delete(:parameters)
 
     new(type, name, data)
   end
 
   def to_data_hash
     data = [:doc, :line, :file, :parent].inject({}) do |hash, param|
       next hash unless (value = self.send(param)) and (value != "")
       hash[param.to_s] = value
       hash
     end
 
     # External documentation uses "parameters" but the internal name
     # is "arguments"
     data['parameters'] = arguments.dup unless arguments.empty?
 
     data['name'] = name
 
     unless RESOURCE_KINDS_TO_EXTERNAL_NAMES.has_key?(type)
       raise ArgumentError, "Unsupported resource kind '#{type}'"
     end
     data['kind'] = RESOURCE_KINDS_TO_EXTERNAL_NAMES[type]
     data
   end
 
   # Are we a child of the passed class?  Do a recursive search up our
   # parentage tree to figure it out.
   def child_of?(klass)
     return false unless parent
 
     return(klass == parent_type ? true : parent_type.child_of?(klass))
   end
 
   # Now evaluate the code associated with this class or definition.
   def evaluate_code(resource)
 
     static_parent = evaluate_parent_type(resource)
     scope = static_parent || resource.scope
 
     scope = scope.newscope(:namespace => namespace, :source => self, :resource => resource) unless resource.title == :main
     scope.compiler.add_class(name) unless definition?
 
     set_resource_parameters(resource, scope)
 
     resource.add_edge_to_stage
 
     if code
       if @match # Only bother setting up the ephemeral scope if there are match variables to add into it
         begin
           elevel = scope.ephemeral_level
           scope.ephemeral_from(@match, file, line)
           code.safeevaluate(scope)
         ensure
           scope.unset_ephemeral_var(elevel)
         end
       else
         code.safeevaluate(scope)
       end
     end
   end
 
   def initialize(type, name, options = {})
     @type = type.to_s.downcase.to_sym
     raise ArgumentError, "Invalid resource supertype '#{type}'" unless RESOURCE_KINDS.include?(@type)
 
     name = convert_from_ast(name) if name.is_a?(Puppet::Parser::AST::HostName)
 
     set_name_and_namespace(name)
 
     [:code, :doc, :line, :file, :parent].each do |param|
       next unless value = options[param]
       send(param.to_s + "=", value)
     end
 
     set_arguments(options[:arguments])
     set_argument_types(options[:argument_types])
 
     @match = nil
 
     @module_name = options[:module_name]
   end
 
   # This is only used for node names, and really only when the node name
   # is a regexp.
   def match(string)
     return string.to_s.downcase == name unless name_is_regex?
 
     @match = @name.match(string)
   end
 
   # Add code from a new instance to our code.
   def merge(other)
     fail "#{name} is not a class; cannot add code to it" unless type == :hostclass
     fail "#{other.name} is not a class; cannot add code from it" unless other.type == :hostclass
     fail "Cannot have code outside of a class/node/define because 'freeze_main' is enabled" if name == "" and Puppet.settings[:freeze_main]
 
     if parent and other.parent and parent != other.parent
       fail "Cannot merge classes with different parent classes (#{name} => #{parent} vs. #{other.name} => #{other.parent})"
     end
 
     # We know they're either equal or only one is set, so keep whichever parent is specified.
     self.parent ||= other.parent
 
     if other.doc
       self.doc ||= ""
       self.doc += other.doc
     end
 
     # This might just be an empty, stub class.
     return unless other.code
 
     unless self.code
       self.code = other.code
       return
     end
 
     self.code = Puppet::Parser::ParserFactory.code_merger.concatenate([self, other])
   end
 
   # Make an instance of the resource type, and place it in the catalog
   # if it isn't in the catalog already.  This is only possible for
   # classes and nodes.  No parameters are be supplied--if this is a
   # parameterized class, then all parameters take on their default
   # values.
   def ensure_in_catalog(scope, parameters=nil)
     type == :definition and raise ArgumentError, "Cannot create resources for defined resource types"
     resource_type = type == :hostclass ? :class : :node
 
     # Do nothing if the resource already exists; this makes sure we don't
     # get multiple copies of the class resource, which helps provide the
     # singleton nature of classes.
     # we should not do this for classes with parameters
     # if parameters are passed, we should still try to create the resource
     # even if it exists so that we can fail
     # this prevents us from being able to combine param classes with include
     if resource = scope.catalog.resource(resource_type, name) and !parameters
       return resource
     end
     resource = Puppet::Parser::Resource.new(resource_type, name, :scope => scope, :source => self)
     assign_parameter_values(parameters, resource)
     instantiate_resource(scope, resource)
     scope.compiler.add_resource(scope, resource)
     resource
   end
 
   def instantiate_resource(scope, resource)
     # Make sure our parent class has been evaluated, if we have one.
     if parent && !scope.catalog.resource(resource.type, parent)
       parent_type(scope).ensure_in_catalog(scope)
     end
 
     if ['Class', 'Node'].include? resource.type
       scope.catalog.tag(*resource.tags)
     end
   end
 
   def name
     return @name unless @name.is_a?(Regexp)
     @name.source.downcase.gsub(/[^-\w:.]/,'').sub(/^\.+/,'')
   end
 
   def name_is_regex?
     @name.is_a?(Regexp)
   end
 
   def assign_parameter_values(parameters, resource)
     return unless parameters
 
     # It'd be nice to assign default parameter values here,
     # but we can't because they often rely on local variables
     # created during set_resource_parameters.
     parameters.each do |name, value|
       resource.set_parameter name, value
     end
   end
 
+  # MQR TODO:
+  #
+  # The change(s) introduced by the fix for #4270 are mostly silly & should be
+  # removed, though we didn't realize it at the time.  If it can be established/
+  # ensured that nodes never call parent_type and that resource_types are always
+  # (as they should be) members of exactly one resource_type_collection the
+  # following method could / should be replaced with:
+  #
+  # def parent_type
+  #   @parent_type ||= parent && (
+  #     resource_type_collection.find_or_load([name],parent,type.to_sym) ||
+  #     fail Puppet::ParseError, "Could not find parent resource type '#{parent}' of type #{type} in #{resource_type_collection.environment}"
+  #   )
+  # end
+  #
+  # ...and then the rest of the changes around passing in scope reverted.
+  #
   def parent_type(scope = nil)
     return nil unless parent
 
-    @parent_type ||= scope.environment.known_resource_types.send("find_#{type}", parent) ||
-      fail(Puppet::ParseError, "Could not find parent resource type '#{parent}' of type #{type} in #{scope.environment}")
+    unless @parent_type
+      raise "Must pass scope to parent_type when called first time" unless scope
+      unless @parent_type = scope.environment.known_resource_types.send("find_#{type}", [name], parent)
+        fail Puppet::ParseError, "Could not find parent resource type '#{parent}' of type #{type} in #{scope.environment}"
+      end
+    end
+
+    @parent_type
   end
 
   # Set any arguments passed by the resource as variables in the scope.
   def set_resource_parameters(resource, scope)
     set = {}
     resource.to_hash.each do |param, value|
       param = param.to_sym
       fail Puppet::ParseError, "#{resource.ref} does not accept attribute #{param}" unless valid_parameter?(param)
 
       exceptwrap { scope[param.to_s] = value }
 
       set[param] = true
     end
 
     if @type == :hostclass
       scope["title"] = resource.title.to_s.downcase unless set.include? :title
       scope["name"] =  resource.name.to_s.downcase  unless set.include? :name
     else
       scope["title"] = resource.title               unless set.include? :title
       scope["name"] =  resource.name                unless set.include? :name
     end
     scope["module_name"] = module_name if module_name and ! set.include? :module_name
 
     if caller_name = scope.parent_module_name and ! set.include?(:caller_module_name)
       scope["caller_module_name"] = caller_name
     end
     scope.class_set(self.name,scope) if hostclass? or node?
 
     # Evaluate the default parameters, now that all other variables are set
     default_params = resource.set_default_parameters(scope)
     default_params.each { |param| scope[param] = resource[param] }
 
     # This has to come after the above parameters so that default values
     # can use their values
     resource.validate_complete
   end
 
   # Check whether a given argument is valid.
   def valid_parameter?(param)
     param = param.to_s
 
     return true if param == "name"
     return true if Puppet::Type.metaparam?(param)
     return false unless defined?(@arguments)
     return(arguments.include?(param) ? true : false)
   end
 
   def set_arguments(arguments)
     @arguments = {}
     return if arguments.nil?
 
     arguments.each do |arg, default|
       arg = arg.to_s
       warn_if_metaparam(arg, default)
       @arguments[arg] = default
     end
   end
 
   # Sets the argument name to Puppet Type hash used for type checking.
   # Names must correspond to available arguments (they must be defined first).
   # Arguments not mentioned will not be type-checked.
   #
   def set_argument_types(name_to_type_hash)
     @argument_types = {}
     return unless name_to_type_hash
     name_to_type_hash.each do |name, t|
       # catch internal errors
       unless @arguments.include?(name)
         raise Puppet::DevError, "Parameter '#{name}' is given a type, but is not a valid parameter."
       end
       unless t.is_a? Puppet::Pops::Types::PAnyType
         raise Puppet::DevError, "Parameter '#{name}' is given a type that is not a Puppet Type, got #{t.class}"
       end
       @argument_types[name] = t
     end
   end
 
   private
 
   def convert_from_ast(name)
     value = name.value
     if value.is_a?(Puppet::Parser::AST::Regex)
       name = value.value
     else
       name = value
     end
   end
 
   def evaluate_parent_type(resource)
     return unless klass = parent_type(resource.scope) and parent_resource = resource.scope.compiler.catalog.resource(:class, klass.name) || resource.scope.compiler.catalog.resource(:node, klass.name)
     parent_resource.evaluate unless parent_resource.evaluated?
     parent_scope(resource.scope, klass)
   end
 
   # Split an fq name into a namespace and name
   def namesplit(fullname)
     ary = fullname.split("::")
     n = ary.pop || ""
     ns = ary.join("::")
     return ns, n
   end
 
   def parent_scope(scope, klass)
     scope.class_scope(klass) || raise(Puppet::DevError, "Could not find scope for #{klass.name}")
   end
 
   def set_name_and_namespace(name)
     if name.is_a?(Regexp)
       @name = name
       @namespace = ""
     else
       @name = name.to_s.downcase
 
       # Note we're doing something somewhat weird here -- we're setting
       # the class's namespace to its fully qualified name.  This means
       # anything inside that class starts looking in that namespace first.
       @namespace, ignored_shortname = @type == :hostclass ? [@name, ''] : namesplit(@name)
     end
   end
 
   def warn_if_metaparam(param, default)
     return unless Puppet::Type.metaparamclass(param)
 
     if default
       warnonce "#{param} is a metaparam; this value will inherit to all contained resources in the #{self.name} definition"
     else
       raise Puppet::ParseError, "#{param} is a metaparameter; please choose another parameter name in the #{self.name} definition"
     end
   end
 end
diff --git a/lib/puppet/resource/type_collection.rb b/lib/puppet/resource/type_collection.rb
index 5d46807ca..1e1be3430 100644
--- a/lib/puppet/resource/type_collection.rb
+++ b/lib/puppet/resource/type_collection.rb
@@ -1,183 +1,215 @@
 require 'puppet/parser/type_loader'
 require 'puppet/util/file_watcher'
 require 'puppet/util/warnings'
 
 class Puppet::Resource::TypeCollection
   attr_reader :environment
   attr_accessor :parse_failed
 
   include Puppet::Util::Warnings
 
   def clear
     @hostclasses.clear
     @definitions.clear
     @nodes.clear
     @notfound.clear
   end
 
   def initialize(env)
     @environment = env
     @hostclasses = {}
     @definitions = {}
     @nodes = {}
     @notfound = {}
 
     # So we can keep a list and match the first-defined regex
     @node_list = []
   end
 
   def import_ast(ast, modname)
     ast.instantiate(modname).each do |instance|
       add(instance)
     end
   end
 
   def inspect
     "TypeCollection" + { :hostclasses => @hostclasses.keys, :definitions => @definitions.keys, :nodes => @nodes.keys }.inspect
   end
 
   def <<(thing)
     add(thing)
     self
   end
 
   def add(instance)
     if instance.type == :hostclass and other = @hostclasses[instance.name] and other.type == :hostclass
       other.merge(instance)
       return other
     end
     method = "add_#{instance.type}"
     send(method, instance)
     instance.resource_type_collection = self
     instance
   end
 
   def add_hostclass(instance)
     dupe_check(instance, @hostclasses) { |dupe| "Class '#{instance.name}' is already defined#{dupe.error_context}; cannot redefine" }
     dupe_check(instance, @definitions) { |dupe| "Definition '#{instance.name}' is already defined#{dupe.error_context}; cannot be redefined as a class" }
 
     @hostclasses[instance.name] = instance
     instance
   end
 
   def hostclass(name)
     @hostclasses[munge_name(name)]
   end
 
   def add_node(instance)
     dupe_check(instance, @nodes) { |dupe| "Node '#{instance.name}' is already defined#{dupe.error_context}; cannot redefine" }
 
     @node_list << instance
     @nodes[instance.name] = instance
     instance
   end
 
   def loader
     @loader ||= Puppet::Parser::TypeLoader.new(environment)
   end
 
   def node(name)
     name = munge_name(name)
 
     if node = @nodes[name]
       return node
     end
 
     @node_list.each do |node|
       next unless node.name_is_regex?
       return node if node.match(name)
     end
     nil
   end
 
   def node_exists?(name)
     @nodes[munge_name(name)]
   end
 
   def nodes?
     @nodes.length > 0
   end
 
   def add_definition(instance)
     dupe_check(instance, @hostclasses) { |dupe| "'#{instance.name}' is already defined#{dupe.error_context} as a class; cannot redefine as a definition" }
     dupe_check(instance, @definitions) { |dupe| "Definition '#{instance.name}' is already defined#{dupe.error_context}; cannot be redefined" }
     @definitions[instance.name] = instance
   end
 
   def definition(name)
     @definitions[munge_name(name)]
   end
 
-  def find_node(name)
+  def find_node(namespaces, name)
     @nodes[munge_name(name)]
   end
 
-  def find_hostclass(name)
-    find_or_load(name, :hostclass)
+  def find_hostclass(namespaces, name, options = {})
+    find_or_load(namespaces, name, :hostclass, options)
   end
 
-  def find_definition(name)
-    find_or_load(name, :definition)
+  def find_definition(namespaces, name)
+    find_or_load(namespaces, name, :definition)
   end
 
   [:hostclasses, :nodes, :definitions].each do |m|
     define_method(m) do
       instance_variable_get("@#{m}").dup
     end
   end
 
   def parse_failed?
     @parse_failed
   end
 
   def version
     if !defined?(@version)
       if environment.config_version.nil? || environment.config_version == ""
         @version = Time.now.to_i
       else
         @version = Puppet::Util::Execution.execute([environment.config_version]).strip
       end
     end
 
     @version
   rescue Puppet::ExecutionFailure => e
     raise Puppet::ParseError, "Execution of config_version command `#{environment.config_version}` failed: #{e.message}", e.backtrace
   end
 
   private
 
-  COLON_COLON = "::".freeze
+  # Return a list of all possible fully-qualified names that might be
+  # meant by the given name, in the context of namespaces.
+  def resolve_namespaces(namespaces, name)
+    name      = name.downcase
+    if name =~ /^::/
+      # name is explicitly fully qualified, so just return it, sans
+      # initial "::".
+      return [name.sub(/^::/, '')]
+    end
+    if name == ""
+      # The name "" has special meaning--it always refers to a "main"
+      # hostclass which contains all toplevel resources.
+      return [""]
+    end
+
+    namespaces = [namespaces] unless namespaces.is_a?(Array)
+    namespaces = namespaces.collect { |ns| ns.downcase }
+
+    result = []
+    namespaces.each do |namespace|
+      ary = namespace.split("::")
+
+      # Search each namespace nesting in innermost-to-outermost order.
+      while ary.length > 0
+        result << "#{ary.join("::")}::#{name}"
+        ary.pop
+      end
+
+      # Finally, search the toplevel namespace.
+      result << name
+    end
+
+    return result.uniq
+  end
 
   # Resolve namespaces and find the given object.  Autoload it if
   # necessary.
-  def find_or_load(name, type)
-    # Name is always absolute, but may start with :: which must be removed
-    fqname = (name[0,2] == COLON_COLON ? name[2..-1] : name)
-
-    result = send(type, fqname)
-    unless result
-      if @notfound[ fqname ] && Puppet[ :ignoremissingtypes ]
-        # do not try to autoload if we already tried and it wasn't conclusive
-        # as this is a time consuming operation. Warn the user.
-        # Check first if debugging is on since the call to debug_once is expensive
-        if Puppet[:debug]
+  def find_or_load(namespaces, name, type, options = {})
+    searchspace = options[:assume_fqname] ? [name].flatten : resolve_namespaces(namespaces, name)
+    searchspace.each do |fqname|
+      result = send(type, fqname)
+      unless result
+        if @notfound[fqname] and Puppet[:ignoremissingtypes]
+          # do not try to autoload if we already tried and it wasn't conclusive
+          # as this is a time consuming operation. Warn the user.
           debug_once "Not attempting to load #{type} #{fqname} as this object was missing during a prior compilation"
+        else
+          result = loader.try_load_fqname(type, fqname)
+          @notfound[fqname] = result.nil?
         end
-      else
-        result = loader.try_load_fqname(type, fqname)
-        @notfound[ fqname ] = result.nil?
       end
+      return result if result
     end
-    result
+
+    return nil
   end
 
   def munge_name(name)
     name.to_s.downcase
   end
 
   def dupe_check(instance, hash)
     return unless dupe = hash[instance.name]
     message = yield dupe
     instance.fail Puppet::ParseError, message
   end
 end
diff --git a/lib/puppet/settings.rb b/lib/puppet/settings.rb
index 46be3c07c..895abd495 100644
--- a/lib/puppet/settings.rb
+++ b/lib/puppet/settings.rb
@@ -1,1461 +1,1461 @@
 require 'puppet'
 require 'getoptlong'
 require 'puppet/util/watched_file'
 require 'puppet/util/command_line/puppet_option_parser'
 require 'forwardable'
 
 # The class for handling configuration files.
 class Puppet::Settings
   extend Forwardable
   include Enumerable
 
   require 'puppet/settings/errors'
   require 'puppet/settings/base_setting'
   require 'puppet/settings/string_setting'
   require 'puppet/settings/enum_setting'
   require 'puppet/settings/array_setting'
   require 'puppet/settings/file_setting'
   require 'puppet/settings/directory_setting'
   require 'puppet/settings/file_or_directory_setting'
   require 'puppet/settings/path_setting'
   require 'puppet/settings/boolean_setting'
   require 'puppet/settings/terminus_setting'
   require 'puppet/settings/duration_setting'
   require 'puppet/settings/ttl_setting'
   require 'puppet/settings/priority_setting'
   require 'puppet/settings/autosign_setting'
   require 'puppet/settings/config_file'
   require 'puppet/settings/value_translator'
   require 'puppet/settings/environment_conf'
 
   # local reference for convenience
   PuppetOptionParser = Puppet::Util::CommandLine::PuppetOptionParser
 
   attr_accessor :files
   attr_reader :timer
 
   # These are the settings that every app is required to specify; there are
   # reasonable defaults defined in application.rb.
   REQUIRED_APP_SETTINGS = [:logdir, :confdir, :vardir]
 
   # The acceptable sections of the puppet.conf configuration file.
   ALLOWED_SECTION_NAMES = ['main', 'master', 'agent', 'user'].freeze
 
   # This method is intended for puppet internal use only; it is a convenience method that
   # returns reasonable application default settings values for a given run_mode.
   def self.app_defaults_for_run_mode(run_mode)
     {
         :name     => run_mode.to_s,
         :run_mode => run_mode.name,
         :confdir  => run_mode.conf_dir,
         :vardir   => run_mode.var_dir,
         :rundir   => run_mode.run_dir,
         :logdir   => run_mode.log_dir,
     }
   end
 
   def self.default_certname()
     hostname = hostname_fact
     domain = domain_fact
     if domain and domain != ""
       fqdn = [hostname, domain].join(".")
     else
       fqdn = hostname
     end
     fqdn.to_s.gsub(/\.$/, '')
   end
 
   def self.hostname_fact()
     Facter.value :hostname
   end
 
   def self.domain_fact()
     Facter.value :domain
   end
 
   def self.default_config_file_name
     "puppet.conf"
   end
 
   # Create a new collection of config settings.
   def initialize
     @config = {}
     @shortnames = {}
 
     @created = []
 
     # Keep track of set values.
     @value_sets = {
       :cli => Values.new(:cli, @config),
       :memory => Values.new(:memory, @config),
       :application_defaults => Values.new(:application_defaults, @config),
       :overridden_defaults => Values.new(:overridden_defaults, @config),
     }
     @configuration_file = nil
 
     # And keep a per-environment cache
     @cache = Hash.new { |hash, key| hash[key] = {} }
     @values = Hash.new { |hash, key| hash[key] = {} }
 
     # The list of sections we've used.
     @used = []
 
     @hooks_to_call_on_application_initialization = []
     @deprecated_setting_names = []
     @deprecated_settings_that_have_been_configured = []
 
     @translate = Puppet::Settings::ValueTranslator.new
     @config_file_parser = Puppet::Settings::ConfigFile.new(@translate)
   end
 
   # @param name [Symbol] The name of the setting to fetch
   # @return [Puppet::Settings::BaseSetting] The setting object
   def setting(name)
     @config[name]
   end
 
   # Retrieve a config value
   # @param param [Symbol] the name of the setting
   # @return [Object] the value of the setting
   # @api private
   def [](param)
     if @deprecated_setting_names.include?(param)
       issue_deprecation_warning(setting(param), "Accessing '#{param}' as a setting is deprecated.")
     end
     value(param)
   end
 
   # Set a config value.  This doesn't set the defaults, it sets the value itself.
   # @param param [Symbol] the name of the setting
   # @param value [Object] the new value of the setting
   # @api private
   def []=(param, value)
     if @deprecated_setting_names.include?(param)
       issue_deprecation_warning(setting(param), "Modifying '#{param}' as a setting is deprecated.")
     end
     @value_sets[:memory].set(param, value)
     unsafe_flush_cache
   end
 
   # Create a new default value for the given setting. The default overrides are
   # higher precedence than the defaults given in defaults.rb, but lower
   # precedence than any other values for the setting. This allows one setting
   # `a` to change the default of setting `b`, but still allow a user to provide
   # a value for setting `b`.
   #
   # @param param [Symbol] the name of the setting
   # @param value [Object] the new default value for the setting
   # @api private
   def override_default(param, value)
     @value_sets[:overridden_defaults].set(param, value)
     unsafe_flush_cache
   end
 
   # Generate the list of valid arguments, in a format that GetoptLong can
   # understand, and add them to the passed option list.
   def addargs(options)
     # Add all of the settings as valid options.
     self.each { |name, setting|
       setting.getopt_args.each { |args| options << args }
     }
 
     options
   end
 
   # Generate the list of valid arguments, in a format that OptionParser can
   # understand, and add them to the passed option list.
   def optparse_addargs(options)
     # Add all of the settings as valid options.
     self.each { |name, setting|
       options << setting.optparse_args
     }
 
     options
   end
 
   # Is our setting a boolean setting?
   def boolean?(param)
     param = param.to_sym
     @config.include?(param) and @config[param].kind_of?(BooleanSetting)
   end
 
   # Remove all set values, potentially skipping cli values.
   def clear
     unsafe_clear
   end
 
   # Remove all set values, potentially skipping cli values.
   def unsafe_clear(clear_cli = true, clear_application_defaults = false)
     if clear_application_defaults
       @value_sets[:application_defaults] = Values.new(:application_defaults, @config)
       @app_defaults_initialized = false
     end
 
     if clear_cli
       @value_sets[:cli] = Values.new(:cli, @config)
 
       # Only clear the 'used' values if we were explicitly asked to clear out
       #  :cli values; otherwise, it may be just a config file reparse,
       #  and we want to retain this cli values.
       @used = []
     end
 
     @value_sets[:memory] = Values.new(:memory, @config)
     @value_sets[:overridden_defaults] = Values.new(:overridden_defaults, @config)
 
     @deprecated_settings_that_have_been_configured.clear
     @values.clear
     @cache.clear
   end
   private :unsafe_clear
 
   # Clears all cached settings for a particular environment to ensure
   # that changes to environment.conf are reflected in the settings if
   # the environment timeout has expired.
   #
   # param [String, Symbol] environment the  name of environment to clear settings for
   #
   # @api private
   def clear_environment_settings(environment)
 
     if environment.nil?
       return
     end
 
     @cache[environment.to_sym].clear
     @values[environment.to_sym] = {}
   end
 
   # Clear @cache, @used and the Environment.
   #
   # Whenever an object is returned by Settings, a copy is stored in @cache.
   # As long as Setting attributes that determine the content of returned
   # objects remain unchanged, Settings can keep returning objects from @cache
   # without re-fetching or re-generating them.
   #
   # Whenever a Settings attribute changes, such as @values or @preferred_run_mode,
   # this method must be called to clear out the caches so that updated
   # objects will be returned.
   def flush_cache
     unsafe_flush_cache
   end
 
   def unsafe_flush_cache
     clearused
   end
   private :unsafe_flush_cache
 
   def clearused
     @cache.clear
     @used = []
   end
 
   def global_defaults_initialized?()
     @global_defaults_initialized
   end
 
   def initialize_global_settings(args = [])
     raise Puppet::DevError, "Attempting to initialize global default settings more than once!" if global_defaults_initialized?
 
     # The first two phases of the lifecycle of a puppet application are:
     # 1) Parse the command line options and handle any of them that are
     #    registered, defined "global" puppet settings (mostly from defaults.rb).
     # 2) Parse the puppet config file(s).
 
     parse_global_options(args)
     parse_config_files
 
     @global_defaults_initialized = true
   end
 
   # This method is called during application bootstrapping.  It is responsible for parsing all of the
   # command line options and initializing the settings accordingly.
   #
   # It will ignore options that are not defined in the global puppet settings list, because they may
   # be valid options for the specific application that we are about to launch... however, at this point
   # in the bootstrapping lifecycle, we don't yet know what that application is.
   def parse_global_options(args)
     # Create an option parser
     option_parser = PuppetOptionParser.new
     option_parser.ignore_invalid_options = true
 
     # Add all global options to it.
     self.optparse_addargs([]).each do |option|
       option_parser.on(*option) do |arg|
         opt, val = Puppet::Settings.clean_opt(option[0], arg)
         handlearg(opt, val)
       end
     end
 
     option_parser.on('--run_mode',
                      "The effective 'run mode' of the application: master, agent, or user.",
                      :REQUIRED) do |arg|
       Puppet.settings.preferred_run_mode = arg
     end
 
     option_parser.parse(args)
 
     # remove run_mode options from the arguments so that later parses don't think
     # it is an unknown option.
     while option_index = args.index('--run_mode') do
       args.delete_at option_index
       args.delete_at option_index
     end
     args.reject! { |arg| arg.start_with? '--run_mode=' }
   end
   private :parse_global_options
 
   # A utility method (public, is used by application.rb and perhaps elsewhere) that munges a command-line
   # option string into the format that Puppet.settings expects.  (This mostly has to deal with handling the
   # "no-" prefix on flag/boolean options).
   #
   # @param [String] opt the command line option that we are munging
   # @param [String, TrueClass, FalseClass] val the value for the setting (as determined by the OptionParser)
   def self.clean_opt(opt, val)
     # rewrite --[no-]option to --no-option if that's what was given
     if opt =~ /\[no-\]/ and !val
       opt = opt.gsub(/\[no-\]/,'no-')
     end
     # otherwise remove the [no-] prefix to not confuse everybody
     opt = opt.gsub(/\[no-\]/, '')
     [opt, val]
   end
 
 
   def app_defaults_initialized?
     @app_defaults_initialized
   end
 
   def initialize_app_defaults(app_defaults)
     REQUIRED_APP_SETTINGS.each do |key|
       raise SettingsError, "missing required app default setting '#{key}'" unless app_defaults.has_key?(key)
     end
 
     app_defaults.each do |key, value|
       if key == :run_mode
         self.preferred_run_mode = value
       else
         @value_sets[:application_defaults].set(key, value)
         unsafe_flush_cache
       end
     end
     apply_metadata
     call_hooks_deferred_to_application_initialization
     issue_deprecations
 
     @app_defaults_initialized = true
   end
 
   def call_hooks_deferred_to_application_initialization(options = {})
     @hooks_to_call_on_application_initialization.each do |setting|
       begin
         setting.handle(self.value(setting.name))
       rescue InterpolationError => err
         raise InterpolationError, err, err.backtrace unless options[:ignore_interpolation_dependency_errors]
         #swallow. We're not concerned if we can't call hooks because dependencies don't exist yet
         #we'll get another chance after application defaults are initialized
       end
     end
   end
   private :call_hooks_deferred_to_application_initialization
 
   # Return a value's description.
   def description(name)
     if obj = @config[name.to_sym]
       obj.desc
     else
       nil
     end
   end
 
   def_delegator :@config, :each
 
   # Iterate over each section name.
   def eachsection
     yielded = []
     @config.each do |name, object|
       section = object.section
       unless yielded.include? section
         yield section
         yielded << section
       end
     end
   end
 
   # Return an object by name.
   def setting(param)
     param = param.to_sym
     @config[param]
   end
 
   # Handle a command-line argument.
   def handlearg(opt, value = nil)
     @cache.clear
 
     if value.is_a?(FalseClass)
       value = "false"
     elsif value.is_a?(TrueClass)
       value = "true"
     end
 
     value &&= @translate[value]
     str = opt.sub(/^--/,'')
 
     bool = true
     newstr = str.sub(/^no-/, '')
     if newstr != str
       str = newstr
       bool = false
     end
     str = str.intern
 
     if @config[str].is_a?(Puppet::Settings::BooleanSetting)
       if value == "" or value.nil?
         value = bool
       end
     end
 
     if s = @config[str]
       @deprecated_settings_that_have_been_configured << s if s.completely_deprecated?
     end
 
     @value_sets[:cli].set(str, value)
     unsafe_flush_cache
   end
 
   def include?(name)
     name = name.intern if name.is_a? String
     @config.include?(name)
   end
 
   # check to see if a short name is already defined
   def shortinclude?(short)
     short = short.intern if name.is_a? String
     @shortnames.include?(short)
   end
 
   # Prints the contents of a config file with the available config settings, or it
   # prints a single value of a config setting.
   def print_config_options
     env = value(:environment)
     val = value(:configprint)
     if val == "all"
       hash = {}
       each do |name, obj|
         val = value(name,env)
         val = val.inspect if val == ""
         hash[name] = val
       end
       hash.sort { |a,b| a[0].to_s <=> b[0].to_s }.each do |name, val|
         puts "#{name} = #{val}"
       end
     else
       val.split(/\s*,\s*/).sort.each do |v|
         if include?(v)
           #if there is only one value, just print it for back compatibility
           if v == val
             puts value(val,env)
             break
           end
           puts "#{v} = #{value(v,env)}"
         else
           puts "invalid setting: #{v}"
           return false
         end
       end
     end
     true
   end
 
   def generate_config
     puts to_config
     true
   end
 
   def generate_manifest
     puts to_manifest
     true
   end
 
   def print_configs
     return print_config_options if value(:configprint) != ""
     return generate_config if value(:genconfig)
     generate_manifest if value(:genmanifest)
   end
 
   def print_configs?
     (value(:configprint) != "" || value(:genconfig) || value(:genmanifest)) && true
   end
 
   # Return a given object's file metadata.
   def metadata(param)
     if obj = @config[param.to_sym] and obj.is_a?(FileSetting)
       {
         :owner => obj.owner,
         :group => obj.group,
         :mode => obj.mode
       }.delete_if { |key, value| value.nil? }
     else
       nil
     end
   end
 
   # Make a directory with the appropriate user, group, and mode
   def mkdir(default)
     obj = get_config_file_default(default)
 
     Puppet::Util::SUIDManager.asuser(obj.owner, obj.group) do
       mode = obj.mode || 0750
       Dir.mkdir(obj.value, mode)
     end
   end
 
   # The currently configured run mode that is preferred for constructing the application configuration.
   def preferred_run_mode
     @preferred_run_mode_name || :user
   end
 
   # PRIVATE!  This only exists because we need a hook to validate the run mode when it's being set, and
   #  it should never, ever, ever, ever be called from outside of this file.
   # This method is also called when --run_mode MODE is used on the command line to set the default
   #
   # @param mode [String|Symbol] the name of the mode to have in effect
   # @api private
   def preferred_run_mode=(mode)
     mode = mode.to_s.downcase.intern
     raise ValidationError, "Invalid run mode '#{mode}'" unless [:master, :agent, :user].include?(mode)
     @preferred_run_mode_name = mode
     # Changing the run mode has far-reaching consequences. Flush any cached
     # settings so they will be re-generated.
     flush_cache
     mode
   end
 
   # Return all of the settings associated with a given section.
   def params(section = nil)
     if section
       section = section.intern if section.is_a? String
       @config.find_all { |name, obj|
         obj.section == section
       }.collect { |name, obj|
         name
       }
     else
       @config.keys
     end
   end
 
   def parse_config(text, file = "text")
     begin
       data = @config_file_parser.parse_file(file, text, ALLOWED_SECTION_NAMES)
     rescue => detail
       Puppet.log_exception(detail, "Could not parse #{file}: #{detail}")
       return
     end
 
     # If we get here and don't have any data, we just return and don't muck with the current state of the world.
     return if data.nil?
 
     # If we get here then we have some data, so we need to clear out any
     # previous settings that may have come from config files.
     unsafe_clear(false, false)
 
     # Screen settings which have been deprecated and removed from puppet.conf
     # but are still valid on the command line and/or in environment.conf
     screen_non_puppet_conf_settings(data)
 
     # Make note of deprecated settings we will warn about later in initialization
     record_deprecations_from_puppet_conf(data)
 
     # And now we can repopulate with the values from our last parsing of the config files.
     @configuration_file = data
 
     # Determine our environment, if we have one.
     if @config[:environment]
       env = self.value(:environment).to_sym
     else
       env = "none"
     end
 
     # Call any hooks we should be calling.
     value_sets = value_sets_for(env, preferred_run_mode)
     @config.values.select(&:has_hook?).each do |setting|
       value_sets.each do |source|
         if source.include?(setting.name)
           # We still have to use value to retrieve the value, since
           # we want the fully interpolated value, not $vardir/lib or whatever.
           # This results in extra work, but so few of the settings
           # will have associated hooks that it ends up being less work this
           # way overall.
           if setting.call_hook_on_initialize?
             @hooks_to_call_on_application_initialization << setting
           else
             setting.handle(ChainedValues.new(
               preferred_run_mode,
               env,
               value_sets,
               @config).interpolate(setting.name))
           end
           break
         end
       end
     end
 
     call_hooks_deferred_to_application_initialization :ignore_interpolation_dependency_errors => true
     apply_metadata
   end
 
   # Parse the configuration file.  Just provides thread safety.
   def parse_config_files
     file = which_configuration_file
     if Puppet::FileSystem.exist?(file)
       begin
         text = read_file(file)
       rescue => detail
         Puppet.log_exception(detail, "Could not load #{file}: #{detail}")
         return
       end
     else
       return
     end
 
     parse_config(text, file)
   end
   private :parse_config_files
 
   def main_config_file
     if explicit_config_file?
       return self[:config]
     else
       return File.join(Puppet::Util::RunMode[:master].conf_dir, config_file_name)
     end
   end
   private :main_config_file
 
   def user_config_file
     return File.join(Puppet::Util::RunMode[:user].conf_dir, config_file_name)
   end
   private :user_config_file
 
   # This method is here to get around some life-cycle issues.  We need to be
   # able to determine the config file name before the settings / defaults are
   # fully loaded.  However, we also need to respect any overrides of this value
   # that the user may have specified on the command line.
   #
   # The easiest way to do this is to attempt to read the setting, and if we
   # catch an error (meaning that it hasn't been set yet), we'll fall back to
   # the default value.
   def config_file_name
     begin
       return self[:config_file_name] if self[:config_file_name]
     rescue SettingsError
       # This just means that the setting wasn't explicitly set on the command line, so we will ignore it and
       #  fall through to the default name.
     end
     return self.class.default_config_file_name
   end
   private :config_file_name
 
   def apply_metadata
     # We have to do it in the reverse of the search path,
     # because multiple sections could set the same value
     # and I'm too lazy to only set the metadata once.
     if @configuration_file
       searchpath(nil, preferred_run_mode).reverse.each do |source|
         if source.type == :section && section = @configuration_file.sections[source.name]
           apply_metadata_from_section(section)
         end
       end
     end
   end
   private :apply_metadata
 
   def apply_metadata_from_section(section)
     section.settings.each do |setting|
       if setting.has_metadata? && type = @config[setting.name]
         type.set_meta(setting.meta)
       end
     end
   end
 
   SETTING_TYPES = {
       :string     => StringSetting,
       :file       => FileSetting,
       :directory  => DirectorySetting,
       :file_or_directory => FileOrDirectorySetting,
       :path       => PathSetting,
       :boolean    => BooleanSetting,
       :terminus   => TerminusSetting,
       :duration   => DurationSetting,
       :ttl        => TTLSetting,
       :array      => ArraySetting,
       :enum       => EnumSetting,
       :priority   => PrioritySetting,
       :autosign   => AutosignSetting,
   }
 
   # Create a new setting.  The value is passed in because it's used to determine
   # what kind of setting we're creating, but the value itself might be either
   # a default or a value, so we can't actually assign it.
   #
   # See #define_settings for documentation on the legal values for the ":type" option.
   def newsetting(hash)
     klass = nil
     hash[:section] = hash[:section].to_sym if hash[:section]
 
     if type = hash[:type]
       unless klass = SETTING_TYPES[type]
         raise ArgumentError, "Invalid setting type '#{type}'"
       end
       hash.delete(:type)
     else
       # The only implicit typing we still do for settings is to fall back to "String" type if they didn't explicitly
       # specify a type.  Personally I'd like to get rid of this too, and make the "type" option mandatory... but
       # there was a little resistance to taking things quite that far for now.  --cprice 2012-03-19
       klass = StringSetting
     end
     hash[:settings] = self
     setting = klass.new(hash)
 
     setting
   end
 
   # This has to be private, because it doesn't add the settings to @config
   private :newsetting
 
   # Iterate across all of the objects in a given section.
   def persection(section)
     section = section.to_sym
     self.each { |name, obj|
       if obj.section == section
         yield obj
       end
     }
   end
 
   # Reparse our config file, if necessary.
   def reparse_config_files
     if files
       if filename = any_files_changed?
         Puppet.notice "Config file #{filename} changed; triggering re-parse of all config files."
         parse_config_files
         reuse
       end
     end
   end
 
   def files
     return @files if @files
     @files = []
     [main_config_file, user_config_file].each do |path|
       if Puppet::FileSystem.exist?(path)
         @files << Puppet::Util::WatchedFile.new(path)
       end
     end
     @files
   end
   private :files
 
   # Checks to see if any of the config files have been modified
   # @return the filename of the first file that is found to have changed, or
   #   nil if no files have changed
   def any_files_changed?
     files.each do |file|
       return file.to_str if file.changed?
     end
     nil
   end
   private :any_files_changed?
 
   def reuse
     return unless defined?(@used)
     new = @used
     @used = []
     self.use(*new)
   end
 
   class SearchPathElement < Struct.new(:name, :type); end
 
   # The order in which to search for values.
   #
   # @param environment [String,Symbol] symbolic reference to an environment name
   # @param run_mode [Symbol] symbolic reference to a Puppet run mode
   # @return [Array<SearchPathElement>]
   # @api private
   def searchpath(environment = nil, run_mode = preferred_run_mode)
     searchpath = [
       SearchPathElement.new(:memory, :values),
       SearchPathElement.new(:cli, :values),
     ]
     searchpath << SearchPathElement.new(environment.intern, :environment) if environment
     searchpath << SearchPathElement.new(run_mode, :section) if run_mode
     searchpath << SearchPathElement.new(:main, :section)
     searchpath << SearchPathElement.new(:application_defaults, :values)
     searchpath << SearchPathElement.new(:overridden_defaults, :values)
   end
 
   # Get a list of objects per section
   def sectionlist
     sectionlist = []
     self.each { |name, obj|
       section = obj.section || "puppet"
       sections[section] ||= []
       sectionlist << section unless sectionlist.include?(section)
       sections[section] << obj
     }
 
     return sectionlist, sections
   end
 
   def service_user_available?
     return @service_user_available if defined?(@service_user_available)
 
     if self[:user]
       user = Puppet::Type.type(:user).new :name => self[:user], :audit => :ensure
 
       @service_user_available = user.exists?
     else
       @service_user_available = false
     end
   end
 
   def service_group_available?
     return @service_group_available if defined?(@service_group_available)
 
     if self[:group]
       group = Puppet::Type.type(:group).new :name => self[:group], :audit => :ensure
 
       @service_group_available = group.exists?
     else
       @service_group_available = false
     end
   end
 
   # Allow later inspection to determine if the setting was set on the
   # command line, or through some other code path.  Used for the
   # `dns_alt_names` option during cert generate. --daniel 2011-10-18
   def set_by_cli?(param)
     param = param.to_sym
     !@value_sets[:cli].lookup(param).nil?
   end
 
   def set_value(param, value, type, options = {})
     Puppet.deprecation_warning("Puppet.settings.set_value is deprecated. Use Puppet[]= instead.")
     if @value_sets[type]
       @value_sets[type].set(param, value)
       unsafe_flush_cache
     end
   end
 
   # Deprecated; use #define_settings instead
   def setdefaults(section, defs)
     Puppet.deprecation_warning("'setdefaults' is deprecated and will be removed; please call 'define_settings' instead")
     define_settings(section, defs)
   end
 
   # Define a group of settings.
   #
   # @param [Symbol] section a symbol to use for grouping multiple settings together into a conceptual unit.  This value
   #   (and the conceptual separation) is not used very often; the main place where it will have a potential impact
   #   is when code calls Settings#use method.  See docs on that method for further details, but basically that method
   #   just attempts to do any preparation that may be necessary before code attempts to leverage the value of a particular
   #   setting.  This has the most impact for file/directory settings, where #use will attempt to "ensure" those
   #   files / directories.
   # @param [Hash[Hash]] defs the settings to be defined.  This argument is a hash of hashes; each key should be a symbol,
   #   which is basically the name of the setting that you are defining.  The value should be another hash that specifies
   #   the parameters for the particular setting.  Legal values include:
   #    [:default] => not required; this is the value for the setting if no other value is specified (via cli, config file, etc.)
   #       For string settings this may include "variables", demarcated with $ or ${} which will be interpolated with values of other settings.
   #       The default value may also be a Proc that will be called only once to evaluate the default when the setting's value is retrieved.
   #    [:desc] => required; a description of the setting, used in documentation / help generation
   #    [:type] => not required, but highly encouraged!  This specifies the data type that the setting represents.  If
   #       you do not specify it, it will default to "string".  Legal values include:
   #       :string - A generic string setting
   #       :boolean - A boolean setting; values are expected to be "true" or "false"
   #       :file - A (single) file path; puppet may attempt to create this file depending on how the settings are used.  This type
   #           also supports additional options such as "mode", "owner", "group"
   #       :directory - A (single) directory path; puppet may attempt to create this file depending on how the settings are used.  This type
   #           also supports additional options such as "mode", "owner", "group"
   #       :path - This is intended to be used for settings whose value can contain multiple directory paths, respresented
   #           as strings separated by the system path separator (e.g. system path, module path, etc.).
   #     [:mode] => an (optional) octal value to be used as the permissions/mode for :file and :directory settings
   #     [:owner] => optional owner username/uid for :file and :directory settings
   #     [:group] => optional group name/gid for :file and :directory settings
   #
   def define_settings(section, defs)
     section = section.to_sym
     call = []
     defs.each do |name, hash|
       raise ArgumentError, "setting definition for '#{name}' is not a hash!" unless hash.is_a? Hash
 
       name = name.to_sym
       hash[:name] = name
       hash[:section] = section
       raise ArgumentError, "Setting #{name} is already defined" if @config.include?(name)
       tryconfig = newsetting(hash)
       if short = tryconfig.short
         if other = @shortnames[short]
           raise ArgumentError, "Setting #{other.name} is already using short name '#{short}'"
         end
         @shortnames[short] = tryconfig
       end
       @config[name] = tryconfig
 
       # Collect the settings that need to have their hooks called immediately.
       # We have to collect them so that we can be sure we're fully initialized before
       # the hook is called.
       if tryconfig.has_hook?
         if tryconfig.call_hook_on_define?
           call << tryconfig
         elsif tryconfig.call_hook_on_initialize?
           @hooks_to_call_on_application_initialization << tryconfig
         end
       end
 
       @deprecated_setting_names << name if tryconfig.deprecated?
     end
 
     call.each do |setting|
       setting.handle(self.value(setting.name))
     end
   end
 
   # Convert the settings we manage into a catalog full of resources that model those settings.
   def to_catalog(*sections)
     sections = nil if sections.empty?
 
     catalog = Puppet::Resource::Catalog.new("Settings", Puppet::Node::Environment::NONE)
     @config.keys.find_all { |key| @config[key].is_a?(FileSetting) }.each do |key|
       file = @config[key]
       next if file.value.nil?
       next unless (sections.nil? or sections.include?(file.section))
       next unless resource = file.to_resource
       next if catalog.resource(resource.ref)
 
-      Puppet.debug {"Using settings: adding file resource '#{key}': '#{resource.inspect}'"}
+      Puppet.debug("Using settings: adding file resource '#{key}': '#{resource.inspect}'")
 
       catalog.add_resource(resource)
     end
 
     add_user_resources(catalog, sections)
     add_environment_resources(catalog, sections)
 
     catalog
   end
 
   # Convert our list of config settings into a configuration file.
   def to_config
     str = %{The configuration file for #{Puppet.run_mode.name}.  Note that this file
 is likely to have unused settings in it; any setting that's
 valid anywhere in Puppet can be in any config file, even if it's not used.
 
 Every section can specify three special parameters: owner, group, and mode.
 These parameters affect the required permissions of any files specified after
 their specification.  Puppet will sometimes use these parameters to check its
 own configured state, so they can be used to make Puppet a bit more self-managing.
 
 The file format supports octothorpe-commented lines, but not partial-line comments.
 
 Generated on #{Time.now}.
 
 }.gsub(/^/, "# ")
 
 #         Add a section heading that matches our name.
     str += "[#{preferred_run_mode}]\n"
     eachsection do |section|
       persection(section) do |obj|
         str += obj.to_config + "\n" unless obj.name == :genconfig
       end
     end
 
     return str
   end
 
   # Convert to a parseable manifest
   def to_manifest
     catalog = to_catalog
     catalog.resource_refs.collect do |ref|
       catalog.resource(ref).to_manifest
     end.join("\n\n")
   end
 
   # Create the necessary objects to use a section.  This is idempotent;
   # you can 'use' a section as many times as you want.
   def use(*sections)
     sections = sections.collect { |s| s.to_sym }
     sections = sections.reject { |s| @used.include?(s) }
 
     return if sections.empty?
 
     begin
       catalog = to_catalog(*sections).to_ral
     rescue => detail
       Puppet.log_and_raise(detail, "Could not create resources for managing Puppet's files and directories in sections #{sections.inspect}: #{detail}")
     end
 
     catalog.host_config = false
     catalog.apply do |transaction|
       if transaction.any_failed?
         report = transaction.report
         status_failures = report.resource_statuses.values.select { |r| r.failed? }
         status_fail_msg = status_failures.
           collect(&:events).
           flatten.
           select { |event| event.status == 'failure' }.
           collect { |event| "#{event.resource}: #{event.message}" }.join("; ")
 
         raise "Got #{status_failures.length} failure(s) while initializing: #{status_fail_msg}"
       end
     end
 
     sections.each { |s| @used << s }
     @used.uniq!
   end
 
   def valid?(param)
     param = param.to_sym
     @config.has_key?(param)
   end
 
   def uninterpolated_value(param, environment = nil)
     Puppet.deprecation_warning("Puppet.settings.uninterpolated_value is deprecated. Use Puppet.settings.value instead")
     param = param.to_sym
     environment &&= environment.to_sym
 
     values(environment, self.preferred_run_mode).lookup(param)
   end
 
   # Retrieve an object that can be used for looking up values of configuration
   # settings.
   #
   # @param environment [Symbol] The name of the environment in which to lookup
   # @param section [Symbol] The name of the configuration section in which to lookup
   # @return [Puppet::Settings::ChainedValues] An object to perform lookups
   # @api public
   def values(environment, section)
     @values[environment][section] ||= ChainedValues.new(
       section,
       environment,
       value_sets_for(environment, section),
       @config)
   end
 
   # Find the correct value using our search path.
   #
   # @param param [String, Symbol] The value to look up
   # @param environment [String, Symbol] The environment to check for the value
   # @param bypass_interpolation [true, false] Whether to skip interpolation
   #
   # @return [Object] The looked up value
   #
   # @raise [InterpolationError]
   def value(param, environment = nil, bypass_interpolation = false)
     param = param.to_sym
     environment &&= environment.to_sym
 
     setting = @config[param]
 
     # Short circuit to nil for undefined settings.
     return nil if setting.nil?
 
     # Check the cache first.  It needs to be a per-environment
     # cache so that we don't spread values from one env
     # to another.
     if @cache[environment||"none"].has_key?(param)
       return @cache[environment||"none"][param]
     elsif bypass_interpolation
       val = values(environment, self.preferred_run_mode).lookup(param)
     else
       val = values(environment, self.preferred_run_mode).interpolate(param)
     end
 
     @cache[environment||"none"][param] = val
     val
   end
 
   ##
   # (#15337) All of the logic to determine the configuration file to use
   #   should be centralized into this method.  The simplified approach is:
   #
   # 1. If there is an explicit configuration file, use that.  (--confdir or
   #    --config)
   # 2. If we're running as a root process, use the system puppet.conf
   #    (usually /etc/puppet/puppet.conf)
   # 3. Otherwise, use the user puppet.conf (usually ~/.puppet/puppet.conf)
   #
   # @api private
   # @todo this code duplicates {Puppet::Util::RunMode#which_dir} as described
   #   in {http://projects.puppetlabs.com/issues/16637 #16637}
   def which_configuration_file
     if explicit_config_file? or Puppet.features.root? then
       return main_config_file
     else
       return user_config_file
     end
   end
 
   # This method just turns a file into a new ConfigFile::Conf instance
   # @param file [String] absolute path to the configuration file
   # @return [Puppet::Settings::ConfigFile::Conf]
   # @api private
   def parse_file(file, allowed_sections = [])
     @config_file_parser.parse_file(file, read_file(file), allowed_sections)
   end
 
   private
 
   DEPRECATION_REFS = {
     # intentionally empty. This could be repopulated if we deprecate more settings
     # and have reference links to associate with them 
   }.freeze
 
   def screen_non_puppet_conf_settings(puppet_conf)
     puppet_conf.sections.values.each do |section|
       forbidden = section.settings.select { |setting| Puppet::Settings::EnvironmentConf::ENVIRONMENT_CONF_ONLY_SETTINGS.include?(setting.name) }
       raise(SettingsError, "Cannot set #{forbidden.map { |s| s.name }.join(", ")} settings in puppet.conf") if !forbidden.empty?
     end
   end
 
   # Record that we want to issue a deprecation warning later in the application
   # initialization cycle when we have settings bootstrapped to the point where
   # we can read the Puppet[:disable_warnings] setting.
   #
   # We are only recording warnings applicable to settings set in puppet.conf
   # itself.
   def record_deprecations_from_puppet_conf(puppet_conf)
     puppet_conf.sections.values.each do |section|
       section.settings.each do |conf_setting|
         if setting = self.setting(conf_setting.name)
           @deprecated_settings_that_have_been_configured << setting if setting.deprecated?
         end
       end
     end
   end
 
   def issue_deprecations
     @deprecated_settings_that_have_been_configured.each do |setting|
       issue_deprecation_warning(setting)
     end
   end
 
   def issue_deprecation_warning(setting, msg = nil)
     name = setting.name
     ref = DEPRECATION_REFS.find { |params,reference| params.include?(name) }
     ref = ref[1] if ref
     case
     when msg
       msg << " #{ref}" if ref
       Puppet.deprecation_warning(msg)
     when setting.completely_deprecated?
       Puppet.deprecation_warning("Setting #{name} is deprecated. #{ref}", "setting-#{name}")
     when setting.allowed_on_commandline?
       Puppet.deprecation_warning("Setting #{name} is deprecated in puppet.conf. #{ref}", "puppet-conf-setting-#{name}")
     end
   end
 
   def get_config_file_default(default)
     obj = nil
     unless obj = @config[default]
       raise ArgumentError, "Unknown default #{default}"
     end
 
     raise ArgumentError, "Default #{default} is not a file" unless obj.is_a? FileSetting
 
     obj
   end
 
   def add_environment_resources(catalog, sections)
     path = self[:environmentpath]
     envdir = path.split(File::PATH_SEPARATOR).first if path
     configured_environment = self[:environment]
     if configured_environment == "production" && envdir && Puppet::FileSystem.exist?(envdir)
       configured_environment_path = File.join(envdir, configured_environment)
       if !Puppet::FileSystem.symlink?(configured_environment_path)
         catalog.add_resource(
           Puppet::Resource.new(:file,
                                configured_environment_path,
                                :parameters => { :ensure => 'directory' })
         )
       end
     end
   end
 
   def add_user_resources(catalog, sections)
     return unless Puppet.features.root?
     return if Puppet.features.microsoft_windows?
     return unless self[:mkusers]
 
     @config.each do |name, setting|
       next unless setting.respond_to?(:owner)
       next unless sections.nil? or sections.include?(setting.section)
 
       if user = setting.owner and user != "root" and catalog.resource(:user, user).nil?
         resource = Puppet::Resource.new(:user, user, :parameters => {:ensure => :present})
         resource[:gid] = self[:group] if self[:group]
         catalog.add_resource resource
       end
       if group = setting.group and ! %w{root wheel}.include?(group) and catalog.resource(:group, group).nil?
         catalog.add_resource Puppet::Resource.new(:group, group, :parameters => {:ensure => :present})
       end
     end
   end
 
   # Yield each search source in turn.
   def value_sets_for(environment, mode)
     searchpath(environment, mode).collect do |source|
       case source.type
       when :values
         @value_sets[source.name]
       when :section
         if @configuration_file && section = @configuration_file.sections[source.name]
           ValuesFromSection.new(source.name, section)
         end
       when :environment
         ValuesFromEnvironmentConf.new(source.name)
       else
         raise(Puppet::DevError, "Unknown searchpath case: #{source.type} for the #{source} settings path element.")
       end
     end.compact
   end
 
   # Read the file in.
   # @api private
   def read_file(file)
     return Puppet::FileSystem.read(file)
   end
 
   # Private method for internal test use only; allows to do a comprehensive clear of all settings between tests.
   #
   # @return nil
   def clear_everything_for_tests()
     unsafe_clear(true, true)
     @configuration_file = nil
     @global_defaults_initialized = false
     @app_defaults_initialized = false
   end
   private :clear_everything_for_tests
 
   def explicit_config_file?
     # Figure out if the user has provided an explicit configuration file.  If
     # so, return the path to the file, if not return nil.
     #
     # The easiest way to determine whether an explicit one has been specified
     #  is to simply attempt to evaluate the value of ":config".  This will
     #  obviously be successful if they've passed an explicit value for :config,
     #  but it will also result in successful interpolation if they've only
     #  passed an explicit value for :confdir.
     #
     # If they've specified neither, then the interpolation will fail and we'll
     #  get an exception.
     #
     begin
       return true if self[:config]
     rescue InterpolationError
       # This means we failed to interpolate, which means that they didn't
       #  explicitly specify either :config or :confdir... so we'll fall out to
       #  the default value.
       return false
     end
   end
   private :explicit_config_file?
 
   # Lookup configuration setting value through a chain of different value sources.
   #
   # @api public
   class ChainedValues
     ENVIRONMENT_SETTING = "environment".freeze
     ENVIRONMENT_INTERPOLATION_ALLOWED = ['config_version'].freeze
 
     # @see Puppet::Settings.values
     # @api private
     def initialize(mode, environment, value_sets, defaults)
       @mode = mode
       @environment = environment
       @value_sets = value_sets
       @defaults = defaults
     end
 
     # Lookup the uninterpolated value.
     #
     # @param name [Symbol] The configuration setting name to look up
     # @return [Object] The configuration setting value or nil if the setting is not known
     # @api public
     def lookup(name)
       set = @value_sets.find do |set|
         set.include?(name)
       end
       if set
         value = set.lookup(name)
         if !value.nil?
           return value
         end
       end
 
       @defaults[name].default
     end
 
     # Lookup the interpolated value. All instances of `$name` in the value will
     # be replaced by performing a lookup of `name` and substituting the text
     # for `$name` in the original value. This interpolation is only performed
     # if the looked up value is a String.
     #
     # @param name [Symbol] The configuration setting name to look up
     # @return [Object] The configuration setting value or nil if the setting is not known
     # @api public
     def interpolate(name)
       setting = @defaults[name]
 
       if setting
         val = lookup(name)
         # if we interpolate code, all hell breaks loose.
         if name == :code
           val
         else
           # Convert it if necessary
           begin
             val = convert(val, name)
           rescue InterpolationError => err
             # This happens because we don't have access to the param name when the
             # exception is originally raised, but we want it in the message
             raise InterpolationError, "Error converting value for param '#{name}': #{err}", err.backtrace
           end
 
           setting.munge(val)
         end
       else
         nil
       end
     end
 
     private
 
     def convert(value, setting_name)
       case value
       when nil
         nil
       when String
         failed_environment_interpolation = false
         interpolated_value = value.gsub(/\$(\w+)|\$\{(\w+)\}/) do |expression|
           varname = $2 || $1
           interpolated_expression =
           if varname != ENVIRONMENT_SETTING || ok_to_interpolate_environment(setting_name)
             if varname == ENVIRONMENT_SETTING && @environment
               @environment
             elsif varname == "run_mode"
               @mode
             elsif !(pval = interpolate(varname.to_sym)).nil?
               pval
             else
               raise InterpolationError, "Could not find value for #{expression}"
             end
           else
             failed_environment_interpolation = true
             expression
           end
           interpolated_expression
         end
         if failed_environment_interpolation
           Puppet.warning("You cannot interpolate $environment within '#{setting_name}' when using directory environments.  Its value will remain #{interpolated_value}.")
         end
         interpolated_value
       else
         value
       end
     end
 
     def ok_to_interpolate_environment(setting_name)
       ENVIRONMENT_INTERPOLATION_ALLOWED.include?(setting_name.to_s)
     end
   end
 
   class Values
     extend Forwardable
 
     attr_reader :name
 
     def initialize(name, defaults)
       @name = name
       @values = {}
       @defaults = defaults
     end
 
     def_delegator :@values, :include?
     def_delegator :@values, :[], :lookup
 
     def set(name, value)
       default = @defaults[name]
 
       if !default
         raise ArgumentError,
           "Attempt to assign a value to unknown setting #{name.inspect}"
       end
 
       if default.has_hook?
         default.handle(value)
       end
 
       @values[name] = value
     end
 
     def inspect
       %Q{<#{self.class}:#{self.object_id} @name="#{@name}" @values="#{@values}">}
     end
   end
 
   class ValuesFromSection
     attr_reader :name
 
     def initialize(name, section)
       @name = name
       @section = section
     end
 
     def include?(name)
       !@section.setting(name).nil?
     end
 
     def lookup(name)
       setting = @section.setting(name)
       if setting
         setting.value
       end
     end
 
     def inspect
       %Q{<#{self.class}:#{self.object_id} @name="#{@name}" @section="#{@section}">}
     end
   end
 
   # @api private
   class ValuesFromEnvironmentConf
     def initialize(environment_name)
       @environment_name = environment_name
     end
 
     def name
       @environment_name
     end
 
     def include?(name)
       if Puppet::Settings::EnvironmentConf::VALID_SETTINGS.include?(name) && conf
         return true
       end
       false
     end
 
     def lookup(name)
       return nil unless Puppet::Settings::EnvironmentConf::VALID_SETTINGS.include?(name)
       conf.send(name) if conf
     end
 
     def conf
       @conf ||= if environments = Puppet.lookup(:environments)
                   environments.get_conf(@environment_name)
                 end
     end
 
     def inspect
       %Q{<#{self.class}:#{self.object_id} @environment_name="#{@environment_name}" @conf="#{@conf}">}
     end
   end
 end
diff --git a/lib/puppet/util/logging.rb b/lib/puppet/util/logging.rb
index 10d3dc7ab..7516d10e1 100644
--- a/lib/puppet/util/logging.rb
+++ b/lib/puppet/util/logging.rb
@@ -1,232 +1,211 @@
 # A module to make logging a bit easier.
 require 'puppet/util/log'
 require 'puppet/error'
 require 'facter'
 
 module Puppet::Util::Logging
 
   def send_log(level, message)
     Puppet::Util::Log.create({:level => level, :source => log_source, :message => message}.merge(log_metadata))
   end
 
   # Create a method for each log level.
   Puppet::Util::Log.eachlevel do |level|
-    # handle debug a special way for performance reasons
-    next if level == :debug
     define_method(level) do |args|
       args = args.join(" ") if args.is_a?(Array)
       send_log(level, args)
     end
   end
 
-  # Output a debug log message if debugging is on (but only then)
-  # If the output is anything except a static string, give the debug
-  # a block - it will be called with all other arguments, and is expected
-  # to return the single string result.
-  #
-  # Use a block at all times for increased performance.
-  #
-  # @example This takes 40% of the time compared to not using a block
-  #  Puppet.debug { "This is a string that interpolated #{x} and #{y} }"
-  #
-  def debug(*args)
-    return nil unless Puppet::Util::Log.level == :debug
-    if block_given?
-      send_log(:debug, yield(*args))
-    else
-      send_log(:debug, args.join(" "))
-    end
-  end
-
   # Log an exception via Puppet.err.  Will also log the backtrace if Puppet[:trace] is set.
   # Parameters:
   # [exception] an Exception to log
   # [message] an optional String overriding the message to be logged; by default, we log Exception.message.
   #    If you pass a String here, your string will be logged instead.  You may also pass nil if you don't
   #    wish to log a message at all; in this case it is likely that you are only calling this method in order
   #    to take advantage of the backtrace logging.
   def log_exception(exception, message = :default, options = {})
     err(format_exception(exception, message, Puppet[:trace] || options[:trace]))
   end
 
   def format_exception(exception, message = :default, trace = true)
     arr = []
     case message
     when :default
       arr << exception.message
     when nil
       # don't log anything if they passed a nil; they are just calling for the optional backtrace logging
     else
       arr << message
     end
 
     if trace and exception.backtrace
       arr << Puppet::Util.pretty_backtrace(exception.backtrace)
     end
     if exception.respond_to?(:original) and exception.original
       arr << "Wrapped exception:"
       arr << format_exception(exception.original, :default, trace)
     end
     arr.flatten.join("\n")
   end
 
   def log_and_raise(exception, message)
     log_exception(exception, message)
     raise exception, message + "\n" + exception.to_s, exception.backtrace
   end
 
   class DeprecationWarning < Exception; end
 
   # Logs a warning indicating that the Ruby code path is deprecated.  Note that
   # this method keeps track of the offending lines of code that triggered the
   # deprecation warning, and will only log a warning once per offending line of
   # code.  It will also stop logging deprecation warnings altogether after 100
   # unique deprecation warnings have been logged.  Finally, if
   # Puppet[:disable_warnings] includes 'deprecations', it will squelch all
   # warning calls made via this method.
   #
   # @param message [String] The message to log (logs via warning)
   # @param key [String] Optional key to mark the message as unique. If not
   #   passed in, the originating call line will be used instead.
   def deprecation_warning(message, key = nil)
     issue_deprecation_warning(message, key, nil, nil, true)
   end
 
   # Logs a warning whose origin comes from Puppet source rather than somewhere
   # internal within Puppet.  Otherwise the same as deprecation_warning()
   #
   # @param message [String] The message to log (logs via warning)
   # @param options [Hash]
   # @option options [String] :file File we are warning from
   # @option options [Integer] :line Line number we are warning from
   # @option options [String] :key (:file + :line) Alternative key used to mark
   #   warning as unique
   #
   # Either :file and :line and/or :key must be passed.
   def puppet_deprecation_warning(message, options = {})
     key = options[:key]
     file = options[:file]
     line = options[:line]
     raise(Puppet::DevError, "Need either :file and :line, or :key") if (key.nil?) && (file.nil? || line.nil?)
 
     key ||= "#{file}:#{line}"
     issue_deprecation_warning(message, key, file, line, false)
   end
 
   def get_deprecation_offender()
     # we have to put this in its own method to simplify testing; we need to be able to mock the offender results in
     # order to test this class, and our framework does not appear to enjoy it if you try to mock Kernel.caller
     #
     # let's find the offending line;  we need to jump back up the stack a few steps to find the method that called
     #  the deprecated method
     if Puppet[:trace]
       caller()[2..-1]
     else
       [caller()[2]]
     end
   end
 
   def clear_deprecation_warnings
     $deprecation_warnings.clear if $deprecation_warnings
   end
 
   # TODO: determine whether there might be a potential use for adding a puppet configuration option that would
   # enable this deprecation logging.
 
   # utility method that can be called, e.g., from spec_helper config.after, when tracking down calls to deprecated
   # code.
   # Parameters:
   # [deprecations_file] relative or absolute path of a file to log the deprecations to
   # [pattern] (default nil) if specified, will only log deprecations whose message matches the provided pattern
   def log_deprecations_to_file(deprecations_file, pattern = nil)
     # this method may get called lots and lots of times (e.g., from spec_helper config.after) without the global
     # list of deprecation warnings being cleared out.  We don't want to keep logging the same offenders over and over,
     # so, we need to keep track of what we've logged.
     #
     # It'd be nice if we could just clear out the list of deprecation warnings, but then the very next spec might
     # find the same offender, and we'd end up logging it again.
     $logged_deprecation_warnings ||= {}
 
     File.open(deprecations_file, "a") do |f|
       if ($deprecation_warnings) then
         $deprecation_warnings.each do |offender, message|
           if (! $logged_deprecation_warnings.has_key?(offender)) then
             $logged_deprecation_warnings[offender] = true
             if ((pattern.nil?) || (message =~ pattern)) then
               f.puts(message)
               f.puts(offender)
               f.puts()
             end
           end
         end
       end
     end
   end
 
   # Sets up Facter logging.
   # This method causes Facter output to be forwarded to Puppet.
   def self.setup_facter_logging!
     # Only recent versions of Facter support this feature
     return false unless Facter.respond_to? :on_message
 
     # The current Facter log levels are: :trace, :debug, :info, :warn, :error, and :fatal.
     # Convert to the corresponding levels in Puppet
     Facter.on_message do |level, message|
       case level
       when :trace, :debug
         level = :debug
       when :info
         # Same as Puppet
       when :warn
         level = :warning
       when :error
         level = :err
       when :fatal
         level = :crit
       else
         next
       end
       Puppet::Util::Log.create({:level => level, :source => 'Facter', :message => message})
       nil
     end
     true
   end
 
   private
 
   def issue_deprecation_warning(message, key, file, line, use_caller)
     return if Puppet[:disable_warnings].include?('deprecations')
     $deprecation_warnings ||= {}
     if $deprecation_warnings.length < 100 then
       key ||= (offender = get_deprecation_offender)
       if (! $deprecation_warnings.has_key?(key)) then
         $deprecation_warnings[key] = message
         call_trace = use_caller ?
           (offender || get_deprecation_offender).join('; ') :
           "#{file || 'unknown'}:#{line || 'unknown'}"
         warning("#{message}\n   (at #{call_trace})")
       end
     end
   end
 
   def is_resource?
     defined?(Puppet::Type) && is_a?(Puppet::Type)
   end
 
   def is_resource_parameter?
     defined?(Puppet::Parameter) && is_a?(Puppet::Parameter)
   end
 
   def log_metadata
     [:file, :line, :tags].inject({}) do |result, attr|
       result[attr] = send(attr) if respond_to?(attr)
       result
     end
   end
 
   def log_source
     # We need to guard the existence of the constants, since this module is used by the base Puppet module.
     (is_resource? or is_resource_parameter?) and respond_to?(:path) and return path.to_s
     to_s
   end
 end
diff --git a/lib/puppet/util/warnings.rb b/lib/puppet/util/warnings.rb
index 5536ea0df..82e80e4be 100644
--- a/lib/puppet/util/warnings.rb
+++ b/lib/puppet/util/warnings.rb
@@ -1,33 +1,32 @@
 # Methods to help with handling warnings.
 module Puppet::Util::Warnings
   module_function
 
   def notice_once(msg)
     Puppet::Util::Warnings.maybe_log(msg, self.class) { Puppet.notice msg }
   end
 
   def debug_once(msg)
-    return nil unless Puppet[:debug]
     Puppet::Util::Warnings.maybe_log(msg, self.class) { Puppet.debug msg }
   end
 
   def warnonce(msg)
     Puppet::Util::Warnings.maybe_log(msg, self.class) { Puppet.warning msg }
   end
 
   def clear_warnings
     @stampwarnings = {}
     nil
   end
 
   protected
 
   def self.maybe_log(message, klass)
     @stampwarnings ||= {}
     @stampwarnings[klass] ||= []
     return nil if @stampwarnings[klass].include? message
     yield
     @stampwarnings[klass] << message
     nil
   end
 end
diff --git a/spec/integration/parser/compiler_spec.rb b/spec/integration/parser/compiler_spec.rb
index 4bfcf1f70..1f42c2cbf 100755
--- a/spec/integration/parser/compiler_spec.rb
+++ b/spec/integration/parser/compiler_spec.rb
@@ -1,938 +1,938 @@
 require 'spec_helper'
 require 'puppet_spec/compiler'
 require 'matchers/resource'
 
 class CompilerTestResource
   attr_accessor :builtin, :virtual, :evaluated, :type, :title
 
   def initialize(type, title)
     @type = type
     @title = title
   end
 
   def [](attr)
     return nil if attr == :stage
     :main
   end
 
   def ref
     "#{type.to_s.capitalize}[#{title}]"
   end
 
   def evaluated?
     @evaluated
   end
 
   def builtin_type?
     @builtin
   end
 
   def virtual?
     @virtual
   end
 
   def class?
     false
   end
 
   def stage?
     false
   end
 
   def evaluate
   end
 
   def file
     "/fake/file/goes/here"
   end
 
   def line
     "42"
   end
 end
 
 describe Puppet::Parser::Compiler do
   include PuppetSpec::Files
   include Matchers::Resource
 
   def resource(type, title)
     Puppet::Parser::Resource.new(type, title, :scope => @scope)
   end
 
   let(:environment) { Puppet::Node::Environment.create(:testing, []) }
 
   before :each do
     # Push me faster, I wanna go back in time!  (Specifically, freeze time
     # across the test since we have a bunch of version == timestamp code
     # hidden away in the implementation and we keep losing the race.)
     # --daniel 2011-04-21
     now = Time.now
     Time.stubs(:now).returns(now)
 
     @node = Puppet::Node.new("testnode",
                              :facts => Puppet::Node::Facts.new("facts", {}),
                              :environment => environment)
     @known_resource_types = environment.known_resource_types
     @compiler = Puppet::Parser::Compiler.new(@node)
     @scope = Puppet::Parser::Scope.new(@compiler, :source => stub('source'))
     @scope_resource = Puppet::Parser::Resource.new(:file, "/my/file", :scope => @scope)
     @scope.resource = @scope_resource
   end
 
   it "should have a class method that compiles, converts, and returns a catalog" do
     compiler = stub 'compiler'
     Puppet::Parser::Compiler.expects(:new).with(@node).returns compiler
     catalog = stub 'catalog'
     compiler.expects(:compile).returns catalog
     converted_catalog = stub 'converted_catalog'
     catalog.expects(:to_resource).returns converted_catalog
 
     Puppet::Parser::Compiler.compile(@node).should equal(converted_catalog)
   end
 
   it "should fail intelligently when a class-level compile fails" do
     Puppet::Parser::Compiler.expects(:new).raises ArgumentError
     lambda { Puppet::Parser::Compiler.compile(@node) }.should raise_error(Puppet::Error)
   end
 
   it "should use the node's environment as its environment" do
     @compiler.environment.should equal(@node.environment)
   end
 
   it "fails if the node's environment has validation errors" do
     conflicted_environment = Puppet::Node::Environment.create(:testing, [], '/some/environment.conf/manifest.pp')
     conflicted_environment.stubs(:validation_errors).returns(['bad environment'])
     @node.environment = conflicted_environment
     expect { Puppet::Parser::Compiler.compile(@node) }.to raise_error(Puppet::Error, /Compilation has been halted because.*bad environment/)
   end
 
   it "should include the resource type collection helper" do
     Puppet::Parser::Compiler.ancestors.should be_include(Puppet::Resource::TypeCollectionHelper)
   end
 
   it "should be able to return a class list containing all added classes" do
     @compiler.add_class ""
     @compiler.add_class "one"
     @compiler.add_class "two"
 
     @compiler.classlist.sort.should == %w{one two}.sort
   end
 
   it "should clear the global caches before compile" do
     compiler = stub 'compiler'
     Puppet::Parser::Compiler.expects(:new).with(@node).returns compiler
     catalog = stub 'catalog'
     compiler.expects(:compile).returns catalog
     catalog.expects(:to_resource)
 
     $known_resource_types = "rspec"
     $env_module_directories = "rspec"
 
     Puppet::Parser::Compiler.compile(@node)
 
     $known_resource_types = nil
     $env_module_directories = nil
   end
 
   describe "when initializing" do
 
     it "should set its node attribute" do
       @compiler.node.should equal(@node)
     end
     it "should detect when ast nodes are absent" do
       @compiler.ast_nodes?.should be_false
     end
 
     it "should detect when ast nodes are present" do
       @known_resource_types.expects(:nodes?).returns true
       @compiler.ast_nodes?.should be_true
     end
 
     it "should copy the known_resource_types version to the catalog" do
       @compiler.catalog.version.should == @known_resource_types.version
     end
 
     it "should copy any node classes into the class list" do
       node = Puppet::Node.new("mynode")
       node.classes = %w{foo bar}
       compiler = Puppet::Parser::Compiler.new(node)
 
       compiler.classlist.should =~ ['foo', 'bar']
     end
 
     it "should transform node class hashes into a class list" do
       node = Puppet::Node.new("mynode")
       node.classes = {'foo'=>{'one'=>'p1'}, 'bar'=>{'two'=>'p2'}}
       compiler = Puppet::Parser::Compiler.new(node)
 
       compiler.classlist.should =~ ['foo', 'bar']
     end
 
     it "should add a 'main' stage to the catalog" do
       @compiler.catalog.resource(:stage, :main).should be_instance_of(Puppet::Parser::Resource)
     end
   end
 
   describe "when managing scopes" do
 
     it "should create a top scope" do
       @compiler.topscope.should be_instance_of(Puppet::Parser::Scope)
     end
 
     it "should be able to create new scopes" do
       @compiler.newscope(@compiler.topscope).should be_instance_of(Puppet::Parser::Scope)
     end
 
     it "should set the parent scope of the new scope to be the passed-in parent" do
       scope = mock 'scope'
       newscope = @compiler.newscope(scope)
 
       newscope.parent.should equal(scope)
     end
 
     it "should set the parent scope of the new scope to its topscope if the parent passed in is nil" do
       scope = mock 'scope'
       newscope = @compiler.newscope(nil)
 
       newscope.parent.should equal(@compiler.topscope)
     end
   end
 
   describe "when compiling" do
 
     def compile_methods
       [:set_node_parameters, :evaluate_main, :evaluate_ast_node, :evaluate_node_classes, :evaluate_generators, :fail_on_unevaluated,
         :finish, :store, :extract, :evaluate_relationships]
     end
 
     # Stub all of the main compile methods except the ones we're specifically interested in.
     def compile_stub(*except)
       (compile_methods - except).each { |m| @compiler.stubs(m) }
     end
 
     it "should set node parameters as variables in the top scope" do
       params = {"a" => "b", "c" => "d"}
       @node.stubs(:parameters).returns(params)
       compile_stub(:set_node_parameters)
       @compiler.compile
       @compiler.topscope['a'].should == "b"
       @compiler.topscope['c'].should == "d"
     end
 
     it "should set the client and server versions on the catalog" do
       params = {"clientversion" => "2", "serverversion" => "3"}
       @node.stubs(:parameters).returns(params)
       compile_stub(:set_node_parameters)
       @compiler.compile
       @compiler.catalog.client_version.should == "2"
       @compiler.catalog.server_version.should == "3"
     end
 
     it "should evaluate the main class if it exists" do
       compile_stub(:evaluate_main)
       main_class = @known_resource_types.add Puppet::Resource::Type.new(:hostclass, "")
       main_class.expects(:evaluate_code).with { |r| r.is_a?(Puppet::Parser::Resource) }
       @compiler.topscope.expects(:source=).with(main_class)
 
       @compiler.compile
     end
 
     it "should create a new, empty 'main' if no main class exists" do
       compile_stub(:evaluate_main)
       @compiler.compile
-      @known_resource_types.find_hostclass("").should be_instance_of(Puppet::Resource::Type)
+      @known_resource_types.find_hostclass([""], "").should be_instance_of(Puppet::Resource::Type)
     end
 
     it "should add an edge between the main stage and main class" do
       @compiler.compile
       (stage = @compiler.catalog.resource(:stage, "main")).should be_instance_of(Puppet::Parser::Resource)
       (klass = @compiler.catalog.resource(:class, "")).should be_instance_of(Puppet::Parser::Resource)
 
       @compiler.catalog.edge?(stage, klass).should be_true
     end
 
     it "should evaluate all added collections" do
       colls = []
       # And when the collections fail to evaluate.
       colls << mock("coll1-false")
       colls << mock("coll2-false")
       colls.each { |c| c.expects(:evaluate).returns(false) }
 
       @compiler.add_collection(colls[0])
       @compiler.add_collection(colls[1])
 
       compile_stub(:evaluate_generators)
       @compiler.compile
     end
 
     it "should ignore builtin resources" do
       resource = resource(:file, "testing")
 
       @compiler.add_resource(@scope, resource)
       resource.expects(:evaluate).never
 
       @compiler.compile
     end
 
     it "should evaluate unevaluated resources" do
       resource = CompilerTestResource.new(:file, "testing")
 
       @compiler.add_resource(@scope, resource)
 
       # We have to now mark the resource as evaluated
       resource.expects(:evaluate).with { |*whatever| resource.evaluated = true }
 
       @compiler.compile
     end
 
     it "should not evaluate already-evaluated resources" do
       resource = resource(:file, "testing")
       resource.stubs(:evaluated?).returns true
 
       @compiler.add_resource(@scope, resource)
       resource.expects(:evaluate).never
 
       @compiler.compile
     end
 
     it "should evaluate unevaluated resources created by evaluating other resources" do
       resource = CompilerTestResource.new(:file, "testing")
       @compiler.add_resource(@scope, resource)
 
       resource2 = CompilerTestResource.new(:file, "other")
 
       # We have to now mark the resource as evaluated
       resource.expects(:evaluate).with { |*whatever| resource.evaluated = true; @compiler.add_resource(@scope, resource2) }
       resource2.expects(:evaluate).with { |*whatever| resource2.evaluated = true }
 
 
       @compiler.compile
     end
 
     describe "when finishing" do
       before do
         @compiler.send(:evaluate_main)
         @catalog = @compiler.catalog
       end
 
       def add_resource(name, parent = nil)
         resource = Puppet::Parser::Resource.new "file", name, :scope => @scope
         @compiler.add_resource(@scope, resource)
         @catalog.add_edge(parent, resource) if parent
         resource
       end
 
       it "should call finish() on all resources" do
         # Add a resource that does respond to :finish
         resource = Puppet::Parser::Resource.new "file", "finish", :scope => @scope
         resource.expects(:finish)
 
         @compiler.add_resource(@scope, resource)
 
         # And one that does not
         dnf_resource = stub_everything "dnf", :ref => "File[dnf]", :type => "file"
 
         @compiler.add_resource(@scope, dnf_resource)
 
         @compiler.send(:finish)
       end
 
       it "should call finish() in add_resource order" do
         resources = sequence('resources')
 
         resource1 = add_resource("finish1")
         resource1.expects(:finish).in_sequence(resources)
 
         resource2 = add_resource("finish2")
         resource2.expects(:finish).in_sequence(resources)
 
         @compiler.send(:finish)
       end
 
       it "should add each container's metaparams to its contained resources" do
         main = @catalog.resource(:class, :main)
         main[:noop] = true
 
         resource1 = add_resource("meh", main)
 
         @compiler.send(:finish)
         resource1[:noop].should be_true
       end
 
       it "should add metaparams recursively" do
         main = @catalog.resource(:class, :main)
         main[:noop] = true
 
         resource1 = add_resource("meh", main)
         resource2 = add_resource("foo", resource1)
 
         @compiler.send(:finish)
         resource2[:noop].should be_true
       end
 
       it "should prefer metaparams from immediate parents" do
         main = @catalog.resource(:class, :main)
         main[:noop] = true
 
         resource1 = add_resource("meh", main)
         resource2 = add_resource("foo", resource1)
 
         resource1[:noop] = false
 
         @compiler.send(:finish)
         resource2[:noop].should be_false
       end
 
       it "should merge tags downward" do
         main = @catalog.resource(:class, :main)
         main.tag("one")
 
         resource1 = add_resource("meh", main)
         resource1.tag "two"
         resource2 = add_resource("foo", resource1)
 
         @compiler.send(:finish)
         resource2.tags.should be_include("one")
         resource2.tags.should be_include("two")
       end
 
       it "should work if only middle resources have metaparams set" do
         main = @catalog.resource(:class, :main)
 
         resource1 = add_resource("meh", main)
         resource1[:noop] = true
         resource2 = add_resource("foo", resource1)
 
         @compiler.send(:finish)
         resource2[:noop].should be_true
       end
     end
 
     it "should return added resources in add order" do
       resource1 = resource(:file, "yay")
       @compiler.add_resource(@scope, resource1)
       resource2 = resource(:file, "youpi")
       @compiler.add_resource(@scope, resource2)
 
       @compiler.resources.should == [resource1, resource2]
     end
 
     it "should add resources that do not conflict with existing resources" do
       resource = resource(:file, "yay")
       @compiler.add_resource(@scope, resource)
 
       @compiler.catalog.should be_vertex(resource)
     end
 
     it "should fail to add resources that conflict with existing resources" do
       path = make_absolute("/foo")
       file1 = resource(:file, path)
       file2 = resource(:file, path)
 
       @compiler.add_resource(@scope, file1)
       lambda { @compiler.add_resource(@scope, file2) }.should raise_error(Puppet::Resource::Catalog::DuplicateResourceError)
     end
 
     it "should add an edge from the scope resource to the added resource" do
       resource = resource(:file, "yay")
       @compiler.add_resource(@scope, resource)
 
       @compiler.catalog.should be_edge(@scope.resource, resource)
     end
 
     it "should not add non-class resources that don't specify a stage to the 'main' stage" do
       main = @compiler.catalog.resource(:stage, :main)
       resource = resource(:file, "foo")
       @compiler.add_resource(@scope, resource)
 
       @compiler.catalog.should_not be_edge(main, resource)
     end
 
     it "should not add any parent-edges to stages" do
       stage = resource(:stage, "other")
       @compiler.add_resource(@scope, stage)
 
       @scope.resource = resource(:class, "foo")
 
       @compiler.catalog.edge?(@scope.resource, stage).should be_false
     end
 
     it "should not attempt to add stages to other stages" do
       other_stage = resource(:stage, "other")
       second_stage = resource(:stage, "second")
       @compiler.add_resource(@scope, other_stage)
       @compiler.add_resource(@scope, second_stage)
 
       second_stage[:stage] = "other"
 
       @compiler.catalog.edge?(other_stage, second_stage).should be_false
     end
 
     it "should have a method for looking up resources" do
       resource = resource(:yay, "foo")
       @compiler.add_resource(@scope, resource)
       @compiler.findresource("Yay[foo]").should equal(resource)
     end
 
     it "should be able to look resources up by type and title" do
       resource = resource(:yay, "foo")
       @compiler.add_resource(@scope, resource)
       @compiler.findresource("Yay", "foo").should equal(resource)
     end
 
     it "should not evaluate virtual defined resources" do
       resource = resource(:file, "testing")
       resource.virtual = true
       @compiler.add_resource(@scope, resource)
 
       resource.expects(:evaluate).never
 
       @compiler.compile
     end
   end
 
   describe "when evaluating collections" do
 
     it "should evaluate each collection" do
       2.times { |i|
         coll = mock 'coll%s' % i
         @compiler.add_collection(coll)
 
         # This is the hard part -- we have to emulate the fact that
         # collections delete themselves if they are done evaluating.
         coll.expects(:evaluate).with do
           @compiler.delete_collection(coll)
         end
       }
 
       @compiler.compile
     end
 
     it "should not fail when there are unevaluated resource collections that do not refer to specific resources" do
       coll = stub 'coll', :evaluate => false
       coll.expects(:unresolved_resources).returns(nil)
 
       @compiler.add_collection(coll)
 
       lambda { @compiler.compile }.should_not raise_error
     end
 
     it "should fail when there are unevaluated resource collections that refer to a specific resource" do
       coll = stub 'coll', :evaluate => false
       coll.expects(:unresolved_resources).returns(:something)
 
       @compiler.add_collection(coll)
 
       lambda { @compiler.compile }.should raise_error(Puppet::ParseError, 'Failed to realize virtual resources something')
     end
 
     it "should fail when there are unevaluated resource collections that refer to multiple specific resources" do
       coll = stub 'coll', :evaluate => false
       coll.expects(:unresolved_resources).returns([:one, :two])
 
       @compiler.add_collection(coll)
 
       lambda { @compiler.compile }.should raise_error(Puppet::ParseError, 'Failed to realize virtual resources one, two')
     end
   end
 
   describe "when evaluating relationships" do
     it "should evaluate each relationship with its catalog" do
       dep = stub 'dep'
       dep.expects(:evaluate).with(@compiler.catalog)
       @compiler.add_relationship dep
       @compiler.evaluate_relationships
     end
   end
 
   describe "when told to evaluate missing classes" do
 
     it "should fail if there's no source listed for the scope" do
       scope = stub 'scope', :source => nil
       proc { @compiler.evaluate_classes(%w{one two}, scope) }.should raise_error(Puppet::DevError)
     end
 
     it "should raise an error if a class is not found" do
-      @scope.expects(:find_hostclass).with("notfound").returns(nil)
+      @scope.expects(:find_hostclass).with("notfound", {:assume_fqname => false}).returns(nil)
       lambda{ @compiler.evaluate_classes(%w{notfound}, @scope) }.should raise_error(Puppet::Error, /Could not find class/)
     end
 
     it "should raise an error when it can't find class" do
       klasses = {'foo'=>nil}
       @node.classes = klasses
-      @compiler.topscope.expects(:find_hostclass).with('foo').returns(nil)
+      @compiler.topscope.expects(:find_hostclass).with('foo', {:assume_fqname => false}).returns(nil)
       lambda{ @compiler.compile }.should raise_error(Puppet::Error, /Could not find class foo for testnode/)
     end
   end
 
   describe "when evaluating found classes" do
 
     before do
       Puppet.settings[:data_binding_terminus] = "none"
       @class = stub 'class', :name => "my::class"
-      @scope.stubs(:find_hostclass).with("myclass").returns(@class)
+      @scope.stubs(:find_hostclass).with("myclass", {:assume_fqname => false}).returns(@class)
 
       @resource = stub 'resource', :ref => "Class[myclass]", :type => "file"
     end
 
     around do |example|
       Puppet.override(
         :environments => Puppet::Environments::Static.new(environment),
         :description => "Static loader for specs"
       ) do
         example.run
       end
     end
 
     it "should evaluate each class" do
       @compiler.catalog.stubs(:tag)
 
       @class.expects(:ensure_in_catalog).with(@scope)
       @scope.stubs(:class_scope).with(@class)
 
       @compiler.evaluate_classes(%w{myclass}, @scope)
     end
 
     describe "and the classes are specified as a hash with parameters" do
       before do
         @node.classes = {}
         @ast_obj = Puppet::Parser::AST::Leaf.new(:value => 'foo')
       end
 
       # Define the given class with default parameters
       def define_class(name, parameters)
         @node.classes[name] = parameters
         klass = Puppet::Resource::Type.new(:hostclass, name, :arguments => {'p1' => @ast_obj, 'p2' => @ast_obj})
         @compiler.topscope.known_resource_types.add klass
       end
 
       def compile
         @catalog = @compiler.compile
       end
 
       it "should record which classes are evaluated" do
         classes = {'foo'=>{}, 'bar::foo'=>{}, 'bar'=>{}}
         classes.each { |c, params| define_class(c, params) }
         compile()
         classes.each { |name, p| @catalog.classes.should include(name) }
       end
 
       it "should provide default values for parameters that have no values specified" do
         define_class('foo', {})
         compile()
         @catalog.resource(:class, 'foo')['p1'].should == "foo"
       end
 
       it "should use any provided values" do
         define_class('foo', {'p1' => 'real_value'})
         compile()
         @catalog.resource(:class, 'foo')['p1'].should == "real_value"
       end
 
       it "should support providing some but not all values" do
         define_class('foo', {'p1' => 'real_value'})
         compile()
         @catalog.resource(:class, 'Foo')['p1'].should == "real_value"
         @catalog.resource(:class, 'Foo')['p2'].should == "foo"
       end
 
       it "should ensure each node class is in catalog and has appropriate tags" do
         klasses = ['bar::foo']
         @node.classes = klasses
         ast_obj = Puppet::Parser::AST::Leaf.new(:value => 'foo')
         klasses.each do |name|
           klass = Puppet::Resource::Type.new(:hostclass, name, :arguments => {'p1' => ast_obj, 'p2' => ast_obj})
           @compiler.topscope.known_resource_types.add klass
         end
         catalog = @compiler.compile
 
         r2 = catalog.resources.detect {|r| r.title == 'Bar::Foo' }
         r2.tags.should == Puppet::Util::TagSet.new(['bar::foo', 'class', 'bar', 'foo'])
       end
     end
 
     it "should fail if required parameters are missing" do
       klass = {'foo'=>{'a'=>'one'}}
       @node.classes = klass
       klass = Puppet::Resource::Type.new(:hostclass, 'foo', :arguments => {'a' => nil, 'b' => nil})
       @compiler.topscope.known_resource_types.add klass
       lambda { @compiler.compile }.should raise_error(Puppet::ParseError, "Must pass b to Class[Foo]")
     end
 
     it "should fail if invalid parameters are passed" do
       klass = {'foo'=>{'3'=>'one'}}
       @node.classes = klass
       klass = Puppet::Resource::Type.new(:hostclass, 'foo', :arguments => {})
       @compiler.topscope.known_resource_types.add klass
       lambda { @compiler.compile }.should raise_error(Puppet::ParseError, "Invalid parameter 3 on Class[Foo]")
     end
 
     it "should ensure class is in catalog without params" do
       @node.classes = klasses = {'foo'=>nil}
       foo = Puppet::Resource::Type.new(:hostclass, 'foo')
       @compiler.topscope.known_resource_types.add foo
       catalog = @compiler.compile
       catalog.classes.should include 'foo'
     end
 
     it "should not evaluate the resources created for found classes unless asked" do
       @compiler.catalog.stubs(:tag)
 
       @resource.expects(:evaluate).never
 
       @class.expects(:ensure_in_catalog).returns(@resource)
       @scope.stubs(:class_scope).with(@class)
 
       @compiler.evaluate_classes(%w{myclass}, @scope)
     end
 
     it "should immediately evaluate the resources created for found classes when asked" do
       @compiler.catalog.stubs(:tag)
 
       @resource.expects(:evaluate)
       @class.expects(:ensure_in_catalog).returns(@resource)
       @scope.stubs(:class_scope).with(@class)
 
       @compiler.evaluate_classes(%w{myclass}, @scope, false)
     end
 
     it "should skip classes that have already been evaluated" do
       @compiler.catalog.stubs(:tag)
 
       @scope.stubs(:class_scope).with(@class).returns(@scope)
 
       @compiler.expects(:add_resource).never
 
       @resource.expects(:evaluate).never
 
       Puppet::Parser::Resource.expects(:new).never
       @compiler.evaluate_classes(%w{myclass}, @scope, false)
     end
 
     it "should skip classes previously evaluated with different capitalization" do
       @compiler.catalog.stubs(:tag)
-      @scope.stubs(:find_hostclass).with("MyClass").returns(@class)
+      @scope.stubs(:find_hostclass).with("MyClass",{:assume_fqname => false}).returns(@class)
       @scope.stubs(:class_scope).with(@class).returns(@scope)
       @compiler.expects(:add_resource).never
       @resource.expects(:evaluate).never
       Puppet::Parser::Resource.expects(:new).never
       @compiler.evaluate_classes(%w{MyClass}, @scope, false)
     end
   end
 
   describe "when evaluating AST nodes with no AST nodes present" do
 
     it "should do nothing" do
       @compiler.expects(:ast_nodes?).returns(false)
       @compiler.known_resource_types.expects(:nodes).never
       Puppet::Parser::Resource.expects(:new).never
 
       @compiler.send(:evaluate_ast_node)
     end
   end
 
   describe "when evaluating AST nodes with AST nodes present" do
 
     before do
       @compiler.known_resource_types.stubs(:nodes?).returns true
 
       # Set some names for our test
       @node.stubs(:names).returns(%w{a b c})
       @compiler.known_resource_types.stubs(:node).with("a").returns(nil)
       @compiler.known_resource_types.stubs(:node).with("b").returns(nil)
       @compiler.known_resource_types.stubs(:node).with("c").returns(nil)
 
       # It should check this last, of course.
       @compiler.known_resource_types.stubs(:node).with("default").returns(nil)
     end
 
     it "should fail if the named node cannot be found" do
       proc { @compiler.send(:evaluate_ast_node) }.should raise_error(Puppet::ParseError)
     end
 
     it "should evaluate the first node class matching the node name" do
       node_class = stub 'node', :name => "c", :evaluate_code => nil
       @compiler.known_resource_types.stubs(:node).with("c").returns(node_class)
 
       node_resource = stub 'node resource', :ref => "Node[c]", :evaluate => nil, :type => "node"
       node_class.expects(:ensure_in_catalog).returns(node_resource)
 
       @compiler.compile
     end
 
     it "should match the default node if no matching node can be found" do
       node_class = stub 'node', :name => "default", :evaluate_code => nil
       @compiler.known_resource_types.stubs(:node).with("default").returns(node_class)
 
       node_resource = stub 'node resource', :ref => "Node[default]", :evaluate => nil, :type => "node"
       node_class.expects(:ensure_in_catalog).returns(node_resource)
 
       @compiler.compile
     end
 
     it "should evaluate the node resource immediately rather than using lazy evaluation" do
       node_class = stub 'node', :name => "c"
       @compiler.known_resource_types.stubs(:node).with("c").returns(node_class)
 
       node_resource = stub 'node resource', :ref => "Node[c]", :type => "node"
       node_class.expects(:ensure_in_catalog).returns(node_resource)
 
       node_resource.expects(:evaluate)
 
       @compiler.send(:evaluate_ast_node)
     end
   end
 
   describe "when evaluating node classes" do
     include PuppetSpec::Compiler
 
     describe "when provided classes in array format" do
       let(:node) { Puppet::Node.new('someone', :classes => ['something']) }
 
       describe "when the class exists" do
         it "should succeed if the class is already included" do
           manifest = <<-MANIFEST
           class something {}
           include something
           MANIFEST
 
           catalog = compile_to_catalog(manifest, node)
 
           catalog.resource('Class', 'Something').should_not be_nil
         end
 
         it "should evaluate the class without parameters if it's not already included" do
           manifest = "class something {}"
 
           catalog = compile_to_catalog(manifest, node)
 
           catalog.resource('Class', 'Something').should_not be_nil
         end
       end
 
       it "should fail if the class doesn't exist" do
         expect { compile_to_catalog('', node) }.to raise_error(Puppet::Error, /Could not find class something/)
       end
     end
 
     describe "when provided classes in hash format" do
       describe "for classes without parameters" do
         let(:node) { Puppet::Node.new('someone', :classes => {'something' => {}}) }
 
         describe "when the class exists" do
           it "should succeed if the class is already included" do
             manifest = <<-MANIFEST
             class something {}
             include something
             MANIFEST
 
             catalog = compile_to_catalog(manifest, node)
 
             catalog.resource('Class', 'Something').should_not be_nil
           end
 
           it "should evaluate the class if it's not already included" do
             manifest = <<-MANIFEST
             class something {}
             MANIFEST
 
             catalog = compile_to_catalog(manifest, node)
 
             catalog.resource('Class', 'Something').should_not be_nil
           end
         end
 
         it "should fail if the class doesn't exist" do
           expect { compile_to_catalog('', node) }.to raise_error(Puppet::Error, /Could not find class something/)
         end
       end
 
       describe "for classes with parameters" do
         let(:node) { Puppet::Node.new('someone', :classes => {'something' => {'configuron' => 'defrabulated'}}) }
 
         describe "when the class exists" do
           it "should fail if the class is already included" do
             manifest = <<-MANIFEST
             class something($configuron=frabulated) {}
             include something
             MANIFEST
 
             expect { compile_to_catalog(manifest, node) }.to raise_error(Puppet::Error, /Class\[Something\] is already declared/)
           end
 
           it "should evaluate the class if it's not already included" do
             manifest = <<-MANIFEST
             class something($configuron=frabulated) {}
             MANIFEST
 
             catalog = compile_to_catalog(manifest, node)
 
             resource = catalog.resource('Class', 'Something')
             resource['configuron'].should == 'defrabulated'
           end
         end
 
         it "should fail if the class doesn't exist" do
           expect { compile_to_catalog('', node) }.to raise_error(Puppet::Error, /Could not find class something/)
         end
 
         it 'evaluates classes declared with parameters before unparameterized classes' do
           node = Puppet::Node.new('someone', :classes => { 'app::web' => {}, 'app' => { 'port' => 8080 } })
           manifest = <<-MANIFEST
           class app($port = 80) { }
 
           class app::web($port = $app::port) inherits app {
             notify { expected: message => "$port" }
           }
           MANIFEST
 
           catalog = compile_to_catalog(manifest, node)
 
           expect(catalog).to have_resource("Class[App]").with_parameter(:port, 8080)
           expect(catalog).to have_resource("Class[App::Web]")
           expect(catalog).to have_resource("Notify[expected]").with_parameter(:message, "8080")
         end
       end
     end
   end
 
   describe "when managing resource overrides" do
 
     before do
       @override = stub 'override', :ref => "File[/foo]", :type => "my"
       @resource = resource(:file, "/foo")
     end
 
     it "should be able to store overrides" do
       lambda { @compiler.add_override(@override) }.should_not raise_error
     end
 
     it "should apply overrides to the appropriate resources" do
       @compiler.add_resource(@scope, @resource)
       @resource.expects(:merge).with(@override)
 
       @compiler.add_override(@override)
 
       @compiler.compile
     end
 
     it "should accept overrides before the related resource has been created" do
       @resource.expects(:merge).with(@override)
 
       # First store the override
       @compiler.add_override(@override)
 
       # Then the resource
       @compiler.add_resource(@scope, @resource)
 
       # And compile, so they get resolved
       @compiler.compile
     end
 
     it "should fail if the compile is finished and resource overrides have not been applied" do
       @compiler.add_override(@override)
 
       lambda { @compiler.compile }.should raise_error Puppet::ParseError, 'Could not find resource(s) File[/foo] for overriding'
     end
   end
 end
diff --git a/spec/integration/resource/type_collection_spec.rb b/spec/integration/resource/type_collection_spec.rb
index 7ce2a8bc6..57dc04711 100755
--- a/spec/integration/resource/type_collection_spec.rb
+++ b/spec/integration/resource/type_collection_spec.rb
@@ -1,79 +1,94 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet_spec/files'
 require 'puppet/resource/type_collection'
 
 describe Puppet::Resource::TypeCollection do
   describe "when autoloading from modules" do
     include PuppetSpec::Files
 
     before do
       @dir = tmpfile("autoload_testing")
       FileUtils.mkdir_p @dir
 
       environment = Puppet::Node::Environment.create(:env, [@dir])
       @code = environment.known_resource_types
     end
 
     # Setup a module.
     def mk_module(name, files = {})
       mdir = File.join(@dir, name)
       mandir = File.join(mdir, "manifests")
       FileUtils.mkdir_p mandir
 
       defs = files.delete(:define)
 
       Dir.chdir(mandir) do
         files.each do |file, classes|
           File.open("#{file}.pp", "w") do |f|
             classes.each { |klass|
               if defs
                 f.puts "define #{klass} {}"
               else
                 f.puts "class #{klass} {}"
               end
             }
           end
         end
       end
     end
 
     it "should return nil when a class can't be found or loaded" do
-      @code.find_hostclass('nosuchclass').should be_nil
+      @code.find_hostclass('', 'nosuchclass').should be_nil
     end
 
     it "should load the module's init file first" do
       name = "simple"
       mk_module(name, :init => [name])
-      @code.find_hostclass(name).name.should == name
+
+      @code.find_hostclass("", name).name.should == name
+    end
+
+    it "should load the module's init file even when searching from a different namespace" do
+      name = "simple"
+      mk_module(name, :init => [name])
+
+      @code.find_hostclass("other::ns", name).name.should == name
     end
 
     it "should be able to load definitions from the module base file" do
       name = "simpdef"
       mk_module(name, :define => true, :init => [name])
-      @code.find_definition(name).name.should == name
+      @code.find_definition("", name).name.should == name
     end
 
     it "should be able to load qualified classes from the module base file" do
-      mk_module('both', :init => %w{both both::sub})
-      @code.find_hostclass("both::sub").name.should == "both::sub"
+      modname = "both"
+      name = "sub"
+      mk_module(modname, :init => %w{both both::sub})
+
+      @code.find_hostclass("both", name).name.should == "both::sub"
     end
 
     it "should be able load classes from a separate file" do
-      mk_module('separate', :init => %w{separate}, :sub => %w{separate::sub})
-      @code.find_hostclass("separate::sub").name.should == "separate::sub"
+      modname = "separate"
+      name = "sub"
+      mk_module(modname, :init => %w{separate}, :sub => %w{separate::sub})
+      @code.find_hostclass("separate", name).name.should == "separate::sub"
     end
 
     it "should not fail when loading from a separate file if there is no module file" do
-      mk_module('alone', :sub => %w{alone::sub})
-      lambda { @code.find_hostclass("alone::sub") }.should_not raise_error
+      modname = "alone"
+      name = "sub"
+      mk_module(modname, :sub => %w{alone::sub})
+      lambda { @code.find_hostclass("alone", name) }.should_not raise_error
     end
 
     it "should be able to load definitions from their own file" do
       name = "mymod"
       mk_module(name, :define => true, :mydefine => ["mymod::mydefine"])
-      @code.find_definition("mymod::mydefine").name.should == "mymod::mydefine"
+      @code.find_definition("", "mymod::mydefine").name.should == "mymod::mydefine"
     end
   end
 end
diff --git a/spec/unit/node/environment_spec.rb b/spec/unit/node/environment_spec.rb
index 74238542f..d3090e189 100755
--- a/spec/unit/node/environment_spec.rb
+++ b/spec/unit/node/environment_spec.rb
@@ -1,483 +1,483 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'tmpdir'
 
 require 'puppet/node/environment'
 require 'puppet/util/execution'
 require 'puppet_spec/modules'
 require 'puppet/parser/parser_factory'
 
 describe Puppet::Node::Environment do
   let(:env) { Puppet::Node::Environment.create("testing", []) }
 
   include PuppetSpec::Files
 
   context 'the environment' do
     it "converts an environment to string when converting to YAML" do
       env.to_yaml.should match(/--- testing/)
     end
 
     describe ".create" do
       it "creates equivalent environments whether specifying name as a symbol or a string" do
         expect(Puppet::Node::Environment.create(:one, [])).to eq(Puppet::Node::Environment.create("one", []))
       end
 
       it "interns name" do
         expect(Puppet::Node::Environment.create("one", []).name).to equal(:one)
       end
       it "does not produce environment singletons" do
         expect(Puppet::Node::Environment.create("one", [])).to_not equal(Puppet::Node::Environment.create("one", []))
       end
     end
 
     it "returns its name when converted to a string" do
       expect(env.to_s).to eq("testing")
     end
 
     it "has an inspect method for debugging" do
       e = Puppet::Node::Environment.create(:test, ['/modules/path', '/other/modules'], '/manifests/path')
       expect("a #{e} env").to eq("a test env")
       expect(e.inspect).to match(%r{<Puppet::Node::Environment:\w* @name="test" @manifest="#{File.expand_path('/manifests/path')}" @modulepath="#{File.expand_path('/modules/path')}:#{File.expand_path('/other/modules')}" >})
     end
 
     describe "equality" do
       it "works as a hash key" do
         base = Puppet::Node::Environment.create(:first, ["modules"], "manifests")
         same = Puppet::Node::Environment.create(:first, ["modules"], "manifests")
         different = Puppet::Node::Environment.create(:first, ["different"], "manifests")
         hash = {}
 
         hash[base] = "base env"
         hash[same] = "same env"
         hash[different] = "different env"
 
         expect(hash[base]).to eq("same env")
         expect(hash[different]).to eq("different env")
         expect(hash).to have(2).item
       end
 
       it "is equal when name, modules, and manifests are the same" do
         base = Puppet::Node::Environment.create(:base, ["modules"], "manifests")
         different_name = Puppet::Node::Environment.create(:different, base.full_modulepath, base.manifest)
 
         expect(base).to_not eq("not an environment")
 
         expect(base).to eq(base)
         expect(base.hash).to eq(base.hash)
 
         expect(base.override_with(:modulepath => ["different"])).to_not eq(base)
         expect(base.override_with(:modulepath => ["different"]).hash).to_not eq(base.hash)
 
         expect(base.override_with(:manifest => "different")).to_not eq(base)
         expect(base.override_with(:manifest => "different").hash).to_not eq(base.hash)
 
         expect(different_name).to_not eq(base)
         expect(different_name.hash).to_not eq(base.hash)
       end
     end
 
     describe "overriding an existing environment" do
       let(:original_path) { [tmpdir('original')] }
       let(:new_path) { [tmpdir('new')] }
       let(:environment) { Puppet::Node::Environment.create(:overridden, original_path, 'orig.pp', '/config/script') }
 
       it "overrides modulepath" do
         overridden = environment.override_with(:modulepath => new_path)
         expect(overridden).to_not be_equal(environment)
         expect(overridden.name).to eq(:overridden)
         expect(overridden.manifest).to eq(File.expand_path('orig.pp'))
         expect(overridden.modulepath).to eq(new_path)
         expect(overridden.config_version).to eq('/config/script')
       end
 
       it "overrides manifest" do
         overridden = environment.override_with(:manifest => 'new.pp')
         expect(overridden).to_not be_equal(environment)
         expect(overridden.name).to eq(:overridden)
         expect(overridden.manifest).to eq(File.expand_path('new.pp'))
         expect(overridden.modulepath).to eq(original_path)
         expect(overridden.config_version).to eq('/config/script')
       end
 
       it "overrides config_version" do
         overridden = environment.override_with(:config_version => '/new/script')
         expect(overridden).to_not be_equal(environment)
         expect(overridden.name).to eq(:overridden)
         expect(overridden.manifest).to eq(File.expand_path('orig.pp'))
         expect(overridden.modulepath).to eq(original_path)
         expect(overridden.config_version).to eq('/new/script')
       end
     end
 
     describe "when managing known resource types" do
       before do
         env.stubs(:perform_initial_import).returns(Puppet::Parser::AST::Hostclass.new(''))
       end
 
       it "creates a resource type collection if none exists" do
         expect(env.known_resource_types).to be_kind_of(Puppet::Resource::TypeCollection)
       end
 
       it "memoizes resource type collection" do
         expect(env.known_resource_types).to equal(env.known_resource_types)
       end
 
       it "performs the initial import when creating a new collection" do
         env.expects(:perform_initial_import).returns(Puppet::Parser::AST::Hostclass.new(''))
         env.known_resource_types
       end
 
       it "generates a new TypeCollection if the current one requires reparsing" do
         old_type_collection = env.known_resource_types
         old_type_collection.stubs(:parse_failed?).returns true
 
         env.check_for_reparse
 
         new_type_collection = env.known_resource_types
         expect(new_type_collection).to be_a Puppet::Resource::TypeCollection
         expect(new_type_collection).to_not equal(old_type_collection)
       end
     end
 
     it "validates the modulepath directories" do
       real_file = tmpdir('moduledir')
       path = ['/one', '/two', real_file]
 
       env = Puppet::Node::Environment.create(:test, path)
 
       expect(env.modulepath).to eq([real_file])
     end
 
     it "prefixes the value of the 'PUPPETLIB' environment variable to the module path if present" do
       first_puppetlib = tmpdir('puppetlib1')
       second_puppetlib = tmpdir('puppetlib2')
       first_moduledir = tmpdir('moduledir1')
       second_moduledir = tmpdir('moduledir2')
       Puppet::Util.withenv("PUPPETLIB" => [first_puppetlib, second_puppetlib].join(File::PATH_SEPARATOR)) do
         env = Puppet::Node::Environment.create(:testing, [first_moduledir, second_moduledir])
 
         expect(env.modulepath).to eq([first_puppetlib, second_puppetlib, first_moduledir, second_moduledir])
       end
     end
 
     describe "validating manifest settings" do
       before(:each) do
         Puppet[:default_manifest] = "/default/manifests/site.pp"
       end
 
       it "has no validation errors when disable_per_environment_manifest is false" do
         expect(Puppet::Node::Environment.create(:directory, [], '/some/non/default/manifest.pp').validation_errors).to be_empty
       end
 
       context "when disable_per_environment_manifest is true" do
         let(:config) { mock('config') }
         let(:global_modulepath) { ["/global/modulepath"] }
         let(:envconf) { Puppet::Settings::EnvironmentConf.new("/some/direnv", config, global_modulepath) }
 
         before(:each) do
           Puppet[:disable_per_environment_manifest] = true
         end
 
         def assert_manifest_conflict(expectation, envconf_manifest_value)
           config.expects(:setting).with(:manifest).returns(
             mock('setting', :value => envconf_manifest_value)
           )
           environment = Puppet::Node::Environment.create(:directory, [], '/default/manifests/site.pp')
           loader = Puppet::Environments::Static.new(environment)
           loader.stubs(:get_conf).returns(envconf)
 
           Puppet.override(:environments => loader) do
             if expectation
               expect(environment.validation_errors).to have_matching_element(/The 'disable_per_environment_manifest' setting is true.*and the.*environment.*conflicts/)
             else
               expect(environment.validation_errors).to be_empty
             end
           end
         end
 
         it "has conflicting_manifest_settings when environment.conf manifest was set" do
           assert_manifest_conflict(true, '/some/envconf/manifest/site.pp')
         end
 
         it "does not have conflicting_manifest_settings when environment.conf manifest is empty" do
           assert_manifest_conflict(false, '')
         end
 
         it "does not have conflicting_manifest_settings when environment.conf manifest is nil" do
           assert_manifest_conflict(false, nil)
         end
 
         it "does not have conflicting_manifest_settings when environment.conf manifest is an exact, uninterpolated match of default_manifest" do
           assert_manifest_conflict(false, '/default/manifests/site.pp')
         end
       end
     end
 
     describe "when modeling a specific environment" do
       let(:first_modulepath) { tmpdir('firstmodules') }
       let(:second_modulepath) { tmpdir('secondmodules') }
       let(:env) { Puppet::Node::Environment.create(:modules_test, [first_modulepath, second_modulepath]) }
       let(:module_options) {
         {
           :environment => env,
           :metadata => {
             :author       => 'puppetlabs',
           },
         }
       }
 
       describe "module data" do
         describe ".module" do
 
           it "returns an individual module that exists in its module path" do
             one = PuppetSpec::Modules.create('one', first_modulepath, module_options)
             expect(env.module('one')).to eq(one)
           end
 
           it "returns nil if asked for a module that does not exist in its path" do
             expect(env.module("doesnotexist")).to be_nil
           end
         end
 
         describe "#modules_by_path" do
           it "returns an empty list if there are no modules" do
             expect(env.modules_by_path).to eq({
               first_modulepath => [],
               second_modulepath => []
             })
           end
 
           it "includes modules even if they exist in multiple dirs in the modulepath" do
             one = PuppetSpec::Modules.create('one', first_modulepath, module_options)
             two = PuppetSpec::Modules.create('two', second_modulepath, module_options)
 
             expect(env.modules_by_path).to eq({
               first_modulepath  => [one],
               second_modulepath => [two],
             })
           end
 
           it "ignores modules with invalid names" do
             PuppetSpec::Modules.generate_files('foo', first_modulepath)
             PuppetSpec::Modules.generate_files('foo2', first_modulepath)
             PuppetSpec::Modules.generate_files('foo-bar', first_modulepath)
             PuppetSpec::Modules.generate_files('foo_bar', first_modulepath)
             PuppetSpec::Modules.generate_files('foo=bar', first_modulepath)
             PuppetSpec::Modules.generate_files('foo bar', first_modulepath)
             PuppetSpec::Modules.generate_files('foo.bar', first_modulepath)
             PuppetSpec::Modules.generate_files('-foo', first_modulepath)
             PuppetSpec::Modules.generate_files('foo-', first_modulepath)
             PuppetSpec::Modules.generate_files('foo--bar', first_modulepath)
 
             expect(env.modules_by_path[first_modulepath].collect{|mod| mod.name}.sort).to eq(%w{foo foo-bar foo2 foo_bar})
           end
 
         end
 
         describe "#module_requirements" do
           it "returns a list of what modules depend on other modules" do
             PuppetSpec::Modules.create(
               'foo',
               first_modulepath,
               :metadata => {
                 :author       => 'puppetlabs',
                 :dependencies => [{ 'name' => 'puppetlabs/bar', "version_requirement" => ">= 1.0.0" }]
               }
             )
             PuppetSpec::Modules.create(
               'bar',
               second_modulepath,
               :metadata => {
                 :author       => 'puppetlabs',
                 :dependencies => [{ 'name' => 'puppetlabs/foo', "version_requirement" => "<= 2.0.0" }]
               }
             )
             PuppetSpec::Modules.create(
               'baz',
               first_modulepath,
               :metadata => {
                 :author       => 'puppetlabs',
                 :dependencies => [{ 'name' => 'puppetlabs-bar', "version_requirement" => "3.0.0" }]
               }
             )
             PuppetSpec::Modules.create(
               'alpha',
               first_modulepath,
               :metadata => {
                 :author       => 'puppetlabs',
                 :dependencies => [{ 'name' => 'puppetlabs/bar', "version_requirement" => "~3.0.0" }]
               }
             )
 
             expect(env.module_requirements).to eq({
               'puppetlabs/alpha' => [],
               'puppetlabs/foo' => [
                 {
                   "name"    => "puppetlabs/bar",
                   "version" => "9.9.9",
                   "version_requirement" => "<= 2.0.0"
                 }
               ],
               'puppetlabs/bar' => [
                 {
                   "name"    => "puppetlabs/alpha",
                   "version" => "9.9.9",
                   "version_requirement" => "~3.0.0"
                 },
                 {
                   "name"    => "puppetlabs/baz",
                   "version" => "9.9.9",
                   "version_requirement" => "3.0.0"
                 },
                 {
                   "name"    => "puppetlabs/foo",
                   "version" => "9.9.9",
                   "version_requirement" => ">= 1.0.0"
                 }
               ],
               'puppetlabs/baz' => []
             })
           end
         end
 
         describe ".module_by_forge_name" do
           it "finds modules by forge_name" do
             mod = PuppetSpec::Modules.create(
               'baz',
               first_modulepath,
-              module_options
+              module_options,
             )
             expect(env.module_by_forge_name('puppetlabs/baz')).to eq(mod)
           end
 
           it "does not find modules with same name by the wrong author" do
             mod = PuppetSpec::Modules.create(
               'baz',
               first_modulepath,
               :metadata => {:author => 'sneakylabs'},
               :environment => env
             )
             expect(env.module_by_forge_name('puppetlabs/baz')).to eq(nil)
           end
 
           it "returns nil when the module can't be found" do
             expect(env.module_by_forge_name('ima/nothere')).to be_nil
           end
         end
 
         describe ".modules" do
           it "returns an empty list if there are no modules" do
             expect(env.modules).to eq([])
           end
 
           it "returns a module named for every directory in each module path" do
             %w{foo bar}.each do |mod_name|
               PuppetSpec::Modules.generate_files(mod_name, first_modulepath)
             end
             %w{bee baz}.each do |mod_name|
               PuppetSpec::Modules.generate_files(mod_name, second_modulepath)
             end
             expect(env.modules.collect{|mod| mod.name}.sort).to eq(%w{foo bar bee baz}.sort)
           end
 
           it "removes duplicates" do
             PuppetSpec::Modules.generate_files('foo', first_modulepath)
             PuppetSpec::Modules.generate_files('foo', second_modulepath)
 
             expect(env.modules.collect{|mod| mod.name}.sort).to eq(%w{foo})
           end
 
           it "ignores modules with invalid names" do
             PuppetSpec::Modules.generate_files('foo', first_modulepath)
             PuppetSpec::Modules.generate_files('foo2', first_modulepath)
             PuppetSpec::Modules.generate_files('foo-bar', first_modulepath)
             PuppetSpec::Modules.generate_files('foo_bar', first_modulepath)
             PuppetSpec::Modules.generate_files('foo=bar', first_modulepath)
             PuppetSpec::Modules.generate_files('foo bar', first_modulepath)
 
             expect(env.modules.collect{|mod| mod.name}.sort).to eq(%w{foo foo-bar foo2 foo_bar})
           end
 
           it "creates modules with the correct environment" do
             PuppetSpec::Modules.generate_files('foo', first_modulepath)
 
             env.modules.each do |mod| 
               expect(mod.environment).to eq(env)
             end
           end
 
           it "logs an exception if a module contains invalid metadata" do
             PuppetSpec::Modules.generate_files(
               'foo',
               first_modulepath,
               :metadata => {
                 :author       => 'puppetlabs'
                 # missing source, version, etc
               }
             )
 
             Puppet.expects(:log_exception).with(is_a(Puppet::Module::MissingMetadata))
 
             env.modules
           end
         end
       end
     end
 
     describe "when performing initial import" do
       it "loads from Puppet[:code]" do
         Puppet[:code] = "define foo {}"
         krt = env.known_resource_types
-        expect(krt.find_definition('foo')).to be_kind_of(Puppet::Resource::Type)
+        expect(krt.find_definition('', 'foo')).to be_kind_of(Puppet::Resource::Type)
       end
 
       it "parses from the the environment's manifests if Puppet[:code] is not set" do
         filename = tmpfile('a_manifest.pp')
         File.open(filename, 'w') do |f|
           f.puts("define from_manifest {}")
         end
         env = Puppet::Node::Environment.create(:testing, [], filename)
         krt = env.known_resource_types
-        expect(krt.find_definition('from_manifest')).to be_kind_of(Puppet::Resource::Type)
+        expect(krt.find_definition('', 'from_manifest')).to be_kind_of(Puppet::Resource::Type)
       end
 
       it "prefers Puppet[:code] over manifest files" do
         Puppet[:code] = "define from_code_setting {}"
         filename = tmpfile('a_manifest.pp')
         File.open(filename, 'w') do |f|
           f.puts("define from_manifest {}")
         end
         env = Puppet::Node::Environment.create(:testing, [], filename)
         krt = env.known_resource_types
-        expect(krt.find_definition('from_code_setting')).to be_kind_of(Puppet::Resource::Type)
+        expect(krt.find_definition('', 'from_code_setting')).to be_kind_of(Puppet::Resource::Type)
       end
 
       it "initial import proceeds even if manifest file does not exist on disk" do
         filename = tmpfile('a_manifest.pp')
         env = Puppet::Node::Environment.create(:testing, [], filename)
         expect(env.known_resource_types).to be_kind_of(Puppet::Resource::TypeCollection)
       end
 
       it "returns an empty TypeCollection if neither code nor manifests is present" do
         expect(env.known_resource_types).to be_kind_of(Puppet::Resource::TypeCollection)
       end
 
       it "fails helpfully if there is an error importing" do
         Puppet[:code] = "oops {"
         expect do
           env.known_resource_types
         end.to raise_error(Puppet::Error, /Could not parse for environment #{env.name}/)
       end
 
       it "should mark the type collection as needing a reparse when there is an error parsing" do
         Puppet[:code] = "oops {"
         expect do
           env.known_resource_types
         end.to raise_error(Puppet::Error, /Syntax error at .../)
         expect(env.known_resource_types.parse_failed?).to be_true
       end
     end
   end
 
 end
diff --git a/spec/unit/parser/compiler_spec.rb b/spec/unit/parser/compiler_spec.rb
index 4bfcf1f70..1f42c2cbf 100755
--- a/spec/unit/parser/compiler_spec.rb
+++ b/spec/unit/parser/compiler_spec.rb
@@ -1,938 +1,938 @@
 require 'spec_helper'
 require 'puppet_spec/compiler'
 require 'matchers/resource'
 
 class CompilerTestResource
   attr_accessor :builtin, :virtual, :evaluated, :type, :title
 
   def initialize(type, title)
     @type = type
     @title = title
   end
 
   def [](attr)
     return nil if attr == :stage
     :main
   end
 
   def ref
     "#{type.to_s.capitalize}[#{title}]"
   end
 
   def evaluated?
     @evaluated
   end
 
   def builtin_type?
     @builtin
   end
 
   def virtual?
     @virtual
   end
 
   def class?
     false
   end
 
   def stage?
     false
   end
 
   def evaluate
   end
 
   def file
     "/fake/file/goes/here"
   end
 
   def line
     "42"
   end
 end
 
 describe Puppet::Parser::Compiler do
   include PuppetSpec::Files
   include Matchers::Resource
 
   def resource(type, title)
     Puppet::Parser::Resource.new(type, title, :scope => @scope)
   end
 
   let(:environment) { Puppet::Node::Environment.create(:testing, []) }
 
   before :each do
     # Push me faster, I wanna go back in time!  (Specifically, freeze time
     # across the test since we have a bunch of version == timestamp code
     # hidden away in the implementation and we keep losing the race.)
     # --daniel 2011-04-21
     now = Time.now
     Time.stubs(:now).returns(now)
 
     @node = Puppet::Node.new("testnode",
                              :facts => Puppet::Node::Facts.new("facts", {}),
                              :environment => environment)
     @known_resource_types = environment.known_resource_types
     @compiler = Puppet::Parser::Compiler.new(@node)
     @scope = Puppet::Parser::Scope.new(@compiler, :source => stub('source'))
     @scope_resource = Puppet::Parser::Resource.new(:file, "/my/file", :scope => @scope)
     @scope.resource = @scope_resource
   end
 
   it "should have a class method that compiles, converts, and returns a catalog" do
     compiler = stub 'compiler'
     Puppet::Parser::Compiler.expects(:new).with(@node).returns compiler
     catalog = stub 'catalog'
     compiler.expects(:compile).returns catalog
     converted_catalog = stub 'converted_catalog'
     catalog.expects(:to_resource).returns converted_catalog
 
     Puppet::Parser::Compiler.compile(@node).should equal(converted_catalog)
   end
 
   it "should fail intelligently when a class-level compile fails" do
     Puppet::Parser::Compiler.expects(:new).raises ArgumentError
     lambda { Puppet::Parser::Compiler.compile(@node) }.should raise_error(Puppet::Error)
   end
 
   it "should use the node's environment as its environment" do
     @compiler.environment.should equal(@node.environment)
   end
 
   it "fails if the node's environment has validation errors" do
     conflicted_environment = Puppet::Node::Environment.create(:testing, [], '/some/environment.conf/manifest.pp')
     conflicted_environment.stubs(:validation_errors).returns(['bad environment'])
     @node.environment = conflicted_environment
     expect { Puppet::Parser::Compiler.compile(@node) }.to raise_error(Puppet::Error, /Compilation has been halted because.*bad environment/)
   end
 
   it "should include the resource type collection helper" do
     Puppet::Parser::Compiler.ancestors.should be_include(Puppet::Resource::TypeCollectionHelper)
   end
 
   it "should be able to return a class list containing all added classes" do
     @compiler.add_class ""
     @compiler.add_class "one"
     @compiler.add_class "two"
 
     @compiler.classlist.sort.should == %w{one two}.sort
   end
 
   it "should clear the global caches before compile" do
     compiler = stub 'compiler'
     Puppet::Parser::Compiler.expects(:new).with(@node).returns compiler
     catalog = stub 'catalog'
     compiler.expects(:compile).returns catalog
     catalog.expects(:to_resource)
 
     $known_resource_types = "rspec"
     $env_module_directories = "rspec"
 
     Puppet::Parser::Compiler.compile(@node)
 
     $known_resource_types = nil
     $env_module_directories = nil
   end
 
   describe "when initializing" do
 
     it "should set its node attribute" do
       @compiler.node.should equal(@node)
     end
     it "should detect when ast nodes are absent" do
       @compiler.ast_nodes?.should be_false
     end
 
     it "should detect when ast nodes are present" do
       @known_resource_types.expects(:nodes?).returns true
       @compiler.ast_nodes?.should be_true
     end
 
     it "should copy the known_resource_types version to the catalog" do
       @compiler.catalog.version.should == @known_resource_types.version
     end
 
     it "should copy any node classes into the class list" do
       node = Puppet::Node.new("mynode")
       node.classes = %w{foo bar}
       compiler = Puppet::Parser::Compiler.new(node)
 
       compiler.classlist.should =~ ['foo', 'bar']
     end
 
     it "should transform node class hashes into a class list" do
       node = Puppet::Node.new("mynode")
       node.classes = {'foo'=>{'one'=>'p1'}, 'bar'=>{'two'=>'p2'}}
       compiler = Puppet::Parser::Compiler.new(node)
 
       compiler.classlist.should =~ ['foo', 'bar']
     end
 
     it "should add a 'main' stage to the catalog" do
       @compiler.catalog.resource(:stage, :main).should be_instance_of(Puppet::Parser::Resource)
     end
   end
 
   describe "when managing scopes" do
 
     it "should create a top scope" do
       @compiler.topscope.should be_instance_of(Puppet::Parser::Scope)
     end
 
     it "should be able to create new scopes" do
       @compiler.newscope(@compiler.topscope).should be_instance_of(Puppet::Parser::Scope)
     end
 
     it "should set the parent scope of the new scope to be the passed-in parent" do
       scope = mock 'scope'
       newscope = @compiler.newscope(scope)
 
       newscope.parent.should equal(scope)
     end
 
     it "should set the parent scope of the new scope to its topscope if the parent passed in is nil" do
       scope = mock 'scope'
       newscope = @compiler.newscope(nil)
 
       newscope.parent.should equal(@compiler.topscope)
     end
   end
 
   describe "when compiling" do
 
     def compile_methods
       [:set_node_parameters, :evaluate_main, :evaluate_ast_node, :evaluate_node_classes, :evaluate_generators, :fail_on_unevaluated,
         :finish, :store, :extract, :evaluate_relationships]
     end
 
     # Stub all of the main compile methods except the ones we're specifically interested in.
     def compile_stub(*except)
       (compile_methods - except).each { |m| @compiler.stubs(m) }
     end
 
     it "should set node parameters as variables in the top scope" do
       params = {"a" => "b", "c" => "d"}
       @node.stubs(:parameters).returns(params)
       compile_stub(:set_node_parameters)
       @compiler.compile
       @compiler.topscope['a'].should == "b"
       @compiler.topscope['c'].should == "d"
     end
 
     it "should set the client and server versions on the catalog" do
       params = {"clientversion" => "2", "serverversion" => "3"}
       @node.stubs(:parameters).returns(params)
       compile_stub(:set_node_parameters)
       @compiler.compile
       @compiler.catalog.client_version.should == "2"
       @compiler.catalog.server_version.should == "3"
     end
 
     it "should evaluate the main class if it exists" do
       compile_stub(:evaluate_main)
       main_class = @known_resource_types.add Puppet::Resource::Type.new(:hostclass, "")
       main_class.expects(:evaluate_code).with { |r| r.is_a?(Puppet::Parser::Resource) }
       @compiler.topscope.expects(:source=).with(main_class)
 
       @compiler.compile
     end
 
     it "should create a new, empty 'main' if no main class exists" do
       compile_stub(:evaluate_main)
       @compiler.compile
-      @known_resource_types.find_hostclass("").should be_instance_of(Puppet::Resource::Type)
+      @known_resource_types.find_hostclass([""], "").should be_instance_of(Puppet::Resource::Type)
     end
 
     it "should add an edge between the main stage and main class" do
       @compiler.compile
       (stage = @compiler.catalog.resource(:stage, "main")).should be_instance_of(Puppet::Parser::Resource)
       (klass = @compiler.catalog.resource(:class, "")).should be_instance_of(Puppet::Parser::Resource)
 
       @compiler.catalog.edge?(stage, klass).should be_true
     end
 
     it "should evaluate all added collections" do
       colls = []
       # And when the collections fail to evaluate.
       colls << mock("coll1-false")
       colls << mock("coll2-false")
       colls.each { |c| c.expects(:evaluate).returns(false) }
 
       @compiler.add_collection(colls[0])
       @compiler.add_collection(colls[1])
 
       compile_stub(:evaluate_generators)
       @compiler.compile
     end
 
     it "should ignore builtin resources" do
       resource = resource(:file, "testing")
 
       @compiler.add_resource(@scope, resource)
       resource.expects(:evaluate).never
 
       @compiler.compile
     end
 
     it "should evaluate unevaluated resources" do
       resource = CompilerTestResource.new(:file, "testing")
 
       @compiler.add_resource(@scope, resource)
 
       # We have to now mark the resource as evaluated
       resource.expects(:evaluate).with { |*whatever| resource.evaluated = true }
 
       @compiler.compile
     end
 
     it "should not evaluate already-evaluated resources" do
       resource = resource(:file, "testing")
       resource.stubs(:evaluated?).returns true
 
       @compiler.add_resource(@scope, resource)
       resource.expects(:evaluate).never
 
       @compiler.compile
     end
 
     it "should evaluate unevaluated resources created by evaluating other resources" do
       resource = CompilerTestResource.new(:file, "testing")
       @compiler.add_resource(@scope, resource)
 
       resource2 = CompilerTestResource.new(:file, "other")
 
       # We have to now mark the resource as evaluated
       resource.expects(:evaluate).with { |*whatever| resource.evaluated = true; @compiler.add_resource(@scope, resource2) }
       resource2.expects(:evaluate).with { |*whatever| resource2.evaluated = true }
 
 
       @compiler.compile
     end
 
     describe "when finishing" do
       before do
         @compiler.send(:evaluate_main)
         @catalog = @compiler.catalog
       end
 
       def add_resource(name, parent = nil)
         resource = Puppet::Parser::Resource.new "file", name, :scope => @scope
         @compiler.add_resource(@scope, resource)
         @catalog.add_edge(parent, resource) if parent
         resource
       end
 
       it "should call finish() on all resources" do
         # Add a resource that does respond to :finish
         resource = Puppet::Parser::Resource.new "file", "finish", :scope => @scope
         resource.expects(:finish)
 
         @compiler.add_resource(@scope, resource)
 
         # And one that does not
         dnf_resource = stub_everything "dnf", :ref => "File[dnf]", :type => "file"
 
         @compiler.add_resource(@scope, dnf_resource)
 
         @compiler.send(:finish)
       end
 
       it "should call finish() in add_resource order" do
         resources = sequence('resources')
 
         resource1 = add_resource("finish1")
         resource1.expects(:finish).in_sequence(resources)
 
         resource2 = add_resource("finish2")
         resource2.expects(:finish).in_sequence(resources)
 
         @compiler.send(:finish)
       end
 
       it "should add each container's metaparams to its contained resources" do
         main = @catalog.resource(:class, :main)
         main[:noop] = true
 
         resource1 = add_resource("meh", main)
 
         @compiler.send(:finish)
         resource1[:noop].should be_true
       end
 
       it "should add metaparams recursively" do
         main = @catalog.resource(:class, :main)
         main[:noop] = true
 
         resource1 = add_resource("meh", main)
         resource2 = add_resource("foo", resource1)
 
         @compiler.send(:finish)
         resource2[:noop].should be_true
       end
 
       it "should prefer metaparams from immediate parents" do
         main = @catalog.resource(:class, :main)
         main[:noop] = true
 
         resource1 = add_resource("meh", main)
         resource2 = add_resource("foo", resource1)
 
         resource1[:noop] = false
 
         @compiler.send(:finish)
         resource2[:noop].should be_false
       end
 
       it "should merge tags downward" do
         main = @catalog.resource(:class, :main)
         main.tag("one")
 
         resource1 = add_resource("meh", main)
         resource1.tag "two"
         resource2 = add_resource("foo", resource1)
 
         @compiler.send(:finish)
         resource2.tags.should be_include("one")
         resource2.tags.should be_include("two")
       end
 
       it "should work if only middle resources have metaparams set" do
         main = @catalog.resource(:class, :main)
 
         resource1 = add_resource("meh", main)
         resource1[:noop] = true
         resource2 = add_resource("foo", resource1)
 
         @compiler.send(:finish)
         resource2[:noop].should be_true
       end
     end
 
     it "should return added resources in add order" do
       resource1 = resource(:file, "yay")
       @compiler.add_resource(@scope, resource1)
       resource2 = resource(:file, "youpi")
       @compiler.add_resource(@scope, resource2)
 
       @compiler.resources.should == [resource1, resource2]
     end
 
     it "should add resources that do not conflict with existing resources" do
       resource = resource(:file, "yay")
       @compiler.add_resource(@scope, resource)
 
       @compiler.catalog.should be_vertex(resource)
     end
 
     it "should fail to add resources that conflict with existing resources" do
       path = make_absolute("/foo")
       file1 = resource(:file, path)
       file2 = resource(:file, path)
 
       @compiler.add_resource(@scope, file1)
       lambda { @compiler.add_resource(@scope, file2) }.should raise_error(Puppet::Resource::Catalog::DuplicateResourceError)
     end
 
     it "should add an edge from the scope resource to the added resource" do
       resource = resource(:file, "yay")
       @compiler.add_resource(@scope, resource)
 
       @compiler.catalog.should be_edge(@scope.resource, resource)
     end
 
     it "should not add non-class resources that don't specify a stage to the 'main' stage" do
       main = @compiler.catalog.resource(:stage, :main)
       resource = resource(:file, "foo")
       @compiler.add_resource(@scope, resource)
 
       @compiler.catalog.should_not be_edge(main, resource)
     end
 
     it "should not add any parent-edges to stages" do
       stage = resource(:stage, "other")
       @compiler.add_resource(@scope, stage)
 
       @scope.resource = resource(:class, "foo")
 
       @compiler.catalog.edge?(@scope.resource, stage).should be_false
     end
 
     it "should not attempt to add stages to other stages" do
       other_stage = resource(:stage, "other")
       second_stage = resource(:stage, "second")
       @compiler.add_resource(@scope, other_stage)
       @compiler.add_resource(@scope, second_stage)
 
       second_stage[:stage] = "other"
 
       @compiler.catalog.edge?(other_stage, second_stage).should be_false
     end
 
     it "should have a method for looking up resources" do
       resource = resource(:yay, "foo")
       @compiler.add_resource(@scope, resource)
       @compiler.findresource("Yay[foo]").should equal(resource)
     end
 
     it "should be able to look resources up by type and title" do
       resource = resource(:yay, "foo")
       @compiler.add_resource(@scope, resource)
       @compiler.findresource("Yay", "foo").should equal(resource)
     end
 
     it "should not evaluate virtual defined resources" do
       resource = resource(:file, "testing")
       resource.virtual = true
       @compiler.add_resource(@scope, resource)
 
       resource.expects(:evaluate).never
 
       @compiler.compile
     end
   end
 
   describe "when evaluating collections" do
 
     it "should evaluate each collection" do
       2.times { |i|
         coll = mock 'coll%s' % i
         @compiler.add_collection(coll)
 
         # This is the hard part -- we have to emulate the fact that
         # collections delete themselves if they are done evaluating.
         coll.expects(:evaluate).with do
           @compiler.delete_collection(coll)
         end
       }
 
       @compiler.compile
     end
 
     it "should not fail when there are unevaluated resource collections that do not refer to specific resources" do
       coll = stub 'coll', :evaluate => false
       coll.expects(:unresolved_resources).returns(nil)
 
       @compiler.add_collection(coll)
 
       lambda { @compiler.compile }.should_not raise_error
     end
 
     it "should fail when there are unevaluated resource collections that refer to a specific resource" do
       coll = stub 'coll', :evaluate => false
       coll.expects(:unresolved_resources).returns(:something)
 
       @compiler.add_collection(coll)
 
       lambda { @compiler.compile }.should raise_error(Puppet::ParseError, 'Failed to realize virtual resources something')
     end
 
     it "should fail when there are unevaluated resource collections that refer to multiple specific resources" do
       coll = stub 'coll', :evaluate => false
       coll.expects(:unresolved_resources).returns([:one, :two])
 
       @compiler.add_collection(coll)
 
       lambda { @compiler.compile }.should raise_error(Puppet::ParseError, 'Failed to realize virtual resources one, two')
     end
   end
 
   describe "when evaluating relationships" do
     it "should evaluate each relationship with its catalog" do
       dep = stub 'dep'
       dep.expects(:evaluate).with(@compiler.catalog)
       @compiler.add_relationship dep
       @compiler.evaluate_relationships
     end
   end
 
   describe "when told to evaluate missing classes" do
 
     it "should fail if there's no source listed for the scope" do
       scope = stub 'scope', :source => nil
       proc { @compiler.evaluate_classes(%w{one two}, scope) }.should raise_error(Puppet::DevError)
     end
 
     it "should raise an error if a class is not found" do
-      @scope.expects(:find_hostclass).with("notfound").returns(nil)
+      @scope.expects(:find_hostclass).with("notfound", {:assume_fqname => false}).returns(nil)
       lambda{ @compiler.evaluate_classes(%w{notfound}, @scope) }.should raise_error(Puppet::Error, /Could not find class/)
     end
 
     it "should raise an error when it can't find class" do
       klasses = {'foo'=>nil}
       @node.classes = klasses
-      @compiler.topscope.expects(:find_hostclass).with('foo').returns(nil)
+      @compiler.topscope.expects(:find_hostclass).with('foo', {:assume_fqname => false}).returns(nil)
       lambda{ @compiler.compile }.should raise_error(Puppet::Error, /Could not find class foo for testnode/)
     end
   end
 
   describe "when evaluating found classes" do
 
     before do
       Puppet.settings[:data_binding_terminus] = "none"
       @class = stub 'class', :name => "my::class"
-      @scope.stubs(:find_hostclass).with("myclass").returns(@class)
+      @scope.stubs(:find_hostclass).with("myclass", {:assume_fqname => false}).returns(@class)
 
       @resource = stub 'resource', :ref => "Class[myclass]", :type => "file"
     end
 
     around do |example|
       Puppet.override(
         :environments => Puppet::Environments::Static.new(environment),
         :description => "Static loader for specs"
       ) do
         example.run
       end
     end
 
     it "should evaluate each class" do
       @compiler.catalog.stubs(:tag)
 
       @class.expects(:ensure_in_catalog).with(@scope)
       @scope.stubs(:class_scope).with(@class)
 
       @compiler.evaluate_classes(%w{myclass}, @scope)
     end
 
     describe "and the classes are specified as a hash with parameters" do
       before do
         @node.classes = {}
         @ast_obj = Puppet::Parser::AST::Leaf.new(:value => 'foo')
       end
 
       # Define the given class with default parameters
       def define_class(name, parameters)
         @node.classes[name] = parameters
         klass = Puppet::Resource::Type.new(:hostclass, name, :arguments => {'p1' => @ast_obj, 'p2' => @ast_obj})
         @compiler.topscope.known_resource_types.add klass
       end
 
       def compile
         @catalog = @compiler.compile
       end
 
       it "should record which classes are evaluated" do
         classes = {'foo'=>{}, 'bar::foo'=>{}, 'bar'=>{}}
         classes.each { |c, params| define_class(c, params) }
         compile()
         classes.each { |name, p| @catalog.classes.should include(name) }
       end
 
       it "should provide default values for parameters that have no values specified" do
         define_class('foo', {})
         compile()
         @catalog.resource(:class, 'foo')['p1'].should == "foo"
       end
 
       it "should use any provided values" do
         define_class('foo', {'p1' => 'real_value'})
         compile()
         @catalog.resource(:class, 'foo')['p1'].should == "real_value"
       end
 
       it "should support providing some but not all values" do
         define_class('foo', {'p1' => 'real_value'})
         compile()
         @catalog.resource(:class, 'Foo')['p1'].should == "real_value"
         @catalog.resource(:class, 'Foo')['p2'].should == "foo"
       end
 
       it "should ensure each node class is in catalog and has appropriate tags" do
         klasses = ['bar::foo']
         @node.classes = klasses
         ast_obj = Puppet::Parser::AST::Leaf.new(:value => 'foo')
         klasses.each do |name|
           klass = Puppet::Resource::Type.new(:hostclass, name, :arguments => {'p1' => ast_obj, 'p2' => ast_obj})
           @compiler.topscope.known_resource_types.add klass
         end
         catalog = @compiler.compile
 
         r2 = catalog.resources.detect {|r| r.title == 'Bar::Foo' }
         r2.tags.should == Puppet::Util::TagSet.new(['bar::foo', 'class', 'bar', 'foo'])
       end
     end
 
     it "should fail if required parameters are missing" do
       klass = {'foo'=>{'a'=>'one'}}
       @node.classes = klass
       klass = Puppet::Resource::Type.new(:hostclass, 'foo', :arguments => {'a' => nil, 'b' => nil})
       @compiler.topscope.known_resource_types.add klass
       lambda { @compiler.compile }.should raise_error(Puppet::ParseError, "Must pass b to Class[Foo]")
     end
 
     it "should fail if invalid parameters are passed" do
       klass = {'foo'=>{'3'=>'one'}}
       @node.classes = klass
       klass = Puppet::Resource::Type.new(:hostclass, 'foo', :arguments => {})
       @compiler.topscope.known_resource_types.add klass
       lambda { @compiler.compile }.should raise_error(Puppet::ParseError, "Invalid parameter 3 on Class[Foo]")
     end
 
     it "should ensure class is in catalog without params" do
       @node.classes = klasses = {'foo'=>nil}
       foo = Puppet::Resource::Type.new(:hostclass, 'foo')
       @compiler.topscope.known_resource_types.add foo
       catalog = @compiler.compile
       catalog.classes.should include 'foo'
     end
 
     it "should not evaluate the resources created for found classes unless asked" do
       @compiler.catalog.stubs(:tag)
 
       @resource.expects(:evaluate).never
 
       @class.expects(:ensure_in_catalog).returns(@resource)
       @scope.stubs(:class_scope).with(@class)
 
       @compiler.evaluate_classes(%w{myclass}, @scope)
     end
 
     it "should immediately evaluate the resources created for found classes when asked" do
       @compiler.catalog.stubs(:tag)
 
       @resource.expects(:evaluate)
       @class.expects(:ensure_in_catalog).returns(@resource)
       @scope.stubs(:class_scope).with(@class)
 
       @compiler.evaluate_classes(%w{myclass}, @scope, false)
     end
 
     it "should skip classes that have already been evaluated" do
       @compiler.catalog.stubs(:tag)
 
       @scope.stubs(:class_scope).with(@class).returns(@scope)
 
       @compiler.expects(:add_resource).never
 
       @resource.expects(:evaluate).never
 
       Puppet::Parser::Resource.expects(:new).never
       @compiler.evaluate_classes(%w{myclass}, @scope, false)
     end
 
     it "should skip classes previously evaluated with different capitalization" do
       @compiler.catalog.stubs(:tag)
-      @scope.stubs(:find_hostclass).with("MyClass").returns(@class)
+      @scope.stubs(:find_hostclass).with("MyClass",{:assume_fqname => false}).returns(@class)
       @scope.stubs(:class_scope).with(@class).returns(@scope)
       @compiler.expects(:add_resource).never
       @resource.expects(:evaluate).never
       Puppet::Parser::Resource.expects(:new).never
       @compiler.evaluate_classes(%w{MyClass}, @scope, false)
     end
   end
 
   describe "when evaluating AST nodes with no AST nodes present" do
 
     it "should do nothing" do
       @compiler.expects(:ast_nodes?).returns(false)
       @compiler.known_resource_types.expects(:nodes).never
       Puppet::Parser::Resource.expects(:new).never
 
       @compiler.send(:evaluate_ast_node)
     end
   end
 
   describe "when evaluating AST nodes with AST nodes present" do
 
     before do
       @compiler.known_resource_types.stubs(:nodes?).returns true
 
       # Set some names for our test
       @node.stubs(:names).returns(%w{a b c})
       @compiler.known_resource_types.stubs(:node).with("a").returns(nil)
       @compiler.known_resource_types.stubs(:node).with("b").returns(nil)
       @compiler.known_resource_types.stubs(:node).with("c").returns(nil)
 
       # It should check this last, of course.
       @compiler.known_resource_types.stubs(:node).with("default").returns(nil)
     end
 
     it "should fail if the named node cannot be found" do
       proc { @compiler.send(:evaluate_ast_node) }.should raise_error(Puppet::ParseError)
     end
 
     it "should evaluate the first node class matching the node name" do
       node_class = stub 'node', :name => "c", :evaluate_code => nil
       @compiler.known_resource_types.stubs(:node).with("c").returns(node_class)
 
       node_resource = stub 'node resource', :ref => "Node[c]", :evaluate => nil, :type => "node"
       node_class.expects(:ensure_in_catalog).returns(node_resource)
 
       @compiler.compile
     end
 
     it "should match the default node if no matching node can be found" do
       node_class = stub 'node', :name => "default", :evaluate_code => nil
       @compiler.known_resource_types.stubs(:node).with("default").returns(node_class)
 
       node_resource = stub 'node resource', :ref => "Node[default]", :evaluate => nil, :type => "node"
       node_class.expects(:ensure_in_catalog).returns(node_resource)
 
       @compiler.compile
     end
 
     it "should evaluate the node resource immediately rather than using lazy evaluation" do
       node_class = stub 'node', :name => "c"
       @compiler.known_resource_types.stubs(:node).with("c").returns(node_class)
 
       node_resource = stub 'node resource', :ref => "Node[c]", :type => "node"
       node_class.expects(:ensure_in_catalog).returns(node_resource)
 
       node_resource.expects(:evaluate)
 
       @compiler.send(:evaluate_ast_node)
     end
   end
 
   describe "when evaluating node classes" do
     include PuppetSpec::Compiler
 
     describe "when provided classes in array format" do
       let(:node) { Puppet::Node.new('someone', :classes => ['something']) }
 
       describe "when the class exists" do
         it "should succeed if the class is already included" do
           manifest = <<-MANIFEST
           class something {}
           include something
           MANIFEST
 
           catalog = compile_to_catalog(manifest, node)
 
           catalog.resource('Class', 'Something').should_not be_nil
         end
 
         it "should evaluate the class without parameters if it's not already included" do
           manifest = "class something {}"
 
           catalog = compile_to_catalog(manifest, node)
 
           catalog.resource('Class', 'Something').should_not be_nil
         end
       end
 
       it "should fail if the class doesn't exist" do
         expect { compile_to_catalog('', node) }.to raise_error(Puppet::Error, /Could not find class something/)
       end
     end
 
     describe "when provided classes in hash format" do
       describe "for classes without parameters" do
         let(:node) { Puppet::Node.new('someone', :classes => {'something' => {}}) }
 
         describe "when the class exists" do
           it "should succeed if the class is already included" do
             manifest = <<-MANIFEST
             class something {}
             include something
             MANIFEST
 
             catalog = compile_to_catalog(manifest, node)
 
             catalog.resource('Class', 'Something').should_not be_nil
           end
 
           it "should evaluate the class if it's not already included" do
             manifest = <<-MANIFEST
             class something {}
             MANIFEST
 
             catalog = compile_to_catalog(manifest, node)
 
             catalog.resource('Class', 'Something').should_not be_nil
           end
         end
 
         it "should fail if the class doesn't exist" do
           expect { compile_to_catalog('', node) }.to raise_error(Puppet::Error, /Could not find class something/)
         end
       end
 
       describe "for classes with parameters" do
         let(:node) { Puppet::Node.new('someone', :classes => {'something' => {'configuron' => 'defrabulated'}}) }
 
         describe "when the class exists" do
           it "should fail if the class is already included" do
             manifest = <<-MANIFEST
             class something($configuron=frabulated) {}
             include something
             MANIFEST
 
             expect { compile_to_catalog(manifest, node) }.to raise_error(Puppet::Error, /Class\[Something\] is already declared/)
           end
 
           it "should evaluate the class if it's not already included" do
             manifest = <<-MANIFEST
             class something($configuron=frabulated) {}
             MANIFEST
 
             catalog = compile_to_catalog(manifest, node)
 
             resource = catalog.resource('Class', 'Something')
             resource['configuron'].should == 'defrabulated'
           end
         end
 
         it "should fail if the class doesn't exist" do
           expect { compile_to_catalog('', node) }.to raise_error(Puppet::Error, /Could not find class something/)
         end
 
         it 'evaluates classes declared with parameters before unparameterized classes' do
           node = Puppet::Node.new('someone', :classes => { 'app::web' => {}, 'app' => { 'port' => 8080 } })
           manifest = <<-MANIFEST
           class app($port = 80) { }
 
           class app::web($port = $app::port) inherits app {
             notify { expected: message => "$port" }
           }
           MANIFEST
 
           catalog = compile_to_catalog(manifest, node)
 
           expect(catalog).to have_resource("Class[App]").with_parameter(:port, 8080)
           expect(catalog).to have_resource("Class[App::Web]")
           expect(catalog).to have_resource("Notify[expected]").with_parameter(:message, "8080")
         end
       end
     end
   end
 
   describe "when managing resource overrides" do
 
     before do
       @override = stub 'override', :ref => "File[/foo]", :type => "my"
       @resource = resource(:file, "/foo")
     end
 
     it "should be able to store overrides" do
       lambda { @compiler.add_override(@override) }.should_not raise_error
     end
 
     it "should apply overrides to the appropriate resources" do
       @compiler.add_resource(@scope, @resource)
       @resource.expects(:merge).with(@override)
 
       @compiler.add_override(@override)
 
       @compiler.compile
     end
 
     it "should accept overrides before the related resource has been created" do
       @resource.expects(:merge).with(@override)
 
       # First store the override
       @compiler.add_override(@override)
 
       # Then the resource
       @compiler.add_resource(@scope, @resource)
 
       # And compile, so they get resolved
       @compiler.compile
     end
 
     it "should fail if the compile is finished and resource overrides have not been applied" do
       @compiler.add_override(@override)
 
       lambda { @compiler.compile }.should raise_error Puppet::ParseError, 'Could not find resource(s) File[/foo] for overriding'
     end
   end
 end
diff --git a/spec/unit/parser/scope_spec.rb b/spec/unit/parser/scope_spec.rb
index 6f90a3809..8d1e62429 100755
--- a/spec/unit/parser/scope_spec.rb
+++ b/spec/unit/parser/scope_spec.rb
@@ -1,649 +1,661 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/compiler'
 require 'puppet_spec/scope'
 
 describe Puppet::Parser::Scope do
   include PuppetSpec::Scope
 
   before :each do
     @scope = Puppet::Parser::Scope.new(
       Puppet::Parser::Compiler.new(Puppet::Node.new("foo"))
     )
     @scope.source = Puppet::Resource::Type.new(:node, :foo)
     @topscope = @scope.compiler.topscope
     @scope.parent = @topscope
   end
 
   describe "create_test_scope_for_node" do
     let(:node_name) { "node_name_foo" }
     let(:scope) { create_test_scope_for_node(node_name) }
 
     it "should be a kind of Scope" do
       scope.should be_a_kind_of(Puppet::Parser::Scope)
     end
     it "should set the source to a node resource" do
       scope.source.should be_a_kind_of(Puppet::Resource::Type)
     end
     it "should have a compiler" do
       scope.compiler.should be_a_kind_of(Puppet::Parser::Compiler)
     end
     it "should set the parent to the compiler topscope" do
       scope.parent.should be(scope.compiler.topscope)
     end
   end
 
   it "should return a scope for use in a test harness" do
     create_test_scope_for_node("node_name_foo").should be_a_kind_of(Puppet::Parser::Scope)
   end
 
   it "should be able to retrieve class scopes by name" do
     @scope.class_set "myname", "myscope"
     @scope.class_scope("myname").should == "myscope"
   end
 
   it "should be able to retrieve class scopes by object" do
     klass = mock 'ast_class'
     klass.expects(:name).returns("myname")
     @scope.class_set "myname", "myscope"
     @scope.class_scope(klass).should == "myscope"
   end
 
   it "should be able to retrieve its parent module name from the source of its parent type" do
     @topscope.source = Puppet::Resource::Type.new(:hostclass, :foo, :module_name => "foo")
 
     @scope.parent_module_name.should == "foo"
   end
 
   it "should return a nil parent module name if it has no parent" do
     @topscope.parent_module_name.should be_nil
   end
 
   it "should return a nil parent module name if its parent has no source" do
     @scope.parent_module_name.should be_nil
   end
 
   it "should get its environment from its compiler" do
     env = Puppet::Node::Environment.create(:testing, [])
     compiler = stub 'compiler', :environment => env, :is_a? => true
     scope = Puppet::Parser::Scope.new(compiler)
     scope.environment.should equal(env)
   end
 
   it "should fail if no compiler is supplied" do
     expect {
       Puppet::Parser::Scope.new
     }.to raise_error(ArgumentError, /wrong number of arguments/)
   end
 
   it "should fail if something that isn't a compiler is supplied" do
     expect {
       Puppet::Parser::Scope.new(:compiler => true)
     }.to raise_error(Puppet::DevError, /you must pass a compiler instance/)
   end
 
   it "should use the resource type collection helper to find its known resource types" do
     Puppet::Parser::Scope.ancestors.should include(Puppet::Resource::TypeCollectionHelper)
   end
 
   describe "when custom functions are called" do
     let(:env) { Puppet::Node::Environment.create(:testing, []) }
     let(:compiler) { Puppet::Parser::Compiler.new(Puppet::Node.new('foo', :environment => env)) }
     let(:scope) { Puppet::Parser::Scope.new(compiler) }
 
     it "calls methods prefixed with function_ as custom functions" do
       scope.function_sprintf(["%b", 123]).should == "1111011"
     end
 
     it "raises an error when arguments are not passed in an Array" do
       expect do
         scope.function_sprintf("%b", 123)
       end.to raise_error ArgumentError, /custom functions must be called with a single array that contains the arguments/
     end
 
     it "raises an error on subsequent calls when arguments are not passed in an Array" do
       scope.function_sprintf(["first call"])
 
       expect do
         scope.function_sprintf("%b", 123)
       end.to raise_error ArgumentError, /custom functions must be called with a single array that contains the arguments/
     end
 
     it "raises NoMethodError when the not prefixed" do
       expect { scope.sprintf(["%b", 123]) }.to raise_error(NoMethodError)
     end
 
     it "raises NoMethodError when prefixed with function_ but it doesn't exist" do
       expect { scope.function_fake_bs(['cows']) }.to raise_error(NoMethodError)
     end
   end
 
   describe "when initializing" do
     it "should extend itself with its environment's Functions module as well as the default" do
       env = Puppet::Node::Environment.create(:myenv, [])
       root = Puppet.lookup(:root_environment)
       compiler = stub 'compiler', :environment => env, :is_a? => true
 
       scope = Puppet::Parser::Scope.new(compiler)
       scope.singleton_class.ancestors.should be_include(Puppet::Parser::Functions.environment_module(env))
       scope.singleton_class.ancestors.should be_include(Puppet::Parser::Functions.environment_module(root))
     end
 
     it "should extend itself with the default Functions module if its environment is the default" do
       root     = Puppet.lookup(:root_environment)
       node     = Puppet::Node.new('localhost')
       compiler = Puppet::Parser::Compiler.new(node)
       scope    = Puppet::Parser::Scope.new(compiler)
       scope.singleton_class.ancestors.should be_include(Puppet::Parser::Functions.environment_module(root))
     end
   end
 
   describe "when looking up a variable" do
     it "should support :lookupvar and :setvar for backward compatibility" do
       @scope.setvar("var", "yep")
       @scope.lookupvar("var").should == "yep"
     end
 
     it "should fail if invoked with a non-string name" do
       expect { @scope[:foo] }.to raise_error(Puppet::ParseError, /Scope variable name .* not a string/)
       expect { @scope[:foo] = 12 }.to raise_error(Puppet::ParseError, /Scope variable name .* not a string/)
     end
 
     it "should return nil for unset variables" do
       @scope["var"].should be_nil
     end
 
     it "should be able to look up values" do
       @scope["var"] = "yep"
       @scope["var"].should == "yep"
     end
 
     it "should be able to look up hashes" do
       @scope["var"] = {"a" => "b"}
       @scope["var"].should == {"a" => "b"}
     end
 
     it "should be able to look up variables in parent scopes" do
       @topscope["var"] = "parentval"
       @scope["var"].should == "parentval"
     end
 
     it "should prefer its own values to parent values" do
       @topscope["var"] = "parentval"
       @scope["var"] = "childval"
       @scope["var"].should == "childval"
     end
 
     it "should be able to detect when variables are set" do
       @scope["var"] = "childval"
       @scope.should be_include("var")
     end
 
     it "does not allow changing a set value" do
       @scope["var"] = "childval"
       expect {
         @scope["var"] = "change"
       }.to raise_error(Puppet::Error, "Cannot reassign variable var")
     end
 
     it "should be able to detect when variables are not set" do
       @scope.should_not be_include("var")
     end
 
     describe "and the variable is qualified" do
       before :each do
         @known_resource_types = @scope.known_resource_types
 
         node      = Puppet::Node.new('localhost')
         @compiler = Puppet::Parser::Compiler.new(node)
       end
 
       def newclass(name)
         @known_resource_types.add Puppet::Resource::Type.new(:hostclass, name)
       end
 
       def create_class_scope(name)
         klass = newclass(name)
 
         catalog = Puppet::Resource::Catalog.new
         catalog.add_resource(Puppet::Parser::Resource.new("stage", :main, :scope => Puppet::Parser::Scope.new(@compiler)))
 
         Puppet::Parser::Resource.new("class", name, :scope => @scope, :source => mock('source'), :catalog => catalog).evaluate
 
         @scope.class_scope(klass)
       end
 
       it "should be able to look up explicitly fully qualified variables from main" do
         Puppet.expects(:deprecation_warning).never
         other_scope = create_class_scope("")
 
         other_scope["othervar"] = "otherval"
 
         @scope["::othervar"].should == "otherval"
       end
 
       it "should be able to look up explicitly fully qualified variables from other scopes" do
         Puppet.expects(:deprecation_warning).never
         other_scope = create_class_scope("other")
 
         other_scope["var"] = "otherval"
 
         @scope["::other::var"].should == "otherval"
       end
 
       it "should be able to look up deeply qualified variables" do
         Puppet.expects(:deprecation_warning).never
         other_scope = create_class_scope("other::deep::klass")
 
         other_scope["var"] = "otherval"
 
         @scope["other::deep::klass::var"].should == "otherval"
       end
 
       it "should return nil for qualified variables that cannot be found in other classes" do
         other_scope = create_class_scope("other::deep::klass")
 
         @scope["other::deep::klass::var"].should be_nil
       end
 
       it "should warn and return nil for qualified variables whose classes have not been evaluated" do
         klass = newclass("other::deep::klass")
         @scope.expects(:warning)
         @scope["other::deep::klass::var"].should be_nil
       end
 
       it "should warn and return nil for qualified variables whose classes do not exist" do
         @scope.expects(:warning)
         @scope["other::deep::klass::var"].should be_nil
       end
 
       it "should return nil when asked for a non-string qualified variable from a class that does not exist" do
         @scope.stubs(:warning)
         @scope["other::deep::klass::var"].should be_nil
       end
 
       it "should return nil when asked for a non-string qualified variable from a class that has not been evaluated" do
         @scope.stubs(:warning)
         klass = newclass("other::deep::klass")
         @scope["other::deep::klass::var"].should be_nil
       end
     end
 
     context "and strict_variables is true" do
       before(:each) do
         Puppet[:strict_variables] = true
       end
 
       it "should throw a symbol when unknown variable is looked up" do
         expect { @scope['john_doe'] }.to throw_symbol(:undefined_variable)
       end
 
       it "should throw a symbol when unknown qualified variable is looked up" do
         expect { @scope['nowhere::john_doe'] }.to throw_symbol(:undefined_variable)
       end
     end
   end
 
   describe "when variables are set with append=true" do
     it "should raise error if the variable is already defined in this scope" do
       @scope.setvar("var", "1", :append => false)
       expect {
         @scope.setvar("var", "1", :append => true)
       }.to raise_error(
         Puppet::ParseError,
         "Cannot append, variable var is defined in this scope"
       )
     end
 
     it "should lookup current variable value" do
       @scope.expects(:[]).with("var").returns("2")
       @scope.setvar("var", "1", :append => true)
     end
 
     it "should store the concatenated string '42'" do
       @topscope.setvar("var", "4", :append => false)
       @scope.setvar("var", "2", :append => true)
       @scope["var"].should == "42"
     end
 
     it "should store the concatenated array [4,2]" do
       @topscope.setvar("var", [4], :append => false)
       @scope.setvar("var", [2], :append => true)
       @scope["var"].should == [4,2]
     end
 
     it "should store the merged hash {a => b, c => d}" do
       @topscope.setvar("var", {"a" => "b"}, :append => false)
       @scope.setvar("var", {"c" => "d"}, :append => true)
       @scope["var"].should == {"a" => "b", "c" => "d"}
     end
 
     it "should raise an error when appending a hash with something other than another hash" do
       @topscope.setvar("var", {"a" => "b"}, :append => false)
 
       expect {
         @scope.setvar("var", "not a hash", :append => true)
       }.to raise_error(
         ArgumentError,
         "Trying to append to a hash with something which is not a hash is unsupported"
       )
     end
   end
 
   describe "when calling number?" do
     it "should return nil if called with anything not a number" do
       Puppet::Parser::Scope.number?([2]).should be_nil
     end
 
     it "should return a Fixnum for a Fixnum" do
       Puppet::Parser::Scope.number?(2).should be_an_instance_of(Fixnum)
     end
 
     it "should return a Float for a Float" do
       Puppet::Parser::Scope.number?(2.34).should be_an_instance_of(Float)
     end
 
     it "should return 234 for '234'" do
       Puppet::Parser::Scope.number?("234").should == 234
     end
 
     it "should return nil for 'not a number'" do
       Puppet::Parser::Scope.number?("not a number").should be_nil
     end
 
     it "should return 23.4 for '23.4'" do
       Puppet::Parser::Scope.number?("23.4").should == 23.4
     end
 
     it "should return 23.4e13 for '23.4e13'" do
       Puppet::Parser::Scope.number?("23.4e13").should == 23.4e13
     end
 
     it "should understand negative numbers" do
       Puppet::Parser::Scope.number?("-234").should == -234
     end
 
     it "should know how to convert exponential float numbers ala '23e13'" do
       Puppet::Parser::Scope.number?("23e13").should == 23e13
     end
 
     it "should understand hexadecimal numbers" do
       Puppet::Parser::Scope.number?("0x234").should == 0x234
     end
 
     it "should understand octal numbers" do
       Puppet::Parser::Scope.number?("0755").should == 0755
     end
 
     it "should return nil on malformed integers" do
       Puppet::Parser::Scope.number?("0.24.5").should be_nil
     end
 
     it "should convert strings with leading 0 to integer if they are not octal" do
       Puppet::Parser::Scope.number?("0788").should == 788
     end
 
     it "should convert strings of negative integers" do
       Puppet::Parser::Scope.number?("-0788").should == -788
     end
 
     it "should return nil on malformed hexadecimal numbers" do
       Puppet::Parser::Scope.number?("0x89g").should be_nil
     end
   end
 
   describe "when using ephemeral variables" do
     it "should store the variable value" do
 #      @scope.setvar("1", :value, :ephemeral => true)
       @scope.set_match_data({1 => :value})
       @scope["1"].should == :value
     end
 
     it "should remove the variable value when unset_ephemeral_var(:all) is called" do
 #      @scope.setvar("1", :value, :ephemeral => true)
       @scope.set_match_data({1 => :value})
       @scope.stubs(:parent).returns(nil)
 
       @scope.unset_ephemeral_var(:all)
 
       @scope["1"].should be_nil
     end
 
     it "should not remove classic variables when unset_ephemeral_var(:all) is called" do
       @scope['myvar'] = :value1
       @scope.set_match_data({1 => :value2})
       @scope.stubs(:parent).returns(nil)
 
       @scope.unset_ephemeral_var(:all)
 
       @scope["myvar"].should == :value1
     end
 
     it "should raise an error when setting numerical variable" do
       expect {
         @scope.setvar("1", :value3, :ephemeral => true)
       }.to raise_error(Puppet::ParseError, /Cannot assign to a numeric match result variable/)
     end
 
     describe "with more than one level" do
       it "should prefer latest ephemeral scopes" do
         @scope.set_match_data({0 => :earliest})
         @scope.new_ephemeral
         @scope.set_match_data({0 => :latest})
         @scope["0"].should == :latest
       end
 
       it "should be able to report the current level" do
         @scope.ephemeral_level.should == 1
         @scope.new_ephemeral
         @scope.ephemeral_level.should == 2
       end
 
       it "should not check presence of an ephemeral variable across multiple levels" do
         # This test was testing that scope actuallys screwed up - making values from earlier matches show as if they
         # where true for latest match - insanity !
         @scope.new_ephemeral
         @scope.set_match_data({1 => :value1})
         @scope.new_ephemeral
         @scope.set_match_data({0 => :value2})
         @scope.new_ephemeral
         @scope.include?("1").should be_false
       end
 
       it "should return false when an ephemeral variable doesn't exist in any ephemeral scope" do
         @scope.new_ephemeral
         @scope.set_match_data({1 => :value1})
         @scope.new_ephemeral
         @scope.set_match_data({0 => :value2})
         @scope.new_ephemeral
         @scope.include?("2").should be_false
       end
 
       it "should not get ephemeral values from earlier scope when not in later" do
         @scope.set_match_data({1 => :value1})
         @scope.new_ephemeral
         @scope.set_match_data({0 => :value2})
         @scope.include?("1").should be_false
       end
 
       describe "when calling unset_ephemeral_var with a level" do
         it "should remove ephemeral scopes up to this level" do
           @scope.set_match_data({1 => :value1})
           @scope.new_ephemeral
           @scope.set_match_data({1 => :value2})
           level = @scope.ephemeral_level()
           @scope.new_ephemeral
           @scope.set_match_data({1 => :value3})
 
           @scope.unset_ephemeral_var(level)
 
           @scope["1"].should == :value2
         end
       end
     end
   end
 
   context "when using ephemeral as local scope" do
     it "should store all variables in local scope" do
       @scope.new_ephemeral true
       @scope.setvar("apple", :fruit)
       @scope["apple"].should == :fruit
     end
 
     it "should remove all local scope variables on unset" do
       @scope.new_ephemeral true
       @scope.setvar("apple", :fruit)
       @scope["apple"].should == :fruit
       @scope.unset_ephemeral_var
       @scope["apple"].should == nil
     end
     it "should be created from a hash" do
       @scope.ephemeral_from({ "apple" => :fruit, "strawberry" => :berry})
       @scope["apple"].should == :fruit
       @scope["strawberry"].should == :berry
     end
   end
 
   describe "when setting ephemeral vars from matches" do
     before :each do
       @match = stub 'match', :is_a? => true
       @match.stubs(:[]).with(0).returns("this is a string")
       @match.stubs(:captures).returns([])
       @scope.stubs(:setvar)
     end
 
     it "should accept only MatchData" do
       expect {
         @scope.ephemeral_from("match")
       }.to raise_error(ArgumentError, /Invalid regex match data/)
     end
 
     it "should set $0 with the full match" do
       # This is an internal impl detail test
       @scope.expects(:new_match_scope).with { |*arg| arg[0][0] == "this is a string" }
       @scope.ephemeral_from(@match)
     end
 
     it "should set every capture as ephemeral var" do
       # This is an internal impl detail test
       @match.stubs(:[]).with(1).returns(:capture1)
       @match.stubs(:[]).with(2).returns(:capture2)
       @scope.expects(:new_match_scope).with { |*arg| arg[0][1] == :capture1 && arg[0][2] == :capture2 }
 
       @scope.ephemeral_from(@match)
     end
 
     it "should shadow previous match variables" do
       # This is an internal impl detail test
       @match.stubs(:[]).with(1).returns(:capture1)
       @match.stubs(:[]).with(2).returns(:capture2)
 
       @match2 = stub 'match', :is_a? => true
       @match2.stubs(:[]).with(1).returns(:capture2_1)
       @match2.stubs(:[]).with(2).returns(nil)
       @scope.ephemeral_from(@match)
       @scope.ephemeral_from(@match2)
       @scope.lookupvar('2').should == nil
     end
 
     it "should create a new ephemeral level" do
       level_before = @scope.ephemeral_level
       @scope.ephemeral_from(@match)
       expect(level_before < @scope.ephemeral_level)
     end
   end
 
+  it "should use its namespaces to find hostclasses" do
+    klass = @scope.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "a::b::c")
+    @scope.add_namespace "a::b"
+    @scope.find_hostclass("c").should equal(klass)
+  end
+
+  it "should use its namespaces to find definitions" do
+    define = @scope.known_resource_types.add Puppet::Resource::Type.new(:definition, "a::b::c")
+    @scope.add_namespace "a::b"
+    @scope.find_definition("c").should equal(define)
+  end
+
   describe "when managing defaults" do
     it "should be able to set and lookup defaults" do
       param = Puppet::Parser::Resource::Param.new(:name => :myparam, :value => "myvalue", :source => stub("source"))
       @scope.define_settings(:mytype, param)
       @scope.lookupdefaults(:mytype).should == {:myparam => param}
     end
 
     it "should fail if a default is already defined and a new default is being defined" do
       param = Puppet::Parser::Resource::Param.new(:name => :myparam, :value => "myvalue", :source => stub("source"))
       @scope.define_settings(:mytype, param)
       expect {
         @scope.define_settings(:mytype, param)
       }.to raise_error(Puppet::ParseError, /Default already defined .* cannot redefine/)
     end
 
     it "should return multiple defaults at once" do
       param1 = Puppet::Parser::Resource::Param.new(:name => :myparam, :value => "myvalue", :source => stub("source"))
       @scope.define_settings(:mytype, param1)
       param2 = Puppet::Parser::Resource::Param.new(:name => :other, :value => "myvalue", :source => stub("source"))
       @scope.define_settings(:mytype, param2)
 
       @scope.lookupdefaults(:mytype).should == {:myparam => param1, :other => param2}
     end
 
     it "should look up defaults defined in parent scopes" do
       param1 = Puppet::Parser::Resource::Param.new(:name => :myparam, :value => "myvalue", :source => stub("source"))
       @scope.define_settings(:mytype, param1)
 
       child_scope = @scope.newscope
       param2 = Puppet::Parser::Resource::Param.new(:name => :other, :value => "myvalue", :source => stub("source"))
       child_scope.define_settings(:mytype, param2)
 
       child_scope.lookupdefaults(:mytype).should == {:myparam => param1, :other => param2}
     end
   end
 
   context "#true?" do
     { "a string" => true,
       "true"     => true,
       "false"    => true,
       true       => true,
       ""         => false,
       :undef     => false,
       nil        => false
     }.each do |input, output|
       it "should treat #{input.inspect} as #{output}" do
         Puppet::Parser::Scope.true?(input).should == output
       end
     end
   end
 
   context "when producing a hash of all variables (as used in templates)" do
     it "should contain all defined variables in the scope" do
       @scope.setvar("orange", :tangerine)
       @scope.setvar("pear", :green)
       @scope.to_hash.should == {'orange' => :tangerine, 'pear' => :green }
     end
 
     it "should contain variables in all local scopes (#21508)" do
       @scope.new_ephemeral true
       @scope.setvar("orange", :tangerine)
       @scope.setvar("pear", :green)
       @scope.new_ephemeral true
       @scope.setvar("apple", :red)
       @scope.to_hash.should == {'orange' => :tangerine, 'pear' => :green, 'apple' => :red }
     end
 
     it "should contain all defined variables in the scope and all local scopes" do
       @scope.setvar("orange", :tangerine)
       @scope.setvar("pear", :green)
       @scope.new_ephemeral true
       @scope.setvar("apple", :red)
       @scope.to_hash.should == {'orange' => :tangerine, 'pear' => :green, 'apple' => :red }
     end
 
     it "should not contain varaibles in match scopes (non local emphemeral)" do
       @scope.new_ephemeral true
       @scope.setvar("orange", :tangerine)
       @scope.setvar("pear", :green)
       @scope.ephemeral_from(/(f)(o)(o)/.match('foo'))
       @scope.to_hash.should == {'orange' => :tangerine, 'pear' => :green }
     end
 
     it "should delete values that are :undef in inner scope" do
       @scope.new_ephemeral true
       @scope.setvar("orange", :tangerine)
       @scope.setvar("pear", :green)
       @scope.new_ephemeral true
       @scope.setvar("apple", :red)
       @scope.setvar("orange", :undef)
       @scope.to_hash.should == {'pear' => :green, 'apple' => :red }
     end
   end
 end
diff --git a/spec/unit/parser/type_loader_spec.rb b/spec/unit/parser/type_loader_spec.rb
index d2de50548..8c9128618 100755
--- a/spec/unit/parser/type_loader_spec.rb
+++ b/spec/unit/parser/type_loader_spec.rb
@@ -1,204 +1,204 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/parser/type_loader'
 require 'puppet/parser/parser_factory'
 require 'puppet_spec/modules'
 require 'puppet_spec/files'
 
 describe Puppet::Parser::TypeLoader do
   include PuppetSpec::Modules
   include PuppetSpec::Files
 
   let(:empty_hostclass) { Puppet::Parser::AST::Hostclass.new('') }
   let(:loader) { Puppet::Parser::TypeLoader.new(:myenv) }
   let(:my_env) { Puppet::Node::Environment.create(:myenv, []) }
 
   around do |example|
     envs = Puppet::Environments::Static.new(my_env)
 
     Puppet.override(:environments => envs) do
       example.run
     end
   end
 
   it "should support an environment" do
     loader = Puppet::Parser::TypeLoader.new(:myenv)
     loader.environment.name.should == :myenv
   end
 
   it "should delegate its known resource types to its environment" do
     loader.known_resource_types.should be_instance_of(Puppet::Resource::TypeCollection)
   end
 
   describe "when loading names from namespaces" do
     it "should do nothing if the name to import is an empty string" do
       loader.try_load_fqname(:hostclass, "").should be_nil
     end
 
     it "should attempt to import each generated name" do
       loader.expects(:import_from_modules).with("foo/bar").returns([])
       loader.expects(:import_from_modules).with("foo").returns([])
       loader.try_load_fqname(:hostclass, "foo::bar")
     end
 
     it "should attempt to load each possible name going from most to least specific" do
       path_order = sequence('path')
       ['foo/bar/baz', 'foo/bar', 'foo'].each do |path|
         Puppet::Parser::Files.expects(:find_manifests_in_modules).with(path, anything).returns([nil, []]).in_sequence(path_order)
       end
 
       loader.try_load_fqname(:hostclass, 'foo::bar::baz')
     end
   end
 
   describe "when importing" do
     let(:stub_parser) { stub 'Parser', :file= => nil, :parse => empty_hostclass }
 
     before(:each) do
       Puppet::Parser::ParserFactory.stubs(:parser).with(anything).returns(stub_parser)
     end
 
     it "should find all manifests matching the file or pattern" do
       Puppet::Parser::Files.expects(:find_manifests_in_modules).with("myfile", anything).returns ["modname", %w{one}]
       loader.import("myfile", "/path")
     end
 
     it "should pass the environment when looking for files" do
       Puppet::Parser::Files.expects(:find_manifests_in_modules).with(anything, loader.environment).returns ["modname", %w{one}]
       loader.import("myfile", "/path")
     end
 
     it "should fail if no files are found" do
       Puppet::Parser::Files.expects(:find_manifests_in_modules).returns [nil, []]
-      lambda { loader.import("myfile", "/path") }.should raise_error(/No file\(s\) found for import/)
+      lambda { loader.import("myfile", "/path") }.should raise_error(Puppet::ImportError)
     end
 
     it "should parse each found file" do
       Puppet::Parser::Files.expects(:find_manifests_in_modules).returns ["modname", [make_absolute("/one")]]
       loader.expects(:parse_file).with(make_absolute("/one")).returns(Puppet::Parser::AST::Hostclass.new(''))
       loader.import("myfile", "/path")
     end
 
     it "should not attempt to import files that have already been imported" do
       loader = Puppet::Parser::TypeLoader.new(:myenv)
 
       Puppet::Parser::Files.expects(:find_manifests_in_modules).twice.returns ["modname", %w{/one}]
       loader.import("myfile", "/path").should_not be_empty
 
       loader.import("myfile", "/path").should be_empty
     end
   end
 
   describe "when importing all" do
     let(:base) { tmpdir("base") }
     let(:modulebase1) { File.join(base, "first") }
     let(:modulebase2) { File.join(base, "second") }
     let(:my_env) { Puppet::Node::Environment.create(:myenv, [modulebase1, modulebase2]) }
 
     before do
       # Create two module path directories
       FileUtils.mkdir_p(modulebase1)
       FileUtils.mkdir_p(modulebase2)
     end
 
     def mk_module(basedir, name)
       PuppetSpec::Modules.create(name, basedir)
     end
 
     # We have to pass the base path so that we can
     # write to modules that are in the second search path
     def mk_manifests(base, mod, files)
       files.collect do |file|
         name = mod.name + "::" + file.gsub("/", "::")
         path = File.join(base, mod.name, "manifests", file + ".pp")
         FileUtils.mkdir_p(File.split(path)[0])
 
         # write out the class
         File.open(path, "w") { |f| f.print "class #{name} {}" }
         name
       end
     end
 
     it "should load all puppet manifests from all modules in the specified environment" do
       module1 = mk_module(modulebase1, "one")
       module2 = mk_module(modulebase2, "two")
 
       mk_manifests(modulebase1, module1, %w{a b})
       mk_manifests(modulebase2, module2, %w{c d})
 
       loader.import_all
 
       loader.environment.known_resource_types.hostclass("one::a").should be_instance_of(Puppet::Resource::Type)
       loader.environment.known_resource_types.hostclass("one::b").should be_instance_of(Puppet::Resource::Type)
       loader.environment.known_resource_types.hostclass("two::c").should be_instance_of(Puppet::Resource::Type)
       loader.environment.known_resource_types.hostclass("two::d").should be_instance_of(Puppet::Resource::Type)
     end
 
     it "should not load manifests from duplicate modules later in the module path" do
       module1 = mk_module(modulebase1, "one")
 
       # duplicate
       module2 = mk_module(modulebase2, "one")
 
       mk_manifests(modulebase1, module1, %w{a})
       mk_manifests(modulebase2, module2, %w{c})
 
       loader.import_all
 
       loader.environment.known_resource_types.hostclass("one::c").should be_nil
     end
 
     it "should load manifests from subdirectories" do
       module1 = mk_module(modulebase1, "one")
 
       mk_manifests(modulebase1, module1, %w{a a/b a/b/c})
 
       loader.import_all
 
       loader.environment.known_resource_types.hostclass("one::a::b").should be_instance_of(Puppet::Resource::Type)
       loader.environment.known_resource_types.hostclass("one::a::b::c").should be_instance_of(Puppet::Resource::Type)
     end
 
     it "should skip modules that don't have manifests" do
       module1 = mk_module(modulebase1, "one")
       module2 = mk_module(modulebase2, "two")
       mk_manifests(modulebase2, module2, %w{c d})
 
       loader.import_all
 
       loader.environment.known_resource_types.hostclass("one::a").should be_nil
       loader.environment.known_resource_types.hostclass("two::c").should be_instance_of(Puppet::Resource::Type)
       loader.environment.known_resource_types.hostclass("two::d").should be_instance_of(Puppet::Resource::Type)
     end
   end
 
   describe "when parsing a file" do
     it "requests a new parser instance for each file" do
       parser = stub 'Parser', :file= => nil, :parse => empty_hostclass
 
       Puppet::Parser::ParserFactory.expects(:parser).twice.returns(parser)
 
       loader.parse_file("/my/file")
       loader.parse_file("/my/other_file")
     end
 
     it "assigns the parser its file and then parses" do
       parser = mock 'parser'
 
       Puppet::Parser::ParserFactory.expects(:parser).returns(parser)
       parser.expects(:file=).with("/my/file")
       parser.expects(:parse).returns(empty_hostclass)
 
       loader.parse_file("/my/file")
     end
   end
 
   it "should be able to add classes to the current resource type collection" do
     file = tmpfile("simple_file.pp")
     File.open(file, "w") { |f| f.puts "class foo {}" }
     loader.import(File.basename(file), File.dirname(file))
 
     loader.known_resource_types.hostclass("foo").should be_instance_of(Puppet::Resource::Type)
   end
 end
diff --git a/spec/unit/pops/evaluator/evaluator_rspec_helper.rb b/spec/unit/pops/evaluator/evaluator_rspec_helper.rb
index 80aadb700..eccf8aaca 100644
--- a/spec/unit/pops/evaluator/evaluator_rspec_helper.rb
+++ b/spec/unit/pops/evaluator/evaluator_rspec_helper.rb
@@ -1,71 +1,75 @@
 require 'puppet/pops'
 require 'puppet/pops/evaluator/evaluator_impl'
 
 require File.join(File.dirname(__FILE__), '/../factory_rspec_helper')
 
 module EvaluatorRspecHelper
   include FactoryRspecHelper
 
   # Evaluate a Factory wrapper round a model object in top scope + named scope
   # Optionally pass two or three model objects (typically blocks) to be executed
   # in top scope, named scope, and then top scope again. If a named_scope is used, it must
   # be preceded by the name of the scope.
   # The optional block is executed before the result of the last specified model object
   # is evaluated. This block gets the top scope as an argument. The intent is to pass
   # a block that asserts the state of the top scope after the operations.
   #
   def evaluate in_top_scope, scopename="x", in_named_scope = nil, in_top_scope_again = nil, &block
     node = Puppet::Node.new('localhost')
     compiler = Puppet::Parser::Compiler.new(node)
 
+    # Compiler must create the top scope
+#    compiler.send(:evaluate_main)
+
     # compiler creates the top scope if one is not present
     top_scope = compiler.topscope()
     # top_scope = Puppet::Parser::Scope.new(compiler)
 
     evaluator = Puppet::Pops::Evaluator::EvaluatorImpl.new
     result = evaluator.evaluate(in_top_scope.current, top_scope)
     if in_named_scope
-      other_scope = Puppet::Parser::Scope.new(compiler, :namespace => scopename)
+      other_scope = Puppet::Parser::Scope.new(compiler)
+      other_scope.add_namespace(scopename)
       result = evaluator.evaluate(in_named_scope.current, other_scope)
     end
     if in_top_scope_again
       result = evaluator.evaluate(in_top_scope_again.current, top_scope)
     end
     if block_given?
       block.call(top_scope)
     end
     result
   end
 
   # Evaluate a Factory wrapper round a model object in top scope + local scope
   # Optionally pass two or three model objects (typically blocks) to be executed
   # in top scope, local scope, and then top scope again
   # The optional block is executed before the result of the last specified model object
   # is evaluated. This block gets the top scope as an argument. The intent is to pass
   # a block that asserts the state of the top scope after the operations.
   #
   def evaluate_l in_top_scope, in_local_scope = nil, in_top_scope_again = nil, &block
     node = Puppet::Node.new('localhost')
     compiler = Puppet::Parser::Compiler.new(node)
 
     # compiler creates the top scope if one is not present
     top_scope = compiler.topscope()
 
     evaluator = Puppet::Pops::Evaluator::EvaluatorImpl.new
     result = evaluator.evaluate(in_top_scope.current, top_scope)
     if in_local_scope
       # This is really bad in 3.x scope
       elevel = top_scope.ephemeral_level
       top_scope.new_ephemeral(true)
       result = evaluator.evaluate(in_local_scope.current, top_scope)
       top_scope.unset_ephemeral_var(elevel)
     end
     if in_top_scope_again
       result = evaluator.evaluate(in_top_scope_again.current, top_scope)
     end
     if block_given?
       block.call(top_scope)
     end
     result
   end
 end
diff --git a/spec/unit/resource/type_collection_spec.rb b/spec/unit/resource/type_collection_spec.rb
index 9e81f275c..1d76cbfba 100755
--- a/spec/unit/resource/type_collection_spec.rb
+++ b/spec/unit/resource/type_collection_spec.rb
@@ -1,313 +1,374 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/resource/type_collection'
 require 'puppet/resource/type'
 
 describe Puppet::Resource::TypeCollection do
   include PuppetSpec::Files
 
   let(:environment) { Puppet::Node::Environment.create(:testing, []) }
 
   before do
     @instance = Puppet::Resource::Type.new(:hostclass, "foo")
     @code = Puppet::Resource::TypeCollection.new(environment)
   end
 
   it "should consider '<<' to be an alias to 'add' but should return self" do
     @code.expects(:add).with "foo"
     @code.expects(:add).with "bar"
     @code << "foo" << "bar"
   end
 
   it "should set itself as the code collection for added resource types" do
     node = Puppet::Resource::Type.new(:node, "foo")
 
     @code.add(node)
     @code.node("foo").should equal(node)
 
     node.resource_type_collection.should equal(@code)
   end
 
   it "should store node resource types as nodes" do
     node = Puppet::Resource::Type.new(:node, "foo")
 
     @code.add(node)
     @code.node("foo").should equal(node)
   end
 
   it "should fail if a duplicate node is added" do
     @code.add(Puppet::Resource::Type.new(:node, "foo"))
 
     expect do
       @code.add(Puppet::Resource::Type.new(:node, "foo"))
     end.to raise_error(Puppet::ParseError, /cannot redefine/)
   end
 
   it "should store hostclasses as hostclasses" do
     klass = Puppet::Resource::Type.new(:hostclass, "foo")
 
     @code.add(klass)
     @code.hostclass("foo").should equal(klass)
   end
 
   it "merge together hostclasses of the same name" do
     klass1 = Puppet::Resource::Type.new(:hostclass, "foo", :doc => "first")
     klass2 = Puppet::Resource::Type.new(:hostclass, "foo", :doc => "second")
 
     @code.add(klass1)
     @code.add(klass2)
 
     @code.hostclass("foo").doc.should == "firstsecond"
   end
 
   it "should store definitions as definitions" do
     define = Puppet::Resource::Type.new(:definition, "foo")
 
     @code.add(define)
     @code.definition("foo").should equal(define)
   end
 
   it "should fail if a duplicate definition is added" do
     @code.add(Puppet::Resource::Type.new(:definition, "foo"))
 
     expect do
       @code.add(Puppet::Resource::Type.new(:definition, "foo"))
     end.to raise_error(Puppet::ParseError, /cannot be redefined/)
   end
 
   it "should remove all nodes, classes, and definitions when cleared" do
     loader = Puppet::Resource::TypeCollection.new(environment)
     loader.add Puppet::Resource::Type.new(:hostclass, "class")
     loader.add Puppet::Resource::Type.new(:definition, "define")
     loader.add Puppet::Resource::Type.new(:node, "node")
 
     loader.clear
     loader.hostclass("class").should be_nil
     loader.definition("define").should be_nil
     loader.node("node").should be_nil
   end
 
+  describe "when resolving namespaces" do
+    [ ['',               '::foo', ['foo']],
+      ['a',              '::foo', ['foo']],
+      ['a::b',           '::foo', ['foo']],
+      [['a::b'],         '::foo', ['foo']],
+      [['a::b', 'c'],    '::foo', ['foo']],
+      [['A::B', 'C'],    '::Foo', ['foo']],
+      ['',               '',      ['']],
+      ['a',              '',      ['']],
+      ['a::b',           '',      ['']],
+      [['a::b'],         '',      ['']],
+      [['a::b', 'c'],    '',      ['']],
+      [['A::B', 'C'],    '',      ['']],
+      ['',               'foo',   ['foo']],
+      ['a',              'foo',   ['a::foo', 'foo']],
+      ['a::b',           'foo',   ['a::b::foo', 'a::foo', 'foo']],
+      ['A::B',           'Foo',   ['a::b::foo', 'a::foo', 'foo']],
+      [['a::b'],         'foo',   ['a::b::foo', 'a::foo', 'foo']],
+      [['a', 'b'],       'foo',   ['a::foo', 'foo', 'b::foo']],
+      [['a::b', 'c::d'], 'foo',   ['a::b::foo', 'a::foo', 'foo', 'c::d::foo', 'c::foo']],
+      [['a::b', 'a::c'], 'foo',   ['a::b::foo', 'a::foo', 'foo', 'a::c::foo']],
+    ].each do |namespaces, name, expected_result|
+      it "should resolve #{name.inspect} in namespaces #{namespaces.inspect} correctly" do
+        @code.instance_eval { resolve_namespaces(namespaces, name) }.should == expected_result
+      end
+    end
+  end
+
   describe "when looking up names" do
     before do
       @type = Puppet::Resource::Type.new(:hostclass, "ns::klass")
     end
 
+    it "should support looking up with multiple namespaces" do
+      @code.add @type
+      @code.find_hostclass(%w{boo baz ns}, "klass").should equal(@type)
+    end
+
     it "should not attempt to import anything when the type is already defined" do
       @code.add @type
       @code.loader.expects(:import).never
-      @code.find_hostclass("ns::klass").should equal(@type)
+      @code.find_hostclass(%w{ns}, "klass").should equal(@type)
     end
 
     describe "that need to be loaded" do
-      it "should use the loader to load the files" do
-        @code.loader.expects(:try_load_fqname).with(:hostclass, "klass")
-        @code.find_hostclass("klass")
-      end
       it "should use the loader to load the files" do
         @code.loader.expects(:try_load_fqname).with(:hostclass, "ns::klass")
-        @code.find_hostclass("ns::klass")
+        @code.loader.expects(:try_load_fqname).with(:hostclass, "klass")
+        @code.find_hostclass(["ns"], "klass")
       end
 
       it "should downcase the name and downcase and array-fy the namespaces before passing to the loader" do
         @code.loader.expects(:try_load_fqname).with(:hostclass, "ns::klass")
-        @code.find_hostclass("ns::klass")
+        @code.loader.expects(:try_load_fqname).with(:hostclass, "klass")
+        @code.find_hostclass("Ns", "Klass")
       end
 
       it "should use the class returned by the loader" do
         @code.loader.expects(:try_load_fqname).returns(:klass)
         @code.expects(:hostclass).with("ns::klass").returns(false)
-        @code.find_hostclass("ns::klass").should == :klass
+        @code.find_hostclass("ns", "klass").should == :klass
       end
 
       it "should return nil if the name isn't found" do
         @code.loader.stubs(:try_load_fqname).returns(nil)
-        @code.find_hostclass("Ns::Klass").should be_nil
+        @code.find_hostclass("Ns", "Klass").should be_nil
       end
 
       it "already-loaded names at broader scopes should not shadow autoloaded names" do
         @code.add Puppet::Resource::Type.new(:hostclass, "bar")
         @code.loader.expects(:try_load_fqname).with(:hostclass, "foo::bar").returns(:foobar)
-        @code.find_hostclass("foo::bar").should == :foobar
+        @code.find_hostclass("foo", "bar").should == :foobar
       end
 
-      context 'when debugging' do
-        # This test requires that debugging is on, it will otherwise not make a call to debug,
-        # which is the easiest way to detect that that a certain path has been taken.
-        before(:each) do
-          Puppet.debug = true
-        end
-
-        after (:each) do
-          Puppet.debug = false
-        end
+      it "should not try to autoload names that we couldn't autoload in a previous step if ignoremissingtypes is enabled" do
+        Puppet[:ignoremissingtypes] = true
+        @code.loader.expects(:try_load_fqname).with(:hostclass, "ns::klass").returns(nil)
+        @code.loader.expects(:try_load_fqname).with(:hostclass, "klass").returns(nil)
+        @code.find_hostclass("Ns", "Klass").should be_nil
 
-        it "should not try to autoload names that we couldn't autoload in a previous step if ignoremissingtypes is enabled" do
-          Puppet[:ignoremissingtypes] = true
-          @code.loader.expects(:try_load_fqname).with(:hostclass, "ns::klass").returns(nil)
-          @code.find_hostclass("ns::klass").should be_nil
-          Puppet.expects(:debug).at_least_once.with {|msg| msg =~ /Not attempting to load hostclass/}
-          @code.find_hostclass("ns::klass").should be_nil
-        end
+        Puppet.expects(:debug).at_least_once.with {|msg| msg =~ /Not attempting to load hostclass/}
+        @code.find_hostclass("Ns", "Klass").should be_nil
       end
     end
   end
 
   %w{hostclass node definition}.each do |data|
     describe "behavior of add for #{data}" do
 
       it "should return the added #{data}" do
         loader = Puppet::Resource::TypeCollection.new(environment)
         instance = Puppet::Resource::Type.new(data, "foo")
 
         loader.add(instance).should equal(instance)
       end
 
       it "should retrieve #{data} insensitive to case" do
         loader = Puppet::Resource::TypeCollection.new(environment)
         instance = Puppet::Resource::Type.new(data, "Bar")
 
         loader.add instance
 
         loader.send(data, "bAr").should equal(instance)
       end
 
       it "should return nil when asked for a #{data} that has not been added" do
         Puppet::Resource::TypeCollection.new(environment).send(data, "foo").should be_nil
       end
     end
   end
 
   describe "when finding a qualified instance" do
     it "should return any found instance if the instance name is fully qualified" do
       loader = Puppet::Resource::TypeCollection.new(environment)
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar")
       loader.add instance
-      loader.find_hostclass("::foo::bar").should equal(instance)
+      loader.find_hostclass("namespace", "::foo::bar").should equal(instance)
     end
 
     it "should return nil if the instance name is fully qualified and no such instance exists" do
       loader = Puppet::Resource::TypeCollection.new(environment)
-      loader.find_hostclass("::foo::bar").should be_nil
+      loader.find_hostclass("namespace", "::foo::bar").should be_nil
     end
 
     it "should be able to find classes in the base namespace" do
       loader = Puppet::Resource::TypeCollection.new(environment)
       instance = Puppet::Resource::Type.new(:hostclass, "foo")
       loader.add instance
-      loader.find_hostclass("foo").should equal(instance)
+      loader.find_hostclass("", "foo").should equal(instance)
+    end
+
+    it "should return the partially qualified object if it exists in a provided namespace" do
+      loader = Puppet::Resource::TypeCollection.new(environment)
+      instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
+      loader.add instance
+      loader.find_hostclass("foo", "bar::baz").should equal(instance)
+    end
+
+    it "should be able to find partially qualified objects in any of the provided namespaces" do
+      loader = Puppet::Resource::TypeCollection.new(environment)
+      instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
+      loader.add instance
+      loader.find_hostclass(["nons", "foo", "otherns"], "bar::baz").should equal(instance)
     end
 
     it "should return the unqualified object if it exists in a provided namespace" do
       loader = Puppet::Resource::TypeCollection.new(environment)
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar")
       loader.add instance
-      loader.find_hostclass("foo::bar").should equal(instance)
+      loader.find_hostclass("foo", "bar").should equal(instance)
+    end
+
+    it "should return the unqualified object if it exists in the parent namespace" do
+      loader = Puppet::Resource::TypeCollection.new(environment)
+      instance = Puppet::Resource::Type.new(:hostclass, "foo::bar")
+      loader.add instance
+      loader.find_hostclass("foo::bar::baz", "bar").should equal(instance)
+    end
+
+    it "should should return the partially qualified object if it exists in the parent namespace" do
+      loader = Puppet::Resource::TypeCollection.new(environment)
+      instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
+      loader.add instance
+      loader.find_hostclass("foo::bar", "bar::baz").should equal(instance)
+    end
+
+    it "should return the qualified object if it exists in the root namespace" do
+      loader = Puppet::Resource::TypeCollection.new(environment)
+      instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
+      loader.add instance
+      loader.find_hostclass("foo::bar", "foo::bar::baz").should equal(instance)
     end
 
     it "should return nil if the object cannot be found" do
       loader = Puppet::Resource::TypeCollection.new(environment)
       instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
       loader.add instance
-      loader.find_hostclass("foo::bar::eh").should be_nil
+      loader.find_hostclass("foo::bar", "eh").should be_nil
     end
 
     describe "when topscope has a class that has the same name as a local class" do
       before do
         @loader = Puppet::Resource::TypeCollection.new(environment)
         [ "foo::bar", "bar" ].each do |name|
           @loader.add Puppet::Resource::Type.new(:hostclass, name)
         end
       end
 
-      it "looks up the given name, no more, no less" do
-        @loader.find_hostclass("bar").name.should == 'bar'
-        @loader.find_hostclass("::bar").name.should == 'bar'
-        @loader.find_hostclass("foo::bar").name.should == 'foo::bar'
-        @loader.find_hostclass("::foo::bar").name.should == 'foo::bar'
+      it "should favor the local class, if the name is unqualified" do
+        @loader.find_hostclass("foo", "bar").name.should == 'foo::bar'
+      end
+
+      it "should only look in the topclass, if the name is qualified" do
+        @loader.find_hostclass("foo", "::bar").name.should == 'bar'
+      end
+
+      it "should only look in the topclass, if we assume the name is fully qualified" do
+        @loader.find_hostclass("foo", "bar", :assume_fqname => true).name.should == 'bar'
       end
     end
 
     it "should not look in the local scope for classes when the name is qualified" do
         @loader = Puppet::Resource::TypeCollection.new(environment)
         @loader.add Puppet::Resource::Type.new(:hostclass, "foo::bar")
 
-        @loader.find_hostclass("::bar").should == nil
+        @loader.find_hostclass("foo", "::bar").should == nil
     end
 
   end
 
   it "should be able to find nodes" do
     node = Puppet::Resource::Type.new(:node, "bar")
     loader = Puppet::Resource::TypeCollection.new(environment)
     loader.add(node)
-    loader.find_node("bar").should == node
+    loader.find_node(stub("ignored"), "bar").should == node
   end
 
   it "should indicate whether any nodes are defined" do
     loader = Puppet::Resource::TypeCollection.new(environment)
     loader.add_node(Puppet::Resource::Type.new(:node, "foo"))
     loader.should be_nodes
   end
 
   it "should indicate whether no nodes are defined" do
     Puppet::Resource::TypeCollection.new(environment).should_not be_nodes
   end
 
   describe "when finding nodes" do
     before :each do
       @loader = Puppet::Resource::TypeCollection.new(environment)
     end
 
     it "should return any node whose name exactly matches the provided node name" do
       node = Puppet::Resource::Type.new(:node, "foo")
       @loader << node
 
       @loader.node("foo").should equal(node)
     end
 
     it "should return the first regex node whose regex matches the provided node name" do
       node1 = Puppet::Resource::Type.new(:node, /\w/)
       node2 = Puppet::Resource::Type.new(:node, /\d/)
       @loader << node1 << node2
 
       @loader.node("foo10").should equal(node1)
     end
 
     it "should preferentially return a node whose name is string-equal over returning a node whose regex matches a provided name" do
       node1 = Puppet::Resource::Type.new(:node, /\w/)
       node2 = Puppet::Resource::Type.new(:node, "foo")
       @loader << node1 << node2
 
       @loader.node("foo").should equal(node2)
     end
   end
 
   describe "when determining the configuration version" do
     before do
       @code = Puppet::Resource::TypeCollection.new(environment)
     end
 
     it "should default to the current time" do
       time = Time.now
 
       Time.stubs(:now).returns time
       @code.version.should == time.to_i
     end
 
     context "when config_version script is specified" do
       let(:environment) { Puppet::Node::Environment.create(:testing, [], '', '/my/foo') }
 
       it "should use the output of the environment's config_version setting if one is provided" do
         Puppet::Util::Execution.expects(:execute).with(["/my/foo"]).returns "output\n"
         @code.version.should == "output"
       end
 
       it "should raise a puppet parser error if executing config_version fails" do
         Puppet::Util::Execution.expects(:execute).raises(Puppet::ExecutionFailure.new("msg"))
 
         lambda { @code.version }.should raise_error(Puppet::ParseError)
       end
     end
   end
 end
diff --git a/spec/unit/util/warnings_spec.rb b/spec/unit/util/warnings_spec.rb
index 492c3540b..f926ae10b 100755
--- a/spec/unit/util/warnings_spec.rb
+++ b/spec/unit/util/warnings_spec.rb
@@ -1,46 +1,38 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Util::Warnings do
   before(:all) do
     @msg1 = "booness"
     @msg2 = "more booness"
   end
 
-  before(:each) do
-    Puppet.debug = true
-  end
-
-  after (:each) do
-    Puppet.debug = false
-  end
-
   {:notice => "notice_once", :warning => "warnonce", :debug => "debug_once"}.each do |log, method|
     describe "when registring '#{log}' messages" do
       it "should always return nil" do
         Puppet::Util::Warnings.send(method, @msg1).should be(nil)
       end
 
       it "should issue a warning" do
         Puppet.expects(log).with(@msg1)
         Puppet::Util::Warnings.send(method, @msg1)
       end
 
       it "should issue a warning exactly once per unique message" do
         Puppet.expects(log).with(@msg1).once
         Puppet::Util::Warnings.send(method, @msg1)
         Puppet::Util::Warnings.send(method, @msg1)
       end
 
       it "should issue multiple warnings for multiple unique messages" do
         Puppet.expects(log).times(2)
         Puppet::Util::Warnings.send(method, @msg1)
         Puppet::Util::Warnings.send(method, @msg2)
       end
     end
   end
 
   after(:each) do
     Puppet::Util::Warnings.clear_warnings
   end
 end