Fix source loc for tokens that immediately follow an escaped newline

[bmoody]

Summary

Previously the location of a token immediately following an escaped newline was the location of the backslash character in the escaped newline.

The change to test/SemaTemplate/instantiation-depth.cpp is to work around a side-effect of this fix - the expected-error comment was getting the location of the backslash on the previous line before. I added the extra slashes so that the comment starts on the correct line.

lib/Lex/Lexer.cpp

if ((*CurPtr == ' ') || (*CurPtr == '\t')) {
     BufferPtr = CurPtr;
     Result.setFlag(Token::LeadingSpace);
   }
 
   unsigned SizeTmp, SizeTmp2;   // Temporaries for use in cases below.
 
   // Read a character, advancing over it.
   char Char = getAndAdvanceChar(CurPtr, Result);
+
+  // If we had to skip over an escaped newline to get this character then
+  // update BufferPtr to point to the character we got, instead of pointing
+  // at the backslash. This fixes the source location for tokens that
+  // immediately follow an escaped newline.
+  if (!isKeepWhitespaceMode() &&
+      Result.needsCleaning() && CurPtr[-1] == Char) {
+    Result.clearFlag(Token::NeedsCleaning);
+    BufferPtr = CurPtr - 1;
+  }
+
   tok::TokenKind Kind;
 
   switch (Char) {
   case 0:  // Null.
     // Found end of file?
     if (CurPtr-1 == BufferEnd)
       return LexEndOfFile(Result, CurPtr-1);
 

test/Misc/escaped-newline-loc.c

+// RUN: %clang_cc1 %s -fsyntax-only -verify -Wno-backslash-newline-escape
+
+// Test that the location of a token that immediately follows an escaped
+// newline is correct, and doesn't point to the backslash
+
+void f() {
+  \
+error1; // expected-error {{use of undeclared identifier 'error1'}}
+
+  // Escaped newline with space
+  \ 
+error2; // expected-error {{use of undeclared identifier 'error2'}}
+
+  // Escaped newline with two spaces
+  \  
+error3; // expected-error {{use of undeclared identifier 'error3'}}
+}

test/SemaTemplate/instantiation-depth.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -ftemplate-depth 5 -ftemplate-backtrace-limit 4 %s
 // RUN: %clang -fsyntax-only -Xclang -verify -ftemplate-depth-5 -ftemplate-backtrace-limit=4 %s
 // RUN: %clang -fsyntax-only -Xclang -verify -ftemplate-depth=5 -ftemplate-backtrace-limit=4 %s
 
 #ifndef NOEXCEPT
 
-template<typename T> struct X : X<T*> { }; \
+template<typename T> struct X : X<T*> { }; // \
 // expected-error{{recursive template instantiation exceeded maximum depth of 5}} \
 // expected-note 3 {{instantiation of template class}} \
 // expected-note {{skipping 2 contexts in backtrace}} \
 // expected-note {{use -ftemplate-depth=N to increase recursive template instantiation depth}}
 
 void test() {
   (void)sizeof(X<int>); // expected-note {{instantiation of template class}}
 }
 
 #else
 
 // RUN: %clang_cc1 -fsyntax-only -verify -ftemplate-depth 5 -ftemplate-backtrace-limit 4 -std=c++11 -DNOEXCEPT %s
 
 template<typename T> struct S {
-  S() noexcept(noexcept(S<S>())); \
+  S() noexcept(noexcept(S<S>())); // \
 // expected-error{{recursive template instantiation exceeded maximum depth of 5}} \
 // expected-note 3 {{in instantiation of exception spec}} \
 // expected-note {{skipping 2 contexts in backtrace}} \
 // expected-note {{use -ftemplate-depth=N to increase recursive template instantiation depth}}
 };
 S<void> t; // expected-note {{in instantiation of exception spec}}
 
 #endif