add go/starlark helper methods for dataconv/types types

dataconv/types/hybrid.go

@@ -155,21 +155,31 @@ func (p *StringOrBytes) Unpack(v starlark.Value) error {
 	return nil
 }
 
-// GoBytes returns the Go byte slice representation of the StringOrBytes.
-func (p StringOrBytes) GoBytes() []byte {
-	return []byte(p)
-}
-
 // GoString returns the Go string representation of the StringOrBytes.
 func (p StringOrBytes) GoString() string {
 	return string(p)
 }
 
+// GoBytes returns the Go byte slice representation of the StringOrBytes.
+func (p StringOrBytes) GoBytes() []byte {
+	return []byte(p)
+}
+
 // StarlarkString returns the Starlark string representation of the StringOrBytes.
 func (p StringOrBytes) StarlarkString() starlark.String {
 	return starlark.String(p)
 }
 
+// StarlarkBytes returns the Starlark bytes representation of the StringOrBytes.
+func (p StringOrBytes) StarlarkBytes() starlark.Bytes {
+	return starlark.Bytes(p)
+}
+
+// IsEmpty returns true if the underlying value is an empty string.
+func (p StringOrBytes) IsEmpty() bool {
+	return p.GoString() == emptyStr
+}
+
 // NullableStringOrBytes is an Unpacker that converts a Starlark None or string to Go's string.
 type NullableStringOrBytes struct {
 	str *string
@@ -210,6 +220,30 @@ func (p *NullableStringOrBytes) GoString() string {
 	return *p.str
 }
 
+// GoBytes returns the Go byte slice representation of the NullableStringOrBytes, if the underlying value is nil, it returns nil.
+func (p *NullableStringOrBytes) GoBytes() []byte {
+	if p == nil || p.str == nil {
+		return nil
+	}
+	return []byte(*p.str)
+}
+
+// StarlarkString returns the Starlark string representation of the NullableStringOrBytes, if the underlying value is nil, it returns a Starlark string with an empty string.
+func (p *NullableStringOrBytes) StarlarkString() starlark.String {
+	if p == nil || p.str == nil {
+		return ""
+	}
+	return starlark.String(*p.str)
+}
+
+// StarlarkBytes returns the Starlark bytes representation of the NullableStringOrBytes, if the underlying value is nil, it returns a Starlark bytes with an empty string.
+func (p *NullableStringOrBytes) StarlarkBytes() starlark.Bytes {
+	if p == nil || p.str == nil {
+		return ""
+	}
+	return starlark.Bytes(*p.str)
+}
+
 // IsNull returns true if the underlying value is nil.
 func (p *NullableStringOrBytes) IsNull() bool {
 	return p == nil || p.str == nil

dataconv/types/hybrid_test.go

@@ -2,6 +2,7 @@ package types
 
 import (
 	"math"
+	"reflect"
 	"runtime"
 	"testing"
 
@@ -437,12 +438,14 @@ func TestStringOrBytes_Stringer(t *testing.T) {
 		v        StringOrBytes
 		wantGo   string
 		wantStar starlark.String
+		empty    bool
 	}{
 		{
 			name:     "empty",
 			v:        "",
 			wantGo:   "",
 			wantStar: starlark.String(""),
+			empty:    true,
 		},
 		{
 			name:     "string",
@@ -468,6 +471,12 @@ func TestStringOrBytes_Stringer(t *testing.T) {
 			if got := tt.v.StarlarkString(); got != tt.wantStar {
 				t.Errorf("StringOrBytes.StarlarkString() = %v, want %v", got, tt.wantStar)
 			}
+			if got := tt.v.StarlarkBytes(); got != starlark.Bytes(tt.wantStar) {
+				t.Errorf("StringOrBytes.StarlarkBytes() = %v, want %v", got, starlark.Bytes(tt.wantStar))
+			}
+			if got := tt.v.IsEmpty(); got != tt.empty {
+				t.Errorf("StringOrBytes.IsEmpty() = %v, want %v", got, tt.empty)
+			}
 		})
 	}
 }
@@ -517,50 +526,71 @@ func TestNullableStringOrBytes_Methods(t *testing.T) {
 	tests := []struct {
 		name        string
 		str         *NullableStringOrBytes
-		wantStr     string
+		wantGoStr   string
+		wantGoBytes []byte
+		wantStarStr starlark.String
 		wantIsNull  bool
 		wantIsEmpty bool
 	}{
 		{
 			name:        "nil",
 			str:         nil,
-			wantStr:     "",
+			wantGoStr:   "",
+			wantGoBytes: nil,
+			wantStarStr: starlark.String(""),
 			wantIsNull:  true,
 			wantIsEmpty: true,
 		},
 		{
 			name:        "nil value",
 			str:         &NullableStringOrBytes{},
-			wantStr:     "",
+			wantGoStr:   "",
+			wantGoBytes: nil,
+			wantStarStr: starlark.String(""),
 			wantIsNull:  true,
 			wantIsEmpty: true,
 		},
 		{
 			name:        "no default",
 			str:         NewNullableStringOrBytesNoDefault(),
-			wantStr:     "",
+			wantGoStr:   "",
+			wantGoBytes: nil,
+			wantStarStr: starlark.String(""),
 			wantIsNull:  true,
 			wantIsEmpty: true,
 		},
 		{
 			name:        "empty string",
 			str:         NewNullableStringOrBytes(""),
-			wantStr:     "",
+			wantGoStr:   "",
+			wantGoBytes: []byte{},
+			wantStarStr: starlark.String(""),
 			wantIsNull:  false,
 			wantIsEmpty: true,
 		},
 		{
 			name:        "non-empty string",
 			str:         NewNullableStringOrBytes("hello"),
-			wantStr:     "hello",
+			wantGoStr:   "hello",
+			wantGoBytes: []byte("hello"),
+			wantStarStr: starlark.String("hello"),
 			wantIsNull:  false,
 			wantIsEmpty: false,
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			if gotStr := tt.str.GoString(); gotStr != tt.wantStr {
-				t.Errorf("NullableStringOrBytes.GoString() = %v, want %v", gotStr, tt.wantStr)
+			if gotStr := tt.str.GoString(); gotStr != tt.wantGoStr {
+				t.Errorf("NullableStringOrBytes.GoString() = %v, want %v", gotStr, tt.wantGoStr)
+			}
+			if gotBytes := tt.str.GoBytes(); !reflect.DeepEqual(gotBytes, tt.wantGoBytes) {
+				t.Errorf("NullableStringOrBytes.GoBytes() = %v, want %v", gotBytes, tt.wantGoBytes)
+			}
+			if gotStr := tt.str.StarlarkString(); gotStr != tt.wantStarStr {
+				t.Errorf("NullableStringOrBytes.StarlarkString() = %v, want %v", gotStr, tt.wantStarStr)
+			}
+			if gotStr := tt.str.StarlarkBytes(); gotStr != starlark.Bytes(tt.wantStarStr) {
+				t.Errorf("NullableStringOrBytes.StarlarkBytes() = %v, want %v", gotStr, starlark.Bytes(tt.wantStarStr))
 			}
 			if gotIsNull := tt.str.IsNull(); gotIsNull != tt.wantIsNull {
 				t.Errorf("NullableStringOrBytes.IsNull() = %v, want %v", gotIsNull, tt.wantIsNull)

lib/atom/atom.go

@@ -48,7 +48,7 @@ var (
 )
 
 func newInt(thread *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
-	var value int64 = 0
+	var value int64
 	if err := starlark.UnpackArgs(b.Name(), args, kwargs, "value?", &value); err != nil {
 		return nil, err
 	}
@@ -184,7 +184,7 @@ type AtomicString struct {
 }
 
 func newString(thread *starlark.Thread, b *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
-	var value string = ""
+	var value string
 	if err := starlark.UnpackArgs(b.Name(), args, kwargs, "value?", &value); err != nil {
 		return nil, err
 	}