fix DeepCopy for *bytes (#80)

Author: zoom-ua

lib/go_emit.js

@@ -213,9 +213,9 @@ exports.GoEmitter = class GoEmitter extends BaseEmitter
     @output "}"
     @output "tmp := ", {frag : true }
     # For pointer-to-type where type has DeepCopy() method, we can simplify
-    # (*x).DeepCopy() to x.DeepCopy(). But for arrays/maps/primitives, we need to dereference.
+    # (*x).DeepCopy() to x.DeepCopy(). But for arrays/maps/primitives/bytes, we need to dereference.
     inner = t[1]
-    can_simplify = (typeof(inner) is 'string' and not @is_primitive_type_lax(inner))
+    can_simplify = (typeof(inner) is 'string' and inner isnt 'bytes' and not @is_primitive_type_lax(inner))
     inner_val = if can_simplify then "x" else "(*x)"
     @deep_copy { t : inner, val : inner_val, exported : true }
     @output "return &tmp"

src/go_emit.iced

@@ -350,6 +350,55 @@ describe 'GoEmitter', () ->
       """)
       return
 
+    it "Should emit a struct with bytes and optional bytes fields", () ->
+      record = {
+        type: "record"
+        name: "BytesRecord"
+        fields: [
+          {
+            type: "bytes",
+            name: "data"
+          },
+          {
+            type: [null, "bytes"],
+            name: "optionalData"
+          }
+        ]
+      }
+      emitter.emit_record record
+      code = emitter._code.join "\n"
+
+      expect(code).toBe("""
+        type BytesRecord struct {
+        \tData\t[]byte\t`codec:"data" json:"data"`
+        \tOptionalData\t*[]byte\t`codec:"optionalData,omitempty" json:"optionalData,omitempty"`
+        }
+
+        func (o BytesRecord) DeepCopy() BytesRecord {
+        \treturn BytesRecord{
+        \t\tData: (func (x []byte) []byte {
+        \t\t\tif x == nil {
+        \t\t\t\treturn nil
+        \t\t\t}
+        \t\t\treturn append([]byte{}, x...)
+        \t\t})(o.Data),
+        \t\tOptionalData: (func (x *[]byte) *[]byte {
+        \t\t\tif x == nil {
+        \t\t\t\treturn nil
+        \t\t\t}
+        \t\t\ttmp := (func (x []byte) []byte {
+        \t\t\t\tif x == nil {
+        \t\t\t\t\treturn nil
+        \t\t\t\t}
+        \t\t\t\treturn append([]byte{}, x...)
+        \t\t\t})((*x))
+        \t\t\treturn &tmp
+        \t\t})(o.OptionalData),
+        \t}
+        }\n
+      """)
+      return
+
     return
 
 

src/go_emit.test.iced

@@ -84,6 +84,19 @@ protocol sample {
 		union {null, array<Blurp>} u;
 	}
 
+	record BytesRecord {
+		bytes data;
+		union {null, bytes} optionalData;
+	}
+
+	record OptionalTypesRecord {
+		union {null, array<int>} optionalArray;
+		union {null, map<string>} optionalMap;
+		union {null, int} optionalInt;
+		union {null, string} optionalString;
+		union {null, boolean} optionalBool;
+	}
+
 	@typedef ("bytes") record Hash {}
 
 	@layout("array")

test/avdl/sample.avdl

@@ -1,5 +1,5 @@
 // Auto-generated to Go types and interfaces using avdl-compiler v1.4.10 (https://github.com/keybase/node-avdl-compiler)
-//   Input file: avdl/sample.avdl
+//   Input file: test/avdl/sample.avdl
 
 package sample1
 
@@ -566,6 +566,103 @@ func (o Simple) DeepCopy() Simple {
 	}
 }
 
+type BytesRecord struct {
+	Data         []byte  `codec:"data" json:"data"`
+	OptionalData *[]byte `codec:"optionalData,omitempty" json:"optionalData,omitempty"`
+}
+
+func (o BytesRecord) DeepCopy() BytesRecord {
+	return BytesRecord{
+		Data: (func(x []byte) []byte {
+			if x == nil {
+				return nil
+			}
+			return append([]byte{}, x...)
+		})(o.Data),
+		OptionalData: (func(x *[]byte) *[]byte {
+			if x == nil {
+				return nil
+			}
+			tmp := (func(x []byte) []byte {
+				if x == nil {
+					return nil
+				}
+				return append([]byte{}, x...)
+			})((*x))
+			return &tmp
+		})(o.OptionalData),
+	}
+}
+
+type OptionalTypesRecord struct {
+	OptionalArray  *[]int             `codec:"optionalArray,omitempty" json:"optionalArray,omitempty"`
+	OptionalMap    *map[string]string `codec:"optionalMap,omitempty" json:"optionalMap,omitempty"`
+	OptionalInt    *int               `codec:"optionalInt,omitempty" json:"optionalInt,omitempty"`
+	OptionalString *string            `codec:"optionalString,omitempty" json:"optionalString,omitempty"`
+	OptionalBool   *bool              `codec:"optionalBool,omitempty" json:"optionalBool,omitempty"`
+}
+
+func (o OptionalTypesRecord) DeepCopy() OptionalTypesRecord {
+	return OptionalTypesRecord{
+		OptionalArray: (func(x *[]int) *[]int {
+			if x == nil {
+				return nil
+			}
+			tmp := (func(x []int) []int {
+				if x == nil {
+					return nil
+				}
+				ret := make([]int, len(x))
+				for i, v := range x {
+					vCopy := v
+					ret[i] = vCopy
+				}
+				return ret
+			})((*x))
+			return &tmp
+		})(o.OptionalArray),
+		OptionalMap: (func(x *map[string]string) *map[string]string {
+			if x == nil {
+				return nil
+			}
+			tmp := (func(x map[string]string) map[string]string {
+				if x == nil {
+					return nil
+				}
+				ret := make(map[string]string, len(x))
+				for k, v := range x {
+					kCopy := k
+					vCopy := v
+					ret[kCopy] = vCopy
+				}
+				return ret
+			})((*x))
+			return &tmp
+		})(o.OptionalMap),
+		OptionalInt: (func(x *int) *int {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.OptionalInt),
+		OptionalString: (func(x *string) *string {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.OptionalString),
+		OptionalBool: (func(x *bool) *bool {
+			if x == nil {
+				return nil
+			}
+			tmp := (*x)
+			return &tmp
+		})(o.OptionalBool),
+	}
+}
+
 type Hash []byte
 
 func (o Hash) DeepCopy() Hash {

test/files/sample.go

@@ -2,7 +2,7 @@
 
 Auto-generated to Python types by avdl-compiler v1.4.10 (https://github.com/keybase/node-avdl-compiler)
 Input files:
- - avdl/sample.avdl
+ - test/avdl/sample.avdl
 """
 
 from dataclasses import dataclass, field
@@ -122,6 +122,19 @@ class Simple(DataClassJsonMixin):
     t: Optional[Blurp] = field(default=None, metadata=config(field_name='t'))
     u: Optional[List[Blurp]] = field(default=None, metadata=config(field_name='u'))
 
+@dataclass
+class BytesRecord(DataClassJsonMixin):
+    data: str = field(metadata=config(field_name='data'))
+    optional_data: Optional[str] = field(default=None, metadata=config(field_name='optionalData'))
+
+@dataclass
+class OptionalTypesRecord(DataClassJsonMixin):
+    optional_array: Optional[List[int]] = field(default=None, metadata=config(field_name='optionalArray'))
+    optional_map: Optional[Dict[str, str]] = field(default=None, metadata=config(field_name='optionalMap'))
+    optional_int: Optional[int] = field(default=None, metadata=config(field_name='optionalInt'))
+    optional_string: Optional[str] = field(default=None, metadata=config(field_name='optionalString'))
+    optional_bool: Optional[bool] = field(default=None, metadata=config(field_name='optionalBool'))
+
 Hash = str
 @dataclass
 class Cat(DataClassJsonMixin):

test/files/sample.py

@@ -4,7 +4,7 @@
  *
  * Auto-generated to TypeScript types by avdl-compiler v1.4.10 (https://github.com/keybase/node-avdl-compiler)
  * Input files:
- * - avdl/sample.avdl
+ * - test/avdl/sample.avdl
  */
 
 import * as keybase1 from 'github.com/keybase/client/go/protocol/keybase1'
@@ -49,6 +49,19 @@ export type Simple = {
   u?: Blurp[] | null
 }
 
+export type BytesRecord = {
+  data: Buffer
+  optionalData?: Buffer
+}
+
+export type OptionalTypesRecord = {
+  optionalArray?: number[] | null
+  optionalMap?: {[key: string]: string}
+  optionalInt?: number
+  optionalString?: string
+  optionalBool?: boolean
+}
+
 export type Hash = Buffer
 
 export type Cat = {