1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
//===--- FeatureModulesTests.cpp -------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "Annotations.h"
#include "FeatureModule.h"
#include "Selection.h"
#include "TestTU.h"
#include "refactor/Tweak.h"
#include "support/Logger.h"
#include "clang/Lex/PreprocessorOptions.h"
#include "llvm/Support/Error.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include <memory>
namespace clang {
namespace clangd {
namespace {
TEST(FeatureModulesTest, ContributesTweak) {
static constexpr const char *TweakID = "ModuleTweak";
struct TweakContributingModule final : public FeatureModule {
struct ModuleTweak final : public Tweak {
const char *id() const override { return TweakID; }
bool prepare(const Selection &Sel) override { return true; }
Expected<Effect> apply(const Selection &Sel) override {
return error("not implemented");
}
std::string title() const override { return id(); }
llvm::StringLiteral kind() const override {
return llvm::StringLiteral("");
};
};
void contributeTweaks(std::vector<std::unique_ptr<Tweak>> &Out) override {
Out.emplace_back(new ModuleTweak);
}
};
FeatureModuleSet Set;
Set.add(std::make_unique<TweakContributingModule>());
auto AST = TestTU::withCode("").build();
auto Tree =
SelectionTree::createRight(AST.getASTContext(), AST.getTokens(), 0, 0);
auto Actual = prepareTweak(
TweakID, Tweak::Selection(nullptr, AST, 0, 0, std::move(Tree), nullptr),
&Set);
ASSERT_TRUE(bool(Actual));
EXPECT_EQ(Actual->get()->id(), TweakID);
}
TEST(FeatureModulesTest, SuppressDiags) {
struct DiagModifierModule final : public FeatureModule {
struct Listener : public FeatureModule::ASTListener {
void sawDiagnostic(const clang::Diagnostic &Info,
clangd::Diag &Diag) override {
Diag.Severity = DiagnosticsEngine::Ignored;
}
};
std::unique_ptr<ASTListener> astListeners() override {
return std::make_unique<Listener>();
};
};
FeatureModuleSet FMS;
FMS.add(std::make_unique<DiagModifierModule>());
Annotations Code("[[test]]; /* error-ok */");
TestTU TU;
TU.Code = Code.code().str();
{
auto AST = TU.build();
EXPECT_THAT(AST.getDiagnostics(), testing::Not(testing::IsEmpty()));
}
TU.FeatureModules = &FMS;
{
auto AST = TU.build();
EXPECT_THAT(AST.getDiagnostics(), testing::IsEmpty());
}
}
TEST(FeatureModulesTest, BeforeExecute) {
struct BeforeExecuteModule final : public FeatureModule {
struct Listener : public FeatureModule::ASTListener {
void beforeExecute(CompilerInstance &CI) override {
CI.getPreprocessor().SetSuppressIncludeNotFoundError(true);
}
};
std::unique_ptr<ASTListener> astListeners() override {
return std::make_unique<Listener>();
};
};
FeatureModuleSet FMS;
FMS.add(std::make_unique<BeforeExecuteModule>());
TestTU TU = TestTU::withCode(R"cpp(
/*error-ok*/
#include "not_found.h"
void foo() {
#include "not_found_not_preamble.h"
}
)cpp");
{
auto AST = TU.build();
EXPECT_THAT(AST.getDiagnostics(), testing::Not(testing::IsEmpty()));
}
TU.FeatureModules = &FMS;
{
auto AST = TU.build();
EXPECT_THAT(AST.getDiagnostics(), testing::IsEmpty());
}
}
} // namespace
} // namespace clangd
} // namespace clang
|
