Coverage Report

Created: 2020-09-19 12:23

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/Sema/SemaModule.cpp
Line
Count
Source (jump to first uncovered line)
1
//===--- SemaModule.cpp - Semantic Analysis for Modules -------------------===//
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
//  This file implements semantic analysis for modules (C++ modules syntax,
10
//  Objective-C modules syntax, and Clang header modules).
11
//
12
//===----------------------------------------------------------------------===//
13
14
#include "clang/AST/ASTConsumer.h"
15
#include "clang/Lex/HeaderSearch.h"
16
#include "clang/Lex/Preprocessor.h"
17
#include "clang/Sema/SemaInternal.h"
18
19
using namespace clang;
20
using namespace sema;
21
22
static void checkModuleImportContext(Sema &S, Module *M,
23
                                     SourceLocation ImportLoc, DeclContext *DC,
24
83.1k
                                     bool FromInclude = false) {
25
83.1k
  SourceLocation ExternCLoc;
26
83.1k
27
83.1k
  if (auto *LSD = dyn_cast<LinkageSpecDecl>(DC)) {
28
33.2k
    switch (LSD->getLanguage()) {
29
33.0k
    case LinkageSpecDecl::lang_c:
30
33.0k
      if (ExternCLoc.isInvalid())
31
33.0k
        ExternCLoc = LSD->getBeginLoc();
32
33.0k
      break;
33
209
    case LinkageSpecDecl::lang_cxx:
34
209
      break;
35
33.2k
    }
36
33.2k
    DC = LSD->getParent();
37
33.2k
  }
38
83.1k
39
83.9k
  
while (83.1k
isa<LinkageSpecDecl>(DC) ||
isa<ExportDecl>(DC)83.1k
)
40
804
    DC = DC->getParent();
41
83.1k
42
83.1k
  if (!isa<TranslationUnitDecl>(DC)) {
43
19
    S.Diag(ImportLoc, (FromInclude && S.isModuleVisible(M))
44
10
                          ? diag::ext_module_import_not_at_top_level_noop
45
9
                          : diag::err_module_import_not_at_top_level_fatal)
46
19
        << M->getFullModuleName() << DC;
47
19
    S.Diag(cast<Decl>(DC)->getBeginLoc(),
48
19
           diag::note_module_import_not_at_top_level)
49
19
        << DC;
50
83.0k
  } else if (!M->IsExternC && 
ExternCLoc.isValid()13.4k
) {
51
10
    S.Diag(ImportLoc, diag::ext_module_import_in_extern_c)
52
10
      << M->getFullModuleName();
53
10
    S.Diag(ExternCLoc, diag::note_extern_c_begins_here);
54
10
  }
55
83.1k
}
56
57
Sema::DeclGroupPtrTy
58
135
Sema::ActOnGlobalModuleFragmentDecl(SourceLocation ModuleLoc) {
59
135
  if (!ModuleScopes.empty() &&
60
0
      ModuleScopes.back().Module->Kind == Module::GlobalModuleFragment) {
61
    // Under -std=c++2a -fmodules-ts, we can find an explicit 'module;' after
62
    // already implicitly entering the global module fragment. That's OK.
63
0
    assert(getLangOpts().CPlusPlusModules && getLangOpts().ModulesTS &&
64
0
           "unexpectedly encountered multiple global module fragment decls");
65
0
    ModuleScopes.back().BeginLoc = ModuleLoc;
66
0
    return nullptr;
67
0
  }
68
135
69
  // We start in the global module; all those declarations are implicitly
70
  // module-private (though they do not have module linkage).
71
135
  auto &Map = PP.getHeaderSearchInfo().getModuleMap();
72
135
  auto *GlobalModule = Map.createGlobalModuleFragmentForModuleUnit(ModuleLoc);
73
135
  assert(GlobalModule && "module creation should not fail");
74
135
75
  // Enter the scope of the global module.
76
135
  ModuleScopes.push_back({});
77
135
  ModuleScopes.back().BeginLoc = ModuleLoc;
78
135
  ModuleScopes.back().Module = GlobalModule;
79
135
  VisibleModules.setVisible(GlobalModule, ModuleLoc);
80
135
81
  // All declarations created from now on are owned by the global module.
82
135
  auto *TU = Context.getTranslationUnitDecl();
83
135
  TU->setModuleOwnershipKind(Decl::ModuleOwnershipKind::Visible);
84
135
  TU->setLocalOwningModule(GlobalModule);
85
135
86
  // FIXME: Consider creating an explicit representation of this declaration.
87
135
  return nullptr;
88
135
}
89
90
Sema::DeclGroupPtrTy
91
Sema::ActOnModuleDecl(SourceLocation StartLoc, SourceLocation ModuleLoc,
92
112
                      ModuleDeclKind MDK, ModuleIdPath Path, bool IsFirstDecl) {
93
112
  assert((getLangOpts().ModulesTS || getLangOpts().CPlusPlusModules) &&
94
112
         "should only have module decl in Modules TS or C++20");
95
112
96
  // A module implementation unit requires that we are not compiling a module
97
  // of any kind. A module interface unit requires that we are not compiling a
98
  // module map.
99
112
  switch (getLangOpts().getCompilingModule()) {
100
64
  case LangOptions::CMK_None:
101
    // It's OK to compile a module interface as a normal translation unit.
102
64
    break;
103
0
104
48
  case LangOptions::CMK_ModuleInterface:
105
48
    if (MDK != ModuleDeclKind::Implementation)
106
47
      break;
107
1
108
    // We were asked to compile a module interface unit but this is a module
109
    // implementation unit. That indicates the 'export' is missing.
110
1
    Diag(ModuleLoc, diag::err_module_interface_implementation_mismatch)
111
1
      << FixItHint::CreateInsertion(ModuleLoc, "export ");
112
1
    MDK = ModuleDeclKind::Interface;
113
1
    break;
114
1
115
0
  case LangOptions::CMK_ModuleMap:
116
0
    Diag(ModuleLoc, diag::err_module_decl_in_module_map_module);
117
0
    return nullptr;
118
1
119
0
  case LangOptions::CMK_HeaderModule:
120
0
    Diag(ModuleLoc, diag::err_module_decl_in_header_module);
121
0
    return nullptr;
122
112
  }
123
112
124
112
  assert(ModuleScopes.size() <= 1 && "expected to be at global module scope");
125
112
126
  // FIXME: Most of this work should be done by the preprocessor rather than
127
  // here, in order to support macro import.
128
112
129
  // Only one module-declaration is permitted per source file.
130
112
  if (!ModuleScopes.empty() &&
131
89
      ModuleScopes.back().Module->isModulePurview()) {
132
4
    Diag(ModuleLoc, diag::err_module_redeclaration);
133
4
    Diag(VisibleModules.getImportLoc(ModuleScopes.back().Module),
134
4
         diag::note_prev_module_declaration);
135
4
    return nullptr;
136
4
  }
137
108
138
  // Find the global module fragment we're adopting into this module, if any.
139
108
  Module *GlobalModuleFragment = nullptr;
140
108
  if (!ModuleScopes.empty() &&
141
85
      ModuleScopes.back().Module->Kind == Module::GlobalModuleFragment)
142
85
    GlobalModuleFragment = ModuleScopes.back().Module;
143
108
144
  // In C++20, the module-declaration must be the first declaration if there
145
  // is no global module fragment.
146
108
  if (getLangOpts().CPlusPlusModules && 
!IsFirstDecl34
&&
!GlobalModuleFragment13
) {
147
2
    Diag(ModuleLoc, diag::err_module_decl_not_at_start);
148
2
    SourceLocation BeginLoc =
149
2
        ModuleScopes.empty()
150
2
            ? SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID())
151
0
            : ModuleScopes.back().BeginLoc;
152
2
    if (BeginLoc.isValid()) {
153
2
      Diag(BeginLoc, diag::note_global_module_introducer_missing)
154
2
          << FixItHint::CreateInsertion(BeginLoc, "module;\n");
155
2
    }
156
2
  }
