diff --git a/lib/puppet/parser/ast/leaf.rb b/lib/puppet/parser/ast/leaf.rb
index b61634d6c..c8ebc9483 100644
--- a/lib/puppet/parser/ast/leaf.rb
+++ b/lib/puppet/parser/ast/leaf.rb
@@ -1,221 +1,221 @@
 class Puppet::Parser::AST
   # The base class for all of the leaves of the parse trees.  These
   # basically just have types and values.  Both of these parameters
   # are simple values, not AST objects.
   class Leaf < AST
     attr_accessor :value, :type
 
     # Return our value.
     def evaluate(scope)
       @value
     end
 
     def match(value)
       @value == value
     end
 
     def to_s
       @value.to_s unless @value.nil?
     end
   end
 
   # The boolean class.  True or false.  Converts the string it receives
   # to a Ruby boolean.
   class Boolean < AST::Leaf
 
     # Use the parent method, but then convert to a real boolean.
     def initialize(hash)
       super
 
       unless @value == true or @value == false
         raise Puppet::DevError,
           "'#{@value}' is not a boolean"
       end
       @value
     end
 
     def to_s
       @value ? "true" : "false"
     end
   end
 
   # The base string class.
   class String < AST::Leaf
     def evaluate(scope)
       @value.dup
     end
 
     def to_s
       "\"#{@value}\""
     end
   end
 
   # An uninterpreted string.
   class FlatString < AST::Leaf
     def evaluate(scope)
       @value
     end
 
     def to_s
       "\"#{@value}\""
     end
   end
 
   class Concat < AST::Leaf
     def evaluate(scope)
       @value.collect { |x| x.evaluate(scope) }.collect{ |x| x == :undef ? '' : x }.join
     end
 
     def to_s
       "#{@value.map { |s| s.to_s.gsub(/^"(.*)"$/, '\1') }.join}"
     end
   end
 
   # The 'default' option on case statements and selectors.
   class Default < AST::Leaf; end
 
   # Capitalized words; used mostly for type-defaults, but also
   # get returned by the lexer any other time an unquoted capitalized
   # word is found.
   class Type < AST::Leaf; end
 
   # Lower-case words.
   class Name < AST::Leaf; end
 
   # double-colon separated class names
   class ClassName < AST::Leaf; end
 
   # undef values; equiv to nil
   class Undef < AST::Leaf; end
 
   # Host names, either fully qualified or just the short name, or even a regex
   class HostName < AST::Leaf
     def initialize(hash)
       super
 
       # Note that this is an AST::Regex, not a Regexp
       @value = @value.to_s.downcase unless @value.is_a?(Regex)
       if @value =~ /[^-\w.]/
         raise Puppet::DevError,
           "'#{@value}' is not a valid hostname"
       end
     end
 
     # implementing eql? and hash so that when an HostName is stored
     # in a hash it has the same hashing properties as the underlying value
     def eql?(value)
       value = value.value if value.is_a?(HostName)
       @value.eql?(value)
     end
 
     def hash
       @value.hash
     end
 
     def to_s
       @value.to_s
     end
   end
 
   # A simple variable.  This object is only used during interpolation;
   # the VarDef class is used for assignment.
   class Variable < Name
     # Looks up the value of the object in the scope tree (does
     # not include syntactical constructs, like '$' and '{}').
     def evaluate(scope)
       parsewrap do
-        if (var = scope.lookupvar(@value)) == :undefined
+        if (var = scope.lookupvar(@value, :file => file, :line => line)) == :undefined
           var = :undef
         end
         var
       end
     end
 
     def to_s
       "\$#{value}"
     end
   end
 
   class HashOrArrayAccess < AST::Leaf
     attr_accessor :variable, :key
 
     def evaluate_container(scope)
       container = variable.respond_to?(:evaluate) ? variable.safeevaluate(scope) : variable
-      (container.is_a?(Hash) or container.is_a?(Array)) ? container : scope.lookupvar(container)
+      (container.is_a?(Hash) or container.is_a?(Array)) ? container : scope.lookupvar(container, :file => file, :line => line)
     end
 
     def evaluate_key(scope)
       key.respond_to?(:evaluate) ? key.safeevaluate(scope) : key
     end
 
     def array_index_or_key(object, key)
       if object.is_a?(Array)
         raise Puppet::ParserError, "#{key} is not an integer, but is used as an index of an array" unless key = Puppet::Parser::Scope.number?(key)
       end
       key
     end
 
     def evaluate(scope)
       object = evaluate_container(scope)
       accesskey = evaluate_key(scope)
 
       raise Puppet::ParseError, "#{variable} is not an hash or array when accessing it with #{accesskey}" unless object.is_a?(Hash) or object.is_a?(Array)
 
       object[array_index_or_key(object, accesskey)]
     end
 
     # Assign value to this hashkey or array index
     def assign(scope, value)
       object = evaluate_container(scope)
       accesskey = evaluate_key(scope)
 
       if object.is_a?(Hash) and object.include?(accesskey)
         raise Puppet::ParseError, "Assigning to the hash '#{variable}' with an existing key '#{accesskey}' is forbidden"
       end
 
       # assign to hash or array
       object[array_index_or_key(object, accesskey)] = value
     end
 
     def to_s
       "\$#{variable.to_s}[#{key.to_s}]"
     end
   end
 
   class Regex < AST::Leaf
     def initialize(hash)
       super
       @value = Regexp.new(@value) unless @value.is_a?(Regexp)
     end
 
     # we're returning self here to wrap the regexp and to be used in places
     # where a string would have been used, without modifying any client code.
     # For instance, in many places we have the following code snippet:
     #  val = @val.safeevaluate(@scope)
     #  if val.match(otherval)
     #      ...
     #  end
     # this way, we don't have to modify this test specifically for handling
     # regexes.
     def evaluate(scope)
       self
     end
 
     def evaluate_match(value, scope, options = {})
       value = value.is_a?(String) ? value : value.to_s
 
       if matched = @value.match(value)
         scope.ephemeral_from(matched, options[:file], options[:line])
       end
       matched
     end
 
     def match(value)
       @value.match(value)
     end
 
     def to_s
       "/#{@value.source}/"
     end
   end
 end
