From 7185c03f75e507c67c06e1342217b114ca171329 Mon Sep 17 00:00:00 2001
From: Kevin Parsons <kevpar@microsoft.com>
Date: Wed, 8 May 2019 15:52:52 -0700
Subject: [PATCH] pkg/guid: Prefer passing GUID by value

Signed-off-by: Kevin Parsons <kevpar@microsoft.com>
---
 pkg/guid/guid.go      | 30 +++++++++++++++---------------
 pkg/guid/guid_test.go | 12 ++++++------
 2 files changed, 21 insertions(+), 21 deletions(-)

diff --git a/pkg/guid/guid.go b/pkg/guid/guid.go
index cc50972..3c112d2 100644
--- a/pkg/guid/guid.go
+++ b/pkg/guid/guid.go
@@ -12,7 +12,7 @@ import (
 	"golang.org/x/sys/windows"
 )
 
-var _ = (json.Marshaler)(&GUID{})
+var _ = (json.Marshaler)(GUID{})
 var _ = (json.Unmarshaler)(&GUID{})
 
 // GUID represents a GUID/UUID. It has the same structure as
@@ -23,10 +23,10 @@ var _ = (json.Unmarshaler)(&GUID{})
 type GUID windows.GUID
 
 // NewV4 returns a new version 4 (pseudorandom) GUID, as defined by RFC 4122.
-func NewV4() (*GUID, error) {
+func NewV4() (GUID, error) {
 	var b [16]byte
 	if _, err := rand.Read(b[:]); err != nil {
-		return nil, err
+		return GUID{}, err
 	}
 
 	var g GUID
@@ -37,10 +37,10 @@ func NewV4() (*GUID, error) {
 
 	g.Data3 = (g.Data3 & 0x0fff) | 0x4000   // Version 4 (randomly generated)
 	g.Data4[0] = (g.Data4[0] & 0x3f) | 0x80 // RFC4122 variant
-	return &g, nil
+	return g, nil
 }
 
-func (g *GUID) String() string {
+func (g GUID) String() string {
 	return fmt.Sprintf(
 		"%08x-%04x-%04x-%04x-%012x",
 		g.Data1,
@@ -53,48 +53,48 @@ func (g *GUID) String() string {
 // FromString parses a string containing a GUID and returns the GUID. The only
 // format currently supported is the `xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx`
 // format.
-func FromString(s string) (*GUID, error) {
+func FromString(s string) (GUID, error) {
 	if len(s) != 36 {
-		return nil, errors.New("invalid GUID format (length)")
+		return GUID{}, errors.New("invalid GUID format (length)")
 	}
 	if s[8] != '-' || s[13] != '-' || s[18] != '-' || s[23] != '-' {
-		return nil, errors.New("invalid GUID format (dashes)")
+		return GUID{}, errors.New("invalid GUID format (dashes)")
 	}
 
 	var g GUID
 
 	data1, err := strconv.ParseUint(s[0:8], 16, 32)
 	if err != nil {
-		return nil, errors.Wrap(err, "invalid GUID format (Data1)")
+		return GUID{}, errors.Wrap(err, "invalid GUID format (Data1)")
 	}
 	g.Data1 = uint32(data1)
 
 	data2, err := strconv.ParseUint(s[9:13], 16, 16)
 	if err != nil {
-		return nil, errors.Wrap(err, "invalid GUID format (Data2)")
+		return GUID{}, errors.Wrap(err, "invalid GUID format (Data2)")
 	}
 	g.Data2 = uint16(data2)
 
 	data3, err := strconv.ParseUint(s[14:18], 16, 16)
 	if err != nil {
-		return nil, errors.Wrap(err, "invalid GUID format (Data3)")
+		return GUID{}, errors.Wrap(err, "invalid GUID format (Data3)")
 	}
 	g.Data3 = uint16(data3)
 
 	for i, x := range []int{19, 21, 24, 26, 28, 30, 32, 34} {
 		v, err := strconv.ParseUint(s[x:x+2], 16, 8)
 		if err != nil {
-			return nil, errors.Wrap(err, "invalid GUID format (Data4)")
+			return GUID{}, errors.Wrap(err, "invalid GUID format (Data4)")
 		}
 		g.Data4[i] = uint8(v)
 	}
 
-	return &g, nil
+	return g, nil
 }
 
 // MarshalJSON marshals the GUID to JSON representation and returns it as a
 // slice of bytes.
-func (g *GUID) MarshalJSON() ([]byte, error) {
+func (g GUID) MarshalJSON() ([]byte, error) {
 	return json.Marshal(g.String())
 }
 
@@ -105,6 +105,6 @@ func (g *GUID) UnmarshalJSON(data []byte) error {
 	if err != nil {
 		return err
 	}
-	*g = *g2
+	*g = g2
 	return nil
 }
diff --git a/pkg/guid/guid_test.go b/pkg/guid/guid_test.go
index 9123cda..9bf37e6 100644
--- a/pkg/guid/guid_test.go
+++ b/pkg/guid/guid_test.go
@@ -15,7 +15,7 @@ func Test_New(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	if *g == *g2 {
+	if g == g2 {
 		t.Fatalf("GUIDs are equal: %s, %s", g, g2)
 	}
 }
@@ -49,7 +49,7 @@ func Test_MarshalJSON(t *testing.T) {
 
 func Test_MarshalJSON_Nested(t *testing.T) {
 	type test struct {
-		G *GUID
+		G GUID
 	}
 	g, err := NewV4()
 	if err != nil {
@@ -79,14 +79,14 @@ func Test_UnmarshalJSON(t *testing.T) {
 	if err := json.Unmarshal(j, &g2); err != nil {
 		t.Fatal(err)
 	}
-	if *g != g2 {
-		t.Fatalf("GUIDs not equal: %s, %s", g, &g2)
+	if g != g2 {
+		t.Fatalf("GUIDs not equal: %s, %s", g, g2)
 	}
 }
 
 func Test_UnmarshalJSON_Nested(t *testing.T) {
 	type test struct {
-		G *GUID
+		G GUID
 	}
 	g, err := NewV4()
 	if err != nil {
@@ -101,7 +101,7 @@ func Test_UnmarshalJSON_Nested(t *testing.T) {
 	if err := json.Unmarshal(j, &t2); err != nil {
 		t.Fatal(err)
 	}
-	if *t1.G != *t2.G {
+	if t1.G != t2.G {
 		t.Fatalf("GUIDs not equal: %v, %v", t1.G, t2.G)
 	}
 }