[clangd] Fix locateMacroAt() for macro definition outside preamble

[nridge]

Summary

Fixes https://github.com/clangd/clangd/issues/577

[nridge]

Sam, you're my go-to reviewer for "tricky macro stuff", but feel free to hand off if you prefer :)

[nridge]

Review ping :)

[sammccall]

Nice catch! As always, sorry about the delay.

clang-tools-extra/clangd/SourceCode.cpp

987

nit: I guess these would be clearer with auto -> SourceLocation

988

I'm a little confused about the condition here: Loc points at the macro name, which must be at least 1 character long, so we can't be at EOF, right?

Unless i'm missing something, I think we can promote to an assert

993

on the other hand, I suppose this case *is* possible with e.g. a builtin macro used at the start of the file.

I think hoisting this into the condition might be clearer by avoiding the redundant case (the actual *performance* doesn't matter, just for readability)

// If this is foo in `#undef foo`, use the old definition.
if (!MI && SM.getLocForStartOfFile(FID) != Loc)
  MI = PP.getMacroDefinitionAtLoc(II, Loc.getLocWithOffset(-1)).getMacroInfo();

[nridge]

Address review comments

clang-tools-extra/clangd/SourceCode.cpp

llvm::Optional<DefinedMacro> locateMacroAt(const syntax::Token &SpelledTok,
                                            Preprocessor &PP) {
   SourceLocation Loc = SpelledTok.location();
   assert(Loc.isFileID());
   const auto &SM = PP.getSourceManager();
   IdentifierInfo *IdentifierInfo = PP.getIdentifierInfo(SpelledTok.text(SM));
   if (!IdentifierInfo || !IdentifierInfo->hadMacroDefinition())
     return None;
 
-  // Get the definition just before the searched location so that a macro
-  // referenced in a '#undef MACRO' can still be found. Note that we only do
-  // that if Loc is not pointing at start of file.
-  if (SM.getLocForStartOfFile(SM.getFileID(Loc)) != Loc)
-    Loc = Loc.getLocWithOffset(-1);
-  MacroDefinition MacroDef = PP.getMacroDefinitionAtLoc(IdentifierInfo, Loc);
-  if (auto *MI = MacroDef.getMacroInfo())
-    return DefinedMacro{
-        IdentifierInfo->getName(), MI,
-        translatePreamblePatchLocation(MI->getDefinitionLoc(), SM)};
+  // We need to take special case to handle #define and #undef.
+  // Preprocessor::getMacroDefinitionAtLoc() only considers a macro
+  // definition to be in scope *after* the location of the macro name in a
+  // #define that introduces it, and *before* the location of the macro name
+  // in an #undef that undefines it. To handle these cases, we check for
+  // the macro being in scope either just after or just before the location
+  // of the token. In getting the location before, we also take care to check
+  // for start-of-file.
+  FileID FID = SM.getFileID(Loc);
+  assert(Loc != SM.getLocForEndOfFile(FID));
+  SourceLocation JustAfterToken = Loc.getLocWithOffset(1);
+  auto *MacroInfo =
+      PP.getMacroDefinitionAtLoc(IdentifierInfo, JustAfterToken).getMacroInfo();
+  if (!MacroInfo && SM.getLocForStartOfFile(FID) != Loc) {
+    SourceLocation JustBeforeToken = Loc.getLocWithOffset(-1);
+    MacroInfo = PP.getMacroDefinitionAtLoc(IdentifierInfo, JustBeforeToken)
+                    .getMacroInfo();
+  }
+  if (!MacroInfo) {
     return None;
   }
+  return DefinedMacro{
+      IdentifierInfo->getName(), MacroInfo,
+      translatePreamblePatchLocation(MacroInfo->getDefinitionLoc(), SM)};
+}
 
 llvm::Expected<std::string> Edit::apply() const {
   return tooling::applyAllReplacements(InitialCode, Replacements);
 }
 
 std::vector<TextEdit> Edit::asTextEdits() const {
   return replacementsToEdits(InitialCode, Replacements);
 }

clang-tools-extra/clangd/unittests/XRefsTests.cpp

const char *Tests[] = {
 
       R"cpp(// Macros
         #define [[MA^CRO]](X) (X+1)
         void test() {
           int x = [[MACRO]]([[MACRO]](1));
         }
       )cpp",
 
+      R"cpp(// Macro outside preamble
+        int breakPreamble;
+        #define [[MA^CRO]](X) (X+1)
+        void test() {
+          int x = [[MACRO]]([[MACRO]](1));
+        }
+      )cpp",
+
       R"cpp(
         int [[v^ar]] = 0;
         void foo(int s = [[var]]);
       )cpp",
 
       R"cpp(
        template <typename T>
        class [[Fo^o]] {};