//===--- SemaModule.cpp - Semantic Analysis for Modules -------------------===//

//

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

//

//===----------------------------------------------------------------------===//

//

//  This file implements semantic analysis for modules (C++ modules syntax,

//  Objective-C modules syntax, and Clang header modules).

//

//===----------------------------------------------------------------------===//

#include "clang/AST/ASTConsumer.h"

#include "clang/Lex/HeaderSearch.h"

#include "clang/Lex/Preprocessor.h"

#include "clang/Sema/SemaInternal.h"

using namespace clang;

using namespace sema;

static void checkModuleImportContext(Sema &S, Module *M,

                                     SourceLocation ImportLoc, DeclContext *DC,

                                     bool FromInclude = false) {

  SourceLocation ExternCLoc;

  if (auto *LSD = dyn_cast<LinkageSpecDecl>(DC)) {

    switch (LSD->getLanguage()) {

    case LinkageSpecDecl::lang_c:

      if (ExternCLoc.isInvalid())

        ExternCLoc = LSD->getBeginLoc();

      break;

    case LinkageSpecDecl::lang_cxx:

      break;

    }

    DC = LSD->getParent();

  }

  
while (144k
isa<LinkageSpecDecl>(DC) || 
isa<ExportDecl>(DC)144k
)

    DC = DC->getParent();

  if (!isa<TranslationUnitDecl>(DC)) {

    S.Diag(ImportLoc, (FromInclude && S.isModuleVisible(M))

                          ? 
diag::ext_module_import_not_at_top_level_noop10

                          : 
diag::err_module_import_not_at_top_level_fatal9
)

        << M->getFullModuleName() << DC;

    S.Diag(cast<Decl>(DC)->getBeginLoc(),

           diag::note_module_import_not_at_top_level)

        << DC;

  } else if (!M->IsExternC && 
ExternCLoc.isValid()66.5k
) {

    S.Diag(ImportLoc, diag::ext_module_import_in_extern_c)

      << M->getFullModuleName();

    S.Diag(ExternCLoc, diag::note_extern_c_begins_here);

  }

}

// We represent the primary and partition names as 'Paths' which are sections

// of the hierarchical access path for a clang module.  However for C++20

// the periods in a name are just another character, and we will need to

// flatten them into a string.

static std::string stringFromPath(ModuleIdPath Path) {

  std::string Name;

  if (Path.empty())

    return Name;

  
for (auto &Piece : Path)475
 {

    if (!Name.empty())

      Name += ".";

    Name += Piece.first->getName();

  }

  return Name;

}

Sema::DeclGroupPtrTy

Sema::ActOnGlobalModuleFragmentDecl(SourceLocation ModuleLoc) {

  if (!ModuleScopes.empty() &&

      
ModuleScopes.back().Module->Kind == Module::GlobalModuleFragment1
) {

    // Under -std=c++2a -fmodules-ts, we can find an explicit 'module;' after

    // already implicitly entering the global module fragment. That's OK.

    assert(getLangOpts().CPlusPlusModules && getLangOpts().ModulesTS &&

           "unexpectedly encountered multiple global module fragment decls");

    ModuleScopes.back().BeginLoc = ModuleLoc;

    return nullptr;

  }

  // We start in the global module; all those declarations are implicitly

  // module-private (though they do not have module linkage).

  Module *GlobalModule =

      PushGlobalModuleFragment(ModuleLoc, /*IsImplicit=*/false);

  // All declarations created from now on are owned by the global module.

  auto *TU = Context.getTranslationUnitDecl();

  // [module.global.frag]p2

  // A global-module-fragment specifies the contents of the global module

  // fragment for a module unit. The global module fragment can be used to

  // provide declarations that are attached to the global module and usable

  // within the module unit.

  //

  // So the declations in the global module shouldn't be visible by default.

  TU->setModuleOwnershipKind(Decl::ModuleOwnershipKind::ReachableWhenImported);

  TU->setLocalOwningModule(GlobalModule);

  // FIXME: Consider creating an explicit representation of this declaration.

  return nullptr;

}

void Sema::HandleStartOfHeaderUnit() {

  assert(getLangOpts().CPlusPlusModules &&

         "Header units are only valid for C++20 modules");

  SourceLocation StartOfTU =

      SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());

  StringRef HUName = getLangOpts().CurrentModule;

  if (HUName.empty()) {

    HUName = SourceMgr.getFileEntryForID(SourceMgr.getMainFileID())->getName();

    const_cast<LangOptions &>(getLangOpts()).CurrentModule = HUName.str();

  }

  // TODO: Make the C++20 header lookup independent.

  // When the input is pre-processed source, we need a file ref to the original

  // file for the header map.

  auto F = SourceMgr.getFileManager().getFile(HUName);

  // For the sake of error recovery (if someone has moved the original header

  // after creating the pre-processed output) fall back to obtaining the file

  // ref for the input file, which must be present.

  if (!F)

    F = SourceMgr.getFileEntryForID(SourceMgr.getMainFileID());

  assert(F && "failed to find the header unit source?");

  Module::Header H{HUName.str(), HUName.str(), *F};

  auto &Map = PP.getHeaderSearchInfo().getModuleMap();

  Module *Mod = Map.createHeaderUnit(StartOfTU, HUName, H);

  assert(Mod && "module creation should not fail");

  ModuleScopes.push_back({}); // No GMF

  ModuleScopes.back().BeginLoc = StartOfTU;

  ModuleScopes.back().Module = Mod;

  ModuleScopes.back().ModuleInterface = true;

  ModuleScopes.back().IsPartition = false;

  VisibleModules.setVisible(Mod, StartOfTU);

  // From now on, we have an owning module for all declarations we see.

  // All of these are implicitly exported.

  auto *TU = Context.getTranslationUnitDecl();

  TU->setModuleOwnershipKind(Decl::ModuleOwnershipKind::Visible);

  TU->setLocalOwningModule(Mod);

}

