[clangd] Use the active file's language for hover code blocks

[dgoldman]

Summary

This helps improve the syntax highlighting for Objective-C code,
although it currently doesn't work well in VS Code with
methods/properties/ivars since we don't currently include the proper
decl context (e.g. class).

[dgoldman]

LMK if you can think of a better approach to decide which language to use here. Likely will send a follow up diff to include more context in the Objective-C decl printing so they highlight properly.

[kadircet]

thanks, mostly looks good. any reason for not doing it centrally though ?

clang-tools-extra/clangd/Hover.cpp

1019

can we set it once around here instead?

[sammccall]

Likely will send a follow up diff to include more context in the Objective-C decl printing so they highlight properly.

This might make sense if it provides useful context to human readers without too much syntactic weight.
However if the issue is that particular editors are mis-highlighting snippets of ObjC, that's probably rather bugs to file against those editors (or maybe reasons to drop the language and fall back to regular highlighting)

[dgoldman]

In D108584#2962271, @sammccall wrote:

Likely will send a follow up diff to include more context in the Objective-C decl printing so they highlight properly.

This might make sense if it provides useful context to human readers without too much syntactic weight.
However if the issue is that particular editors are mis-highlighting snippets of ObjC, that's probably rather bugs to file against those editors (or maybe reasons to drop the language and fall back to regular highlighting)

Right, we're just missing the decl context (since objc decls must be in a top level container)

e.g. currently we have:

// In AppDelegate()
@property(nonatomic, assign, unsafe_unretained, readwrite) NSInteger version;

instead we could show

@interface AppDelegate()
@property(nonatomic, assign, unsafe_unretained, readwrite) NSInteger version;
@end

[dgoldman]

Simplify setting the definition language

[kadircet]

thanks, lgtm!

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

968

nit: we can drop that since we're only checking for definition language field.

[dgoldman]

Remove unnecessary build flag

clang-tools-extra/clangd/Hover.cpp

 std::string printDefinition(const Decl *D, const PrintingPolicy &PP) {
   std::string Definition;
   llvm::raw_string_ostream OS(Definition);
   D->print(OS, PP);
   OS.flush();
   return Definition;
 }
 
+const char *getMarkdownLanguage(const ASTContext &Ctx) {
+  const auto &LangOpts = Ctx.getLangOpts();
+  if (LangOpts.ObjC && LangOpts.CPlusPlus)
+    return "objective-cpp";
+  return LangOpts.ObjC ? "objective-c" : "cpp";
+}
+
 std::string printType(QualType QT, const PrintingPolicy &PP) {
   // TypePrinter doesn't resolve decltypes, so resolve them here.
   // FIXME: This doesn't handle composite types that contain a decltype in them.
   // We should rather have a printing policy for that.
   while (!QT.isNull() && QT->isDecltypeType())
     QT = QT->getAs<DecltypeType>()->getUnderlyingType();
   std::string Result;
   llvm::raw_string_ostream OS(Result);
llvm::Optional<HoverInfo> getHover(ParsedAST &AST, Position Pos,
   if (!HI)
     return llvm::None;
 
   auto Replacements = format::reformat(
       Style, HI->Definition, tooling::Range(0, HI->Definition.size()));
   if (auto Formatted =
           tooling::applyAllReplacements(HI->Definition, Replacements))
     HI->Definition = *Formatted;
+  HI->DefinitionLanguage = getMarkdownLanguage(AST.getASTContext());
   HI->SymRange = halfOpenToRange(SM, HighlightRange);
 
   return HI;
 }
 
 markup::Document HoverInfo::present() const {
   markup::Document Output;
 
   // Header contains a text of the form:
   // variable `var`

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

for (const auto &Case : Cases) {
     EXPECT_EQ(H->Size, Expected.Size);
     EXPECT_EQ(H->Offset, Expected.Offset);
     EXPECT_EQ(H->AccessSpecifier, Expected.AccessSpecifier);
     EXPECT_EQ(H->CalleeArgInfo, Expected.CalleeArgInfo);
     EXPECT_EQ(H->CallPassType, Expected.CallPassType);
   }
 }
 
+TEST(Hover, DefinitionLanuage) {
+  struct {
+    const char *const Code;
+    const std::string ClangLanguageFlag;
+    const char *const ExpectedDefinitionLanguage;
+  } Cases[] = {{R"cpp(
+          void [[some^Global]]() {}
+          )cpp",
+                "", "cpp"},
+               {R"cpp(
+          void [[some^Global]]() {}
+          )cpp",
+                "-xobjective-c++", "objective-cpp"},
+               {R"cpp(
+          void [[some^Global]]() {}
+          )cpp",
+                "-xobjective-c", "objective-c"}};
+  for (const auto &Case : Cases) {
+    SCOPED_TRACE(Case.Code);
+
+    Annotations T(Case.Code);
+    TestTU TU = TestTU::withCode(T.code());
+    if (!Case.ClangLanguageFlag.empty())
+      TU.ExtraArgs.push_back(Case.ClangLanguageFlag);
+    auto AST = TU.build();
+
+    auto H = getHover(AST, T.point(), format::getLLVMStyle(), nullptr);
+    ASSERT_TRUE(H);
+
+    EXPECT_STREQ(H->DefinitionLanguage, Case.ExpectedDefinitionLanguage);
+  }
+}
+
 TEST(Hover, CallPassType) {
   const llvm::StringRef CodePrefix = R"cpp(
 class Base {};
 class Derived : public Base {};
 class CustomClass {
  public:
   CustomClass() {}
   CustomClass(const Base &x) {}