diff --git a/lib/puppet/parser/ast/resource.rb b/lib/puppet/parser/ast/resource.rb
index 9149b06c3..0c58538d5 100644
--- a/lib/puppet/parser/ast/resource.rb
+++ b/lib/puppet/parser/ast/resource.rb
@@ -1,77 +1,78 @@
 require 'puppet/parser/ast/resource_reference'
 
 # Any normal puppet resource declaration.  Can point to a definition or a
 # builtin type.
 class Puppet::Parser::AST
 class Resource < AST::ResourceReference
 
   associates_doc
 
   attr_accessor :title, :type, :exported, :virtual
   attr_reader :parameters
 
   # Does not actually return an object; instead sets an object
   # in the current scope.
   def evaluate(scope)
     # Evaluate all of the specified params.
     paramobjects = parameters.collect { |param|
       param.safeevaluate(scope)
     }
 
     resource_titles = @title.safeevaluate(scope)
 
     # it's easier to always use an array, even for only one name
     resource_titles = [resource_titles] unless resource_titles.is_a?(Array)
 
     # We want virtual to be true if exported is true.  We can't
     # just set :virtual => self.virtual in the initialization,
     # because sometimes the :virtual attribute is set *after*
     # :exported, in which case it clobbers :exported if :exported
     # is true.  Argh, this was a very tough one to track down.
     virt = self.virtual || self.exported
 
     # This is where our implicit iteration takes place; if someone
     # passed an array as the name, then we act just like the called us
     # many times.
-    resource_type = scope.find_resource_type(type)
+    fully_qualified_type, resource_titles = scope.resolve_type_and_titles(type, resource_titles)
+
     resource_titles.flatten.collect { |resource_title|
       exceptwrap :type => Puppet::ParseError do
         resource = Puppet::Parser::Resource.new(
-          resource_type.name, resource_title,
+          fully_qualified_type, resource_title,
           :parameters => paramobjects,
           :file => self.file,
           :line => self.line,
           :exported => self.exported,
           :virtual => virt,
           :source => scope.source,
           :scope => scope,
         
           :strict => true
         )
 
         # And then store the resource in the compiler.
         # At some point, we need to switch all of this to return
         # resources instead of storing them like this.
         scope.compiler.add_resource(scope, resource)
         resource
       end
     }.reject { |resource| resource.nil? }
   end
 
   # Set the parameters for our object.
   def parameters=(params)
     if params.is_a?(AST::ASTArray)
       @parameters = params
     else
 
             @parameters = AST::ASTArray.new(
                 
         :line => params.line,
         :file => params.file,
         
         :children => [params]
       )
     end
   end
 end
 end
diff --git a/lib/puppet/parser/ast/resource_reference.rb b/lib/puppet/parser/ast/resource_reference.rb
index 5b1b0aa3a..0f8e655bf 100644
--- a/lib/puppet/parser/ast/resource_reference.rb
+++ b/lib/puppet/parser/ast/resource_reference.rb
@@ -1,42 +1,28 @@
 require 'puppet/parser/ast'
 require 'puppet/parser/ast/branch'
 
 class Puppet::Parser::AST::ResourceReference < Puppet::Parser::AST::Branch
   attr_accessor :title, :type
 
   # Evaluate our object, but just return a simple array of the type
   # and name.
   def evaluate(scope)
-    a_type = type
     titles = Array(title.safeevaluate(scope))
 
-    case type.downcase
-    when "class"
-      # resolve the titles
-      titles = titles.collect do |a_title|
-        hostclass = scope.find_hostclass(a_title)
-        hostclass ?  hostclass.name : a_title
-      end
-    when "node"
-      # no-op
-    else
-      # resolve the type
-      resource_type = scope.find_resource_type(type)
-      a_type = resource_type.name if resource_type
-    end
+    a_type, titles = scope.resolve_type_and_titles(type, titles)
 
     resources = titles.collect{ |a_title|
       Puppet::Resource.new(a_type, a_title)
     }
 
     return(resources.length == 1 ? resources.pop : resources)
   end
 
   def to_s
     if title.is_a?(Puppet::Parser::AST::ASTArray)
       "#{type.to_s.capitalize}#{title}"
     else
       "#{type.to_s.capitalize}[#{title}]"
     end
   end
 end