Sema::DeclGroupPtrTy

Sema::ActOnModuleDecl(SourceLocation StartLoc, SourceLocation ModuleLoc,

                      ModuleDeclKind MDK, ModuleIdPath Path,

                      ModuleIdPath Partition, ModuleImportState &ImportState) {

  assert((getLangOpts().ModulesTS || getLangOpts().CPlusPlusModules) &&

         "should only have module decl in Modules TS or C++20");

  bool IsFirstDecl = ImportState == ModuleImportState::FirstDecl;

  bool SeenGMF = ImportState == ModuleImportState::GlobalFragment;

  // If any of the steps here fail, we count that as invalidating C++20

  // module state;

  ImportState = ModuleImportState::NotACXX20Module;

  bool IsPartition = !Partition.empty();

  if (IsPartition)

    switch (MDK) {

    case ModuleDeclKind::Implementation:

      MDK = ModuleDeclKind::PartitionImplementation;

      break;

    case ModuleDeclKind::Interface:

      MDK = ModuleDeclKind::PartitionInterface;

      break;

    default:

      llvm_unreachable("how did we get a partition type set?");

    }

  // A (non-partition) module implementation unit requires that we are not

  // compiling a module of any kind.  A partition implementation emits an

  // interface (and the AST for the implementation), which will subsequently

  // be consumed to emit a binary.

  // A module interface unit requires that we are not compiling a module map.

  switch (getLangOpts().getCompilingModule()) {

  case LangOptions::CMK_None:

    // It's OK to compile a module interface as a normal translation unit.

    break;

  case LangOptions::CMK_ModuleInterface:

    if (MDK != ModuleDeclKind::Implementation)

      break;

    // We were asked to compile a module interface unit but this is a module

    // implementation unit.

    Diag(ModuleLoc, diag::err_module_interface_implementation_mismatch)

      << FixItHint::CreateInsertion(ModuleLoc, "export ");

    MDK = ModuleDeclKind::Interface;

    break;

  case LangOptions::CMK_ModuleMap:

    Diag(ModuleLoc, diag::err_module_decl_in_module_map_module);

    return nullptr;

  case LangOptions::CMK_HeaderModule:

  case LangOptions::CMK_HeaderUnit:

    Diag(ModuleLoc, diag::err_module_decl_in_header_module);

    return nullptr;

  }

  assert(ModuleScopes.size() <= 1 && "expected to be at global module scope");

  // FIXME: Most of this work should be done by the preprocessor rather than

  // here, in order to support macro import.

  // Only one module-declaration is permitted per source file.

  if (!ModuleScopes.empty() &&

      
ModuleScopes.back().Module->isModulePurview()137
) {

    Diag(ModuleLoc, diag::err_module_redeclaration);

    Diag(VisibleModules.getImportLoc(ModuleScopes.back().Module),

         diag::note_prev_module_declaration);

    return nullptr;

  }

  // Find the global module fragment we're adopting into this module, if any.

  Module *GlobalModuleFragment = nullptr;

  if (!ModuleScopes.empty() &&

      
ModuleScopes.back().Module->Kind == Module::GlobalModuleFragment133
)

    GlobalModuleFragment = ModuleScopes.back().Module;

  assert((!getLangOpts().CPlusPlusModules || getLangOpts().ModulesTS ||

          SeenGMF == (bool)GlobalModuleFragment) &&

         "mismatched global module state");

  // In C++20, the module-declaration must be the first declaration if there

  // is no global module fragment.

  if (getLangOpts().CPlusPlusModules && 
!IsFirstDecl200
 && 
!SeenGMF59
) {

    Diag(ModuleLoc, diag::err_module_decl_not_at_start);

    SourceLocation BeginLoc =

        ModuleScopes.empty()

            ? SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID())

            : 
ModuleScopes.back().BeginLoc0
;

    if (BeginLoc.isValid()) {

      Diag(BeginLoc, diag::note_global_module_introducer_missing)

          << FixItHint::CreateInsertion(BeginLoc, "module;\n");

    }

  }

  // Flatten the dots in a module name. Unlike Clang's hierarchical module map

  // modules, the dots here are just another character that can appear in a

  // module name.

  std::string ModuleName = stringFromPath(Path);

  if (IsPartition) {

    ModuleName += ":";

    ModuleName += stringFromPath(Partition);

  }

  // If a module name was explicitly specified on the command line, it must be

  // correct.

  if (!getLangOpts().CurrentModule.empty() &&

      
getLangOpts().CurrentModule != ModuleName0
) {

    Diag(Path.front().second, diag::err_current_module_name_mismatch)

        << SourceRange(Path.front().second, IsPartition

                                                ? Partition.back().second

                                                : Path.back().second)

        << getLangOpts().CurrentModule;

    return nullptr;

  }

  const_cast<LangOptions&>(getLangOpts()).CurrentModule = ModuleName;

  auto &Map = PP.getHeaderSearchInfo().getModuleMap();

  Module *Mod;

  switch (MDK) {

  case ModuleDeclKind::Interface:

  case ModuleDeclKind::PartitionInterface: {

    // We can't have parsed or imported a definition of this module or parsed a

    // module map defining it already.

    if (auto *M = Map.findModule(ModuleName)) {

      Diag(Path[0].second, diag::err_module_redefinition) << ModuleName;

      if (M->DefinitionLoc.isValid())

        Diag(M->DefinitionLoc, diag::note_prev_module_definition);

      else if (Optional<FileEntryRef> FE = M->getASTFile())

        Diag(M->DefinitionLoc, diag::note_prev_module_definition_from_ast_file)

            << FE->getName();

      Mod = M;

      break;

    }

    // Create a Module for the module that we're defining.

    Mod = Map.createModuleForInterfaceUnit(ModuleLoc, ModuleName,

                                           GlobalModuleFragment);

    if (MDK == ModuleDeclKind::PartitionInterface)

      Mod->Kind = Module::ModulePartitionInterface;

    assert(Mod && "module creation should not fail");

    break;

  }

  case ModuleDeclKind::Implementation: {

    std::pair<IdentifierInfo *, SourceLocation> ModuleNameLoc(

        PP.getIdentifierInfo(ModuleName), Path[0].second);

    // C++20 A module-declaration that contains neither an export-

    // keyword nor a module-partition implicitly imports the primary

    // module interface unit of the module as if by a module-import-

    // declaration.

    Mod = getModuleLoader().loadModule(ModuleLoc, {ModuleNameLoc},

                                       Module::AllVisible,

                                       /*IsInclusionDirective=*/false);

    if (!Mod) {

      Diag(ModuleLoc, diag::err_module_not_defined) << ModuleName;

      // Create an empty module interface unit for error recovery.

      Mod = Map.createModuleForInterfaceUnit(ModuleLoc, ModuleName,

                                             GlobalModuleFragment);

    }

  } break;

  case ModuleDeclKind::PartitionImplementation:

    // Create an interface, but note that it is an implementation

    // unit.

    Mod = Map.createModuleForInterfaceUnit(ModuleLoc, ModuleName,

                                           GlobalModuleFragment);

    Mod->Kind = Module::ModulePartitionImplementation;

    break;

  }

  if (!GlobalModuleFragment) {

    ModuleScopes.push_back({});

    if (getLangOpts().ModulesLocalVisibility)

      ModuleScopes.back().OuterVisibleModules = std::move(VisibleModules);

  } else {

    // We're done with the global module fragment now.

    ActOnEndOfTranslationUnitFragment(TUFragmentKind::Global);

  }

  // Switch from the global module fragment (if any) to the named module.

  ModuleScopes.back().BeginLoc = StartLoc;

  ModuleScopes.back().Module = Mod;

  ModuleScopes.back().ModuleInterface = MDK != ModuleDeclKind::Implementation;

  ModuleScopes.back().IsPartition = IsPartition;

  VisibleModules.setVisible(Mod, ModuleLoc);

  // From now on, we have an owning module for all declarations we see.

  // In C++20 modules, those declaration would be reachable when imported

  // unless explicitily exported.

  // Otherwise, those declarations are module-private unless explicitly

  // exported.

  auto *TU = Context.getTranslationUnitDecl();

  TU->setModuleOwnershipKind(Decl::ModuleOwnershipKind::ReachableWhenImported);

  TU->setLocalOwningModule(Mod);

  // We are in the module purview, but before any other (non import)

  // statements, so imports are allowed.

  ImportState = ModuleImportState::ImportAllowed;

  // FIXME: Create a ModuleDecl.

  return nullptr;

}

