[C++20] [Modules] [NFC] Add Preprocessor methods for named modules - for ClangScanDeps (1/4)

[ChuanqiXu]

Summary

This patch prepares the necessary interfaces in the preprocessor part for D137527 since we need to recognize if we're in a module unit, the module kinds and the module declaration and the module we're importing in the preprocessor.

[ChuanqiXu]

Format codes.

[ChuanqiXu]

clang/include/clang/Lex/Preprocessor.h

321–322

This is needed since in fact we use @import in objective-c++ mode. See the test for example.

[jansvoboda11]

I'm not familiar with standard C++ modules. @Bigcheese any thoughts?

clang/include/clang/Lex/Preprocessor.h

2372

Preprocessor::isNamedModule() is bit misleading. How about Preprocessor::isInNamedModule()? Similar for other Preprocessor::is*() functions this patch introduces.

[ChuanqiXu]

Address comments.

[ChuanqiXu]

Replace llvm::Optional with std::optional

[thakis]

clang/unittests/Lex/CMakeLists.txt

21

It seems strange layering-wise that the Lex unit tests would depend on Frontend. Is there any way to prevent that dep?

[nikic]

It looks like this causes a minor compile-time regression (about 0.2% on O0 builds): http://llvm-compile-time-tracker.com/compare.php?from=ad81d019a62d33e5d1f232844b83d3e164e4b160&to=6470706bc0ed2425704bc8c9e121a72e2d272616&stat=instructions:u

