Fix GPUError message storage by using std::string instead of char const *

Co-authored-by: wcandillon <306134+wcandillon@users.noreply.github.com>

Author: Copilot

packages/webgpu/cpp/rnwgpu/api/GPU.cpp

@@ -50,7 +50,7 @@ GPU::requestAdapter(
 std::unordered_set<std::string> GPU::getWgslLanguageFeatures() {
   wgpu::SupportedWGSLLanguageFeatures supportedFeatures = {};
   _instance.GetWGSLLanguageFeatures(&supportedFeatures);
-  
+
   std::unordered_set<std::string> result;
   for (size_t i = 0; i < supportedFeatures.featureCount; i++) {
     wgpu::WGSLLanguageFeatureName feature = supportedFeatures.features[i];

packages/webgpu/cpp/rnwgpu/api/GPUError.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <memory>
+#include <string>
 
 #include "webgpu/webgpu_cpp.h"
 
@@ -13,10 +14,10 @@ class GPUError {
 
 public:
   GPUError(wgpu::ErrorType aType, char const *aMessage)
-      : type(aType), message(aMessage) {}
+      : type(aType), message(aMessage ? aMessage : "") {}
 
   wgpu::ErrorType type;
-  char const *message;
+  std::string message;
 };
 
 } // namespace rnwgpu
@@ -33,8 +34,9 @@ template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUError>> {
   static jsi::Value toJSI(jsi::Runtime &runtime,
                           std::shared_ptr<rnwgpu::GPUError> arg) {
     jsi::Object result(runtime);
-    result.setProperty(runtime, "message",
-                       jsi::String::createFromUtf8(runtime, arg->message));
+    result.setProperty(
+        runtime, "message",
+        jsi::String::createFromUtf8(runtime, arg->message.c_str()));
     return result;
   }
 };

packages/webgpu/cpp/rnwgpu/api/descriptors/Unions.h

@@ -441,7 +441,8 @@ static void convertJSUnionToEnum(const std::string &inUnion,
   } else if (inUnion == "dawn-native") {
     *outEnum = wgpu::FeatureName::DawnNative;
   } else if (inUnion == "chromium-experimental-timestamp-query-inside-passes") {
-    *outEnum = wgpu::FeatureName::ChromiumExperimentalTimestampQueryInsidePasses;
+    *outEnum =
+        wgpu::FeatureName::ChromiumExperimentalTimestampQueryInsidePasses;
   } else if (inUnion == "implicit-device-synchronization") {
     *outEnum = wgpu::FeatureName::ImplicitDeviceSynchronization;
   } else if (inUnion == "transient-attachments") {
@@ -613,7 +614,7 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum,
   case wgpu::FeatureName::ANGLETextureSharing:
     *outUnion = "angle-texture-sharing";
     break;
-    case wgpu::FeatureName::ChromiumExperimentalSubgroupMatrix:
+  case wgpu::FeatureName::ChromiumExperimentalSubgroupMatrix:
     *outUnion = "chromium-experimental-subgroups-matrix";
     break;
   case wgpu::FeatureName::PixelLocalStorageCoherent:

packages/webgpu/src/__tests__/ErrorScope.spec.ts

@@ -0,0 +1,70 @@
+import { client } from "./setup";
+
+describe("Error Scope", () => {
+  it("should capture and return error messages from popErrorScope", async () => {
+    const result = await client.eval(({ device }) => {
+      // Invalid WGSL shader with syntax error (missing closing parenthesis)
+      const invalidShaderWGSL = `@fragment
+fn main() -> @location(0) vec4f {
+  return vec4(1.0, 0.0, 0.0, 1.0;
+}`;
+
+      device.pushErrorScope("validation");
+
+      // This should generate a validation error due to syntax error
+      device.createShaderModule({
+        code: invalidShaderWGSL,
+      });
+
+      return device.popErrorScope().then((error) => {
+        if (error) {
+          return {
+            hasError: true,
+            message: error.message,
+            messageLength: error.message.length,
+            messageNotEmpty: error.message.length > 0,
+            messageContainsExpected:
+              error.message.includes("expected") ||
+              error.message.includes("error") ||
+              error.message.includes("parsing"),
+          };
+        } else {
+          return {
+            hasError: false,
+            message: "",
+            messageLength: 0,
+            messageNotEmpty: false,
+            messageContainsExpected: false,
+          };
+        }
+      });
+    });
+
+    expect(result.hasError).toBe(true);
+    expect(result.messageNotEmpty).toBe(true);
+    expect(result.messageLength).toBeGreaterThan(0);
+    // The error message should contain some indication that it's a parsing error
+    expect(result.messageContainsExpected).toBe(true);
+  });
+
+  it("should return null when no error occurs", async () => {
+    const result = await client.eval(({ device, shaders: { redFragWGSL } }) => {
+      device.pushErrorScope("validation");
+
+      // This should not generate any errors
+      device.createShaderModule({
+        code: redFragWGSL,
+      });
+
+      return device.popErrorScope().then((error) => {
+        return {
+          hasError: error !== null,
+          error: error,
+        };
+      });
+    });
+
+    expect(result.hasError).toBe(false);
+    expect(result.error).toBe(null);
+  });
+});