diff --git a/lib/puppet/parser/ast/vardef.rb b/lib/puppet/parser/ast/vardef.rb
index 6de1860c8..b766311dd 100644
--- a/lib/puppet/parser/ast/vardef.rb
+++ b/lib/puppet/parser/ast/vardef.rb
@@ -1,33 +1,33 @@
 require 'puppet/parser/ast/branch'
 
 class Puppet::Parser::AST
   # Define a variable.  Stores the value in the current scope.
   class VarDef < AST::Branch
 
     associates_doc
 
     attr_accessor :name, :value, :append
 
     @settor = true
 
     # Look up our name and value, and store them appropriately.  The
     # lexer strips off the syntax stuff like '$'.
     def evaluate(scope)
       value = @value.safeevaluate(scope)
       if name.is_a?(HashOrArrayAccess)
         name.assign(scope, value)
       else
         name = @name.safeevaluate(scope)
 
         parsewrap do
-          scope.setvar(name,value, :file => @file, :line => @line, :append => @append)
+          scope.setvar(name,value, :file => file, :line => line, :append => @append)
         end
       end
     end
 
     def each
       [@name,@value].each { |child| yield child }
     end
   end
 
 end
diff --git a/lib/puppet/parser/scope.rb b/lib/puppet/parser/scope.rb
index 95b765b52..a61a8578f 100644
--- a/lib/puppet/parser/scope.rb
+++ b/lib/puppet/parser/scope.rb
@@ -1,443 +1,444 @@
 # 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 :source, :resource
   attr_accessor :base, :keyword
   attr_accessor :top, :translated, :compiler
   attr_accessor :parent, :dynamic
   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
 
   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 undef_as(x,v)
     (v == :undefined) ? x : (v == :undef) ? x : v
   end
 
   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
 
   # Look up a variable.  The simplest value search we do.  
-  def lookupvar(name)
+  def lookupvar(name, options = {})
     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 =~ /^(.*)::(.+)$/
       begin 
-        qualified_scope($1).lookupvar($2)
+        qualified_scope($1).lookupvar($2,options)
       rescue RuntimeError => e
-        warning "Could not look up qualified variable '#{name}'; #{e.message}"
+        location = (options[:file] && options[:line]) ? " at #{options[:file]}:#{options[:line]}" : ''
+        warning "Could not look up qualified variable '#{name}'; #{e.message}#{location}"
         :undefined
       end
     elsif ephemeral_include?(name) or table.include?(name)
       # We can't use "if table[name]" here because the value might be false
       table[name]
     elsif parent