Sema::DeclGroupPtrTy

Sema::ActOnPrivateModuleFragmentDecl(SourceLocation ModuleLoc,

                                     SourceLocation PrivateLoc) {

  // C++20 [basic.link]/2:

  //   A private-module-fragment shall appear only in a primary module

  //   interface unit.

  switch (ModuleScopes.empty() ? 
Module::GlobalModuleFragment1

                               : 
ModuleScopes.back().Module->Kind18
) {

  case Module::ModuleMapModule:

  case Module::GlobalModuleFragment:

  case Module::ModulePartitionImplementation:

  case Module::ModulePartitionInterface:

  case Module::ModuleHeaderUnit:

    Diag(PrivateLoc, diag::err_private_module_fragment_not_module);

    return nullptr;

  case Module::PrivateModuleFragment:

    Diag(PrivateLoc, diag::err_private_module_fragment_redefined);

    Diag(ModuleScopes.back().BeginLoc, diag::note_previous_definition);

    return nullptr;

  case Module::ModuleInterfaceUnit:

    break;

  }

  if (!ModuleScopes.back().ModuleInterface) {

    Diag(PrivateLoc, diag::err_private_module_fragment_not_module_interface);

    Diag(ModuleScopes.back().BeginLoc,

         diag::note_not_module_interface_add_export)

        << FixItHint::CreateInsertion(ModuleScopes.back().BeginLoc, "export ");

    return nullptr;

  }

  // FIXME: Check this isn't a module interface partition.

  // FIXME: Check that this translation unit does not import any partitions;

  // such imports would violate [basic.link]/2's "shall be the only module unit"

  // restriction.

  // We've finished the public fragment of the translation unit.

  ActOnEndOfTranslationUnitFragment(TUFragmentKind::Normal);

  auto &Map = PP.getHeaderSearchInfo().getModuleMap();

  Module *PrivateModuleFragment =

      Map.createPrivateModuleFragmentForInterfaceUnit(

          ModuleScopes.back().Module, PrivateLoc);

  assert(PrivateModuleFragment && "module creation should not fail");

  // Enter the scope of the private module fragment.

  ModuleScopes.push_back({});

  ModuleScopes.back().BeginLoc = ModuleLoc;

  ModuleScopes.back().Module = PrivateModuleFragment;

  ModuleScopes.back().ModuleInterface = true;

  VisibleModules.setVisible(PrivateModuleFragment, ModuleLoc);

  // All declarations created from now on are scoped to the private module

  // fragment (and are neither visible nor reachable in importers of the module

  // interface).

  auto *TU = Context.getTranslationUnitDecl();

  TU->setModuleOwnershipKind(Decl::ModuleOwnershipKind::ModulePrivate);

  TU->setLocalOwningModule(PrivateModuleFragment);

  // FIXME: Consider creating an explicit representation of this declaration.

  return nullptr;

}

