[Mangling] Temporarily stage out (#ifdef out) the ASTMangler API changes and Embedded Swift prefix

Author: kubamracek

include/swift/AST/ASTMangler.h

@@ -45,7 +45,9 @@ enum class DestructorKind {
 /// The mangler for AST declarations.
 class ASTMangler : public Mangler {
 protected:
+#if 0 // STAGING
   const ASTContext &Context;
+#endif
   ModuleDecl *Mod = nullptr;
 
   /// Optimize out protocol names if a type only conforms to one protocol.
@@ -187,6 +189,19 @@ class ASTMangler : public Mangler {
     HasSymbolQuery,
   };
 
+  // STAGING: legacy constructor for LLDB
+  /// lldb overrides the defaulted argument to 'true'.
+  ASTMangler(bool DWARFMangling = false) {
+    if (DWARFMangling) {
+      DWARFMangling = true;
+      RespectOriginallyDefinedIn = false;
+    }
+  }
+
+  /// lldb overrides the defaulted argument to 'true'.
+  ASTMangler(const ASTContext &Ctx, bool DWARFMangling = false) : ASTMangler(DWARFMangling) {}
+
+#if 0
   /// lldb overrides the defaulted argument to 'true'.
   ASTMangler(const ASTContext &Ctx, bool DWARFMangling = false) : Context(Ctx) {
     if (DWARFMangling) {
@@ -199,6 +214,7 @@ class ASTMangler : public Mangler {
   }
 
   const ASTContext &getASTContext() { return Context; }
+#endif
 
   void addTypeSubstitution(Type type, GenericSignature sig) {
     type = dropProtocolsFromAssociatedTypes(type, sig);

include/swift/Demangling/Demangle.h

@@ -674,27 +674,27 @@ class [[nodiscard]] ManglingErrorOr {
 };
 
 /// Remangle a demangled parse tree.
-ManglingErrorOr<std::string> mangleNode(NodePointer root,
-                                        Mangle::ManglingFlavor Flavor);
+ManglingErrorOr<std::string>
+mangleNode(NodePointer root,
+           Mangle::ManglingFlavor Flavor = Mangle::ManglingFlavor::Default);
 
 using SymbolicResolver = llvm::function_ref<Demangle::NodePointer(
     SymbolicReferenceKind, const void *)>;
 
 /// Remangle a demangled parse tree, using a callback to resolve
 /// symbolic references.
-ManglingErrorOr<std::string> mangleNode(NodePointer root,
-                                        SymbolicResolver resolver,
-                                        Mangle::ManglingFlavor Flavor);
+ManglingErrorOr<std::string>
+mangleNode(NodePointer root, SymbolicResolver resolver,
+           Mangle::ManglingFlavor Flavor = Mangle::ManglingFlavor::Default);
 
 /// Remangle a demangled parse tree, using a callback to resolve
 /// symbolic references.
 ///
 /// The returned string is owned by \p Factory. This means \p Factory must stay
 /// alive as long as the returned string is used.
-ManglingErrorOr<llvm::StringRef> mangleNode(NodePointer root,
-                                            SymbolicResolver resolver,
-                                            NodeFactory &Factory,
-                                            Mangle::ManglingFlavor Flavor);
+ManglingErrorOr<llvm::StringRef>
+mangleNode(NodePointer root, SymbolicResolver resolver, NodeFactory &Factory,
+           Mangle::ManglingFlavor Flavor = Mangle::ManglingFlavor::Default);
 
 /// Remangle in the old mangling scheme.
 ///
@@ -814,10 +814,9 @@ llvm::StringRef makeSymbolicMangledNameStringRef(const char *base);
 
 /// Produce the mangled name for the nominal type descriptor of a type
 /// referenced by its module and type name.
-std::string mangledNameForTypeMetadataAccessor(llvm::StringRef moduleName,
-                                               llvm::StringRef typeName,
-                                               Node::Kind typeKind,
-                                               Mangle::ManglingFlavor Flavor);
+std::string mangledNameForTypeMetadataAccessor(
+    llvm::StringRef moduleName, llvm::StringRef typeName, Node::Kind typeKind,
+    Mangle::ManglingFlavor Flavor = Mangle::ManglingFlavor::Default);
 
 SWIFT_END_INLINE_NAMESPACE
 } // end namespace Demangle

lib/AST/ASTMangler.cpp

@@ -600,7 +600,11 @@ static NodePointer mangleSILDifferentiabilityWitnessAsNode(
           Node::Kind::IndexSubset, config.resultIndices->getString()),
       demangler);
   if (auto genSig = config.derivativeGenericSignature) {
+#if 0 // STAGING
     ASTMangler genSigMangler(mangler->getASTContext());
+#else
+    ASTMangler genSigMangler;
+#endif
     auto genSigSymbol = genSigMangler.mangleGenericSignature(genSig);
     auto demangledGenSig = demangler.demangleSymbol(genSigSymbol);
     assert(demangledGenSig);
@@ -713,8 +717,13 @@ static Type getTypeForDWARFMangling(Type t) {
 }
 
 std::string ASTMangler::mangleTypeForDebugger(Type Ty, GenericSignature sig) {
+#if 0 // STAGING
   PrettyStackTraceType prettyStackTrace(Context, "mangling type for debugger",
                                         Ty);
+#else
+  PrettyStackTraceType prettyStackTrace(Ty->getASTContext(), "mangling type for debugger",
+                                        Ty);
+#endif
 
   DWARFMangling = true;
   RespectOriginallyDefinedIn = false;
@@ -1322,7 +1331,11 @@ void ASTMangler::appendType(Type type, GenericSignature sig,
       // unless the type alias references a builtin type.
       auto underlyingType = aliasTy->getSinglyDesugaredType();
       TypeAliasDecl *decl = aliasTy->getDecl();
+#if 0 // STAGING
       if (decl->getModuleContext() == Context.TheBuiltinModule) {
+#else
+      if (decl->getModuleContext() == decl->getASTContext().TheBuiltinModule) {
+#endif
         return appendType(underlyingType, sig, forDecl);
       }
 
@@ -2123,8 +2136,13 @@ void ASTMangler::appendImplFunctionType(SILFunctionType *fn,
     OpArgs.push_back('t');
   }
 
+#if 0 // STAGING
   bool mangleClangType =
       Context.LangOpts.UseClangFunctionTypes && fn->hasNonDerivableClangType();
+#else
+  bool mangleClangType = fn->getASTContext().LangOpts.UseClangFunctionTypes &&
+                         fn->hasNonDerivableClangType();
+#endif
 
   auto appendClangTypeToVec = [this, fn](auto &Vec) {
     llvm::raw_svector_ostream OpArgsOS(Vec);
@@ -3034,8 +3052,13 @@ void ASTMangler::appendFunctionType(AnyFunctionType *fn, GenericSignature sig,
 
   appendFunctionSignature(fn, sig, forDecl, NoFunctionMangling, isRecursedInto);
 
+#if 0 // STAGING
   bool mangleClangType =
       Context.LangOpts.UseClangFunctionTypes && fn->hasNonDerivableClangType();
+#else
+  bool mangleClangType = fn->getASTContext().LangOpts.UseClangFunctionTypes &&
+                         fn->hasNonDerivableClangType();
+#endif
 
   // Note that we do not currently use thin representations in the AST
   // for the types of function decls.  This may need to change at some
@@ -3085,8 +3108,13 @@ void ASTMangler::appendClangType(FnType *fn, llvm::raw_svector_ostream &out) {
   auto clangType = fn->getClangTypeInfo().getType();
   SmallString<64> scratch;
   llvm::raw_svector_ostream scratchOS(scratch);
+#if 0 // STAGING
   clang::ASTContext &clangCtx =
       Context.getClangModuleLoader()->getClangASTContext();
+#else
+   clang::ASTContext &clangCtx =
+      fn->getASTContext().getClangModuleLoader()->getClangASTContext();
+#endif
   std::unique_ptr<clang::ItaniumMangleContext> mangler{
       clang::ItaniumMangleContext::create(clangCtx, clangCtx.getDiagnostics())};
   mangler->mangleCanonicalTypeName(clang::QualType(clangType, 0), scratchOS);
@@ -3112,7 +3140,11 @@ void ASTMangler::appendFunctionSignature(AnyFunctionType *fn,
   if (fn->isSendable())
     appendOperator("Yb");
   if (auto thrownError = fn->getEffectiveThrownErrorType()) {
+#if 0 // STAGING
     if ((*thrownError)->isEqual(Context.getErrorExistentialType())
+#else
+    if ((*thrownError)->isEqual(fn->getASTContext().getErrorExistentialType())
+#endif
         || !AllowTypedThrows) {
       appendOperator("K");
     } else {
@@ -3811,7 +3843,11 @@ void ASTMangler::appendClosureEntity(const AbstractClosureExpr *closure) {
   // code; the type-checker currently isn't strict about producing typed
   // expression nodes when it fails. Once we enforce that, we can remove this.
   if (!type)
+#if 0 // STAGING
     type = CanType(ErrorType::get(Context));
+#else
+    type = CanType(ErrorType::get(closure->getASTContext()));
+#endif
 
   auto canType = type->getCanonicalType();
   if (canType->hasLocalArchetype())
@@ -3882,16 +3918,22 @@ CanType ASTMangler::getDeclTypeForMangling(
   genericSig = GenericSignature();
   parentGenericSig = GenericSignature();
 
+#if 0 // STAGING
+  auto &C = Context;
+#else
+  auto &C = decl->getASTContext();
+#endif
+
   auto ty = decl->getInterfaceType()->getReferenceStorageReferent();
   if (ty->hasError()) {
     if (isa<AbstractFunctionDecl>(decl) || isa<EnumElementDecl>(decl) ||
         isa<SubscriptDecl>(decl)) {
       // FIXME: Verify ExtInfo state is correct, not working by accident.
       CanFunctionType::ExtInfo info;
-      return CanFunctionType::get({AnyFunctionType::Param(Context.TheErrorType)},
-                                  Context.TheErrorType, info);
+      return CanFunctionType::get({AnyFunctionType::Param(C.TheErrorType)},
+                                  C.TheErrorType, info);
     }
-    return Context.TheErrorType;
+    return C.TheErrorType;
   }
 
   // If this declaration predates concurrency, adjust its type to not
@@ -4501,7 +4543,12 @@ void ASTMangler::appendMacroExpansionContext(
   if (loc.isInvalid())
     return appendContext(origDC, nullBase, StringRef());
 
+#if 0 // STAGING
   SourceManager &sourceMgr = Context.SourceMgr;
+#else
+  ASTContext &ctx = origDC->getASTContext();
+  SourceManager &sourceMgr = ctx.SourceMgr;
+#endif
 
   auto appendMacroExpansionLoc = [&]() {
     appendIdentifier(origDC->getParentModule()->getName().str());
@@ -4579,7 +4626,7 @@ void ASTMangler::appendMacroExpansionContext(
     if (auto *macroDecl = decl->getResolvedMacro(attr))
       baseName = macroDecl->getBaseName();
     else
-      baseName = Context.getIdentifier("__unknown_macro__");
+      baseName = ctx.getIdentifier("__unknown_macro__");
 
     discriminator = decl->getAttachedMacroDiscriminator(baseName, role, attr);
     break;

lib/Basic/Mangler.cpp

@@ -123,6 +123,7 @@ void Mangler::beginManglingWithoutPrefix() {
 void Mangler::beginMangling() {
   beginManglingWithoutPrefix();
 
+#if 0 // STAGING: To be switched over to soon.
   switch (Flavor) {
   case ManglingFlavor::Default:
     Buffer << MANGLING_PREFIX_STR;
@@ -131,6 +132,9 @@ void Mangler::beginMangling() {
     Buffer << MANGLING_PREFIX_EMBEDDED_STR;
     break;
   }
+#else
+  Buffer << MANGLING_PREFIX_STR;
+#endif
 }
 
 /// Finish the mangling of the symbol and return the mangled name.
@@ -140,6 +144,7 @@ std::string Mangler::finalize() {
   Storage.clear();
 
 #ifndef NDEBUG
+#if 0 // STAGING: To be switched over to soon.
   switch (Flavor) {
   case ManglingFlavor::Default:
     if (StringRef(result).starts_with(MANGLING_PREFIX_STR))
@@ -150,6 +155,10 @@ std::string Mangler::finalize() {
       verify(result, Flavor);
     break;
   }
+#else
+  if (StringRef(result).starts_with(MANGLING_PREFIX_STR))
+    verify(result, Flavor);
+#endif
 #endif
 
   return result;
@@ -184,6 +193,7 @@ void Mangler::verify(StringRef nameStr, ManglingFlavor Flavor) {
     // It should be kept in sync.
     assert(StringRef(MANGLING_PREFIX_STR) != "_S" && "redundant check");
 
+#if 0 // STAGING: To be switched over to soon.
     switch (Flavor) {
     case ManglingFlavor::Default:
       buffer += MANGLING_PREFIX_STR;
@@ -192,6 +202,9 @@ void Mangler::verify(StringRef nameStr, ManglingFlavor Flavor) {
       buffer += MANGLING_PREFIX_EMBEDDED_STR;
       break;
     }
+#else
+    buffer += MANGLING_PREFIX_STR;
+#endif
 
     buffer += nameStr;
     nameStr = buffer.str();

lib/Demangling/Remangler.cpp

@@ -1795,6 +1795,7 @@ ManglingError Remangler::mangleGetter(Node *node, unsigned depth) {
 }
 
 ManglingError Remangler::mangleGlobal(Node *node, unsigned depth) {
+#if 0 // STAGING: To be switched over to soon.
   switch (Flavor) {
   case ManglingFlavor::Default:
     Buffer << MANGLING_PREFIX_STR;
@@ -1803,6 +1804,9 @@ ManglingError Remangler::mangleGlobal(Node *node, unsigned depth) {
     Buffer << MANGLING_PREFIX_EMBEDDED_STR;
     break;
   }
+#else
+  Buffer << MANGLING_PREFIX_STR;
+#endif
   bool mangleInReverseOrder = false;
   for (auto Iter = node->begin(), End = node->end(); Iter != End; ++Iter) {
     Node *Child = *Iter;