-      parent.lookupvar(name)
+      parent.lookupvar(name,options)
     else
       :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
     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] = undef_as('',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 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/lib/puppet/parser/templatewrapper.rb b/lib/puppet/parser/templatewrapper.rb
index 73fcb8aac..180a03dc9 100644
--- a/lib/puppet/parser/templatewrapper.rb
+++ b/lib/puppet/parser/templatewrapper.rb
@@ -1,109 +1,115 @@
 # A simple wrapper for templates, so they don't have full access to
 # the scope objects.
 require 'puppet/parser/files'
 require 'erb'
 
 class Puppet::Parser::TemplateWrapper
   attr_writer :scope
   attr_reader :file
   attr_accessor :string
   include Puppet::Util
   Puppet::Util.logmethods(self)
 
   def initialize(scope)
     @__scope__ = scope
   end
 
   def scope
     @__scope__
   end
 
+  def script_line
+    # find which line in the template (if any) we were called from
+    caller.find { |l| l =~ /#{file}:/ }.first[/:(\d+):/,1]
+  end
+
   # Should return true if a variable is defined, false if it is not
   def has_variable?(name)
-    scope.lookupvar(name.to_s) != :undefined
+    scope.lookupvar(name.to_s, :file => file, :line => script_line) != :undefined
   end
 
   # Allow templates to access the defined classes
   def classes
     scope.catalog.classes
   end
 
   # Allow templates to access the tags defined in the current scope
   def tags
     scope.tags
   end
 
   # Allow templates to access the all the defined tags
   def all_tags
     scope.catalog.tags
   end
 
   # Ruby treats variables like methods, so we used to expose variables
   # within scope to the ERB code via method_missing.  As per RedMine #1427,
   # though, this means that conflicts between methods in our inheritance
   # tree (Kernel#fork) and variable names (fork => "yes/no") could arise.
   #
   # Worse, /new/ conflicts could pop up when a new kernel or object method
   # was added to Ruby, causing templates to suddenly fail mysteriously when
   # Ruby was upgraded.
   #
   # To ensure that legacy templates using unqualified names work we retain
   # the missing_method definition here until we declare the syntax finally
   # dead.
   def method_missing(name, *args)
-    value = scope.lookupvar(name.to_s)
+    value = scope.lookupvar(name.to_s,:file => file,:line => script_line)
     if value != :undefined
       return value
     else
       # Just throw an error immediately, instead of searching for
       # other missingmethod things or whatever.
-      raise Puppet::ParseError, "Could not find value for '#{name}'"
+      raise Puppet::ParseError.new("Could not find value for '#{name}'",@file,script_line)
     end
   end
 
   def file=(filename)
     unless @file = Puppet::Parser::Files.find_template(filename, scope.compiler.environment.to_s)
       raise Puppet::ParseError, "Could not find template '#{filename}'"
     end
 
     # We'll only ever not have a parser in testing, but, eh.
     scope.known_resource_types.watch_file(file)
 
     @string = File.read(file)
   end
 
   def result(string = nil)
     if string
       self.string = string
       template_source = "inline template"
     else
       template_source = file
     end
 
     # Expose all the variables in our scope as instance variables of the
     # current object, making it possible to access them without conflict
     # to the regular methods.
     benchmark(:debug, "Bound template variables for #{template_source}") do
       scope.to_hash.each { |name, value|
         if name.kind_of?(String)
           realname = name.gsub(/[^\w]/, "_")
         else
           realname = name
         end
         instance_variable_set("@#{realname}", value)
       }
     end
 
     result = nil
     benchmark(:debug, "Interpolated template #{template_source}") do
       template = ERB.new(self.string, 0, "-")
+      template.filename = file
       result = template.result(binding)
     end
 
     result
   end
 
   def to_s
     "template[#{(file ? file : "inline")}]"
   end
 end
diff --git a/spec/unit/parser/ast/arithmetic_operator_spec.rb b/spec/unit/parser/ast/arithmetic_operator_spec.rb
index 0aab6f080..9b54f09d8 100755
--- a/spec/unit/parser/ast/arithmetic_operator_spec.rb
+++ b/spec/unit/parser/ast/arithmetic_operator_spec.rb
@@ -1,73 +1,63 @@
 #!/usr/bin/env ruby
 
 require 'spec_helper'
 
 describe Puppet::Parser::AST::ArithmeticOperator do
 
   ast = Puppet::Parser::AST
 
   before :each do
     @scope = Puppet::Parser::Scope.new
     @one = stub 'lval', :safeevaluate => 1
     @two = stub 'rval', :safeevaluate => 2
   end
 
   it "should evaluate both branches" do
     lval = stub "lval"
     lval.expects(:safeevaluate).with(@scope).returns(1)
     rval = stub "rval"
     rval.expects(:safeevaluate).with(@scope).returns(2)
 
     operator = ast::ArithmeticOperator.new :rval => rval, :operator => "+", :lval => lval
     operator.evaluate(@scope)
   end
 
   it "should fail for an unknown operator" do
     lambda { operator = ast::ArithmeticOperator.new :lval => @one, :operator => "%", :rval => @two }.should raise_error
   end
 
   it "should call Puppet::Parser::Scope.number?" do
     Puppet::Parser::Scope.expects(:number?).with(1).returns(1)
     Puppet::Parser::Scope.expects(:number?).with(2).returns(2)
 
     ast::ArithmeticOperator.new(:lval => @one, :operator => "+", :rval => @two).evaluate(@scope)
   end
 
 
   %w{ + - * / << >>}.each do |op|
     it "should call ruby Numeric '#{op}'" do
       one = stub 'one'
       two = stub 'two'
       operator = ast::ArithmeticOperator.new :lval => @one, :operator => op, :rval => @two
       Puppet::Parser::Scope.stubs(:number?).with(1).returns(one)
       Puppet::Parser::Scope.stubs(:number?).with(2).returns(two)
       one.expects(:send).with(op,two)
       operator.evaluate(@scope)
     end
   end
 
   it "should work even with numbers embedded in strings" do
     two = stub 'two', :safeevaluate => "2"
     one = stub 'one', :safeevaluate => "1"
     operator = ast::ArithmeticOperator.new :lval => two, :operator => "+", :rval => one
     operator.evaluate(@scope).should == 3
   end
 
   it "should work even with floats" do
     two = stub 'two', :safeevaluate => 2.53
     one = stub 'one', :safeevaluate => 1.80
     operator = ast::ArithmeticOperator.new :lval => two, :operator => "+", :rval => one
     operator.evaluate(@scope).should == 4.33
   end
 
-  it "should work for variables too" do
-    @scope.expects(:lookupvar).with("one").returns(1)
-    @scope.expects(:lookupvar).with("two").returns(2)
-    one = ast::Variable.new( :value => "one" )
-    two = ast::Variable.new( :value => "two" )
-
-    operator = ast::ArithmeticOperator.new :lval => one, :operator => "+", :rval => two
-    operator.evaluate(@scope).should == 3
-  end
-
 end
diff --git a/spec/unit/parser/ast/comparison_operator_spec.rb b/spec/unit/parser/ast/comparison_operator_spec.rb
index 3efe28bb6..060827390 100755
--- a/spec/unit/parser/ast/comparison_operator_spec.rb
+++ b/spec/unit/parser/ast/comparison_operator_spec.rb
@@ -1,116 +1,116 @@
 #!/usr/bin/env ruby
 
 require 'spec_helper'
 
 describe Puppet::Parser::AST::ComparisonOperator do
   before :each do
     @scope = Puppet::Parser::Scope.new
     @one = Puppet::Parser::AST::Leaf.new(:value => "1")
     @two = Puppet::Parser::AST::Leaf.new(:value => "2")
 
     @lval = Puppet::Parser::AST::Leaf.new(:value => "one")
     @rval = Puppet::Parser::AST::Leaf.new(:value => "two")
   end
 
   it "should evaluate both values" do
     @lval.expects(:safeevaluate).with(@scope)
     @rval.expects(:safeevaluate).with(@scope)
 
     operator = Puppet::Parser::AST::ComparisonOperator.new :lval => @lval, :operator => "==", :rval => @rval
     operator.evaluate(@scope)
   end
 
   it "should convert the arguments to numbers if they are numbers in string" do
     Puppet::Parser::Scope.expects(:number?).with("1").returns(1)
     Puppet::Parser::Scope.expects(:number?).with("2").returns(2)
 
     operator = Puppet::Parser::AST::ComparisonOperator.new :lval => @one, :operator => "==", :rval => @two
     operator.evaluate(@scope)
   end
 
   %w{< > <= >=}.each do |oper|
     it "should use string comparison #{oper} if operands are strings" do
       operator = Puppet::Parser::AST::ComparisonOperator.new :lval => @lval, :operator => oper, :rval => @rval
       operator.evaluate(@scope).should == "one".send(oper,"two")
     end
   end
 
   describe "with string comparison" do
     it "should use matching" do
       @rval.expects(:evaluate_match).with("one", @scope)
 
       operator = Puppet::Parser::AST::ComparisonOperator.new :lval => @lval, :operator => "==", :rval => @rval
       operator.evaluate(@scope)
     end
 
     it "should return true for :undef to '' equality" do
       astundef = Puppet::Parser::AST::Leaf.new(:value => :undef)
       empty = Puppet::Parser::AST::Leaf.new(:value => '')
 
       operator = Puppet::Parser::AST::ComparisonOperator.new :lval => astundef, :operator => "==", :rval => empty
       operator.evaluate(@scope).should be_true
     end
 
     [true, false].each do |result|
       it "should return #{(result).inspect} with '==' when matching return #{result.inspect}" do
         @rval.expects(:evaluate_match).with("one", @scope).returns result
 
         operator = Puppet::Parser::AST::ComparisonOperator.new :lval => @lval, :operator => "==", :rval => @rval
         operator.evaluate(@scope).should == result
       end
 
       it "should return #{(!result).inspect} with '!=' when matching return #{result.inspect}" do
         @rval.expects(:evaluate_match).with("one", @scope).returns result
 
         operator = Puppet::Parser::AST::ComparisonOperator.new :lval => @lval, :operator => "!=", :rval => @rval
         operator.evaluate(@scope).should == !result
       end
     end
   end
 
   it "should fail with arguments of different types" do
     operator = Puppet::Parser::AST::ComparisonOperator.new :lval => @one, :operator => ">", :rval => @rval
     lambda { operator.evaluate(@scope) }.should raise_error(ArgumentError)
   end
 
   it "should fail for an unknown operator" do
     lambda { operator = Puppet::Parser::AST::ComparisonOperator.new :lval => @one, :operator => "or", :rval => @two }.should raise_error
   end
 
   %w{< > <= >= ==}.each do |oper|
     it "should return the result of using '#{oper}' to compare the left and right sides" do
       operator = Puppet::Parser::AST::ComparisonOperator.new :lval => @one, :operator => oper, :rval => @two
 
       operator.evaluate(@scope).should == 1.send(oper,2)
     end
   end
 
   it "should return the result of using '!=' to compare the left and right sides" do
     operator = Puppet::Parser::AST::ComparisonOperator.new :lval => @one, :operator => '!=', :rval => @two
 
     operator.evaluate(@scope).should == true
   end
 
   it "should work for variables too" do
     one = Puppet::Parser::AST::Variable.new( :value => "one" )
     two = Puppet::Parser::AST::Variable.new( :value => "two" )
 
-    @scope.expects(:lookupvar).with("one").returns(1)
-    @scope.expects(:lookupvar).with("two").returns(2)
+    one.expects(:safeevaluate).with(@scope).returns(1)
+    two.expects(:safeevaluate).with(@scope).returns(2)
 
     operator = Puppet::Parser::AST::ComparisonOperator.new :lval => one, :operator => "<", :rval => two
     operator.evaluate(@scope).should == true
   end
 
   # see ticket #1759
   %w{< > <= >=}.each do |oper|
     it "should return the correct result of using '#{oper}' to compare 10 and 9" do
       ten = Puppet::Parser::AST::Leaf.new(:value => "10")
       nine = Puppet::Parser::AST::Leaf.new(:value => "9")
       operator = Puppet::Parser::AST::ComparisonOperator.new :lval => ten, :operator => oper, :rval => nine
 
       operator.evaluate(@scope).should == 10.send(oper,9)
     end
   end
 
 end
diff --git a/spec/unit/parser/ast/leaf_spec.rb b/spec/unit/parser/ast/leaf_spec.rb
index 97c996b40..64fdcd659 100755
--- a/spec/unit/parser/ast/leaf_spec.rb
+++ b/spec/unit/parser/ast/leaf_spec.rb
@@ -1,408 +1,413 @@
 #!/usr/bin/env ruby
 
 require 'spec_helper'
 
 describe Puppet::Parser::AST::Leaf do
   before :each do
     @scope = stub 'scope'
     @value = stub 'value'
     @leaf = Puppet::Parser::AST::Leaf.new(:value => @value)
   end
 
   it "should have a evaluate_match method" do
     Puppet::Parser::AST::Leaf.new(:value => "value").should respond_to(:evaluate_match)
   end
 
   describe "when converting to string" do
     it "should transform its value to string" do
       value = stub 'value', :is_a? => true
       value.expects(:to_s)
       Puppet::Parser::AST::Leaf.new( :value => value ).to_s
     end
   end
 
   it "should have a match method" do
     @leaf.should respond_to(:match)
   end
 
   it "should delegate match to ==" do
     @value.expects(:==).with("value")
 
     @leaf.match("value")
   end
 end
 
 describe Puppet::Parser::AST::FlatString do
   describe "when converting to string" do
     it "should transform its value to a quoted string" do
       value = stub 'value', :is_a? => true, :to_s => "ab"
       Puppet::Parser::AST::FlatString.new( :value => value ).to_s.should == "\"ab\""
     end
   end
 end
 
 describe Puppet::Parser::AST::String do
   describe "when converting to string" do
     it "should transform its value to a quoted string" do
       value = stub 'value', :is_a? => true, :to_s => "ab"
       Puppet::Parser::AST::String.new( :value => value ).to_s.should == "\"ab\""
     end
     it "should return a dup of its value" do
       value = ""
       Puppet::Parser::AST::String.new( :value => value ).evaluate(stub('scope')).should_not be_equal(value)
     end
   end
 end
 
 describe Puppet::Parser::AST::Concat do
   describe "when evaluating" do
     before :each do
       @scope = stub_everything 'scope'
     end
     it "should interpolate variables and concatenate their values" do
       one = Puppet::Parser::AST::String.new(:value => "one")
       one.stubs(:evaluate).returns("one ")
       two = Puppet::Parser::AST::String.new(:value => "two")
       two.stubs(:evaluate).returns(" two ")
       three = Puppet::Parser::AST::String.new(:value => "three")
       three.stubs(:evaluate).returns(" three")
       var = Puppet::Parser::AST::Variable.new(:value => "myvar")
       var.stubs(:evaluate).returns("foo")
       array = Puppet::Parser::AST::Variable.new(:value => "array")
       array.stubs(:evaluate).returns(["bar","baz"])
       concat = Puppet::Parser::AST::Concat.new(:value => [one,var,two,array,three])
 
       concat.evaluate(@scope).should == 'one foo two barbaz three'
     end
 
     it "should transform undef variables to empty string" do
       var = Puppet::Parser::AST::Variable.new(:value => "myvar")
       var.stubs(:evaluate).returns(:undef)
       concat = Puppet::Parser::AST::Concat.new(:value => [var])
 
       concat.evaluate(@scope).should == ''
     end
   end
 end
 
 describe Puppet::Parser::AST::Undef do
   before :each do
     @scope = stub 'scope'
     @undef = Puppet::Parser::AST::Undef.new(:value => :undef)
   end
 
   it "should match undef with undef" do
     @undef.evaluate_match(:undef, @scope).should be_true
   end
 
   it "should not match undef with an empty string" do
     @undef.evaluate_match("", @scope).should be_false
   end
 end
 
 describe Puppet::Parser::AST::HashOrArrayAccess do
   before :each do
     @scope = stub 'scope'
   end
 
   describe "when evaluating" do
     it "should evaluate the variable part if necessary" do
-      @scope.stubs(:lookupvar).with("a").returns(["b"])
+      @scope.stubs(:lookupvar).with { |name,options| name == 'a'}.returns(["b"])
 
       variable = stub 'variable', :evaluate => "a"
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => variable, :key => 0 )
 
       variable.expects(:safeevaluate).with(@scope).returns("a")
 
       access.evaluate(@scope).should == "b"
     end
 
     it "should evaluate the access key part if necessary" do
-      @scope.stubs(:lookupvar).with("a").returns(["b"])
+      @scope.stubs(:lookupvar).with { |name,options| name == 'a'}.returns(["b"])
 
       index = stub 'index', :evaluate => 0
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => index )
 
       index.expects(:safeevaluate).with(@scope).returns(0)
 
       access.evaluate(@scope).should == "b"
     end
 
     it "should be able to return an array member" do