DeclResult Sema::ActOnModuleImport(SourceLocation StartLoc,

                                   SourceLocation ExportLoc,

                                   SourceLocation ImportLoc, ModuleIdPath Path,

                                   bool IsPartition) {

  bool Cxx20Mode = getLangOpts().CPlusPlusModules || 
getLangOpts().ModulesTS1.73k
;

  assert((!IsPartition || Cxx20Mode) && "partition seen in non-C++20 code?");

  // For a C++20 module name, flatten into a single identifier with the source

  // location of the first component.

  std::pair<IdentifierInfo *, SourceLocation> ModuleNameLoc;

  std::string ModuleName;

  if (IsPartition) {

    // We already checked that we are in a module purview in the parser.

    assert(!ModuleScopes.empty() && "in a module purview, but no module?");

    Module *NamedMod = ModuleScopes.back().Module;

    // If we are importing into a partition, find the owning named module,

    // otherwise, the name of the importing named module.

    ModuleName = NamedMod->getPrimaryModuleInterfaceName().str();

    ModuleName += ":";

    ModuleName += stringFromPath(Path);

    ModuleNameLoc = {PP.getIdentifierInfo(ModuleName), Path[0].second};

    Path = ModuleIdPath(ModuleNameLoc);

  } else if (Cxx20Mode) {

    ModuleName = stringFromPath(Path);

    ModuleNameLoc = {PP.getIdentifierInfo(ModuleName), Path[0].second};

    Path = ModuleIdPath(ModuleNameLoc);

  }

  // Diagnose self-import before attempting a load.

  // [module.import]/9

  // A module implementation unit of a module M that is not a module partition

  // shall not contain a module-import-declaration nominating M.

  // (for an implementation, the module interface is imported implicitly,

  //  but that's handled in the module decl code).

  if (getLangOpts().CPlusPlusModules && 
isCurrentModulePurview()99
 &&

      
getCurrentModule()->Name == ModuleName63
) {

    Diag(ImportLoc, diag::err_module_self_import_cxx20)

        << ModuleName << !ModuleScopes.back().ModuleInterface;

    return true;

  }

  Module *Mod = getModuleLoader().loadModule(

      ImportLoc, Path, Module::AllVisible, /*IsInclusionDirective=*/false);

  if (!Mod)

    return true;

  return ActOnModuleImport(StartLoc, ExportLoc, ImportLoc, Mod, Path);

}

/// Determine whether \p D is lexically within an export-declaration.

static const ExportDecl *getEnclosingExportDecl(const Decl *D) {

  for (auto *DC = D->getLexicalDeclContext(); DC; 
DC = DC->getLexicalParent()330
)

    if (auto *ED = dyn_cast<ExportDecl>(DC))

      return ED;

  return nullptr;

}

