try fix go case

Signed-off-by: tison <[email protected]>

bindings/c/include/opendal.h

@@ -1314,7 +1314,7 @@ struct opendal_capability opendal_operator_info_get_native_capability(const stru
 /**
  * \brief Frees the heap memory used by the opendal_bytes
  */
-void opendal_bytes_free(struct opendal_bytes *bs);
+void opendal_bytes_free(struct opendal_bytes *ptr);
 
 /**
  * \brief Construct a heap-allocated opendal_operator_options

bindings/c/src/types.rs

@@ -59,9 +59,9 @@ impl opendal_bytes {
 
     /// \brief Frees the heap memory used by the opendal_bytes
     #[no_mangle]
-    pub unsafe extern "C" fn opendal_bytes_free(bs: *mut opendal_bytes) {
-        if !bs.is_null() {
-            let bs = &mut *bs;
+    pub unsafe extern "C" fn opendal_bytes_free(ptr: *mut opendal_bytes) {
+        if !ptr.is_null() {
+            let bs = &mut *ptr;
             if !bs.data.is_null() {
                 drop(Vec::from_raw_parts(bs.data, bs.len, bs.capacity));
                 bs.data = std::ptr::null_mut();

bindings/go/error.go

@@ -77,7 +77,7 @@ func parseError(ctx context.Context, err *opendalError) error {
 	defer free(err)
 	return &Error{
 		code:    ErrorCode(err.code),
-		message: string(parseBytes(&err.message)),
+		message: string(parseBytes(err.message)),
 	}
 }
 

bindings/go/reader.go

@@ -68,8 +68,7 @@ func (op *Operator) Read(path string) ([]byte, error) {
 	data := parseBytes(bytes)
 	if len(data) > 0 {
 		free := getFFI[bytesFree](op.ctx, symBytesFree)
-		free(bytes)
-
+		free(&bytes)
 	}
 	return data, nil
 }
@@ -203,17 +202,17 @@ func (r *Reader) Close() error {
 
 const symOperatorRead = "opendal_operator_read"
 
-type operatorRead func(op *opendalOperator, path string) (*opendalBytes, error)
+type operatorRead func(op *opendalOperator, path string) (opendalBytes, error)
 
 var withOperatorRead = withFFI(ffiOpts{
 	sym:    symOperatorRead,
 	rType:  &typeResultRead,
 	aTypes: []*ffi.Type{&ffi.TypePointer, &ffi.TypePointer},
 }, func(ctx context.Context, ffiCall func(rValue unsafe.Pointer, aValues ...unsafe.Pointer)) operatorRead {
-	return func(op *opendalOperator, path string) (*opendalBytes, error) {
+	return func(op *opendalOperator, path string) (opendalBytes, error) {
 		bytePath, err := unix.BytePtrFromString(path)
 		if err != nil {
-			return nil, err
+			return opendalBytes{}, err
 		}
 		var result resultRead
 		ffiCall(

bindings/go/types.go

@@ -38,7 +38,7 @@ var (
 	typeResultRead = ffi.Type{
 		Type: ffi.Struct,
 		Elements: &[]*ffi.Type{
-			&ffi.TypePointer,
+			&typeBytes,
 			&ffi.TypePointer,
 			nil,
 		}[0],
@@ -217,7 +217,7 @@ type resultOperatorNew struct {
 type opendalOperator struct{}
 
 type resultRead struct {
-	data  *opendalBytes
+	data  opendalBytes
 	error *opendalError
 }
 
@@ -300,8 +300,8 @@ func toOpendalBytes(data []byte) opendalBytes {
 	}
 }
 
-func parseBytes(b *opendalBytes) (data []byte) {
-	if b == nil || b.len == 0 {
+func parseBytes(b opendalBytes) (data []byte) {
+	if b.len == 0 {
 		return nil
 	}
 	data = make([]byte, b.len)

bindings/zig/test/bdd.zig

@@ -57,11 +57,13 @@ test "Opendal BDD test" {
     var testkit = OpendalBDDTest.init();
     defer testkit.deinit();
 
+    const allocator = std.heap.page_allocator;
+    const dupe_content = try allocator.dupeZ(u8, std.mem.span(testkit.content));
     // When Blocking write path "test" with content "Hello, World!"
     const data: opendal.c.opendal_bytes = .{
-        .data = @constCast(testkit.content),
-        .len = std.mem.len(testkit.content),
-        .capacity = std.mem.len(testkit.content),
+        .data = dupe_content.ptr,
+        .len = dupe_content.len,
+        .capacity = dupe_content.len,
     };
     const result = opendal.c.opendal_operator_write(testkit.p, testkit.path, &data);
     try testing.expectEqual(result, null);