-      @scope.stubs(:lookupvar).with("a").returns(["val1", "val2", "val3"])
+      @scope.stubs(:lookupvar).with { |name,options| name == 'a'}.returns(["val1", "val2", "val3"])
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => 1 )
 
       access.evaluate(@scope).should == "val2"
     end
 
     it "should be able to return an array member when index is a stringified number" do
       @scope.stubs(:lookupvar).with("a").returns(["val1", "val2", "val3"])
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "1" )
 
       access.evaluate(@scope).should == "val2"
     end
 
     it "should raise an error when accessing an array with a key" do
       @scope.stubs(:lookupvar).with("a").returns(["val1", "val2", "val3"])
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "get_me_the_second_element_please" )
 
       lambda { access.evaluate(@scope) }.should raise_error
     end
 
     it "should be able to return an hash value" do
-      @scope.stubs(:lookupvar).with("a").returns({ "key1" => "val1", "key2" => "val2", "key3" => "val3" })
+      @scope.stubs(:lookupvar).with { |name,options| name == 'a'}.returns({ "key1" => "val1", "key2" => "val2", "key3" => "val3" })
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key2" )
 
       access.evaluate(@scope).should == "val2"
     end
 
     it "should be able to return an hash value with a numerical key" do
       @scope.stubs(:lookupvar).with("a").returns({ "key1" => "val1", "key2" => "val2", "45" => "45", "key3" => "val3" })
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "45" )
 
       access.evaluate(@scope).should == "45"
     end
 
     it "should raise an error if the variable lookup didn't return an hash or an array" do
       @scope.stubs(:lookupvar).with("a").returns("I'm a string")
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key2" )
 
       lambda { access.evaluate(@scope) }.should raise_error
     end
 
     it "should raise an error if the variable wasn't in the scope" do