DeclResult Sema::ActOnModuleImport(SourceLocation StartLoc,

                                   SourceLocation ExportLoc,

                                   SourceLocation ImportLoc, Module *Mod,

                                   ModuleIdPath Path) {

  VisibleModules.setVisible(Mod, ImportLoc);

  checkModuleImportContext(*this, Mod, ImportLoc, CurContext);

  // FIXME: we should support importing a submodule within a different submodule

  // of the same top-level module. Until we do, make it an error rather than

  // silently ignoring the import.

  // FIXME: Should we warn on a redundant import of the current module?

  if (Mod->getTopLevelModuleName() == getLangOpts().CurrentModule &&

      
(10
getLangOpts().isCompilingModule()10
 || 
!getLangOpts().ModulesTS9
)) {

    Diag(ImportLoc, getLangOpts().isCompilingModule()

                        ? 
diag::err_module_self_import1

                        : 
diag::err_module_import_in_implementation3
)

        << Mod->getFullModuleName() << getLangOpts().CurrentModule;

  }

  SmallVector<SourceLocation, 2> IdentifierLocs;

  if (Path.empty()) {

    // If this was a header import, pad out with dummy locations.

    // FIXME: Pass in and use the location of the header-name token in this

    // case.

    for (Module *ModCheck = Mod; ModCheck; 
ModCheck = ModCheck->Parent30
)

      IdentifierLocs.push_back(SourceLocation());

  } else if (getLangOpts().CPlusPlusModules && 
!Mod->Parent92
) {

    // A single identifier for the whole name.

    IdentifierLocs.push_back(Path[0].second);

  } else {

    Module *ModCheck = Mod;

    for (unsigned I = 0, N = Path.size(); I != N; 
++I1.79k
) {

      // If we've run out of module parents, just drop the remaining

      // identifiers.  We need the length to be consistent.

      if (!ModCheck)

        break;

      ModCheck = ModCheck->Parent;

      IdentifierLocs.push_back(Path[I].second);

    }

  }

  ImportDecl *Import = ImportDecl::Create(Context, CurContext, StartLoc,

                                          Mod, IdentifierLocs);

  CurContext->addDecl(Import);

  // Sequence initialization of the imported module before that of the current

  // module, if any.

  if (!ModuleScopes.empty())

    Context.addModuleInitializer(ModuleScopes.back().Module, Import);

  // A module (partition) implementation unit shall not be exported.

  if (getLangOpts().CPlusPlusModules && 
ExportLoc.isValid()120
 &&

      
Mod->Kind == Module::ModuleKind::ModulePartitionImplementation19
) {

    Diag(ExportLoc, diag::err_export_partition_impl)

        << SourceRange(ExportLoc, Path.back().second);

  } else if (!ModuleScopes.empty() &&

             
(306
ModuleScopes.back().ModuleInterface306
 ||

              
(222
getLangOpts().CPlusPlusModules222
 &&

               
ModuleScopes.back().Module->isGlobalModule()11
))) {

    assert((!ModuleScopes.back().Module->isGlobalModule() ||

            Mod->Kind == Module::ModuleKind::ModuleHeaderUnit) &&

           "should only be importing a header unit into the GMF");

    // Re-export the module if the imported module is exported.

    // Note that we don't need to add re-exported module to Imports field

    // since `Exports` implies the module is imported already.

    if (ExportLoc.isValid() || 
getEnclosingExportDecl(Import)76
)

      getCurrentModule()->Exports.emplace_back(Mod, false);

    else

      getCurrentModule()->Imports.insert(Mod);

  } else if (ExportLoc.isValid()) {

    // [module.interface]p1:

    // An export-declaration shall inhabit a namespace scope and appear in the

    // purview of a module interface unit.

    Diag(ExportLoc, diag::err_export_not_in_module_interface)

        << (!ModuleScopes.empty() &&

            
!ModuleScopes.back().ImplicitGlobalModuleFragment1
);

  } else if (getLangOpts().isCompilingModule()) {

    Module *ThisModule = PP.getHeaderSearchInfo().lookupModule(

        getLangOpts().CurrentModule, ExportLoc, false, false);

    (void)ThisModule;

    assert(ThisModule && "was expecting a module if building one");

  }

  // In some cases we need to know if an entity was present in a directly-

  // imported module (as opposed to a transitive import).  This avoids

  // searching both Imports and Exports.

  DirectModuleImports.insert(Mod);

  return Import;

}

void Sema::ActOnModuleInclude(SourceLocation DirectiveLoc, Module *Mod) {

  checkModuleImportContext(*this, Mod, DirectiveLoc, CurContext, true);

  BuildModuleInclude(DirectiveLoc, Mod);

}

