[TBD] Refactored SymbolSourceMap to be a typedef

Author: Zak Kent

include/swift/AST/ASTTypeIDZone.def

@@ -37,7 +37,6 @@ SWIFT_TYPEID(FragileFunctionKind)
 SWIFT_TYPEID(PolymorphicEffectKind)
 SWIFT_TYPEID(PolymorphicEffectRequirementList)
 SWIFT_TYPEID(TangentPropertyInfo)
-SWIFT_TYPEID(SymbolSourceMap)
 SWIFT_TYPEID(Type)
 SWIFT_TYPEID(TypePair)
 SWIFT_TYPEID(TypeWitnessAndDecl)

include/swift/AST/ASTTypeIDs.h

@@ -70,7 +70,6 @@ struct FragileFunctionKind;
 enum class PolymorphicEffectKind : uint8_t;
 class PolymorphicEffectRequirementList;
 class SourceFile;
-class SymbolSourceMap;
 struct TangentPropertyInfo;
 class Type;
 class TypeAliasDecl;

include/swift/AST/TBDGenRequests.h

@@ -205,50 +205,12 @@ class SymbolSource {
 };
 
 /// Maps a symbol back to its source for lazy compilation.
-class SymbolSourceMap {
-  friend class SymbolSourceMapRequest;
-
-  using Storage = llvm::StringMap<SymbolSource>;
-  const Storage *storage;
-
-  explicit SymbolSourceMap(const Storage *storage) : storage(storage) {
-    assert(storage);
-  }
-
-public:
-  llvm::Optional<SymbolSource> find(StringRef symbol) const {
-    auto result = storage->find(symbol);
-    if (result == storage->end())
-      return llvm::None;
-    return result->second;
-  }
-  
-  Storage::const_iterator begin() const {
-    return storage->begin();
-  }
-  
-  Storage::const_iterator end() const {
-    return storage->end();
-  }
-
-  friend bool operator==(const SymbolSourceMap &lhs,
-                         const SymbolSourceMap &rhs) {
-    return lhs.storage == rhs.storage;
-  }
-  friend bool operator!=(const SymbolSourceMap &lhs,
-                         const SymbolSourceMap &rhs) {
-    return !(lhs == rhs);
-  }
-
-  friend void simple_display(llvm::raw_ostream &out, const SymbolSourceMap &) {
-    out << "(symbol storage map)";
-  }
-};
+using SymbolSourceMap = llvm::StringMap<SymbolSource>;
 
 /// Computes a map of symbols to their SymbolSource for a file or module.
 class SymbolSourceMapRequest
     : public SimpleRequest<SymbolSourceMapRequest,
-                           SymbolSourceMap(TBDGenDescriptor),
+                           const SymbolSourceMap *(TBDGenDescriptor),
                            RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
@@ -257,7 +219,8 @@ class SymbolSourceMapRequest
   friend SimpleRequest;
 
   // Evaluation.
-  SymbolSourceMap evaluate(Evaluator &evaluator, TBDGenDescriptor desc) const;
+  const SymbolSourceMap *evaluate(Evaluator &evaluator,
+                                  TBDGenDescriptor desc) const;
 
 public:
   // Cached.

include/swift/AST/TBDGenTypeIDZone.def

@@ -20,7 +20,7 @@ SWIFT_REQUEST(TBDGen, PublicSymbolsRequest,
               std::vector<std::string>(TBDGenDescriptor),
               Uncached, NoLocationInfo)
 SWIFT_REQUEST(TBDGen, SymbolSourceMapRequest,
-              SymbolSourceMap(TBDGenDescriptor),
+              const SymbolSourceMap *(TBDGenDescriptor),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TBDGen, APIGenRequest, apigen::API(TBDGenDescriptor), Uncached,
               NoLocationInfo)

include/swift/Immediate/SwiftMaterializationUnit.h

@@ -127,15 +127,15 @@ class LazySwiftMaterializationUnit : public llvm::orc::MaterializationUnit {
 
 private:
   LazySwiftMaterializationUnit(SwiftJIT &JIT, CompilerInstance &CI,
-                               SymbolSourceMap Sources,
+                               const SymbolSourceMap *Sources,
                                llvm::orc::SymbolFlagsMap Symbols);
   void materialize(
       std::unique_ptr<llvm::orc::MaterializationResponsibility> MR) override;
 
   void discard(const llvm::orc::JITDylib &JD,
                const llvm::orc::SymbolStringPtr &Sym) override;
 
-  SymbolSourceMap Sources;
+  const SymbolSourceMap *Sources;
   SwiftJIT &JIT;
   CompilerInstance &CI;
 };

lib/IRGen/IRGen.cpp