-      @scope.stubs(:lookupvar).with("a").returns(nil)
+      @scope.stubs(:lookupvar).with { |name,options| name == 'a'}.returns(nil)
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key2" )
 
       lambda { access.evaluate(@scope) }.should raise_error
     end
 
     it "should return a correct string representation" do
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key2" )
       access.to_s.should == '$a[key2]'
     end
 
     it "should work with recursive hash access" do
-      @scope.stubs(:lookupvar).with("a").returns({ "key" => { "subkey" => "b" }})
+      @scope.stubs(:lookupvar).with { |name,options| name == 'a'}.returns({ "key" => { "subkey" => "b" }})
 
       access1 = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key")
       access2 = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => access1, :key => "subkey")
 
       access2.evaluate(@scope).should == 'b'
     end
 
     it "should work with interleaved array and hash access" do
-      @scope.stubs(:lookupvar).with("a").returns({ "key" => [ "a" , "b" ]})
+      @scope.stubs(:lookupvar).with { |name,options| name == 'a'}.returns({ "key" => [ "a" , "b" ]})
 
       access1 = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key")
       access2 = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => access1, :key => 1)
 
       access2.evaluate(@scope).should == 'b'
     end
   end
 
   describe "when assigning" do
     it "should add a new key and value" do
       scope = Puppet::Parser::Scope.new
       scope.setvar("a", { 'a' => 'b' })
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "b")
       access.assign(scope, "c" )
 
       scope.lookupvar("a").should be_include("b")
     end
 
     it "should raise an error when assigning an array element with a key" do
       @scope.stubs(:lookupvar).with("a").returns([])
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "get_me_the_second_element_please" )
 
       lambda { access.assign(@scope, "test") }.should raise_error
     end
 
     it "should be able to return an array member when index is a stringified number" do
       scope = Puppet::Parser::Scope.new
       scope.setvar("a", [])
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "0" )
 
       access.assign(scope, "val2")
       scope.lookupvar("a").should == ["val2"]
     end
 
     it "should raise an error when trying to overwrite an hash value" do
       @scope.stubs(:lookupvar).with("a").returns({ "key" => [ "a" , "b" ]})
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key")
 
       lambda { access.assign(@scope, "test") }.should raise_error
     end
   end
 end
 
 describe Puppet::Parser::AST::Regex do
   before :each do
     @scope = stub 'scope'
   end
 
   describe "when initializing" do
     it "should create a Regexp with its content when value is not a Regexp" do
       Regexp.expects(:new).with("/ab/")
 
       Puppet::Parser::AST::Regex.new :value => "/ab/"
     end
 
     it "should not create a Regexp with its content when value is a Regexp" do
       value = Regexp.new("/ab/")
       Regexp.expects(:new).with("/ab/").never
 
       Puppet::Parser::AST::Regex.new :value => value
     end
   end
 
   describe "when evaluating" do
     it "should return self" do
       val = Puppet::Parser::AST::Regex.new :value => "/ab/"
 
       val.evaluate(@scope).should === val
     end
   end
 
   describe "when evaluate_match" do
     before :each do
       @value = stub 'regex'
       @value.stubs(:match).with("value").returns(true)
       Regexp.stubs(:new).returns(@value)
       @regex = Puppet::Parser::AST::Regex.new :value => "/ab/"
     end
 
     it "should issue the regexp match" do
       @value.expects(:match).with("value")
 
       @regex.evaluate_match("value", @scope)
     end
 
     it "should not downcase the paramater value" do
       @value.expects(:match).with("VaLuE")
 
       @regex.evaluate_match("VaLuE", @scope)
     end
 
     it "should set ephemeral scope vars if there is a match" do
       @scope.expects(:ephemeral_from).with(true, nil, nil)
 
       @regex.evaluate_match("value", @scope)
     end
 
     it "should return the match to the caller" do
       @value.stubs(:match).with("value").returns(:match)
       @scope.stubs(:ephemeral_from)
 
       @regex.evaluate_match("value", @scope)
     end
   end
 
   it "should return the regex source with to_s" do
     regex = stub 'regex'
     Regexp.stubs(:new).returns(regex)
 
     val = Puppet::Parser::AST::Regex.new :value => "/ab/"
 
     regex.expects(:source)
 
     val.to_s
   end
 
   it "should delegate match to the underlying regexp match method" do
     regex = Regexp.new("/ab/")
     val = Puppet::Parser::AST::Regex.new :value => regex
 
     regex.expects(:match).with("value")
 
     val.match("value")
   end
 end
 
 describe Puppet::Parser::AST::Variable do
   before :each do
     @scope = stub 'scope'
