[ASTMangler] Pass ASTContext to all instantiations of ASTMangler

Author: kubamracek

include/swift/AST/ASTMangler.h

@@ -13,6 +13,7 @@
 #ifndef SWIFT_AST_ASTMANGLER_H
 #define SWIFT_AST_ASTMANGLER_H
 
+#include "swift/AST/ASTContext.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/FreestandingMacroExpansion.h"
 #include "swift/AST/SILThunkKind.h"
@@ -44,6 +45,7 @@ enum class DestructorKind {
 /// The mangler for AST declarations.
 class ASTMangler : public Mangler {
 protected:
+  const ASTContext &Context;
   ModuleDecl *Mod = nullptr;
 
   /// Optimize out protocol names if a type only conforms to one protocol.
@@ -186,13 +188,15 @@ class ASTMangler : public Mangler {
   };
 
   /// lldb overrides the defaulted argument to 'true'.
-  ASTMangler(bool DWARFMangling = false) {
+  ASTMangler(const ASTContext &Ctx, bool DWARFMangling = false) : Context(Ctx) {
     if (DWARFMangling) {
       DWARFMangling = true;
       RespectOriginallyDefinedIn = false;
     }
   }
 
+  const ASTContext &getASTContext() { return Context; }
+
   void addTypeSubstitution(Type type, GenericSignature sig) {
     type = dropProtocolsFromAssociatedTypes(type, sig);
     addSubstitution(type.getPointer());

include/swift/IRGen/Linking.h

@@ -1452,9 +1452,9 @@ class LinkEntity {
     return entity;
   }
 
-  void mangle(llvm::raw_ostream &out) const;
-  void mangle(SmallVectorImpl<char> &buffer) const;
-  std::string mangleAsString() const;
+  void mangle(ASTContext &Ctx, llvm::raw_ostream &out) const;
+  void mangle(ASTContext &Ctx, SmallVectorImpl<char> &buffer) const;
+  std::string mangleAsString(ASTContext &Ctx) const;
 
   SILDeclRef getSILDeclRef() const;
   SILLinkage getLinkage(ForDefinition_t isDefinition) const;

include/swift/SIL/GenericSpecializationMangler.h

@@ -13,6 +13,7 @@
 #ifndef SWIFT_SIL_UTILS_GENERICSPECIALIZATIONMANGLER_H
 #define SWIFT_SIL_UTILS_GENERICSPECIALIZATIONMANGLER_H
 
+#include "swift/AST/ASTContext.h"
 #include "swift/AST/ASTMangler.h"
 #include "swift/AST/Effects.h"
 #include "swift/Basic/NullablePtr.h"
@@ -50,14 +51,14 @@ class SpecializationMangler : public Mangle::ASTMangler {
   PossibleEffects RemovedEffects;
 
 protected:
-  SpecializationMangler(SpecializationPass P, swift::SerializedKind_t Serialized,
+  SpecializationMangler(ASTContext &Ctx, SpecializationPass P, swift::SerializedKind_t Serialized,
                         SILFunction *F)
-      : Pass(P), Serialized(Serialized), Function(F),
+      : ASTMangler(Ctx), Pass(P), Serialized(Serialized), Function(F),
         ArgOpBuffer(ArgOpStorage) {}
 
-  SpecializationMangler(SpecializationPass P, swift::SerializedKind_t Serialized,
+  SpecializationMangler(ASTContext &Ctx, SpecializationPass P, swift::SerializedKind_t Serialized,
                         std::string functionName)
-      : Pass(P), Serialized(Serialized), Function(nullptr),
+      : ASTMangler(Ctx), Pass(P), Serialized(Serialized), Function(nullptr),
         FunctionName(functionName), ArgOpBuffer(ArgOpStorage) {}
 
   void beginMangling();
@@ -73,8 +74,8 @@ class SpecializationMangler : public Mangle::ASTMangler {
 // The mangler for specialized generic functions.
 class GenericSpecializationMangler : public SpecializationMangler {
 
-  GenericSpecializationMangler(std::string origFuncName)
-      : SpecializationMangler(SpecializationPass::GenericSpecializer,
+  GenericSpecializationMangler(ASTContext &Ctx, std::string origFuncName)
+      : SpecializationMangler(Ctx, SpecializationPass::GenericSpecializer,
                               IsNotSerialized, origFuncName) {}
 
   GenericSignature getGenericSignature() {
@@ -90,8 +91,8 @@ class GenericSpecializationMangler : public SpecializationMangler {
   void appendRemovedParams(const SmallBitVector &paramsRemoved);
 
 public:
-  GenericSpecializationMangler(SILFunction *F, swift::SerializedKind_t Serialized)
-      : SpecializationMangler(SpecializationPass::GenericSpecializer,
+  GenericSpecializationMangler(ASTContext &Ctx, SILFunction *F, swift::SerializedKind_t Serialized)
+      : SpecializationMangler(Ctx, SpecializationPass::GenericSpecializer,
                               Serialized, F) {}
 
   std::string mangleNotReabstracted(SubstitutionMap subs,
@@ -118,7 +119,7 @@ class GenericSpecializationMangler : public SpecializationMangler {
     return manglePrespecialized(getGenericSignature(), subs);
   }
 
-  static std::string manglePrespecialization(std::string unspecializedName,
+  static std::string manglePrespecialization(ASTContext &Ctx, std::string unspecializedName,
                                              GenericSignature genericSig,
                                              GenericSignature specializedSig);
 };

include/swift/SIL/TypeSubstCloner.h

@@ -383,7 +383,7 @@ class TypeSubstCloner : public SILClonerWithScopes<ImplClass> {
       return ParentFunction;
 
     // Clone the function with the substituted type for the debug info.
-    Mangle::GenericSpecializationMangler Mangler(ParentFunction,
+    Mangle::GenericSpecializationMangler Mangler(M.getASTContext(), ParentFunction,
                                                  IsNotSerialized);
     std::string MangledName =
       Mangler.mangleForDebugInfo(RemappedSig, SubsMap, ForInlining);

include/swift/SILOptimizer/Utils/DifferentiationMangler.h

@@ -13,6 +13,7 @@
 #ifndef SWIFT_SIL_UTILS_DIFFERENTIATIONMANGLER_H
 #define SWIFT_SIL_UTILS_DIFFERENTIATIONMANGLER_H
 
+#include "swift/AST/ASTContext.h"
 #include "swift/AST/ASTMangler.h"
 #include "swift/AST/AutoDiff.h"
 #include "swift/Basic/NullablePtr.h"
@@ -25,7 +26,7 @@ namespace Mangle {
 /// A mangler for generated differentiation functions.
 class DifferentiationMangler : public ASTMangler {
 public:
-  DifferentiationMangler() {}
+  DifferentiationMangler(const ASTContext &Ctx) : ASTMangler(Ctx) {}
   /// Returns the mangled name for a differentiation function of the given kind.
   std::string mangleAutoDiffFunction(StringRef originalName,
                                      Demangle::AutoDiffFunctionKind kind,

include/swift/SILOptimizer/Utils/SpecializationMangler.h

@@ -32,10 +32,10 @@ class PartialSpecializationMangler : public SpecializationMangler {
   bool isReAbstracted;
 
 public:
-  PartialSpecializationMangler(SILFunction *F,
+  PartialSpecializationMangler(ASTContext &Ctx, SILFunction *F,
                                CanSILFunctionType SpecializedFnTy,
                                swift::SerializedKind_t Serialized, bool isReAbstracted)
-      : SpecializationMangler(SpecializationPass::GenericSpecializer,
+      : SpecializationMangler(Ctx, SpecializationPass::GenericSpecializer,
                               Serialized, F),
         SpecializedFnTy(SpecializedFnTy), isReAbstracted(isReAbstracted) {}
 
@@ -92,7 +92,7 @@ class FunctionSignatureSpecializationMangler : public SpecializationMangler {
   ReturnValueModifierIntBase ReturnValue;
 
 public:
-  FunctionSignatureSpecializationMangler(SpecializationPass Pass,
+  FunctionSignatureSpecializationMangler(ASTContext &Ctx, SpecializationPass Pass,
                                          swift::SerializedKind_t Serialized,
                                          SILFunction *F);
   // For arguments / return values

include/swift/Serialization/SerializedSILLoader.h

@@ -42,6 +42,7 @@ class SILDifferentiabilityWitness;
 /// on each SILDeserializer.
 class SerializedSILLoader {
 private:
+  ASTContext &Context;
   std::vector<std::unique_ptr<SILDeserializer>> LoadedSILSections;
 
   explicit SerializedSILLoader(

lib/APIDigester/ModuleAnalyzerNodes.cpp

@@ -1116,7 +1116,7 @@ static StringRef calculateMangledName(SDKContext &Ctx, ValueDecl *VD) {
   if (auto *attr = VD->getAttrs().getAttribute<SILGenNameAttr>()) {
     return Ctx.buffer(attr->Name);
   }
-  Mangle::ASTMangler NewMangler;
+  Mangle::ASTMangler NewMangler(VD->getASTContext());
   return Ctx.buffer(NewMangler.mangleAnyDecl(VD, true,
                                     /*bool respectOriginallyDefinedIn*/true));
 }

lib/AST/ASTMangler.cpp

@@ -579,7 +579,7 @@ void ASTMangler::appendIndexSubset(IndexSubset *indices) {
 
 static NodePointer mangleSILDifferentiabilityWitnessAsNode(
     StringRef originalName, DifferentiabilityKind kind,
-    const AutoDiffConfig &config, Demangler &demangler) {
+    const AutoDiffConfig &config, Demangler &demangler, ASTMangler *mangler) {
   auto *diffWitnessNode = demangler.createNode(
       Node::Kind::DifferentiabilityWitness);
   auto origNode = demangler.demangleSymbol(originalName);
@@ -600,7 +600,7 @@ static NodePointer mangleSILDifferentiabilityWitnessAsNode(
           Node::Kind::IndexSubset, config.resultIndices->getString()),
       demangler);
   if (auto genSig = config.derivativeGenericSignature) {
-    ASTMangler genSigMangler;
+    ASTMangler genSigMangler(mangler->getASTContext());
     auto genSigSymbol = genSigMangler.mangleGenericSignature(genSig);
     auto demangledGenSig = demangler.demangleSymbol(genSigSymbol);
     assert(demangledGenSig);
@@ -620,7 +620,7 @@ std::string ASTMangler::mangleSILDifferentiabilityWitness(StringRef originalName
   if (isMangledName(originalName)) {
     Demangler demangler;
     auto *node = mangleSILDifferentiabilityWitnessAsNode(
-        originalName, kind, config, demangler);
+        originalName, kind, config, demangler, this);
     auto mangling = mangleNode(node);
     if (!mangling.isSuccess()) {
       llvm_unreachable("unexpected mangling failure");

lib/AST/Decl.cpp

@@ -1,3 +1,4 @@
+
 //===--- Decl.cpp - Swift Language Decl ASTs ------------------------------===//
 //
 // This source file is part of the Swift.org open source project
@@ -6199,7 +6200,7 @@ ClassDecl::MetaclassKind ClassDecl::getMetaclassKind() const {
 static StringRef mangleObjCRuntimeName(const NominalTypeDecl *nominal,
                                        llvm::SmallVectorImpl<char> &buffer) {
   {
-    Mangle::ASTMangler Mangler;
+    Mangle::ASTMangler Mangler(nominal->getASTContext());
     std::string MangledName = Mangler.mangleObjCRuntimeName(nominal);
 
     buffer.clear();
@@ -10067,7 +10068,7 @@ Identifier OpaqueTypeDecl::getOpaqueReturnTypeIdentifier() const {
   SmallString<64> mangleBuf;
   {
     llvm::raw_svector_ostream os(mangleBuf);
-    Mangle::ASTMangler mangler;
+    Mangle::ASTMangler mangler(getASTContext());
     os << mangler.mangleOpaqueTypeDecl(this);
   }