[C++20] [Modules] Makes sure internal declaration won't be found by other TU #123059
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
ChuanqiXu9
added
clang:modules
|
@llvm/pr-subscribers-clang @llvm/pr-subscribers-clang-modules Author: Chuanqi Xu (ChuanqiXu9) ChangesClose #61427 And this is also helpful to implement The implementation strategy mimics Patch is 40.52 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/123059.diff 11 Files Affected:
diff --git a/clang/include/clang/Serialization/ASTBitCodes.h b/clang/include/clang/Serialization/ASTBitCodes.h
index 40dae25f7b54b7..d568d2fd7aa301 100644
--- a/clang/include/clang/Serialization/ASTBitCodes.h
+++ b/clang/include/clang/Serialization/ASTBitCodes.h
@@ -740,6 +740,8 @@ enum ASTRecordTypes {
CXX_ADDED_TEMPLATE_PARTIAL_SPECIALIZATION = 75,
UPDATE_MODULE_LOCAL_VISIBLE = 76,
+
+ UPDATE_TU_LOCAL_VISIBLE = 77,
};
/// Record types used within a source manager block.
@@ -1340,6 +1342,10 @@ enum DeclCode {
/// only visible from DeclContext in the same module.
DECL_CONTEXT_MODULE_LOCAL_VISIBLE,
+ /// A record that stores the set of declarations that are only visible
+ /// to the TU.
+ DECL_CONTEXT_TU_LOCAL_VISIBLE,
+
/// A LabelDecl record.
DECL_LABEL,
diff --git a/clang/include/clang/Serialization/ASTReader.h b/clang/include/clang/Serialization/ASTReader.h
index ea12adaec3ee81..1459c9f9b083f1 100644
--- a/clang/include/clang/Serialization/ASTReader.h
+++ b/clang/include/clang/Serialization/ASTReader.h
@@ -528,6 +528,7 @@ class ASTReader
uint64_t LexicalOffset;
uint64_t VisibleOffset;
uint64_t ModuleLocalOffset;
+ uint64_t TULocalOffset;
};
using DelayedNamespaceOffsetMapTy =
@@ -640,6 +641,9 @@ class ASTReader
llvm::DenseMap<const DeclContext *,
serialization::reader::ModuleLocalLookupTable>
ModuleLocalLookups;
+ llvm::DenseMap<const DeclContext *,
+ serialization::reader::DeclContextLookupTable>
+ TULocalLookups;
using SpecLookupTableTy =
llvm::DenseMap<const Decl *,
@@ -670,6 +674,7 @@ class ASTReader
llvm::DenseMap<GlobalDeclID, DeclContextVisibleUpdates> PendingVisibleUpdates;
llvm::DenseMap<GlobalDeclID, DeclContextVisibleUpdates>
PendingModuleLocalVisibleUpdates;
+ llvm::DenseMap<GlobalDeclID, DeclContextVisibleUpdates> TULocalUpdates;
using SpecializationsUpdate = SmallVector<UpdateData, 1>;
using SpecializationsUpdateMap =
@@ -704,11 +709,17 @@ class ASTReader
llvm::BitstreamCursor &Cursor,
uint64_t Offset, DeclContext *DC);
+ enum class VisibleDeclContextStorageKind {
+ GenerallyVisible,
+ ModuleLocalVisible,
+ TULocalVisible,
+ };
+
/// Read the record that describes the visible contents of a DC.
bool ReadVisibleDeclContextStorage(ModuleFile &M,
llvm::BitstreamCursor &Cursor,
uint64_t Offset, GlobalDeclID ID,
- bool IsModuleLocal);
+ VisibleDeclContextStorageKind VisibleKind);
bool ReadSpecializations(ModuleFile &M, llvm::BitstreamCursor &Cursor,
uint64_t Offset, Decl *D, bool IsPartial);
@@ -1148,6 +1159,10 @@ class ASTReader
unsigned NumModuleLocalVisibleDeclContexts = 0,
TotalModuleLocalVisibleDeclContexts = 0;
+ /// Number of TU Local decl contexts read/total
+ unsigned NumTULocalVisibleDeclContexts = 0,
+ TotalTULocalVisibleDeclContexts = 0;
+
/// Total size of modules, in bits, currently loaded
uint64_t TotalModulesSizeInBits = 0;
@@ -1463,6 +1478,9 @@ class ASTReader
const serialization::reader::ModuleLocalLookupTable *
getModuleLocalLookupTables(DeclContext *Primary) const;
+ const serialization::reader::DeclContextLookupTable *
+ getTULocalLookupTables(DeclContext *Primary) const;
+
/// Get the loaded specializations lookup tables for \p D,
/// if any.
serialization::reader::LazySpecializationInfoLookupTable *
diff --git a/clang/include/clang/Serialization/ASTWriter.h b/clang/include/clang/Serialization/ASTWriter.h
index 53b09cc914392e..079e39a9fb678b 100644
--- a/clang/include/clang/Serialization/ASTWriter.h
+++ b/clang/include/clang/Serialization/ASTWriter.h
@@ -496,6 +496,9 @@ class ASTWriter : public ASTDeserializationListener,
/// file.
unsigned NumModuleLocalDeclContexts = 0;
+ /// The number of TULocal declcontexts written to the AST file.
+ unsigned NumTULocalDeclContexts = 0;
+
/// A mapping from each known submodule to its ID number, which will
/// be a positive integer.
llvm::DenseMap<const Module *, unsigned> SubmoduleIDs;
@@ -594,12 +597,14 @@ class ASTWriter : public ASTDeserializationListener,
void
GenerateNameLookupTable(ASTContext &Context, const DeclContext *DC,
llvm::SmallVectorImpl<char> &LookupTable,
- llvm::SmallVectorImpl<char> &ModuleLocalLookupTable);
+ llvm::SmallVectorImpl<char> &ModuleLocalLookupTable,
+ llvm::SmallVectorImpl<char> &TULocalLookupTable);
uint64_t WriteDeclContextLexicalBlock(ASTContext &Context,
const DeclContext *DC);
void WriteDeclContextVisibleBlock(ASTContext &Context, DeclContext *DC,
uint64_t &VisibleBlockOffset,
- uint64_t &ModuleLocalBlockOffset);
+ uint64_t &ModuleLocalBlockOffset,
+ uint64_t &TULocalBlockOffset);
void WriteTypeDeclOffsets();
void WriteFileDeclIDsMap();
void WriteComments(ASTContext &Context);
@@ -633,8 +638,10 @@ class ASTWriter : public ASTDeserializationListener,
unsigned DeclContextLexicalAbbrev = 0;
unsigned DeclContextVisibleLookupAbbrev = 0;
unsigned DeclModuleLocalVisibleLookupAbbrev = 0;
+ unsigned DeclTULocalLookupAbbrev = 0;
unsigned UpdateVisibleAbbrev = 0;
unsigned ModuleLocalUpdateVisibleAbbrev = 0;
+ unsigned TULocalUpdateVisibleAbbrev = 0;
unsigned DeclRecordAbbrev = 0;
unsigned DeclTypedefAbbrev = 0;
unsigned DeclVarAbbrev = 0;
diff --git a/clang/lib/Serialization/ASTReader.cpp b/clang/lib/Serialization/ASTReader.cpp
index 06853a227215e0..b1d79727603163 100644
--- a/clang/lib/Serialization/ASTReader.cpp
+++ b/clang/lib/Serialization/ASTReader.cpp
@@ -1425,10 +1425,9 @@ bool ASTReader::ReadLexicalDeclContextStorage(ModuleFile &M,
return false;
}
-bool ASTReader::ReadVisibleDeclContextStorage(ModuleFile &M,
- BitstreamCursor &Cursor,
- uint64_t Offset, GlobalDeclID ID,
- bool IsModuleLocal) {
+bool ASTReader::ReadVisibleDeclContextStorage(
+ ModuleFile &M, BitstreamCursor &Cursor, uint64_t Offset, GlobalDeclID ID,
+ ASTReader::VisibleDeclContextStorageKind VisibleKind) {
assert(Offset != 0);
SavedStreamPosition SavedPosition(Cursor);
@@ -1452,22 +1451,42 @@ bool ASTReader::ReadVisibleDeclContextStorage(ModuleFile &M,
return true;
}
unsigned RecCode = MaybeRecCode.get();
- if (!IsModuleLocal && RecCode != DECL_CONTEXT_VISIBLE) {
- Error("Expected visible lookup table block");
- return true;
- }
- if (IsModuleLocal && RecCode != DECL_CONTEXT_MODULE_LOCAL_VISIBLE) {
- Error("Expected module local visible lookup table block");
- return true;
+ switch (VisibleKind) {
+ case VisibleDeclContextStorageKind::GenerallyVisible:
+ if (RecCode != DECL_CONTEXT_VISIBLE) {
+ Error("Expected visible lookup table block");
+ return true;
+ }
+ break;
+ case VisibleDeclContextStorageKind::ModuleLocalVisible:
+ if (RecCode != DECL_CONTEXT_MODULE_LOCAL_VISIBLE) {
+ Error("Expected module local visible lookup table block");
+ return true;
+ }
+ break;
+ case VisibleDeclContextStorageKind::TULocalVisible:
+ if (RecCode != DECL_CONTEXT_TU_LOCAL_VISIBLE) {
+ Error("Expected TU local lookup table block");
+ return true;
+ }
+ break;
}
// We can't safely determine the primary context yet, so delay attaching the
// lookup table until we're done with recursive deserialization.
auto *Data = (const unsigned char*)Blob.data();
- if (!IsModuleLocal)
+ switch (VisibleKind) {
+ case VisibleDeclContextStorageKind::GenerallyVisible:
PendingVisibleUpdates[ID].push_back(UpdateData{&M, Data});
- else
+ break;
+ case VisibleDeclContextStorageKind::ModuleLocalVisible:
PendingModuleLocalVisibleUpdates[ID].push_back(UpdateData{&M, Data});
+ break;
+ case VisibleDeclContextStorageKind::TULocalVisible:
+ if (M.Kind == MK_MainFile)
+ TULocalUpdates[ID].push_back(UpdateData{&M, Data});
+ break;
+ }
return false;
}
@@ -3613,6 +3632,21 @@ llvm::Error ASTReader::ReadASTBlock(ModuleFile &F,
break;
}
+ case UPDATE_TU_LOCAL_VISIBLE: {
+ if (F.Kind != MK_MainFile)
+ break;
+ unsigned Idx = 0;
+ GlobalDeclID ID = ReadDeclID(F, Record, Idx);
+ auto *Data = (const unsigned char *)Blob.data();
+ TULocalUpdates[ID].push_back(UpdateData{&F, Data});
+ // If we've already loaded the decl, perform the updates when we finish
+ // loading this block.
+ if (Decl *D = GetExistingDecl(ID))
+ PendingUpdateRecords.push_back(
+ PendingUpdateRecord(ID, D, /*JustLoaded=*/false));
+ break;
+ }
+
case CXX_ADDED_TEMPLATE_SPECIALIZATION: {
unsigned Idx = 0;
GlobalDeclID ID = ReadDeclID(F, Record, Idx);
@@ -3717,6 +3751,7 @@ llvm::Error ASTReader::ReadASTBlock(ModuleFile &F,
TotalLexicalDeclContexts += Record[2];
TotalVisibleDeclContexts += Record[3];
TotalModuleLocalVisibleDeclContexts += Record[4];
+ TotalTULocalVisibleDeclContexts += Record[5];
break;
case UNUSED_FILESCOPED_DECLS:
@@ -4002,7 +4037,7 @@ llvm::Error ASTReader::ReadASTBlock(ModuleFile &F,
break;
case DELAYED_NAMESPACE_LEXICAL_VISIBLE_RECORD: {
- if (Record.size() % 4 != 0)
+ if (Record.size() % 5 != 0)
return llvm::createStringError(
std::errc::illegal_byte_sequence,
"invalid DELAYED_NAMESPACE_LEXICAL_VISIBLE_RECORD block in AST "
@@ -4021,9 +4056,12 @@ llvm::Error ASTReader::ReadASTBlock(ModuleFile &F,
uint64_t LocalModuleLocalOffset = Record[I++];
uint64_t ModuleLocalOffset =
LocalModuleLocalOffset ? BaseOffset + LocalModuleLocalOffset : 0;
+ uint64_t TULocalLocalOffset = Record[I++];
+ uint64_t TULocalOffset =
+ TULocalLocalOffset ? BaseOffset + TULocalLocalOffset : 0;
DelayedNamespaceOffsetMap[ID] = {LexicalOffset, VisibleOffset,
- ModuleLocalOffset};
+ ModuleLocalOffset, TULocalOffset};
assert(!GetExistingDecl(ID) &&
"We shouldn't load the namespace in the front of delayed "
@@ -8471,6 +8509,15 @@ bool ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC,
}
}
+ if (auto It = TULocalLookups.find(DC); It != TULocalLookups.end()) {
+ ++NumTULocalVisibleDeclContexts;
+ for (GlobalDeclID ID : It->second.Table.find(Name)) {
+ NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
+ if (ND->getDeclName() == Name && Found.insert(ND).second)
+ Decls.push_back(ND);
+ }
+ }
+
SetExternalVisibleDeclsForName(DC, Name, Decls);
return !Decls.empty();
}
@@ -8498,6 +8545,7 @@ void ASTReader::completeVisibleDeclsMap(const DeclContext *DC) {
findAll(Lookups, NumVisibleDeclContextsRead);
findAll(ModuleLocalLookups, NumModuleLocalVisibleDeclContexts);
+ findAll(TULocalLookups, NumTULocalVisibleDeclContexts);
for (DeclsMap::iterator I = Decls.begin(), E = Decls.end(); I != E; ++I) {
SetExternalVisibleDeclsForName(DC, I->first, I->second);
@@ -8517,6 +8565,12 @@ ASTReader::getModuleLocalLookupTables(DeclContext *Primary) const {
return I == ModuleLocalLookups.end() ? nullptr : &I->second;
}
+const serialization::reader::DeclContextLookupTable *
+ASTReader::getTULocalLookupTables(DeclContext *Primary) const {
+ auto I = TULocalLookups.find(Primary);
+ return I == TULocalLookups.end() ? nullptr : &I->second;
+}
+
serialization::reader::LazySpecializationInfoLookupTable *
ASTReader::getLoadedSpecializationsLookupTables(const Decl *D, bool IsPartial) {
assert(D->isCanonicalDecl());
@@ -8632,6 +8686,11 @@ void ASTReader::PrintStats() {
NumModuleLocalVisibleDeclContexts, TotalModuleLocalVisibleDeclContexts,
((float)NumModuleLocalVisibleDeclContexts /
TotalModuleLocalVisibleDeclContexts * 100));
+ if (TotalTULocalVisibleDeclContexts)
+ std::fprintf(stderr, " %u/%u visible declcontexts in GMF read (%f%%)\n",
+ NumTULocalVisibleDeclContexts, TotalTULocalVisibleDeclContexts,
+ ((float)NumTULocalVisibleDeclContexts /
+ TotalTULocalVisibleDeclContexts * 100));
if (TotalNumMethodPoolEntries)
std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n",
NumMethodPoolEntriesRead, TotalNumMethodPoolEntries,
diff --git a/clang/lib/Serialization/ASTReaderDecl.cpp b/clang/lib/Serialization/ASTReaderDecl.cpp
index 1c51a7b5e460f6..72191395ec8067 100644
--- a/clang/lib/Serialization/ASTReaderDecl.cpp
+++ b/clang/lib/Serialization/ASTReaderDecl.cpp
@@ -414,7 +414,8 @@ class ASTDeclReader : public DeclVisitor<ASTDeclReader, void> {
void VisitLifetimeExtendedTemporaryDecl(LifetimeExtendedTemporaryDecl *D);
void VisitDeclContext(DeclContext *DC, uint64_t &LexicalOffset,
- uint64_t &VisibleOffset, uint64_t &ModuleLocalOffset);
+ uint64_t &VisibleOffset, uint64_t &ModuleLocalOffset,
+ uint64_t &TULocalOffset);
template <typename T>
RedeclarableResult VisitRedeclarable(Redeclarable<T> *D);
@@ -1859,7 +1860,9 @@ void ASTDeclReader::VisitHLSLBufferDecl(HLSLBufferDecl *D) {
uint64_t LexicalOffset = 0;
uint64_t VisibleOffset = 0;
uint64_t ModuleLocalOffset = 0;
- VisitDeclContext(D, LexicalOffset, VisibleOffset, ModuleLocalOffset);
+ uint64_t TULocalOffset = 0;
+ VisitDeclContext(D, LexicalOffset, VisibleOffset, ModuleLocalOffset,
+ TULocalOffset);
D->IsCBuffer = Record.readBool();
D->KwLoc = readSourceLocation();
D->LBraceLoc = readSourceLocation();
@@ -2770,10 +2773,12 @@ void ASTDeclReader::VisitLifetimeExtendedTemporaryDecl(
void ASTDeclReader::VisitDeclContext(DeclContext *DC, uint64_t &LexicalOffset,
uint64_t &VisibleOffset,
- uint64_t &ModuleLocalOffset) {
+ uint64_t &ModuleLocalOffset,
+ uint64_t &TULocalOffset) {
LexicalOffset = ReadLocalOffset();
VisibleOffset = ReadLocalOffset();
ModuleLocalOffset = ReadLocalOffset();
+ TULocalOffset = ReadLocalOffset();
}
template <typename T>
@@ -3875,6 +3880,7 @@ Decl *ASTReader::ReadDeclRecord(GlobalDeclID ID) {
case DECL_CONTEXT_LEXICAL:
case DECL_CONTEXT_VISIBLE:
case DECL_CONTEXT_MODULE_LOCAL_VISIBLE:
+ case DECL_CONTEXT_TU_LOCAL_VISIBLE:
case DECL_SPECIALIZATIONS:
case DECL_PARTIAL_SPECIALIZATIONS:
llvm_unreachable("Record cannot be de-serialized with readDeclRecord");
@@ -4185,9 +4191,10 @@ Decl *ASTReader::ReadDeclRecord(GlobalDeclID ID) {
uint64_t LexicalOffset = 0;
uint64_t VisibleOffset = 0;
uint64_t ModuleLocalOffset = 0;
+ uint64_t TULocalOffset = 0;
- Reader.VisitDeclContext(DC, LexicalOffset, VisibleOffset,
- ModuleLocalOffset);
+ Reader.VisitDeclContext(DC, LexicalOffset, VisibleOffset, ModuleLocalOffset,
+ TULocalOffset);
// Get the lexical and visible block for the delayed namespace.
// It is sufficient to judge if ID is in DelayedNamespaceOffsetMap.
@@ -4199,18 +4206,24 @@ Decl *ASTReader::ReadDeclRecord(GlobalDeclID ID) {
LexicalOffset = Iter->second.LexicalOffset;
VisibleOffset = Iter->second.VisibleOffset;
ModuleLocalOffset = Iter->second.ModuleLocalOffset;
+ TULocalOffset = Iter->second.TULocalOffset;
}
if (LexicalOffset &&
ReadLexicalDeclContextStorage(*Loc.F, DeclsCursor, LexicalOffset, DC))
return nullptr;
- if (VisibleOffset &&
- ReadVisibleDeclContextStorage(*Loc.F, DeclsCursor, VisibleOffset, ID,
- /*IsModuleLocal=*/false))
+ if (VisibleOffset && ReadVisibleDeclContextStorage(
+ *Loc.F, DeclsCursor, VisibleOffset, ID,
+ VisibleDeclContextStorageKind::GenerallyVisible))
return nullptr;
if (ModuleLocalOffset &&
- ReadVisibleDeclContextStorage(*Loc.F, DeclsCursor, ModuleLocalOffset,
- ID, /*IsModuleLocal=*/true))
+ ReadVisibleDeclContextStorage(
+ *Loc.F, DeclsCursor, ModuleLocalOffset, ID,
+ VisibleDeclContextStorageKind::ModuleLocalVisible))
+ return nullptr;
+ if (TULocalOffset && ReadVisibleDeclContextStorage(
+ *Loc.F, DeclsCursor, TULocalOffset, ID,
+ VisibleDeclContextStorageKind::TULocalVisible))
return nullptr;
}
assert(Record.getIdx() == Record.size());
@@ -4376,6 +4389,18 @@ void ASTReader::loadDeclUpdateRecords(PendingUpdateRecord &Record) {
DC->setHasExternalVisibleStorage(true);
}
+ if (auto I = TULocalUpdates.find(ID); I != TULocalUpdates.end()) {
+ auto Updates = std::move(I->second);
+ TULocalUpdates.erase(I);
+
+ auto *DC = cast<DeclContext>(D)->getPrimaryContext();
+ for (const auto &Update : Updates)
+ TULocalLookups[DC].Table.add(
+ Update.Mod, Update.Data,
+ reader::ASTDeclContextNameLookupTrait(*this, *Update.Mod));
+ DC->setHasExternalVisibleStorage(true);
+ }
+
// Load any pending related decls.
if (D->isCanonicalDecl()) {
if (auto IT = RelatedDeclsMap.find(ID); IT != RelatedDeclsMap.end()) {
diff --git a/clang/lib/Serialization/ASTWriter.cpp b/clang/lib/Serialization/ASTWriter.cpp
index a6f8c6009f1ffa..d405ca26902439 100644
--- a/clang/lib/Serialization/ASTWriter.cpp
+++ b/clang/lib/Serialization/ASTWriter.cpp
@@ -4044,6 +4044,13 @@ class ASTDeclContextNameLookupTraitBase {
: Writer(Writer) {}
public:
+ data_type getData(const DeclIDsTy &LocalIDs) {
+ unsigned Start = DeclIDs.size();
+ for (auto ID : LocalIDs)
+ DeclIDs.push_back(ID);
+ return std::make_pair(Start, DeclIDs.size());
+ }
+
data_type ImportData(const reader::ASTDeclContextNameLookupTrait::data_type &FromReader) {
unsigned Start = DeclIDs.size();
DeclIDs.insert(
@@ -4136,23 +4143,16 @@ class ASTDeclContextNameLookupTraitBase {
}
};
-class ModuleLocalNameLookupTrait : public ASTDeclContextNameLookupTraitBase {
+class ModuleLevelNameLookupTrait : public ASTDeclContextNameLookupTraitBase {
public:
using primary_module_hash_type = unsigned;
using key_type = std::pair<DeclarationNameKey, primary_module_hash_type>;
using key_type_ref = key_type;
- explicit ModuleLocalNameLookupTrait(ASTWriter &Writer)
+ explicit ModuleLevelNameLookupTrait(ASTWriter &Writer)
: ASTDeclContextNameLookupTraitBase(Writer) {}
- data_type getData(const DeclIDsTy &LocalIDs) {
- unsigned Start = DeclIDs.size();
- for (auto ID : LocalIDs)
- DeclIDs.push_back(ID);
- return std::make_pair(Start, DeclIDs.size());
- }
-
static bool EqualKey(key_type_ref a, key_type_ref b) { return a == b; }
hash_value_type ComputeHash(key_type Key) {
@@ -4181,19 +4181,37 @@ class ModuleLocalNameLookupTrait : public ASTDeclContextNameLookupTraitBase {
}
};
+static bool shouldBeInTULocalLookupTable(NamedDecl *D) {
+ Module *NamedModule = D->getTopLevelOwningNamedModule();
+ if (!NamedModule)
+ return false;
+
+ // It is fine enough to not put these in TULocalLookupTable.
+ // Otherwise, if the consumers get its context decl somehow,
+ // it is problematic to lookup in that context.
+ if (!D->getNonTransparentDeclContext()->isFileContext())
+ return false;
+
+ return D->getLinkageInternal() == Linkage::Internal;
+}
+
// Trait used for the on-disk hash table used in the method pool.
+template <bool CollectingTULocalDecls>
class ASTDeclContextNameLookupTrait : public ASTDeclContextNameLookupTraitBase {
public:
- using ModuleLocalDeclsMapTy =
- llvm::DenseMap<ModuleLocalNameLookup...
[truncated]
|
…ther TU Close llvm#61427 And this is also helpful to implement llvm#112294 partially. The implementation strategy mimics llvm#122887. This patch split the internal declarations from the general lookup table so that other TU can't find the internal declarations.
ChuanqiXu9
force-pushed
the
TULocalLookup
branch
from
8ab290b to
d0decfc
Compare
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Close #61427
And this is also helpful to implement
#112294 partially.
The implementation strategy mimics
#122887. This patch split the internal declarations from the general lookup table so that other TU can't find the internal declarations.