-    @var = Puppet::Parser::AST::Variable.new(:value => "myvar")
+    @var = Puppet::Parser::AST::Variable.new(:value => "myvar", :file => 'my.pp', :line => 222)
   end
 
   it "should lookup the variable in scope" do
-    @scope.expects(:lookupvar).with("myvar").returns(:myvalue)
+    @scope.expects(:lookupvar).with { |name,options| name == "myvar" }.returns(:myvalue)
+    @var.safeevaluate(@scope).should == :myvalue
+  end
+
+  it "should pass the source location to lookupvar" do
+    @scope.expects(:lookupvar).with { |name,options| name == "myvar" and options[:file] == 'my.pp' and options[:line] == 222 }.returns(:myvalue)
     @var.safeevaluate(@scope).should == :myvalue
   end
 
   it "should return undef if the variable wasn't set" do
-    @scope.expects(:lookupvar).with("myvar").returns(:undefined)
+    @scope.expects(:lookupvar).with { |name,options| name == "myvar" }.returns(:undefined)
     @var.safeevaluate(@scope).should == :undef
   end
 
   describe "when converting to string" do
     it "should transform its value to a variable" do
       value = stub 'value', :is_a? => true, :to_s => "myvar"
       Puppet::Parser::AST::Variable.new( :value => value ).to_s.should == "\$myvar"
     end
   end
 end
 
 describe Puppet::Parser::AST::HostName do
   before :each do
     @scope = stub 'scope'
     @value = stub 'value', :=~ => false
     @value.stubs(:to_s).returns(@value)
     @value.stubs(:downcase).returns(@value)
     @host = Puppet::Parser::AST::HostName.new( :value => @value)
   end
 
   it "should raise an error if hostname is not valid" do
     lambda { Puppet::Parser::AST::HostName.new( :value => "not an hostname!" ) }.should raise_error
   end
 
   it "should not raise an error if hostname is a regex" do
     lambda { Puppet::Parser::AST::HostName.new( :value => Puppet::Parser::AST::Regex.new(:value => "/test/") ) }.should_not raise_error
   end
 
   it "should stringify the value" do
     value = stub 'value', :=~ => false
 
     value.expects(:to_s).returns("test")
 
     Puppet::Parser::AST::HostName.new(:value => value)
   end
 
   it "should downcase the value" do
     value = stub 'value', :=~ => false
     value.stubs(:to_s).returns("UPCASED")
     host = Puppet::Parser::AST::HostName.new(:value => value)
 
     host.value == "upcased"
   end
 
   it "should evaluate to its value" do
     @host.evaluate(@scope).should == @value
   end
 
   it "should delegate eql? to the underlying value if it is an HostName" do
     @value.expects(:eql?).with("value")
     @host.eql?("value")
   end
 
   it "should delegate eql? to the underlying value if it is not an HostName" do
     value = stub 'compared', :is_a? => true, :value => "value"
     @value.expects(:eql?).with("value")
     @host.eql?(value)
   end
 
   it "should delegate hash to the underlying value" do
     @value.expects(:hash)
     @host.hash
   end
 end
