[clangd] Make a.k.a printing configurable.

[lh123]

Summary

Currently, a.k.a printing is closed by default.

[lh123]

fix testcase.

[lh123]

rebase to head.

[sammccall]

(Sorry about all the boilerplate for adding config, I think I should probably add some tablegen magic to cover everything except Config.h)

clang-tools-extra/clangd/ConfigFragment.h

271

One question is whether the setting should control hover specifically, or whether it covers "in places we print types" more generally. But it doesn't seem likely we'll make this configurable for diagnostics, and I don't have other examples. Most of our settings are per-feature. So I think this is right as it is.

273

I'd call this ShowAKA

(verb before its object; "show" is a little less jargony)

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

1

we should also add at least one test with it disabled

[lh123]

clang-tools-extra/clangd/ConfigFragment.h

271

In the future, the AKA type can also be displayed in the signature help, but I don't know the best place for this option.（for now, it should be fine to put this setting in hover）

[kadircet]

clang-tools-extra/clangd/ConfigFragment.h

271

we've got a Style section actually, which might be more suitable for extensibility but I am also afraid of pushing ourselves into a corner by putting too much meaning into a boolean flag.

maybe we should just go with a command line flag until we figure out what to do here (as it's less invasive)?

[sammccall]

clang-tools-extra/clangd/ConfigFragment.h

271

I thought about style but the idea is that reflects coding style of the project, where this is really more of a user preference.

I'm a little skeptical whether we'll want this in sig help/completion (vs just being smarter about whether to desugar)

Command line flag is tempting but annoying to wire up. My favorite is probably what we have here

[kadircet]

SG if you also considered the style block. I suppose the risks of having
this in a feature-specific block is much lower.

clang-tools-extra/clangd/Config.h

struct Config {
   } Style;
 
   /// Configures code completion feature.
   struct {
     /// Whether code completion includes results that are not visible in current
     /// scopes.
     bool AllScopes = true;
   } Completion;
+
+  /// Configures hover feature.
+  struct {
+    /// Whether hover show a.k.a type.
+    bool ShowAKA = false;
+  } Hover;
 };
 
 } // namespace clangd
 } // namespace clang
 
 namespace llvm {
 template <> struct DenseMapInfo<clang::clangd::Config::ExternalIndexSpec> {
   using ExternalIndexSpec = clang::clangd::Config::ExternalIndexSpec;

clang-tools-extra/clangd/ConfigCompile.cpp

if (!F.Source.Directory.empty()) {
       if (FragmentDirectory.back() != '/')
         FragmentDirectory += '/';
     }
     compile(std::move(F.If));
     compile(std::move(F.CompileFlags));
     compile(std::move(F.Index));
     compile(std::move(F.Diagnostics));
     compile(std::move(F.Completion));
+    compile(std::move(F.Hover));
   }
 
   void compile(Fragment::IfBlock &&F) {
     if (F.HasUnrecognizedCondition)
       Out.Conditions.push_back([&](const Params &) { return false; });
 
 #ifdef CLANGD_PATH_CASE_INSENSITIVE
     llvm::Regex::RegexFlags Flags = llvm::Regex::IgnoreCase;
void compile(Fragment::CompletionBlock &&F) {
     if (F.AllScopes) {
       Out.Apply.push_back(
           [AllScopes(**F.AllScopes)](const Params &, Config &C) {
             C.Completion.AllScopes = AllScopes;
           });
     }
   }
 
+  void compile(Fragment::HoverBlock &&F) {
+    if (F.ShowAKA) {
+      Out.Apply.push_back([ShowAKA(**F.ShowAKA)](const Params &, Config &C) {
+        C.Hover.ShowAKA = ShowAKA;
+      });
+    }
+  }
+
   constexpr static llvm::SourceMgr::DiagKind Error = llvm::SourceMgr::DK_Error;
   constexpr static llvm::SourceMgr::DiagKind Warning =
       llvm::SourceMgr::DK_Warning;
   void diag(llvm::SourceMgr::DiagKind Kind, llvm::StringRef Message,
             llvm::SMRange Range) {
     if (Range.isValid() && SourceMgr != nullptr)
       Diagnostic(SourceMgr->GetMessage(Range.Start, Kind, Message, Range));
     else

clang-tools-extra/clangd/ConfigFragment.h

struct Fragment {
 
   /// Describes code completion preferences.
   struct CompletionBlock {
     /// Whether code completion should include suggestions from scopes that are
     /// not visible. The required scope prefix will be inserted.
     llvm::Optional<Located<bool>> AllScopes;
   };
   CompletionBlock Completion;
+
+  /// Describes hover preferences.
+  struct HoverBlock {
+    /// Whether hover show a.k.a type.
+    llvm::Optional<Located<bool>> ShowAKA;
+  };
+  HoverBlock Hover;
 };
 
 } // namespace config
 } // namespace clangd
 } // namespace clang
 
 #endif