@@ -1077,22 +1077,23 @@ getSymbolSourcesToEmit(const IRGenDescriptor &desc) {
   auto &ctx = desc.getParentModule()->getASTContext();
   auto tbdDesc = desc.getTBDGenDescriptor();
   tbdDesc.getOptions().PublicSymbolsOnly = false;
-  auto symbolMap =
+  const auto *symbolMap =
       llvm::cantFail(ctx.evaluator(SymbolSourceMapRequest{std::move(tbdDesc)}));
 
   // Then split up the symbols so they can be emitted by the appropriate part
   // of the pipeline.
   SILRefsToEmit silRefsToEmit;
   IREntitiesToEmit irEntitiesToEmit;
   for (const auto &symbol : *desc.SymbolsToEmit) {
-    auto source = symbolMap.find(symbol);
-    assert(source && "Couldn't find symbol");
-    switch (source->kind) {
+    auto itr = symbolMap->find(symbol);
+    assert(itr != symbolMap->end() && "Couldn't find symbol");
+    const auto &source = itr->getValue();
+    switch (source.kind) {
     case SymbolSource::Kind::SIL:
-      silRefsToEmit.push_back(source->getSILDeclRef());
+      silRefsToEmit.push_back(source.getSILDeclRef());
       break;
     case SymbolSource::Kind::IR:
-      irEntitiesToEmit.push_back(source->getIRLinkEntity());
+      irEntitiesToEmit.push_back(source.getIRLinkEntity());
       break;
     case SymbolSource::Kind::LinkerDirective:
     case SymbolSource::Kind::Unknown:

lib/IRGen/TBDGen.cpp

@@ -855,24 +855,24 @@ void swift::writeAPIJSONFile(ModuleDecl *M, llvm::raw_ostream &os,
 
 /// NOTE: This is part of an incomplete experimental feature. There are
 /// currently no clients that depend on its output.
-SymbolSourceMap SymbolSourceMapRequest::evaluate(Evaluator &evaluator,
-                                                 TBDGenDescriptor desc) const {
-  using Map = SymbolSourceMap::Storage;
-  Map symbolSources;
+const SymbolSourceMap *
+SymbolSourceMapRequest::evaluate(Evaluator &evaluator,
+                                 TBDGenDescriptor desc) const {
 
-  auto addSymbol = [&](StringRef symbol, SymbolKind kind, SymbolSource source) {
-    symbolSources.insert({symbol, source});
+  // FIXME: Once the evaluator supports returning a reference to a cached value
+  // in storage, this won't be necessary.
+  auto &Ctx = desc.getParentModule()->getASTContext();
+  auto *SymbolSources = Ctx.Allocate<SymbolSourceMap>();
+
+  auto addSymbol = [=](StringRef symbol, SymbolKind kind, SymbolSource source) {
+    SymbolSources->insert({symbol, source});
   };
 
   SimpleAPIRecorder recorder(addSymbol);
   TBDGenVisitor visitor(desc, recorder);
   visitor.visit(desc);
 
-  // FIXME: Once the evaluator supports returning a reference to a cached value
-  // in storage, this won't be necessary.
-  auto &ctx = desc.getParentModule()->getASTContext();
-  auto *memory = ctx.Allocate<Map>();
-  *memory = std::move(symbolSources);
-  ctx.addCleanup([memory](){ memory->~Map(); });
-  return SymbolSourceMap(memory);
+  Ctx.addCleanup([SymbolSources]() { SymbolSources->~SymbolSourceMap(); });
+
+  return SymbolSources;
 }

lib/Immediate/SwiftMaterializationUnit.cpp

@@ -293,10 +293,10 @@ LazySwiftMaterializationUnit::Create(SwiftJIT &JIT, CompilerInstance &CI) {
   Opts.PublicSymbolsOnly = false;
   auto TBDDesc = TBDGenDescriptor::forModule(M, std::move(Opts));
   SymbolSourceMapRequest SourceReq{TBDDesc};
-  auto Sources =
+  const auto *Sources =
       llvm::cantFail(M->getASTContext().evaluator(std::move(SourceReq)));
   llvm::orc::SymbolFlagsMap PublicInterface;
-  for (const auto &Entry : Sources) {
+  for (const auto &Entry : *Sources) {
     const auto &Source = Entry.getValue();
     if (Source.kind != SymbolSource::Kind::SIL) {
       continue;
@@ -320,20 +320,21 @@ StringRef LazySwiftMaterializationUnit::getName() const {
 }
 
 LazySwiftMaterializationUnit::LazySwiftMaterializationUnit(
-    SwiftJIT &JIT, CompilerInstance &CI, SymbolSourceMap Sources,
+    SwiftJIT &JIT, CompilerInstance &CI, const SymbolSourceMap *Sources,
     llvm::orc::SymbolFlagsMap Symbols)
-    : MaterializationUnit({std::move(Symbols), nullptr}),
-      Sources(std::move(Sources)), JIT(JIT), CI(CI) {}
+    : MaterializationUnit({std::move(Symbols), nullptr}), Sources(Sources),
+      JIT(JIT), CI(CI) {}
 
 void LazySwiftMaterializationUnit::materialize(
     std::unique_ptr<llvm::orc::MaterializationResponsibility> MR) {
   SILRefsToEmit Refs;
   const auto &RS = MR->getRequestedSymbols();
   for (auto &Sym : RS) {
     auto Name = demangle(*Sym);
-    auto Source = Sources.find(Name);
-    assert(Source && "Requested symbol doesn't have source?");
-    auto Ref = Source->getSILDeclRef();
+    auto itr = Sources->find(Name);
+    assert(itr != Sources->end() && "Requested symbol doesn't have source?");
+    const auto &Source = itr->getValue();
+    auto Ref = Source.getSILDeclRef();
     if (auto *AFD = Ref.getAbstractFunctionDecl()) {
       AFD->getTypecheckedBody();
       if (CI.getASTContext().hadError()) {
@@ -390,7 +391,7 @@ void LazySwiftMaterializationUnit::materialize(
     }
   }
   std::unique_ptr<MaterializationUnit> UnrequestedMU(
-      new LazySwiftMaterializationUnit(JIT, CI, std::move(Sources),
+      new LazySwiftMaterializationUnit(JIT, CI, Sources,
                                        std::move(UnrequestedSymbols)));
   if (auto Err = MR->replace(std::move(UnrequestedMU))) {
     logError(std::move(Err));