diff --git a/spec/unit/parser/ast/vardef_spec.rb b/spec/unit/parser/ast/vardef_spec.rb
index a462e8ef5..5a851bb13 100755
--- a/spec/unit/parser/ast/vardef_spec.rb
+++ b/spec/unit/parser/ast/vardef_spec.rb
@@ -1,60 +1,67 @@
 #!/usr/bin/env ruby
 
 require 'spec_helper'
 
 describe Puppet::Parser::AST::VarDef do
   before :each do
     @scope = Puppet::Parser::Scope.new
   end
 
   describe "when evaluating" do
 
     it "should evaluate arguments" do
       name = mock 'name'
       value = mock 'value'
 
       name.expects(:safeevaluate).with(@scope)
       value.expects(:safeevaluate).with(@scope)
 
-      vardef = Puppet::Parser::AST::VarDef.new :name => name, :value => value, :file => nil,
-        :line => nil
+      vardef = Puppet::Parser::AST::VarDef.new :name => name, :value => value, :file => nil, :line => nil
       vardef.evaluate(@scope)
     end
 
     it "should be in append=false mode if called without append" do
       name = stub 'name', :safeevaluate => "var"
       value = stub 'value', :safeevaluate => "1"
 
       @scope.expects(:setvar).with { |name,value,options| options[:append] == nil }
 
-      vardef = Puppet::Parser::AST::VarDef.new :name => name, :value => value, :file => nil,
-        :line => nil
+      vardef = Puppet::Parser::AST::VarDef.new :name => name, :value => value, :file => nil, :line => nil
       vardef.evaluate(@scope)
     end
 
     it "should call scope in append mode if append is true" do
       name = stub 'name', :safeevaluate => "var"
       value = stub 'value', :safeevaluate => "1"
 
       @scope.expects(:setvar).with { |name,value,options| options[:append] == true }
 
-      vardef = Puppet::Parser::AST::VarDef.new :name => name, :value => value, :file => nil,
-        :line => nil, :append => true
+      vardef = Puppet::Parser::AST::VarDef.new :name => name, :value => value, :file => nil, :line => nil, :append => true
+      vardef.evaluate(@scope)
+    end
+
+    it "should call pass the source location to setvar" do
+      name = stub 'name', :safeevaluate => "var"
+      value = stub 'value', :safeevaluate => "1"
+
+      @scope.expects(:setvar).with { |name,value,options| options[:file] == 'setvar.pp' and options[:line] == 917 }
+
+      vardef = Puppet::Parser::AST::VarDef.new :name => name, :value => value, :file => 'setvar.pp', :line => 917
       vardef.evaluate(@scope)
     end
 
     describe "when dealing with hash" do
       it "should delegate to the HashOrArrayAccess assign" do
         access = stub 'name'
         access.stubs(:is_a?).with(Puppet::Parser::AST::HashOrArrayAccess).returns(true)
         value = stub 'value', :safeevaluate => "1"
         vardef = Puppet::Parser::AST::VarDef.new :name => access, :value => value, :file => nil, :line => nil
 
         access.expects(:assign).with(@scope, '1')
 
         vardef.evaluate(@scope)
       end
     end
 
   end
 end
diff --git a/spec/unit/parser/templatewrapper_spec.rb b/spec/unit/parser/templatewrapper_spec.rb
index 4a713b8a8..0c7199ba1 100755
--- a/spec/unit/parser/templatewrapper_spec.rb
+++ b/spec/unit/parser/templatewrapper_spec.rb
@@ -1,145 +1,143 @@
 #!/usr/bin/env ruby
 
 require 'spec_helper'
 require 'puppet/parser/templatewrapper'
 
 describe Puppet::Parser::TemplateWrapper do
   before(:each) do
     @known_resource_types = Puppet::Resource::TypeCollection.new("env")
     @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
     @compiler.environment.stubs(:known_resource_types).returns @known_resource_types
     @scope = Puppet::Parser::Scope.new :compiler => @compiler
 
     @file = "fake_template"
     Puppet::Parser::Files.stubs(:find_template).returns("/tmp/fake_template")
     FileTest.stubs(:exists?).returns("true")
     File.stubs(:read).with("/tmp/fake_template").returns("template content")
     @tw = Puppet::Parser::TemplateWrapper.new(@scope)
   end
 
