[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 ↗

(On Diff #202920)

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

76 ↗

(On Diff #202920)

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.

76 ↗

(On Diff #202920)

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

221 ↗

(On Diff #202920)

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 ↗

(On Diff #207039)

(can now revert this change)

clang-tools-extra/clangd/XRefs.h

143 ↗

(On Diff #207039)

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

144 ↗

(On Diff #207039)

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 ↗

(On Diff #207039)

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 ↗

(On Diff #207039)

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

to avoid triggering in e.g. dependent code like

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

39 ↗

(On Diff #207039)

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

47 ↗

(On Diff #207039)

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 ↗

(On Diff #207039)

nit: this is just CachedLocation->getSourceRange()

55 ↗

(On Diff #207039)

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 ↗

(On Diff #207039)

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 ↗

(On Diff #207039)

(nit: for loop in disguise!)

108 ↗

(On Diff #207039)

also a for loop in disguise

111 ↗

(On Diff #207039)

nit: you can combine these with

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

112 ↗

(On Diff #207039)

nit: prefer auto*

113 ↗

(On Diff #207039)

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 ↗

(On Diff #207039)

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 ↗

(On Diff #207039)

(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

76 ↗

(On Diff #202920)

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

32 ↗

(On Diff #207039)

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

39 ↗

(On Diff #207039)

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

47 ↗

(On Diff #207039)

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

53 ↗

(On Diff #207039)

correct.

68 ↗

(On Diff #207039)

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

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

396 ↗

(On Diff #207039)

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

221 ↗

(On Diff #202920)

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

[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

79 ↗

(On Diff #208706)

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

88 ↗

(On Diff #208706)

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

89 ↗

(On Diff #208706)

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

90 ↗

(On Diff #208706)

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 ↗

(On Diff #208706)

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

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/trunk/clangd/AST.h

 /// 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/trunk/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/trunk/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,
+    // which is not the node itself.
+    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; }

clang-tools-extra/trunk/clangd/Selection.cpp

const Node *SelectionTree::commonAncestor() const {
   if (!Root)
     return nullptr;
   const Node *Ancestor = Root;
   while (Ancestor->Children.size() == 1 && !Ancestor->Selected)
     Ancestor = Ancestor->Children.front();
   return Ancestor;
 }
 
+const DeclContext& SelectionTree::Node::getDeclContext() const {
+  for (const Node* CurrentNode = this; CurrentNode != nullptr;
+       CurrentNode = CurrentNode->Parent) {
+    if (const Decl* Current = CurrentNode->ASTNode.get<Decl>()) {
+      if (CurrentNode != this)
+        if (auto *DC = dyn_cast<DeclContext>(Current))
+          return *DC;
+      return *Current->getDeclContext();
+    }
+  }
+  llvm_unreachable("A tree must always be rooted at TranslationUnitDecl.");
+}
+
 } // namespace clangd
 } // namespace clang

clang-tools-extra/trunk/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/trunk/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,
                                    const SymbolIndex *Index) {
   llvm::Optional<HoverInfo> HI;
   SourceLocation SourceLocationBeg = getBeginningOfIdentifier(
       AST, Pos, AST.getSourceManager().getMainFileID());

clang-tools-extra/trunk/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/trunk/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.
+  // FIXME: there are other types that have similar problems
+  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/trunk/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/trunk/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/trunk/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/trunk/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>

 
 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);
+  ASSERT_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");
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);
+
+  // replace array types
+  Input = R"cpp(
+    au^to x = "test";
+  )cpp";
+  Output = R"cpp(
+    const char * x = "test";
+  )cpp";
+  checkTransform(ID, Input, Output);
+}
+
 } // namespace
 } // namespace clangd
 } // namespace clang

clang-tools-extra/trunk/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