add tests for C++ symbol demangling

Author: ktoso

stdlib/public/runtime/Demangle.cpp

@@ -1112,21 +1112,18 @@ namespace swift {
 
           if (outputBufferSize) {
             bufferSize = *outputBufferSize;
-            *outputBufferSize = resultLen;
+            if (!outputBuffer) {
+              // cxa_demangle always \0 terminates the strings, however since we're relying on the initialized 
+              // count when forming Spans around the results from this func, we don't need to rely on null-terminated strings.
+              *outputBufferSize = resultLen - 1; 
+              return result;
+            } else {
+              *outputBufferSize = resultLen - 1; // ignore the trailing
+            }
           }
 
-          if (outputBuffer == nullptr) {
-            return result;
-          }
-
-          size_t toCopy = std::min(
-            shouldNullTerminateString ? (bufferSize - 1) : bufferSize, 
-            shouldNullTerminateString ? (resultLen - 1) : resultLen
-          );
+          size_t toCopy = std::min(bufferSize, resultLen);
           ::memcpy(outputBuffer, result, toCopy);
-          if (shouldNullTerminateString) {
-            outputBuffer[toCopy] = '\0';
-          }
 
           free(result);
 

test/Concurrency/Runtime/RuntimeDemangle.swift

@@ -30,16 +30,16 @@ if #available(SwiftStdlib 6.3, *) {
     expectEqual(demangle("_$sSS7cStringSSSPys4Int8VG_tcfC"), "Swift.String.init(cString: Swift.UnsafePointer<Swift.Int8>) -> Swift.String")
   }
 
-  DemangleTests.test("Span API") {
-    func test(body: (inout OutputSpan<UTF8.CodeUnit>) -> ()) {
-      let buffer = UnsafeMutableBufferPointer<UInt8>.allocate(capacity: 140)
-      var outputSpan = OutputSpan<UTF8.CodeUnit>(buffer: buffer, initializedCount: 0)
+  func test(body: (inout OutputSpan<UTF8.CodeUnit>) -> ()) {
+    let buffer = UnsafeMutableBufferPointer<UInt8>.allocate(capacity: 140)
+    var outputSpan = OutputSpan<UTF8.CodeUnit>(buffer: buffer, initializedCount: 0)
 
-      defer { buffer.deallocate() }
+    defer { buffer.deallocate() }
 
-      body(&outputSpan)
-    }
+    body(&outputSpan)
+  }
 
+  DemangleTests.test("Span API") {
     // First, test that the buffer is still empty after failed demanglings.
     test { outputSpan in 
       let res = demangle("abc123".utf8Span, into: &outputSpan)
@@ -136,6 +136,42 @@ if #available(SwiftStdlib 6.3, *) {
     expectEqual(String(copying: try! UTF8Span(validating: smolOutputSpan.span)), "Smol.Int")
   }
 
+  DemangleTests.test("String API - demangle C++ symbols") {
+    expectEqual(demangle("_ZN7MyClass6methodEi"), "MyClass::method(int)")
+    expectEqual(demangle("_ZNKSt6vectorIiSaIiEE4sizeEv"), "std::vector<int, std::allocator<int>>::size() const")
+  }
+
+  DemangleTests.test("String API - demangle C++ symbols, illegal") {
+    expectEqual(demangle("_ZNKSt6vectorIiSaIiEEv"), nil)
+  }
+  
+  DemangleTests.test("Span API - demangle C++ symbols") {
+    test { outputSpan in 
+      let res = demangle("_ZN7MyClass6methodEi".utf8Span, into: &outputSpan)
+      let demangled = String(copying: try! UTF8Span(validating: outputSpan.span))
+      print("res = \(demangled) len:\(demangled.count)")
+      expectEqual(res, .success)
+      expectEqual(demangled, "MyClass::method(int)")
+    }
+    test { outputSpan in 
+      let res = demangle("_ZNKSt6vectorIiSaIiEE4sizeEv".utf8Span, into: &outputSpan)
+      let demangled = String(copying: try! UTF8Span(validating: outputSpan.span))
+      print("res = \(demangled) len:\(demangled.count)")
+      expectEqual(res, .success)
+      expectEqual(demangled, "std::vector<int, std::allocator<int>>::size() const")
+    }
+  }
+
+  DemangleTests.test("Span API - demangle C++ symbols, too small buffer") {
+    let smolBuffer = UnsafeMutableBufferPointer<UInt8>.allocate(capacity: 12)
+    var smolOutputSpan = OutputSpan<UTF8.CodeUnit>(buffer: smolBuffer, initializedCount: 0)
+    defer { smolBuffer.deallocate() }
+
+    let fail = demangle("_ZN7MyClass6methodEi".utf8Span, into: &smolOutputSpan)
+    expectEqual(fail, .truncated(9))
+    expectEqual(String(copying: try! UTF8Span(validating: smolOutputSpan.span)), "MyClass::met")
+  }
+
 }
 
 runAllTests()