[clangd] support expanding `decltype(expr)`

[v1nh1shungry]

Summary

Enable the existing tweak ExpandAutoType to expand
decltype(expr), e.g.

decltype(0) i;

will expand to

int i;

Therefore, rename the tweak ExpandAutoType to ExpandDeducedType.

This patch also fixes some nits,

• avoid replacing reference to a function
• avoid replacing array types and reference to an array

[v1nh1shungry]

If this is okay to go ahead, I'm considering renaming the tweak. Does ExpandType or ExpandDeducedType sound good?

[v1nh1shungry]

rename the tweak ExpandAutoType to ExpandDeducedType

[v1nh1shungry]

• avoid expanding dependent types
• avoid expanding reference to a function
• avoid expanding array type and reference to an array

[v1nh1shungry]

avoid expanding pointer to an array

[sammccall]

Thanks for doing this!

There are a couple of separate logical changes here - I don't think it's a problem per se, but it does mean it takes a bit longer to get the good + obvious stuff reviewed and landed.

clang-tools-extra/clangd/refactor/tweaks/ExpandDeducedType.cpp

56

Maybe "Replace with deduced type" would be clearer for both cases?

Then we don't need to track IsAutoType.
(I have no objection with spending a bit of code to provide better text, but given that the cursor is either on top of "auto" or "decltype" I don't think we're actually adding anything by echoing it back)

124

isDeducedAsLambda is detecting the specific pattern auto x = [&} { ... };, which doesn't occur with decltype.

On the other hand I suspect the DecltypeTypeLoc for decltype(some_lambda) doesn't suffer from the same issue as the AutoTypeLoc in a declaration, and we can simply call getUnderlyingType().

So I think you can simply factor out isLambda(QualType) from isDeducedAsLambda, and call isLambda(DTTL.getType()->getUnderlyingType()) here.

141–142

