diff --git a/include/clang/Lex/Lexer.h b/include/clang/Lex/Lexer.h
index 77399e6..4ca1114 100644
--- a/include/clang/Lex/Lexer.h
+++ b/include/clang/Lex/Lexer.h
@@ -177,6 +177,10 @@
   /// getSourceLocation - Return a source location identifier for the specified
   /// offset in the current file.
   SourceLocation getSourceLocation(const char *Loc) const;
+    
+  /// getSourceLocation - Return a source location for the next character in
+  /// the current file.
+  SourceLocation getSourceLocation() { return getSourceLocation(BufferPtr); }
   
   /// Stringify - Convert the specified string into a C string by escaping '\'
   /// and " characters.  This does not add surrounding ""'s to the string.
diff --git a/include/clang/Lex/PTHLexer.h b/include/clang/Lex/PTHLexer.h
index 7f6ae53..a1d41b5 100644
--- a/include/clang/Lex/PTHLexer.h
+++ b/include/clang/Lex/PTHLexer.h
@@ -69,6 +69,10 @@
   ///  the PreprocessorLexer interface.
   void IndirectLex(Token &Result) { Lex(Result); }
   
+  /// getSourceLocation - Return a source location for the token in
+  /// the current file.
+  SourceLocation getSourceLocation() { return GetToken().getLocation(); }
+
 private:
   
   /// AtLastToken - Returns true if the PTHLexer is at the last token.
diff --git a/include/clang/Lex/PreprocessorLexer.h b/include/clang/Lex/PreprocessorLexer.h
index e178d27..a889a55 100644
--- a/include/clang/Lex/PreprocessorLexer.h
+++ b/include/clang/Lex/PreprocessorLexer.h
@@ -79,6 +79,10 @@
   
   virtual void IndirectLex(Token& Result) = 0;
   
+  /// getSourceLocation - Return the source location for the next observable
+  ///  location.
+  virtual SourceLocation getSourceLocation() = 0;
+  
   //===--------------------------------------------------------------------===//
   // #if directive handling.
   
diff --git a/lib/Lex/PPLexerChange.cpp b/lib/Lex/PPLexerChange.cpp
index bb2536d..cd50f0e 100644
--- a/lib/Lex/PPLexerChange.cpp
+++ b/lib/Lex/PPLexerChange.cpp
@@ -275,16 +275,8 @@
     if (Callbacks && !isEndOfMacro && CurPPLexer) {
       SrcMgr::CharacteristicKind FileType =
         SourceMgr.getFileCharacteristic(CurPPLexer->getFileID());
-
-      if (CurLexer) {
-        Callbacks->FileChanged(CurLexer->getSourceLocation(CurLexer->BufferPtr),
-                               PPCallbacks::ExitFile, FileType);
-      }
-      else {
-        // FIXME: Is this okay to use the location of 'Result'?
-        Callbacks->FileChanged(Result.getLocation(), PPCallbacks::ExitFile,
-                               FileType);  
-      }
+        Callbacks->FileChanged(CurPPLexer->getSourceLocation(),
+                               PPCallbacks::ExitFile, FileType); 
     }
 
     // Client should lex another token.
