[clang][NFC] Expand some `auto`s and add another test for matcher `isExpandedFromMacro`.

[ymandel]

Summary

Spells out some autos explicitly and adds another test for the matcher isExpandedFromMacro.

[aaron.ballman]

LGTM, thank you!

clang/include/clang/ASTMatchers/ASTMatchers.h

 /// appearances of the macro.
 ///
 /// FIXME: Change to be a polymorphic matcher that works on any syntactic
 /// node. There's nothing `Stmt`-specific about it.
 AST_MATCHER_P(clang::Stmt, isExpandedFromMacro, llvm::StringRef, MacroName) {
   // Verifies that the statement' beginning and ending are both expanded from
   // the same instance of the given macro.
   auto& Context = Finder->getASTContext();
-  auto B =
+  llvm::Optional<SourceLocation> B =
       internal::getExpansionLocOfMacro(MacroName, Node.getBeginLoc(), Context);
   if (!B) return false;
-  auto E =
+  llvm::Optional<SourceLocation> E =
       internal::getExpansionLocOfMacro(MacroName, Node.getEndLoc(), Context);
   if (!E) return false;
   return *B == *E;
 }
 
 /// Matches declarations.
 ///
 /// Examples matches \c X, \c C, and the friend declaration inside \c C;

clang/lib/ASTMatchers/ASTMatchersInternal.cpp

 
 // Checks whether \p Loc points to a token with source text of \p TokenText.
 static bool isTokenAtLoc(const SourceManager &SM, const LangOptions &LangOpts,
                          StringRef Text, SourceLocation Loc) {
   llvm::SmallString<16> Buffer;
   bool Invalid = false;
   // Since `Loc` may point into an expansion buffer, which has no corresponding
   // source, we need to look at the spelling location to read the actual source.
-  StringRef TokenText = clang::Lexer::getSpelling(
-      SM.getSpellingLoc(Loc), Buffer, SM, LangOpts, &Invalid);
+  StringRef TokenText = Lexer::getSpelling(SM.getSpellingLoc(Loc), Buffer, SM,
+                                           LangOpts, &Invalid);
   return !Invalid && Text == TokenText;
 }
 
 llvm::Optional<SourceLocation>
 getExpansionLocOfMacro(StringRef MacroName, SourceLocation Loc,
                        const ASTContext &Context) {
-  auto& SM = Context.getSourceManager();
-  const auto& LangOpts = Context.getLangOpts();
+  auto &SM = Context.getSourceManager();
+  const LangOptions &LangOpts = Context.getLangOpts();
   while (Loc.isMacroID()) {
-    auto Expansion = SM.getSLocEntry(SM.getFileID(Loc)).getExpansion();
+    SrcMgr::ExpansionInfo Expansion =
+        SM.getSLocEntry(SM.getFileID(Loc)).getExpansion();
     if (Expansion.isMacroArgExpansion())
       // Check macro argument for an expansion of the given macro. For example,
       // `F(G(3))`, where `MacroName` is `G`.
-      if (auto ArgLoc = getExpansionLocOfMacro(
+      if (llvm::Optional<SourceLocation> ArgLoc = getExpansionLocOfMacro(
               MacroName, Expansion.getSpellingLoc(), Context))
         return ArgLoc;
     Loc = Expansion.getExpansionLocStart();
     if (isTokenAtLoc(SM, LangOpts, MacroName, Loc))
       return Loc;
   }
   return llvm::None;
 }

clang/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp

 #define PLUS (2 + 2)
     void Test() {
       PLUS;
     }
   )cc";
   EXPECT_TRUE(matches(input, binaryOperator(isExpandedFromMacro("PLUS"))));
 }
 
+TEST(IsExpandedFromMacro, ShouldMatchFromCommandLine) {
+  std::string input = R"cc(
+    void Test() { FOUR_PLUS_FOUR; }
+  )cc";
+  EXPECT_TRUE(matchesConditionally(input,
+                                   binaryOperator(isExpandedFromMacro("FOUR_PLUS_FOUR")),
+                                   true, {"-std=c++11", "-DFOUR_PLUS_FOUR=4+4"}));
+}
+
 TEST(IsExpandedFromMacro, ShouldNotMatchBeginOnly) {
   std::string input = R"cc(
 #define ONE_PLUS 1+
   void Test() { ONE_PLUS 4; }
   )cc";
   EXPECT_TRUE(
       notMatches(input, binaryOperator(isExpandedFromMacro("ONE_PLUS"))));
 }