diff --git a/lib/puppet/parser/ast/function.rb b/lib/puppet/parser/ast/function.rb
index 74023f631..80e6e6512 100644
--- a/lib/puppet/parser/ast/function.rb
+++ b/lib/puppet/parser/ast/function.rb
@@ -1,50 +1,50 @@
 require 'puppet/parser/ast/branch'
 
 class Puppet::Parser::AST
   # An AST object to call a function.
   class Function < AST::Branch
 
     associates_doc
 
     attr_accessor :name, :arguments
 
     @settor = true
 
     def evaluate(scope)
       # Make sure it's a defined function
       raise Puppet::ParseError, "Unknown function #{@name}" unless Puppet::Parser::Functions.function(@name)
 
       # Now check that it's been used correctly
       case @ftype
       when :rvalue
         raise Puppet::ParseError, "Function '#{@name}' does not return a value" unless Puppet::Parser::Functions.rvalue?(@name)
       when :statement
         if Puppet::Parser::Functions.rvalue?(@name)
           raise Puppet::ParseError,
             "Function '#{@name}' must be the value of a statement"
         end
       else
         raise Puppet::DevError, "Invalid function type #{@ftype.inspect}"
       end
 
       # We don't need to evaluate the name, because it's plaintext
-      args = @arguments.safeevaluate(scope)
+      args = @arguments.safeevaluate(scope).map { |x| x == :undef ? '' : x }
 
       scope.send("function_#{@name}", args)
     end
 
     def initialize(hash)
       @ftype = hash[:ftype] || :rvalue
       hash.delete(:ftype) if hash.include? :ftype
 
       super(hash)
 
       # Lastly, check the parity
     end
 
     def to_s
       args = arguments.is_a?(ASTArray) ? arguments.to_s.gsub(/\[(.*)\]/,'\1') : arguments
       "#{name}(#{args})"
     end
   end
 end
diff --git a/spec/unit/parser/ast/function_spec.rb b/spec/unit/parser/ast/function_spec.rb
index c57c7f098..38e344157 100644
--- a/spec/unit/parser/ast/function_spec.rb
+++ b/spec/unit/parser/ast/function_spec.rb
@@ -1,83 +1,93 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../../spec_helper'
 
 describe Puppet::Parser::AST::Function do
   before :each do
     @scope = mock 'scope'
   end
 
   describe "when initializing" do
     it "should not fail if the function doesn't exist" do
       Puppet::Parser::Functions.stubs(:function).returns(false)
 
       lambda{ Puppet::Parser::AST::Function.new :name => "dontexist" }.should_not raise_error(Puppet::ParseError)
 
     end
   end
 
   it "should return its representation with to_s" do
     args = stub 'args', :is_a? => true, :to_s => "[a, b]"
 
     Puppet::Parser::AST::Function.new(:name => "func", :arguments => args).to_s.should == "func(a, b)"
   end
 
   describe "when evaluating" do
 
     it "should fail if the function doesn't exist" do
       Puppet::Parser::Functions.stubs(:function).returns(false)
       func = Puppet::Parser::AST::Function.new :name => "dontexist"
 
       lambda{ func.evaluate(@scope) }.should raise_error(Puppet::ParseError)
     end
 
     it "should fail if the function is a statement used as rvalue" do
       Puppet::Parser::Functions.stubs(:function).with("exist").returns(true)
       Puppet::Parser::Functions.stubs(:rvalue?).with("exist").returns(false)
 
       func = Puppet::Parser::AST::Function.new :name => "exist", :ftype => :rvalue
 
       lambda{ func.evaluate(@scope) }.should raise_error(Puppet::ParseError, "Function 'exist' does not return a value")
     end
 
     it "should fail if the function is an rvalue used as statement" do
       Puppet::Parser::Functions.stubs(:function).with("exist").returns(true)
       Puppet::Parser::Functions.stubs(:rvalue?).with("exist").returns(true)
 
       func = Puppet::Parser::AST::Function.new :name => "exist", :ftype => :statement
 
       lambda{ func.evaluate(@scope) }.should raise_error(Puppet::ParseError,"Function 'exist' must be the value of a statement")
     end
 
     it "should evaluate its arguments" do
       argument = stub 'arg'
       Puppet::Parser::Functions.stubs(:function).with("exist").returns(true)
       func = Puppet::Parser::AST::Function.new :name => "exist", :ftype => :statement, :arguments => argument
       @scope.stubs(:function_exist)
 
       argument.expects(:safeevaluate).with(@scope).returns("argument")
 
       func.evaluate(@scope)
     end
 
     it "should call the underlying ruby function" do
-      argument = stub 'arg', :safeevaluate => "nothing"
+      argument = stub 'arg', :safeevaluate => ["nothing"]
       Puppet::Parser::Functions.stubs(:function).with("exist").returns(true)
       func = Puppet::Parser::AST::Function.new :name => "exist", :ftype => :statement, :arguments => argument
 
-      @scope.expects(:function_exist).with("nothing")
+      @scope.expects(:function_exist).with(["nothing"])
+
+      func.evaluate(@scope)
+    end
+
+    it "should convert :undef to '' in arguments" do
+      argument = stub 'arg', :safeevaluate => ["foo", :undef, "bar"]
+      Puppet::Parser::Functions.stubs(:function).with("exist").returns(true)
+      func = Puppet::Parser::AST::Function.new :name => "exist", :ftype => :statement, :arguments => argument
+
+      @scope.expects(:function_exist).with(["foo", "", "bar"])
 
       func.evaluate(@scope)
     end
 
     it "should return the ruby function return for rvalue functions" do
-      argument = stub 'arg', :safeevaluate => "nothing"
+      argument = stub 'arg', :safeevaluate => ["nothing"]
       Puppet::Parser::Functions.stubs(:function).with("exist").returns(true)
       func = Puppet::Parser::AST::Function.new :name => "exist", :ftype => :statement, :arguments => argument
-      @scope.stubs(:function_exist).with("nothing").returns("returning")
+      @scope.stubs(:function_exist).with(["nothing"]).returns("returning")
 
       func.evaluate(@scope).should == "returning"
     end
 
   end
 end