+  def mock_template(source=nil)
+    template_mock = mock("template", :result => "woot!")
+    ERB.expects(:new).with("template contents", 0, "-").returns(template_mock)
+    template_mock.expects(:filename=).with(source)
+  end
+
   it "should create a new object TemplateWrapper from a scope" do
     tw = Puppet::Parser::TemplateWrapper.new(@scope)
 
     tw.should be_a_kind_of(Puppet::Parser::TemplateWrapper)
   end
 
   it "should check template file existance and read its content" do
     Puppet::Parser::Files.expects(:find_template).with("fake_template", @scope.environment.to_s).returns("/tmp/fake_template")
     File.expects(:read).with("/tmp/fake_template").returns("template content")
 
     @tw.file = @file
   end
 
   it "should mark the file for watching" do
     Puppet::Parser::Files.expects(:find_template).returns("/tmp/fake_template")
     File.stubs(:read)
 
     @known_resource_types.expects(:watch_file).with("/tmp/fake_template")
     @tw.file = @file
   end
 
   it "should fail if a template cannot be found" do
     Puppet::Parser::Files.expects(:find_template).returns nil
 
     lambda { @tw.file = @file }.should raise_error(Puppet::ParseError)
   end
 
   it "should turn into a string like template[name] for file based template" do
     @tw.file = @file
     @tw.to_s.should eql("template[/tmp/fake_template]")
   end
 
   it "should turn into a string like template[inline] for string-based template" do
     @tw.to_s.should eql("template[inline]")
   end
 
   it "should return the processed template contents with a call to result" do
-    template_mock = mock("template", :result => "woot!")
+    mock_template("/tmp/fake_template")
     File.expects(:read).with("/tmp/fake_template").returns("template contents")
-    ERB.expects(:new).with("template contents", 0, "-").returns(template_mock)
 
     @tw.file = @file
     @tw.result.should eql("woot!")
   end
 
   it "should return the processed template contents with a call to result and a string" do
-    template_mock = mock("template", :result => "woot!")
-    ERB.expects(:new).with("template contents", 0, "-").returns(template_mock)
-
+    mock_template
     @tw.result("template contents").should eql("woot!")
   end
 
   it "should return the contents of a variable if called via method_missing" do
-    @scope.expects(:lookupvar).with("chicken").returns("is good")
+    @scope.expects(:lookupvar).with { |name,options| name == "chicken"}.returns("is good")
     tw = Puppet::Parser::TemplateWrapper.new(@scope)
     tw.chicken.should eql("is good")
   end
 
   it "should throw an exception if a variable is called via method_missing and it does not exist" do
-    @scope.expects(:lookupvar).with("chicken").returns(:undefined)
+    @scope.expects(:lookupvar).with { |name,options| name == "chicken"}.returns(:undefined)
     tw = Puppet::Parser::TemplateWrapper.new(@scope)
     lambda { tw.chicken }.should raise_error(Puppet::ParseError)
   end
 
   it "should allow you to check whether a variable is defined with has_variable?" do
-    @scope.expects(:lookupvar).with("chicken").returns("is good")
+    @scope.expects(:lookupvar).with { |name,options| name == "chicken"}.returns("is good")
     tw = Puppet::Parser::TemplateWrapper.new(@scope)
     tw.has_variable?("chicken").should eql(true)
   end
 
   it "should allow you to check whether a variable is not defined with has_variable?" do
-    @scope.expects(:lookupvar).with("chicken").returns(:undefined)
+    @scope.expects(:lookupvar).with { |name,options| name == "chicken"}.returns(:undefined)
     tw = Puppet::Parser::TemplateWrapper.new(@scope)
     tw.has_variable?("chicken").should eql(false)
   end
 
   it "should allow you to retrieve the defined classes with classes" do
     catalog = mock 'catalog', :classes => ["class1", "class2"]
     @scope.expects(:catalog).returns( catalog )
     tw = Puppet::Parser::TemplateWrapper.new(@scope)
     tw.classes.should == ["class1", "class2"]
   end
 
   it "should allow you to retrieve all the tags with all_tags" do
     catalog = mock 'catalog', :tags => ["tag1", "tag2"]
     @scope.expects(:catalog).returns( catalog )
     tw = Puppet::Parser::TemplateWrapper.new(@scope)
     tw.all_tags.should == ["tag1","tag2"]
   end
 
   it "should allow you to retrieve the tags defined in the current scope" do
     @scope.expects(:tags).returns( ["tag1", "tag2"] )
     tw = Puppet::Parser::TemplateWrapper.new(@scope)
     tw.tags.should == ["tag1","tag2"]
   end
 
   it "should set all of the scope's variables as instance variables" do
-    template_mock = mock("template", :result => "woot!")
-    ERB.expects(:new).with("template contents", 0, "-").returns(template_mock)
-
+    mock_template
     @scope.expects(:to_hash).returns("one" => "foo")
     @tw.result("template contents")
 
     @tw.instance_variable_get("@one").should == "foo"
   end
 
   it "should not error out if one of the variables is a symbol" do
-    template_mock = mock("template", :result => "woot!")
-    ERB.expects(:new).with("template contents", 0, "-").returns(template_mock)
+    mock_template
 
     @scope.expects(:to_hash).returns(:_timestamp => "1234")
     @tw.result("template contents")
   end
 
   %w{! . ; :}.each do |badchar|
     it "should translate #{badchar} to _ when setting the instance variables" do
-    template_mock = mock("template", :result => "woot!")
-    ERB.expects(:new).with("template contents", 0, "-").returns(template_mock)
-
-    @scope.expects(:to_hash).returns("one#{badchar}" => "foo")
-    @tw.result("template contents")
+      mock_template
+      @scope.expects(:to_hash).returns("one#{badchar}" => "foo")
+      @tw.result("template contents")
 
-    @tw.instance_variable_get("@one_").should == "foo"
-  end
+      @tw.instance_variable_get("@one_").should == "foo"
+    end
   end
 end