diff --git a/lib/puppet/parser/scope.rb b/lib/puppet/parser/scope.rb
index 2ca28d824..24f1d01f7 100644
--- a/lib/puppet/parser/scope.rb
+++ b/lib/puppet/parser/scope.rb
@@ -1,497 +1,518 @@
 # The scope class, which handles storing and retrieving variables and types and
 # such.
 
 require 'puppet/parser/parser'
 require 'puppet/parser/templatewrapper'
 require 'puppet/transportable'
 require 'strscan'
 
 require 'puppet/resource/type_collection_helper'
 
 class Puppet::Parser::Scope
   include Puppet::Resource::TypeCollectionHelper
   require 'puppet/parser/resource'
 
   AST = Puppet::Parser::AST
 
   Puppet::Util.logmethods(self)
 
   include Enumerable
   include Puppet::Util::Errors
   attr_accessor :level, :source, :resource
   attr_accessor :base, :keyword
   attr_accessor :top, :translated, :compiler
   attr_accessor :parent
   attr_reader :namespaces
 
   # thin wrapper around an ephemeral
   # symbol table.
   # when a symbol
   class Ephemeral
     def initialize(parent=nil)
       @symbols = {}
       @parent = parent
     end
 
     [:include?, :delete, :[]=].each do |m|
       define_method(m) do |*args|
         @symbols.send(m, *args)
       end
     end
 
     def [](name)
       unless @symbols.include?(name) or @parent.nil?
         @parent[name]
       else
         @symbols[name]
       end
     end
   end
 
   # A demeterific shortcut to the catalog.
   def catalog
     compiler.catalog
   end
 
   def environment
     compiler.environment
   end
 
   # Proxy accessors
   def host
     @compiler.node.name
   end
 
   # Is the value true?  This allows us to control the definition of truth
   # in one place.
   def self.true?(value)
     (value != false and value != "" and value != :undef)
   end
 
   # Is the value a number?, return the correct object or nil if not a number
   def self.number?(value)
     return nil unless value.is_a?(Fixnum) or value.is_a?(Bignum) or value.is_a?(Float) or value.is_a?(String)
 
     if value.is_a?(String)
       if value =~ /^-?\d+(:?\.\d+|(:?\.\d+)?e\d+)$/
         return value.to_f
       elsif value =~ /^0x[0-9a-f]+$/i
         return value.to_i(16)
       elsif value =~ /^0[0-7]+$/
         return value.to_i(8)
       elsif value =~ /^-?\d+$/
         return value.to_i
       else
         return nil
       end
     end
     # it is one of Fixnum,Bignum or Float
     value
   end
 
   # Add to our list of namespaces.
   def add_namespace(ns)
     return false if @namespaces.include?(ns)
     if @namespaces == [""]
       @namespaces = [ns]
     else
       @namespaces << ns
     end
   end
 
   # Remove this when rebasing
   def environment
     compiler.environment
   end
 
   # Are we the top scope?
   def topscope?
     @level == 1
   end
 
   def find_hostclass(name)
     known_resource_types.find_hostclass(namespaces, name)
   end
 
   def find_definition(name)
     known_resource_types.find_definition(namespaces, name)
   end
 
   def findresource(string, name = nil)
     compiler.findresource(string, name)
   end
 
   # Initialize our new scope.  Defaults to having no parent.
   def initialize(hash = {})
     if hash.include?(:namespace)
       if n = hash[:namespace]
         @namespaces = [n]
       end
       hash.delete(:namespace)
     else
       @namespaces = [""]
     end
     hash.each { |name, val|
       method = name.to_s + "="
       if self.respond_to? method
         self.send(method, val)
       else
         raise Puppet::DevError, "Invalid scope argument #{name}"
       end
     }
 
     extend_with_functions_module
 
     @tags = []
 
     # The symbol table for this scope.  This is where we store variables.
     @symtable = {}
 
     # the ephemeral symbol tables
     # those should not persist long, and are used for the moment only
     # for $0..$xy capture variables of regexes
     # this is actually implemented as a stack, with each ephemeral scope
     # shadowing the previous one
     @ephemeral = [ Ephemeral.new ]
 
     # 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)
     return parent.class_set(name,scope) if parent
     @class_scopes[name] = scope
   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.
   def lookupdefaults(type)
     values = {}
 
     # first collect the values from the parents
     unless parent.nil?
       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
 
     #Puppet.debug "Got defaults for %s: %s" %
     #    [type,values.inspect]
     values
   end
 
   # Look up a defined type.
   def lookuptype(name)
     find_definition(name) || find_hostclass(name)
   end
 
   def lookup_qualified_var(name, usestring)
     parts = name.split(/::/)
     shortname = parts.pop
     klassname = parts.join("::")
     klass = find_hostclass(klassname)
     unless klass
       warning "Could not look up qualified variable '#{name}'; class #{klassname} could not be found"
       return usestring ? "" : :undefined
     end
     unless kscope = class_scope(klass)
       warning "Could not look up qualified variable '#{name}'; class #{klassname} has not been evaluated"
       return usestring ? "" : :undefined
     end
     kscope.lookupvar(shortname, usestring)
   end
 
   private :lookup_qualified_var
 
   # Look up a variable.  The simplest value search we do.  Default to returning
   # an empty string for missing values, but support returning a constant.
   def lookupvar(name, usestring = true)
     table = ephemeral?(name) ? @ephemeral.last : @symtable
     # If the variable is qualified, then find the specified scope and look the variable up there instead.
     if name =~ /::/
       return lookup_qualified_var(name, usestring)
     end
     # We can't use "if table[name]" here because the value might be false
     if ephemeral_include?(name) or table.include?(name)
       if usestring and table[name] == :undef
         return ""
       else
         return table[name]
       end
     elsif self.parent
       return parent.lookupvar(name, usestring)
     elsif usestring
       return ""
     else
       return :undefined
     end
   end
 
   # Return a hash containing our variables and their values, optionally (and
   # by default) including the values defined in our parent.  Local values
   # shadow parent values.
   def to_hash(recursive = true)
     target = parent.to_hash(recursive) if recursive and parent
     target ||= Hash.new
     @symtable.keys.each { |name|
       value = @symtable[name]
       if value == :undef
         target.delete(name)
       else
         target[name] = value
       end
     }
     target
   end
 
   def namespaces
     @namespaces.dup
   end
 
   # Create a new scope and set these options.
   def newscope(options = {})
     compiler.newscope(self, options)
   end
 
   def parent_module_name
     return nil unless @parent
     return nil unless @parent.source
     @parent.source.module_name
   end
 
   # Return the list of scopes up to the top scope, ordered with our own first.
   # This is used for looking up variables and defaults.
   def scope_path
     if parent
       [self, parent.scope_path].flatten.compact
     else
       [self]
     end
   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 setdefaults(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|
       #Puppet.debug "Default for %s is %s => %s" %
       #    [type,ary[0].inspect,ary[1].inspect]
       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
 
   # 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.
   def setvar(name,value, options = {})
     table = options[:ephemeral] ? @ephemeral.last : @symtable
     #Puppet.debug "Setting %s to '%s' at level %s mode append %s" %
     #    [name.inspect,value,self.level, append]
     if table.include?(name)
       unless options[:append]
         error = Puppet::ParseError.new("Cannot reassign variable #{name}")
       else
         error = Puppet::ParseError.new("Cannot append, variable #{name} is defined in this scope")
       end
       error.file = options[:file] if options[:file]
       error.line = options[:line] if options[:line]
       raise error
     end
 
     unless options[:append]
       table[name] = value
     else # append case
       # lookup the value in the scope if it exists and insert the var
       table[name] = lookupvar(name)
       # concatenate if string, append if array, nothing for other types
       case value
       when Array
         table[name] += value
       when Hash
         raise ArgumentError, "Trying to append to a hash with something which is not a hash is unsupported" unless value.is_a?(Hash)
         table[name].merge!(value)
       else
         table[name] << value
       end
     end
   end
 
   # Return an interpolated string.
   def strinterp(string, file = nil, line = nil)
     # Most strings won't have variables in them.
     ss = StringScanner.new(string)
     out = ""
     while not ss.eos?
       if ss.scan(/^\$\{((\w*::)*\w+|[0-9]+)\}|^\$([0-9])|^\$((\w*::)*\w+)/)
         # If it matches the backslash, then just retun the dollar sign.
         if ss.matched == '\\$'
           out << '$'
         else # look the variable up
           # make sure $0-$9 are lookupable only if ephemeral
           var = ss[1] || ss[3] || ss[4]
           if var and var =~ /^[0-9]+$/ and not ephemeral_include?(var)
             next
           end
           out << lookupvar(var).to_s || ""
         end
       elsif ss.scan(/^\\(.)/)
         # Puppet.debug("Got escape: pos:%d; m:%s" % [ss.pos, ss.matched])
         case ss[1]
         when 'n'
           out << "\n"
         when 't'
           out << "\t"
         when 's'
           out << " "
         when '\\'
           out << '\\'
         when '$'
           out << '$'
         else
           str = "Unrecognised escape sequence '#{ss.matched}'"
           str += " in file #{file}" if file
           str += " at line #{line}" if line
           Puppet.warning str
           out << ss.matched
         end
       elsif ss.scan(/^\$/)
         out << '$'
       elsif ss.scan(/^\\\n/) # an escaped carriage return
         next
       else
         tmp = ss.scan(/[^\\$]+/)
         # Puppet.debug("Got other: pos:%d; m:%s" % [ss.pos, tmp])
         unless tmp
           error = Puppet::ParseError.new("Could not parse string #{string.inspect}")
           {:file= => file, :line= => line}.each do |m,v|
             error.send(m, v) if v
           end
           raise error
         end
         out << tmp
       end
     end
 
     out
   end
 
   # Return the tags associated with this scope.  It's basically
   # just our parents' tags, plus our type.  We don't cache this value
   # because our parent tags might change between calls.
   def tags
     resource.tags
   end
 
   # Used mainly for logging
   def to_s
     "Scope(#{@resource})"
   end
 
   # Undefine a variable; only used for testing.
   def unsetvar(var)
     table = ephemeral?(var) ? @ephemeral.last : @symtable
     table.delete(var) if table.include?(var)
   end
 
   # remove ephemeral scope up to level
   def unset_ephemeral_var(level=:all)
     if level == :all
       @ephemeral = [ Ephemeral.new ]
     else
       (@ephemeral.size - level).times do
         @ephemeral.pop
       end
     end
   end
 
   # check if name exists in one of the ephemeral scope.
   def ephemeral_include?(name)
     @ephemeral.reverse.each do |eph|
       return true if eph.include?(name)
     end
     false
   end
 
   # is name an ephemeral variable?
   def ephemeral?(name)
     name =~ /^\d+$/
   end
 
   def ephemeral_level
     @ephemeral.size
   end
 
   def new_ephemeral
     @ephemeral.push(Ephemeral.new(@ephemeral.last))
   end
 
   def ephemeral_from(match, file = nil, line = nil)
     raise(ArgumentError,"Invalid regex match data") unless match.is_a?(MatchData)
 
     new_ephemeral
 
     setvar("0", match[0], :file => file, :line => line, :ephemeral => true)
     match.captures.each_with_index do |m,i|
       setvar("#{i+1}", m, :file => file, :line => line, :ephemeral => true)
     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)
     environment.known_resource_types.find_definition(namespaces, type.to_s.downcase)
   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
