[Demangling] Make Demangle::getUnspecialized() return errors too.

This lets us completely remove the unreachable() function from Remangler.cpp.

rdar://79725187

Author: al45tair

include/swift/Demangling/Demangle.h

@@ -691,7 +691,7 @@ bool nodeConsumesGenericArgs(Node *node);
 
 bool isSpecialized(Node *node);
 
-NodePointer getUnspecialized(Node *node, NodeFactory &Factory);
+ManglingErrorOr<NodePointer> getUnspecialized(Node *node, NodeFactory &Factory);
 
 /// Returns true if the node \p kind refers to a context node, e.g. a nominal
 /// type or a function.

include/swift/Demangling/TypeDecoder.h

@@ -1378,7 +1378,10 @@ return {}; // Not Implemented!
         parent = decodeMangledType(parentContext, depth + 1).getType();
         // Remove any generic arguments from the context node, producing a
         // node that references the nominal type declaration.
-        declNode = Demangle::getUnspecialized(node, Builder.getNodeFactory());
+        auto unspec = Demangle::getUnspecialized(node, Builder.getNodeFactory());
+        if (!unspec.isSuccess())
+          return TypeLookupError("Failed to unspecialize type");
+        declNode = unspec.result();
         break;
       }
     }

lib/Demangling/Context.cpp