157
108
158
  // Flatten the dots in a module name. Unlike Clang's hierarchical module map
159
  // modules, the dots here are just another character that can appear in a
160
  // module name.
161
108
  std::string ModuleName;
162
113
  for (auto &Piece : Path) {
163
113
    if (!ModuleName.empty())
164
5
      ModuleName += ".";
165
113
    ModuleName += Piece.first->getName();
166
113
  }
167
108
168
  // If a module name was explicitly specified on the command line, it must be
169
  // correct.
170
108
  if (!getLangOpts().CurrentModule.empty() &&
171
0
      getLangOpts().CurrentModule != ModuleName) {
172
0
    Diag(Path.front().second, diag::err_current_module_name_mismatch)
173
0
        << SourceRange(Path.front().second, Path.back().second)
174
0
        << getLangOpts().CurrentModule;
175
0
    return nullptr;
176
0
  }
177
108
  const_cast<LangOptions&>(getLangOpts()).CurrentModule = ModuleName;
178
108
179
108
  auto &Map = PP.getHeaderSearchInfo().getModuleMap();
180
108
  Module *Mod;
181
108
182
108
  switch (MDK) {
183
83
  case ModuleDeclKind::Interface: {
184
    // We can't have parsed or imported a definition of this module or parsed a
185
    // module map defining it already.
186
83
    if (auto *M = Map.findModule(ModuleName)) {
187
4
      Diag(Path[0].second, diag::err_module_redefinition) << ModuleName;
188
4
      if (M->DefinitionLoc.isValid())
189
0
        Diag(M->DefinitionLoc, diag::note_prev_module_definition);
190
4
      else if (const auto *FE = M->getASTFile())
191
4
        Diag(M->DefinitionLoc, diag::note_prev_module_definition_from_ast_file)
192
4
            << FE->getName();
193
4
      Mod = M;
194
4
      break;
195
4
    }
196
79
197
    // Create a Module for the module that we're defining.
198
79
    Mod = Map.createModuleForInterfaceUnit(ModuleLoc, ModuleName,
199
79
                                           GlobalModuleFragment);
200
79
    assert(Mod && "module creation should not fail");
201
79
    break;
202
79
  }
203
79
204
25
  case ModuleDeclKind::Implementation:
205
25
    std::pair<IdentifierInfo *, SourceLocation> ModuleNameLoc(
206
25
        PP.getIdentifierInfo(ModuleName), Path[0].second);
207
25
    Mod = getModuleLoader().loadModule(ModuleLoc, {ModuleNameLoc},
208
25
                                       Module::AllVisible,
209
25
                                       /*IsInclusionDirective=*/false);
210
25
    if (!Mod) {
211
2
      Diag(ModuleLoc, diag::err_module_not_defined) << ModuleName;
212
      // Create an empty module interface unit for error recovery.
213
2
      Mod = Map.createModuleForInterfaceUnit(ModuleLoc, ModuleName,
214
2
                                             GlobalModuleFragment);
215
2
    }
216
25
    break;
217
108
  }