void Sema::BuildModuleInclude(SourceLocation DirectiveLoc, Module *Mod) {

  // Determine whether we're in the #include buffer for a module. The #includes

  // in that buffer do not qualify as module imports; they're just an

  // implementation detail of us building the module.

  //

  // FIXME: Should we even get ActOnModuleInclude calls for those?

  bool IsInModuleIncludes =

      TUKind == TU_Module &&

      
getSourceManager().isWrittenInMainFile(DirectiveLoc)140k
;

  bool ShouldAddImport = !IsInModuleIncludes;

  // If this module import was due to an inclusion directive, create an

  // implicit import declaration to capture it in the AST.

  if (ShouldAddImport) {

    TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl();

    ImportDecl *ImportD = ImportDecl::CreateImplicit(getASTContext(), TU,

                                                     DirectiveLoc, Mod,

                                                     DirectiveLoc);

    if (!ModuleScopes.empty())

      Context.addModuleInitializer(ModuleScopes.back().Module, ImportD);

    TU->addDecl(ImportD);

    Consumer.HandleImplicitImportDecl(ImportD);

  }

  getModuleLoader().makeModuleVisible(Mod, Module::AllVisible, DirectiveLoc);

  VisibleModules.setVisible(Mod, DirectiveLoc);

  if (getLangOpts().isCompilingModule()) {

    Module *ThisModule = PP.getHeaderSearchInfo().lookupModule(

        getLangOpts().CurrentModule, DirectiveLoc, false, false);

    (void)ThisModule;

    assert(ThisModule && "was expecting a module if building one");

  }

}

void Sema::ActOnModuleBegin(SourceLocation DirectiveLoc, Module *Mod) {

  checkModuleImportContext(*this, Mod, DirectiveLoc, CurContext, true);

  ModuleScopes.push_back({});

  ModuleScopes.back().Module = Mod;

  if (getLangOpts().ModulesLocalVisibility)

    ModuleScopes.back().OuterVisibleModules = std::move(VisibleModules);

  VisibleModules.setVisible(Mod, DirectiveLoc);

  // The enclosing context is now part of this module.

  // FIXME: Consider creating a child DeclContext to hold the entities

  // lexically within the module.

  if (getLangOpts().trackLocalOwningModule()) {

    for (auto *DC = CurContext; DC; 
DC = DC->getLexicalParent()143k
) {

      cast<Decl>(DC)->setModuleOwnershipKind(

          getLangOpts().ModulesLocalVisibility

              ? 
Decl::ModuleOwnershipKind::VisibleWhenImported2.32k

              : 
Decl::ModuleOwnershipKind::Visible141k
);

      cast<Decl>(DC)->setLocalOwningModule(Mod);

    }

  }

}

void Sema::ActOnModuleEnd(SourceLocation EomLoc, Module *Mod) {

  if (getLangOpts().ModulesLocalVisibility) {

    VisibleModules = std::move(ModuleScopes.back().OuterVisibleModules);

    // Leaving a module hides namespace names, so our visible namespace cache

    // is now out of date.

    VisibleNamespaceCache.clear();

  }

  assert(!ModuleScopes.empty() && ModuleScopes.back().Module == Mod &&

         "left the wrong module scope");

  ModuleScopes.pop_back();

  // We got to the end of processing a local module. Create an

  // ImportDecl as we would for an imported module.

  FileID File = getSourceManager().getFileID(EomLoc);

  SourceLocation DirectiveLoc;

  if (EomLoc == getSourceManager().getLocForEndOfFile(File)) {

    // We reached the end of a #included module header. Use the #include loc.

    assert(File != getSourceManager().getMainFileID() &&

           "end of submodule in main source file");

    DirectiveLoc = getSourceManager().getIncludeLoc(File);

  } else {

    // We reached an EOM pragma. Use the pragma location.

    DirectiveLoc = EomLoc;

  }

  BuildModuleInclude(DirectiveLoc, Mod);

  // Any further declarations are in whatever module we returned to.

  if (getLangOpts().trackLocalOwningModule()) {

    // The parser guarantees that this is the same context that we entered

    // the module within.

    for (auto *DC = CurContext; DC; 
DC = DC->getLexicalParent()143k
) {

      cast<Decl>(DC)->setLocalOwningModule(getCurrentModule());

      if (!getCurrentModule())

        cast<Decl>(DC)->setModuleOwnershipKind(

            Decl::ModuleOwnershipKind::Unowned);

    }

  }

}

void Sema::createImplicitModuleImportForErrorRecovery(SourceLocation Loc,

                                                      Module *Mod) {

  // Bail if we're not allowed to implicitly import a module here.

  if (isSFINAEContext() || !getLangOpts().ModulesErrorRecovery ||

      
VisibleModules.isVisible(Mod)88
)

    return;

  // Create the implicit import declaration.

  TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl();

  ImportDecl *ImportD = ImportDecl::CreateImplicit(getASTContext(), TU,

                                                   Loc, Mod, Loc);

  TU->addDecl(ImportD);

  Consumer.HandleImplicitImportDecl(ImportD);

  // Make the module visible.

  getModuleLoader().makeModuleVisible(Mod, Module::AllVisible, Loc);

  VisibleModules.setVisible(Mod, Loc);

}

/// We have parsed the start of an export declaration, including the '{'

/// (if present).

