maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang-tools-extra/clangd/unittests/HoverTests.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

2837 lines
84 KiB
C++
Raw Normal View History

[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
//===-- HoverTests.cpp ----------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
[clangd] Improve documentation for auto and implicit specs Summary: Clangd didn't fill documentation for `auto` when it wasn't available in index. Also it wasn't showing any documentations for implicit instantiations. This patch ensures auto and normal decl case behaves in the same way and also makes use of the explicit template specialization while fetching comments for implicit instantiations. Reviewers: ilya-biryukov Subscribers: MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D71596
2019-12-17 19:13:28 +08:00
#include "AST.h"
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
#include "Annotations.h"
#include "Hover.h"
#include "TestIndex.h"
#include "TestTU.h"
#include "index/MemIndex.h"
[clangd] Add access specifier information to hover contents Summary: For https://github.com/clangd/clangd/issues/382 This commit adds access specifier information to the hover contents. For example, the hover information of a class field or member function will now indicate if the field or member is private, public, or protected. This can be particularly useful when a developer is in the implementation file and wants to know if a particular member definition is public or private. Reviewers: kadircet Reviewed By: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, kadircet, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D80472
2020-05-28 00:17:07 +08:00
#include "clang/Basic/Specifiers.h"
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
#include "clang/Index/IndexSymbol.h"
#include "llvm/ADT/None.h"
#include "llvm/ADT/StringRef.h"
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
#include "gmock/gmock.h"
#include "gtest/gtest.h"
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
#include <string>
#include <vector>
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
namespace clang {
namespace clangd {
namespace {
[clangd] Improve hover on arguments to function call Summary: In cases like: foo(a, ^b); We now additionally show the name and type of the parameter to foo that corresponds that "b" is passed as. The name should help with understanding what it's used for and type can be useful to find out if call to foo() can mutate variable "b" or not (i.e. if it is pass by value, reference, const reference, etc). Patch By: adamcz@ ! Reviewers: kadircet Reviewed By: kadircet Subscribers: nridge, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D81169
2020-07-03 17:20:22 +08:00
using PassMode = HoverInfo::PassType::PassMode;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
TEST(Hover, Structured) {
struct {
const char *const Code;
const std::function<void(HoverInfo &)> ExpectedBuilder;
} Cases[] = {
// Global scope.
{R"cpp(
// Best foo ever.
void [[fo^o]]() {}
)cpp",
[](HoverInfo &HI) {
HI.NamespaceScope = "";
HI.Name = "foo";
[clangd] Store index::SymbolKind in HoverInfo Summary: LSP's SymbolKind has some shortcomings when it comes to C++ types, index::SymbolKind has more detailed info like Destructor, Parameter, MACRO etc. We are planning to make use of that information in our new Hover response, and it would be nice to display the Symbol type in full detail, rather than some approximation. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70723
2019-11-27 01:06:17 +08:00
HI.Kind = index::SymbolKind::Function;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
HI.Documentation = "Best foo ever.";
HI.Definition = "void foo()";
HI.ReturnType = "void";
HI.Type = "void ()";
HI.Parameters.emplace();
}},
// Inside namespace
{R"cpp(
namespace ns1 { namespace ns2 {
/// Best foo ever.
void [[fo^o]]() {}
}}
)cpp",
[](HoverInfo &HI) {
HI.NamespaceScope = "ns1::ns2::";
HI.Name = "foo";
[clangd] Store index::SymbolKind in HoverInfo Summary: LSP's SymbolKind has some shortcomings when it comes to C++ types, index::SymbolKind has more detailed info like Destructor, Parameter, MACRO etc. We are planning to make use of that information in our new Hover response, and it would be nice to display the Symbol type in full detail, rather than some approximation. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70723
2019-11-27 01:06:17 +08:00
HI.Kind = index::SymbolKind::Function;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
HI.Documentation = "Best foo ever.";
HI.Definition = "void foo()";
HI.ReturnType = "void";
HI.Type = "void ()";
HI.Parameters.emplace();
}},
// Field
{R"cpp(
namespace ns1 { namespace ns2 {
struct Foo {
[clangd] show layout info when hovering on a class/field definition. Summary: This triggers only on the definition itself, not on references (probably too noisy). Inspecting the definition seems like a decent hint for being interested in layout. Reviewers: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D77355
2020-04-03 09:07:10 +08:00
char [[b^ar]];
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
};
}}
)cpp",
[](HoverInfo &HI) {
HI.NamespaceScope = "ns1::ns2::";
HI.LocalScope = "Foo::";
HI.Name = "bar";
[clangd] Store index::SymbolKind in HoverInfo Summary: LSP's SymbolKind has some shortcomings when it comes to C++ types, index::SymbolKind has more detailed info like Destructor, Parameter, MACRO etc. We are planning to make use of that information in our new Hover response, and it would be nice to display the Symbol type in full detail, rather than some approximation. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70723
2019-11-27 01:06:17 +08:00
HI.Kind = index::SymbolKind::Field;
[clangd] show layout info when hovering on a class/field definition. Summary: This triggers only on the definition itself, not on references (probably too noisy). Inspecting the definition seems like a decent hint for being interested in layout. Reviewers: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D77355
2020-04-03 09:07:10 +08:00
HI.Definition = "char bar";
HI.Type = "char";
HI.Offset = 0;
HI.Size = 1;
[clangd] Add access specifier information to hover contents Summary: For https://github.com/clangd/clangd/issues/382 This commit adds access specifier information to the hover contents. For example, the hover information of a class field or member function will now indicate if the field or member is private, public, or protected. This can be particularly useful when a developer is in the implementation file and wants to know if a particular member definition is public or private. Reviewers: kadircet Reviewed By: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, kadircet, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D80472
2020-05-28 00:17:07 +08:00
HI.AccessSpecifier = "public";
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}},
// Local to class method.
{R"cpp(
namespace ns1 { namespace ns2 {
struct Foo {
void foo() {
int [[b^ar]];
}
};
}}
)cpp",
[](HoverInfo &HI) {
HI.NamespaceScope = "ns1::ns2::";
HI.LocalScope = "Foo::foo::";
HI.Name = "bar";
[clangd] Store index::SymbolKind in HoverInfo Summary: LSP's SymbolKind has some shortcomings when it comes to C++ types, index::SymbolKind has more detailed info like Destructor, Parameter, MACRO etc. We are planning to make use of that information in our new Hover response, and it would be nice to display the Symbol type in full detail, rather than some approximation. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70723
2019-11-27 01:06:17 +08:00
HI.Kind = index::SymbolKind::Variable;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
HI.Definition = "int bar";
HI.Type = "int";
}},
// Anon namespace and local scope.
{R"cpp(
namespace ns1 { namespace {
struct {
[clangd] show layout info when hovering on a class/field definition. Summary: This triggers only on the definition itself, not on references (probably too noisy). Inspecting the definition seems like a decent hint for being interested in layout. Reviewers: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D77355
2020-04-03 09:07:10 +08:00
char [[b^ar]];
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
} T;
}}
)cpp",
[](HoverInfo &HI) {
[clangd] Fix handling of inline/anon namespaces and names of deduced types in hover Summary: Clangd normally skips inline and anon namespaces while printing nested name specifiers. It also drops any tag specifiers since we make use of `HoverInfo::Kind` instead of some text in `HoverInfo::Name` There was a bug causing us to print innermost inline/anon namespace, this patch fixes that by skipping those. Also changes printing and kind detection of deduced types to be similar to decl case. Also improves printing for lambdas, currently clangd prints lambdas as `(anonymous class)`, we can improve it by at least printing `(lambda)` instead. Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D71543
2019-12-16 21:22:48 +08:00
HI.NamespaceScope = "ns1::";
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
HI.LocalScope = "(anonymous struct)::";
HI.Name = "bar";
[clangd] Store index::SymbolKind in HoverInfo Summary: LSP's SymbolKind has some shortcomings when it comes to C++ types, index::SymbolKind has more detailed info like Destructor, Parameter, MACRO etc. We are planning to make use of that information in our new Hover response, and it would be nice to display the Symbol type in full detail, rather than some approximation. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70723
2019-11-27 01:06:17 +08:00
HI.Kind = index::SymbolKind::Field;
[clangd] show layout info when hovering on a class/field definition. Summary: This triggers only on the definition itself, not on references (probably too noisy). Inspecting the definition seems like a decent hint for being interested in layout. Reviewers: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D77355
2020-04-03 09:07:10 +08:00
HI.Definition = "char bar";
HI.Type = "char";
HI.Offset = 0;
HI.Size = 1;
[clangd] Add access specifier information to hover contents Summary: For https://github.com/clangd/clangd/issues/382 This commit adds access specifier information to the hover contents. For example, the hover information of a class field or member function will now indicate if the field or member is private, public, or protected. This can be particularly useful when a developer is in the implementation file and wants to know if a particular member definition is public or private. Reviewers: kadircet Reviewed By: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, kadircet, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D80472
2020-05-28 00:17:07 +08:00
HI.AccessSpecifier = "public";
[clangd] show layout info when hovering on a class/field definition. Summary: This triggers only on the definition itself, not on references (probably too noisy). Inspecting the definition seems like a decent hint for being interested in layout. Reviewers: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D77355
2020-04-03 09:07:10 +08:00
}},
// Struct definition shows size.
{R"cpp(
struct [[^X]]{};
)cpp",
[](HoverInfo &HI) {
HI.NamespaceScope = "";
HI.Name = "X";
HI.Kind = index::SymbolKind::Struct;
HI.Definition = "struct X {}";
HI.Size = 1;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}},
// Variable with template type
{R"cpp(
template <typename T, class... Ts> class Foo { public: Foo(int); };
Foo<int, char, bool> [[fo^o]] = Foo<int, char, bool>(5);
)cpp",
[](HoverInfo &HI) {
HI.NamespaceScope = "";
HI.Name = "foo";
[clangd] Store index::SymbolKind in HoverInfo Summary: LSP's SymbolKind has some shortcomings when it comes to C++ types, index::SymbolKind has more detailed info like Destructor, Parameter, MACRO etc. We are planning to make use of that information in our new Hover response, and it would be nice to display the Symbol type in full detail, rather than some approximation. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70723
2019-11-27 01:06:17 +08:00
HI.Kind = index::SymbolKind::Variable;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
HI.Definition = "Foo<int, char, bool> foo = Foo<int, char, bool>(5)";
HI.Type = "Foo<int, char, bool>";
}},
// Implicit template instantiation
{R"cpp(
template <typename T> class vector{};
[[vec^tor]]<int> foo;
)cpp",
[](HoverInfo &HI) {
HI.NamespaceScope = "";
[clangd] Improve documentation for auto and implicit specs Summary: Clangd didn't fill documentation for `auto` when it wasn't available in index. Also it wasn't showing any documentations for implicit instantiations. This patch ensures auto and normal decl case behaves in the same way and also makes use of the explicit template specialization while fetching comments for implicit instantiations. Reviewers: ilya-biryukov Subscribers: MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D71596
2019-12-17 19:13:28 +08:00
HI.Name = "vector<int>";
[clangd] Store index::SymbolKind in HoverInfo Summary: LSP's SymbolKind has some shortcomings when it comes to C++ types, index::SymbolKind has more detailed info like Destructor, Parameter, MACRO etc. We are planning to make use of that information in our new Hover response, and it would be nice to display the Symbol type in full detail, rather than some approximation. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70723
2019-11-27 01:06:17 +08:00
HI.Kind = index::SymbolKind::Class;
[clangd] Improve documentation for auto and implicit specs Summary: Clangd didn't fill documentation for `auto` when it wasn't available in index. Also it wasn't showing any documentations for implicit instantiations. This patch ensures auto and normal decl case behaves in the same way and also makes use of the explicit template specialization while fetching comments for implicit instantiations. Reviewers: ilya-biryukov Subscribers: MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D71596
2019-12-17 19:13:28 +08:00
HI.Definition = "template <> class vector<int> {}";
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}},
// Class template
{R"cpp(
template <template<typename, bool...> class C,
typename = char,
int = 0,
bool Q = false,
class... Ts> class Foo {};
template <template<typename, bool...> class T>
[[F^oo]]<T> foo;
)cpp",
[](HoverInfo &HI) {
HI.NamespaceScope = "";
HI.Name = "Foo";
[clangd] Store index::SymbolKind in HoverInfo Summary: LSP's SymbolKind has some shortcomings when it comes to C++ types, index::SymbolKind has more detailed info like Destructor, Parameter, MACRO etc. We are planning to make use of that information in our new Hover response, and it would be nice to display the Symbol type in full detail, rather than some approximation. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70723
2019-11-27 01:06:17 +08:00
HI.Kind = index::SymbolKind::Class;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
HI.Definition =
R"cpp(template <template <typename, bool...> class C, typename = char, int = 0,
bool Q = false, class... Ts>
class Foo {})cpp";
HI.TemplateParameters = {
{std::string("template <typename, bool...> class"),
std::string("C"), llvm::None},
{std::string("typename"), llvm::None, std::string("char")},
{std::string("int"), llvm::None, std::string("0")},
{std::string("bool"), std::string("Q"), std::string("false")},
{std::string("class..."), std::string("Ts"), llvm::None},
};
}},
// Function template
{R"cpp(
template <template<typename, bool...> class C,
typename = char,
int = 0,
bool Q = false,
class... Ts> void foo();
template<typename, bool...> class Foo;
void bar() {
[[fo^o]]<Foo>();
}
)cpp",
[](HoverInfo &HI) {
HI.NamespaceScope = "";
HI.Name = "foo";
[clangd] Store index::SymbolKind in HoverInfo Summary: LSP's SymbolKind has some shortcomings when it comes to C++ types, index::SymbolKind has more detailed info like Destructor, Parameter, MACRO etc. We are planning to make use of that information in our new Hover response, and it would be nice to display the Symbol type in full detail, rather than some approximation. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70723
2019-11-27 01:06:17 +08:00
HI.Kind = index::SymbolKind::Function;
[clangd] Improve documentation for auto and implicit specs Summary: Clangd didn't fill documentation for `auto` when it wasn't available in index. Also it wasn't showing any documentations for implicit instantiations. This patch ensures auto and normal decl case behaves in the same way and also makes use of the explicit template specialization while fetching comments for implicit instantiations. Reviewers: ilya-biryukov Subscribers: MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D71596
2019-12-17 19:13:28 +08:00
HI.Definition = "template <> void foo<Foo, char, 0, false, <>>()";
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
HI.ReturnType = "void";
HI.Type = "void ()";
HI.Parameters.emplace();
}},
// Function decl
{R"cpp(
template<typename, bool...> class Foo {};
Foo<bool, true, false> foo(int, bool T = false);
void bar() {
[[fo^o]](3);
}
)cpp",
[](HoverInfo &HI) {
HI.NamespaceScope = "";
HI.Name = "foo";
[clangd] Store index::SymbolKind in HoverInfo Summary: LSP's SymbolKind has some shortcomings when it comes to C++ types, index::SymbolKind has more detailed info like Destructor, Parameter, MACRO etc. We are planning to make use of that information in our new Hover response, and it would be nice to display the Symbol type in full detail, rather than some approximation. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70723
2019-11-27 01:06:17 +08:00
HI.Kind = index::SymbolKind::Function;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
HI.Definition = "Foo<bool, true, false> foo(int, bool T = false)";
HI.ReturnType = "Foo<bool, true, false>";
HI.Type = "Foo<bool, true, false> (int, bool)";
HI.Parameters = {
{std::string("int"), llvm::None, llvm::None},
{std::string("bool"), std::string("T"), std::string("false")},
};
}},
// Pointers to lambdas
{R"cpp(
void foo() {
auto lamb = [](int T, bool B) -> bool { return T && B; };
auto *b = &lamb;
auto *[[^c]] = &b;
}
)cpp",
[](HoverInfo &HI) {
HI.NamespaceScope = "";
HI.LocalScope = "foo::";
HI.Name = "c";
[clangd] Store index::SymbolKind in HoverInfo Summary: LSP's SymbolKind has some shortcomings when it comes to C++ types, index::SymbolKind has more detailed info like Destructor, Parameter, MACRO etc. We are planning to make use of that information in our new Hover response, and it would be nice to display the Symbol type in full detail, rather than some approximation. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70723
2019-11-27 01:06:17 +08:00
HI.Kind = index::SymbolKind::Variable;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
HI.Definition = "auto *c = &b";
[clangd] Make our printing policies for Hover more consistent, especially tags Different cases were using a bunch of different variants of the printing policy. Each of these had something going for it, but the result was inconsistent. Goals: - single printing policy used (almost) everywhere - avoid unidiomatic tags like `class vector<class X>` - be informative and easy to understand For tags, the solution I wound up with is: we print only the outer tag and only in the simplest cases where this elaboration won't cause confusion. For example: - class X - enum Foo - vector<int> - X* This seems to strike a nice balance of providing plenty of info/context in common cases while never being confusing. Differential Revision: https://reviews.llvm.org/D93553
2020-12-19 01:39:20 +08:00
HI.Type = "(lambda) **";
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
HI.ReturnType = "bool";
HI.Parameters = {
{std::string("int"), std::string("T"), llvm::None},
{std::string("bool"), std::string("B"), llvm::None},
};
return HI;
}},
// Lambda parameter with decltype reference
{R"cpp(
auto lamb = [](int T, bool B) -> bool { return T && B; };
void foo(decltype(lamb)& bar) {
[[ba^r]](0, false);
}
)cpp",
[](HoverInfo &HI) {
HI.NamespaceScope = "";
HI.LocalScope = "foo::";
HI.Name = "bar";
[clangd] Store index::SymbolKind in HoverInfo Summary: LSP's SymbolKind has some shortcomings when it comes to C++ types, index::SymbolKind has more detailed info like Destructor, Parameter, MACRO etc. We are planning to make use of that information in our new Hover response, and it would be nice to display the Symbol type in full detail, rather than some approximation. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70723
2019-11-27 01:06:17 +08:00
HI.Kind = index::SymbolKind::Parameter;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
HI.Definition = "decltype(lamb) &bar";
HI.Type = "decltype(lamb) &";
HI.ReturnType = "bool";
HI.Parameters = {
{std::string("int"), std::string("T"), llvm::None},
{std::string("bool"), std::string("B"), llvm::None},
};
return HI;
}},
// Lambda parameter with decltype
{R"cpp(
auto lamb = [](int T, bool B) -> bool { return T && B; };
void foo(decltype(lamb) bar) {
[[ba^r]](0, false);
}
)cpp",
[](HoverInfo &HI) {
HI.NamespaceScope = "";
HI.LocalScope = "foo::";
HI.Name = "bar";
[clangd] Store index::SymbolKind in HoverInfo Summary: LSP's SymbolKind has some shortcomings when it comes to C++ types, index::SymbolKind has more detailed info like Destructor, Parameter, MACRO etc. We are planning to make use of that information in our new Hover response, and it would be nice to display the Symbol type in full detail, rather than some approximation. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70723
2019-11-27 01:06:17 +08:00
HI.Kind = index::SymbolKind::Parameter;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
HI.Definition = "decltype(lamb) bar";
HI.Type = "class (lambda)";
HI.ReturnType = "bool";
HI.Parameters = {
{std::string("int"), std::string("T"), llvm::None},
{std::string("bool"), std::string("B"), llvm::None},
};
[clangd] Show values of more expressions on hover Reviewers: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70359
2019-11-17 05:15:05 +08:00
HI.Value = "false";
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
return HI;
}},
// Lambda variable
{R"cpp(
void foo() {
int bar = 5;
auto lamb = [&bar](int T, bool B) -> bool { return T && B && bar; };
bool res = [[lam^b]](bar, false);
}
)cpp",
[](HoverInfo &HI) {
HI.NamespaceScope = "";
HI.LocalScope = "foo::";
HI.Name = "lamb";
[clangd] Store index::SymbolKind in HoverInfo Summary: LSP's SymbolKind has some shortcomings when it comes to C++ types, index::SymbolKind has more detailed info like Destructor, Parameter, MACRO etc. We are planning to make use of that information in our new Hover response, and it would be nice to display the Symbol type in full detail, rather than some approximation. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70723
2019-11-27 01:06:17 +08:00
HI.Kind = index::SymbolKind::Variable;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
HI.Definition = "auto lamb = [&bar](int T, bool B) -> bool {}";
HI.Type = "class (lambda)";
HI.ReturnType = "bool";
HI.Parameters = {
{std::string("int"), std::string("T"), llvm::None},
{std::string("bool"), std::string("B"), llvm::None},
};
return HI;
}},
// Local variable in lambda
{R"cpp(
void foo() {
auto lamb = []{int [[te^st]];};
}
)cpp",
[](HoverInfo &HI) {
HI.NamespaceScope = "";
HI.LocalScope = "foo::(anonymous class)::operator()::";
HI.Name = "test";
[clangd] Store index::SymbolKind in HoverInfo Summary: LSP's SymbolKind has some shortcomings when it comes to C++ types, index::SymbolKind has more detailed info like Destructor, Parameter, MACRO etc. We are planning to make use of that information in our new Hover response, and it would be nice to display the Symbol type in full detail, rather than some approximation. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70723
2019-11-27 01:06:17 +08:00
HI.Kind = index::SymbolKind::Variable;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
HI.Definition = "int test";
HI.Type = "int";
}},
// Partially-specialized class template. (formerly type-parameter-0-0)
{R"cpp(
template <typename T> class X;
template <typename T> class [[^X]]<T*> {};
)cpp",
[](HoverInfo &HI) {
HI.Name = "X<T *>";
HI.NamespaceScope = "";
[clangd] Store index::SymbolKind in HoverInfo Summary: LSP's SymbolKind has some shortcomings when it comes to C++ types, index::SymbolKind has more detailed info like Destructor, Parameter, MACRO etc. We are planning to make use of that information in our new Hover response, and it would be nice to display the Symbol type in full detail, rather than some approximation. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70723
2019-11-27 01:06:17 +08:00
HI.Kind = index::SymbolKind::Class;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
HI.Definition = "template <typename T> class X<T *> {}";
}},
// Constructor of partially-specialized class template
{R"cpp(
template<typename, typename=void> struct X;
template<typename T> struct X<T*>{ [[^X]](); };
)cpp",
[](HoverInfo &HI) {
HI.NamespaceScope = "";
HI.Name = "X";
HI.LocalScope = "X<T *>::"; // FIXME: X<T *, void>::
[clangd] Store index::SymbolKind in HoverInfo Summary: LSP's SymbolKind has some shortcomings when it comes to C++ types, index::SymbolKind has more detailed info like Destructor, Parameter, MACRO etc. We are planning to make use of that information in our new Hover response, and it would be nice to display the Symbol type in full detail, rather than some approximation. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70723
2019-11-27 01:06:17 +08:00
HI.Kind = index::SymbolKind::Constructor;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
HI.Definition = "X()";
HI.Parameters.emplace();
[clangd] Add access specifier information to hover contents Summary: For https://github.com/clangd/clangd/issues/382 This commit adds access specifier information to the hover contents. For example, the hover information of a class field or member function will now indicate if the field or member is private, public, or protected. This can be particularly useful when a developer is in the implementation file and wants to know if a particular member definition is public or private. Reviewers: kadircet Reviewed By: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, kadircet, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D80472
2020-05-28 00:17:07 +08:00
HI.AccessSpecifier = "public";
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}},
{"class X { [[^~]]X(); };", // FIXME: Should be [[~X]]()
[](HoverInfo &HI) {
HI.NamespaceScope = "";
HI.Name = "~X";
HI.LocalScope = "X::";
[clangd] Store index::SymbolKind in HoverInfo Summary: LSP's SymbolKind has some shortcomings when it comes to C++ types, index::SymbolKind has more detailed info like Destructor, Parameter, MACRO etc. We are planning to make use of that information in our new Hover response, and it would be nice to display the Symbol type in full detail, rather than some approximation. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70723
2019-11-27 01:06:17 +08:00
HI.Kind = index::SymbolKind::Destructor;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
HI.Definition = "~X()";
HI.Parameters.emplace();
[clangd] Add access specifier information to hover contents Summary: For https://github.com/clangd/clangd/issues/382 This commit adds access specifier information to the hover contents. For example, the hover information of a class field or member function will now indicate if the field or member is private, public, or protected. This can be particularly useful when a developer is in the implementation file and wants to know if a particular member definition is public or private. Reviewers: kadircet Reviewed By: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, kadircet, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D80472
2020-05-28 00:17:07 +08:00
HI.AccessSpecifier = "private";
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}},
[clangd] Fix early selection for non-vardecl declarators Summary: Selection tree was performing an early claim only for VarDecls, but there are other cases where we can have declarators, e.g. FieldDecls. This patch extends the early claim logic to all types of declarators. Fixes https://github.com/clangd/clangd/issues/292 Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D75106
2020-02-25 16:33:52 +08:00
{"class X { [[op^erator]] int(); };",
[clangd] Drop returntype/type when hovering over type-ish names Summary: Some names, e.g. constructor/destructor/conversions, already contain the type info, no need to duplicate them in the hoverinfo. Fixes https://github.com/clangd/clangd/issues/252 Reviewers: sammccall, ilya-biryukov Subscribers: MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D73110
2020-01-21 23:49:32 +08:00
[](HoverInfo &HI) {
HI.NamespaceScope = "";
HI.Name = "operator int";
HI.LocalScope = "X::";
HI.Kind = index::SymbolKind::ConversionFunction;
HI.Definition = "operator int()";
HI.Parameters.emplace();
[clangd] Add access specifier information to hover contents Summary: For https://github.com/clangd/clangd/issues/382 This commit adds access specifier information to the hover contents. For example, the hover information of a class field or member function will now indicate if the field or member is private, public, or protected. This can be particularly useful when a developer is in the implementation file and wants to know if a particular member definition is public or private. Reviewers: kadircet Reviewed By: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, kadircet, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D80472
2020-05-28 00:17:07 +08:00
HI.AccessSpecifier = "private";
[clangd] Drop returntype/type when hovering over type-ish names Summary: Some names, e.g. constructor/destructor/conversions, already contain the type info, no need to duplicate them in the hoverinfo. Fixes https://github.com/clangd/clangd/issues/252 Reviewers: sammccall, ilya-biryukov Subscribers: MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D73110
2020-01-21 23:49:32 +08:00
}},
[clangd] Fix early selection for non-vardecl declarators Summary: Selection tree was performing an early claim only for VarDecls, but there are other cases where we can have declarators, e.g. FieldDecls. This patch extends the early claim logic to all types of declarators. Fixes https://github.com/clangd/clangd/issues/292 Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D75106
2020-02-25 16:33:52 +08:00
{"class X { operator [[^X]](); };",
[](HoverInfo &HI) {
HI.NamespaceScope = "";
HI.Name = "X";
HI.Kind = index::SymbolKind::Class;
HI.Definition = "class X {}";
}},
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
// auto on structured bindings
{R"cpp(
void foo() {
struct S { int x; float y; };
[[au^to]] [x, y] = S();
}
)cpp",
[](HoverInfo &HI) {
HI.Name = "auto";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "struct S";
}},
// undeduced auto
{R"cpp(
template<typename T>
void foo() {
[[au^to]] x = T{};
}
)cpp",
[](HoverInfo &HI) {
HI.Name = "auto";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "/* not deduced */";
}},
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
// auto on lambda
{R"cpp(
void foo() {
[[au^to]] lamb = []{};
}
)cpp",
[](HoverInfo &HI) {
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
HI.Name = "auto";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "class(lambda)";
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}},
// auto on template instantiation
{R"cpp(
template<typename T> class Foo{};
void foo() {
[[au^to]] x = Foo<int>();
}
)cpp",
[](HoverInfo &HI) {
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
HI.Name = "auto";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "class Foo<int>";
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}},
// auto on specialized template
{R"cpp(
template<typename T> class Foo{};
template<> class Foo<int>{};
void foo() {
[[au^to]] x = Foo<int>();
}
)cpp",
[](HoverInfo &HI) {
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
HI.Name = "auto";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "class Foo<int>";
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}},
// macro
{R"cpp(
// Best MACRO ever.
#define MACRO(x,y,z) void foo(x, y, z);
[[MAC^RO]](int, double d, bool z = false);
)cpp",
[](HoverInfo &HI) {
[clangd] Store index::SymbolKind in HoverInfo Summary: LSP's SymbolKind has some shortcomings when it comes to C++ types, index::SymbolKind has more detailed info like Destructor, Parameter, MACRO etc. We are planning to make use of that information in our new Hover response, and it would be nice to display the Symbol type in full detail, rather than some approximation. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70723
2019-11-27 01:06:17 +08:00
HI.Name = "MACRO", HI.Kind = index::SymbolKind::Macro,
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
HI.Definition = "#define MACRO(x, y, z) void foo(x, y, z);";
}},
// constexprs
{R"cpp(
constexpr int add(int a, int b) { return a + b; }
int [[b^ar]] = add(1, 2);
)cpp",
[](HoverInfo &HI) {
HI.Name = "bar";
HI.Definition = "int bar = add(1, 2)";
[clangd] Store index::SymbolKind in HoverInfo Summary: LSP's SymbolKind has some shortcomings when it comes to C++ types, index::SymbolKind has more detailed info like Destructor, Parameter, MACRO etc. We are planning to make use of that information in our new Hover response, and it would be nice to display the Symbol type in full detail, rather than some approximation. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70723
2019-11-27 01:06:17 +08:00
HI.Kind = index::SymbolKind::Variable;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
HI.Type = "int";
HI.NamespaceScope = "";
HI.Value = "3";
}},
{R"cpp(
int [[b^ar]] = sizeof(char);
)cpp",
[](HoverInfo &HI) {
HI.Name = "bar";
HI.Definition = "int bar = sizeof(char)";
[clangd] Store index::SymbolKind in HoverInfo Summary: LSP's SymbolKind has some shortcomings when it comes to C++ types, index::SymbolKind has more detailed info like Destructor, Parameter, MACRO etc. We are planning to make use of that information in our new Hover response, and it would be nice to display the Symbol type in full detail, rather than some approximation. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70723
2019-11-27 01:06:17 +08:00
HI.Kind = index::SymbolKind::Variable;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
HI.Type = "int";
HI.NamespaceScope = "";
HI.Value = "1";
}},
{R"cpp(
template<int a, int b> struct Add {
static constexpr int result = a + b;
};
int [[ba^r]] = Add<1, 2>::result;
)cpp",
[](HoverInfo &HI) {
HI.Name = "bar";
HI.Definition = "int bar = Add<1, 2>::result";
[clangd] Store index::SymbolKind in HoverInfo Summary: LSP's SymbolKind has some shortcomings when it comes to C++ types, index::SymbolKind has more detailed info like Destructor, Parameter, MACRO etc. We are planning to make use of that information in our new Hover response, and it would be nice to display the Symbol type in full detail, rather than some approximation. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70723
2019-11-27 01:06:17 +08:00
HI.Kind = index::SymbolKind::Variable;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
HI.Type = "int";
HI.NamespaceScope = "";
HI.Value = "3";
}},
{R"cpp(
enum Color { RED, GREEN, };
Color x = [[GR^EEN]];
)cpp",
[](HoverInfo &HI) {
HI.Name = "GREEN";
HI.NamespaceScope = "";
HI.LocalScope = "Color::";
HI.Definition = "GREEN";
[clangd] Store index::SymbolKind in HoverInfo Summary: LSP's SymbolKind has some shortcomings when it comes to C++ types, index::SymbolKind has more detailed info like Destructor, Parameter, MACRO etc. We are planning to make use of that information in our new Hover response, and it would be nice to display the Symbol type in full detail, rather than some approximation. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70723
2019-11-27 01:06:17 +08:00
HI.Kind = index::SymbolKind::EnumConstant;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
HI.Type = "enum Color";
[clangd] Show values of more expressions on hover Reviewers: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70359
2019-11-17 05:15:05 +08:00
HI.Value = "1"; // Numeric when hovering on the enumerator name.
}},
{R"cpp(
enum Color { RED, GREEN, };
Color x = GREEN;
Color y = [[^x]];
)cpp",
[](HoverInfo &HI) {
HI.Name = "x";
HI.NamespaceScope = "";
[clangd] Improve type printing in hover Summary: Do not include tag keywords when printing types for symbol names, as it will come from SymbolKind. Also suppress them while printing definitions to prevent them occuring in template arguments. Make use of `getAsString`, instead of `print` in all places to have a consistent style across the file. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D72450
2020-01-07 22:15:00 +08:00
HI.Definition = "Color x = GREEN";
[clangd] Store index::SymbolKind in HoverInfo Summary: LSP's SymbolKind has some shortcomings when it comes to C++ types, index::SymbolKind has more detailed info like Destructor, Parameter, MACRO etc. We are planning to make use of that information in our new Hover response, and it would be nice to display the Symbol type in full detail, rather than some approximation. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70723
2019-11-27 01:06:17 +08:00
HI.Kind = index::SymbolKind::Variable;
[clangd] Show values of more expressions on hover Reviewers: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70359
2019-11-17 05:15:05 +08:00
HI.Type = "enum Color";
HI.Value = "GREEN (1)"; // Symbolic when hovering on an expression.
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}},
{R"cpp(
template<int a, int b> struct Add {
static constexpr int result = a + b;
};
int bar = Add<1, 2>::[[resu^lt]];
)cpp",
[](HoverInfo &HI) {
HI.Name = "result";
[clangd] Improve documentation for auto and implicit specs Summary: Clangd didn't fill documentation for `auto` when it wasn't available in index. Also it wasn't showing any documentations for implicit instantiations. This patch ensures auto and normal decl case behaves in the same way and also makes use of the explicit template specialization while fetching comments for implicit instantiations. Reviewers: ilya-biryukov Subscribers: MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D71596
2019-12-17 19:13:28 +08:00
HI.Definition = "static constexpr int result = 1 + 2";
[clangd] Store index::SymbolKind in HoverInfo Summary: LSP's SymbolKind has some shortcomings when it comes to C++ types, index::SymbolKind has more detailed info like Destructor, Parameter, MACRO etc. We are planning to make use of that information in our new Hover response, and it would be nice to display the Symbol type in full detail, rather than some approximation. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70723
2019-11-27 01:06:17 +08:00
HI.Kind = index::SymbolKind::StaticProperty;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
HI.Type = "const int";
HI.NamespaceScope = "";
[clangd] Improve documentation for auto and implicit specs Summary: Clangd didn't fill documentation for `auto` when it wasn't available in index. Also it wasn't showing any documentations for implicit instantiations. This patch ensures auto and normal decl case behaves in the same way and also makes use of the explicit template specialization while fetching comments for implicit instantiations. Reviewers: ilya-biryukov Subscribers: MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D71596
2019-12-17 19:13:28 +08:00
HI.LocalScope = "Add<1, 2>::";
[clangd] Show values of more expressions on hover Reviewers: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70359
2019-11-17 05:15:05 +08:00
HI.Value = "3";
[clangd] Add access specifier information to hover contents Summary: For https://github.com/clangd/clangd/issues/382 This commit adds access specifier information to the hover contents. For example, the hover information of a class field or member function will now indicate if the field or member is private, public, or protected. This can be particularly useful when a developer is in the implementation file and wants to know if a particular member definition is public or private. Reviewers: kadircet Reviewed By: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, kadircet, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D80472
2020-05-28 00:17:07 +08:00
HI.AccessSpecifier = "public";
[clangd] Show values of more expressions on hover Reviewers: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70359
2019-11-17 05:15:05 +08:00
}},
{R"cpp(
constexpr int answer() { return 40 + 2; }
int x = [[ans^wer]]();
)cpp",
[](HoverInfo &HI) {
HI.Name = "answer";
HI.Definition = "constexpr int answer()";
[clangd] Store index::SymbolKind in HoverInfo Summary: LSP's SymbolKind has some shortcomings when it comes to C++ types, index::SymbolKind has more detailed info like Destructor, Parameter, MACRO etc. We are planning to make use of that information in our new Hover response, and it would be nice to display the Symbol type in full detail, rather than some approximation. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70723
2019-11-27 01:06:17 +08:00
HI.Kind = index::SymbolKind::Function;
[clangd] Show values of more expressions on hover Reviewers: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70359
2019-11-17 05:15:05 +08:00
HI.Type = "int ()";
HI.ReturnType = "int";
HI.Parameters.emplace();
HI.NamespaceScope = "";
HI.Value = "42";
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}},
{R"cpp(
const char *[[ba^r]] = "1234";
)cpp",
[](HoverInfo &HI) {
HI.Name = "bar";
HI.Definition = "const char *bar = \"1234\"";
[clangd] Store index::SymbolKind in HoverInfo Summary: LSP's SymbolKind has some shortcomings when it comes to C++ types, index::SymbolKind has more detailed info like Destructor, Parameter, MACRO etc. We are planning to make use of that information in our new Hover response, and it would be nice to display the Symbol type in full detail, rather than some approximation. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70723
2019-11-27 01:06:17 +08:00
HI.Kind = index::SymbolKind::Variable;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
HI.Type = "const char *";
HI.NamespaceScope = "";
HI.Value = "&\"1234\"[0]";
}},
[clangd] Fix hover crashing on null types Summary: Fixes https://github.com/clangd/clangd/issues/225 Reviewers: sammccall, ilya-biryukov Subscribers: MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D71403
2019-12-12 17:41:27 +08:00
{R"cpp(// Should not crash
template <typename T>
struct Tmpl {
Tmpl(int name);
};
template <typename A>
void boom(int name) {
new Tmpl<A>([[na^me]]);
})cpp",
[](HoverInfo &HI) {
HI.Name = "name";
HI.Definition = "int name";
HI.Kind = index::SymbolKind::Parameter;
HI.Type = "int";
HI.NamespaceScope = "";
HI.LocalScope = "boom::";
}},
[clangd] Fix handling of inline/anon namespaces and names of deduced types in hover Summary: Clangd normally skips inline and anon namespaces while printing nested name specifiers. It also drops any tag specifiers since we make use of `HoverInfo::Kind` instead of some text in `HoverInfo::Name` There was a bug causing us to print innermost inline/anon namespace, this patch fixes that by skipping those. Also changes printing and kind detection of deduced types to be similar to decl case. Also improves printing for lambdas, currently clangd prints lambdas as `(anonymous class)`, we can improve it by at least printing `(lambda)` instead. Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D71543
2019-12-16 21:22:48 +08:00
{
R"cpp(// Should not print inline or anon namespaces.
namespace ns {
inline namespace in_ns {
namespace a {
namespace {
namespace b {
inline namespace in_ns2 {
class Foo {};
} // in_ns2
} // b
} // anon
} // a
} // in_ns
} // ns
void foo() {
ns::a::b::[[F^oo]] x;
(void)x;
}
)cpp",
[](HoverInfo &HI) {
HI.Name = "Foo";
HI.Kind = index::SymbolKind::Class;
HI.NamespaceScope = "ns::a::b::";
HI.Definition = "class Foo {}";
}},
{
R"cpp(
template <typename T> class Foo {};
class X;
void foo() {
[[^auto]] x = Foo<X>();
}
)cpp",
[](HoverInfo &HI) {
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
HI.Name = "auto";
HI.Kind = index::SymbolKind::TypeAlias;
[clangd] Make our printing policies for Hover more consistent, especially tags Different cases were using a bunch of different variants of the printing policy. Each of these had something going for it, but the result was inconsistent. Goals: - single printing policy used (almost) everywhere - avoid unidiomatic tags like `class vector<class X>` - be informative and easy to understand For tags, the solution I wound up with is: we print only the outer tag and only in the simplest cases where this elaboration won't cause confusion. For example: - class X - enum Foo - vector<int> - X* This seems to strike a nice balance of providing plenty of info/context in common cases while never being confusing. Differential Revision: https://reviews.llvm.org/D93553
2020-12-19 01:39:20 +08:00
HI.Definition = "class Foo<X>";
[clangd] Fix handling of inline/anon namespaces and names of deduced types in hover Summary: Clangd normally skips inline and anon namespaces while printing nested name specifiers. It also drops any tag specifiers since we make use of `HoverInfo::Kind` instead of some text in `HoverInfo::Name` There was a bug causing us to print innermost inline/anon namespace, this patch fixes that by skipping those. Also changes printing and kind detection of deduced types to be similar to decl case. Also improves printing for lambdas, currently clangd prints lambdas as `(anonymous class)`, we can improve it by at least printing `(lambda)` instead. Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D71543
2019-12-16 21:22:48 +08:00
}},
[clangd][Hover] Handle uninstantiated templates Summary: Fixes https://github.com/clangd/clangd/issues/263 Reviewers: hokein, sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D73344
2020-01-24 20:04:00 +08:00
{// Falls back to primary template, when the type is not instantiated.
R"cpp(
// comment from primary
template <typename T> class Foo {};
// comment from specialization
template <typename T> class Foo<T*> {};
void foo() {
[[Fo^o]]<int*> *x = nullptr;
}
)cpp",
[](HoverInfo &HI) {
HI.Name = "Foo<int *>";
HI.Kind = index::SymbolKind::Class;
HI.NamespaceScope = "";
HI.Definition = "template <> class Foo<int *>";
// FIXME: Maybe force instantiation to make use of real template
// pattern.
HI.Documentation = "comment from primary";
}},
[clang][Index] Introduce a TemplateParm SymbolKind Summary: Currently template parameters has symbolkind `Unknown`. This patch introduces a new kind `TemplateParm` for templatetemplate, templatetype and nontypetemplate parameters. Also adds tests in clangd hover feature. Reviewers: sammccall Subscribers: kristof.beyls, ilya-biryukov, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D73696
2020-01-30 21:07:42 +08:00
{// Template Type Parameter
R"cpp(
template <typename [[^T]] = int> void foo();
)cpp",
[](HoverInfo &HI) {
HI.Name = "T";
HI.Kind = index::SymbolKind::TemplateTypeParm;
HI.NamespaceScope = "";
HI.Definition = "typename T = int";
HI.LocalScope = "foo::";
HI.Type = "typename";
[clangd] Add access specifier information to hover contents Summary: For https://github.com/clangd/clangd/issues/382 This commit adds access specifier information to the hover contents. For example, the hover information of a class field or member function will now indicate if the field or member is private, public, or protected. This can be particularly useful when a developer is in the implementation file and wants to know if a particular member definition is public or private. Reviewers: kadircet Reviewed By: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, kadircet, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D80472
2020-05-28 00:17:07 +08:00
HI.AccessSpecifier = "public";
[clang][Index] Introduce a TemplateParm SymbolKind Summary: Currently template parameters has symbolkind `Unknown`. This patch introduces a new kind `TemplateParm` for templatetemplate, templatetype and nontypetemplate parameters. Also adds tests in clangd hover feature. Reviewers: sammccall Subscribers: kristof.beyls, ilya-biryukov, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D73696
2020-01-30 21:07:42 +08:00
}},
{// TemplateTemplate Type Parameter
R"cpp(
template <template<typename> class [[^T]]> void foo();
)cpp",
[](HoverInfo &HI) {
HI.Name = "T";
HI.Kind = index::SymbolKind::TemplateTemplateParm;
HI.NamespaceScope = "";
HI.Definition = "template <typename> class T";
HI.LocalScope = "foo::";
HI.Type = "template <typename> class";
[clangd] Add access specifier information to hover contents Summary: For https://github.com/clangd/clangd/issues/382 This commit adds access specifier information to the hover contents. For example, the hover information of a class field or member function will now indicate if the field or member is private, public, or protected. This can be particularly useful when a developer is in the implementation file and wants to know if a particular member definition is public or private. Reviewers: kadircet Reviewed By: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, kadircet, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D80472
2020-05-28 00:17:07 +08:00
HI.AccessSpecifier = "public";
[clang][Index] Introduce a TemplateParm SymbolKind Summary: Currently template parameters has symbolkind `Unknown`. This patch introduces a new kind `TemplateParm` for templatetemplate, templatetype and nontypetemplate parameters. Also adds tests in clangd hover feature. Reviewers: sammccall Subscribers: kristof.beyls, ilya-biryukov, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D73696
2020-01-30 21:07:42 +08:00
}},
{// NonType Template Parameter
R"cpp(
template <int [[^T]] = 5> void foo();
)cpp",
[](HoverInfo &HI) {
HI.Name = "T";
HI.Kind = index::SymbolKind::NonTypeTemplateParm;
HI.NamespaceScope = "";
HI.Definition = "int T = 5";
HI.LocalScope = "foo::";
HI.Type = "int";
[clangd] Add access specifier information to hover contents Summary: For https://github.com/clangd/clangd/issues/382 This commit adds access specifier information to the hover contents. For example, the hover information of a class field or member function will now indicate if the field or member is private, public, or protected. This can be particularly useful when a developer is in the implementation file and wants to know if a particular member definition is public or private. Reviewers: kadircet Reviewed By: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, kadircet, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D80472
2020-05-28 00:17:07 +08:00
HI.AccessSpecifier = "public";
[clang][Index] Introduce a TemplateParm SymbolKind Summary: Currently template parameters has symbolkind `Unknown`. This patch introduces a new kind `TemplateParm` for templatetemplate, templatetype and nontypetemplate parameters. Also adds tests in clangd hover feature. Reviewers: sammccall Subscribers: kristof.beyls, ilya-biryukov, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D73696
2020-01-30 21:07:42 +08:00
}},
[clang] Annotate trivial getters and setters on hover. Summary: (Only if their definitions are visible and they have no other docs) Reviewers: kadircet Subscribers: jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D77408
2020-04-03 23:09:38 +08:00
{// Getter
R"cpp(
struct X { int Y; float [[^y]]() { return Y; } };
)cpp",
[](HoverInfo &HI) {
HI.Name = "y";
HI.Kind = index::SymbolKind::InstanceMethod;
HI.NamespaceScope = "";
HI.Definition = "float y()";
HI.LocalScope = "X::";
HI.Documentation = "Trivial accessor for `Y`.";
HI.Type = "float ()";
HI.ReturnType = "float";
HI.Parameters.emplace();
[clangd] Add access specifier information to hover contents Summary: For https://github.com/clangd/clangd/issues/382 This commit adds access specifier information to the hover contents. For example, the hover information of a class field or member function will now indicate if the field or member is private, public, or protected. This can be particularly useful when a developer is in the implementation file and wants to know if a particular member definition is public or private. Reviewers: kadircet Reviewed By: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, kadircet, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D80472
2020-05-28 00:17:07 +08:00
HI.AccessSpecifier = "public";
[clang] Annotate trivial getters and setters on hover. Summary: (Only if their definitions are visible and they have no other docs) Reviewers: kadircet Subscribers: jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D77408
2020-04-03 23:09:38 +08:00
}},
{// Setter
R"cpp(
struct X { int Y; void [[^setY]](float v) { Y = v; } };
)cpp",
[](HoverInfo &HI) {
HI.Name = "setY";
HI.Kind = index::SymbolKind::InstanceMethod;
HI.NamespaceScope = "";
HI.Definition = "void setY(float v)";
HI.LocalScope = "X::";
HI.Documentation = "Trivial setter for `Y`.";
HI.Type = "void (float)";
HI.ReturnType = "void";
HI.Parameters.emplace();
HI.Parameters->emplace_back();
HI.Parameters->back().Type = "float";
HI.Parameters->back().Name = "v";
[clangd] Add access specifier information to hover contents Summary: For https://github.com/clangd/clangd/issues/382 This commit adds access specifier information to the hover contents. For example, the hover information of a class field or member function will now indicate if the field or member is private, public, or protected. This can be particularly useful when a developer is in the implementation file and wants to know if a particular member definition is public or private. Reviewers: kadircet Reviewed By: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, kadircet, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D80472
2020-05-28 00:17:07 +08:00
HI.AccessSpecifier = "public";
[clang] Annotate trivial getters and setters on hover. Summary: (Only if their definitions are visible and they have no other docs) Reviewers: kadircet Subscribers: jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D77408
2020-04-03 23:09:38 +08:00
}},
{// Setter (builder)
R"cpp(
struct X { int Y; X& [[^setY]](float v) { Y = v; return *this; } };
)cpp",
[](HoverInfo &HI) {
HI.Name = "setY";
HI.Kind = index::SymbolKind::InstanceMethod;
HI.NamespaceScope = "";
HI.Definition = "X &setY(float v)";
HI.LocalScope = "X::";
HI.Documentation = "Trivial setter for `Y`.";
[clangd] Make our printing policies for Hover more consistent, especially tags Different cases were using a bunch of different variants of the printing policy. Each of these had something going for it, but the result was inconsistent. Goals: - single printing policy used (almost) everywhere - avoid unidiomatic tags like `class vector<class X>` - be informative and easy to understand For tags, the solution I wound up with is: we print only the outer tag and only in the simplest cases where this elaboration won't cause confusion. For example: - class X - enum Foo - vector<int> - X* This seems to strike a nice balance of providing plenty of info/context in common cases while never being confusing. Differential Revision: https://reviews.llvm.org/D93553
2020-12-19 01:39:20 +08:00
HI.Type = "X &(float)";
HI.ReturnType = "X &";
[clang] Annotate trivial getters and setters on hover. Summary: (Only if their definitions are visible and they have no other docs) Reviewers: kadircet Subscribers: jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D77408
2020-04-03 23:09:38 +08:00
HI.Parameters.emplace();
HI.Parameters->emplace_back();
HI.Parameters->back().Type = "float";
HI.Parameters->back().Name = "v";
[clangd] Add access specifier information to hover contents Summary: For https://github.com/clangd/clangd/issues/382 This commit adds access specifier information to the hover contents. For example, the hover information of a class field or member function will now indicate if the field or member is private, public, or protected. This can be particularly useful when a developer is in the implementation file and wants to know if a particular member definition is public or private. Reviewers: kadircet Reviewed By: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, kadircet, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D80472
2020-05-28 00:17:07 +08:00
HI.AccessSpecifier = "public";
[clang] Annotate trivial getters and setters on hover. Summary: (Only if their definitions are visible and they have no other docs) Reviewers: kadircet Subscribers: jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D77408
2020-04-03 23:09:38 +08:00
}},
[clangd] Trivial setter support when moving items to fields Extend the Trivial setter documentation to support cases where the value is moved into a field using `std::move`. Reviewed By: sammccall, kadircet Differential Revision: https://reviews.llvm.org/D88297
2020-09-30 04:51:14 +08:00
{// Setter (move)
R"cpp(
namespace std { template<typename T> T&& move(T&& t); }
struct X { int Y; void [[^setY]](float v) { Y = std::move(v); } };
)cpp",
[](HoverInfo &HI) {
HI.Name = "setY";
HI.Kind = index::SymbolKind::InstanceMethod;
HI.NamespaceScope = "";
HI.Definition = "void setY(float v)";
HI.LocalScope = "X::";
HI.Documentation = "Trivial setter for `Y`.";
HI.Type = "void (float)";
HI.ReturnType = "void";
HI.Parameters.emplace();
HI.Parameters->emplace_back();
HI.Parameters->back().Type = "float";
HI.Parameters->back().Name = "v";
HI.AccessSpecifier = "public";
}},
[clangd] Disable printing of Value for tag-types on hover Summary: This is both confusing and crashy. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D82326
2020-06-23 03:53:47 +08:00
{// Field type initializer.
R"cpp(
struct X { int x = 2; };
X ^[[x]];
)cpp",
[](HoverInfo &HI) {
HI.Name = "x";
HI.Kind = index::SymbolKind::Variable;
HI.NamespaceScope = "";
HI.Definition = "X x";
HI.Type = "struct X";
}},
[clangd][Hover] Dont crash on null types Reviewers: hokein, sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D82701
2020-06-27 17:12:51 +08:00
{// Don't crash on null types.
R"cpp(auto [^[[x]]] = 1; /*error-ok*/)cpp",
[](HoverInfo &HI) {
HI.Name = "x";
HI.Kind = index::SymbolKind::Variable;
HI.NamespaceScope = "";
HI.Definition = "";
HI.Type = "NULL TYPE";
// Bindings are in theory public members of an anonymous struct.
HI.AccessSpecifier = "public";
}},
[clangd] Improve hover on arguments to function call Summary: In cases like: foo(a, ^b); We now additionally show the name and type of the parameter to foo that corresponds that "b" is passed as. The name should help with understanding what it's used for and type can be useful to find out if call to foo() can mutate variable "b" or not (i.e. if it is pass by value, reference, const reference, etc). Patch By: adamcz@ ! Reviewers: kadircet Reviewed By: kadircet Subscribers: nridge, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D81169
2020-07-03 17:20:22 +08:00
{// Extra info for function call.
R"cpp(
void fun(int arg_a, int &arg_b) {};
void code() {
int a = 1, b = 2;
fun(a, [[^b]]);
}
)cpp",
[](HoverInfo &HI) {
HI.Name = "b";
HI.Kind = index::SymbolKind::Variable;
HI.NamespaceScope = "";
HI.Definition = "int b = 2";
HI.LocalScope = "code::";
HI.Value = "2";
HI.Type = "int";
HI.CalleeArgInfo.emplace();
HI.CalleeArgInfo->Name = "arg_b";
HI.CalleeArgInfo->Type = "int &";
HI.CallPassType.emplace();
HI.CallPassType->PassBy = PassMode::Ref;
HI.CallPassType->Converted = false;
}},
{// Extra info for method call.
R"cpp(
class C {
public:
void fun(int arg_a = 3, int arg_b = 4) {}
};
void code() {
int a = 1, b = 2;
C c;
c.fun([[^a]], b);
}
)cpp",
[](HoverInfo &HI) {
HI.Name = "a";
HI.Kind = index::SymbolKind::Variable;
HI.NamespaceScope = "";
HI.Definition = "int a = 1";
HI.LocalScope = "code::";
HI.Value = "1";
HI.Type = "int";
HI.CalleeArgInfo.emplace();
HI.CalleeArgInfo->Name = "arg_a";
HI.CalleeArgInfo->Type = "int";
HI.CalleeArgInfo->Default = "3";
HI.CallPassType.emplace();
HI.CallPassType->PassBy = PassMode::Value;
HI.CallPassType->Converted = false;
}},
[clangd] Fix hover crash on invalid decls Summary: This also changes the way we display Size and Offset to be independent. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D83143
2020-07-04 02:52:41 +08:00
{// Dont crash on invalid decl
R"cpp(
// error-ok
struct Foo {
Bar [[x^x]];
};)cpp",
[](HoverInfo &HI) {
HI.Name = "xx";
HI.Kind = index::SymbolKind::Field;
HI.NamespaceScope = "";
HI.Definition = "int xx";
HI.LocalScope = "Foo::";
HI.Type = "int";
HI.AccessSpecifier = "public";
}},
[clangd] More complete fix for hover crashes on invalid record. We should not call getFieldOffset on invalid record decls. Differential Revision: https://reviews.llvm.org/D83189
2020-07-06 23:12:39 +08:00
{R"cpp(
// error-ok
struct Foo {
Bar xx;
int [[y^y]];
};)cpp",
[](HoverInfo &HI) {
HI.Name = "yy";
HI.Kind = index::SymbolKind::Field;
HI.NamespaceScope = "";
HI.Definition = "int yy";
HI.LocalScope = "Foo::";
HI.Type = "int";
HI.AccessSpecifier = "public";
[clangd] Fix hover crash on InitListExpr. Fixes https://github.com/clangd/clangd/issues/455 Differential Revision: https://reviews.llvm.org/D83546
2020-07-10 22:18:10 +08:00
}},
[clangd] Trivial setter support when moving items to fields Extend the Trivial setter documentation to support cases where the value is moved into a field using `std::move`. Reviewed By: sammccall, kadircet Differential Revision: https://reviews.llvm.org/D88297
2020-09-30 04:51:14 +08:00
{// No crash on InitListExpr.
R"cpp(
[clangd] Fix hover crash on InitListExpr. Fixes https://github.com/clangd/clangd/issues/455 Differential Revision: https://reviews.llvm.org/D83546
2020-07-10 22:18:10 +08:00
struct Foo {
int a[10];
};
constexpr Foo k2 = {
^[[{]]1} // FIXME: why the hover range is 1 character?
};
)cpp",
[](HoverInfo &HI) {
HI.Name = "expression";
HI.Kind = index::SymbolKind::Unknown;
HI.Type = "int [10]";
HI.Value = "{1}";
[clangd] More complete fix for hover crashes on invalid record. We should not call getFieldOffset on invalid record decls. Differential Revision: https://reviews.llvm.org/D83189
2020-07-06 23:12:39 +08:00
}}};
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
for (const auto &Case : Cases) {
SCOPED_TRACE(Case.Code);
Annotations T(Case.Code);
TestTU TU = TestTU::withCode(T.code());
TU.ExtraArgs.push_back("-std=c++17");
[clangd][Hover] Make tests hermetic by setting target triplet Summary: Fixes https://bugs.llvm.org/show_bug.cgi?id=44696 Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D73613
2020-01-29 18:17:45 +08:00
// Types might be different depending on the target triplet, we chose a
// fixed one to make sure tests passes on different platform.
TU.ExtraArgs.push_back("--target=x86_64-pc-linux-gnu");
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
auto AST = TU.build();
auto H = getHover(AST, T.point(), format::getLLVMStyle(), nullptr);
ASSERT_TRUE(H);
HoverInfo Expected;
Expected.SymRange = T.range();
Case.ExpectedBuilder(Expected);
EXPECT_EQ(H->NamespaceScope, Expected.NamespaceScope);
EXPECT_EQ(H->LocalScope, Expected.LocalScope);
EXPECT_EQ(H->Name, Expected.Name);
EXPECT_EQ(H->Kind, Expected.Kind);
EXPECT_EQ(H->Documentation, Expected.Documentation);
EXPECT_EQ(H->Definition, Expected.Definition);
EXPECT_EQ(H->Type, Expected.Type);
EXPECT_EQ(H->ReturnType, Expected.ReturnType);
EXPECT_EQ(H->Parameters, Expected.Parameters);
EXPECT_EQ(H->TemplateParameters, Expected.TemplateParameters);
EXPECT_EQ(H->SymRange, Expected.SymRange);
EXPECT_EQ(H->Value, Expected.Value);
[clangd] show layout info when hovering on a class/field definition. Summary: This triggers only on the definition itself, not on references (probably too noisy). Inspecting the definition seems like a decent hint for being interested in layout. Reviewers: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D77355
2020-04-03 09:07:10 +08:00
EXPECT_EQ(H->Size, Expected.Size);
EXPECT_EQ(H->Offset, Expected.Offset);
[clangd] Add access specifier information to hover contents Summary: For https://github.com/clangd/clangd/issues/382 This commit adds access specifier information to the hover contents. For example, the hover information of a class field or member function will now indicate if the field or member is private, public, or protected. This can be particularly useful when a developer is in the implementation file and wants to know if a particular member definition is public or private. Reviewers: kadircet Reviewed By: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, kadircet, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D80472
2020-05-28 00:17:07 +08:00
EXPECT_EQ(H->AccessSpecifier, Expected.AccessSpecifier);
[clangd] Improve hover on arguments to function call Summary: In cases like: foo(a, ^b); We now additionally show the name and type of the parameter to foo that corresponds that "b" is passed as. The name should help with understanding what it's used for and type can be useful to find out if call to foo() can mutate variable "b" or not (i.e. if it is pass by value, reference, const reference, etc). Patch By: adamcz@ ! Reviewers: kadircet Reviewed By: kadircet Subscribers: nridge, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D81169
2020-07-03 17:20:22 +08:00
EXPECT_EQ(H->CalleeArgInfo, Expected.CalleeArgInfo);
EXPECT_EQ(H->CallPassType, Expected.CallPassType);
}
}
TEST(Hover, CallPassType) {
const llvm::StringRef CodePrefix = R"cpp(
class Base {};
class Derived : public Base {};
class CustomClass {
public:
CustomClass() {}
CustomClass(const Base &x) {}
CustomClass(int &x) {}
CustomClass(float x) {}
};
void int_by_ref(int &x) {}
void int_by_const_ref(const int &x) {}
void int_by_value(int x) {}
void base_by_ref(Base &x) {}
void base_by_const_ref(const Base &x) {}
void base_by_value(Base x) {}
void float_by_value(float x) {}
void custom_by_value(CustomClass x) {}
void fun() {
int int_x;
int &int_ref = int_x;
const int &int_const_ref = int_x;
Base base;
const Base &base_const_ref = base;
Derived derived;
float float_x;
)cpp";
const llvm::StringRef CodeSuffix = "}";
struct {
const char *const Code;
HoverInfo::PassType::PassMode PassBy;
bool Converted;
} Tests[] = {
// Integer tests
{"int_by_value([[^int_x]]);", PassMode::Value, false},
{"int_by_ref([[^int_x]]);", PassMode::Ref, false},
{"int_by_const_ref([[^int_x]]);", PassMode::ConstRef, false},
{"int_by_value([[^int_ref]]);", PassMode::Value, false},
{"int_by_const_ref([[^int_ref]]);", PassMode::ConstRef, false},
{"int_by_const_ref([[^int_ref]]);", PassMode::ConstRef, false},
{"int_by_const_ref([[^int_const_ref]]);", PassMode::ConstRef, false},
// Custom class tests
{"base_by_ref([[^base]]);", PassMode::Ref, false},
{"base_by_const_ref([[^base]]);", PassMode::ConstRef, false},
{"base_by_const_ref([[^base_const_ref]]);", PassMode::ConstRef, false},
{"base_by_value([[^base]]);", PassMode::Value, false},
{"base_by_value([[^base_const_ref]]);", PassMode::Value, false},
{"base_by_ref([[^derived]]);", PassMode::Ref, false},
{"base_by_const_ref([[^derived]]);", PassMode::ConstRef, false},
{"base_by_value([[^derived]]);", PassMode::Value, false},
// Converted tests
{"float_by_value([[^int_x]]);", PassMode::Value, true},
{"float_by_value([[^int_ref]]);", PassMode::Value, true},
{"float_by_value([[^int_const_ref]]);", PassMode::Value, true},
{"custom_by_value([[^int_x]]);", PassMode::Ref, true},
{"custom_by_value([[^float_x]]);", PassMode::Value, true},
{"custom_by_value([[^base]]);", PassMode::ConstRef, true},
};
for (const auto &Test : Tests) {
SCOPED_TRACE(Test.Code);
const auto Code = (CodePrefix + Test.Code + CodeSuffix).str();
Annotations T(Code);
TestTU TU = TestTU::withCode(T.code());
TU.ExtraArgs.push_back("-std=c++17");
auto AST = TU.build();
auto H = getHover(AST, T.point(), format::getLLVMStyle(), nullptr);
ASSERT_TRUE(H);
EXPECT_EQ(H->CallPassType->PassBy, Test.PassBy);
EXPECT_EQ(H->CallPassType->Converted, Test.Converted);
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
}
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
TEST(Hover, NoHover) {
llvm::StringRef Tests[] = {
"^int main() {}",
"void foo() {^}",
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
// FIXME: "decltype(auto)" should be a single hover
"decltype(au^to) x = 0;",
// FIXME: not supported yet
R"cpp(// Lambda auto parameter
auto lamb = [](a^uto){};
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
)cpp",
[clangd] targetDecl() returns only NamedDecls. Summary: While it's perfectly reasonable for non-named decls such as static_assert to resolve to themselves: - nothing else ever resolves to them - features based on references (hover, highlight, find refs etc) tend to be uninteresting where only trivial references are possible - returning NamedDecl is a more convenient API (we cast to it in many places) - this aligns closer to findExplicitReferences/explicitReferenceTargets This fixes a crash in explicitReferenceTargets: if the target is a non-named decl then there's an invalid unchecked cast to NamedDecl. In practice this means when hovering over e.g. a static_assert: - before ac3f9e4842, we would show a (boring) hover card - after ac3f9e4842, we would crash - after this patch, we will show nothing Reviewers: kadircet, ilya-biryukov Subscribers: MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D72163
2020-01-04 00:26:33 +08:00
R"cpp(// non-named decls don't get hover. Don't crash!
^static_assert(1, "");
)cpp",
[clangd] Show hower info for expressions Summary: This currently populates only the Name with the expression's type and Value if expression is evaluatable. Fixes https://github.com/clangd/clangd/issues/56 Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D72500
2020-01-10 20:11:09 +08:00
R"cpp(// non-evaluatable expr
template <typename T> void foo() {
(void)[[size^of]](T);
})cpp",
[clang] Set the error-bit for ill-formed semantic InitListExpr. When a semantic checking fails on a syntactic InitListExpr, we will get an ill-formed semantic InitListExpr (e.g. some inits are nullptr), using this semantic InitListExpr in clang (without setting the err-bits) is crashy. Differential Revision: https://reviews.llvm.org/D84140
2020-07-21 15:39:44 +08:00
R"cpp(// should not crash on invalid semantic form of init-list-expr.
/*error-ok*/
struct Foo {
int xyz = 0;
};
class Bar {};
constexpr Foo s = ^{
.xyz = Bar(),
};
)cpp",
[clangd] Show hower info for expressions Summary: This currently populates only the Name with the expression's type and Value if expression is evaluatable. Fixes https://github.com/clangd/clangd/issues/56 Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D72500
2020-01-10 20:11:09 +08:00
// literals
"auto x = t^rue;",
"auto x = '^A';",
"auto x = ^(int){42};",
"auto x = ^42.;",
"auto x = ^42.0i;",
"auto x = ^42;",
"auto x = ^nullptr;",
"auto x = ^\"asdf\";",
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
};
for (const auto &Test : Tests) {
SCOPED_TRACE(Test);
Annotations T(Test);
TestTU TU = TestTU::withCode(T.code());
TU.ExtraArgs.push_back("-std=c++17");
auto AST = TU.build();
auto H = getHover(AST, T.point(), format::getLLVMStyle(), nullptr);
ASSERT_FALSE(H);
}
}
TEST(Hover, All) {
struct {
const char *const Code;
const std::function<void(HoverInfo &)> ExpectedBuilder;
} Cases[] = {
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
{
R"cpp(// Local variable
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
int main() {
int bonjour;
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
^[[bonjour]] = 2;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
int test1 = bonjour;
}
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
HI.Name = "bonjour";
HI.Kind = index::SymbolKind::Variable;
HI.NamespaceScope = "";
HI.LocalScope = "main::";
HI.Type = "int";
HI.Definition = "int bonjour";
}},
{
R"cpp(// Local variable in method
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
struct s {
void method() {
int bonjour;
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
^[[bonjour]] = 2;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
};
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
HI.Name = "bonjour";
HI.Kind = index::SymbolKind::Variable;
HI.NamespaceScope = "";
HI.LocalScope = "s::method::";
HI.Type = "int";
HI.Definition = "int bonjour";
}},
{
R"cpp(// Struct
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
namespace ns1 {
struct MyClass {};
} // namespace ns1
int main() {
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
ns1::[[My^Class]]* Params;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
HI.Name = "MyClass";
HI.Kind = index::SymbolKind::Struct;
HI.NamespaceScope = "ns1::";
HI.Definition = "struct MyClass {}";
}},
{
R"cpp(// Class
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
namespace ns1 {
class MyClass {};
} // namespace ns1
int main() {
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
ns1::[[My^Class]]* Params;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
HI.Name = "MyClass";
HI.Kind = index::SymbolKind::Class;
HI.NamespaceScope = "ns1::";
HI.Definition = "class MyClass {}";
}},
{
R"cpp(// Union
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
namespace ns1 {
union MyUnion { int x; int y; };
} // namespace ns1
int main() {
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
ns1::[[My^Union]] Params;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
HI.Name = "MyUnion";
HI.Kind = index::SymbolKind::Union;
HI.NamespaceScope = "ns1::";
HI.Definition = "union MyUnion {}";
}},
{
R"cpp(// Function definition via pointer
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
void foo(int) {}
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
int main() {
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
auto *X = &^[[foo]];
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
HI.Name = "foo";
HI.Kind = index::SymbolKind::Function;
HI.NamespaceScope = "";
HI.Type = "void (int)";
HI.Definition = "void foo(int)";
HI.Documentation = "Function definition via pointer";
HI.ReturnType = "void";
HI.Parameters = {
{std::string("int"), llvm::None, llvm::None},
};
}},
{
R"cpp(// Function declaration via call
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
int foo(int);
int main() {
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
return ^[[foo]](42);
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
HI.Name = "foo";
HI.Kind = index::SymbolKind::Function;
HI.NamespaceScope = "";
HI.Type = "int (int)";
HI.Definition = "int foo(int)";
HI.Documentation = "Function declaration via call";
HI.ReturnType = "int";
HI.Parameters = {
{std::string("int"), llvm::None, llvm::None},
};
}},
{
R"cpp(// Field
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
struct Foo { int x; };
int main() {
Foo bar;
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
(void)bar.^[[x]];
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
HI.Name = "x";
HI.Kind = index::SymbolKind::Field;
HI.NamespaceScope = "";
HI.LocalScope = "Foo::";
HI.Type = "int";
HI.Definition = "int x";
}},
{
R"cpp(// Field with initialization
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
struct Foo { int x = 5; };
int main() {
Foo bar;
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
(void)bar.^[[x]];
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
HI.Name = "x";
HI.Kind = index::SymbolKind::Field;
HI.NamespaceScope = "";
HI.LocalScope = "Foo::";
HI.Type = "int";
HI.Definition = "int x = 5";
}},
{
R"cpp(// Static field
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
struct Foo { static int x; };
int main() {
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
(void)Foo::^[[x]];
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
HI.Name = "x";
HI.Kind = index::SymbolKind::StaticProperty;
HI.NamespaceScope = "";
HI.LocalScope = "Foo::";
HI.Type = "int";
HI.Definition = "static int x";
}},
{
R"cpp(// Field, member initializer
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
struct Foo {
int x;
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
Foo() : ^[[x]](0) {}
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
};
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
HI.Name = "x";
HI.Kind = index::SymbolKind::Field;
HI.NamespaceScope = "";
HI.LocalScope = "Foo::";
HI.Type = "int";
HI.Definition = "int x";
}},
{
R"cpp(// Field, GNU old-style field designator
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
struct Foo { int x; };
int main() {
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
Foo bar = { ^[[x]] : 1 };
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
HI.Name = "x";
HI.Kind = index::SymbolKind::Field;
HI.NamespaceScope = "";
HI.LocalScope = "Foo::";
HI.Type = "int";
HI.Definition = "int x";
[clangd] Disable printing of Value for tag-types on hover Summary: This is both confusing and crashy. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D82326
2020-06-23 03:53:47 +08:00
// FIXME: Initializer for x is a DesignatedInitListExpr, hence it is
// of struct type and omitted.
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
}},
{
R"cpp(// Field, field designator
[clangd] Disable printing of Value for tag-types on hover Summary: This is both confusing and crashy. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D82326
2020-06-23 03:53:47 +08:00
struct Foo { int x; int y; };
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
int main() {
[clangd] Disable printing of Value for tag-types on hover Summary: This is both confusing and crashy. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D82326
2020-06-23 03:53:47 +08:00
Foo bar = { .^[[x]] = 2, .y = 2 };
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
HI.Name = "x";
HI.Kind = index::SymbolKind::Field;
HI.NamespaceScope = "";
HI.LocalScope = "Foo::";
HI.Type = "int";
HI.Definition = "int x";
}},
{
R"cpp(// Method call
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
struct Foo { int x(); };
int main() {
Foo bar;
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
bar.^[[x]]();
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
HI.Name = "x";
HI.Kind = index::SymbolKind::InstanceMethod;
HI.NamespaceScope = "";
HI.LocalScope = "Foo::";
HI.Type = "int ()";
HI.Definition = "int x()";
HI.ReturnType = "int";
HI.Parameters = std::vector<HoverInfo::Param>{};
}},
{
R"cpp(// Static method call
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
struct Foo { static int x(); };
int main() {
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
Foo::^[[x]]();
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
HI.Name = "x";
HI.Kind = index::SymbolKind::StaticMethod;
HI.NamespaceScope = "";
HI.LocalScope = "Foo::";
HI.Type = "int ()";
HI.Definition = "static int x()";
HI.ReturnType = "int";
HI.Parameters = std::vector<HoverInfo::Param>{};
}},
{
R"cpp(// Typedef
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
typedef int Foo;
int main() {
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
^[[Foo]] bar;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
HI.Name = "Foo";
HI.Kind = index::SymbolKind::TypeAlias;
HI.NamespaceScope = "";
HI.Definition = "typedef int Foo";
HI.Documentation = "Typedef";
// FIXME: Maybe put underlying type into HI.Type for aliases?
}},
{
R"cpp(// Typedef with embedded definition
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
typedef struct Bar {} Foo;
int main() {
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
^[[Foo]] bar;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
HI.Name = "Foo";
HI.Kind = index::SymbolKind::TypeAlias;
HI.NamespaceScope = "";
HI.Definition = "typedef struct Bar Foo";
HI.Documentation = "Typedef with embedded definition";
}},
{
R"cpp(// Namespace
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
namespace ns {
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
struct Foo { static void bar(); };
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
} // namespace ns
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
int main() { ^[[ns]]::Foo::bar(); }
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
HI.Name = "ns";
HI.Kind = index::SymbolKind::Namespace;
HI.NamespaceScope = "";
HI.Definition = "namespace ns {}";
}},
{
R"cpp(// Anonymous namespace
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
namespace ns {
namespace {
int foo;
} // anonymous namespace
} // namespace ns
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
int main() { ns::[[f^oo]]++; }
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
HI.Name = "foo";
HI.Kind = index::SymbolKind::Variable;
HI.NamespaceScope = "ns::";
HI.Type = "int";
HI.Definition = "int foo";
}},
{
R"cpp(// Macro
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
#define MACRO 0
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
int main() { return ^[[MACRO]]; }
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
HI.Name = "MACRO";
HI.Kind = index::SymbolKind::Macro;
HI.Definition = "#define MACRO 0";
}},
{
R"cpp(// Macro
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
#define MACRO 0
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
#define MACRO2 ^[[MACRO]]
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
HI.Name = "MACRO";
HI.Kind = index::SymbolKind::Macro;
HI.Definition = "#define MACRO 0";
}},
{
R"cpp(// Macro
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
#define MACRO {\
return 0;\
}
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
int main() ^[[MACRO]]
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
HI.Name = "MACRO";
HI.Kind = index::SymbolKind::Macro;
HI.Definition =
R"cpp(#define MACRO \
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
{ return 0; })cpp";
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
}},
{
R"cpp(// Forward class declaration
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
class Foo;
class Foo {};
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
[[F^oo]]* foo();
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
HI.Name = "Foo";
HI.Kind = index::SymbolKind::Class;
HI.NamespaceScope = "";
HI.Definition = "class Foo {}";
HI.Documentation = "Forward class declaration";
}},
{
R"cpp(// Function declaration
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
void foo();
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
void g() { [[f^oo]](); }
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
void foo() {}
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
HI.Name = "foo";
HI.Kind = index::SymbolKind::Function;
HI.NamespaceScope = "";
HI.Type = "void ()";
HI.Definition = "void foo()";
HI.Documentation = "Function declaration";
HI.ReturnType = "void";
HI.Parameters = std::vector<HoverInfo::Param>{};
}},
{
R"cpp(// Enum declaration
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
enum Hello {
ONE, TWO, THREE,
};
void foo() {
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
[[Hel^lo]] hello = ONE;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
HI.Name = "Hello";
HI.Kind = index::SymbolKind::Enum;
HI.NamespaceScope = "";
HI.Definition = "enum Hello {}";
HI.Documentation = "Enum declaration";
}},
{
R"cpp(// Enumerator
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
enum Hello {
ONE, TWO, THREE,
};
void foo() {
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
Hello hello = [[O^NE]];
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
HI.Name = "ONE";
HI.Kind = index::SymbolKind::EnumConstant;
HI.NamespaceScope = "";
HI.LocalScope = "Hello::";
HI.Type = "enum Hello";
HI.Definition = "ONE";
HI.Value = "0";
}},
{
R"cpp(// Enumerator in anonymous enum
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
enum {
ONE, TWO, THREE,
};
void foo() {
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
int hello = [[O^NE]];
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
HI.Name = "ONE";
HI.Kind = index::SymbolKind::EnumConstant;
HI.NamespaceScope = "";
// FIXME: This should be `(anon enum)::`
HI.LocalScope = "";
HI.Type = "enum (anonymous)";
HI.Definition = "ONE";
HI.Value = "0";
}},
{
R"cpp(// Global variable
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
static int hey = 10;
void foo() {
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
[[he^y]]++;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
HI.Name = "hey";
HI.Kind = index::SymbolKind::Variable;
HI.NamespaceScope = "";
HI.Type = "int";
HI.Definition = "static int hey = 10";
HI.Documentation = "Global variable";
// FIXME: Value shouldn't be set in this case
HI.Value = "10";
}},
{
R"cpp(// Global variable in namespace
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
namespace ns1 {
static int hey = 10;
}
void foo() {
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
ns1::[[he^y]]++;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
HI.Name = "hey";
HI.Kind = index::SymbolKind::Variable;
HI.NamespaceScope = "ns1::";
HI.Type = "int";
HI.Definition = "static int hey = 10";
HI.Value = "10";
}},
{
R"cpp(// Field in anonymous struct
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
static struct {
int hello;
} s;
void foo() {
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
s.[[he^llo]]++;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
HI.Name = "hello";
HI.Kind = index::SymbolKind::Field;
HI.NamespaceScope = "";
HI.LocalScope = "(anonymous struct)::";
HI.Type = "int";
HI.Definition = "int hello";
}},
{
R"cpp(// Templated function
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
template <typename T>
T foo() {
return 17;
}
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
void g() { auto x = [[f^oo]]<int>(); }
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
HI.Name = "foo";
HI.Kind = index::SymbolKind::Function;
HI.NamespaceScope = "";
HI.Type = "int ()";
HI.Definition = "template <> int foo<int>()";
HI.Documentation = "Templated function";
HI.ReturnType = "int";
HI.Parameters = std::vector<HoverInfo::Param>{};
// FIXME: We should populate template parameters with arguments in
// case of instantiations.
}},
{
R"cpp(// Anonymous union
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
struct outer {
union {
int abc, def;
} v;
};
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
void g() { struct outer o; o.v.[[d^ef]]++; }
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
HI.Name = "def";
HI.Kind = index::SymbolKind::Field;
HI.NamespaceScope = "";
HI.LocalScope = "outer::(anonymous union)::";
HI.Type = "int";
HI.Definition = "int def";
}},
{
R"cpp(// documentation from index
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
int nextSymbolIsAForwardDeclFromIndexWithNoLocalDocs;
void indexSymbol();
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
void g() { [[ind^exSymbol]](); }
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
HI.Name = "indexSymbol";
HI.Kind = index::SymbolKind::Function;
HI.NamespaceScope = "";
HI.Type = "void ()";
HI.Definition = "void indexSymbol()";
HI.ReturnType = "void";
HI.Parameters = std::vector<HoverInfo::Param>{};
HI.Documentation = "comment from index";
}},
{
R"cpp(// Simple initialization with auto
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
void foo() {
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
^[[auto]] i = 1;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
HI.Name = "auto";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "int";
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
}},
{
R"cpp(// Simple initialization with const auto
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
void foo() {
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
const ^[[auto]] i = 1;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
[](HoverInfo &HI) {
HI.Name = "auto";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "int";
}},
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
{
R"cpp(// Simple initialization with const auto&
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
void foo() {
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
const ^[[auto]]& i = 1;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
[](HoverInfo &HI) {
HI.Name = "auto";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "int";
}},
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
{
R"cpp(// Simple initialization with auto&
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
void foo() {
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
int x;
^[[auto]]& i = x;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
[](HoverInfo &HI) {
HI.Name = "auto";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "int";
}},
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
{
R"cpp(// Simple initialization with auto*
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
void foo() {
int a = 1;
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
^[[auto]]* i = &a;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
[](HoverInfo &HI) {
HI.Name = "auto";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "int";
}},
{
R"cpp(// Simple initialization with auto from pointer
void foo() {
int a = 1;
^[[auto]] i = &a;
}
)cpp",
[](HoverInfo &HI) {
HI.Name = "auto";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "int *";
}},
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
{
R"cpp(// Auto with initializer list.
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
namespace std
{
template<class _E>
class initializer_list {};
}
void foo() {
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
^[[auto]] i = {1,2};
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
HI.Name = "auto";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "class std::initializer_list<int>";
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
}},
{
R"cpp(// User defined conversion to auto
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
struct Bar {
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
operator ^[[auto]]() const { return 10; }
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
};
)cpp",
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
[](HoverInfo &HI) {
HI.Name = "auto";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "int";
}},
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
{
R"cpp(// Simple initialization with decltype(auto)
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
void foo() {
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
^[[decltype]](auto) i = 1;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
[](HoverInfo &HI) {
HI.Name = "decltype";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "int";
}},
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
{
R"cpp(// Simple initialization with const decltype(auto)
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
void foo() {
const int j = 0;
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
^[[decltype]](auto) i = j;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
[](HoverInfo &HI) {
HI.Name = "decltype";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "const int";
}},
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
{
R"cpp(// Simple initialization with const& decltype(auto)
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
void foo() {
int k = 0;
const int& j = k;
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
^[[decltype]](auto) i = j;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
[](HoverInfo &HI) {
HI.Name = "decltype";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "const int &";
}},
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
{
R"cpp(// Simple initialization with & decltype(auto)
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
void foo() {
int k = 0;
int& j = k;
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
^[[decltype]](auto) i = j;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
[](HoverInfo &HI) {
HI.Name = "decltype";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "int &";
}},
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
{
R"cpp(// simple trailing return type
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
^[[auto]] main() -> int {
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
return 0;
}
)cpp",
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
[](HoverInfo &HI) {
HI.Name = "auto";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "int";
}},
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
{
R"cpp(// auto function return with trailing type
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
struct Bar {};
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
^[[auto]] test() -> decltype(Bar()) {
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
return Bar();
}
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
HI.Name = "auto";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "struct Bar";
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
HI.Documentation = "auto function return with trailing type";
}},
{
R"cpp(// trailing return type
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
struct Bar {};
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
auto test() -> ^[[decltype]](Bar()) {
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
return Bar();
}
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
HI.Name = "decltype";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "struct Bar";
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
HI.Documentation = "trailing return type";
}},
{
R"cpp(// auto in function return
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
struct Bar {};
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
^[[auto]] test() {
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
return Bar();
}
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
HI.Name = "auto";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "struct Bar";
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
HI.Documentation = "auto in function return";
}},
{
R"cpp(// auto& in function return
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
struct Bar {};
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
^[[auto]]& test() {
static Bar x;
return x;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
HI.Name = "auto";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "struct Bar";
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
HI.Documentation = "auto& in function return";
}},
{
R"cpp(// auto* in function return
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
struct Bar {};
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
^[[auto]]* test() {
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
Bar* bar;
return bar;
}
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
HI.Name = "auto";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "struct Bar";
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
HI.Documentation = "auto* in function return";
}},
{
R"cpp(// const auto& in function return
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
struct Bar {};
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
const ^[[auto]]& test() {
static Bar x;
return x;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
HI.Name = "auto";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "struct Bar";
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
HI.Documentation = "const auto& in function return";
}},
{
R"cpp(// decltype(auto) in function return
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
struct Bar {};
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
^[[decltype]](auto) test() {
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
return Bar();
}
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
HI.Name = "decltype";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "struct Bar";
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
HI.Documentation = "decltype(auto) in function return";
}},
{
R"cpp(// decltype(auto) reference in function return
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
^[[decltype]](auto) test() {
static int a;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
return (a);
}
)cpp",
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
[](HoverInfo &HI) {
HI.Name = "decltype";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "int &";
}},
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
{
R"cpp(// decltype lvalue reference
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
void foo() {
int I = 0;
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
^[[decltype]](I) J = I;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
[](HoverInfo &HI) {
HI.Name = "decltype";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "int";
}},
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
{
R"cpp(// decltype lvalue reference
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
void foo() {
int I= 0;
int &K = I;
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
^[[decltype]](K) J = I;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
[](HoverInfo &HI) {
HI.Name = "decltype";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "int &";
}},
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
{
R"cpp(// decltype lvalue reference parenthesis
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
void foo() {
int I = 0;
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
^[[decltype]]((I)) J = I;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
[](HoverInfo &HI) {
HI.Name = "decltype";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "int &";
}},
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
{
R"cpp(// decltype rvalue reference
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
void foo() {
int I = 0;
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
^[[decltype]](static_cast<int&&>(I)) J = static_cast<int&&>(I);
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
[](HoverInfo &HI) {
HI.Name = "decltype";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "int &&";
}},
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
{
R"cpp(// decltype rvalue reference function call
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
int && bar();
void foo() {
int I = 0;
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
^[[decltype]](bar()) J = bar();
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
[](HoverInfo &HI) {
HI.Name = "decltype";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "int &&";
}},
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
{
R"cpp(// decltype of function with trailing return type.
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
struct Bar {};
auto test() -> decltype(Bar()) {
return Bar();
}
void foo() {
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
^[[decltype]](test()) i = test();
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
HI.Name = "decltype";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "struct Bar";
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
HI.Documentation =
"decltype of function with trailing return type.";
}},
{
R"cpp(// decltype of var with decltype.
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
void foo() {
int I = 0;
decltype(I) J = I;
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
^[[decltype]](J) K = J;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
)cpp",
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
[](HoverInfo &HI) {
HI.Name = "decltype";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "int";
}},
{
R"cpp(// decltype of dependent type
template <typename T>
struct X {
using Y = ^[[decltype]](T::Z);
};
)cpp",
[](HoverInfo &HI) {
HI.Name = "decltype";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "<dependent type>";
}},
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
{
NFC: Fix trivial typos in comments
2020-01-04 23:28:41 +08:00
R"cpp(// More complicated structured types.
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
int bar();
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
^[[auto]] (*foo)() = bar;
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
)cpp",
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
[](HoverInfo &HI) {
HI.Name = "auto";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "int";
}},
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
{
R"cpp(// Should not crash when evaluating the initializer.
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
struct Test {};
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
void test() { Test && [[te^st]] = {}; }
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
HI.Name = "test";
HI.Kind = index::SymbolKind::Variable;
HI.NamespaceScope = "";
HI.LocalScope = "test::";
[clangd] Make our printing policies for Hover more consistent, especially tags Different cases were using a bunch of different variants of the printing policy. Each of these had something going for it, but the result was inconsistent. Goals: - single printing policy used (almost) everywhere - avoid unidiomatic tags like `class vector<class X>` - be informative and easy to understand For tags, the solution I wound up with is: we print only the outer tag and only in the simplest cases where this elaboration won't cause confusion. For example: - class X - enum Foo - vector<int> - X* This seems to strike a nice balance of providing plenty of info/context in common cases while never being confusing. Differential Revision: https://reviews.llvm.org/D93553
2020-12-19 01:39:20 +08:00
HI.Type = "Test &&";
[clangd] Improve type printing in hover Summary: Do not include tag keywords when printing types for symbol names, as it will come from SymbolKind. Also suppress them while printing definitions to prevent them occuring in template arguments. Make use of `getAsString`, instead of `print` in all places to have a consistent style across the file. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D72450
2020-01-07 22:15:00 +08:00
HI.Definition = "Test &&test = {}";
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
}},
{
R"cpp(// auto on alias
[clangd][NFC] Make use of TagDecl inside type for hover on auto Summary: We were traversing AST twice to get the Decl in case of sugared types(auto, decltype). They seem to be same in practice, so this patch gets rid of the second traversal and makes use of TagDecl inside QualType instead. Reviewers: ilya-biryukov Subscribers: MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D71597
2019-12-17 20:00:12 +08:00
typedef int int_type;
^[[auto]] x = int_type();
)cpp",
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
[](HoverInfo &HI) {
HI.Name = "auto";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "int";
}},
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
{
R"cpp(// auto on alias
[clangd][NFC] Make use of TagDecl inside type for hover on auto Summary: We were traversing AST twice to get the Decl in case of sugared types(auto, decltype). They seem to be same in practice, so this patch gets rid of the second traversal and makes use of TagDecl inside QualType instead. Reviewers: ilya-biryukov Subscribers: MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D71597
2019-12-17 20:00:12 +08:00
struct cls {};
typedef cls cls_type;
^[[auto]] y = cls_type();
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
HI.Name = "auto";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "struct cls";
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
HI.Documentation = "auto on alias";
}},
{
R"cpp(// auto on alias
[clangd][NFC] Make use of TagDecl inside type for hover on auto Summary: We were traversing AST twice to get the Decl in case of sugared types(auto, decltype). They seem to be same in practice, so this patch gets rid of the second traversal and makes use of TagDecl inside QualType instead. Reviewers: ilya-biryukov Subscribers: MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D71597
2019-12-17 20:00:12 +08:00
template <class>
struct templ {};
^[[auto]] z = templ<int>();
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
HI.Name = "auto";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "struct templ<int>";
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
HI.Documentation = "auto on alias";
}},
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
{
R"cpp(// Undeduced auto declaration
template<typename T>
void foo() {
^[[auto]] x = T();
}
)cpp",
[](HoverInfo &HI) {
HI.Name = "auto";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "/* not deduced */";
}},
{
R"cpp(// Undeduced auto return type
template<typename T>
^[[auto]] foo() {
return T();
}
)cpp",
[](HoverInfo &HI) {
HI.Name = "auto";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "/* not deduced */";
}},
{
R"cpp(// Template auto parameter
template<[[a^uto]] T>
void func() {
}
)cpp",
[](HoverInfo &HI) {
// FIXME: not sure this is what we want, but this
// is what we currently get with getDeducedType
HI.Name = "auto";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "/* not deduced */";
}},
{
R"cpp(// Undeduced decltype(auto) return type
template<typename T>
^[[decltype]](auto) foo() {
return T();
}
)cpp",
[](HoverInfo &HI) {
HI.Name = "decltype";
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "/* not deduced */";
}},
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
{
R"cpp(// should not crash.
[clangd] Fix crash in hover
2019-12-27 16:11:03 +08:00
template <class T> struct cls {
int method();
};
auto test = cls<int>().[[m^ethod]]();
)cpp",
[clangd] Reformat `HoverTests.cpp` NFC I accidentally broke formatting in the previous revision.
2019-12-27 16:26:39 +08:00
[](HoverInfo &HI) {
HI.Definition = "int method()";
HI.Kind = index::SymbolKind::InstanceMethod;
HI.NamespaceScope = "";
HI.LocalScope = "cls<int>::";
HI.Name = "method";
HI.Parameters.emplace();
HI.ReturnType = "int";
HI.Type = "int ()";
}},
[clangd] Improve type printing in hover Summary: Do not include tag keywords when printing types for symbol names, as it will come from SymbolKind. Also suppress them while printing definitions to prevent them occuring in template arguments. Make use of `getAsString`, instead of `print` in all places to have a consistent style across the file. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D72450
2020-01-07 22:15:00 +08:00
{
R"cpp(// type of nested templates.
template <class T> struct cls {};
cls<cls<cls<int>>> [[fo^o]];
)cpp",
[](HoverInfo &HI) {
HI.Definition = "cls<cls<cls<int>>> foo";
HI.Kind = index::SymbolKind::Variable;
HI.NamespaceScope = "";
HI.Name = "foo";
[AST] Print a<b<c>> without extra spaces in C++11 or later. Summary: It's not 1998 anymore. Reviewers: kadircet Subscribers: jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D76801
2020-03-26 04:41:12 +08:00
HI.Type = "cls<cls<cls<int>>>";
[clangd] Improve type printing in hover Summary: Do not include tag keywords when printing types for symbol names, as it will come from SymbolKind. Also suppress them while printing definitions to prevent them occuring in template arguments. Make use of `getAsString`, instead of `print` in all places to have a consistent style across the file. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D72450
2020-01-07 22:15:00 +08:00
}},
{
R"cpp(// type of nested templates.
template <class T> struct cls {};
[[cl^s]]<cls<cls<int>>> foo;
)cpp",
[](HoverInfo &HI) {
HI.Definition = "template <> struct cls<cls<cls<int>>> {}";
HI.Kind = index::SymbolKind::Struct;
HI.NamespaceScope = "";
[AST] Print a<b<c>> without extra spaces in C++11 or later. Summary: It's not 1998 anymore. Reviewers: kadircet Subscribers: jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D76801
2020-03-26 04:41:12 +08:00
HI.Name = "cls<cls<cls<int>>>";
[clangd] Improve type printing in hover Summary: Do not include tag keywords when printing types for symbol names, as it will come from SymbolKind. Also suppress them while printing definitions to prevent them occuring in template arguments. Make use of `getAsString`, instead of `print` in all places to have a consistent style across the file. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D72450
2020-01-07 22:15:00 +08:00
HI.Documentation = "type of nested templates.";
}},
[clangd] Print underlying type for decltypes in hover Summary: Fixes https://github.com/clangd/clangd/issues/249 Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D72498
2020-01-16 22:20:13 +08:00
{
R"cpp(// type with decltype
int a;
decltype(a) [[b^]] = a;)cpp",
[](HoverInfo &HI) {
HI.Definition = "decltype(a) b = a";
HI.Kind = index::SymbolKind::Variable;
HI.NamespaceScope = "";
HI.Name = "b";
HI.Type = "int";
}},
{
R"cpp(// type with decltype
int a;
decltype(a) c;
decltype(c) [[b^]] = a;)cpp",
[](HoverInfo &HI) {
HI.Definition = "decltype(c) b = a";
HI.Kind = index::SymbolKind::Variable;
HI.NamespaceScope = "";
HI.Name = "b";
HI.Type = "int";
}},
{
R"cpp(// type with decltype
int a;
const decltype(a) [[b^]] = a;)cpp",
[](HoverInfo &HI) {
HI.Definition = "const decltype(a) b = a";
HI.Kind = index::SymbolKind::Variable;
HI.NamespaceScope = "";
HI.Name = "b";
HI.Type = "int";
}},
{
R"cpp(// type with decltype
int a;
auto [[f^oo]](decltype(a) x) -> decltype(a) { return 0; })cpp",
[](HoverInfo &HI) {
HI.Definition = "auto foo(decltype(a) x) -> decltype(a)";
HI.Kind = index::SymbolKind::Function;
HI.NamespaceScope = "";
HI.Name = "foo";
// FIXME: Handle composite types with decltype with a printing
// policy.
HI.Type = "auto (decltype(a)) -> decltype(a)";
HI.ReturnType = "int";
HI.Parameters = {
{std::string("int"), std::string("x"), llvm::None}};
}},
[clangd][Hover] Make tests hermetic by setting target triplet Summary: Fixes https://bugs.llvm.org/show_bug.cgi?id=44696 Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D73613
2020-01-29 18:17:45 +08:00
{
R"cpp(// sizeof expr
void foo() {
(void)[[size^of]](char);
})cpp",
[](HoverInfo &HI) {
HI.Name = "expression";
HI.Type = "unsigned long";
HI.Value = "1";
}},
{
R"cpp(// alignof expr
void foo() {
(void)[[align^of]](char);
})cpp",
[](HoverInfo &HI) {
HI.Name = "expression";
HI.Type = "unsigned long";
HI.Value = "1";
}},
[clangd][Hover] Handle uninstantiated default args Summary: Default args might exist but be unparsed or uninstantiated. getDefaultArg asserts on those. This patch makes sure we don't crash in such scenarios. Reviewers: sammccall, ilya-biryukov Subscribers: MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D73723
2020-01-31 01:42:01 +08:00
{
R"cpp(
template <typename T = int>
void foo(const T& = T()) {
[[f^oo]]<>(3);
})cpp",
[](HoverInfo &HI) {
HI.Name = "foo";
HI.Kind = index::SymbolKind::Function;
HI.Type = "void (const int &)";
HI.ReturnType = "void";
HI.Parameters = {
{std::string("const int &"), llvm::None, std::string("T()")}};
HI.Definition = "template <> void foo<int>(const int &)";
HI.NamespaceScope = "";
}},
[AST] Fix an assertion violation in FieldDecl::getParent. Summary: FieldDecl::getParent assumes that the FiledDecl::getDeclContext returns a RecordDecl, this is true for C/C++, but not for ObjCIvarDecl: The Decls hierarchy is like following FieldDecl <-- ObjCIvarDecl DeclContext <-- ObjCContainerDecl <-- ObjCInterfaceDecl ^ |----- TagDecl <-- RecordDecl calling getParent() on ObjCIvarDecl will: 1. invoke getDeclContext(), which returns a DeclContext*, which points to an ObjCInterfaceDecl; 2. then downcast the "DeclContext" pointer to a RecordDecl*, and we will hit the "is_a<RecordDecl>" assertion in llvm::cast (undefined behavior in release build without assertion enabled); Fixes https://github.com/clangd/clangd/issues/369 Reviewers: sammccall Reviewed By: sammccall Subscribers: rsmith, jkorous, arphaman, kadircet, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D79627
2020-05-19 21:26:42 +08:00
{
R"cpp(// should not crash
@interface ObjC {
char [[da^ta]];
}@end
)cpp",
[](HoverInfo &HI) {
HI.Name = "data";
HI.Type = "char";
HI.Kind = index::SymbolKind::Field;
Improve hover scopes for Objective-C code - Instead of `AppDelegate::application:didFinishLaunchingWithOptions:` you will now see `-[AppDelegate application:didFinishLaunchingWithOptions:]` - Also include categories in the name when printing the scopes, e.g. `Class(Category)` and `-[Class(Category) method]` Differential Revision: https://reviews.llvm.org/D68590
2020-12-05 04:04:25 +08:00
HI.LocalScope = "ObjC::";
HI.NamespaceScope = "";
[AST] Fix an assertion violation in FieldDecl::getParent. Summary: FieldDecl::getParent assumes that the FiledDecl::getDeclContext returns a RecordDecl, this is true for C/C++, but not for ObjCIvarDecl: The Decls hierarchy is like following FieldDecl <-- ObjCIvarDecl DeclContext <-- ObjCContainerDecl <-- ObjCInterfaceDecl ^ |----- TagDecl <-- RecordDecl calling getParent() on ObjCIvarDecl will: 1. invoke getDeclContext(), which returns a DeclContext*, which points to an ObjCInterfaceDecl; 2. then downcast the "DeclContext" pointer to a RecordDecl*, and we will hit the "is_a<RecordDecl>" assertion in llvm::cast (undefined behavior in release build without assertion enabled); Fixes https://github.com/clangd/clangd/issues/369 Reviewers: sammccall Reviewed By: sammccall Subscribers: rsmith, jkorous, arphaman, kadircet, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D79627
2020-05-19 21:26:42 +08:00
HI.Definition = "char data";
}},
[clangd][ObjC] Support nullability annotations Nullability annotations are implmented using attributes; previusly clangd would skip over AttributedTypeLoc since their location points to the attribute instead of the modified type. Also add some test cases for this. Differential Revision: https://reviews.llvm.org/D89579
2020-10-17 02:14:37 +08:00
{
R"cpp(
@interface MYObject
@end
@interface Interface
@property(retain) [[MYOb^ject]] *x;
@end
)cpp",
[](HoverInfo &HI) {
HI.Name = "MYObject";
HI.Kind = index::SymbolKind::Class;
HI.NamespaceScope = "";
HI.Definition = "@interface MYObject\n@end";
}},
{
R"cpp(
@interface MYObject
@end
@interface Interface
- (void)doWith:([[MYOb^ject]] *)object;
@end
)cpp",
[](HoverInfo &HI) {
HI.Name = "MYObject";
HI.Kind = index::SymbolKind::Class;
HI.NamespaceScope = "";
HI.Definition = "@interface MYObject\n@end";
}},
[clangd] Add hover info for `this` expr How about add hover information for `this` expr? It seems useful to show related information about the class for `this` expr sometimes. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D92041
2020-12-15 16:45:56 +08:00
{
R"cpp(// this expr
// comment
namespace ns {
class Foo {
Foo* bar() {
return [[t^his]];
}
};
}
)cpp",
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
[](HoverInfo &HI) {
HI.Name = "this";
[clangd] Make our printing policies for Hover more consistent, especially tags Different cases were using a bunch of different variants of the printing policy. Each of these had something going for it, but the result was inconsistent. Goals: - single printing policy used (almost) everywhere - avoid unidiomatic tags like `class vector<class X>` - be informative and easy to understand For tags, the solution I wound up with is: we print only the outer tag and only in the simplest cases where this elaboration won't cause confusion. For example: - class X - enum Foo - vector<int> - X* This seems to strike a nice balance of providing plenty of info/context in common cases while never being confusing. Differential Revision: https://reviews.llvm.org/D93553
2020-12-19 01:39:20 +08:00
HI.Definition = "ns::Foo *";
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
}},
[clangd] Add hover info for `this` expr How about add hover information for `this` expr? It seems useful to show related information about the class for `this` expr sometimes. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D92041
2020-12-15 16:45:56 +08:00
{
R"cpp(// this expr for template class
namespace ns {
template <typename T>
class Foo {
Foo* bar() const {
return [[t^his]];
}
};
}
)cpp",
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
[](HoverInfo &HI) {
HI.Name = "this";
HI.Definition = "const Foo<T> *";
}},
[clangd] Add hover info for `this` expr How about add hover information for `this` expr? It seems useful to show related information about the class for `this` expr sometimes. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D92041
2020-12-15 16:45:56 +08:00
{
R"cpp(// this expr for specialization class
namespace ns {
template <typename T> class Foo {};
template <>
struct Foo<int> {
Foo* bar() {
return [[thi^s]];
}
};
}
)cpp",
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
[](HoverInfo &HI) {
HI.Name = "this";
HI.Definition = "Foo<int> *";
}},
[clangd] Add hover info for `this` expr How about add hover information for `this` expr? It seems useful to show related information about the class for `this` expr sometimes. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D92041
2020-12-15 16:45:56 +08:00
{
R"cpp(// this expr for partial specialization struct
namespace ns {
template <typename T, typename F> struct Foo {};
template <typename F>
struct Foo<int, F> {
Foo* bar() const {
return [[thi^s]];
}
};
}
)cpp",
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
[](HoverInfo &HI) {
HI.Name = "this";
HI.Definition = "const Foo<int, F> *";
}},
Improve hover scopes for Objective-C code - Instead of `AppDelegate::application:didFinishLaunchingWithOptions:` you will now see `-[AppDelegate application:didFinishLaunchingWithOptions:]` - Also include categories in the name when printing the scopes, e.g. `Class(Category)` and `-[Class(Category) method]` Differential Revision: https://reviews.llvm.org/D68590
2020-12-05 04:04:25 +08:00
{
R"cpp(
@interface MYObject
@end
@interface MYObject (Private)
@property(nonatomic, assign) int privateField;
@end
int someFunction() {
MYObject *obj = [MYObject sharedInstance];
return obj.[[private^Field]];
}
)cpp",
[](HoverInfo &HI) {
HI.Name = "privateField";
HI.Kind = index::SymbolKind::InstanceProperty;
HI.LocalScope = "MYObject(Private)::";
HI.NamespaceScope = "";
HI.Definition = "@property(nonatomic, assign, unsafe_unretained, "
"readwrite) int privateField;";
}},
{
R"cpp(
@protocol MYProtocol
@property(nonatomic, assign) int prop1;
@end
int someFunction() {
id<MYProtocol> obj = 0;
return obj.[[pro^p1]];
}
)cpp",
[](HoverInfo &HI) {
HI.Name = "prop1";
HI.Kind = index::SymbolKind::InstanceProperty;
HI.LocalScope = "MYProtocol::";
HI.NamespaceScope = "";
HI.Definition = "@property(nonatomic, assign, unsafe_unretained, "
"readwrite) int prop1;";
}},
{R"objc(
@interface Foo
@end
@implementation Foo(Private)
+ (int)somePrivateMethod {
int [[res^ult]] = 2;
return result;
}
@end
)objc",
[](HoverInfo &HI) {
HI.Name = "result";
HI.Definition = "int result = 2";
HI.Kind = index::SymbolKind::Variable;
HI.Type = "int";
HI.LocalScope = "+[Foo(Private) somePrivateMethod]::";
HI.NamespaceScope = "";
HI.Value = "2";
}},
{R"objc(
@interface Foo
@end
@implementation Foo
- (int)variadicArgMethod:(id)first, ... {
int [[res^ult]] = 0;
return result;
}
@end
)objc",
[](HoverInfo &HI) {
HI.Name = "result";
HI.Definition = "int result = 0";
HI.Kind = index::SymbolKind::Variable;
HI.Type = "int";
HI.LocalScope = "-[Foo variadicArgMethod:, ...]::";
HI.NamespaceScope = "";
HI.Value = "0";
}},
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
};
// Create a tiny index, so tests above can verify documentation is fetched.
Symbol IndexSym = func("indexSymbol");
IndexSym.Documentation = "comment from index";
SymbolSlab::Builder Symbols;
Symbols.insert(IndexSym);
auto Index =
MemIndex::build(std::move(Symbols).build(), RefSlab(), RelationSlab());
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
for (const auto &Case : Cases) {
SCOPED_TRACE(Case.Code);
Annotations T(Case.Code);
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
TestTU TU = TestTU::withCode(T.code());
TU.ExtraArgs.push_back("-std=c++17");
[AST] Fix an assertion violation in FieldDecl::getParent. Summary: FieldDecl::getParent assumes that the FiledDecl::getDeclContext returns a RecordDecl, this is true for C/C++, but not for ObjCIvarDecl: The Decls hierarchy is like following FieldDecl <-- ObjCIvarDecl DeclContext <-- ObjCContainerDecl <-- ObjCInterfaceDecl ^ |----- TagDecl <-- RecordDecl calling getParent() on ObjCIvarDecl will: 1. invoke getDeclContext(), which returns a DeclContext*, which points to an ObjCInterfaceDecl; 2. then downcast the "DeclContext" pointer to a RecordDecl*, and we will hit the "is_a<RecordDecl>" assertion in llvm::cast (undefined behavior in release build without assertion enabled); Fixes https://github.com/clangd/clangd/issues/369 Reviewers: sammccall Reviewed By: sammccall Subscribers: rsmith, jkorous, arphaman, kadircet, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D79627
2020-05-19 21:26:42 +08:00
TU.ExtraArgs.push_back("-xobjective-c++");
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
TU.ExtraArgs.push_back("-Wno-gnu-designator");
[clangd][Hover] Make tests hermetic by setting target triplet Summary: Fixes https://bugs.llvm.org/show_bug.cgi?id=44696 Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D73613
2020-01-29 18:17:45 +08:00
// Types might be different depending on the target triplet, we chose a
// fixed one to make sure tests passes on different platform.
TU.ExtraArgs.push_back("--target=x86_64-pc-linux-gnu");
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
auto AST = TU.build();
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
auto H = getHover(AST, T.point(), format::getLLVMStyle(), Index.get());
ASSERT_TRUE(H);
HoverInfo Expected;
Expected.SymRange = T.range();
Case.ExpectedBuilder(Expected);
[clangd] Print underlying type for decltypes in hover Summary: Fixes https://github.com/clangd/clangd/issues/249 Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D72498
2020-01-16 22:20:13 +08:00
SCOPED_TRACE(H->present().asPlainText());
[clangd] Switch Hover.All to structured tests Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70911
2019-12-03 02:34:03 +08:00
EXPECT_EQ(H->NamespaceScope, Expected.NamespaceScope);
EXPECT_EQ(H->LocalScope, Expected.LocalScope);
EXPECT_EQ(H->Name, Expected.Name);
EXPECT_EQ(H->Kind, Expected.Kind);
EXPECT_EQ(H->Documentation, Expected.Documentation);
EXPECT_EQ(H->Definition, Expected.Definition);
EXPECT_EQ(H->Type, Expected.Type);
EXPECT_EQ(H->ReturnType, Expected.ReturnType);
EXPECT_EQ(H->Parameters, Expected.Parameters);
EXPECT_EQ(H->TemplateParameters, Expected.TemplateParameters);
EXPECT_EQ(H->SymRange, Expected.SymRange);
EXPECT_EQ(H->Value, Expected.Value);
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
}
}
[clangd] Improve documentation for auto and implicit specs Summary: Clangd didn't fill documentation for `auto` when it wasn't available in index. Also it wasn't showing any documentations for implicit instantiations. This patch ensures auto and normal decl case behaves in the same way and also makes use of the explicit template specialization while fetching comments for implicit instantiations. Reviewers: ilya-biryukov Subscribers: MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D71596
2019-12-17 19:13:28 +08:00
TEST(Hover, DocsFromIndex) {
Annotations T(R"cpp(
template <typename T> class X {};
void foo() {
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
auto t = X<int>();
[clangd] Improve documentation for auto and implicit specs Summary: Clangd didn't fill documentation for `auto` when it wasn't available in index. Also it wasn't showing any documentations for implicit instantiations. This patch ensures auto and normal decl case behaves in the same way and also makes use of the explicit template specialization while fetching comments for implicit instantiations. Reviewers: ilya-biryukov Subscribers: MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D71596
2019-12-17 19:13:28 +08:00
X^<int> w;
(void)w;
})cpp");
TestTU TU = TestTU::withCode(T.code());
auto AST = TU.build();
Symbol IndexSym;
[clangd] Value initialize SymbolIDs We were default initializing SymbolIDs before, which would leave indeterminate values in underlying std::array. This patch updates the underlying data initalization to be value-init and adds a way to check for validness of a SymbolID. Differential Revision: https://reviews.llvm.org/D90397
2020-10-29 23:04:53 +08:00
IndexSym.ID = getSymbolID(&findDecl(AST, "X"));
[clangd] Improve documentation for auto and implicit specs Summary: Clangd didn't fill documentation for `auto` when it wasn't available in index. Also it wasn't showing any documentations for implicit instantiations. This patch ensures auto and normal decl case behaves in the same way and also makes use of the explicit template specialization while fetching comments for implicit instantiations. Reviewers: ilya-biryukov Subscribers: MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D71596
2019-12-17 19:13:28 +08:00
IndexSym.Documentation = "comment from index";
SymbolSlab::Builder Symbols;
Symbols.insert(IndexSym);
auto Index =
MemIndex::build(std::move(Symbols).build(), RefSlab(), RelationSlab());
for (const auto &P : T.points()) {
auto H = getHover(AST, P, format::getLLVMStyle(), Index.get());
ASSERT_TRUE(H);
EXPECT_EQ(H->Documentation, IndexSym.Documentation);
}
}
TEST(Hover, DocsFromAST) {
Annotations T(R"cpp(
// doc
template <typename T> class X {};
// doc
template <typename T> void bar() {}
// doc
template <typename T> T baz;
void foo() {
au^to t = X<int>();
X^<int>();
b^ar<int>();
au^to T = ba^z<X<int>>;
ba^z<int> = 0;
})cpp");
TestTU TU = TestTU::withCode(T.code());
auto AST = TU.build();
for (const auto &P : T.points()) {
auto H = getHover(AST, P, format::getLLVMStyle(), nullptr);
ASSERT_TRUE(H);
EXPECT_EQ(H->Documentation, "doc");
}
}
TEST(Hover, DocsFromMostSpecial) {
Annotations T(R"cpp(
// doc1
template <typename T> class $doc1^X {};
// doc2
template <> class $doc2^X<int> {};
// doc3
template <typename T> class $doc3^X<T*> {};
void foo() {
X$doc1^<char>();
X$doc2^<int>();
X$doc3^<int*>();
})cpp");
TestTU TU = TestTU::withCode(T.code());
auto AST = TU.build();
for (auto Comment : {"doc1", "doc2", "doc3"}) {
for (const auto &P : T.points(Comment)) {
auto H = getHover(AST, P, format::getLLVMStyle(), nullptr);
ASSERT_TRUE(H);
EXPECT_EQ(H->Documentation, Comment);
}
}
}
[clangd] Render header of hover card as a heading Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D72625
2020-01-14 00:50:23 +08:00
[clangd] Refurbish HoverInfo::present Summary: Improves basic hover presentation logic to include more info. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D71555
2019-12-13 16:34:59 +08:00
TEST(Hover, Present) {
struct {
const std::function<void(HoverInfo &)> Builder;
llvm::StringRef ExpectedRender;
} Cases[] = {
{
[](HoverInfo &HI) {
HI.Kind = index::SymbolKind::Unknown;
HI.Name = "X";
},
[clangd] Dont display `<unknown>` kinds in hover board Summary: Currently when hovering over an `auto` or `decltype` that resolve to a builtin-type, clangd would display `<unknown>` as the kind of the symbol. Drop that to make rendering nicer. Reviewers: usaxena95 Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D72777
2020-01-16 01:09:51 +08:00
R"(X)",
[clangd] Refurbish HoverInfo::present Summary: Improves basic hover presentation logic to include more info. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D71555
2019-12-13 16:34:59 +08:00
},
{
[](HoverInfo &HI) {
HI.Kind = index::SymbolKind::NamespaceAlias;
HI.Name = "foo";
},
R"(namespace-alias foo)",
},
{
[](HoverInfo &HI) {
HI.Kind = index::SymbolKind::Class;
[clangd] show layout info when hovering on a class/field definition. Summary: This triggers only on the definition itself, not on references (probably too noisy). Inspecting the definition seems like a decent hint for being interested in layout. Reviewers: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D77355
2020-04-03 09:07:10 +08:00
HI.Size = 10;
[clangd] Refurbish HoverInfo::present Summary: Improves basic hover presentation logic to include more info. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D71555
2019-12-13 16:34:59 +08:00
HI.TemplateParameters = {
{std::string("typename"), std::string("T"), llvm::None},
{std::string("typename"), std::string("C"),
std::string("bool")},
};
HI.Documentation = "documentation";
HI.Definition =
"template <typename T, typename C = bool> class Foo {}";
HI.Name = "foo";
HI.NamespaceScope.emplace();
},
R"(class foo
[clangd] Add a ruler after header in hover Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D72622
2020-01-14 00:14:24 +08:00
[clangd] show layout info when hovering on a class/field definition. Summary: This triggers only on the definition itself, not on references (probably too noisy). Inspecting the definition seems like a decent hint for being interested in layout. Reviewers: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D77355
2020-04-03 09:07:10 +08:00
Size: 10 bytes
[clangd] Refurbish HoverInfo::present Summary: Improves basic hover presentation logic to include more info. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D71555
2019-12-13 16:34:59 +08:00
documentation
template <typename T, typename C = bool> class Foo {})",
},
{
[](HoverInfo &HI) {
HI.Kind = index::SymbolKind::Function;
HI.Name = "foo";
HI.Type = "type";
HI.ReturnType = "ret_type";
HI.Parameters.emplace();
HoverInfo::Param P;
HI.Parameters->push_back(P);
P.Type = "type";
HI.Parameters->push_back(P);
P.Name = "foo";
HI.Parameters->push_back(P);
P.Default = "default";
HI.Parameters->push_back(P);
HI.NamespaceScope = "ns::";
HI.Definition = "ret_type foo(params) {}";
},
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
"function foo\n"
"\n"
"→ ret_type\n"
"Parameters:\n"
"- \n"
"- type\n"
"- type foo\n"
"- type foo = default\n"
"\n"
"// In namespace ns\n"
"ret_type foo(params) {}",
[clangd] Refurbish HoverInfo::present Summary: Improves basic hover presentation logic to include more info. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D71555
2019-12-13 16:34:59 +08:00
},
{
[](HoverInfo &HI) {
[clangd] show layout info when hovering on a class/field definition. Summary: This triggers only on the definition itself, not on references (probably too noisy). Inspecting the definition seems like a decent hint for being interested in layout. Reviewers: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D77355
2020-04-03 09:07:10 +08:00
HI.Kind = index::SymbolKind::Field;
HI.LocalScope = "test::Bar::";
[clangd] Refurbish HoverInfo::present Summary: Improves basic hover presentation logic to include more info. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D71555
2019-12-13 16:34:59 +08:00
HI.Value = "value";
HI.Name = "foo";
HI.Type = "type";
HI.Definition = "def";
[clangd] show layout info when hovering on a class/field definition. Summary: This triggers only on the definition itself, not on references (probably too noisy). Inspecting the definition seems like a decent hint for being interested in layout. Reviewers: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D77355
2020-04-03 09:07:10 +08:00
HI.Size = 4;
HI.Offset = 12;
[clangd] Refurbish HoverInfo::present Summary: Improves basic hover presentation logic to include more info. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D71555
2019-12-13 16:34:59 +08:00
},
[clangd] show layout info when hovering on a class/field definition. Summary: This triggers only on the definition itself, not on references (probably too noisy). Inspecting the definition seems like a decent hint for being interested in layout. Reviewers: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D77355
2020-04-03 09:07:10 +08:00
R"(field foo
[clangd] Add a ruler after header in hover Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D72622
2020-01-14 00:14:24 +08:00
[clangd] Rearrange type, returntype and parameters in hover card Summary: Moves type/returntype into its own line as it is more readable in cases where the type is long. Also gives parameter lists a heading, `Parameters:` to make them stand out. Leaves the `right arrow` instead of `Returns: ` before Return Type to make output more symmetric. ``` function foo Returns: ret_type Parameters: - int x ``` vs ``` function foo 🡺 ret_type Parameters: - int x ``` Reviewers: sammccall, ilya-biryukov Subscribers: MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D72623
2020-01-14 00:21:31 +08:00
Type: type
[clangd] Refurbish HoverInfo::present Summary: Improves basic hover presentation logic to include more info. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D71555
2019-12-13 16:34:59 +08:00
Value = value
[clangd] show layout info when hovering on a class/field definition. Summary: This triggers only on the definition itself, not on references (probably too noisy). Inspecting the definition seems like a decent hint for being interested in layout. Reviewers: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D77355
2020-04-03 09:07:10 +08:00
Offset: 12 bytes
Size: 4 bytes
[clangd] Refurbish HoverInfo::present Summary: Improves basic hover presentation logic to include more info. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D71555
2019-12-13 16:34:59 +08:00
[clangd] show layout info when hovering on a class/field definition. Summary: This triggers only on the definition itself, not on references (probably too noisy). Inspecting the definition seems like a decent hint for being interested in layout. Reviewers: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D77355
2020-04-03 09:07:10 +08:00
// In test::Bar
[clangd] Refurbish HoverInfo::present Summary: Improves basic hover presentation logic to include more info. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D71555
2019-12-13 16:34:59 +08:00
def)",
},
[clangd] Add access specifier information to hover contents Summary: For https://github.com/clangd/clangd/issues/382 This commit adds access specifier information to the hover contents. For example, the hover information of a class field or member function will now indicate if the field or member is private, public, or protected. This can be particularly useful when a developer is in the implementation file and wants to know if a particular member definition is public or private. Reviewers: kadircet Reviewed By: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, kadircet, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D80472
2020-05-28 00:17:07 +08:00
{
[](HoverInfo &HI) {
HI.Kind = index::SymbolKind::Field;
HI.AccessSpecifier = "public";
HI.Name = "foo";
HI.LocalScope = "test::Bar::";
HI.Definition = "def";
},
R"(field foo
// In test::Bar
public: def)",
},
{
[](HoverInfo &HI) {
HI.Definition = "int method()";
HI.AccessSpecifier = "protected";
HI.Kind = index::SymbolKind::InstanceMethod;
HI.NamespaceScope = "";
HI.LocalScope = "cls<int>::";
HI.Name = "method";
HI.Parameters.emplace();
HI.ReturnType = "int";
HI.Type = "int ()";
},
R"(instance-method method
→ int
// In cls<int>
protected: int method())",
},
{
[](HoverInfo &HI) {
HI.Kind = index::SymbolKind::Union;
HI.AccessSpecifier = "private";
HI.Name = "foo";
HI.NamespaceScope = "ns1::";
HI.Definition = "union foo {}";
},
R"(union foo
// In namespace ns1
private: union foo {})",
[clangd] Improve hover on arguments to function call Summary: In cases like: foo(a, ^b); We now additionally show the name and type of the parameter to foo that corresponds that "b" is passed as. The name should help with understanding what it's used for and type can be useful to find out if call to foo() can mutate variable "b" or not (i.e. if it is pass by value, reference, const reference, etc). Patch By: adamcz@ ! Reviewers: kadircet Reviewed By: kadircet Subscribers: nridge, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D81169
2020-07-03 17:20:22 +08:00
},
{
[](HoverInfo &HI) {
HI.Kind = index::SymbolKind::Variable;
HI.Name = "foo";
HI.Definition = "int foo = 3";
HI.LocalScope = "test::Bar::";
HI.Value = "3";
HI.Type = "int";
HI.CalleeArgInfo.emplace();
HI.CalleeArgInfo->Name = "arg_a";
HI.CalleeArgInfo->Type = "int";
HI.CalleeArgInfo->Default = "7";
HI.CallPassType.emplace();
HI.CallPassType->PassBy = PassMode::Value;
HI.CallPassType->Converted = false;
},
R"(variable foo
Type: int
Value = 3
Passed as arg_a
// In test::Bar
int foo = 3)",
},
{
[](HoverInfo &HI) {
HI.Kind = index::SymbolKind::Variable;
HI.Name = "foo";
HI.Definition = "int foo = 3";
HI.LocalScope = "test::Bar::";
HI.Value = "3";
HI.Type = "int";
HI.CalleeArgInfo.emplace();
HI.CalleeArgInfo->Name = "arg_a";
HI.CalleeArgInfo->Type = "int";
HI.CalleeArgInfo->Default = "7";
HI.CallPassType.emplace();
HI.CallPassType->PassBy = PassMode::Ref;
HI.CallPassType->Converted = false;
},
R"(variable foo
Type: int
Value = 3
Passed by reference as arg_a
// In test::Bar
int foo = 3)",
},
{
[](HoverInfo &HI) {
HI.Kind = index::SymbolKind::Variable;
HI.Name = "foo";
HI.Definition = "int foo = 3";
HI.LocalScope = "test::Bar::";
HI.Value = "3";
HI.Type = "int";
HI.CalleeArgInfo.emplace();
HI.CalleeArgInfo->Name = "arg_a";
HI.CalleeArgInfo->Type = "int";
HI.CalleeArgInfo->Default = "7";
HI.CallPassType.emplace();
HI.CallPassType->PassBy = PassMode::Value;
HI.CallPassType->Converted = true;
},
R"(variable foo
Type: int
Value = 3
Passed as arg_a (converted to int)
// In test::Bar
int foo = 3)",
},
{
[](HoverInfo &HI) {
HI.Kind = index::SymbolKind::Variable;
HI.Name = "foo";
HI.Definition = "int foo = 3";
HI.LocalScope = "test::Bar::";
HI.Value = "3";
HI.Type = "int";
HI.CalleeArgInfo.emplace();
HI.CalleeArgInfo->Name = "arg_a";
HI.CalleeArgInfo->Type = "int";
HI.CalleeArgInfo->Default = "7";
HI.CallPassType.emplace();
HI.CallPassType->PassBy = PassMode::ConstRef;
HI.CallPassType->Converted = true;
},
R"(variable foo
Type: int
Value = 3
Passed by const reference as arg_a (converted to int)
// In test::Bar
int foo = 3)",
[clangd] Add access specifier information to hover contents Summary: For https://github.com/clangd/clangd/issues/382 This commit adds access specifier information to the hover contents. For example, the hover information of a class field or member function will now indicate if the field or member is private, public, or protected. This can be particularly useful when a developer is in the implementation file and wants to know if a particular member definition is public or private. Reviewers: kadircet Reviewed By: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, kadircet, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D80472
2020-05-28 00:17:07 +08:00
}};
[clangd] Refurbish HoverInfo::present Summary: Improves basic hover presentation logic to include more info. Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D71555
2019-12-13 16:34:59 +08:00
for (const auto &C : Cases) {
HoverInfo HI;
C.Builder(HI);
EXPECT_EQ(HI.present().asPlainText(), C.ExpectedRender);
}
}
[clangd] Parse `foo` in documentation comments and render as code. Reviewers: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D77456
2020-04-04 15:12:30 +08:00
TEST(Hover, ParseDocumentation) {
[clangd] Change line break behaviour for hoverinfo `parseDocumentation` retains hard line breaks and removes soft line breaks inside documentation comments. Wether a line break is hard or soft is determined by the following rules (some of which have been discussed in https://github.com/clangd/clangd/issues/95): Line breaks that are preceded by a punctuation are retained Line breaks that are followed by "interesting characters" (e.g. Markdown syntax, doxygen commands) are retained All other line breaks are removed Related issue: https://github.com/clangd/clangd/issues/95 Differential Revision: https://reviews.llvm.org/D76094
2020-03-24 19:30:51 +08:00
struct Case {
llvm::StringRef Documentation;
llvm::StringRef ExpectedRenderMarkdown;
llvm::StringRef ExpectedRenderPlainText;
} Cases[] = {{
" \n foo\nbar",
"foo bar",
"foo bar",
},
{
"foo\nbar \n ",
"foo bar",
"foo bar",
},
{
"foo \nbar",
"foo bar",
"foo bar",
},
{
"foo \nbar",
"foo bar",
"foo bar",
},
{
"foo\n\n\nbar",
"foo \nbar",
"foo\nbar",
},
{
"foo\n\n\n\tbar",
"foo \nbar",
"foo\nbar",
},
{
"foo\n\n\n bar",
"foo \nbar",
"foo\nbar",
},
{
"foo.\nbar",
"foo. \nbar",
"foo.\nbar",
},
[clangd] Tweak parseDocumentation loop to use raw lines. NFC This clears the way for the raw lines themselves to be parsed easily. (Okay, one functional change: fix punctuation linebreaks with trailing WS)
2020-04-04 14:06:24 +08:00
{
"foo. \nbar",
"foo. \nbar",
"foo.\nbar",
},
[clangd] Change line break behaviour for hoverinfo `parseDocumentation` retains hard line breaks and removes soft line breaks inside documentation comments. Wether a line break is hard or soft is determined by the following rules (some of which have been discussed in https://github.com/clangd/clangd/issues/95): Line breaks that are preceded by a punctuation are retained Line breaks that are followed by "interesting characters" (e.g. Markdown syntax, doxygen commands) are retained All other line breaks are removed Related issue: https://github.com/clangd/clangd/issues/95 Differential Revision: https://reviews.llvm.org/D76094
2020-03-24 19:30:51 +08:00
{
"foo\n*bar",
"foo \n\\*bar",
"foo\n*bar",
},
{
"foo\nbar",
"foo bar",
"foo bar",
[clangd] Parse `foo` in documentation comments and render as code. Reviewers: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D77456
2020-04-04 15:12:30 +08:00
},
{
"Tests primality of `p`.",
[clangd] Fix whitespace between chunks in markdown paragraphs. Summary: Old model: chunks are always separated by one space. This makes it impossible to render "Foo `bar`." correctly. New model: chunks are separated by space if the left had trailing space, or the right had leading space, or space was explicitly requested. (Only leading/trailing space in plaintext chunks count, not code) Reviewers: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D79139
2020-04-30 07:03:59 +08:00
"Tests primality of `p`.",
"Tests primality of `p`.",
[clangd] Parse `foo` in documentation comments and render as code. Reviewers: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D77456
2020-04-04 15:12:30 +08:00
},
{
"'`' should not occur in `Code`",
"'\\`' should not occur in `Code`",
[clangd] Render doc-comment code spans with `backticks` in plaintext mode Reviewers: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D79142
2020-04-30 07:25:18 +08:00
"'`' should not occur in `Code`",
[clangd] Parse `foo` in documentation comments and render as code. Reviewers: kadircet Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D77456
2020-04-04 15:12:30 +08:00
},
{
"`not\nparsed`",
"\\`not parsed\\`",
"`not parsed`",
[clangd] Change line break behaviour for hoverinfo `parseDocumentation` retains hard line breaks and removes soft line breaks inside documentation comments. Wether a line break is hard or soft is determined by the following rules (some of which have been discussed in https://github.com/clangd/clangd/issues/95): Line breaks that are preceded by a punctuation are retained Line breaks that are followed by "interesting characters" (e.g. Markdown syntax, doxygen commands) are retained All other line breaks are removed Related issue: https://github.com/clangd/clangd/issues/95 Differential Revision: https://reviews.llvm.org/D76094
2020-03-24 19:30:51 +08:00
}};
for (const auto &C : Cases) {
markup::Document Output;
parseDocumentation(C.Documentation, Output);
EXPECT_EQ(Output.asMarkdown(), C.ExpectedRenderMarkdown);
EXPECT_EQ(Output.asPlainText(), C.ExpectedRenderPlainText);
}
}
[clangd] Render header of hover card as a heading Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D72625
2020-01-14 00:50:23 +08:00
// This is a separate test as headings don't create any differences in plaintext
// mode.
TEST(Hover, PresentHeadings) {
HoverInfo HI;
HI.Kind = index::SymbolKind::Variable;
HI.Name = "foo";
[clangd] Rearrange type, returntype and parameters in hover card Summary: Moves type/returntype into its own line as it is more readable in cases where the type is long. Also gives parameter lists a heading, `Parameters:` to make them stand out. Leaves the `right arrow` instead of `Returns: ` before Return Type to make output more symmetric. ``` function foo Returns: ret_type Parameters: - int x ``` vs ``` function foo 🡺 ret_type Parameters: - int x ``` Reviewers: sammccall, ilya-biryukov Subscribers: MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D72623
2020-01-14 00:21:31 +08:00
EXPECT_EQ(HI.present().asMarkdown(), "### variable `foo`");
[clangd] Render header of hover card as a heading Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D72625
2020-01-14 00:50:23 +08:00
}
[clangd] Add a ruler after header in hover Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D72622
2020-01-14 00:14:24 +08:00
// This is a separate test as rulers behave differently in markdown vs
// plaintext.
TEST(Hover, PresentRulers) {
HoverInfo HI;
HI.Kind = index::SymbolKind::Variable;
HI.Name = "foo";
HI.Value = "val";
HI.Definition = "def";
[clangd] Smarter hover on auto and decltype Only show the keyword as the hover "Name". Show whether the type is deduced or undeduced as the hover "Documentation". Show the deduced type (if any) as the "Definition". Don't show any hover information for: - the "auto" word of "decltype(auto)" - "auto" in lambda parameters - "auto" in template arguments --------------- This diff is a suggestion based on what @sammccall suggested in https://reviews.llvm.org/D92977 about hover on "auto". It somehow "hacks" onto the "Documentation" and "Definition" fields of `HoverInfo`. It sure looks good on VSCode, let me know if this seem acceptable to you. Reviewed By: sammccall Differential Revision: https://reviews.llvm.org/D93227
2020-12-18 23:10:29 +08:00
llvm::StringRef ExpectedMarkdown = //
"### variable `foo` \n"
"\n"
"---\n"
"Value = `val` \n"
"\n"
"---\n"
"```cpp\n"
"def\n"
"```";
[clangd] Extract string literals in macro arguments to unbreak gcc buildbots
2020-01-16 00:59:02 +08:00
EXPECT_EQ(HI.present().asMarkdown(), ExpectedMarkdown);
llvm::StringRef ExpectedPlaintext = R"pt(variable foo
[clangd] Add a ruler after header in hover Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D72622
2020-01-14 00:14:24 +08:00
Value = val
[clangd] Extract string literals in macro arguments to unbreak gcc buildbots
2020-01-16 00:59:02 +08:00
def)pt";
EXPECT_EQ(HI.present().asPlainText(), ExpectedPlaintext);
[clangd] Add a ruler after header in hover Reviewers: sammccall Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D72622
2020-01-14 00:14:24 +08:00
}
[clangd] Untangle Hover from XRefs, move into own file. Summary: This is mostly mechanical, with a few exceptions: - getDeducedType moved into AST.h where it belongs. It now takes ASTContext instead of ParsedAST, and avoids using the preprocessor. - hover now uses SelectionTree directly rather than via getDeclAtPosition helper - hover on 'auto' used to find the decl that contained the 'auto' and use that to set Kind and documentation for the hover result. Now we use targetDecl() to find the decl matching the deduced type instead. This changes tests, e.g. 'variable' -> class for auto on lambdas. I think this is better, but the motivation was to avoid depending on the internals of DeducedTypeVisitor. This functionality is removed from the visitor. Reviewers: kadircet Subscribers: mgorny, ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D70357
2019-11-17 00:00:19 +08:00
} // namespace
} // namespace clangd
} // namespace clang