[clangd] Support macro evaluation on hover

[zyounan]

Summary

Creating a SelectionTree at the location where macro expands allows
us to obtain the associated expression, which might then be used to
evaluate compile-time values if possible.

Closes clangd/clangd#1595.

[zyounan]

Fix tests on Windows

[zyounan]

unsigned long isn't 8 bytes on windows

[zyounan]

Do not validate type of builtin operators

[zyounan]

Ping

[nridge]

Thanks for the patch and the thorough testcase!

I wonder if we should make this a bit more strict: if the macro expansion itself is an expression, show the value of that expression, but not e.g. an enclosing expression. Otherwise, the Definition field of the hover (which shows the tokens of the macro expansion) and the Value and Type fields (which show the value and type of a larger expression) could be out of sync and confusing.

A (somewhat contrived) example would be:

#define PLUS_TWO + 2
int x = 40 PLUS_TW^O;  // huh, the value of "+ 2" is "42"?

Of your existing testcases, I think the only one this stricter rule would break is #6 (define_lambda_begin), and I think that's fine.

clang-tools-extra/clangd/Hover.cpp

778

Why createEach() when the non-macro case uses createRight()?

[zyounan]

Update

[zyounan]

Sorry for responding late and thank you for the good catch!
I've updated the code and please feel free to leave comments. :)

clang-tools-extra/clangd/Hover.cpp

778

TBH, I didn't notice that we're using createRight() before and I'm not quite sure if there exists such case, that yields nothing with the right selection tree (which is exactly the 1st tree produced by createEach()) but could be evaluated with falling back to the left selection tree.
I'll change it to createEach anyway.

[zyounan]

Oops, an inline comment disappears accidentally.

#define PLUS_TWO + 2
int x = 40 PLUS_TW^O;  // huh, the value of "+ 2" is "42"?

The reason is we're getting a SelectionNode with a wider range. Here is the layout of the tree:

