[clangd] Implementation of auto type expansion.

[kuhnel]

Summary

Add a tweak for clangd to replace an auto keyword to the deduced type.

This way a user can declare something with auto and then have the IDE/clangd replace auto with whatever type clangd thinks it is. In case of long/complext types this makes is reduces writing effort for the user.

The functionality is similar to the hover over the auto keyword.

Example (from the header):

/// Before:
///    auto x = Something();
///    ^^^^
/// After:
///    MyClass x = Something();
///    ^^^^^^^

[sammccall]

Sorry about the delay here. Happy to chat offline if I'm being confusing.

clang-tools-extra/clangd/AST.cpp

172 ↗

(On Diff #202920)

It looks like this has been moved from somewhere (at least code looks familiar) but isn't deleted anywhere. (The code in XRefs is touched but doesn't seem to use this). Is there a reason we can't reuse one copy?

clang-tools-extra/clangd/AST.h

72

nit: deduced
(also docs! In particular the fact that the SearchedLocation should point to exactly an auto, decltype etc token)

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

77

This is nice. We might want to move it to SourceCode.h, somewhere near SplitQualifiedName. Then we'd generally unit test all the cases in SourceCodeTests, and we only have to smoke test the shortening here.

One limitation is that it only handles shortening the qualifier on the name itself, but not other parts of a printed type. e.g. namespace ns { struct S(); auto* x = new std::vector<S>(); } will expand to std::vector<ns::S>, not std::vector<S>. To fully solve this we may want to modify PrintingPolicy at some point, though we could probably get a long way by searching for chunks of text inside printed types that look like qualified names.

I think it might more clearly communicate the limitations if this function operated on the scope part only, e.g. printScope("clang::clangd::", "clang::") --> "clangd::".

In the general case, CurrentNamespace should be a vector, because there can be others (introduced by using-declarations). Fine to leave this as a fixme if it's hard to do here, though.

77

StringRefs are passed by value. They're just shorthand for a char* + length.

clang-tools-extra/clangd/refactor/tweaks/ExpandAutoType.h

2

update filename