why not? replacing this with T seems perfectly reasonable.
(The fact that we don't do this with auto t = T{} is just because we're hitting a limitation of clang's AST)

151

these are unrelated to the decltype change (decltype(auto) is an AutoType rather than a DecltypeType and already works/has this bug today).

In future it's best to split unrelated changes into different patches/a patch sequence, though this is simple enough it's probably OK.

153

the commonality between these cases you're excluding (and the function types below) is that they use C-style declarator syntax that may have chunks following the declarator-id. Specifically:

• array, function, and paren types always have chunks following the declarator
• pointer and reference types compose inside-out so their pointee types may contain trailing chunks

If we want to make some attempt to detect more cases, we should pull out a function here and do it properly, something like: bool hasTrailingChunks(QualType) which calls recursively for pointertype etc.

But there's a cheaper way: when we call printType() below, we can optionally specify the declarator-id. Then we can simply check whether it's at the end of the string:

std::string PrettyDeclarator = printType(..., "DECLARATOR_ID");
llvm::StringRef PrettyType = PrettyDeclarator;
if (!PrettyType.consume_back("DECLARATOR_ID"))
  return error("could not expand non-contiguous type {0}", PrettyType);
PrettyType = PrettyType.rtrim();

This feels slightly hacky, but it's direct and simple and we shouldn't miss a case.

[v1nh1shungry]

Thank you for reviewing and giving suggestions!

clang-tools-extra/clangd/refactor/tweaks/ExpandDeducedType.cpp

56

I think your suggestion is better. Thanks!

141–142

I'd like it too. But the printType() would give out a <dependent type>. Though I haven't looked into this, would you mind giving some suggestions about it?

[sammccall]

clang-tools-extra/clangd/refactor/tweaks/ExpandDeducedType.cpp

141–142

Ah, there are three subtly different concepts here:

• is this type usefully printable? There are various reasons why it may not be, it can contain DependentTy, or a canonical template parameter (<template-param-0-0>), or a lambda.
• is this type dependent in the language sense - an example is some type parameter T. This may or may not be usefully printable. (e.g. try template<class X> std::vector<X> y; and hover on y)
• is this type specifically DependentTy, the placeholder dependent type which we have no information about. This is never usefully printable: prints as <dependent type>

As a heuristic, I'm happy with saying dependent types (in the language sense) are likely not to print usefully, so don't replace them. But the comment should say so (this is a heuristic for unprintable rather than an end in itself), and probably give examples.

[v1nh1shungry]

clang-tools-extra/clangd/refactor/tweaks/ExpandDeducedType.cpp

141–142

Hmm, do you mean it's okay to refuse to replace dependent types but I should leave a comment saying the reason is that they are likely not to print usefully? Sorry if I misunderstood anything! I'm really not a good reader :(

153

TBH, I'm confused about printType() and its placeholder DECLARATOR_ID. Is the code your offered above can be used directly?

If so, I had a try on it and it did refuse to replace types like function and array. But it would give an error message saying "Could not expand non-contiguous type const char (&DECLARATOR_ID)[6]". Is this okay? I mean isn't the "DECLARATOR_ID" in the message a bit confusing?

[sammccall]

clang-tools-extra/clangd/refactor/tweaks/ExpandDeducedType.cpp

141–142

Yeah, exactly!

153

That was the idea, but I think you're right the error message is confusing.

We need to strike a balance between being precise, being easy to understand, and being reasonable to maintain.

I think it's probably best to be a bit vague here rather than using precise but obscure language, maybe "could not expand type that isn't a simple string".
Whether to leave out the actual type, include it with DECLARATOR_ID in it, or call printType() again with an empty placeholder is up to you - I don't think any of those are too confusing in context.

[v1nh1shungry]

address the comments

[sammccall]

LGTM with a comment nit, thank you!
Do you have commit access?

clang-tools-extra/clangd/refactor/tweaks/ExpandDeducedType.cpp

152

Say why rather than what, e.g.

Some types aren't written as single chunks of text, e.g:
  auto fptr = &func; // auto is void(*)()
==>
  void (*fptr)();

Replacing these requires examining the declarator, we don't support it yet.

[sammccall]

clang-tools-extra/clangd/refactor/tweaks/ExpandDeducedType.cpp

152

oops, that should be void (*fptr)() = &func; of course..

[v1nh1shungry]

modify the comment

[v1nh1shungry]

Thank you for reviewing and giving guidance!

Do you have commit access?

I don't. If this patch is okay to land, could you please help me commit it? Thanks a lot!

clang-tools-extra/clangd/refactor/tweaks/CMakeLists.txt

 # $<TARGET_OBJECTS:obj.clangDaemonTweaks> to a list of sources, see
 # clangd/tool/CMakeLists.txt for an example.
 add_clang_library(clangDaemonTweaks OBJECT
   AddUsing.cpp
   AnnotateHighlightings.cpp
   DumpAST.cpp
   DefineInline.cpp
   DefineOutline.cpp
-  ExpandAutoType.cpp
+  ExpandDeducedType.cpp
   ExpandMacro.cpp
   ExtractFunction.cpp
   ExtractVariable.cpp
   MemberwiseConstructor.cpp
   ObjCLocalizeStringLiteral.cpp
   ObjCMemberwiseInitializer.cpp
   PopulateSwitch.cpp
   RawStringLiteral.cpp

clang-tools-extra/clangd/refactor/tweaks/ExpandDeducedType.cpp

-//===--- ExpandAutoType.cpp --------------------------------------*- C++-*-===//
+//===--- ExpandDeducedType.cpp -----------------------------------*- C++-*-===//
 //
 // 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 "refactor/Tweak.h"
 

 
 /// Expand the "auto" type to the derived type
 /// Before:
 ///    auto x = Something();
 ///    ^^^^
 /// After:
 ///    MyClass x = Something();
 ///    ^^^^^^^
-/// FIXME: Handle decltype as well
-class ExpandAutoType : public Tweak {
+/// Expand `decltype(expr)` to the deduced type
+/// Before:
+///   decltype(0) i;
+///   ^^^^^^^^^^^
+/// After:
+///   int i;
+///   ^^^
+class ExpandDeducedType : public Tweak {
 public:
   const char *id() const final;
   llvm::StringLiteral kind() const override {
     return CodeAction::REFACTOR_KIND;
   }
   bool prepare(const Selection &Inputs) override;
   Expected<Effect> apply(const Selection &Inputs) override;
   std::string title() const override;
 
 private:
-  SourceRange AutoRange;
+  SourceRange Range;
 };
 
-REGISTER_TWEAK(ExpandAutoType)
+REGISTER_TWEAK(ExpandDeducedType)
 
-std::string ExpandAutoType::title() const { return "Expand auto type"; }
+std::string ExpandDeducedType::title() const {
+  return "Replace with deduced type";
+}
 
 // Structured bindings must use auto, e.g. `const auto& [a,b,c] = ...;`.
 // Return whether N (an AutoTypeLoc) is such an auto that must not be expanded.
 bool isStructuredBindingType(const SelectionTree::Node *N) {
   // Walk up the TypeLoc chain, because auto may be qualified.
   while (N && N->ASTNode.get<TypeLoc>())
     N = N->Parent;
   // The relevant type is the only direct type child of a Decomposition.
   return N && N->ASTNode.get<DecompositionDecl>();
 }
 
+bool isLambda(QualType QT) {
+  if (!QT.isNull())
+    if (const auto *RD = QT->getAsRecordDecl())
+      return RD->isLambda();
+  return false;
+}
+
 // Returns true iff Node is a lambda, and thus should not be expanded. Loc is
 // the location of the auto type.
 bool isDeducedAsLambda(const SelectionTree::Node *Node, SourceLocation Loc) {
   // getDeducedType() does a traversal, which we want to avoid in prepare().
   // But at least check this isn't auto x = []{...};, which can't ever be
   // expanded.
   // (It would be nice if we had an efficient getDeducedType(), instead).
   for (const auto *It = Node; It; It = It->Parent) {
     if (const auto *DD = It->ASTNode.get<DeclaratorDecl>()) {
       if (DD->getTypeSourceInfo() &&
-          DD->getTypeSourceInfo()->getTypeLoc().getBeginLoc() == Loc) {
-        if (auto *RD = DD->getType()->getAsRecordDecl())
-          return RD->isLambda();
-      }
+          DD->getTypeSourceInfo()->getTypeLoc().getBeginLoc() == Loc &&
+          isLambda(DD->getType()))
+        return true;
     }
   }
   return false;
 }
 
 // Returns true iff "auto" in Node is really part of the template parameter,
 // which we cannot expand.
 bool isTemplateParam(const SelectionTree::Node *Node) {
   if (Node->Parent)
     if (Node->Parent->ASTNode.get<NonTypeTemplateParmDecl>())
       return true;
   return false;
 }
 
-bool ExpandAutoType::prepare(const Selection &Inputs) {
+bool ExpandDeducedType::prepare(const Selection &Inputs) {
   if (auto *Node = Inputs.ASTSelection.commonAncestor()) {
     if (auto *TypeNode = Node->ASTNode.get<TypeLoc>()) {
       if (const AutoTypeLoc Result = TypeNode->getAs<AutoTypeLoc>()) {
         if (!isStructuredBindingType(Node) &&
             !isDeducedAsLambda(Node, Result.getBeginLoc()) &&
             !isTemplateParam(Node))
-          AutoRange = Result.getSourceRange();
+          Range = Result.getSourceRange();
       }
       if (auto TTPAuto = TypeNode->getAs<TemplateTypeParmTypeLoc>()) {
         // We exclude concept constraints for now, as the SourceRange is wrong.
         // void foo(C auto x) {};
         //            ^^^^
         // TTPAuto->getSourceRange only covers "auto", not "C auto".
         if (TTPAuto.getDecl()->isImplicit() &&
             !TTPAuto.getDecl()->hasTypeConstraint())
-          AutoRange = TTPAuto.getSourceRange();
+          Range = TTPAuto.getSourceRange();
+      }
+
+      if (auto DTTL = TypeNode->getAs<DecltypeTypeLoc>()) {
+        if (!isLambda(cast<DecltypeType>(DTTL.getType())->getUnderlyingType()))
+          Range = DTTL.getSourceRange();
       }
     }
   }
 
-  return AutoRange.isValid();
+  return Range.isValid();
 }
 
-Expected<Tweak::Effect> ExpandAutoType::apply(const Selection& Inputs) {
+Expected<Tweak::Effect> ExpandDeducedType::apply(const Selection &Inputs) {
   auto &SrcMgr = Inputs.AST->getSourceManager();
 
   std::optional<clang::QualType> DeducedType =
-      getDeducedType(Inputs.AST->getASTContext(), AutoRange.getBegin());
+      getDeducedType(Inputs.AST->getASTContext(), Range.getBegin());
 
   // if we can't resolve the type, return an error message
   if (DeducedType == std::nullopt || (*DeducedType)->isUndeducedAutoType())
     return error("Could not deduce type for 'auto' type");
 
-  // if it's a lambda expression, return an error message
-  if (isa<RecordType>(*DeducedType) &&
-      cast<RecordType>(*DeducedType)->getDecl()->isLambda()) {
-    return error("Could not expand type of lambda expression");
-  }
-
-  // if it's a function expression, return an error message
-  // naively replacing 'auto' with the type will break declarations.
-  // FIXME: there are other types that have similar problems
-  if (DeducedType->getTypePtr()->isFunctionPointerType()) {
-    return error("Could not expand type of function pointer");
-  }
-
-  std::string PrettyTypeName = printType(*DeducedType,
-      Inputs.ASTSelection.commonAncestor()->getDeclContext());
+  // we shouldn't replace a dependent type which is likely not to print
+  // usefully, e.g.
+  //   template <class T>
+  //   struct Foobar {
+  //     decltype(T{}) foobar;
+  //     ^^^^^^^^^^^^^ would turn out to be `<dependent-type>`
+  //   };
+  if ((*DeducedType)->isDependentType())
+    return error("Could not expand a dependent type");
+
+  // Some types aren't written as single chunks of text, e.g:
+  //   auto fptr = &func; // auto is void(*)()
+  // ==>
+  //   void (*fptr)() = &func;
+  // Replacing these requires examining the declarator, we don't support it yet.
+  std::string PrettyDeclarator = printType(
+      *DeducedType, Inputs.ASTSelection.commonAncestor()->getDeclContext(),
+      "DECLARATOR_ID");
+  llvm::StringRef PrettyTypeName = PrettyDeclarator;
+  if (!PrettyTypeName.consume_back("DECLARATOR_ID"))
+    return error("Could not expand type that isn't a simple string");
+  PrettyTypeName = PrettyTypeName.rtrim();
 
-  tooling::Replacement Expansion(SrcMgr, CharSourceRange(AutoRange, true),
+  tooling::Replacement Expansion(SrcMgr, CharSourceRange(Range, true),
                                  PrettyTypeName);
 
   return Effect::mainFileEdit(SrcMgr, tooling::Replacements(Expansion));
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/test/check-fail.test

 // RUN: cp %s %t.cpp
 // RUN: not clangd -enable-config=0 -check=%t.cpp 2>&1 | FileCheck -strict-whitespace %s
 
 // CHECK: Testing on source file {{.*}}check-fail.test
 // CHECK: internal (cc1) args are: -cc1
 // CHECK: Building preamble...
 // CHECK: [pp_file_not_found] Line {{.*}}: 'missing.h' file not found
 // CHECK: Building AST...
 // CHECK: Testing features at each token
-// CHECK: tweak: ExpandAutoType ==> FAIL
+// CHECK: tweak: ExpandDeducedType ==> FAIL
 // CHECK: All checks completed, 2 errors
 
 #include "missing.h"
 void fun();
 auto x = fun;

clang-tools-extra/clangd/test/check-lines.test

 // RUN: cp %s %t.cpp
 // RUN: not clangd -enable-config=0 -check=%t.cpp -check-lines=6-14 2>&1 | FileCheck -strict-whitespace %s
 // RUN: not clangd -enable-config=0 -check=%t.cpp -check-lines=14 2>&1 | FileCheck -strict-whitespace %s
 
 // CHECK: Testing on source file {{.*}}check-lines.test
 // CHECK: internal (cc1) args are: -cc1
 // CHECK: Building preamble...
 // CHECK: Building AST...
 // CHECK: Testing features at each token
-// CHECK: tweak: ExpandAutoType ==> FAIL
+// CHECK: tweak: ExpandDeducedType ==> FAIL
 // CHECK: All checks completed, 1 errors
 
 void fun();
 auto x = fun; // This line is tested
 auto y = fun; // This line is not tested

clang-tools-extra/clangd/test/check.test

 // RUN: cp %s %t.cpp
 // RUN: clangd -enable-config=0 -log=verbose -check=%t.cpp 2>&1 | FileCheck -strict-whitespace %s
 
 // CHECK: Testing on source file
 // CHECK: internal (cc1) args are: -cc1
 // CHECK: Building preamble...
 // CHECK: Built preamble
 // CHECK: Building AST...
 // CHECK: Testing features at each token
-// CHECK-DAG: tweak: ExpandAuto
+// CHECK-DAG: tweak: ExpandDeducedType
 // CHECK-DAG: hover: true
 // CHECK-DAG: tweak: AddUsing
 // CHECK: All checks completed, 0 errors
 
 namespace ns {
 struct Foo {};
 } // namespace ns
 auto f = ns::Foo();

clang-tools-extra/clangd/test/code-action-request.test

 # CHECK-NEXT:              "character": 4,
 # CHECK-NEXT:              "line": 0
 # CHECK-NEXT:            },
 # CHECK-NEXT:            "start": {
 # CHECK-NEXT:              "character": 0,
 # CHECK-NEXT:              "line": 0
 # CHECK-NEXT:            }
 # CHECK-NEXT:          },
-# CHECK-NEXT:          "tweakID": "ExpandAutoType"
+# CHECK-NEXT:          "tweakID": "ExpandDeducedType"
 # CHECK-NEXT:        }
 # CHECK-NEXT:      ],
 # CHECK-NEXT:      "command": "clangd.applyTweak",
-# CHECK-NEXT:      "title": "Expand auto type"
+# CHECK-NEXT:      "title": "Replace with deduced type"
 # CHECK-NEXT:    }
 # CHECK-NEXT:  ]
 ---
 {
   "jsonrpc": "2.0",
   "id": 2,
   "method": "textDocument/codeAction",
   "params": {
"textDocument": { "uri": "test:///main.cpp" },
         }
     }
 }
 #      CHECK:  "id": 3,
 # CHECK-NEXT:  "jsonrpc": "2.0",
 # CHECK-NEXT:  "result": [
 # CHECK-NEXT:    {
 ---
-{"jsonrpc":"2.0","id":4,"method":"workspace/executeCommand","params":{"command":"clangd.applyTweak","arguments":[{"file":"test:///main.cpp","selection":{"end":{"character":4,"line":0},"start":{"character":0,"line":0}},"tweakID":"ExpandAutoType"}]}}
+{"jsonrpc":"2.0","id":4,"method":"workspace/executeCommand","params":{"command":"clangd.applyTweak","arguments":[{"file":"test:///main.cpp","selection":{"end":{"character":4,"line":0},"start":{"character":0,"line":0}},"tweakID":"ExpandDeducedType"}]}}
 #      CHECK:    "newText": "int",
 # CHECK-NEXT:    "range": {
 # CHECK-NEXT:      "end": {
 # CHECK-NEXT:        "character": 4,
 # CHECK-NEXT:        "line": 0
 # CHECK-NEXT:      },
 # CHECK-NEXT:      "start": {
 # CHECK-NEXT:        "character": 0,
 # CHECK-NEXT:        "line": 0
 # CHECK-NEXT:      }
 # CHECK-NEXT:    }
 ---
 {"jsonrpc":"2.0","id":5,"method":"shutdown"}
 ---
 {"jsonrpc":"2.0","method":"exit"}
 ---

clang-tools-extra/clangd/test/request-reply.test

 # RUN: clangd -log=verbose -lit-test < %s | FileCheck -strict-whitespace %s
 {"jsonrpc":"2.0","id":0,"method":"initialize","params":{"processId":123,"rootPath":"clangd","capabilities":{},"trace":"off"}}
 ---
 {"jsonrpc":"2.0","method":"textDocument/didOpen","params":{"textDocument":{"uri":"test:///main.cpp","languageId":"cpp","version":1,"text":"auto i = 0;"}}}
 ---
-{"jsonrpc":"2.0","id":4,"method":"workspace/executeCommand","params":{"command":"clangd.applyTweak","arguments":[{"file":"test:///main.cpp","selection":{"end":{"character":4,"line":0},"start":{"character":0,"line":0}},"tweakID":"ExpandAutoType"}]}}
+{"jsonrpc":"2.0","id":4,"method":"workspace/executeCommand","params":{"command":"clangd.applyTweak","arguments":[{"file":"test:///main.cpp","selection":{"end":{"character":4,"line":0},"start":{"character":0,"line":0}},"tweakID":"ExpandDeducedType"}]}}
 #      CHECK:  "id": 0,
 #      CHECK:  "method": "workspace/applyEdit",
 #      CHECK:  "newText": "int",
 # CHECK-NEXT:  "range": {
 # CHECK-NEXT:    "end": {
 # CHECK-NEXT:      "character": 4,
 # CHECK-NEXT:      "line": 0
 # CHECK-NEXT:    },
 # CHECK-NEXT:    "start": {
 # CHECK-NEXT:      "character": 0,
 # CHECK-NEXT:      "line": 0
 # CHECK-NEXT:    }
 # CHECK-NEXT:  }
 ---
 {"jsonrpc":"2.0","id":0,"result":{"applied":false}}
 #      CHECK:  "error": {
 # CHECK-NEXT:    "code": -32001,
 # CHECK-NEXT:    "message": "edits were not applied: unknown reason"
 # CHECK-NEXT:  },
 # CHECK-NEXT:  "id": 4,
 ---
-{"jsonrpc":"2.0","id":5,"method":"workspace/executeCommand","params":{"command":"clangd.applyTweak","arguments":[{"file":"test:///main.cpp","selection":{"end":{"character":4,"line":0},"start":{"character":0,"line":0}},"tweakID":"ExpandAutoType"}]}}
+{"jsonrpc":"2.0","id":5,"method":"workspace/executeCommand","params":{"command":"clangd.applyTweak","arguments":[{"file":"test:///main.cpp","selection":{"end":{"character":4,"line":0},"start":{"character":0,"line":0}},"tweakID":"ExpandDeducedType"}]}}
 #      CHECK:  "id": 1,
 #      CHECK:  "method": "workspace/applyEdit",
 ---
 {"jsonrpc":"2.0","id":1,"result":{"applied":true}}
 #      CHECK:  "id": 5,
 # CHECK-NEXT:  "jsonrpc": "2.0",
 # CHECK-NEXT:  "result": "Tweak applied."
 ---
 # a reply with an invalid id.
 {"jsonrpc":"2.0","id":"invalid","result":{"applied":true}}
 # clangd doesn't reply, just emits an elog.
 ---
 {"jsonrpc":"2.0","id":6,"method":"shutdown"}
 ---
 {"jsonrpc":"2.0","method":"exit"}

clang-tools-extra/clangd/unittests/CMakeLists.txt

add_unittest(ClangdUnitTests ClangdTests
 
   tweaks/AddUsingTests.cpp
   tweaks/AnnotateHighlightingsTests.cpp
   tweaks/DefineInlineTests.cpp
   tweaks/DefineOutlineTests.cpp
   tweaks/DumpASTTests.cpp
   tweaks/DumpRecordLayoutTests.cpp
   tweaks/DumpSymbolTests.cpp
-  tweaks/ExpandAutoTypeTests.cpp
+  tweaks/ExpandDeducedTypeTests.cpp
   tweaks/ExpandMacroTests.cpp
   tweaks/ExtractFunctionTests.cpp
   tweaks/ExtractVariableTests.cpp
   tweaks/MemberwiseConstructorTests.cpp
   tweaks/ObjCLocalizeStringLiteralTests.cpp
   tweaks/ObjCMemberwiseInitializerTests.cpp
   tweaks/PopulateSwitchTests.cpp
   tweaks/RawStringLiteralTests.cpp

clang-tools-extra/clangd/unittests/tweaks/ExpandDeducedTypeTests.cpp

-//===-- ExpandAutoTypeTests.cpp ---------------------------------*- C++ -*-===//
+//===-- ExpandDeducedTypeTests.cpp ------------------------------*- C++ -*-===//
 //
 // 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 "TweakTesting.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 using ::testing::StartsWith;
 
 namespace clang {
 namespace clangd {
 namespace {
 
-TWEAK_TEST(ExpandAutoType);
+TWEAK_TEST(ExpandDeducedType);
 
-TEST_F(ExpandAutoTypeTest, Test) {
+TEST_F(ExpandDeducedTypeTest, Test) {
   Header = R"cpp(
     namespace ns {
       struct Class {
         struct Nested {};
       };
       void Func();
     }
     inline namespace inl_ns {
TEST_F(ExpandDeducedTypeTest, Test) {
   // check that namespaces are shortened
   EXPECT_EQ(apply("namespace ns { void f() { ^auto C = Class(); } }"),
             "namespace ns { void f() { Class C = Class(); } }");
   // undefined functions should not be replaced
   EXPECT_THAT(apply("au^to x = doesnt_exist(); // error-ok"),
               StartsWith("fail: Could not deduce type for 'auto' type"));
   // function pointers should not be replaced
   EXPECT_THAT(apply("au^to x = &ns::Func;"),
-              StartsWith("fail: Could not expand type of function pointer"));
+              StartsWith("fail: Could not expand type"));
+  // function references should not be replaced
+  EXPECT_THAT(apply("au^to &x = ns::Func;"),
+              StartsWith("fail: Could not expand type"));
   // lambda types are not replaced
   EXPECT_UNAVAILABLE("au^to x = []{};");
   // inline namespaces
   EXPECT_EQ(apply("au^to x = inl_ns::Visible();"),
             "inl_ns::Visible x = inl_ns::Visible();");
   // local class
   EXPECT_EQ(apply("namespace x { void y() { struct S{}; ^auto z = S(); } }"),
             "namespace x { void y() { struct S{}; S z = S(); } }");
-  // replace array types
+  // replace pointers
   EXPECT_EQ(apply(R"cpp(au^to x = "test";)cpp"),
             R"cpp(const char * x = "test";)cpp");
+  // pointers to an array are not replaced
+  EXPECT_THAT(apply(R"cpp(au^to s = &"foobar";)cpp"),
+              StartsWith("fail: Could not expand type"));
 
   EXPECT_EQ(apply("ns::Class * foo() { au^to c = foo(); }"),
             "ns::Class * foo() { ns::Class * c = foo(); }");
   EXPECT_EQ(
       apply("void ns::Func() { au^to x = new ns::Class::Nested{}; }"),
       "void ns::Func() { ns::Class::Nested * x = new ns::Class::Nested{}; }");
 
   EXPECT_EQ(apply("dec^ltype(auto) x = 10;"), "int x = 10;");
   EXPECT_EQ(apply("decltype(au^to) x = 10;"), "int x = 10;");
+  // references to array types are not replaced
+  EXPECT_THAT(apply(R"cpp(decl^type(auto) s = "foobar"; // error-ok)cpp"),
+              StartsWith("fail: Could not expand type"));
+  // array types are not replaced
+  EXPECT_THAT(apply("int arr[10]; decl^type(auto) foobar = arr; // error-ok"),
+              StartsWith("fail: Could not expand type"));
+  // pointers to an array are not replaced
+  EXPECT_THAT(apply(R"cpp(decl^type(auto) s = &"foobar";)cpp"),
+              StartsWith("fail: Could not expand type"));
   // expanding types in structured bindings is syntactically invalid.
   EXPECT_UNAVAILABLE("const ^auto &[x,y] = (int[]){1,2};");
 
   // unknown types in a template should not be replaced
   EXPECT_THAT(apply("template <typename T> void x() { ^auto y = T::z(); }"),
               StartsWith("fail: Could not deduce type for 'auto' type"));
 
+  // check primitive type
+  EXPECT_EQ(apply("decl^type(0) i;"), "int i;");
+  // function should not be replaced
+  EXPECT_THAT(apply("void f(); decl^type(f) g;"),
+              StartsWith("fail: Could not expand type"));
+  // check return type in function proto
+  EXPECT_EQ(apply("decl^type(0) f();"), "int f();");
+  // check trailing return type
+  EXPECT_EQ(apply("auto f() -> decl^type(0) { return 0; }"),
+            "auto f() -> int { return 0; }");
+  // check function parameter type
+  EXPECT_EQ(apply("void f(decl^type(0));"), "void f(int);");
+  // check template parameter type
+  EXPECT_EQ(apply("template <decl^type(0)> struct Foobar {};"),
+            "template <int> struct Foobar {};");
+  // check default template argument
+  EXPECT_EQ(apply("template <class = decl^type(0)> class Foo {};"),
+            "template <class = int> class Foo {};");
+  // check template argument
+  EXPECT_EQ(apply("template <class> class Bar {}; Bar<decl^type(0)> b;"),
+            "template <class> class Bar {}; Bar<int> b;");
+  // dependent types are not replaced
+  EXPECT_THAT(apply("template <class T> struct Foobar { decl^type(T{}) t; };"),
+              StartsWith("fail: Could not expand a dependent type"));
+  // references to array types are not replaced
+  EXPECT_THAT(apply(R"cpp(decl^type("foobar") s; // error-ok)cpp"),
+              StartsWith("fail: Could not expand type"));
+  // array types are not replaced
+  EXPECT_THAT(apply("int arr[10]; decl^type(arr) foobar;"),
+              StartsWith("fail: Could not expand type"));
+  // pointers to an array are not replaced
+  EXPECT_THAT(apply(R"cpp(decl^type(&"foobar") s;)cpp"),
+              StartsWith("fail: Could not expand type"));
+
   ExtraArgs.push_back("-std=c++20");
   EXPECT_UNAVAILABLE("template <au^to X> class Y;");
 
   EXPECT_THAT(apply("auto X = [](^auto){};"),
               StartsWith("fail: Could not deduce"));
   EXPECT_EQ(apply("auto X = [](^auto){return 0;}; int Y = X(42);"),
             "auto X = [](int){return 0;}; int Y = X(42);");
   EXPECT_THAT(apply("auto X = [](^auto){return 0;}; int Y = X(42) + X('c');"),
               StartsWith("fail: Could not deduce"));
   // FIXME: should work on constrained auto params, once SourceRange is fixed.
   EXPECT_UNAVAILABLE("template<class> concept C = true;"
                      "auto X = [](C ^auto *){return 0;};");
+
+  // lambda should not be replaced
+  EXPECT_UNAVAILABLE("auto f = [](){}; decl^type(f) g;");
+  EXPECT_UNAVAILABLE("decl^type([]{}) f;");
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/unittests/tweaks/TweakTesting.h

 #include <string>
 
 namespace clang {
 namespace clangd {
 
 // Fixture base for testing tweaks. Intended to be subclassed for each tweak.
 //
 // Usage:
-// TWEAK_TEST(ExpandAutoType);
+// TWEAK_TEST(ExpandDeducedType);
 //
-// TEST_F(ExpandAutoTypeTest, ShortensTypes) {
+// TEST_F(ExpandDeducedTypeTest, ShortensTypes) {
 //   Header = R"cpp(
 //     namespace foo { template<typename> class X{}; }
 //     using namespace foo;
 //   )cpp";
 //   Context = Function;
 //   EXPECT_THAT(apply("[[auto]] X = foo<int>();"),
 //               "foo<int> X = foo<int();");
 //   EXPECT_AVAILABLE("^a^u^t^o^ X = foo<int>();");

clang/docs/tools/clang-formatted-files.txt

 clang-tools-extra/clangd/unittests/support/ThreadingTests.cpp
 clang-tools-extra/clangd/unittests/support/TraceTests.cpp
 clang-tools-extra/clangd/unittests/tweaks/AddUsingTests.cpp
 clang-tools-extra/clangd/unittests/tweaks/AnnotateHighlightingsTests.cpp
 clang-tools-extra/clangd/unittests/tweaks/DefineOutlineTests.cpp
 clang-tools-extra/clangd/unittests/tweaks/DumpASTTests.cpp
 clang-tools-extra/clangd/unittests/tweaks/DumpRecordLayoutTests.cpp
 clang-tools-extra/clangd/unittests/tweaks/DumpSymbolTests.cpp
-clang-tools-extra/clangd/unittests/tweaks/ExpandAutoTypeTests.cpp
+clang-tools-extra/clangd/unittests/tweaks/ExpandDeducedTypeTests.cpp
 clang-tools-extra/clangd/unittests/tweaks/ExpandMacroTests.cpp
 clang-tools-extra/clangd/unittests/tweaks/ExtractFunctionTests.cpp
 clang-tools-extra/clangd/unittests/tweaks/ExtractVariableTests.cpp
 clang-tools-extra/clangd/unittests/tweaks/ObjCLocalizeStringLiteralTests.cpp
 clang-tools-extra/clangd/unittests/tweaks/PopulateSwitchTests.cpp
 clang-tools-extra/clangd/unittests/tweaks/RawStringLiteralTests.cpp
 clang-tools-extra/clangd/unittests/tweaks/RemoveUsingNamespaceTests.cpp
 clang-tools-extra/clangd/unittests/tweaks/ShowSelectionTreeTests.cpp

llvm/utils/gn/secondary/clang-tools-extra/clangd/refactor/tweaks/BUILD.gn

source_set("tweaks") {
   ]
   include_dirs = [ "../.." ]
   sources = [
     "AddUsing.cpp",
     "AnnotateHighlightings.cpp",
     "DefineInline.cpp",
     "DefineOutline.cpp",
     "DumpAST.cpp",
-    "ExpandAutoType.cpp",
+    "ExpandDeducedType.cpp",
     "ExpandMacro.cpp",
     "ExtractFunction.cpp",
     "ExtractVariable.cpp",
     "MemberwiseConstructor.cpp",
     "ObjCLocalizeStringLiteral.cpp",
     "ObjCMemberwiseInitializer.cpp",
     "PopulateSwitch.cpp",
     "RawStringLiteral.cpp",
     "RemoveUsingNamespace.cpp",
     "SpecialMembers.cpp",
     "SwapIfBranches.cpp",
   ]
 }

llvm/utils/gn/secondary/clang-tools-extra/clangd/unittests/BUILD.gn

sources = [
     "support/TraceTests.cpp",
     "tweaks/AddUsingTests.cpp",
     "tweaks/AnnotateHighlightingsTests.cpp",
     "tweaks/DefineInlineTests.cpp",
     "tweaks/DefineOutlineTests.cpp",
     "tweaks/DumpASTTests.cpp",
     "tweaks/DumpRecordLayoutTests.cpp",
     "tweaks/DumpSymbolTests.cpp",
-    "tweaks/ExpandAutoTypeTests.cpp",
+    "tweaks/ExpandDeducedTypeTests.cpp",
     "tweaks/ExpandMacroTests.cpp",
     "tweaks/ExtractFunctionTests.cpp",
     "tweaks/ExtractVariableTests.cpp",
     "tweaks/MemberwiseConstructorTests.cpp",
     "tweaks/ObjCLocalizeStringLiteralTests.cpp",
     "tweaks/ObjCMemberwiseInitializerTests.cpp",
     "tweaks/PopulateSwitchTests.cpp",
     "tweaks/RawStringLiteralTests.cpp",
     "tweaks/RemoveUsingNamespaceTests.cpp",
     "tweaks/ShowSelectionTreeTests.cpp",
     "tweaks/SwapIfBranchesTests.cpp",
     "tweaks/TweakTesting.cpp",
     "tweaks/TweakTests.cpp",
   ]
 }