txt
Built selection tree
 TranslationUnitDecl 
   FunctionDecl void check()
     CompoundStmt { …
      .BinaryOperator 40 + 2
        *IntegerLiteral 2

The dot prior to AST node kind indicates partial selection and the asterisk indicates complete selection according to SelectionTree::print.

By invoking Tree.commonAncestor() it would stop at BinaryOperator despite the fact that we're expecting IntegerLiteral, that represents the number being accordance with the macro expansion.

In order to address such case, I think we could go down the SelectionTree a little further and start evaluating at the node with complete selection.

[sammccall]

(This looks really cool, nice work! only a driveby comment from me I'm afraid)

In D148457#4304915, @zyounan wrote:

The dot prior to AST node kind indicates partial selection and the asterisk indicates complete selection according to SelectionTree::print.

By invoking Tree.commonAncestor() it would stop at BinaryOperator despite the fact that we're expecting IntegerLiteral, that represents the number being accordance with the macro expansion.

In order to address such case, I think we could go down the SelectionTree a little further and start evaluating at the node with complete selection.

I think rather if the common ancestor isn't completely selected, evaluation shouldn't happen. (I think this is what Nathan was suggesting by "strict"?)

(Here, "+ 2" doesn't have a value, the + is binary rather than unary)

The partial/fully selected concept in SelectionTree was originally intended for exactly this kind of thing, so I'm happy to see it get some use :-)

[zyounan]

Haha. My bad for misunderstanding.

I think rather if the common ancestor isn't completely selected, evaluation shouldn't happen.

I don't think it is a feasible approach to simply rule out partial selection. Please consider this snippet:

#define SizeOf sizeof
void check() {
  Siz^eOf(int);
}

And associative selection tree:

Built selection tree
 TranslationUnitDecl 
   FunctionDecl void check()
     CompoundStmt { …
      .UnaryExprOrTypeTraitExpr sizeof(int)  # Partial selected. Exclude it?

Obviously we're expecting evaluation on such macro (which is just what the original issue addresses). And it's worth noting that if we define the macro a whole expression e.g., sizeof(int), rather than a token sizeof, the common ancestor will be seen as completely selected.

OTOH, it doesn't seem so trivial to me to tell if an expression or token is appropriate (or to say, full enough?) to evaluate. Take Nathan's case for example. The macros #define PLUS_TWO +2 and #define TWO 2 are both transformed into the same AST. The mapped selection tree is,

.BinaryOperator 40 + 2
   *IntegerLiteral 2  # For either '40 PLU^S_TWO' or '40 + T^WO'

...or even more extreme,

#define PLUS_TWO +2
40 + PL^US_TWO;  // it should be seen as '+2', right?

As of now I didn't come up with a better idea to split the cases. Any suggestion? :)

[zyounan]

Refactor tests. Obtain type from VarDecl.

[sammccall]

Obviously we're expecting evaluation on such macro (which is just what the original issue addresses).

That wasn't (and isn't) obvious to me - the issue didn't mention the macro in question, i assumed it was #define alignof(x) __alignof(x) or similar. Looks like both forms are in use but clang provides #define alignof __alignof as a built-in.

A couple of ideas:

• special-case alignof
• (generalization) allow partial selection via macros that expand to a single token
• (generalization) allow partial selection as long as it's of a single node - the common ancestor is partially selected and no children are

[zyounan]

Do not evaluate on partial selection with children.

[zyounan]

Thank you very much for the ideas.

(generalization) allow partial selection as long as it's of a single node - the common ancestor is partially selected and no children are

This strategy looks reasonable to me and it passes my test cases. I've updated my patch again. :)

[zyounan]

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

3924

Oops, this should be FALSE I think.

[zyounan]

Exclude the macro expands to single punctulator token.

[zyounan]

Gently ping

[nridge]

Thanks for the update, and thank you Sam for the suggestions!

In D148457#4307402, @sammccall wrote:

A couple of ideas:

• special-case alignof
• (generalization) allow partial selection via macros that expand to a single token
• (generalization) allow partial selection as long as it's of a single node - the common ancestor is partially selected and no children are

I was going to suggest a variant of the second option, where if a macro expands to a single token, the behaviour is the same as if the expanded token had been written in the source and that's what had been hovered over.

However, I don't have any strong concerns about the additional scenarios supported by the third option, so since this is what was implemented, let's go with it. We can always tweak this in the future if necessary.

---

Circling back to my original concern:

In D148457#4297847, @nridge wrote:

the Definition field of the hover (which shows the tokens of the macro expansion) and the Value and Type fields (which show the value and type of a larger expression) could be out of sync and confusing

the original selection being "partial" vs. "complete" is just one part of this concern. Another part is the loop in visitExprFromSelectionTree that can choose a larger enclosing expression than the original selection (even if it's "complete"), so that we can get a Definition for a smaller expression but a Value for a larger one.

However, I discovered that this sort of discrepancy can already arise without macros, where the same loop means Type is given for a smaller expression and Value for a larger one. I filed https://github.com/clangd/clangd/issues/1622 for this with an example.

Since this is a pre-existing issue, I think it's fine not to worry about it in this patch. Perhaps in a follow-up patch we can find a solution that addresses both the macro and non-macro cases.

clang-tools-extra/clangd/Hover.cpp

471

Instead of generalizing printExprValue to take an arbitrary callback, can we modify the original function to return both the Expr* and its printed value (grouped in a pair or small struct)? And then our new call site can call getType() on the Expr*.

(I realize this would be a slight change in semantics as the callback for the macro codepath currently exits the loop as soon as we have a type... but I think there's value in keeping the behaviour consistent between the macro and non-macro cases.)

707

This check for punctuators actually makes the behaviour more strict for macros than for non-macros in some cases.

For example:

#define PLUS +

constexpr int A = 2 + 3;  // hover over `+` shows `Value = 5`
constexpr int B = 2 PLUS 3;  // hover over `PLUS` does not show `Value`

I don't think this is a particularly important use case (it's a bit of a hack to get the expression's value this way, much better would be to select the entire expression you want to evaluate in the editor, but unfortunately LSP only sends a single position in textDocument/hover, not a full range...), but perhaps we could consider relaxing this in the future. (I'm thinking, if we switched to "allow partial selection via macros that expand to a single token", we could probably drop this condition.)

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

3855

I guess with this style of test you can simplify the $3^ to ^

[zyounan]

Address comments

[zyounan]

Thank you for the opinions. I've updated and please take a look.

clang-tools-extra/clangd/Hover.cpp

707

Thanks for clarifying this intention (for any bug hunter in the future).

if we switched to "allow partial selection via macros that expand to a single token", we could probably drop this condition.

I'm afraid we can't. For the array case in the test,

vector left_b^racket 3 right_b^racket;
// left_bracket -> [
// right_bracket -> ]

the associated selection tree is,

TranslationUnitDecl 
  FunctionDecl void function()
    CompoundStmt { …
     .ArraySubscriptExpr vector[3]

(function is the wrapper that facilitates writing single expression, doesn't matter here.)
It expands to one single token and is partially selected, which exactly matches the strategy. If we do allow evaluation, we'd get a value/type on [ or ]. Yes, it is a contrived and weird use case, but for now I think it's fine to keep it unevaluated to avoid issue aforementioned.

(But I'm willing to remove this restriction if you prefer a relaxed strategy.)

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

3855

Aha, that's a typo.

[nridge]

Thanks! LGTM with one final nit (the other comment is just food for future thought)

clang-tools-extra/clangd/Hover.cpp

503

nit: just inline this into its only call site as doPrintExprValue(N, Ctx).PrintedValue (and then we can call the function printExprValue instead of doPrintExprValue)

707

If we do allow evaluation, we'd get a value/type on [ or ].

Out of curiosity, I tried commenting out this condition locally, and the left_bracket test case still passed for me.

The reason is that in that test case, the ArraySubscriptExpr cannot be evaluated (we don't know what the array values are).

In a modified version of the testcase where the array values are known, but macros are not used:

int main() {
  constexpr int vector[3] = {1, 2, 3};
  vector [ 2 ];
}

hovering over the [ or ] does work (in clangd today, no patch needed).

(But maybe a hover in this situation is more confusing than useful, and it would be better if it didn't work?)

Anyways, we can discuss this further in follow-up issues like https://github.com/clangd/clangd/issues/1622, I think this is good enough for now.

[zyounan]

Final update

clang-tools-extra/clangd/Hover.cpp

if (T->isIntegralOrEnumerationType() && Constant.Val.isInt() &&
       Constant.Val.getInt().getSignificantBits() <= 64 &&
       Constant.Val.getInt().uge(10))
     return llvm::formatv("{0} ({1})", Constant.Val.getAsString(Ctx, T),
                          printHex(Constant.Val.getInt()))
         .str();
   return Constant.Val.getAsString(Ctx, T);
 }
 
-std::optional<std::string> printExprValue(const SelectionTree::Node *N,
-                                          const ASTContext &Ctx) {
+struct PrintExprResult {
+  /// The evaluation result on expression `Expr`.
+  std::optional<std::string> PrintedValue;
+  /// The Expr object that represents the closest evaluable
+  /// expression.
+  const Expr *Expr;
+  /// The node of selection tree where the traversal stops.
+  const SelectionTree::Node *Node;
+};
+
+// Seek the closest evaluable expression along the ancestors of node N
+// in a selection tree. If a node in the path can be converted to an evaluable
+// Expr, a possible evaluation would happen and the associated context
+// is returned.
+// If evaluation couldn't be done, return the node where the traversal ends.
+PrintExprResult printExprValue(const SelectionTree::Node *N,
   for (; N; N = N->Parent) {
     // Try to evaluate the first evaluatable enclosing expression.
     if (const Expr *E = N->ASTNode.get<Expr>()) {
       // Once we cross an expression of type 'cv void', the evaluated result
       // has nothing to do with our original cursor position.
       if (!E->getType().isNull() && E->getType()->isVoidType())
         break;
       if (auto Val = printExprValue(E, Ctx))
-        return Val;
+        return PrintExprResult{/*PrintedValue=*/std::move(Val), /*Expr=*/E,
+                               /*Node=*/N};
     } else if (N->ASTNode.get<Decl>() || N->ASTNode.get<Stmt>()) {
       // Refuse to cross certain non-exprs. (TypeLoc are OK as part of Exprs).
       // This tries to ensure we're showing a value related to the cursor.
       break;
     }
   }
-  return std::nullopt;
+  return PrintExprResult{/*PrintedValue=*/std::nullopt, /*Expr=*/nullptr,
+                         /*Node=*/N};
 }
 
 std::optional<StringRef> fieldName(const Expr *E) {
   const auto *ME = llvm::dyn_cast<MemberExpr>(E->IgnoreCasts());
   if (!ME || !llvm::isa<CXXThisExpr>(ME->getBase()->IgnoreCasts()))
     return std::nullopt;
   const auto *Field = llvm::dyn_cast<FieldDecl>(ME->getMemberDecl());
   if (!Field || !Field->getDeclName().isIdentifier())
     return std::nullopt;
   return Field->getDeclName().getAsIdentifierInfo()->getName();
 }
if (const StringLiteral *Name = PE.getFunctionName()) {
     QualType StringType = Ctx.getIncompleteArrayType(
         Ctx.CharTy.withConst(), ArrayType::ArraySizeModifier::Normal,
         /*IndexTypeQuals=*/0);
     HI.Type = printType(StringType, Ctx, PP);
   }
   return HI;
 }
 
+HoverInfo evaluateMacroExpansion(unsigned int SpellingBeginOffset,
+                                 unsigned int SpellingEndOffset,
+                                 llvm::ArrayRef<syntax::Token> Expanded,
+                                 ParsedAST &AST) {
+  auto &Context = AST.getASTContext();
+  auto &Tokens = AST.getTokens();
+  auto PP = getPrintingPolicy(Context.getPrintingPolicy());
+  auto Tree = SelectionTree::createRight(Context, Tokens, SpellingBeginOffset,
+                                         SpellingEndOffset);
+
+  // If macro expands to one single token, rule out punctuator or digraph.
+  // E.g., for the case `array L_BRACKET 42 R_BRACKET;` where L_BRACKET and
+  // R_BRACKET expand to
+  // '[' and ']' respectively, we don't want the type of
+  // 'array[42]' when user hovers on L_BRACKET.
+  if (Expanded.size() == 1)
+    if (tok::getPunctuatorSpelling(Expanded[0].kind()))
+      return {};
+
+  auto *StartNode = Tree.commonAncestor();
+  if (!StartNode)
+    return {};
+  // If the common ancestor is partially selected, do evaluate if it has no
+  // children, thus we can disallow evaluation on incomplete expression.
+  // For example,
+  // #define PLUS_2 +2
+  // 40 PL^US_2
+  // In this case we don't want to present 'value: 2' as PLUS_2 actually expands
+  // to a non-value rather than a binary operand.
+  if (StartNode->Selected == SelectionTree::Selection::Partial)
+    if (!StartNode->Children.empty())
+      return {};
+
+  HoverInfo HI;
+  // Attempt to evaluate it from Expr first.
+  auto ExprResult = printExprValue(StartNode, Context);
+  HI.Value = std::move(ExprResult.PrintedValue);
+  if (auto *E = ExprResult.Expr)
+    HI.Type = printType(E->getType(), Context, PP);
+
+  // If failed, extract the type from Decl if possible.
+  if (!HI.Value && !HI.Type && ExprResult.Node)
+    if (auto *VD = ExprResult.Node->ASTNode.get<VarDecl>())
+      HI.Type = printType(VD->getType(), Context, PP);
+
+  return HI;
+}
+
 /// Generate a \p Hover object given the macro \p MacroDecl.
 HoverInfo getHoverContents(const DefinedMacro &Macro, const syntax::Token &Tok,
                            ParsedAST &AST) {
   HoverInfo HI;
   SourceManager &SM = AST.getSourceManager();
   HI.Name = std::string(Macro.Name);
   HI.Kind = index::SymbolKind::Macro;
   // FIXME: Populate documentation
if (!Invalid) {
       unsigned StartOffset = SM.getFileOffset(StartLoc);
       unsigned EndOffset = SM.getFileOffset(EndLoc);
       if (EndOffset <= Buffer.size() && StartOffset < EndOffset)
         HI.Definition =
             ("#define " + Buffer.substr(StartOffset, EndOffset - StartOffset))
                 .str();
     }
   }
 
   if (auto Expansion = AST.getTokens().expansionStartingAt(&Tok)) {
     // We drop expansion that's longer than the threshold.
     // For extremely long expansion text, it's not readable from hover card
     // anyway.
     std::string ExpansionText;
     for (const auto &ExpandedTok : Expansion->Expanded) {
       ExpansionText += ExpandedTok.text(SM);
       ExpansionText += " ";
       if (ExpansionText.size() > 2048) {
         ExpansionText.clear();
         break;
       }
     }
 
     if (!ExpansionText.empty()) {
       if (!HI.Definition.empty()) {
         HI.Definition += "\n\n";
       }
       HI.Definition += "// Expands to\n";
       HI.Definition += ExpansionText;
     }
+
+    auto Evaluated = evaluateMacroExpansion(
+        /*SpellingBeginOffset=*/SM.getFileOffset(Tok.location()),
+        /*SpellingEndOffset=*/SM.getFileOffset(Tok.endLocation()),
+        /*Expanded=*/Expansion->Expanded, AST);
+    HI.Value = std::move(Evaluated.Value);
+    HI.Type = std::move(Evaluated.Type);
   }
   return HI;
 }
 
 std::string typeAsDefinition(const HoverInfo::PrintedType &PType) {
   std::string Result;
   llvm::raw_string_ostream OS(Result);
   OS << PType.Type;
if (const SelectionTree::Node *N = ST.commonAncestor()) {
       if (const auto *DeclToUse = pickDeclToUse(Decls)) {
         HoverCountMetric.record(1, "decl");
         HI = getHoverContents(DeclToUse, PP, Index, TB);
         // Layout info only shown when hovering on the field/class itself.
         if (DeclToUse == N->ASTNode.get<Decl>())
           addLayoutInfo(*DeclToUse, *HI);
         // Look for a close enclosing expression to show the value of.
         if (!HI->Value)
-          HI->Value = printExprValue(N, AST.getASTContext());
+          HI->Value = printExprValue(N, AST.getASTContext()).PrintedValue;
         maybeAddCalleeArgInfo(N, *HI, PP);
         maybeAddSymbolProviders(AST, *HI, include_cleaner::Symbol{*DeclToUse});
       } else if (const Expr *E = N->ASTNode.get<Expr>()) {
         HoverCountMetric.record(1, "expr");
         HI = getHoverContents(N, E, AST, PP, Index);
       } else if (const Attr *A = N->ASTNode.get<Attr>()) {
         HoverCountMetric.record(1, "attribute");
         HI = getHoverContents(A, AST);

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

 #include "TestFS.h"
 #include "TestIndex.h"
 #include "TestTU.h"
 #include "index/MemIndex.h"
 #include "clang/AST/Attr.h"
 #include "clang/Format/Format.h"
 #include "clang/Index/IndexSymbol.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/Twine.h"
 
 #include "gtest/gtest.h"
 #include <functional>
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace clangd {
class Foo final {})cpp";
       // object-like macro
       {R"cpp(
         #define MACRO 41
         int x = [[MAC^RO]];
         )cpp",
        [](HoverInfo &HI) {
          HI.Name = "MACRO";
          HI.Kind = index::SymbolKind::Macro;
+         HI.Value = "41 (0x29)";
+         HI.Type = "int";
          HI.Definition = "#define MACRO 41\n\n"
                          "// Expands to\n"
                          "41";
        }},
 
       // function-like macro
       {R"cpp(
         // Best MACRO ever.
class Foo final {})cpp";
         #define DECL_STR(NAME, VALUE) const char *v_##NAME = STRINGIFY(VALUE)
         #define FOO 41
 
         [[DECL^_STR]](foo, FOO);
         )cpp",
        [](HoverInfo &HI) {
          HI.Name = "DECL_STR";
          HI.Kind = index::SymbolKind::Macro;
+         HI.Type = HoverInfo::PrintedType("const char *");
          HI.Definition = "#define DECL_STR(NAME, VALUE) const char *v_##NAME = "
                          "STRINGIFY(VALUE)\n\n"
                          "// Expands to\n"
                          "const char *v_foo = \"41\"";
        }},
 
       // constexprs
       {R"cpp(
const std::function<void(HoverInfo &)> ExpectedBuilder;
           }},
       {
           R"cpp(// Macro
             #define MACRO 0
             int main() { return ^[[MACRO]]; }
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "MACRO";
+            HI.Value = "0";
+            HI.Type = "int";
             HI.Kind = index::SymbolKind::Macro;
             HI.Definition = "#define MACRO 0\n\n"
                             "// Expands to\n"
                             "0";
           }},
       {
           R"cpp(// Macro
             #define MACRO 0
TEST(Hover, Typedefs) {
   TestTU TU = TestTU::withCode(T.code());
   auto AST = TU.build();
   auto H = getHover(AST, T.point(), format::getLLVMStyle(), nullptr);
 
   ASSERT_TRUE(H && H->Type);
   EXPECT_EQ(H->Type->Type, "int");
   EXPECT_EQ(H->Definition, "using foo = type<true, int, double>");
 }
+
+TEST(Hover, EvaluateMacros) {
+  llvm::StringRef PredefinedCXX = R"cpp(
+#define X 42
+#define SizeOf sizeof
+#define AlignOf alignof
+#define PLUS_TWO +2
+#define TWO 2
+
+using u64 = unsigned long long;
+// calculate (a ** b) % p
+constexpr u64 pow_with_mod(u64 a, u64 b, u64 p) {
+  u64 ret = 1;
+  while (b) {
+    if (b & 1)
+      ret = (ret * a) % p;
+    a = (a * a) % p;
+    b >>= 1;
+  }
+  return ret;
+}
+#define last_n_digit(x, y, n)                                                  \
+  pow_with_mod(x, y, pow_with_mod(10, n, 2147483647))
+#define declare_struct(X, name, value)                                         \
+  struct X {                                                                   \
+    constexpr auto name() { return value; }                                    \
+  }
+#define gnu_statement_expression(value)                                        \
+  ({                                                                           \
+    declare_struct(Widget, getter, value);                                     \
+    Widget().getter();                                                         \
+  })
+#define define_lambda_begin(lambda, ...)                                       \
+  [&](__VA_ARGS__) {
+#define define_lambda_end() }
+
+#define left_bracket [
+#define right_bracket ]
+#define dg_left_bracket <:
+#define dg_right_bracket :>
+#define array_decl(type, name, size) type name left_bracket size right_bracket
+  )cpp";
+
+  struct {
+    llvm::StringRef Code;
+    const std::function<void(std::optional<HoverInfo>, size_t /*Id*/)>
+        Validator;
+  } Cases[] = {
+      {
+          /*Code=*/R"cpp(
+            X^;
+          )cpp",
+          /*Validator=*/
+          [](std::optional<HoverInfo> HI, size_t) {
+            EXPECT_EQ(HI->Value, "42 (0x2a)");
+            EXPECT_EQ(HI->Type, HoverInfo::PrintedType("int"));
+          },
+      },
+      {
+          /*Code=*/R"cpp(
+            Size^Of(int);
+          )cpp",
+          /*Validator=*/
+          [](std::optional<HoverInfo> HI, size_t) {
+            EXPECT_TRUE(HI->Value);
+            EXPECT_TRUE(HI->Type);
+            // Don't validate type or value of `sizeof` and `alignof` as we're
+            // getting different values or desugared types on different
+            // platforms. Same as below.
+          },
+      },
+      {
+          /*Code=*/R"cpp(
+          struct Y {
+            int y;
+            double z;
+          };
+          Alig^nOf(Y);
+        )cpp",
+          /*Validator=*/
+          [](std::optional<HoverInfo> HI, size_t) {
+            EXPECT_TRUE(HI->Value);
+            EXPECT_TRUE(HI->Type);
+          },
+      },
+      {
+          /*Code=*/R"cpp(
+          // 2**32 == 4294967296
+          last_n_di^git(2, 32, 6);
+        )cpp",
+          /*Validator=*/
+          [](std::optional<HoverInfo> HI, size_t) {
+            EXPECT_EQ(HI->Value, "967296 (0xec280)");
+            EXPECT_EQ(HI->Type, "u64");
+          },
+      },
+      {
+          /*Code=*/R"cpp(
+          gnu_statement_exp^ression(42);
+        )cpp",
+          /*Validator=*/
+          [](std::optional<HoverInfo> HI, size_t) {
+            EXPECT_EQ(HI->Value, "42 (0x2a)");
+            EXPECT_EQ(HI->Type, "int");
+          },
+      },
+      {
+          /*Code=*/R"cpp(
+          40 + PLU^S_TWO;
+        )cpp",
+          /*Validator=*/
+          [](std::optional<HoverInfo> HI, size_t) {
+            EXPECT_EQ(HI->Value, "2");
+            EXPECT_EQ(HI->Type, "int");
+          },
+      },
+      {
+          /*Code=*/R"cpp(
+          40 PLU^S_TWO;
+        )cpp",
+          /*Validator=*/
+          [](std::optional<HoverInfo> HI, size_t) {
+            EXPECT_FALSE(HI->Value) << HI->Value;
+            EXPECT_FALSE(HI->Type) << HI->Type;
+          },
+      },
+      {
+          /*Code=*/R"cpp(
+          40 + TW^O;
+        )cpp",
+          /*Validator=*/
+          [](std::optional<HoverInfo> HI, size_t) {
+            EXPECT_EQ(HI->Value, "2");
+            EXPECT_EQ(HI->Type, "int");
+          },
+      },
+      {
+          /*Code=*/R"cpp(
+          arra^y_decl(int, vector, 10);
+          vector left_b^racket 3 right_b^racket;
+          vector dg_le^ft_bracket 3 dg_righ^t_bracket;
+        )cpp",
+          /*Validator=*/
+          [](std::optional<HoverInfo> HI, size_t Id) {
+            switch (Id) {
+            case 0:
+              EXPECT_EQ(HI->Type, HoverInfo::PrintedType("int[10]"));
+              break;
+            case 1:
+            case 2:
+            case 3:
+            case 4:
+              EXPECT_FALSE(HI->Type) << HI->Type;
+              EXPECT_FALSE(HI->Value) << HI->Value;
+              break;
+            default:
+              ASSERT_TRUE(false) << "Unhandled id: " << Id;
+            }
+          },
+      },
+      {
+          /*Code=*/R"cpp(
+          constexpr auto value = define_lamb^da_begin(lambda, int, char)
+            // Check if the expansion range is right.
+            return ^last_n_digit(10, 3, 3)^;
+          define_lam^bda_end();
+        )cpp",
+          /*Validator=*/
+          [](std::optional<HoverInfo> HI, size_t Id) {
+            switch (Id) {
+            case 0:
+              EXPECT_FALSE(HI->Value);
+              EXPECT_EQ(HI->Type, HoverInfo::PrintedType("const (lambda)"));
+              break;
+            case 1:
+              EXPECT_EQ(HI->Value, "0");
+              EXPECT_EQ(HI->Type, HoverInfo::PrintedType("u64"));
+              break;
+            case 2:
+              EXPECT_FALSE(HI);
+              break;
+            case 3:
+              EXPECT_FALSE(HI->Type) << HI->Type;
+              EXPECT_FALSE(HI->Value) << HI->Value;
+              break;
+            default:
+              ASSERT_TRUE(false) << "Unhandled id: " << Id;
+            }
+          },
+      },
+  };
+
+  Config Cfg;
+  Cfg.Hover.ShowAKA = false;
+  WithContextValue WithCfg(Config::Key, std::move(Cfg));
+  for (const auto &C : Cases) {
+    Annotations Code(
+        (PredefinedCXX + "void function() {\n" + C.Code + "}\n").str());
+    auto TU = TestTU::withCode(Code.code());
+    TU.ExtraArgs.push_back("-std=c++17");
+    auto AST = TU.build();
+    for (auto [Index, Position] : llvm::enumerate(Code.points())) {
+      C.Validator(getHover(AST, Position, format::getLLVMStyle(), nullptr),
+                  Index);
+    }
+  }
+
+  Annotations C(R"c(
+    #define alignof _Alignof
+    void foo() {
+      al^ignof(struct { int x; char y[10]; });
+    }
+  )c");
+
+  auto TU = TestTU::withCode(C.code());
+  TU.Filename = "TestTU.c";
+  TU.ExtraArgs = {
+      "-std=c17",
+  };
+  auto AST = TU.build();
+  auto H = getHover(AST, C.point(), format::getLLVMStyle(), nullptr);
+
+  ASSERT_TRUE(H);
+  EXPECT_EQ(H->Value, "4");
+}
+
 } // namespace
 } // namespace clangd
 } // namespace clang