(these headers are so silly :-()

22

Maybe add a FIXME to handle decltype here too? It's pretty similar (though rarer).

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

250

can you add testcases for:

• unknown types in a template template <typename T> void x() { auto y = T::z(); }
• broken code auto x = doesnt_exist();
• lambda auto x = []{};
• inline/anon namespace: inline namespace x { namespace { struct S; } } auto y = S(); should insert "S" not "x::S" or "(anonymous)::S".
• local class: namespace x { void y() { struct S{}; auto z = S(); } } (should insert "S")

(it's ok if the behavior is bad in these cases, we can fix that later. Ideal in first 3 is no change)

[kuhnel]

fixed code review comments from sam

[kuhnel]

fixed merge error around hasDeducedType

[lebedev.ri]

The patch is completely missing description.

[sammccall]

Let's chat offline about how to land this.

Main points are:

• we may just be able to use the AutoTypeLoc instead of the separate RecursiveASTVisitor. (If so, we can do more checks in prepare())
• I have lots of questions about where to draw the line on pretty-printing, and whether the initial version here is a useful first step. Maybe we should just move this part to AST.h and stub it out, with a plan to incrementally improve later.

clang-tools-extra/clangd/AST.h

20

(can now revert this change)

clang-tools-extra/clangd/XRefs.h

143

Can you elaborate slightly whether this returns the AutoType/DecltypeType or its underlying type?

144

nit: I'd change the second sentence to be "Retuns None unless SourceLocationBeg starts an auto/decltype token".

The current wording isn't totally specific about the token, or what happens in other cases (UB is common for preconditions)

150

This appears to be unused, and isn't really worth having unless it's significantly more efficient than getDeducedType().hasValue() and we think that matters.

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

32

&& !CachedLocation->getTypePtr()->getDeducedType()->isNull()?

to avoid triggering in e.g. dependent code like

template <typename T> void f() {
auto X = T::foo();
}

39

is this ever not just CachedLocation->getTypePtr()->getDeducedType()?

47

again, this is actually a cheap test (if we don't need to use the deduced type visitor), we can lift it into prepare

53

nit: this is just CachedLocation->getSourceRange()

55

this logic around pretty-printing a type for insertion in code is going to be:

• eventually more complicated than this: (e.g. this won't trim the "clangd" from std::vector<clangd::Tweak>)
• needed in several places, like "extract expression" refactoring
• fairly easily isolated from the rest of the code here

Can we move this to AST.h, with some signature like:
std::string printType(QualType, DeclContext &)

Note that the namespace and (most) governing using decls/directives can be obtained from the DC (printNamespaceScope in AST.h).
The limitations in the current version are fine for now, but we should document them.

68

I'm confused about this - how can the user select the child of an AutoTypeLoc rather than the AutoTypeLoc itself? i.e. do we need the loop?

70

(nit: for loop in disguise!)

108

also a for loop in disguise

111

nit: you can combine these with

if (const auto* NSD = dyn_cast_or_null<NamespaceDecl>(Node->ASTNode.get<Decl>()))

112

nit: prefer auto*

113

with namespaces, both inline and (probably) anonymous namespaces should be ignored, which I don't think this function will do.

note there can also be non-namespace qualifiers like MyClass::MyNestedClass.

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

396

can we have one for function pointers?

int foo();
auto x = &foo;

The correct replacement would be int (*x)() = &foo; but I think we should just aim to produce no edits in such cases.

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

2111

(still "deducted" here)

[kuhnel]

Allrighty then, next update:

• moved 2 helper funtions to AST.cpp
• added ASTTests.cpp
• added more tests
• removed a lot of redundant code
• implemented corner case for not replacing function pointers
• removed unwanted header file

clang-tools-extra/clangd/AST.cpp

172 ↗

(On Diff #202920)

Ah interesting. It got messed up during rebase and someone implemented a similar function in XRefs.cpp in the mean time. So I'll just move over to their implementation. And remove the changes to AST...

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

32

I added the new testcase and if fails with and without the added condition.

39

There is some difference, because quite a few tests fail, wenn I use your call. --> Staying with current implementation

47

Then I would have to move the call to getDeducedType(...) also to prepare....

53

correct.

68

At first I understood that we would have to walk the AST, but it seems we don't have to...

77

1. added documentation on that.

2. In general it would be nicer to do these operations on a some model and not on bare strings. We could probably recursively search for more namespaces inside angle brackets <>...

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

250

Did not add tests, as the code does not yet support this:

• inline/anon namespace: inline namespace x { namespace { struct S; } } auto y = S(); should insert "S" not "x::S" or "(anonymous)::S".
• local class: namespace x { void y() { struct S{}; auto z = S(); } } (should insert "S")

This requires some changes on how I identify the namespaces. I would do that in a second version/increment of the feature.

Working:

• unknown types in a template template <typename T> void x() { auto y = T::z(); }
• broken code auto x = doesnt_exist();
• lambda auto x = []{};

396

You're an infinite oracle of strange C++ corner cases ;)
I added a test and another check for this case...

[kuhnel]

fixed typo on "Deducted"

[sammccall]

Great, let's land this!
We can enhance further later, but this covers the most common cases.

(I think the remaining comments are trivial - then I/you can land without further review)

clang-tools-extra/clangd/AST.cpp

181 ↗

(On Diff #208706)

unsigned rather than u_int (just common llvm style)

clang-tools-extra/clangd/AST.h

80

can you leave a FIXME that this should take a DeclContext for lookup instead of the current namespace name, take in to account using directives etc?
(Otherwise it's not obvious why it belongs in AST instead of SourceCode - but it does)

clang-tools-extra/clangd/Selection.cpp

369 ↗

(On Diff #208706)

I think this function is not quite correct. At least, it returns the enclosing DC outside the enclosing Decl, but that doesn't seem quite right.

There are three critical cases:

• StartNode is a DeclContext
• StartNode is (e.g.) an Expr whose containing Decl is a DeclContext
• StartNode is an Expr whose containing Decl is not a DeclContext

Currently, you return the second, second, and first DeclContext encountered, respectively.

• If the definition is "enclosing DC that is not the node itself", it should be second, first, first.
• If the definition is "enclosing DC that may be the node itself", it should be first, first, first.

I think "enclosing DC that's not the node itself" is simplest in which case you should add something like if (CurrentNode != StartNode) if (auto *DC = dyn_cast<DeclContext>(DC)) return DC; in the inner if.

clang-tools-extra/clangd/Selection.h

104 ↗

(On Diff #208706)

, which is not the node itself. (Is this the intended behavior? worth calling out either way)

105 ↗

(On Diff #208706)

Thinking about this again - this can't ever happen, it violates the invariant that a tree must be rooted at TranslationUnitDecl. Just return a reference and add an assert to the implementation.

106 ↗

(On Diff #208706)

nit: I think this would be slightly clearer as a (non-static) member function on Node. (It also makes it obvious node can't be null).

106 ↗

(On Diff #208706)

please run git clang-format.
(LLVM uses type *var not type* var)

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

89

comment should say why
// naively replacing 'auto' with the type will break declarations.

90

no need for this first check/cast: isFunctionPointerType is a member of Type

91

please also check isFunctionReferenceType, isMemberPointerType, isArrayType for the same reason

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

34 ↗

(On Diff #208706)

rather than commenting out the test, assert the (bad) behavior and keep the comment.
That way someone gets a happy surprise when they fix it :-)

42 ↗

(On Diff #208706)

delete the comment unless the tests will be added in this patch :-)

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

23

remove

[kuhnel]

fixed parts of the 3rd round of review comments

[kuhnel]

pair programming with Sam, fixed final issues

[thakis]

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

54 ↗

(On Diff #209240)

FYI, referring to a file opened as test:///foo.cpp as file:///clangd-test/file.cpp is wrong on Windows. I fixed this in rL374746.

clang-tools-extra/clangd/AST.h

 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_AST_H_
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_AST_H_
 
 #include "index/SymbolID.h"
 #include "clang/AST/Decl.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Lex/MacroInfo.h"
+#include "clang/AST/RecursiveASTVisitor.h"
 
 namespace clang {
 class SourceManager;
 class Decl;
 
 namespace clangd {
 
 /// Returns true if the declaration is considered implementation detail based on

 /// macro (e.g. a change in definition offset can result in a different USR). We
 /// could change these semantics in the future by reimplementing this funcure
 /// (e.g. avoid USR for macros).
 llvm::Optional<SymbolID> getSymbolID(const IdentifierInfo &II,
                                      const MacroInfo *MI,
                                      const SourceManager &SM);
 
 } // namespace clangd
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_AST_H_

clang-tools-extra/clangd/XRefs.h

 /// Given a record type declaration, find its base (parent) types.
 std::vector<const CXXRecordDecl *> typeParents(const CXXRecordDecl *CXXRD);
 
 /// Get type hierarchy information at \p Pos.
 llvm::Optional<TypeHierarchyItem> getTypeHierarchy(
     ParsedAST &AST, Position Pos, int Resolve, TypeHierarchyDirection Direction,
     const SymbolIndex *Index = nullptr, PathRef TUPath = PathRef{});
 
+/// Retrieves the deduced type at a given location (auto, decltype).
+/// SourceLocationBeg must point to the first character of the token
+llvm::Optional<QualType> getDeducedType(ParsedAST &AST,
+                                        SourceLocation SourceLocationBeg);
+
+/// Check if there is a deduced type at a given location (auto, decltype).
+/// SourceLocationBeg must point to the first character of the token
+bool hasDeducedType(ParsedAST &AST, SourceLocation SourceLocationBeg);
+
 } // namespace clangd
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_XREFS_H

clang-tools-extra/clangd/XRefs.cpp

public:
   }
 
   QualType DeducedType;
   const Decl *D = nullptr;
 };
 } // namespace
 
 /// Retrieves the deduced type at a given location (auto, decltype).
-bool hasDeducedType(ParsedAST &AST, SourceLocation SourceLocationBeg) {
+/// SourceLocationBeg must point to the first character of the token
+llvm::Optional<QualType> getDeducedType(ParsedAST &AST,
+                                        SourceLocation SourceLocationBeg) {
   Token Tok;
   auto &ASTCtx = AST.getASTContext();
   // Only try to find a deduced type if the token is auto or decltype.
   if (!SourceLocationBeg.isValid() ||
       Lexer::getRawToken(SourceLocationBeg, Tok, ASTCtx.getSourceManager(),
                          ASTCtx.getLangOpts(), false) ||
       !Tok.is(tok::raw_identifier)) {
-    return false;
+    return {};
   }
   AST.getPreprocessor().LookUpIdentifierInfo(Tok);
   if (!(Tok.is(tok::kw_auto) || Tok.is(tok::kw_decltype)))
-    return false;
-  return true;
+    return {};
+
+  DeducedTypeVisitor V(SourceLocationBeg);
+  V.TraverseAST(AST.getASTContext());
+  return V.DeducedType;
+}
+
+/// Retrieves the deduced type at a given location (auto, decltype).
+bool hasDeducedType(ParsedAST &AST, SourceLocation SourceLocationBeg) {
+  return (bool) getDeducedType(AST, SourceLocationBeg);
 }
 
 llvm::Optional<HoverInfo> getHover(ParsedAST &AST, Position Pos,
                                    format::FormatStyle Style) {
   llvm::Optional<HoverInfo> HI;
   SourceLocation SourceLocationBeg = getBeginningOfIdentifier(
       AST, Pos, AST.getSourceManager().getMainFileID());
   // Identified symbols at a specific position.

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

 # constructors that register individual tweaks in a global registry.
 # To enable these tweaks in executables or shared libraries, add
 # $<TARGET_OBJECTS:obj.clangDaemonTweaks> to a list of sources, see
 # clangd/tool/CMakeLists.txt for an example.
 add_clang_library(clangDaemonTweaks OBJECT
   DumpAST.cpp
   RawStringLiteral.cpp
   SwapIfBranches.cpp
+  ExpandAutoType.cpp
 
   LINK_LIBS
   clangAST
   clangBasic
   clangDaemon
   clangToolingCore
   )

clang-tools-extra/clangd/refactor/tweaks/ExpandAutoType.h

+//===--- ExpandAutoType.h ----------------------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_REFACTOR_ACTIONS_TWEAKS_EXPANDAUTO_TYPE_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_REFACTOR_ACTIONS_TWEAKS_EXPANDAUTO_TYPE_H
+#include "refactor/Tweak.h"
+
+namespace clang {
+namespace clangd {
+/// 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 {
+public:
+  const char *id() const final;
+  Intent intent() const override { return Intent::Refactor;}
+  bool prepare(const Selection &Inputs) override;
+  Expected<Effect> apply(const Selection &Inputs) override;
+  std::string title() const override;
+
+protected:
+  /// Walk up the AST from the given Node to find the next AutoTypeLoc,
+  /// if it exists 
+  const llvm::Optional<AutoTypeLoc>
+  findAutoType(const SelectionTree::Node *Node);
+
+  /// Get the namespaces of a node as string, e.g.
+  /// outernamespace::innernamespace.
+  static std::string getNamespaceString(const SelectionTree::Node *Node);
+
+  /// Try to shorten the OriginalName by removing namespaces from the left of 
+  /// the string that are redundant in the CurrentNamespace. This way the type 
+  /// idenfier become shorter and easier to read.
+  /// Limitation: It only handles the qualifier of the type itself, not that of 
+  /// templates.
+  /// Example: shortenNamespace("ns1::MyClass<ns1::OtherClass>", "ns1")
+  ///    --> "MyClass<ns1::OtherClass>"
+  static std::string shortenNamespace(llvm::StringRef OriginalName,
+                                      llvm::StringRef CurrentNamespace);
+
+private:
+  /// Cache the AutoTypeLoc, so that we do not need to search twice.
+  llvm::Optional<clang::AutoTypeLoc> CachedLocation;
+  
+  // Create an error message with filename and line number in it
+  llvm::Error createErrorMessage(const std::string& Message,
+                                 const Selection &Inputs);
+
+};
+
+} // namespace clangd
+} // namespace clang
+
+#endif
 No newline at end of file

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

+//===--- ReplaceAutoType.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 "ExpandAutoType.h"
+
+#include "Logger.h"
+#include "clang/AST/Type.h"
+#include "clang/AST/TypeLoc.h"
+#include "clang/Basic/LLVM.h"
+#include "llvm/ADT/None.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/Error.h"
+#include <climits>
+#include <memory>
+#include <string>
+#include "XRefs.h"
+#include "llvm/ADT/StringExtras.h"
+
+namespace clang {
+namespace clangd {
+
+REGISTER_TWEAK(ExpandAutoType)
+
+bool ExpandAutoType::prepare(const Selection& Inputs) {
+  auto Node = Inputs.ASTSelection.commonAncestor();
+  CachedLocation = findAutoType(Node);
+  return CachedLocation != llvm::None;
+}
+
+Expected<Tweak::Effect> ExpandAutoType::apply(const Selection& Inputs) {
+  auto& SrcMgr = Inputs.AST.getASTContext().getSourceManager();
+
+  llvm::Optional<clang::QualType> DeductedType =
+      getDeducedType(Inputs.AST, CachedLocation->getBeginLoc());
+
+  // if we can't resolve the type, return an error message
+  if (DeductedType == llvm::None || DeductedType->isNull()) {
+    return createErrorMessage("Could not deduct type for 'auto' type", Inputs);
+  }
+
+  // if it's a lambda expression, return an error message
+  if (isa<RecordType>(*DeductedType) and
+      dyn_cast<RecordType>(*DeductedType)->getDecl()->isLambda()) {
+    return createErrorMessage("Could not expand type of lambda expression",
+                              Inputs);
+  }
+
+  SourceRange OriginalRange(CachedLocation->getBeginLoc(),
+                            CachedLocation->getEndLoc());
+  PrintingPolicy PP(Inputs.AST.getASTContext().getPrintingPolicy());
+  PP.SuppressTagKeyword = 1;
+  std::string PrettyTypeName = shortenNamespace(
+      DeductedType->getAsString(PP),
+      getNamespaceString(Inputs.ASTSelection.commonAncestor()));
+  tooling::Replacement Expansion(SrcMgr, CharSourceRange(OriginalRange, true),
+                                 PrettyTypeName);
+
+  return Tweak::Effect::applyEdit(tooling::Replacements(Expansion));
+}
+
+// try to find an 'auto' type location from the Selection
+const llvm::Optional<AutoTypeLoc>
+ExpandAutoType::findAutoType(const SelectionTree::Node* StartNode) {
+  auto Node = StartNode;
+  while (Node != nullptr) {
+    auto TypeNode = Node->ASTNode.get<TypeLoc>();
+    if (TypeNode) {
+      if (const AutoTypeLoc Result = TypeNode->getAs<AutoTypeLoc>()) {
+        return Result;
+      }
+    }
+    Node = Node->Parent;
+  }
+  return llvm::None;
+}
+
+std::string ExpandAutoType::title() const { return "expand auto type"; }
+
+std::string
+ExpandAutoType::shortenNamespace(const llvm::StringRef OriginalName,
+                                 const llvm::StringRef CurrentNamespace) {
+  llvm::SmallVector<llvm::StringRef, 8> OriginalParts;
+  llvm::SmallVector<llvm::StringRef, 8> CurrentParts;
+  llvm::SmallVector<llvm::StringRef, 8> Result;
+  OriginalName.split(OriginalParts, "::");
+  CurrentNamespace.split(CurrentParts, "::");
+  auto MinLength = std::min(CurrentParts.size(), OriginalParts.size());
+
+  u_int DifferentAt = 0;
+  while (DifferentAt < MinLength &&
+      CurrentParts[DifferentAt] == OriginalParts[DifferentAt]) {
+    DifferentAt++;
+  }
+
+  for (u_int i = DifferentAt; i < OriginalParts.size(); ++i) {
+    Result.push_back(OriginalParts[i]);
+  }
+  return join(Result, "::");
+}
+
+std::string ExpandAutoType::getNamespaceString(
+    const SelectionTree::Node* StartNode) {
+  auto Node = StartNode;
+  while (Node != nullptr) {
+    LLVM_DEBUG(Node->ASTNode.print());
+    if (const Decl* Current = Node->ASTNode.get<Decl>()) {
+      if (auto CurrentNameSpace = dyn_cast<NamespaceDecl>(Current)) {
+        return CurrentNameSpace->getQualifiedNameAsString();
+      }
+    }
+    Node = Node->Parent;
+  }
+  return "";
+}
+
+llvm::Error ExpandAutoType::createErrorMessage(const std::string& Message,
+                                               const Selection& Inputs) {
+  auto& SrcMgr = Inputs.AST.getASTContext().getSourceManager();
+  std::string ErrorMessage =
+      Message + ": " +
+          SrcMgr.getFilename(Inputs.Cursor).str() + " Line " +
+          std::to_string(SrcMgr.getExpansionLineNumber(Inputs.Cursor));
+
+  return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                 ErrorMessage.c_str());
+}
+
+} // namespace clangd
+} // namespace clang

clang-tools-extra/clangd/test/code-action-request.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": 1,
+  "method": "textDocument/codeAction",
+  "params": {
+    "textDocument": {
+      "uri": "test:///main.cpp"
+    },
+        "range": {
+            "start": {
+                "line": 0,
+                "character": 0
+            },
+            "end": {
+                "line": 0,
+                "character": 4
+            }
+        },
+        "context": {
+            "diagnostics": []
+        }
+    }
+}
+#      CHECK:  "id": 1,
+# CHECK-NEXT:  "jsonrpc": "2.0",
+# CHECK-NEXT:  "result": [
+# CHECK-NEXT:    {
+# CHECK-NEXT:      "arguments": [
+# CHECK-NEXT:        {
+# CHECK-NEXT:          "file": "file:///clangd-test/main.cpp",
+# CHECK-NEXT:          "selection": {
+# 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:          },
+# CHECK-NEXT:          "tweakID": "ExpandAutoType"
+# CHECK-NEXT:        }
+# CHECK-NEXT:      ],
+# CHECK-NEXT:      "command": "clangd.applyTweak",
+# CHECK-NEXT:      "title": "expand auto type"
+# CHECK-NEXT:    }
+# CHECK-NEXT:  ]
+---
+{"jsonrpc":"2.0","id":4,"method":"workspace/executeCommand","params":{"command":"clangd.applyTweak","arguments":[{"file":"file:///clangd-test/main.cpp","selection":{"end":{"character":4,"line":0},"start":{"character":0,"line":0}},"tweakID":"ExpandAutoType"}]}}
+#      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":4,"method":"shutdown"}
+---
+{"jsonrpc":"2.0","method":"exit"}
+---
 No newline at end of file

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

 //===-- TweakTests.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 "Annotations.h"
 #include "SourceCode.h"
 #include "TestTU.h"
 #include "refactor/Tweak.h"
 #include "clang/AST/Expr.h"
+#include "clang/Basic/LLVM.h"
 #include "clang/Rewrite/Core/Rewriter.h"
 #include "clang/Tooling/Core/Replacement.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Testing/Support/Error.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <cassert>
+#include "refactor/tweaks/ExpandAutoType.h"
 
 using llvm::Failed;
 using llvm::Succeeded;
 
 namespace clang {
 namespace clangd {
 namespace {
 

 
 void checkTransform(llvm::StringRef ID, llvm::StringRef Input,
                     std::string Output) {
   auto Result = applyEdit(ID, Input);
   ASSERT_TRUE(bool(Result)) << llvm::toString(Result.takeError()) << Input;
   EXPECT_EQ(Output, std::string(*Result)) << Input;
 }
 
+/// Check if apply returns an error and that the @ErrorMessage is contained
+/// in that error
+void checkApplyContainsError(llvm::StringRef ID, llvm::StringRef Input,
+                             const std::string& ErrorMessage) {
+  auto Result = apply(ID, Input);
+  EXPECT_FALSE(Result) << "expected error message:\n   " << ErrorMessage <<
+                       "\non input:" << Input;
+  EXPECT_NE(std::string::npos,
+            llvm::toString(Result.takeError()).find(ErrorMessage))
+            << "Wrong error message:\n  " << llvm::toString(Result.takeError())
+            << "\nexpected:\n  " << ErrorMessage;
+}
+
 TEST(TweakTest, SwapIfBranches) {
   llvm::StringLiteral ID = "SwapIfBranches";
 
   checkAvailable(ID, R"cpp(
     void test() {
       ^i^f^^(^t^r^u^e^) { return 100; } ^e^l^s^e^ { continue; }
     }
   )cpp");

 token
 string
 literal)";
     }
   )cpp";
   checkTransform(ID, Input, Output);
 }
 
 TEST(TweakTest, DumpAST) {
   llvm::StringLiteral ID = "DumpAST";
 
   checkAvailable(ID, "^int f^oo() { re^turn 2 ^+ 2; }");
   checkNotAvailable(ID, "/*c^omment*/ int foo() return 2 ^ + 2; }");
 
   const char *Input = "int x = 2 ^+ 2;";
   auto result = getMessage(ID, Input);
   EXPECT_THAT(result, ::testing::HasSubstr("BinaryOperator"));
TEST(TweakTest, DumpRecordLayout) {
   checkNotAvailable(ID, "struct ^X;");
   checkNotAvailable(ID, "template <typename T> struct ^X { T t; };");
   checkNotAvailable(ID, "enum ^X {};");
 
   const char *Input = "struct ^X { int x; int y; }";
   EXPECT_THAT(getMessage(ID, Input), ::testing::HasSubstr("0 |   int x"));
 }
 
+TEST(TweakTest, ExpandAutoType) {
+  llvm::StringLiteral ID = "ExpandAutoType";
+
+  checkAvailable(ID, R"cpp(
+    ^a^u^t^o^ i = 0;
+  )cpp");
+
+  checkNotAvailable(ID, R"cpp(
+    auto ^i^ ^=^ ^0^;^
+  )cpp");
+
+  llvm::StringLiteral Input = R"cpp(
+    [[auto]] i = 0;
+  )cpp";
+  llvm::StringLiteral Output = R"cpp(
+    int i = 0;
+  )cpp";
+  checkTransform(ID, Input, Output);
+
+  // check primitive type
+  Input = R"cpp(
+    au^to i = 0;
+  )cpp";
+  Output = R"cpp(
+    int i = 0;
+  )cpp";
+  checkTransform(ID, Input, Output);
+
+  // check classes and namespaces
+  Input = R"cpp(
+    namespace testns {
+      class TestClass {
+        class SubClass {};
+      };
+    }
+    ^auto C = testns::TestClass::SubClass();
+  )cpp";
+  Output = R"cpp(
+    namespace testns {
+      class TestClass {
+        class SubClass {};
+      };
+    }
+    testns::TestClass::SubClass C = testns::TestClass::SubClass();
+  )cpp";
+  checkTransform(ID, Input, Output);
+
+  // check that namespaces are shortened
+  Input = R"cpp(
+    namespace testns {
+    class TestClass {
+    };
+    void func() { ^auto C = TestClass(); }
+    }
+  )cpp";
+  Output = R"cpp(
+    namespace testns {
+    class TestClass {
+    };
+    void func() { TestClass C = TestClass(); }
+    }
+  )cpp";
+  checkTransform(ID, Input, Output);
+
+  // unknown types in a template should not be replaced
+  Input = R"cpp(
+    template <typename T> void x() {
+        ^auto y =  T::z();
+        }
+  )cpp";
+  checkApplyContainsError(ID, Input, "Could not deduct type for 'auto' type");
+
+  // undefined functions should not be replaced
+  Input = R"cpp(
+    a^uto x = doesnt_exist();
+  )cpp";
+  checkApplyContainsError(ID, Input, "Could not deduct type for 'auto' type");
+
+  // lambda types are not replaced
+  Input = R"cpp(
+    au^to x = []{};
+  )cpp";
+  checkApplyContainsError(ID, Input,
+      "Could not expand type of lambda expression");
+
+  // local class
+  Input = R"cpp(
+  namespace x {
+    void y() {
+      struct S{};
+      a^uto z = S();
+  }}
+  )cpp";
+  Output = R"cpp(
+  namespace x {
+    void y() {
+      struct S{};
+      S z = S();
+  }}
+  )cpp";
+  checkTransform(ID, Input, Output);
+}
+
+TEST(ExpandAutoType, GetNamespaceString) {
+  struct EATWrapper : ExpandAutoType {
+    // to access the protected method
+    using ExpandAutoType::getNamespaceString;
+  };
+
+  auto GetNamespaceString = [](std::string CppCode) {
+    TestTU TU;
+    TU.Filename = "foo.cpp";
+    Annotations Code(CppCode);
+    TU.Code = Code.code();
+    ParsedAST AST = TU.build();
+    assert(AST.getDiagnostics().empty());
+    auto Tree = SelectionTree(
+        AST.getASTContext(),
+        static_cast<unsigned int>(*positionToOffset(Code.code(),
+                                                    Code.point())));
+    return EATWrapper::getNamespaceString(Tree.commonAncestor());
+  };
+
+  ASSERT_EQ("firstns::secondns",
+            GetNamespaceString(
+                "namespace firstns{namespace secondns{ au^to i = 0;} }"));
+}
+
+TEST(ExpandAutoType, ShortenNamespace) {
+  struct EATWrapper : ExpandAutoType {
+    // to access the protected method
+    using ExpandAutoType::shortenNamespace;
+  };
+
+  ASSERT_EQ("TestClass", EATWrapper::shortenNamespace("TestClass", ""));
+
+  ASSERT_EQ("TestClass", EATWrapper::shortenNamespace(
+                             "testnamespace::TestClass", "testnamespace"));
+
+  ASSERT_EQ(
+      "namespace1::TestClass",
+      EATWrapper::shortenNamespace("namespace1::TestClass", "namespace2"));
+
+  ASSERT_EQ("TestClass",
+            EATWrapper::shortenNamespace("testns1::testns2::TestClass",
+                                         "testns1::testns2"));
+
+  ASSERT_EQ(
+      "testns2::TestClass",
+      EATWrapper::shortenNamespace("testns1::testns2::TestClass", "testns1"));
+
+  // FIXME: template types are ignored right now, we should add this in the
+  // future
+  ASSERT_EQ("TestClass<testns1::OtherClass>",
+            EATWrapper::shortenNamespace(
+                "testns1::TestClass<testns1::OtherClass>", "testns1"));
+}
+
 } // namespace
 } // namespace clangd
 } // namespace clang

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