Decl *Sema::ActOnStartExportDecl(Scope *S, SourceLocation ExportLoc,

                                 SourceLocation LBraceLoc) {

  ExportDecl *D = ExportDecl::Create(Context, CurContext, ExportLoc);

  // Set this temporarily so we know the export-declaration was braced.

  D->setRBraceLoc(LBraceLoc);

  CurContext->addDecl(D);

  PushDeclContext(S, D);

  // C++2a [module.interface]p1:

  //   An export-declaration shall appear only [...] in the purview of a module

  //   interface unit. An export-declaration shall not appear directly or

  //   indirectly within [...] a private-module-fragment.

  if (ModuleScopes.empty() || 
!ModuleScopes.back().Module->isModulePurview()247
) {

    Diag(ExportLoc, diag::err_export_not_in_module_interface) << 0;

    D->setInvalidDecl();

    return D;

  } else if (!ModuleScopes.back().ModuleInterface) {

    Diag(ExportLoc, diag::err_export_not_in_module_interface) << 1;

    Diag(ModuleScopes.back().BeginLoc,

         diag::note_not_module_interface_add_export)

        << FixItHint::CreateInsertion(ModuleScopes.back().BeginLoc, "export ");

    D->setInvalidDecl();

    return D;

  } else if (ModuleScopes.back().Module->Kind ==

             Module::PrivateModuleFragment) {

    Diag(ExportLoc, diag::err_export_in_private_module_fragment);

    Diag(ModuleScopes.back().BeginLoc, diag::note_private_module_fragment);

    D->setInvalidDecl();

    return D;

  }

  
for (const DeclContext *DC = CurContext; 237
DC; 
DC = DC->getLexicalParent()488
) {

    if (const auto *ND = dyn_cast<NamespaceDecl>(DC)) {

      //   An export-declaration shall not appear directly or indirectly within

      //   an unnamed namespace [...]

      if (ND->isAnonymousNamespace()) {

        Diag(ExportLoc, diag::err_export_within_anonymous_namespace);

        Diag(ND->getLocation(), diag::note_anonymous_namespace);

        // Don't diagnose internal-linkage declarations in this region.

        D->setInvalidDecl();

        return D;

      }

      //   A declaration is exported if it is [...] a namespace-definition

      //   that contains an exported declaration.

      //

      // Defer exporting the namespace until after we leave it, in order to

      // avoid marking all subsequent declarations in the namespace as exported.

      if (!DeferredExportedNamespaces.insert(ND).second)

        break;

    }

  }

  //   [...] its declaration or declaration-seq shall not contain an

  //   export-declaration.

  if (auto *ED = getEnclosingExportDecl(D)) {

    Diag(ExportLoc, diag::err_export_within_export);

    if (ED->hasBraces())

      Diag(ED->getLocation(), diag::note_export);

    D->setInvalidDecl();

    return D;

  }

  D->setModuleOwnershipKind(Decl::ModuleOwnershipKind::VisibleWhenImported);

  return D;

}

static bool checkExportedDeclContext(Sema &S, DeclContext *DC,

                                     SourceLocation BlockStart);

namespace {

enum class UnnamedDeclKind {

  Empty,

  StaticAssert,

  Asm,

  UsingDirective,

  Namespace,

  Context

};

}

static llvm::Optional<UnnamedDeclKind> getUnnamedDeclKind(Decl *D) {

  if (isa<EmptyDecl>(D))

    return UnnamedDeclKind::Empty;

  if (isa<StaticAssertDecl>(D))

    return UnnamedDeclKind::StaticAssert;

  if (isa<FileScopeAsmDecl>(D))

    return UnnamedDeclKind::Asm;

  if (isa<UsingDirectiveDecl>(D))

    return UnnamedDeclKind::UsingDirective;

  // Everything else either introduces one or more names or is ill-formed.

  return llvm::None;

}

unsigned getUnnamedDeclDiag(UnnamedDeclKind UDK, bool InBlock) {

  switch (UDK) {

  case UnnamedDeclKind::Empty:

  case UnnamedDeclKind::StaticAssert:

    // Allow empty-declarations and static_asserts in an export block as an

    // extension.

    return InBlock ? 
diag::ext_export_no_name_block4
 : 
diag::err_export_no_name5
;

  case UnnamedDeclKind::UsingDirective:

    // Allow exporting using-directives as an extension.

    return diag::ext_export_using_directive;

  case UnnamedDeclKind::Namespace:

    // Anonymous namespace with no content.

    return diag::introduces_no_names;

  case UnnamedDeclKind::Context:

    // Allow exporting DeclContexts that transitively contain no declarations

    // as an extension.

    return diag::ext_export_no_names;

  case UnnamedDeclKind::Asm:

    return diag::err_export_no_name;

  }

  llvm_unreachable("unknown kind");

}

static void diagExportedUnnamedDecl(Sema &S, UnnamedDeclKind UDK, Decl *D,

                                    SourceLocation BlockStart) {

  S.Diag(D->getLocation(), getUnnamedDeclDiag(UDK, BlockStart.isValid()))

      << (unsigned)UDK;

  if (BlockStart.isValid())

    S.Diag(BlockStart, diag::note_export);

}

/// Check that it's valid to export \p D.