218
108
219
108
  if (!GlobalModuleFragment) {
220
23
    ModuleScopes.push_back({});
221
23
    if (getLangOpts().ModulesLocalVisibility)
222
23
      ModuleScopes.back().OuterVisibleModules = std::move(VisibleModules);
223
85
  } else {
224
    // We're done with the global module fragment now.
225
85
    ActOnEndOfTranslationUnitFragment(TUFragmentKind::Global);
226
85
  }
227
108
228
  // Switch from the global module fragment (if any) to the named module.
229
108
  ModuleScopes.back().BeginLoc = StartLoc;
230
108
  ModuleScopes.back().Module = Mod;
231
108
  ModuleScopes.back().ModuleInterface = MDK != ModuleDeclKind::Implementation;
232
108
  VisibleModules.setVisible(Mod, ModuleLoc);
233
108
234
  // From now on, we have an owning module for all declarations we see.
235
  // However, those declarations are module-private unless explicitly
236
  // exported.
237
108
  auto *TU = Context.getTranslationUnitDecl();
238
108
  TU->setModuleOwnershipKind(Decl::ModuleOwnershipKind::ModulePrivate);
239
108
  TU->setLocalOwningModule(Mod);
240
108
241
  // FIXME: Create a ModuleDecl.
242
108
  return nullptr;