+
   private
 
   def extend_with_functions_module
     extend Puppet::Parser::Functions.environment_module(Puppet::Node::Environment.root)
     extend Puppet::Parser::Functions.environment_module(compiler ? environment : nil)
   end
 end
diff --git a/spec/unit/parser/ast/resource_spec.rb b/spec/unit/parser/ast/resource_spec.rb
index 58ffae925..5c94ac0e9 100755
--- a/spec/unit/parser/ast/resource_spec.rb
+++ b/spec/unit/parser/ast/resource_spec.rb
@@ -1,120 +1,127 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../../spec_helper'
 
 describe Puppet::Parser::AST::Resource do
   ast = Puppet::Parser::AST
 
   before :each do
     @title = Puppet::Parser::AST::String.new(:value => "mytitle")
     @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
     @scope = Puppet::Parser::Scope.new(:compiler => @compiler)
     @scope.stubs(:resource).returns(stub_everything)
     @resource = ast::Resource.new(:title => @title, :type => "file", :parameters => ast::ASTArray.new(:children => []) )
     @resource.stubs(:qualified_type).returns("Resource")
   end
 
   it "should evaluate all its parameters" do
     param = stub 'param'
     param.expects(:safeevaluate).with(@scope).returns Puppet::Parser::Resource::Param.new(:name => "myparam", :value => "myvalue", :source => stub("source"))
     @resource.stubs(:parameters).returns [param]
 
     @resource.evaluate(@scope)
   end
 
   it "should evaluate its title" do
     @resource.evaluate(@scope)[0].title.should == "mytitle"
   end
 
   it "should flatten the titles array" do
     titles = []
     %w{one two}.each do |title|
       titles << Puppet::Parser::AST::String.new(:value => title)
     end
 
     array = Puppet::Parser::AST::ASTArray.new(:children => titles)
 
     @resource.title = array
     result = @resource.evaluate(@scope).collect { |r| r.title }
     result.should be_include("one")
     result.should be_include("two")
   end
 
   it "should create and return one resource objects per title" do
     titles = []
     %w{one two}.each do |title|
       titles << Puppet::Parser::AST::String.new(:value => title)
     end
 
     array = Puppet::Parser::AST::ASTArray.new(:children => titles)
 
     @resource.title = array
     result = @resource.evaluate(@scope).collect { |r| r.title }
     result.should be_include("one")
     result.should be_include("two")
   end
 
   it "should handover resources to the compiler" do
     titles = []
     %w{one two}.each do |title|
       titles << Puppet::Parser::AST::String.new(:value => title)
     end
 
     array = Puppet::Parser::AST::ASTArray.new(:children => titles)
 
     @resource.title = array
     result = @resource.evaluate(@scope)
 
     result.each do |res|
       @compiler.catalog.resource(res.ref).should be_instance_of(Puppet::Parser::Resource)
     end
   end
   it "should generate virtual resources if it is virtual" do
     @resource.virtual = true
 
     result = @resource.evaluate(@scope)
     result[0].should be_virtual
   end
 
   it "should generate virtual and exported resources if it is exported" do
     @resource.exported = true
 
     result = @resource.evaluate(@scope)
     result[0].should be_virtual
     result[0].should be_exported
   end
 
   # Related to #806, make sure resources always look up the full path to the resource.
   describe "when generating qualified resources" do
     before do
       @scope = Puppet::Parser::Scope.new :compiler => Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
       @parser = Puppet::Parser::Parser.new(Puppet::Node::Environment.new)
       @parser.newdefine "one"
       @parser.newdefine "one::two"
       @parser.newdefine "three"
       @twoscope = @scope.newscope(:namespace => "one")
       @twoscope.resource = @scope.resource
     end
 
     def resource(type, params = nil)
       params ||= Puppet::Parser::AST::ASTArray.new(:children => [])
       Puppet::Parser::AST::Resource.new(:type => type, :title => Puppet::Parser::AST::String.new(:value => "myresource"), :parameters => params)
     end
 
     it "should be able to generate resources with fully qualified type information" do
       resource("two").evaluate(@twoscope)[0].type.should == "One::Two"
     end
 
     it "should be able to generate resources with unqualified type information" do
       resource("one").evaluate(@twoscope)[0].type.should == "One"
     end
 
     it "should correctly generate resources that can look up builtin types" do
       resource("file").evaluate(@twoscope)[0].type.should == "File"
     end
 
+    it "should correctly generate resources that can look up defined classes by title" do
+      @scope.known_resource_types.add_hostclass Puppet::Resource::Type.new(:hostclass, "Myresource", {})
+      res = resource("class").evaluate(@twoscope)[0]
+      res.type.should == "Class"
+      res.title.should == "Myresource"
+    end
+
     it "should fail for resource types that do not exist" do
       lambda { resource("nosuchtype").evaluate(@twoscope) }.should raise_error(Puppet::ParseError)
     end
   end
 end