static bool checkExportedDecl(Sema &S, Decl *D, SourceLocation BlockStart) {

  // C++2a [module.interface]p3:

  //   An exported declaration shall declare at least one name

  if (auto UDK = getUnnamedDeclKind(D))

    diagExportedUnnamedDecl(S, *UDK, D, BlockStart);

  //   [...] shall not declare a name with internal linkage.

  bool HasName = false;

  if (auto *ND = dyn_cast<NamedDecl>(D)) {

    // Don't diagnose anonymous union objects; we'll diagnose their members

    // instead.

    HasName = (bool)ND->getDeclName();

    if (HasName && 
ND->getFormalLinkage() == InternalLinkage362
) {

      S.Diag(ND->getLocation(), diag::err_export_internal) << ND;

      if (BlockStart.isValid())

        S.Diag(BlockStart, diag::note_export);

    }

  }

  // C++2a [module.interface]p5:

  //   all entities to which all of the using-declarators ultimately refer

  //   shall have been introduced with a name having external linkage

  if (auto *USD = dyn_cast<UsingShadowDecl>(D)) {

    NamedDecl *Target = USD->getUnderlyingDecl();

    Linkage Lk = Target->getFormalLinkage();

    if (Lk == InternalLinkage || 
Lk == ModuleLinkage29
) {

      S.Diag(USD->getLocation(), diag::err_export_using_internal)

          << (Lk == InternalLinkage ? 
020
 : 
112
) << Target;

      S.Diag(Target->getLocation(), diag::note_using_decl_target);

      if (BlockStart.isValid())

        S.Diag(BlockStart, diag::note_export);

    }

  }

  // Recurse into namespace-scope DeclContexts. (Only namespace-scope

  // declarations are exported.).

  if (auto *DC = dyn_cast<DeclContext>(D)) {

    if (isa<NamespaceDecl>(D) && 
DC->decls().empty()22
) {

      if (!HasName)

        // We don't allow an empty anonymous namespace (we don't allow decls

        // in them either, but that's handled in the recursion).

        diagExportedUnnamedDecl(S, UnnamedDeclKind::Namespace, D, BlockStart);

      // We allow an empty named namespace decl.

    } else if (DC->getRedeclContext()->isFileContext() && 
!isa<EnumDecl>(D)33
)

      return checkExportedDeclContext(S, DC, BlockStart);

  }

  return false;

}

/// Check that it's valid to export all the declarations in \p DC.

static bool checkExportedDeclContext(Sema &S, DeclContext *DC,

                                     SourceLocation BlockStart) {

  bool AllUnnamed = true;

  for (auto *D : DC->decls())

    AllUnnamed &= checkExportedDecl(S, D, BlockStart);

  return AllUnnamed;

}

/// Complete the definition of an export declaration.

Decl *Sema::ActOnFinishExportDecl(Scope *S, Decl *D, SourceLocation RBraceLoc) {

  auto *ED = cast<ExportDecl>(D);

  if (RBraceLoc.isValid())

    ED->setRBraceLoc(RBraceLoc);

  PopDeclContext();

  if (!D->isInvalidDecl()) {

    SourceLocation BlockStart =

        ED->hasBraces() ? 
ED->getBeginLoc()22
 : 
SourceLocation()208
;

    for (auto *Child : ED->decls()) {

      if (checkExportedDecl(*this, Child, BlockStart)) {

        // If a top-level child is a linkage-spec declaration, it might contain

        // no declarations (transitively), in which case it's ill-formed.

        diagExportedUnnamedDecl(*this, UnnamedDeclKind::Context, Child,

                                BlockStart);

      }

    }

  }

  return D;

}

Module *Sema::PushGlobalModuleFragment(SourceLocation BeginLoc,

                                       bool IsImplicit) {

  // We shouldn't create new global module fragment if there is already

  // one.

  if (!GlobalModuleFragment) {

    ModuleMap &Map = PP.getHeaderSearchInfo().getModuleMap();

    GlobalModuleFragment = Map.createGlobalModuleFragmentForModuleUnit(

        BeginLoc, getCurrentModule());

  }

  assert(GlobalModuleFragment && "module creation should not fail");

  // Enter the scope of the global module.

  ModuleScopes.push_back({BeginLoc, GlobalModuleFragment,

                          /*ModuleInterface=*/false,

                          /*IsPartition=*/false,

                          /*ImplicitGlobalModuleFragment=*/IsImplicit,

                          /*OuterVisibleModules=*/{}});

  VisibleModules.setVisible(GlobalModuleFragment, BeginLoc);

  return GlobalModuleFragment;

}

void Sema::PopGlobalModuleFragment() {

  assert(!ModuleScopes.empty() && getCurrentModule()->isGlobalModule() &&

         "left the wrong module scope, which is not global module fragment");

  ModuleScopes.pop_back();

}

bool Sema::isModuleUnitOfCurrentTU(const Module *M) const {

  assert(M);

  Module *CurrentModuleUnit = getCurrentModule();

  // If we are not in a module currently, M must not be the module unit of

  // current TU.

  if (!CurrentModuleUnit)

    return false;

  return M->isSubModuleOf(CurrentModuleUnit->getTopLevelModule());

}