243
108
}
244
245
Sema::DeclGroupPtrTy
246
Sema::ActOnPrivateModuleFragmentDecl(SourceLocation ModuleLoc,
247
13
                                     SourceLocation PrivateLoc) {
248
  // C++20 [basic.link]/2:
249
  //   A private-module-fragment shall appear only in a primary module
250
  //   interface unit.
251
1
  switch (ModuleScopes.empty() ? Module::GlobalModuleFragment
252
12
                               : ModuleScopes.back().Module->Kind) {
253
2
  case Module::ModuleMapModule:
254
2
  case Module::GlobalModuleFragment:
255
2
    Diag(PrivateLoc, diag::err_private_module_fragment_not_module);
256
2
    return nullptr;
257
2
258
3
  case Module::PrivateModuleFragment:
259
3
    Diag(PrivateLoc, diag::err_private_module_fragment_redefined);
260
3
    Diag(ModuleScopes.back().BeginLoc, diag::note_previous_definition);
261
3
    return nullptr;
262
2
263
8
  case Module::ModuleInterfaceUnit:
264
8
    break;
265
8
  }
266
8
267
8
  if (!ModuleScopes.back().ModuleInterface) {
268
1
    Diag(PrivateLoc, diag::err_private_module_fragment_not_module_interface);
269
1
    Diag(ModuleScopes.back().BeginLoc,
270
1
         diag::note_not_module_interface_add_export)
271
1
        << FixItHint::CreateInsertion(ModuleScopes.back().BeginLoc, "export ");
272
1
    return nullptr;
273
1
  }
274
7
275
  // FIXME: Check this isn't a module interface partition.
276
  // FIXME: Check that this translation unit does not import any partitions;
277
  // such imports would violate [basic.link]/2's "shall be the only module unit"
278
  // restriction.
279
7
280
  // We've finished the public fragment of the translation unit.
281
7
  ActOnEndOfTranslationUnitFragment(TUFragmentKind::Normal);
282
7
283
7
  auto &Map = PP.getHeaderSearchInfo().getModuleMap();
284
7
  Module *PrivateModuleFragment =
285
7
      Map.createPrivateModuleFragmentForInterfaceUnit(
286
7
          ModuleScopes.back().Module, PrivateLoc);
287
7
  assert(PrivateModuleFragment && "module creation should not fail");
288
7
289
  // Enter the scope of the private module fragment.
290
7
  ModuleScopes.push_back({});
291
7
  ModuleScopes.back().BeginLoc = ModuleLoc;
292
7
  ModuleScopes.back().Module = PrivateModuleFragment;
293
7
  ModuleScopes.back().ModuleInterface = true;
294
7
  VisibleModules.setVisible(PrivateModuleFragment, ModuleLoc);
295
7
296
  // All declarations created from now on are scoped to the private module
297
  // fragment (and are neither visible nor reachable in importers of the module
298
  // interface).
299
7
  auto *TU = Context.getTranslationUnitDecl();
300
7
  TU->setModuleOwnershipKind(Decl::ModuleOwnershipKind::ModulePrivate);
301
7
  TU->setLocalOwningModule(PrivateModuleFragment);
302
7
303
  // FIXME: Consider creating an explicit representation of this declaration.
304
7
  return nullptr;
305
7
}
306
307
DeclResult Sema::ActOnModuleImport(SourceLocation StartLoc,
308
                                   SourceLocation ExportLoc,
309
                                   SourceLocation ImportLoc,
310
1.49k
                                   ModuleIdPath Path) {
311
  // Flatten the module path for a Modules TS module name.
312
1.49k
  std::pair<IdentifierInfo *, SourceLocation> ModuleNameLoc;
313
1.49k
  if (getLangOpts().ModulesTS) {
314
68
    std::string ModuleName;
315
75
    for (auto &Piece : Path) {
316
75
      if (!ModuleName.empty())
317
7
        ModuleName += ".";
318
75
      ModuleName += Piece.first->getName();
319
75
    }
320
68
    ModuleNameLoc = {PP.getIdentifierInfo(ModuleName), Path[0].second};
321
68
    Path = ModuleIdPath(ModuleNameLoc);
322
68
  }
323
1.49k
324
1.49k
  Module *Mod =
325
1.49k
      getModuleLoader().loadModule(ImportLoc, Path, Module::AllVisible,
326
1.49k
                                   /*IsInclusionDirective=*/false);
327
1.49k
  if (!Mod)
328
89
    return true;
329
1.40k
330
1.40k
  return ActOnModuleImport(StartLoc, ExportLoc, ImportLoc, Mod, Path);
331
1.40k
}
332
333
/// Determine whether \p D is lexically within an export-declaration.
334
120
static const ExportDecl *getEnclosingExportDecl(const Decl *D) {
335
246
  for (auto *DC = D->getLexicalDeclContext(); DC; 
DC = DC->getLexicalParent()126
)
336
133
    if (auto *ED = dyn_cast<ExportDecl>(DC))
337
7
      return ED;
338
113
  return nullptr;
339
120
}
340
341
DeclResult Sema::ActOnModuleImport(SourceLocation StartLoc,
342
                                   SourceLocation ExportLoc,
343
                                   SourceLocation ImportLoc,
344
1.40k
                                   Module *Mod, ModuleIdPath Path) {
345
1.40k
  VisibleModules.setVisible(Mod, ImportLoc);
346
1.40k
347
1.40k
  checkModuleImportContext(*this, Mod, ImportLoc, CurContext);
348
1.40k
349
  // FIXME: we should support importing a submodule within a different submodule
350
  // of the same top-level module. Until we do, make it an error rather than
351
  // silently ignoring the import.
352
  // Import-from-implementation is valid in the Modules TS. FIXME: Should we
353
  // warn on a redundant import of the current module?
354
  // FIXME: Import of a module from an implementation partition of the same
355
  // module is permitted.
356
1.40k
  if (Mod->getTopLevelModuleName() == getLangOpts().CurrentModule &&
357
10
      (getLangOpts().isCompilingModule() || 
!getLangOpts().ModulesTS9
)) {
358
4
    Diag(ImportLoc, getLangOpts().isCompilingModule()
359
1
                        ? diag::err_module_self_import
360
3
                        : diag::err_module_import_in_implementation)
361
4
        << Mod->getFullModuleName() << getLangOpts().CurrentModule;
362
4
  }
363
1.40k
364
1.40k
  SmallVector<SourceLocation, 2> IdentifierLocs;
365
1.40k
  Module *ModCheck = Mod;
366
2.95k
  for (unsigned I = 0, N = Path.size(); I != N; 
++I1.55k
) {
367
    // If we've run out of module parents, just drop the remaining identifiers.
368
    // We need the length to be consistent.
369
1.56k
    if (!ModCheck)
370
6
      break;
371
1.55k
    ModCheck = ModCheck->Parent;
372
1.55k
373
1.55k
    IdentifierLocs.push_back(Path[I].second);
374
1.55k
  }
375
1.40k
376
  // If this was a header import, pad out with dummy locations.
377
  // FIXME: Pass in and use the location of the header-name token in this case.
378
1.40k
  if (Path.empty()) {
379
6
    for (; ModCheck; 
ModCheck = ModCheck->Parent4
) {
380
4
      IdentifierLocs.push_back(SourceLocation());
381
4
    }
382
2
  }
383
1.40k
384
1.40k
  ImportDecl *Import = ImportDecl::Create(Context, CurContext, StartLoc,
385
1.40k
                                          Mod, IdentifierLocs);
386
1.40k
  CurContext->addDecl(Import);
387
1.40k
388
  // Sequence initialization of the imported module before that of the current
389
  // module, if any.
390
1.40k
  if (!ModuleScopes.empty())
391
220
    Context.addModuleInitializer(ModuleScopes.back().Module, Import);
392
1.40k
393
  // Re-export the module if needed.
394
1.40k
  if (!ModuleScopes.empty() && 
ModuleScopes.back().ModuleInterface220
) {
395
18
    if (ExportLoc.isValid() || 
getEnclosingExportDecl(Import)17
)
396
5
      getCurrentModule()->Exports.emplace_back(Mod, false);
397
1.38k
  } else if (ExportLoc.isValid()) {
398
0
    Diag(ExportLoc, diag::err_export_not_in_module_interface);
399
0
  }
400
1.40k
401
1.40k
  return Import;
402
1.40k
}
403
404
20.2k
void Sema::ActOnModuleInclude(SourceLocation DirectiveLoc, Module *Mod) {
405
20.2k
  checkModuleImportContext(*this, Mod, DirectiveLoc, CurContext, true);
406
20.2k
  BuildModuleInclude(DirectiveLoc, Mod);
407
20.2k
}
408
409
81.7k
void Sema::BuildModuleInclude(SourceLocation DirectiveLoc, Module *Mod) {
410
  // Determine whether we're in the #include buffer for a module. The #includes
411
  // in that buffer do not qualify as module imports; they're just an
412
  // implementation detail of us building the module.
413
  //
414
  // FIXME: Should we even get ActOnModuleInclude calls for those?
415
81.7k
  bool IsInModuleIncludes =
416
81.7k
      TUKind == TU_Module &&
417
79.6k
      getSourceManager().isWrittenInMainFile(DirectiveLoc);
418
81.7k
419
81.7k
  bool ShouldAddImport = !IsInModuleIncludes;
420
81.7k
421
  // If this module import was due to an inclusion directive, create an
422
  // implicit import declaration to capture it in the AST.
423
81.7k
  if (ShouldAddImport) {
424
79.6k
    TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl();
425
79.6k
    ImportDecl *ImportD = ImportDecl::CreateImplicit(getASTContext(), TU,
426
79.6k
                                                     DirectiveLoc, Mod,
427
79.6k
                                                     DirectiveLoc);
428
79.6k
    if (!ModuleScopes.empty())
429
63.9k
      Context.addModuleInitializer(ModuleScopes.back().Module, ImportD);
430
79.6k
    TU->addDecl(ImportD);
431
79.6k
    Consumer.HandleImplicitImportDecl(ImportD);
432
79.6k
  }
433
81.7k
434
81.7k
  getModuleLoader().makeModuleVisible(Mod, Module::AllVisible, DirectiveLoc);
435
81.7k
  VisibleModules.setVisible(Mod, DirectiveLoc);
436
81.7k
}
437
438
61.4k
void Sema::ActOnModuleBegin(SourceLocation DirectiveLoc, Module *Mod) {
439
61.4k
  checkModuleImportContext(*this, Mod, DirectiveLoc, CurContext, true);
440
61.4k
441
61.4k
  ModuleScopes.push_back({});
442
61.4k
  ModuleScopes.back().Module = Mod;
443
61.4k
  if (getLangOpts().ModulesLocalVisibility)
444
292
    ModuleScopes.back().OuterVisibleModules = std::move(VisibleModules);
445
61.4k
446
61.4k
  VisibleModules.setVisible(Mod, DirectiveLoc);
447
61.4k
448
  // The enclosing context is now part of this module.
449
  // FIXME: Consider creating a child DeclContext to hold the entities
450
  // lexically within the module.
451
61.4k
  if (getLangOpts().trackLocalOwningModule()) {
452
149k
    for (auto *DC = CurContext; DC; 
DC = DC->getLexicalParent()88.2k
) {
453
88.2k
      cast<Decl>(DC)->setModuleOwnershipKind(
454
88.2k
          getLangOpts().ModulesLocalVisibility
455
298
              ? Decl::ModuleOwnershipKind::VisibleWhenImported
456
87.9k
              : Decl::ModuleOwnershipKind::Visible);
457
88.2k
      cast<Decl>(DC)->setLocalOwningModule(Mod);
458
88.2k
    }
459
61.3k
  }
460
61.4k
}
461
462
61.4k
void Sema::ActOnModuleEnd(SourceLocation EomLoc, Module *Mod) {
463
61.4k
  if (getLangOpts().ModulesLocalVisibility) {
464
292
    VisibleModules = std::move(ModuleScopes.back().OuterVisibleModules);
465
    // Leaving a module hides namespace names, so our visible namespace cache
466
    // is now out of date.
467
292
    VisibleNamespaceCache.clear();
468
292
  }
469
61.4k
470
61.4k
  assert(!ModuleScopes.empty() && ModuleScopes.back().Module == Mod &&
471
61.4k
         "left the wrong module scope");
472
61.4k
  ModuleScopes.pop_back();
473
61.4k
474
  // We got to the end of processing a local module. Create an
475
  // ImportDecl as we would for an imported module.
476
61.4k
  FileID File = getSourceManager().getFileID(EomLoc);
477
61.4k
  SourceLocation DirectiveLoc;
478
61.4k
  if (EomLoc == getSourceManager().getLocForEndOfFile(File)) {
479
    // We reached the end of a #included module header. Use the #include loc.
480
428
    assert(File != getSourceManager().getMainFileID() &&
481
428
           "end of submodule in main source file");
482
428
    DirectiveLoc = getSourceManager().getIncludeLoc(File);
483
60.9k
  } else {
484
    // We reached an EOM pragma. Use the pragma location.
485
60.9k
    DirectiveLoc = EomLoc;
486
60.9k
  }
487
61.4k
  BuildModuleInclude(DirectiveLoc, Mod);
488
61.4k
489
  // Any further declarations are in whatever module we returned to.
490
61.4k
  if (getLangOpts().trackLocalOwningModule()) {
491
    // The parser guarantees that this is the same context that we entered
492
    // the module within.
493
149k
    for (auto *DC = CurContext; DC; 
DC = DC->getLexicalParent()88.2k
) {
494
88.2k
      cast<Decl>(DC)->setLocalOwningModule(getCurrentModule());
495
88.2k
      if (!getCurrentModule())
496
19.6k
        cast<Decl>(DC)->setModuleOwnershipKind(
497
19.6k
            Decl::ModuleOwnershipKind::Unowned);
498
88.2k
    }
499
61.3k
  }
500
61.4k
}
501
502
void Sema::createImplicitModuleImportForErrorRecovery(SourceLocation Loc,
503
669
                                                      Module *Mod) {
504
  // Bail if we're not allowed to implicitly import a module here.
505
669
  if (isSFINAEContext() || !getLangOpts().ModulesErrorRecovery ||
506
54
      VisibleModules.isVisible(Mod))
507
616
    return;
508
53
509
  // Create the implicit import declaration.
510
53
  TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl();
511
53
  ImportDecl *ImportD = ImportDecl::CreateImplicit(getASTContext(), TU,
512
53
                                                   Loc, Mod, Loc);
513
53
  TU->addDecl(ImportD);
514
53
  Consumer.HandleImplicitImportDecl(ImportD);
515
53
516
  // Make the module visible.
517
53
  getModuleLoader().makeModuleVisible(Mod, Module::AllVisible, Loc);
518
53
  VisibleModules.setVisible(Mod, Loc);
519
53
}
520
521
/// We have parsed the start of an export declaration, including the '{'
522
/// (if present).
523
Decl *Sema::ActOnStartExportDecl(Scope *S, SourceLocation ExportLoc,
524
103
                                 SourceLocation LBraceLoc) {
525
103
  ExportDecl *D = ExportDecl::Create(Context, CurContext, ExportLoc);
526
103
527
  // Set this temporarily so we know the export-declaration was braced.
528
103
  D->setRBraceLoc(LBraceLoc);
529
103
530
  // C++2a [module.interface]p1:
531
  //   An export-declaration shall appear only [...] in the purview of a module
532
  //   interface unit. An export-declaration shall not appear directly or
533
  //   indirectly within [...] a private-module-fragment.
534
103
  if (ModuleScopes.empty() || !ModuleScopes.back().Module->isModulePurview()) {
535
3
    Diag(ExportLoc, diag::err_export_not_in_module_interface) << 0;
536
100
  } else if (!ModuleScopes.back().ModuleInterface) {
537
3
    Diag(ExportLoc, diag::err_export_not_in_module_interface) << 1;
538
3
    Diag(ModuleScopes.back().BeginLoc,
539
3
         diag::note_not_module_interface_add_export)
540
3
        << FixItHint::CreateInsertion(ModuleScopes.back().BeginLoc, "export ");
541
97
  } else if (ModuleScopes.back().Module->Kind ==
542
1
             Module::PrivateModuleFragment) {
543
1
    Diag(ExportLoc, diag::err_export_in_private_module_fragment);
544
1
    Diag(ModuleScopes.back().BeginLoc, diag::note_private_module_fragment);
545
1
  }
546
103
547
216
  for (const DeclContext *DC = CurContext; DC; 
DC = DC->getLexicalParent()113
) {
548
116
    if (const auto *ND = dyn_cast<NamespaceDecl>(DC)) {
549
      //   An export-declaration shall not appear directly or indirectly within
550
      //   an unnamed namespace [...]
551
12
      if (ND->isAnonymousNamespace()) {
552
3
        Diag(ExportLoc, diag::err_export_within_anonymous_namespace);
553
3
        Diag(ND->getLocation(), diag::note_anonymous_namespace);
554
        // Don't diagnose internal-linkage declarations in this region.
555
3
        D->setInvalidDecl();
556
3
        break;
557
3
      }
558
9
559
      //   A declaration is exported if it is [...] a namespace-definition
560
      //   that contains an exported declaration.
561
      //
562
      // Defer exporting the namespace until after we leave it, in order to
563
      // avoid marking all subsequent declarations in the namespace as exported.
564
9
      if (!DeferredExportedNamespaces.insert(ND).second)
565
0
        break;
566
9
    }
567
116
  }
568
103
569
  //   [...] its declaration or declaration-seq shall not contain an
570
  //   export-declaration.
571
103
  if (auto *ED = getEnclosingExportDecl(D)) {
572
3
    Diag(ExportLoc, diag::err_export_within_export);
573
3
    if (ED->hasBraces())
574
2
      Diag(ED->getLocation(), diag::note_export);
575
3
  }
576
103
577
103
  CurContext->addDecl(D);
578
103
  PushDeclContext(S, D);
579
103
  D->setModuleOwnershipKind(Decl::ModuleOwnershipKind::VisibleWhenImported);
580
103
  return D;
581
103
}
582
583
static bool checkExportedDeclContext(Sema &S, DeclContext *DC,
584
                                     SourceLocation BlockStart);