clang-tools-extra/clangd/ConfigYAML.cpp

public:
   bool parse(Fragment &F, Node &N) {
     DictParser Dict("Config", this);
     Dict.handle("If", [&](Node &N) { parse(F.If, N); });
     Dict.handle("CompileFlags", [&](Node &N) { parse(F.CompileFlags, N); });
     Dict.handle("Index", [&](Node &N) { parse(F.Index, N); });
     Dict.handle("Style", [&](Node &N) { parse(F.Style, N); });
     Dict.handle("Diagnostics", [&](Node &N) { parse(F.Diagnostics, N); });
     Dict.handle("Completion", [&](Node &N) { parse(F.Completion, N); });
+    Dict.handle("Hover", [&](Node &N) { parse(F.Hover, N); });
     Dict.parse(N);
     return !(N.failed() || HadError);
   }
 
 private:
   void parse(Fragment::IfBlock &F, Node &N) {
     DictParser Dict("If", this);
     Dict.unrecognized([&](Located<std::string>, Node &) {
Dict.handle("AllScopes", [&](Node &N) {
           F.AllScopes = *AllScopes;
         else
           warning("AllScopes should be a boolean", N);
       }
     });
     Dict.parse(N);
   }
 
+  void parse(Fragment::HoverBlock &F, Node &N) {
+    DictParser Dict("Hover", this);
+    Dict.handle("ShowAKA", [&](Node &N) {
+      if (auto Value = scalarValue(N, "ShowAKA")) {
+        if (auto ShowAKA = llvm::yaml::parseBool(**Value))
+          F.ShowAKA = *ShowAKA;
+        else
+          warning("ShowAKA should be a boolean", N);
+      }
+    });
+    Dict.parse(N);
+  }
+
   // Helper for parsing mapping nodes (dictionaries).
   // We don't use YamlIO as we want to control over unknown keys.
   class DictParser {
     llvm::StringRef Description;
     std::vector<std::pair<llvm::StringRef, std::function<void(Node &)>>> Keys;
     std::function<bool(Located<std::string>, Node &)> UnknownHandler;
     Parser *Outer;
 

clang-tools-extra/clangd/Hover.cpp

 //===--- Hover.cpp - Information about code at the cursor location --------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Hover.h"
 
 #include "AST.h"
 #include "CodeCompletionStrings.h"
+#include "Config.h"
 #include "FindTarget.h"
 #include "ParsedAST.h"
 #include "Selection.h"
 #include "SourceCode.h"
 #include "index/SymbolCollector.h"
 #include "support/Logger.h"
 #include "support/Markup.h"
 #include "clang/AST/ASTContext.h"
HoverInfo::PrintedType printType(QualType QT, ASTContext &ASTCtx,
   // This isn't very idiomatic, so don't attempt it for complex cases, including
   // pointers/references, template specializations, etc.
   if (!QT.isNull() && !QT.hasQualifiers() && PP.SuppressTagKeyword) {
     if (auto *TT = llvm::dyn_cast<TagType>(QT.getTypePtr()))
       OS << TT->getDecl()->getKindName() << " ";
   }
   QT.print(OS, PP);
   OS.flush();
-  if (!QT.isNull()) {
+
+  const Config &Cfg = Config::current();
+  if (!QT.isNull() && Cfg.Hover.ShowAKA) {
     bool ShouldAKA = false;
     QualType DesugaredTy = clang::desugarForDiagnostic(ASTCtx, QT, ShouldAKA);
     if (ShouldAKA)
       Result.AKA = DesugaredTy.getAsString(PP);
   }
   return Result;
 }
 

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

Completion:
   EXPECT_THAT(Diags.Diagnostics,
               ElementsAre(AllOf(DiagMessage("AllScopes should be a boolean"),
                                 DiagKind(llvm::SourceMgr::DK_Warning),
                                 DiagPos(YAML.range("diagrange").start),
                                 DiagRange(YAML.range("diagrange")))));
   ASSERT_EQ(Results.size(), 1u);
   EXPECT_THAT(Results[0].Completion.AllScopes, testing::Eq(llvm::None));
 }
+
+TEST(ParseYAML, ShowAKA) {
+  CapturedDiags Diags;
+  Annotations YAML(R"yaml(
+Hover:
+  ShowAKA: True
+  )yaml");
+  auto Results =
+      Fragment::parseYAML(YAML.code(), "config.yaml", Diags.callback());
+  ASSERT_THAT(Diags.Diagnostics, IsEmpty());
+  ASSERT_EQ(Results.size(), 1u);
+  EXPECT_THAT(Results[0].Hover.ShowAKA, llvm::ValueIs(Val(true)));
+}
 } // namespace
 } // namespace config
 } // namespace clangd
 } // namespace clang

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

 //===-- HoverTests.cpp ----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "AST.h"
 #include "Annotations.h"
