[Demangler] Tidy up a bit, and add line numbers to ManglingErrors.

Because DEMANGLER_ASSERT() might cause the remanglers to return a ManglingError
with the code ManglingError::AssertionFailed, it's useful to have a line number
in the ManglingError as well as the other information.  This is also potentially
helpful for other cases where the code is used multiple times in the remanglers.

rdar://79725187

Author: al45tair

include/swift/Demangling/Demangle.h

@@ -542,14 +542,17 @@ struct SWIFT_NODISCARD ManglingError {
 
   Code        code;
   NodePointer node;
+  unsigned    line;
 
   ManglingError() : code(Uninitialized), node(nullptr) {}
-  ManglingError(Code c) : code(c), node(nullptr) {}
-  ManglingError(Code c, NodePointer n) : code(c), node(n) {}
+  ManglingError(Code c) : code(c), node(nullptr), line(0) {}
+  ManglingError(Code c, NodePointer n, unsigned l) : code(c), node(n), line(l) {}
 
   bool isSuccess() const { return code == Success; }
 };
 
+#define MANGLING_ERROR(c,n)     ManglingError((c), (n), __LINE__)
+
 /// Used as a return type for mangling functions that may fail
 template <typename T>
 class SWIFT_NODISCARD ManglingErrorOr {
@@ -559,17 +562,17 @@ class SWIFT_NODISCARD ManglingErrorOr {
 
 public:
   ManglingErrorOr() : err_() {}
-  ManglingErrorOr(ManglingError::Code code, NodePointer node = nullptr)
-    : err_(code, node) {}
+  ManglingErrorOr(ManglingError::Code code,
+                  NodePointer node = nullptr,
+                  unsigned line = 0)
+  : err_(code, node, line) {}
   ManglingErrorOr(const ManglingError &err) : err_(err) {}
   ManglingErrorOr(const T &t) : err_(ManglingError::Success), value_(t) {}
   ManglingErrorOr(T &&t) : err_(ManglingError::Success), value_(std::move(t)) {}
 
   bool isSuccess() const { return err_.code == ManglingError::Success; }
 
   const ManglingError &error() const { return err_; }
-  ManglingError::Code errorCode() const { return err_.code; }
-  NodePointer errorNode() const { return err_.node; }
 
   const T &result() const {
     assert(isSuccess());

include/swift/Demangling/TypeDecoder.h

@@ -611,8 +611,9 @@ class TypeDecoder {
       auto mangling = Demangle::mangleNode(Node);
       if (!mangling.isSuccess()) {
         return MAKE_NODE_TYPE_ERROR(Node,
-                                    "failed to mangle node (%d)",
-                                    mangling.errorCode());
+                                    "failed to mangle node (%d:%u)",
+                                    mangling.error().code,
+                                    mangling.error().line);
       }
       return Builder.createBuiltinType(Node->getText().str(), mangling.result());
     }

lib/Demangling/DemanglerAssert.h

@@ -19,13 +19,13 @@
 #define SWIFT_DEMANGLING_ASSERT_H
 
 #if SWIFT_RUNTIME
-#define DEMANGLER_ASSERT(expr, node)                            \
-do {                                                            \
-  if (!(expr))                                                  \
-    return ManglingError(ManglingError::AssertionFailed, node); \
-} while (0)
+#define DEMANGLER_ASSERT(expr, node)                                           \
+  do {                                                                         \
+    if (!(expr))                                                               \
+      return ManglingError(ManglingError::AssertionFailed, (node), __LINE__);  \
+  } while (0)
 #else
-#define DEMANGLER_ASSERT(expr, node)    assert(expr)
+#define DEMANGLER_ASSERT(expr, node) assert(expr)
 #endif
 
 #endif // SWIFT_DEMANGLING_ASSERT_H