Merge pull request #22407 from slavapestov/fix-demangler-circularity

AST: ASTMangler should not depend on ASTDemangler

Author: slavapestov

include/swift/AST/ASTMangler.h

@@ -158,8 +158,7 @@ class ASTMangler : public Mangler {
                                       GenericSignature *signature,
                                       ResilienceExpansion expansion);
 
-  std::string mangleTypeForDebugger(Type decl, const DeclContext *DC,
-                                    bool verify=false);
+  std::string mangleTypeForDebugger(Type decl, const DeclContext *DC);
 
   std::string mangleDeclType(const ValueDecl *decl);
 

lib/AST/ASTMangler.cpp

@@ -42,10 +42,6 @@
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/CommandLine.h"
 
-#ifndef NDEBUG
-#include "swift/AST/ASTDemangler.h"
-#endif
-
 using namespace swift;
 using namespace swift::Mangle;
 
@@ -364,30 +360,7 @@ std::string ASTMangler::mangleReabstractionThunkHelper(
   return finalize();
 }
 
-#ifndef NDEBUG
-static bool areTypesReallyEqual(Type lhs, Type rhs) {
-  // Due to an oversight, escaping and non-escaping @convention(block)
-  // are mangled identically.
-  auto eraseEscapingBlock = [](Type t) -> Type {
-    return t.transform([](Type t) -> Type {
-      if (auto *fnType = t->getAs<FunctionType>()) {
-        if (fnType->getExtInfo().getRepresentation()
-              == FunctionTypeRepresentation::Block) {
-          return FunctionType::get(fnType->getParams(),
-                                   fnType->getResult(),
-                                   fnType->getExtInfo().withNoEscape(true));
-        }
-      }
-      return t;
-    });
-  };
-
-  return eraseEscapingBlock(lhs)->isEqual(eraseEscapingBlock(rhs));
-}
-#endif
-
-std::string ASTMangler::mangleTypeForDebugger(Type Ty, const DeclContext *DC,
-                                              bool verify) {
+std::string ASTMangler::mangleTypeForDebugger(Type Ty, const DeclContext *DC) {
   PrettyStackTraceType prettyStackTrace(Ty->getASTContext(),
                                         "mangling type for debugger", Ty);
 
@@ -400,33 +373,7 @@ std::string ASTMangler::mangleTypeForDebugger(Type Ty, const DeclContext *DC,
 
   appendType(Ty);
   appendOperator("D");
-  std::string result = finalize();
-
-  if (!verify)
-    return result;
-
-  // Make sure we can reconstruct mangled types for the debugger.
-#ifndef NDEBUG
-  auto &Ctx = Ty->getASTContext();
-  Type Reconstructed = Demangle::getTypeForMangling(Ctx, result);
-  if (!Reconstructed) {
-    llvm::errs() << "Failed to reconstruct type for " << result << "\n";
-    llvm::errs() << "Original type:\n";
-    Ty->dump();
-    abort();
-  } else if (!Reconstructed->isEqual(Ty)) {
-    if (!areTypesReallyEqual(Reconstructed, Ty)) {
-      llvm::errs() << "Incorrect reconstructed type for " << result << "\n";
-      llvm::errs() << "Original type:\n";
-      Ty->dump();
-      llvm::errs() << "Reconstructed type:\n";
-      Reconstructed->dump();
-      abort();
-    }
-  }
-#endif
-
-  return result;
+  return finalize();
 }
 
 std::string ASTMangler::mangleDeclType(const ValueDecl *decl) {

lib/IRGen/IRGenDebugInfo.cpp

@@ -57,6 +57,10 @@
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/Utils/Local.h"
 
+#ifndef NDEBUG
+#include "swift/AST/ASTDemangler.h"
+#endif
+
 using namespace swift;
 using namespace irgen;
 
@@ -688,6 +692,28 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
     return Size(size);
   }
 
+#ifndef NDEBUG
+  static bool areTypesReallyEqual(Type lhs, Type rhs) {
+    // Due to an oversight, escaping and non-escaping @convention(block)
+    // are mangled identically.
+    auto eraseEscapingBlock = [](Type t) -> Type {
+      return t.transform([](Type t) -> Type {
+        if (auto *fnType = t->getAs<FunctionType>()) {
+          if (fnType->getExtInfo().getRepresentation()
+                == FunctionTypeRepresentation::Block) {
+            return FunctionType::get(fnType->getParams(),
+                                    fnType->getResult(),
+                                    fnType->getExtInfo().withNoEscape(true));
+          }
+        }
+        return t;
+      });
+    };
+
+    return eraseEscapingBlock(lhs)->isEqual(eraseEscapingBlock(rhs));
+  }
+#endif
+
   StringRef getMangledName(DebugTypeInfo DbgTy) {
     if (MetadataTypeDecl && DbgTy.getDecl() == MetadataTypeDecl)
       return BumpAllocatedString(DbgTy.getDecl()->getName().str());
@@ -697,10 +723,33 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
       Ty = Ty->mapTypeOutOfContext();
 
     Mangle::ASTMangler Mangler;
-    std::string Name = Mangler.mangleTypeForDebugger(
-        Ty, DbgTy.getDeclContext(),
-        !Opts.DisableRoundTripDebugTypes);
-    return BumpAllocatedString(Name);
+    std::string Result = Mangler.mangleTypeForDebugger(
+        Ty, DbgTy.getDeclContext());
+
+    if (!Opts.DisableRoundTripDebugTypes) {
+      // Make sure we can reconstruct mangled types for the debugger.
+#ifndef NDEBUG
+      auto &Ctx = Ty->getASTContext();
+      Type Reconstructed = Demangle::getTypeForMangling(Ctx, Result);
+      if (!Reconstructed) {
+        llvm::errs() << "Failed to reconstruct type for " << Result << "\n";
+        llvm::errs() << "Original type:\n";
+        Ty->dump();
+        abort();
+      } else if (!Reconstructed->isEqual(Ty)) {
+        if (!areTypesReallyEqual(Reconstructed, Ty)) {
+          llvm::errs() << "Incorrect reconstructed type for " << Result << "\n";
+          llvm::errs() << "Original type:\n";
+          Ty->dump();
+          llvm::errs() << "Reconstructed type:\n";
+          Reconstructed->dump();
+          abort();
+        }
+      }
+#endif
+    }
+
+    return BumpAllocatedString(Result);
   }
 
   llvm::DIDerivedType *createMemberType(DebugTypeInfo DbgTy, StringRef Name,