+#include "Config.h"
 #include "Hover.h"
 #include "TestIndex.h"
 #include "TestTU.h"
 #include "index/MemIndex.h"
 #include "clang/AST/Attr.h"
 #include "clang/Basic/Specifiers.h"
 #include "clang/Index/IndexSymbol.h"
 #include "llvm/ADT/None.h"
for (const auto &Case : Cases) {
 
     Annotations T(Case.Code);
     TestTU TU = TestTU::withCode(T.code());
     TU.ExtraArgs.push_back("-std=c++17");
     // Types might be different depending on the target triplet, we chose a
     // fixed one to make sure tests passes on different platform.
     TU.ExtraArgs.push_back("--target=x86_64-pc-linux-gnu");
     auto AST = TU.build();
+    Config Cfg;
+    Cfg.Hover.ShowAKA = true;
+    WithContextValue WithCfg(Config::Key, std::move(Cfg));
 
     auto H = getHover(AST, T.point(), format::getLLVMStyle(), nullptr);
     ASSERT_TRUE(H);
     HoverInfo Expected;
     Expected.SymRange = T.range();
     Case.ExpectedBuilder(Expected);
 
     EXPECT_EQ(H->NamespaceScope, Expected.NamespaceScope);
for (const auto &Case : Cases) {
     TU.ExtraArgs.push_back("-std=c++17");
     TU.ExtraArgs.push_back("-xobjective-c++");
 
     TU.ExtraArgs.push_back("-Wno-gnu-designator");
     // Types might be different depending on the target triplet, we chose a
     // fixed one to make sure tests passes on different platform.
     TU.ExtraArgs.push_back("--target=x86_64-pc-linux-gnu");
     auto AST = TU.build();
-
+    Config Cfg;
+    Cfg.Hover.ShowAKA = true;
+    WithContextValue WithCfg(Config::Key, std::move(Cfg));
     auto H = getHover(AST, T.point(), format::getLLVMStyle(), Index.get());
     ASSERT_TRUE(H);
     HoverInfo Expected;
     Expected.SymRange = T.range();
     Case.ExpectedBuilder(Expected);
 
     SCOPED_TRACE(H->present().asPlainText());
     EXPECT_EQ(H->NamespaceScope, Expected.NamespaceScope);
int foo = 3)",
           R"(stdio.h
 
 /usr/include/stdio.h)",
       }};
 
   for (const auto &C : Cases) {
     HoverInfo HI;
     C.Builder(HI);
+    Config Cfg;
+    Cfg.Hover.ShowAKA = true;
+    WithContextValue WithCfg(Config::Key, std::move(Cfg));
     EXPECT_EQ(HI.present().asPlainText(), C.ExpectedRender);
   }
 }
 
 TEST(Hover, ParseDocumentation) {
   struct Case {
     llvm::StringRef Documentation;
     llvm::StringRef ExpectedRenderMarkdown;
TEST(Hover, ForwardStructNoCrash) {
 
   TestTU TU = TestTU::withCode(T.code());
   auto AST = TU.build();
   auto HI = getHover(AST, T.point(), format::getLLVMStyle(), nullptr);
   ASSERT_TRUE(HI);
   EXPECT_EQ(*HI->Value, "&bar");
 }
 
+TEST(Hover, DisableShowAKA) {
+  Annotations T(R"cpp(
+    using m_int = int;
+    m_int ^[[a]];
+  )cpp");
+
+  Config Cfg;
+  Cfg.Hover.ShowAKA = false;
+  WithContextValue WithCfg(Config::Key, std::move(Cfg));
+
+  TestTU TU = TestTU::withCode(T.code());
+  TU.ExtraArgs.push_back("-std=c++17");
+  auto AST = TU.build();
+  auto H = getHover(AST, T.point(), format::getLLVMStyle(), nullptr);
+
+  ASSERT_TRUE(H);
+  EXPECT_EQ(H->Type, HoverInfo::PrintedType("m_int"));
+}
+
 } // namespace
 } // namespace clangd
 } // namespace clang