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.