for (Test T : Tests) {
     findReferences(AST, File.point(), 0, &Rec);
     if (T.WantQuery)
       EXPECT_NE(Rec.RefIDs, None) << T.AnnotatedCode;
     else
       EXPECT_EQ(Rec.RefIDs, None) << T.AnnotatedCode;
   }
 }
 
+TEST(GetDeductedType, KwAutoExpansion) {
+  struct Test {
+    StringRef AnnotatedCode;
+    const char *DeductedType;
+  } Tests[] = {
+      {"^auto i = 0;", "int"},
+      {"^auto f(){ return 1;};", "int"}
+  };
+  for (Test T : Tests) {
+    Annotations File(T.AnnotatedCode);
+    auto AST = TestTU::withCode(File.code()).build();
+    ASSERT_TRUE(AST.getDiagnostics().empty()) << AST.getDiagnostics().begin()->Message;
+    SourceManagerForFile SM("foo.cpp", File.code());
+
+    for (Position Pos : File.points()) {
+      auto Location = sourceLocationInMainFile(SM.get(), Pos);
+      auto DeducedType = getDeducedType(AST, *Location);
+      EXPECT_EQ(DeducedType->getAsString(), T.DeductedType);
+    }
+  }
+}
+
 } // namespace
 } // namespace clangd
 } // namespace clang