[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

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

71

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

1 ↗

(On Diff #202920)

update filename

(these headers are so silly :-()

21 ↗

(On Diff #202920)

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

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

249

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

33

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

to avoid triggering in e.g. dependent code like

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

40

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

48

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

54

nit: this is just CachedLocation->getSourceRange()

56

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.

69

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?

71

(nit: for loop in disguise!)

109

also a for loop in disguise

112

nit: you can combine these with

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

113

nit: prefer auto*

114

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

626

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

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

33

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

40

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

48

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

54

correct.

69

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

249

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 = []{};

626

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

unsigned rather than u_int (just common llvm style)

clang-tools-extra/clangd/AST.h

79

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

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

107

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

108

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.

109

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).

109

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

35

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 :-)

43

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"
 
 namespace clang {
 class SourceManager;
 class Decl;
 
 namespace clangd {
 
 /// Returns true if the declaration is considered implementation detail based on
 /// heuristics. For example, a declaration whose name is not explicitly spelled

 /// FIXME: the USR semantics might not be stable enough as the ID for index
 /// 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);
 
+/// Returns a QualType as string.
+std::string printType(const QualType QT, const DeclContext & Context);
+
+/// 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.
+/// FIXME: change type of parameter CurrentNamespace to DeclContext ,
+/// take in to account using directives etc
+/// Example: shortenNamespace("ns1::MyClass<ns1::OtherClass>", "ns1")
+///    --> "MyClass<ns1::OtherClass>"
+std::string  shortenNamespace(const llvm::StringRef OriginalName,
+                              const llvm::StringRef CurrentNamespace);
+
+
 } // namespace clangd
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_AST_H_

clang-tools-extra/clangd/AST.cpp

llvm::Optional<SymbolID> getSymbolID(const IdentifierInfo &II,
   if (MI == nullptr)
     return None;
   llvm::SmallString<128> USR;
   if (index::generateUSRForMacro(II.getName(), MI->getDefinitionLoc(), SM, USR))
     return None;
   return SymbolID(USR);
 }
 
+std::string 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());
+
+  unsigned 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 printType(const QualType QT, const DeclContext & Context){
+  PrintingPolicy PP(Context.getParentASTContext().getPrintingPolicy());
+  PP.SuppressTagKeyword = 1;
+  return shortenNamespace(
+      QT.getAsString(PP),
+      printNamespaceScope(Context) );
+}
+
+
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/Selection.h

struct Node {
     // The parent within the selection tree. nullptr for TranslationUnitDecl.
     Node *Parent;
     // Direct children within the selection tree.
     llvm::SmallVector<const Node *, 8> Children;
     // The corresponding node from the full AST.
     ast_type_traits::DynTypedNode ASTNode;
     // The extent to which this node is covered by the selection.
     Selection Selected;
+    // Walk up the AST to get the DeclContext of this Node.
+    const DeclContext& getDeclContext() const;
+
   };
 
   // The most specific common ancestor of all the selected nodes.
   // If there is no selection, this is nullptr.
   const Node *commonAncestor() const;
   // The selection node corresponding to TranslationUnitDecl.
   // If there is no selection, this is nullptr.
   const Node *root() const { return Root; }
 
 private:
   std::deque<Node> Nodes; // Stable-pointer storage.
   const Node *Root;
   clang::PrintingPolicy PrintPolicy;
 
   void print(llvm::raw_ostream &OS, const Node &N, int Indent) const;
   friend llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                                        const SelectionTree &T) {
     if (auto R = T.root())
       T.print(OS, *R, 0);

clang-tools-extra/clangd/Selection.cpp

const Node *SelectionTree::commonAncestor() const {
   for (const Node *Ancestor = Root;; Ancestor = Ancestor->Children.front()) {
     if (Ancestor->Selected || Ancestor->Children.size() > 1)
       return Ancestor;
     // The tree only contains ancestors of the interesting nodes.
     assert(!Ancestor->Children.empty() && "bad node in selection tree");
   }
 }
 
+const DeclContext& SelectionTree::Node::getDeclContext() const {
+  for (const Node* CurrentNode = this; CurrentNode != nullptr;
+       CurrentNode = CurrentNode->Parent) {
+    if (const Decl* Current = CurrentNode->ASTNode.get<Decl>()) {
+      return *Current->getDeclContext();
+    }
+  }
+  // A tree must always be rooted at TranslationUnitDecl, so this part
+  // should not be reachable.
+  assert(!"Unreachable code");
+  // FIXME: What should we return here?
+}
+
 } // namespace clangd
 } // namespace clang

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).
+/// Retuns None unless SourceLocationBeg starts an auto/decltype token.
+/// It will return the underlying type.
+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

 # clangd/tool/CMakeLists.txt for an example.
 add_clang_library(clangDaemonTweaks OBJECT
   AnnotateHighlightings.cpp
   DumpAST.cpp
   ExpandMacro.cpp
   RawStringLiteral.cpp
   SwapIfBranches.cpp
   ExtractVariable.cpp
+  ExpandAutoType.cpp
 
   LINK_LIBS
   clangAST
   clangBasic
   clangDaemon
   clangToolingCore
   clangToolingSyntax
   )

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 "refactor/Tweak.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 <AST.h>
+#include "XRefs.h"
+#include "llvm/ADT/StringExtras.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;
+
+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);
+
+};
+
+REGISTER_TWEAK(ExpandAutoType)
+
+std::string ExpandAutoType::title() const { return "expand auto type"; }
+
+bool ExpandAutoType::prepare(const Selection& Inputs) {
+  CachedLocation = llvm::None;
+  if (auto *Node = Inputs.ASTSelection.commonAncestor()) {
+    if (auto *TypeNode = Node->ASTNode.get<TypeLoc>()) {
+      if (const AutoTypeLoc Result = TypeNode->getAs<AutoTypeLoc>()) {
+        CachedLocation = Result;
+      }
+    }
+  }
+  return (bool) CachedLocation;
+}
+
+Expected<Tweak::Effect> ExpandAutoType::apply(const Selection& Inputs) {
+  auto& SrcMgr = Inputs.AST.getASTContext().getSourceManager();
+
+  llvm::Optional<clang::QualType> DeducedType =
+      getDeducedType(Inputs.AST, CachedLocation->getBeginLoc());
+
+  // if we can't resolve the type, return an error message
+  if (DeducedType == llvm::None || DeducedType->isNull()) {
+    return createErrorMessage("Could not deduce type for 'auto' type", Inputs);
+  }
+
+  // if it's a lambda expression, return an error message
+  if (isa<RecordType>(*DeducedType) and
+      dyn_cast<RecordType>(*DeducedType)->getDecl()->isLambda()) {
+    return createErrorMessage("Could not expand type of lambda expression",
+                              Inputs);
+  }
+
+  // if it's a function expression, return an error message
+  // naively replacing 'auto' with the type will break declarations.
+  if (DeducedType->getTypePtr()->isFunctionPointerType()) {
+    return createErrorMessage("Could not expand type of function pointer",
+                              Inputs);
+  }
+
+  std::string PrettyTypeName = printType(*DeducedType,
+      Inputs.ASTSelection.commonAncestor()->getDeclContext());
+
+  tooling::Replacement
+      Expansion(SrcMgr, CharSourceRange(CachedLocation->getSourceRange(), true),
+                PrettyTypeName);
+
+  return Tweak::Effect::applyEdit(tooling::Replacements(Expansion));
+}
+
+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/ASTTests.cpp