585
586
namespace {
587
enum class UnnamedDeclKind {
588
  Empty,
589
  StaticAssert,
590
  Asm,
591
  UsingDirective,
592
  Context
593
};
594
}
595
596
252
static llvm::Optional<UnnamedDeclKind> getUnnamedDeclKind(Decl *D) {
597
252
  if (isa<EmptyDecl>(D))
598
5
    return UnnamedDeclKind::Empty;
599
247
  if (isa<StaticAssertDecl>(D))
600
3
    return UnnamedDeclKind::StaticAssert;
601
244
  if (isa<FileScopeAsmDecl>(D))
602
1
    return UnnamedDeclKind::Asm;
603
243
  if (isa<UsingDirectiveDecl>(D))
604
2
    return UnnamedDeclKind::UsingDirective;
605
  // Everything else either introduces one or more names or is ill-formed.
606
241
  return llvm::None;
607
241
}
608
609
16
unsigned getUnnamedDeclDiag(UnnamedDeclKind UDK, bool InBlock) {
610
16
  switch (UDK) {
611
8
  case UnnamedDeclKind::Empty:
612
8
  case UnnamedDeclKind::StaticAssert:
613
    // Allow empty-declarations and static_asserts in an export block as an
614
    // extension.
615
4
    return InBlock ? diag::ext_export_no_name_block : diag::err_export_no_name;
616
8
617
2
  case UnnamedDeclKind::UsingDirective:
618
    // Allow exporting using-directives as an extension.
619
2
    return diag::ext_export_using_directive;
620
8
621
5
  case UnnamedDeclKind::Context:
622
    // Allow exporting DeclContexts that transitively contain no declarations
623
    // as an extension.
624
5
    return diag::ext_export_no_names;
625
8
626
1
  case UnnamedDeclKind::Asm:
627
1
    return diag::err_export_no_name;
628
0
  }
629
0
  llvm_unreachable("unknown kind");
630
0
}
631
632
static void diagExportedUnnamedDecl(Sema &S, UnnamedDeclKind UDK, Decl *D,
633
16
                                    SourceLocation BlockStart) {
634
16
  S.Diag(D->getLocation(), getUnnamedDeclDiag(UDK, BlockStart.isValid()))
635
16
      << (unsigned)UDK;
636
16
  if (BlockStart.isValid())
637
6
    S.Diag(BlockStart, diag::note_export);
638
16
}
639
640
/// Check that it's valid to export \p D.
641
252
static bool checkExportedDecl(Sema &S, Decl *D, SourceLocation BlockStart) {
642
  // C++2a [module.interface]p3:
643
  //   An exported declaration shall declare at least one name
644
252
  if (auto UDK = getUnnamedDeclKind(D))
645
11
    diagExportedUnnamedDecl(S, *UDK, D, BlockStart);
646
252
647
  //   [...] shall not declare a name with internal linkage.
648
252
  if (auto *ND = dyn_cast<NamedDecl>(D)) {
649
    // Don't diagnose anonymous union objects; we'll diagnose their members
650
    // instead.
651
228
    if (ND->getDeclName() && 
ND->getFormalLinkage() == InternalLinkage211
) {
652
8
      S.Diag(ND->getLocation(), diag::err_export_internal) << ND;
653
8
      if (BlockStart.isValid())
654
2
        S.Diag(BlockStart, diag::note_export);
655
8
    }
656
228
  }
657
252
658
  // C++2a [module.interface]p5:
659
  //   all entities to which all of the using-declarators ultimately refer
660
  //   shall have been introduced with a name having external linkage
661
252
  if (auto *USD = dyn_cast<UsingShadowDecl>(D)) {
662
38
    NamedDecl *Target = USD->getUnderlyingDecl();
663
38
    if (Target->getFormalLinkage() == InternalLinkage) {
664
19
      S.Diag(USD->getLocation(), diag::err_export_using_internal) << Target;
665
19
      S.Diag(Target->getLocation(), diag::note_using_decl_target);
666
19
      if (BlockStart.isValid())
667
19
        S.Diag(BlockStart, diag::note_export);
668
19
    }
669
38
  }
670
252
671
  // Recurse into namespace-scope DeclContexts. (Only namespace-scope
672
  // declarations are exported.)
673
252
  if (auto *DC = dyn_cast<DeclContext>(D))
674
64
    if (DC->getRedeclContext()->isFileContext() && 
!isa<EnumDecl>(D)23
)
675
20
      return checkExportedDeclContext(S, DC, BlockStart);
676
232
  return false;
677
232
}
678
679
/// Check that it's valid to export all the declarations in \p DC.
680
static bool checkExportedDeclContext(Sema &S, DeclContext *DC,
681
20
                                     SourceLocation BlockStart) {
682
20
  bool AllUnnamed = true;
683
20
  for (auto *D : DC->decls())
684
50
    AllUnnamed &= checkExportedDecl(S, D, BlockStart);
685
20
  return AllUnnamed;
686
20
}
687
688
/// Complete the definition of an export declaration.
689
103
Decl *Sema::ActOnFinishExportDecl(Scope *S, Decl *D, SourceLocation RBraceLoc) {
690
103
  auto *ED = cast<ExportDecl>(D);
691
103
  if (RBraceLoc.isValid())
692
20
    ED->setRBraceLoc(RBraceLoc);
693
103
694
103
  PopDeclContext();
695
103
696
103
  if (!D->isInvalidDecl()) {
697
100
    SourceLocation BlockStart =
698
80
        ED->hasBraces() ? 
ED->getBeginLoc()20
: SourceLocation();
699
202
    for (auto *Child : ED->decls()) {
700
202
      if (checkExportedDecl(*this, Child, BlockStart)) {
701
        // If a top-level child is a linkage-spec declaration, it might contain
702
        // no declarations (transitively), in which case it's ill-formed.
703
5
        diagExportedUnnamedDecl(*this, UnnamedDeclKind::Context, Child,
704
5
                                BlockStart);
705
5
      }
706
202
    }
707
100
  }
708
103
709
103
  return D;
710
103
}