diff --git a/lib/puppet/face/node/clean.rb b/lib/puppet/face/node/clean.rb
index bfd88feb3..6ed5bf22a 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 884fd2f03..f9cbad817 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/compiler.rb b/lib/puppet/parser/compiler.rb
index 3a048082c..cd88dd027 100644
--- a/lib/puppet/parser/compiler.rb
+++ b/lib/puppet/parser/compiler.rb
@@ -1,607 +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
 
   # Evaluate each specified class in turn.  If there are any classes we can't
   # find, raise an error.  This method really just creates resource objects
   # that point back to the classes, and then the resources are themselves
   # evaluated later in the process.
   #
   # Sometimes we evaluate classes with a fully qualified name already, in which
   # case, we tell scope.find_hostclass we've pre-qualified the name so it
   # doesn't need to search its namespaces again.  This gets around a weird
   # edge case of duplicate class names, one at top scope and one nested in our
   # namespace and the wrong one (or both!) getting selected. See ticket #13349
   # for more detail.  --jeffweiss 26 apr 2012
   def evaluate_classes(classes, scope, lazy_evaluate = true, fqname = false)
     raise Puppet::DevError, "No source for scope passed to evaluate_classes" unless scope.source
     class_parameters = nil
     # if we are a param class, save the classes hash
     # and transform classes to be the keys
     if classes.class == Hash
       class_parameters = classes
       classes = classes.keys
     end
 
     hostclasses = classes.collect do |name|
-      scope.find_hostclass(name, :assume_fqname => fqname) or raise Puppet::Error, "Could not find class #{name} for #{node.name}"
+      scope.find_hostclass(name) 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/scope.rb b/lib/puppet/parser/scope.rb
index 8cd337071..fd4bfe9a1 100644
--- a/lib/puppet/parser/scope.rb
+++ b/lib/puppet/parser/scope.rb
@@ -1,844 +1,845 @@
 # 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, options = {})
-    known_resource_types.find_hostclass(namespaces, name, options)
+  def find_hostclass(name)
+    known_resource_types.find_hostclass(name)
   end
 
   def find_definition(name)
-    known_resource_types.find_definition(namespaces, name)
+    known_resource_types.find_definition(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
     else
       @namespaces = ["".freeze].freeze
     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)
-    find_definition(name) || find_hostclass(name)
+    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
   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(namespaces, type.to_s.downcase)
+    known_resource_types.find_definition(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/resource/type.rb b/lib/puppet/resource/type.rb
index e60fd1167..96424854e 100644
--- a/lib/puppet/resource/type.rb
+++ b/lib/puppet/resource/type.rb
@@ -1,395 +1,398 @@
 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) ||
+  #     resource_type_collection.find_or_load(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 ||= parent && (scope.environment.known_resource_types.find_or_load(parent, type.to_sym) ||
+#      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)
+      unless @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}"
       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 133373543..0de1eefc1 100644
--- a/lib/puppet/resource/type_collection.rb
+++ b/lib/puppet/resource/type_collection.rb
@@ -1,180 +1,180 @@
 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(namespaces, name)
+  def find_node(name)
     @nodes[munge_name(name)]
   end
 
-  def find_hostclass(namespaces, name, options = {})
-    find_or_load(namespaces, name, :hostclass, options)
+  def find_hostclass(name)
+    find_or_load(name, :hostclass)
   end
 
-  def find_definition(namespaces, name)
-    find_or_load(namespaces, name, :definition)
+  def find_definition(name)
+    find_or_load(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
 
   # Resolve namespaces and find the given object.  Autoload it if
   # necessary.
-  def find_or_load(namespaces, name, type, options = {})
+  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.
         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
     end
     result
   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/spec/integration/parser/compiler_spec.rb b/spec/integration/parser/compiler_spec.rb
index 1f42c2cbf..4bfcf1f70 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", {:assume_fqname => false}).returns(nil)
+      @scope.expects(:find_hostclass).with("notfound").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', {:assume_fqname => false}).returns(nil)
+      @compiler.topscope.expects(:find_hostclass).with('foo').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", {:assume_fqname => false}).returns(@class)
+      @scope.stubs(:find_hostclass).with("myclass").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",{:assume_fqname => false}).returns(@class)
+      @scope.stubs(:find_hostclass).with("MyClass").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 184eded17..7ce2a8bc6 100755
--- a/spec/integration/resource/type_collection_spec.rb
+++ b/spec/integration/resource/type_collection_spec.rb
@@ -1,91 +1,79 @@
 #! /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
-    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
+      @code.find_hostclass(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
-      modname = "both"
-      name = "sub"
-      mk_module(modname, :init => %w{both both::sub})
-      @code.find_hostclass([], "both::sub").name.should == "both::sub"
+      mk_module('both', :init => %w{both both::sub})
+      @code.find_hostclass("both::sub").name.should == "both::sub"
     end
 
     it "should be able load classes from a separate file" do
-      modname = "separate"
-      name = "sub"
-      mk_module(modname, :init => %w{separate}, :sub => %w{separate::sub})
-      @code.find_hostclass([], "separate::sub").name.should == "separate::sub"
+      mk_module('separate', :init => %w{separate}, :sub => %w{separate::sub})
+      @code.find_hostclass("separate::sub").name.should == "separate::sub"
     end
 
     it "should not fail when loading from a separate file if there is no module file" do
-      modname = "alone"
-      name = "sub"
-      mk_module(modname, :sub => %w{alone::sub})
-      lambda { @code.find_hostclass("alone", name) }.should_not raise_error
+      mk_module('alone', :sub => %w{alone::sub})
+      lambda { @code.find_hostclass("alone::sub") }.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/parser/compiler_spec.rb b/spec/unit/parser/compiler_spec.rb
index 1f42c2cbf..4bfcf1f70 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", {:assume_fqname => false}).returns(nil)
+      @scope.expects(:find_hostclass).with("notfound").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', {:assume_fqname => false}).returns(nil)
+      @compiler.topscope.expects(:find_hostclass).with('foo').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", {:assume_fqname => false}).returns(@class)
+      @scope.stubs(:find_hostclass).with("myclass").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",{:assume_fqname => false}).returns(@class)
+      @scope.stubs(:find_hostclass).with("MyClass").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/resource/type_collection_spec.rb b/spec/unit/resource/type_collection_spec.rb
index a0fdd00bf..0c359ca69 100755
--- a/spec/unit/resource/type_collection_spec.rb
+++ b/spec/unit/resource/type_collection_spec.rb
@@ -1,302 +1,302 @@
 #! /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 looking up names" do
     before do
       @type = Puppet::Resource::Type.new(:hostclass, "ns::klass")
     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("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")
+        @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.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.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
 
       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
+        @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
+        @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("namespace", "::foo::bar").should equal(instance)
+      loader.find_hostclass("::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("namespace", "::foo::bar").should be_nil
+      loader.find_hostclass("::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 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 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'
+        @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'
       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("foo", "::bar").should == nil
+        @loader.find_hostclass("::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(stub("ignored"), "bar").should == node
+    loader.find_node("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