I wanted to check whether this is expected (as I don't think CTMark even compiles anything in C++20 mode).

[ChuanqiXu]

In D137526#4125578, @nikic wrote:

It looks like this causes a minor compile-time regression (about 0.2% on O0 builds): http://llvm-compile-time-tracker.com/compare.php?from=ad81d019a62d33e5d1f232844b83d3e164e4b160&to=6470706bc0ed2425704bc8c9e121a72e2d272616&stat=instructions:u

I wanted to check whether this is expected (as I don't think CTMark even compiles anything in C++20 mode).

This is strange since all the codes would only work if there is an import. And I didn't introduce any loops so it shouldn't cause compile-time regression.

clang/unittests/Lex/CMakeLists.txt

21

I see. I'll try to look at it.

[ChuanqiXu]

clang/unittests/Lex/CMakeLists.txt

21

I've addressed this in https://github.com/llvm/llvm-project/commit/54cf24dc6e6317f7a77f8a320f1fbccc31ea7291.

clang/include/clang/Lex/Preprocessor.h

private:
 
   /// The source location of the \c import contextual keyword we just
   /// lexed, if any.
   SourceLocation ModuleImportLoc;
 
   /// The import path for named module that we're currently processing.
   SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> NamedModuleImportPath;
 
+  /// Whether the import is an `@import` or a standard c++ modules import.
+  bool IsAtImport = false;
+
   /// Whether the last token we lexed was an '@'.
   bool LastTokenWasAt = false;
 
   /// A position within a C++20 import-seq.
   class StdCXXImportSeq {
   public:
     enum State : int {
       // Positive values represent a number of unclosed brackets.
private:
   private:
     /// Track the transitions into and out of a Global Module Fragment,
     /// if one is present.
     GMFState S;
   };
 
   TrackGMF TrackGMFState = TrackGMF::BeforeGMFIntroducer;
 
+  /// Track the status of the c++20 module decl.
+  ///
+  ///   module-declaration:
+  ///     'export'[opt] 'module' module-name module-partition[opt]
+  ///     attribute-specifier-seq[opt] ';'
+  ///
+  ///   module-name:
+  ///     module-name-qualifier[opt] identifier
+  ///
+  ///   module-partition:
+  ///     ':' module-name-qualifier[opt] identifier
+  ///
+  ///   module-name-qualifier:
+  ///     identifier '.'
+  ///     module-name-qualifier identifier '.'
+  ///
+  /// Transition state:
+  ///
+  ///   NotAModuleDecl --- export ---> FoundExport
+  ///   NotAModuleDecl --- module ---> ImplementationCandidate
+  ///   FoundExport --- module ---> InterfaceCandidate
+  ///   ImplementationCandidate --- Identifier ---> ImplementationCandidate
+  ///   ImplementationCandidate --- period ---> ImplementationCandidate
+  ///   ImplementationCandidate --- colon ---> ImplementationCandidate
+  ///   InterfaceCandidate --- Identifier ---> InterfaceCandidate
+  ///   InterfaceCandidate --- period ---> InterfaceCandidate
+  ///   InterfaceCandidate --- colon ---> InterfaceCandidate
+  ///   ImplementationCandidate --- Semi ---> NamedModuleImplementation
+  ///   NamedModuleInterface --- Semi ---> NamedModuleInterface
+  ///   NamedModuleImplementation --- Anything ---> NamedModuleImplementation
+  ///   NamedModuleInterface --- Anything ---> NamedModuleInterface
+  ///
+  /// FIXME: We haven't handle attribute-specifier-seq here. It may not be bad
+  /// soon since we don't support any module attributes yet.
+  class ModuleDeclSeq {
+    enum ModuleDeclState : int {
+      NotAModuleDecl,
+      FoundExport,
+      InterfaceCandidate,
+      ImplementationCandidate,
+      NamedModuleInterface,
+      NamedModuleImplementation,
+    };
+
+  public:
+    ModuleDeclSeq() : State(NotAModuleDecl) {}
+
+    void handleExport() {
+      if (State == NotAModuleDecl)
+        State = FoundExport;
+      else if (!isNamedModule())
+        reset();
+    }
+
+    void handleModule() {
+      if (State == FoundExport)
+        State = InterfaceCandidate;
+      else if (State == NotAModuleDecl)
+        State = ImplementationCandidate;
+      else if (!isNamedModule())
+        reset();
+    }
+
+    void handleIdentifier(IdentifierInfo *Identifier) {
+      if (isModuleCandidate() && Identifier)
+        Name += Identifier->getName().str();
+      else if (!isNamedModule())
+        reset();
+    }
+
+    void handleColon() {
+      if (isModuleCandidate())
+        Name += ":";
+      else if (!isNamedModule())
+        reset();
+    }
+
+    void handlePeriod() {
+      if (isModuleCandidate())
+        Name += ".";
+      else if (!isNamedModule())
+        reset();
+    }
+
+    void handleSemi() {
+      if (!Name.empty() && isModuleCandidate()) {
+        if (State == InterfaceCandidate)
+          State = NamedModuleInterface;
+        else if (State == ImplementationCandidate)
+          State = NamedModuleImplementation;
+        else
+          llvm_unreachable("Unimaged ModuleDeclState.");
+      } else if (!isNamedModule())
+        reset();
+    }
+
+    void handleMisc() {
+      if (!isNamedModule())
+        reset();
+    }
+
+    bool isModuleCandidate() const {
+      return State == InterfaceCandidate || State == ImplementationCandidate;
+    }
+
+    bool isNamedModule() const {
+      return State == NamedModuleInterface ||
+             State == NamedModuleImplementation;
+    }
+
+    bool isNamedInterface() const { return State == NamedModuleInterface; }
+
+    bool isImplementationUnit() const {
+      return State == NamedModuleImplementation && !getName().contains(':');
+    }
+
+    StringRef getName() const {
+      assert(isNamedModule() && "Can't get name from a non named module");
+      return Name;
+    }
+
+    StringRef getPrimaryName() const {
+      assert(isNamedModule() && "Can't get name from a non named module");
+      return getName().split(':').first;
+    }
+
+    void reset() {
+      Name.clear();
+      State = NotAModuleDecl;
+    }
+
+  private:
+    ModuleDeclState State;
+    std::string Name;
+  };
+
+  ModuleDeclSeq ModuleDeclState;
+
   /// Whether the module import expects an identifier next. Otherwise,
   /// it expects a '.' or ';'.
   bool ModuleImportExpectsIdentifier = false;
 
   /// The identifier and source location of the currently-active
   /// \#pragma clang arc_cf_code_audited begin.
   std::pair<IdentifierInfo *, SourceLocation> PragmaARCCFCodeAuditedInfo;
 
public:
   }
 
   /// Retrieves the module that we're currently building, if any.
   Module *getCurrentModule();
 
   /// Retrieves the module whose implementation we're current compiling, if any.
   Module *getCurrentModuleImplementation();
 
+  /// If we are preprocessing a named module.
+  bool isNamedModule() const { return ModuleDeclState.isNamedModule(); }
+
+  /// If we are proprocessing a named interface unit.
+  /// Note that a module implementation partition is not considered as an
+  /// named interface unit here although it is importable
+  /// to ease the parsing.
+  bool isNamedInterfaceUnit() const {
+    return ModuleDeclState.isNamedInterface();
+  }
+
+  /// Get the named module name we're preprocessing.
+  /// Requires we're preprocessing a named module.
+  StringRef getNamedModuleName() const { return ModuleDeclState.getName(); }
+
+  /// If we are implementing an implementation module unit.
+  /// Note that the module implementation partition is not considered as an
+  /// implementation unit.
+  bool isImplementationUnit() const {
+    return ModuleDeclState.isImplementationUnit();
+  }
+
+  /// If we're importing a standard C++20 Named Modules.
+  bool isImportingCXXNamedModules() const {
+    // NamedModuleImportPath will be non-empty only if we're importing
+    // Standard C++ named modules.
+    return !NamedModuleImportPath.empty() && getLangOpts().CPlusPlusModules &&
+           !IsAtImport;
+  }
+
   /// Allocate a new MacroInfo object with the provided SourceLocation.
   MacroInfo *AllocateMacroInfo(SourceLocation L);
 
   /// Turn the specified lexer token into a fully checked and spelled
   /// filename, e.g. as an operand of \#include.
   ///
   /// The caller is expected to provide a buffer that is large enough to hold
   /// the spelling of the filename, but is also expected to handle the case

clang/lib/Lex/Preprocessor.cpp

bool Preprocessor::HandleIdentifier(Token &Identifier) {
   // Likewise if this is the C++ Modules TS import keyword.
   if (((LastTokenWasAt && II.isModulesImport()) ||
        Identifier.is(tok::kw_import)) &&
       !InMacroArgs && !DisableMacroExpansion &&
       (getLangOpts().Modules || getLangOpts().DebuggerSupport) &&
       CurLexerKind != CLK_CachingLexer) {
     ModuleImportLoc = Identifier.getLocation();
     NamedModuleImportPath.clear();
+    IsAtImport = true;
     ModuleImportExpectsIdentifier = true;
     CurLexerKind = CLK_LexAfterModuleImport;
   }
   return true;
 }
 
 void Preprocessor::Lex(Token &Result) {
   ++LexLevel;
case tok::r_brace:
       StdCXXImportSeqState.handleCloseBrace();
       break;
     // This token is injected to represent the translation of '#include "a.h"'
     // into "import a.h;". Mimic the notional ';'.
     case tok::annot_module_include:
     case tok::semi:
       TrackGMFState.handleSemi();
       StdCXXImportSeqState.handleSemi();
+      ModuleDeclState.handleSemi();
       break;
     case tok::header_name:
     case tok::annot_header_unit:
       StdCXXImportSeqState.handleHeaderName();
       break;
     case tok::kw_export:
       TrackGMFState.handleExport();
       StdCXXImportSeqState.handleExport();
+      ModuleDeclState.handleExport();
+      break;
+    case tok::colon:
+      ModuleDeclState.handleColon();
+      break;
+    case tok::period:
+      ModuleDeclState.handlePeriod();
       break;
     case tok::identifier:
       if (Result.getIdentifierInfo()->isModulesImport()) {
         TrackGMFState.handleImport(StdCXXImportSeqState.afterTopLevelSeq());
         StdCXXImportSeqState.handleImport();
         if (StdCXXImportSeqState.afterImportSeq()) {
           ModuleImportLoc = Result.getLocation();
           NamedModuleImportPath.clear();
+          IsAtImport = false;
           ModuleImportExpectsIdentifier = true;
           CurLexerKind = CLK_LexAfterModuleImport;
         }
         break;
       } else if (Result.getIdentifierInfo() == getIdentifierInfo("module")) {
         TrackGMFState.handleModule(StdCXXImportSeqState.afterTopLevelSeq());
+        ModuleDeclState.handleModule();
+        break;
+      } else {
+        ModuleDeclState.handleIdentifier(Result.getIdentifierInfo());
+        if (ModuleDeclState.isModuleCandidate())
           break;
       }
       [[fallthrough]];
     default:
       TrackGMFState.handleMisc();
       StdCXXImportSeqState.handleMisc();
+      ModuleDeclState.handleMisc();
       break;
     }
   }
 
   LastTokenWasAt = Result.is(tok::at);
   --LexLevel;
 
   if ((LexLevel == 0 || PreprocessToken) &&
bool Preprocessor::LexAfterModuleImport(Token &Result) {
   // a pp-import.
   //
   // For now, we only support header-name imports in C++20 mode.
   // FIXME: Should we allow this in all language modes that support an import
   // declaration as an extension?
   if (NamedModuleImportPath.empty() && getLangOpts().CPlusPlusModules) {
     if (LexHeaderName(Result))
       return true;
+
+    if (Result.is(tok::colon) && ModuleDeclState.isNamedModule()) {
+      std::string Name = ModuleDeclState.getPrimaryName().str();
+      Name += ":";
+      NamedModuleImportPath.push_back(
+          {getIdentifierInfo(Name), Result.getLocation()});
+      CurLexerKind = CLK_LexAfterModuleImport;
+      return true;
+    }
   } else {
     Lex(Result);
   }
 
   // Allocate a holding buffer for a sequence of tokens and introduce it into
   // the token stream.
   auto EnterTokens = [this](ArrayRef<Token> Toks) {
     auto ToksCopy = std::make_unique<Token[]>(Toks.size());
     std::copy(Toks.begin(), Toks.end(), ToksCopy.get());
     EnterTokenStream(std::move(ToksCopy), Toks.size(),
                      /*DisableMacroExpansion*/ true, /*IsReinject*/ false);
   };
 
+  bool ImportingHeader = Result.is(tok::header_name);
   // Check for a header-name.
   SmallVector<Token, 32> Suffix;
-  if (Result.is(tok::header_name)) {
+  if (ImportingHeader) {
     // Enter the header-name token into the token stream; a Lex action cannot
     // both return a token and cache tokens (doing so would corrupt the token
     // cache if the call to Lex comes from CachingLex / PeekAhead).
     Suffix.push_back(Result);
 
     // Consume the pp-import-suffix and expand any macros in it now. We'll add
     // it back into the token stream later.
     CollectPpImportSuffix(Suffix);
bool Preprocessor::LexAfterModuleImport(Token &Result) {
   //
   //   import identifier (. identifier)*
   //
   // indicates a module import directive. We already saw the 'import'
   // contextual keyword, so now we're looking for the identifiers.
   if (ModuleImportExpectsIdentifier && Result.getKind() == tok::identifier) {
     // We expected to see an identifier here, and we did; continue handling
     // identifiers.
-    NamedModuleImportPath.push_back(std::make_pair(Result.getIdentifierInfo(),
-                                              Result.getLocation()));
+    NamedModuleImportPath.push_back(
+        std::make_pair(Result.getIdentifierInfo(), Result.getLocation()));
     ModuleImportExpectsIdentifier = false;
     CurLexerKind = CLK_LexAfterModuleImport;
     return true;
   }
 
   // If we're expecting a '.' or a ';', and we got a '.', then wait until we
   // see the next identifier. (We can also see a '[[' that begins an
   // attribute-specifier-seq here under the C++ Modules TS.)
bool Preprocessor::LexAfterModuleImport(Token &Result) {
 
   // Under the Modules TS, the dot is just part of the module name, and not
   // a real hierarchy separator. Flatten such module names now.
   //
   // FIXME: Is this the right level to be performing this transformation?
   std::string FlatModuleName;
   if (getLangOpts().ModulesTS || getLangOpts().CPlusPlusModules) {
     for (auto &Piece : NamedModuleImportPath) {
-      if (!FlatModuleName.empty())
+      // If the FlatModuleName ends with colon, it implies it is a partition.
+      if (!FlatModuleName.empty() && FlatModuleName.back() != ':')
         FlatModuleName += ".";
       FlatModuleName += Piece.first->getName();
     }
     SourceLocation FirstPathLoc = NamedModuleImportPath[0].second;
     NamedModuleImportPath.clear();
     NamedModuleImportPath.push_back(
         std::make_pair(getIdentifierInfo(FlatModuleName), FirstPathLoc));
   }
 
   Module *Imported = nullptr;
-  if (getLangOpts().Modules) {
+  // We don't/shouldn't load the standard c++20 modules when preprocessing.
+  if (getLangOpts().Modules && !isImportingCXXNamedModules()) {
     Imported = TheModuleLoader.loadModule(ModuleImportLoc,
                                           NamedModuleImportPath,
                                           Module::Hidden,
                                           /*IsInclusionDirective=*/false);
     if (Imported)
       makeModuleVisible(Imported, SemiLoc);
   }
+
   if (Callbacks)
     Callbacks->moduleImport(ModuleImportLoc, NamedModuleImportPath, Imported);
 
   if (!Suffix.empty()) {
     EnterTokens(Suffix);
     return false;
   }
   return true;

clang/unittests/Lex/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Support
   )
 
 add_clang_unittest(LexTests
   DependencyDirectivesScannerTest.cpp
   HeaderMapTest.cpp
   HeaderSearchTest.cpp
   LexerTest.cpp
+  ModuleDeclStateTest.cpp
   PPCallbacksTest.cpp
   PPConditionalDirectiveRecordTest.cpp
   PPDependencyDirectivesTest.cpp
   PPMemoryAllocationsTest.cpp
   )
 
 clang_target_link_libraries(LexTests
   PRIVATE
   clangAST
   clangBasic
+  clangFrontend
   clangLex
   clangParse
   clangSema
   )
 
 target_link_libraries(LexTests
   PRIVATE
   LLVMTestingSupport
   )

clang/unittests/Lex/ModuleDeclStateTest.cpp

+//===- unittests/Lex/ModuleDeclStateTest.cpp - PPCallbacks tests ------===//
+//
+// 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 "clang/Basic/Diagnostic.h"
+#include "clang/Basic/DiagnosticOptions.h"
+#include "clang/Basic/FileManager.h"
+#include "clang/Basic/LangOptions.h"
+#include "clang/Basic/SourceManager.h"
+#include "clang/Basic/TargetInfo.h"
+#include "clang/Basic/TargetOptions.h"
+#include "clang/Frontend/CompilerInvocation.h"
+#include "clang/Lex/HeaderSearch.h"
+#include "clang/Lex/HeaderSearchOptions.h"
+#include "clang/Lex/ModuleLoader.h"
+#include "clang/Lex/Preprocessor.h"
+#include "clang/Lex/PreprocessorOptions.h"
+#include "gtest/gtest.h"
+#include <cstddef>
+#include <initializer_list>
+
+using namespace clang;
+
+namespace {
+
+class CheckNamedModuleImportingCB : public PPCallbacks {
+  Preprocessor &PP;
+  std::vector<bool> IsImportingNamedModulesAssertions;
+  std::size_t NextCheckingIndex;
+
+public:
+  CheckNamedModuleImportingCB(Preprocessor &PP,
+                              std::initializer_list<bool> lists)
+      : PP(PP), IsImportingNamedModulesAssertions(lists), NextCheckingIndex(0) {
+  }
+
+  void moduleImport(SourceLocation ImportLoc, ModuleIdPath Path,
+                    const Module *Imported) override {
+    ASSERT_TRUE(NextCheckingIndex < IsImportingNamedModulesAssertions.size());
+    EXPECT_EQ(PP.isImportingCXXNamedModules(),
+              IsImportingNamedModulesAssertions[NextCheckingIndex]);
+    NextCheckingIndex++;
+
+    ASSERT_EQ(Imported, nullptr);
+  }
+
+  // Currently, only the named module will be handled by `moduleImport`
+  // callback.
+  std::size_t importNamedModuleNum() { return NextCheckingIndex; }
+};
+class ModuleDeclStateTest : public ::testing::Test {
+protected:
+  ModuleDeclStateTest()
+      : FileMgr(FileMgrOpts), DiagID(new DiagnosticIDs()),
+        Diags(DiagID, new DiagnosticOptions, new IgnoringDiagConsumer()),
+        SourceMgr(Diags, FileMgr), TargetOpts(new TargetOptions), Invocation() {
+    TargetOpts->Triple = "x86_64-unknown-linux-gnu";
+    Target = TargetInfo::CreateTargetInfo(Diags, TargetOpts);
+  }
+
+  LangOptions &getLangOpts(ArrayRef<const char *> CommandLineArgs) {
+    CompilerInvocation::CreateFromArgs(Invocation, CommandLineArgs, Diags);
+    return *Invocation.getLangOpts();
+  }
+
+  std::unique_ptr<Preprocessor>
+  getPreprocessor(const char *source, ArrayRef<const char *> CommandLineArgs) {
+    std::unique_ptr<llvm::MemoryBuffer> Buf =
+        llvm::MemoryBuffer::getMemBuffer(source);
+    SourceMgr.setMainFileID(SourceMgr.createFileID(std::move(Buf)));
+
+    LangOptions &LangOpts = getLangOpts(CommandLineArgs);
+    HeaderInfo.emplace(std::make_shared<HeaderSearchOptions>(), SourceMgr,
+                       Diags, LangOpts, Target.get());
+
+    return std::make_unique<Preprocessor>(
+        std::make_shared<PreprocessorOptions>(), Diags, LangOpts, SourceMgr,
+        *HeaderInfo, ModLoader,
+        /*IILookup =*/nullptr,
+        /*OwnsHeaderSearch =*/false);
+  }
+
+  void preprocess(Preprocessor &PP, std::unique_ptr<PPCallbacks> C) {
+    PP.Initialize(*Target);
+    PP.addPPCallbacks(std::move(C));
+    PP.EnterMainSourceFile();
+
+    while (1) {
+      Token tok;
+      PP.Lex(tok);
+      if (tok.is(tok::eof))
+        break;
+    }
+  }
+
+  FileSystemOptions FileMgrOpts;
+  FileManager FileMgr;
+  IntrusiveRefCntPtr<DiagnosticIDs> DiagID;
+  DiagnosticsEngine Diags;
+  SourceManager SourceMgr;
+  std::shared_ptr<TargetOptions> TargetOpts;
+  IntrusiveRefCntPtr<TargetInfo> Target;
+  CompilerInvocation Invocation;
+  TrivialModuleLoader ModLoader;
+  llvm::Optional<HeaderSearch> HeaderInfo;
+};
+
+TEST_F(ModuleDeclStateTest, NamedModuleInterface) {
+  const char *source = R"(
+export module foo;
+  )";
+  std::unique_ptr<Preprocessor> PP = getPreprocessor(source, "-std=c++20");
+
+  std::initializer_list<bool> ImportKinds = {};
+  preprocess(*PP,
+             std::make_unique<CheckNamedModuleImportingCB>(*PP, ImportKinds));
+
+  auto *Callback =
+      static_cast<CheckNamedModuleImportingCB *>(PP->getPPCallbacks());
+  EXPECT_EQ(Callback->importNamedModuleNum(), 0);
+  EXPECT_TRUE(PP->isNamedModule());
+  EXPECT_TRUE(PP->isNamedInterfaceUnit());
+  EXPECT_FALSE(PP->isImplementationUnit());
+  EXPECT_EQ(PP->getNamedModuleName(), "foo");
+}
+
+TEST_F(ModuleDeclStateTest, NamedModuleImplementation) {
+  const char *source = R"(
+module foo;
+  )";
+  std::unique_ptr<Preprocessor> PP = getPreprocessor(source, "-std=c++20");
+
+  std::initializer_list<bool> ImportKinds = {};
+  preprocess(*PP,
+             std::make_unique<CheckNamedModuleImportingCB>(*PP, ImportKinds));
+
+  auto *Callback =
+      static_cast<CheckNamedModuleImportingCB *>(PP->getPPCallbacks());
+  EXPECT_EQ(Callback->importNamedModuleNum(), 0);
+  EXPECT_TRUE(PP->isNamedModule());
+  EXPECT_FALSE(PP->isNamedInterfaceUnit());
+  EXPECT_TRUE(PP->isImplementationUnit());
+  EXPECT_EQ(PP->getNamedModuleName(), "foo");
+}
+
+TEST_F(ModuleDeclStateTest, ModuleImplementationPartition) {
+  const char *source = R"(
+module foo:part;
+  )";
+  std::unique_ptr<Preprocessor> PP = getPreprocessor(source, "-std=c++20");
+
+  std::initializer_list<bool> ImportKinds = {};
+  preprocess(*PP,
+             std::make_unique<CheckNamedModuleImportingCB>(*PP, ImportKinds));
+
+  auto *Callback =
+      static_cast<CheckNamedModuleImportingCB *>(PP->getPPCallbacks());
+  EXPECT_EQ(Callback->importNamedModuleNum(), 0);
+  EXPECT_TRUE(PP->isNamedModule());
+  EXPECT_FALSE(PP->isNamedInterfaceUnit());
+  EXPECT_FALSE(PP->isImplementationUnit());
+  EXPECT_EQ(PP->getNamedModuleName(), "foo:part");
+}
+
+TEST_F(ModuleDeclStateTest, ModuleInterfacePartition) {
+  const char *source = R"(
+export module foo:part;
+  )";
+  std::unique_ptr<Preprocessor> PP = getPreprocessor(source, "-std=c++20");
+
+  std::initializer_list<bool> ImportKinds = {};
+  preprocess(*PP,
+             std::make_unique<CheckNamedModuleImportingCB>(*PP, ImportKinds));
+
+  auto *Callback =
+      static_cast<CheckNamedModuleImportingCB *>(PP->getPPCallbacks());
+  EXPECT_EQ(Callback->importNamedModuleNum(), 0);
+  EXPECT_TRUE(PP->isNamedModule());
+  EXPECT_TRUE(PP->isNamedInterfaceUnit());
+  EXPECT_FALSE(PP->isImplementationUnit());
+  EXPECT_EQ(PP->getNamedModuleName(), "foo:part");
+}
+
+TEST_F(ModuleDeclStateTest, ModuleNameWithDot) {
+  const char *source = R"(
+export module foo.dot:part.dot;
+  )";
+  std::unique_ptr<Preprocessor> PP = getPreprocessor(source, "-std=c++20");
+
+  std::initializer_list<bool> ImportKinds = {};
+  preprocess(*PP,
+             std::make_unique<CheckNamedModuleImportingCB>(*PP, ImportKinds));
+
+  auto *Callback =
+      static_cast<CheckNamedModuleImportingCB *>(PP->getPPCallbacks());
+  EXPECT_EQ(Callback->importNamedModuleNum(), 0);
+  EXPECT_TRUE(PP->isNamedModule());
+  EXPECT_TRUE(PP->isNamedInterfaceUnit());
+  EXPECT_FALSE(PP->isImplementationUnit());
+  EXPECT_EQ(PP->getNamedModuleName(), "foo.dot:part.dot");
+}
+
+TEST_F(ModuleDeclStateTest, NotModule) {
+  const char *source = R"(
+// export module foo:part;
+  )";
+  std::unique_ptr<Preprocessor> PP = getPreprocessor(source, "-std=c++20");
+
+  std::initializer_list<bool> ImportKinds = {};
+  preprocess(*PP,
+             std::make_unique<CheckNamedModuleImportingCB>(*PP, ImportKinds));
+
+  auto *Callback =
+      static_cast<CheckNamedModuleImportingCB *>(PP->getPPCallbacks());
+  EXPECT_EQ(Callback->importNamedModuleNum(), 0);
+  EXPECT_FALSE(PP->isNamedModule());
+  EXPECT_FALSE(PP->isNamedInterfaceUnit());
+  EXPECT_FALSE(PP->isImplementationUnit());
+}
+
+TEST_F(ModuleDeclStateTest, ModuleWithGMF) {
+  const char *source = R"(
+module;
+#include "bar.h"
+#include <zoo.h>
+import "bar";
+import <zoo>;
+export module foo:part;
+import "HU";
+import M;
+import :another;
+  )";
+  std::unique_ptr<Preprocessor> PP = getPreprocessor(source, "-std=c++20");
+
+  std::initializer_list<bool> ImportKinds = {true, true};
+  preprocess(*PP,
+             std::make_unique<CheckNamedModuleImportingCB>(*PP, ImportKinds));
+
+  auto *Callback =
+      static_cast<CheckNamedModuleImportingCB *>(PP->getPPCallbacks());
+  EXPECT_EQ(Callback->importNamedModuleNum(), 2);
+  EXPECT_TRUE(PP->isNamedModule());
+  EXPECT_TRUE(PP->isNamedInterfaceUnit());
+  EXPECT_FALSE(PP->isImplementationUnit());
+  EXPECT_EQ(PP->getNamedModuleName(), "foo:part");
+}
+
+TEST_F(ModuleDeclStateTest, ModuleWithGMFWithClangNamedModule) {
+  const char *source = R"(
+module;
+#include "bar.h"
+#include <zoo.h>
+import "bar";
+import <zoo>;
+export module foo:part;
+import "HU";
+import M;
+import :another;
+  )";
+  std::unique_ptr<Preprocessor> PP = getPreprocessor(source, "-std=c++20");
+
+  std::initializer_list<bool> ImportKinds = {true, true};
+  preprocess(*PP,
+             std::make_unique<CheckNamedModuleImportingCB>(*PP, ImportKinds));
+
+  auto *Callback =
+      static_cast<CheckNamedModuleImportingCB *>(PP->getPPCallbacks());
+  EXPECT_EQ(Callback->importNamedModuleNum(), 2);
+  EXPECT_TRUE(PP->isNamedModule());
+  EXPECT_TRUE(PP->isNamedInterfaceUnit());
+  EXPECT_FALSE(PP->isImplementationUnit());
+  EXPECT_EQ(PP->getNamedModuleName(), "foo:part");
+}
+
+TEST_F(ModuleDeclStateTest, ImportsInNormalTU) {
+  const char *source = R"(
+#include "bar.h"
+#include <zoo.h>
+import "bar";
+import <zoo>;
+import "HU";
+import M;
+// We can't import a partition in non-module TU.
+import :another;
+  )";
+  std::unique_ptr<Preprocessor> PP = getPreprocessor(source, "-std=c++20");
+
+  std::initializer_list<bool> ImportKinds = {true};
+  preprocess(*PP,
+             std::make_unique<CheckNamedModuleImportingCB>(*PP, ImportKinds));
+
+  auto *Callback =
+      static_cast<CheckNamedModuleImportingCB *>(PP->getPPCallbacks());
+  EXPECT_EQ(Callback->importNamedModuleNum(), 1);
+  EXPECT_FALSE(PP->isNamedModule());
+  EXPECT_FALSE(PP->isNamedInterfaceUnit());
+  EXPECT_FALSE(PP->isImplementationUnit());
+}
+
+TEST_F(ModuleDeclStateTest, ImportAClangNamedModule) {
+  const char *source = R"(
+@import anything;
+  )";
+  std::unique_ptr<Preprocessor> PP =
+      getPreprocessor(source, {"-fmodules", "-fimplicit-module-maps", "-x",
+                               "objective-c++", "-std=c++20"});
+
+  std::initializer_list<bool> ImportKinds = {false};
+  preprocess(*PP,
+             std::make_unique<CheckNamedModuleImportingCB>(*PP, ImportKinds));
+
+  auto *Callback =
+      static_cast<CheckNamedModuleImportingCB *>(PP->getPPCallbacks());
+  EXPECT_EQ(Callback->importNamedModuleNum(), 1);
+  EXPECT_FALSE(PP->isNamedModule());
+  EXPECT_FALSE(PP->isNamedInterfaceUnit());
+  EXPECT_FALSE(PP->isImplementationUnit());
+}
+
+TEST_F(ModuleDeclStateTest, ImportWixedForm) {
+  const char *source = R"(
+import "HU";
+@import anything;
+import M;
+@import another;
+import M2;
+  )";
+  std::unique_ptr<Preprocessor> PP =
+      getPreprocessor(source, {"-fmodules", "-fimplicit-module-maps", "-x",
+                               "objective-c++", "-std=c++20"});
+
+  std::initializer_list<bool> ImportKinds = {false, true, false, true};
+  preprocess(*PP,
+             std::make_unique<CheckNamedModuleImportingCB>(*PP, ImportKinds));
+
+  auto *Callback =
+      static_cast<CheckNamedModuleImportingCB *>(PP->getPPCallbacks());
+  EXPECT_EQ(Callback->importNamedModuleNum(), 4);
+  EXPECT_FALSE(PP->isNamedModule());
+  EXPECT_FALSE(PP->isNamedInterfaceUnit());
+  EXPECT_FALSE(PP->isImplementationUnit());
+}
+
+} // namespace