Debian Codegraph @

llvm-project/clang/unittests/Lex/ModuleDeclStateTest.cpp

raw
1 //===- unittests/Lex/ModuleDeclStateTest.cpp - PPCallbacks tests ------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===--------------------------------------------------------------===//
8
9 #include "clang/Basic/Diagnostic.h"
10 #include "clang/Basic/DiagnosticOptions.h"
11 #include "clang/Basic/FileManager.h"
12 #include "clang/Basic/LangOptions.h"
13 #include "clang/Basic/SourceManager.h"
14 #include "clang/Basic/TargetInfo.h"
15 #include "clang/Basic/TargetOptions.h"
16 #include "clang/Frontend/CompilerInvocation.h"
17 #include "clang/Lex/HeaderSearch.h"
18 #include "clang/Lex/HeaderSearchOptions.h"
19 #include "clang/Lex/ModuleLoader.h"
20 #include "clang/Lex/Preprocessor.h"
21 #include "clang/Lex/PreprocessorOptions.h"
22 #include "gtest/gtest.h"
23 #include <cstddef>
24 #include <initializer_list>
25
26 using namespace clang;
27
28 namespace {
29
30 class CheckNamedModuleImportingCB : public PPCallbacks {
31 Preprocessor &PP;
32 std::vector<bool> IsImportingNamedModulesAssertions;
33 std::size_t NextCheckingIndex;
34
35 public:
36 CheckNamedModuleImportingCB(Preprocessor &PP,
37 std::initializer_list<bool> lists)
38 : PP(PP), IsImportingNamedModulesAssertions(lists), NextCheckingIndex(0) {
39 }
40
41 void moduleImport(SourceLocation ImportLoc, ModuleIdPath Path,
42 const Module *Imported) override {
43 ASSERT_TRUE(NextCheckingIndex < IsImportingNamedModulesAssertions.size());
44 EXPECT_EQ(PP.isInImportingCXXNamedModules(),
45 IsImportingNamedModulesAssertions[NextCheckingIndex]);
46 NextCheckingIndex++;
47
48 ASSERT_EQ(Imported, nullptr);
49 }
50
51 // Currently, only the named module will be handled by `moduleImport`
52 // callback.
53 std::size_t importNamedModuleNum() { return NextCheckingIndex; }
54 };
55 class ModuleDeclStateTest : public ::testing::Test {
56 protected:
57 ModuleDeclStateTest()
58 : FileMgr(FileMgrOpts), DiagID(new DiagnosticIDs()),
59 Diags(DiagID, new DiagnosticOptions, new IgnoringDiagConsumer()),
60 SourceMgr(Diags, FileMgr), TargetOpts(new TargetOptions), Invocation() {
61 TargetOpts->Triple = "x86_64-unknown-linux-gnu";
62 Target = TargetInfo::CreateTargetInfo(Diags, TargetOpts);
63 }
64
65 LangOptions &getLangOpts(ArrayRef<const char *> CommandLineArgs) {
66 CompilerInvocation::CreateFromArgs(Invocation, CommandLineArgs, Diags);
67 return *Invocation.getLangOpts();
68 }
69
70 std::unique_ptr<Preprocessor>
71 getPreprocessor(const char *source, ArrayRef<const char *> CommandLineArgs) {
72 std::unique_ptr<llvm::MemoryBuffer> Buf =
73 llvm::MemoryBuffer::getMemBuffer(source);
74 SourceMgr.setMainFileID(SourceMgr.createFileID(std::move(Buf)));
75
76 LangOptions &LangOpts = getLangOpts(CommandLineArgs);
77 HeaderInfo.emplace(std::make_shared<HeaderSearchOptions>(), SourceMgr,
78 Diags, LangOpts, Target.get());
79
80 return std::make_unique<Preprocessor>(
81 std::make_shared<PreprocessorOptions>(), Diags, LangOpts, SourceMgr,
82 *HeaderInfo, ModLoader,
83 /*IILookup =*/nullptr,
84 /*OwnsHeaderSearch =*/false);
85 }
86
87 void preprocess(Preprocessor &PP, std::unique_ptr<PPCallbacks> C) {
88 PP.Initialize(*Target);
89 PP.addPPCallbacks(std::move(C));
90 PP.EnterMainSourceFile();
91
92 while (1) {
93 Token tok;
94 PP.Lex(tok);
95 if (tok.is(tok::eof))
96 break;
97 }
98 }
99
100 FileSystemOptions FileMgrOpts;
101 FileManager FileMgr;
102 IntrusiveRefCntPtr<DiagnosticIDs> DiagID;
103 DiagnosticsEngine Diags;
104 SourceManager SourceMgr;
105 std::shared_ptr<TargetOptions> TargetOpts;
106 IntrusiveRefCntPtr<TargetInfo> Target;
107 CompilerInvocation Invocation;
108 TrivialModuleLoader ModLoader;
109 std::optional<HeaderSearch> HeaderInfo;
110 };
111
112 TEST_F(ModuleDeclStateTest, NamedModuleInterface) {
113 const char *source = R"(
114 export module foo;
115 )";
116 std::unique_ptr<Preprocessor> PP = getPreprocessor(source, "-std=c++20");
117
118 std::initializer_list<bool> ImportKinds = {};
119 preprocess(*PP,
120 std::make_unique<CheckNamedModuleImportingCB>(*PP, ImportKinds));
121
122 auto *Callback =
123 static_cast<CheckNamedModuleImportingCB *>(PP->getPPCallbacks());
124 EXPECT_EQ(Callback->importNamedModuleNum(), (size_t)0);
125 EXPECT_TRUE(PP->isInNamedModule());
126 EXPECT_TRUE(PP->isInNamedInterfaceUnit());
127 EXPECT_FALSE(PP->isInImplementationUnit());
128 EXPECT_EQ(PP->getNamedModuleName(), "foo");
129 }
130
131 TEST_F(ModuleDeclStateTest, NamedModuleImplementation) {
132 const char *source = R"(
133 module foo;
134 )";
135 std::unique_ptr<Preprocessor> PP = getPreprocessor(source, "-std=c++20");
136
137 std::initializer_list<bool> ImportKinds = {};
138 preprocess(*PP,
139 std::make_unique<CheckNamedModuleImportingCB>(*PP, ImportKinds));
140
141 auto *Callback =
142 static_cast<CheckNamedModuleImportingCB *>(PP->getPPCallbacks());
143 EXPECT_EQ(Callback->importNamedModuleNum(), (size_t)0);
144 EXPECT_TRUE(PP->isInNamedModule());
145 EXPECT_FALSE(PP->isInNamedInterfaceUnit());
146 EXPECT_TRUE(PP->isInImplementationUnit());
147 EXPECT_EQ(PP->getNamedModuleName(), "foo");
148 }
149
150 TEST_F(ModuleDeclStateTest, ModuleImplementationPartition) {
151 const char *source = R"(
152 module foo:part;
153 )";
154 std::unique_ptr<Preprocessor> PP = getPreprocessor(source, "-std=c++20");
155
156 std::initializer_list<bool> ImportKinds = {};
157 preprocess(*PP,
158 std::make_unique<CheckNamedModuleImportingCB>(*PP, ImportKinds));
159
160 auto *Callback =
161 static_cast<CheckNamedModuleImportingCB *>(PP->getPPCallbacks());
162 EXPECT_EQ(Callback->importNamedModuleNum(), (size_t)0);
163 EXPECT_TRUE(PP->isInNamedModule());
164 EXPECT_FALSE(PP->isInNamedInterfaceUnit());
165 EXPECT_FALSE(PP->isInImplementationUnit());
166 EXPECT_EQ(PP->getNamedModuleName(), "foo:part");
167 }
168
169 TEST_F(ModuleDeclStateTest, ModuleInterfacePartition) {
170 const char *source = R"(
171 export module foo:part;
172 )";
173 std::unique_ptr<Preprocessor> PP = getPreprocessor(source, "-std=c++20");
174
175 std::initializer_list<bool> ImportKinds = {};
176 preprocess(*PP,
177 std::make_unique<CheckNamedModuleImportingCB>(*PP, ImportKinds));
178
179 auto *Callback =
180 static_cast<CheckNamedModuleImportingCB *>(PP->getPPCallbacks());
181 EXPECT_EQ(Callback->importNamedModuleNum(), (size_t)0);
182 EXPECT_TRUE(PP->isInNamedModule());
183 EXPECT_TRUE(PP->isInNamedInterfaceUnit());
184 EXPECT_FALSE(PP->isInImplementationUnit());
185 EXPECT_EQ(PP->getNamedModuleName(), "foo:part");
186 }
187
188 TEST_F(ModuleDeclStateTest, ModuleNameWithDot) {
189 const char *source = R"(
190 export module foo.dot:part.dot;
191 )";
192 std::unique_ptr<Preprocessor> PP = getPreprocessor(source, "-std=c++20");
193
194 std::initializer_list<bool> ImportKinds = {};
195 preprocess(*PP,
196 std::make_unique<CheckNamedModuleImportingCB>(*PP, ImportKinds));
197
198 auto *Callback =
199 static_cast<CheckNamedModuleImportingCB *>(PP->getPPCallbacks());
200 EXPECT_EQ(Callback->importNamedModuleNum(), (size_t)0);
201 EXPECT_TRUE(PP->isInNamedModule());
202 EXPECT_TRUE(PP->isInNamedInterfaceUnit());
203 EXPECT_FALSE(PP->isInImplementationUnit());
204 EXPECT_EQ(PP->getNamedModuleName(), "foo.dot:part.dot");
205 }
206
207 TEST_F(ModuleDeclStateTest, NotModule) {
208 const char *source = R"(
209 // export module foo:part;
210 )";
211 std::unique_ptr<Preprocessor> PP = getPreprocessor(source, "-std=c++20");
212
213 std::initializer_list<bool> ImportKinds = {};
214 preprocess(*PP,
215 std::make_unique<CheckNamedModuleImportingCB>(*PP, ImportKinds));
216
217 auto *Callback =
218 static_cast<CheckNamedModuleImportingCB *>(PP->getPPCallbacks());
219 EXPECT_EQ(Callback->importNamedModuleNum(), (size_t)0);
220 EXPECT_FALSE(PP->isInNamedModule());
221 EXPECT_FALSE(PP->isInNamedInterfaceUnit());
222 EXPECT_FALSE(PP->isInImplementationUnit());
223 }
224
225 TEST_F(ModuleDeclStateTest, ModuleWithGMF) {
226 const char *source = R"(
227 module;
228 #include "bar.h"
229 #include <zoo.h>
230 import "bar";
231 import <zoo>;
232 export module foo:part;
233 import "HU";
234 import M;
235 import :another;
236 )";
237 std::unique_ptr<Preprocessor> PP = getPreprocessor(source, "-std=c++20");
238
239 std::initializer_list<bool> ImportKinds = {true, true};
240 preprocess(*PP,
241 std::make_unique<CheckNamedModuleImportingCB>(*PP, ImportKinds));
242
243 auto *Callback =
244 static_cast<CheckNamedModuleImportingCB *>(PP->getPPCallbacks());
245 EXPECT_EQ(Callback->importNamedModuleNum(), (size_t)2);
246 EXPECT_TRUE(PP->isInNamedModule());
247 EXPECT_TRUE(PP->isInNamedInterfaceUnit());
248 EXPECT_FALSE(PP->isInImplementationUnit());
249 EXPECT_EQ(PP->getNamedModuleName(), "foo:part");
250 }
251
252 TEST_F(ModuleDeclStateTest, ModuleWithGMFWithClangNamedModule) {
253 const char *source = R"(
254 module;
255 #include "bar.h"
256 #include <zoo.h>
257 import "bar";
258 import <zoo>;
259 export module foo:part;
260 import "HU";
261 import M;
262 import :another;
263 )";
264 std::unique_ptr<Preprocessor> PP = getPreprocessor(source, "-std=c++20");
265
266 std::initializer_list<bool> ImportKinds = {true, true};
267 preprocess(*PP,
268 std::make_unique<CheckNamedModuleImportingCB>(*PP, ImportKinds));
269
270 auto *Callback =
271 static_cast<CheckNamedModuleImportingCB *>(PP->getPPCallbacks());
272 EXPECT_EQ(Callback->importNamedModuleNum(), (size_t)2);
273 EXPECT_TRUE(PP->isInNamedModule());
274 EXPECT_TRUE(PP->isInNamedInterfaceUnit());
275 EXPECT_FALSE(PP->isInImplementationUnit());
276 EXPECT_EQ(PP->getNamedModuleName(), "foo:part");
277 }
278
279 TEST_F(ModuleDeclStateTest, ImportsInNormalTU) {
280 const char *source = R"(
281 #include "bar.h"
282 #include <zoo.h>
283 import "bar";
284 import <zoo>;
285 import "HU";
286 import M;
287 // We can't import a partition in non-module TU.
288 import :another;
289 )";
290 std::unique_ptr<Preprocessor> PP = getPreprocessor(source, "-std=c++20");
291
292 std::initializer_list<bool> ImportKinds = {true};
293 preprocess(*PP,
294 std::make_unique<CheckNamedModuleImportingCB>(*PP, ImportKinds));
295
296 auto *Callback =
297 static_cast<CheckNamedModuleImportingCB *>(PP->getPPCallbacks());
298 EXPECT_EQ(Callback->importNamedModuleNum(), (size_t)1);
299 EXPECT_FALSE(PP->isInNamedModule());
300 EXPECT_FALSE(PP->isInNamedInterfaceUnit());
301 EXPECT_FALSE(PP->isInImplementationUnit());
302 }
303
304 TEST_F(ModuleDeclStateTest, ImportAClangNamedModule) {
305 const char *source = R"(
306 @import anything;
307 )";
308 std::unique_ptr<Preprocessor> PP =
309 getPreprocessor(source, {"-fmodules", "-fimplicit-module-maps", "-x",
310 "objective-c++", "-std=c++20"});
311
312 std::initializer_list<bool> ImportKinds = {false};
313 preprocess(*PP,
314 std::make_unique<CheckNamedModuleImportingCB>(*PP, ImportKinds));
315
316 auto *Callback =
317 static_cast<CheckNamedModuleImportingCB *>(PP->getPPCallbacks());
318 EXPECT_EQ(Callback->importNamedModuleNum(), (size_t)1);
319 EXPECT_FALSE(PP->isInNamedModule());
320 EXPECT_FALSE(PP->isInNamedInterfaceUnit());
321 EXPECT_FALSE(PP->isInImplementationUnit());
322 }
323
324 TEST_F(ModuleDeclStateTest, ImportWixedForm) {
325 const char *source = R"(
326 import "HU";
327 @import anything;
328 import M;
329 @import another;
330 import M2;
331 )";
332 std::unique_ptr<Preprocessor> PP =
333 getPreprocessor(source, {"-fmodules", "-fimplicit-module-maps", "-x",
334 "objective-c++", "-std=c++20"});
335
336 std::initializer_list<bool> ImportKinds = {false, true, false, true};
337 preprocess(*PP,
338 std::make_unique<CheckNamedModuleImportingCB>(*PP, ImportKinds));
339
340 auto *Callback =
341 static_cast<CheckNamedModuleImportingCB *>(PP->getPPCallbacks());
342 EXPECT_EQ(Callback->importNamedModuleNum(), (size_t)4);
343 EXPECT_FALSE(PP->isInNamedModule());
344 EXPECT_FALSE(PP->isInNamedInterfaceUnit());
345 EXPECT_FALSE(PP->isInImplementationUnit());
346 }
347
348 } // namespace