+//===-- ASTTests.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 "AST.h"
+#include "gtest/gtest.h"
+
+namespace clang {
+namespace clangd {
+namespace {
+
+TEST(ExpandAutoType, ShortenNamespace) {
+  ASSERT_EQ("TestClass", shortenNamespace("TestClass", ""));
+
+  ASSERT_EQ("TestClass", shortenNamespace(
+      "testnamespace::TestClass", "testnamespace"));
+
+  ASSERT_EQ(
+      "namespace1::TestClass",
+      shortenNamespace("namespace1::TestClass", "namespace2"));
+
+  ASSERT_EQ("TestClass",
+            shortenNamespace("testns1::testns2::TestClass",
+                             "testns1::testns2"));
+
+  ASSERT_EQ(
+      "testns2::TestClass",
+      shortenNamespace("testns1::testns2::TestClass", "testns1"));
+
+  ASSERT_EQ("TestClass<testns1::OtherClass>",
+            shortenNamespace(
+                "testns1::TestClass<testns1::OtherClass>", "testns1"));
+}
+
+
+} // namespace
+} // namespace clangd
+} // namespace clang

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

if (EXISTS ${LLVM_MAIN_SRC_DIR}/lib/Testing/Support
     add_subdirectory(${LLVM_MAIN_SRC_DIR}/lib/Testing/Support
       lib/Testing/Support)
   endif()
 endif()
 
 add_custom_target(ClangdUnitTests)
 add_unittest(ClangdUnitTests ClangdTests
   Annotations.cpp
+  ASTTests.cpp
   BackgroundIndexTests.cpp
   CancellationTests.cpp
   CanonicalIncludesTests.cpp
   ClangdTests.cpp
   ClangdUnitTests.cpp
   CodeCompleteTests.cpp
   CodeCompletionStringsTests.cpp
   ContextTests.cpp

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>
 
 using llvm::Failed;
 using llvm::Succeeded;
 
 namespace clang {
 namespace clangd {
 namespace {
 
 std::string markRange(llvm::StringRef Code, Range R) {

 
 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"));
int a = 123 EMPTY_FN(1) ^EMPTY;
   )cpp",
                  R"cpp(
 #define EMPTY
 #define EMPTY_FN(X)
 int a = 123 EMPTY_FN(1) ;
   )cpp");
 }
 
+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 deduce type for 'auto' type");
+
+  // undefined functions should not be replaced
+  Input = R"cpp(
+    a^uto x = doesnt_exist();
+  )cpp";
+  checkApplyContainsError(ID, Input, "Could not deduce type for 'auto' type");
+
+  // function pointers should not be replaced
+  Input = R"cpp(
+    int foo();
+    au^to x = &foo;
+  )cpp";
+  checkApplyContainsError(ID, Input,
+      "Could not expand type of function pointer");
+
+  // lambda types are not replaced
+  Input = R"cpp(
+    au^to x = []{};
+  )cpp";
+  checkApplyContainsError(ID, Input,
+      "Could not expand type of lambda expression");
+
+  // inline namespaces
+  Input = R"cpp(
+    inline namespace x {
+      namespace { struct S; }
+    }
+    au^to y = S();
+  )cpp";
+  Output = R"cpp(
+    inline namespace x {
+      namespace { struct S; }
+    }
+    S y = S();
+  )cpp";
+
+  // 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);
+
+}
+
 } // 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(GetDeducedType, KwAutoExpansion) {
+  struct Test {
+    StringRef AnnotatedCode;
+    const char *DeducedType;
+  } 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.DeducedType);
+    }
+  }
+}
+
 } // namespace
 } // namespace clangd
 } // namespace clang