@@ -216,7 +216,11 @@ std::string Context::getModuleName(llvm::StringRef mangledName) {
     }
     default:
       if (isSpecialized(node)) {
-        node = getUnspecialized(node, *D);
+        auto unspec = getUnspecialized(node, *D);
+        if (!unspec.isSuccess())
+          node = nullptr;
+        else
+          node = unspec.result();
         break;
       }
       if (isContext(node->getKind())) {

lib/Demangling/OldRemangler.cpp

@@ -1937,7 +1937,10 @@ void Remangler::mangleAnyNominalType(Node *node, EntityContext &ctx,
   if (isSpecialized(node)) {
     Buffer << 'G';
 
-    NodePointer unboundType = getUnspecialized(node, Factory);
+    auto unspec = getUnspecialized(node, Factory);
+    if (!unspec.isSuccess())
+      unreachable("unable to unspecialize");
+    NodePointer unboundType = unspec.result();
 
     mangleAnyNominalType(unboundType, ctx, depth + 1);
     mangleGenericArgs(node, ctx, depth + 1);

lib/Demangling/Remangler.cpp

@@ -39,12 +39,6 @@ using namespace Mangle;
       return err;                                                              \
   } while (0)
 
-[[noreturn]]
-static void unreachable(const char *Message) {
-  fprintf(stderr, "fatal error: %s\n", Message);
-  std::abort();
-}
-
 static char getCharOfNodeText(Node *node, unsigned idx) {
   switch (node->getKind()) {
   case Node::Kind::InfixOperator:
@@ -500,7 +494,10 @@ ManglingError Remangler::mangleAnyNominalType(Node *node, unsigned depth) {
     if (trySubstitution(node, entry))
       return ManglingError::Success;
 
-    NodePointer unboundType = getUnspecialized(node, Factory);
+    auto unspec = getUnspecialized(node, Factory);
+    if (!unspec.isSuccess())
+      return unspec.error();
+    NodePointer unboundType = unspec.result();
     RETURN_IF_ERROR(mangleAnyNominalType(unboundType, depth + 1));
     char Separator = 'y';
     RETURN_IF_ERROR(mangleGenericArgs(node, Separator, depth + 1));
@@ -642,7 +639,8 @@ ManglingError Remangler::mangleAbstractStorage(Node *node,
   switch (node->getKind()) {
     case Node::Kind::Subscript: Buffer << "i"; break;
     case Node::Kind::Variable: Buffer << "v"; break;
-    default: unreachable("Not a storage node");
+    default:
+      return ManglingError(ManglingError::NotAStorageNode, node);
   }
   Buffer << accessorCode;
   return ManglingError::Success;
@@ -815,7 +813,10 @@ ManglingError Remangler::mangleBoundGenericFunction(Node *node,
   if (trySubstitution(node, entry))
     return ManglingError::Success;
 
-  NodePointer unboundFunction = getUnspecialized(node, Factory);
+  auto unspec = getUnspecialized(node, Factory);
+  if (!unspec.isSuccess())
+    return unspec.error();
+  NodePointer unboundFunction = unspec.result();
   RETURN_IF_ERROR(mangleFunction(unboundFunction, depth + 1));
   char Separator = 'y';
   RETURN_IF_ERROR(mangleGenericArgs(node, Separator, depth + 1));
@@ -3418,7 +3419,8 @@ bool Demangle::isSpecialized(Node *node) {
   }
 }
 
-NodePointer Demangle::getUnspecialized(Node *node, NodeFactory &Factory) {
+ManglingErrorOr<NodePointer> Demangle::getUnspecialized(Node *node,
+                                                        NodeFactory &Factory) {
   unsigned NumToCopy = 2;
   switch (node->getKind()) {
     case Node::Kind::Function:
@@ -3450,8 +3452,12 @@ NodePointer Demangle::getUnspecialized(Node *node, NodeFactory &Factory) {
     case Node::Kind::OtherNominalType: {
       NodePointer result = Factory.createNode(node->getKind());
       NodePointer parentOrModule = node->getChild(0);
-      if (isSpecialized(parentOrModule))
-        parentOrModule = getUnspecialized(parentOrModule, Factory);
+      if (isSpecialized(parentOrModule)) {
+        auto unspec = getUnspecialized(parentOrModule, Factory);
+        if (!unspec.isSuccess())
+          return unspec;
+        parentOrModule = unspec.result();
+      }
       result->addChild(parentOrModule, Factory);
       for (unsigned Idx = 1; Idx < NumToCopy; ++Idx) {
         result->addChild(node->getChild(Idx), Factory);
@@ -3486,16 +3492,19 @@ NodePointer Demangle::getUnspecialized(Node *node, NodeFactory &Factory) {
       NodePointer parent = node->getChild(1);
       if (!isSpecialized(parent))
         return node;
+      auto unspec = getUnspecialized(parent, Factory);
+      if (!unspec.isSuccess())
+        return unspec.error();
       NodePointer result = Factory.createNode(Node::Kind::Extension);
       result->addChild(node->getFirstChild(), Factory);
-      result->addChild(getUnspecialized(parent, Factory), Factory);
+      result->addChild(unspec.result(), Factory);
       if (node->getNumChildren() == 3) {
         // Add the generic signature of the extension.
         result->addChild(node->getChild(2), Factory);
       }
       return result;
     }
     default:
-      unreachable("bad nominal type kind");
+      return ManglingError(ManglingError::BadNominalTypeKind, node);
   }
 }

stdlib/public/runtime/MetadataLookup.cpp

@@ -325,7 +325,10 @@ _findExtendedTypeContextDescriptor(const ContextDescriptor *maybeExtension,
     node = node->getChild(0);
   }
   if (Demangle::isSpecialized(node)) {
-    node = Demangle::getUnspecialized(node, demangler);
+    auto unspec = Demangle::getUnspecialized(node, demangler);
+    if (!unspec.isSuccess())
+      return nullptr;
+    node = unspec.result();
   }
 
   return _findContextDescriptor(node, demangler);

test/TypeRoundTrip/Inputs/RoundTrip/RoundTrip.cpp

@@ -30,7 +30,13 @@ extern "C" SWIFT_CC(swift) void roundTripType(const Metadata *md) {
   auto nodeTree = _swift_buildDemanglingForMetadata(md, dem);
 
   // Mangle that
-  std::string mangledName = Demangle::__runtime::mangleNode(nodeTree);
+  auto mangling = Demangle::__runtime::mangleNode(nodeTree);
+  if (!mangling.isSuccess()) {
+    printf("FAIL: %s (%p) -> mangling error %d\n",
+           mdName.c_str(), md, mangling.errorCode());
+    return;
+  }
+  std::string mangledName = mangling.result();
 
   // Look up the result
   auto result = swift_getTypeByMangledName(MetadataState::Abstract,