gentypes: Add support for third-party types

The gentypes tool was previously limited to generating optional types for local
types that implemented the MarshalMsgpack and UnmarshalMsgpack methods. Thi
made it impossible to generate optional types for types from external modules.

This commit enhances the generator to support third-party types by introducing
the following new flags:

* -force: To bypass the check for MarshalMsgpack and UnmarshalMsgpack methods.
* -imports: To add necessary imports for the third-party type and custom functions.
* -marshal-func: To specify a custom marshal function.
* -unmarshal-func: To specify a custom unmarshal function.

The generator code has been refactored to use a GenerateOptions struct for
better organization.

Additionally, this commit:

* Adds a new test case for generating an optional type for uuid.UUID.
* Updates the README.md with documentation for the new flags and an example.
* Moves test files to a more appropriate internal/test directory.

Closes #TNTP-3734.

Author: bigbes

.golangci.yml

@@ -57,6 +57,7 @@ linters:
             - "golang.org/x/tools"
             - "github.com/vmihailenco/msgpack/v5"
             - "github.com/tarantool/go-option"
+            - "github.com/google/uuid"
         test:
           files:
             - "$test"

README.md

@@ -66,10 +66,65 @@ Or you can use it to generate file from go:
 
 Flags:
 
- • `-package`: Path to the Go package containing types to wrap (default: `"."`)
- • `-ext-code`: MessagePack extension code to use for custom types (must be between
+ * `-package`: Path to the Go package containing types to wrap (default: `"."`)
+ * `-ext-code`: MessagePack extension code to use for custom types (must be between
    -128 and 127, no default value)
- • `-verbose`: Enable verbose output (default: `false`)
+ * `-verbose`: Enable verbose output (default: `false`)
+ * `-force`: Ignore absence of marshal/unmarshal methods on type (default: `false`).
+   Helpful for types from third-party modules.
+ * `-imports`: Add imports to generated file (default is empty).
+   Helpful for types from third-party modules.
+ * `-marshal-func`: func that should do marshaling (default is `MarshalMsgpack` method).
+   Helpful for types from third-party modules.
+   Should be func of type `func(v T) ([]byte, error)` and should
+   be located in the same dir or should be imported.
+ * `-unmarshal-func`: func that should do unmarshalling (default is `UnmarshalMsgpack` method).
+   Helpful for types from third-party modules.
+   Should be func of type `func(v *T, data []byte) error` and should
+   be located in the same dir or should be imported.
+
+#### Generating Optional Types for Third-Party Modules
+
+Sometimes you need to generate an optional type for a type from a third-party module,
+and you can't add `MarshalMsgpack`/`UnmarshalMsgpack` methods to it.
+In this case, you can use the `-force`, `-imports`, `-marshal-func`, and `-unmarshal-func` flags.
+
+For example, to generate an optional type for `github.com/google/uuid.UUID`:
+
+1.  Create a file with marshal and unmarshal functions for the third-party type.
+    For example, `uuid.go`:
+
+    ```go
+    package main
+
+    import (
+        "errors"
+
+        "github.com/google/uuid"
+    )
+
+    func encodeUUID(uuid uuid.UUID) ([]byte, error) {
+        return uuid[:], nil
+    }
+
+    var (
+        ErrInvalidLength = errors.New("invalid length")
+    )
+
+    func decodeUUID(uuid *uuid.UUID, data []byte) error {
+        if len(data) != len(uuid) {
+            return ErrInvalidLength
+        }
+        copy(uuid[:], data)
+        return nil
+    }
+    ```
+
+2.  Use the following `go:generate` command:
+
+    ```go
+    //go:generate go run github.com/tarantool/go-option/cmd/gentypes@latest -package . -imports "github.com/google/uuid" -type UUID -marshal-func "encodeUUID" -unmarshal-func "decodeUUID" -force -ext-code 100
+    ```
 
 #### Using Generated Types
 

cmd/gentypes/flag.go

@@ -0,0 +1,34 @@
+package main
+
+import (
+	"maps"
+	"slices"
+	"strings"
+)
+
+type stringListFlag []string
+
+func (s *stringListFlag) String() string {
+	return strings.Join(*s, ", ")
+}
+
+func (s *stringListFlag) Set(s2 string) error {
+	*s = append(*s, s2)
+	return nil
+}
+
+func deleteDuplicates(s stringListFlag) stringListFlag {
+	uniqMap := map[string]struct{}{}
+	for _, val := range s {
+		uniqMap[val] = struct{}{}
+	}
+
+	return slices.Collect(maps.Keys(uniqMap))
+}
+
+func (s *stringListFlag) Get() []string {
+	deduped := deleteDuplicates(*s)
+	slices.Sort(deduped)
+
+	return deduped
+}

cmd/gentypes/generate.go

@@ -1,2 +1,5 @@
-//go:generate go run github.com/tarantool/go-option/cmd/gentypes -ext-code 1 -package test FullMsgpackExtType
+//go:generate go run github.com/tarantool/go-option/cmd/gentypes -ext-code 1 -package internal/test FullMsgpackExtType
+//go:generate go run github.com/tarantool/go-option/cmd/gentypes -ext-code 2 -force -package internal/test HiddenTypeAlias
+//go:generate go run github.com/tarantool/go-option/cmd/gentypes -ext-code 3 -imports github.com/google/uuid -package internal/test -marshal-func encodeUUID -unmarshal-func decodeUUID uuid.UUID
+
 package main

cmd/gentypes/generator/extension.go

@@ -6,6 +6,7 @@ import (
 	_ "embed"
 	"fmt"
 	"strconv"
+	"strings"
 	"text/template"
 )
 
@@ -26,22 +27,72 @@ func InitializeTemplates() {
 	cTypeGenTestTemplate = template.Must(template.New("type_gen_test.go.tpl").Parse(typeGenTestTemplate))
 }
 
+const (
+	maxNameParts = 2
+)
+
+func constructTypeName(typeName string) string {
+	splittedName := strings.SplitN(typeName, ".", maxNameParts)
+	switch len(splittedName) {
+	case 1:
+		typeName = splittedName[0]
+	case maxNameParts:
+		typeName = splittedName[1]
+	default:
+		panic("invalid type name: " + typeName)
+	}
+
+	return "Optional" + typeName
+}
+
+// GenerateOptions is the options for the code generation.
+type GenerateOptions struct {
+	// TypeName is the name of the type to generate optional to.
+	TypeName string
+	// ExtCode is the extension code.
+	ExtCode int
+	// PackageName is the name of the package to generate to.
+	PackageName string
+	// Imports is the list of imports to add to the generated code.
+	Imports []string
+	// CustomMarshalFunc is the name of the custom marshal function.
+	CustomMarshalFunc string
+	// CustomUnmarshalFunc is the name of the custom unmarshal function.
+	CustomUnmarshalFunc string
+}
+
 // GenerateByType generates the code for the optional type.
-func GenerateByType(typeName string, code int, packageName string) ([]byte, error) {
+func GenerateByType(opts GenerateOptions) ([]byte, error) {
 	var buf bytes.Buffer
 
+	if opts.CustomMarshalFunc == "" {
+		opts.CustomMarshalFunc = "o.value.MarshalMsgpack()"
+	} else {
+		opts.CustomMarshalFunc += "(o.value)"
+	}
+
+	if opts.CustomUnmarshalFunc == "" {
+		opts.CustomUnmarshalFunc = "o.value.UnmarshalMsgpack(a)"
+	} else {
+		opts.CustomUnmarshalFunc += "(&o.value, a)"
+	}
+
 	err := cTypeGenTemplate.Execute(&buf, struct {
-		Name        string
-		Type        string
-		ExtCode     string
-		PackageName string
-		Imports     []string
+		Name                string
+		Type                string
+		ExtCode             string
+		PackageName         string
+		Imports             []string
+		CustomMarshalFunc   string
+		CustomUnmarshalFunc string
 	}{
-		Name:        "Optional" + typeName,
-		Type:        typeName,
-		ExtCode:     strconv.Itoa(code),
-		PackageName: packageName,
-		Imports:     nil,
+		Name:                constructTypeName(opts.TypeName),
+		Type:                opts.TypeName,
+		ExtCode:             strconv.Itoa(opts.ExtCode),
+		PackageName:         opts.PackageName,
+		Imports:             opts.Imports,
+		CustomMarshalFunc:   opts.CustomMarshalFunc,
+		CustomUnmarshalFunc: opts.CustomUnmarshalFunc,
 	})
 	if err != nil {
 		return nil, fmt.Errorf("failed to generateByType: %w", err)

cmd/gentypes/generator/type_gen.go.tpl

@@ -153,7 +153,7 @@ func (o {{.Name}}) UnwrapOrElse(defaultValue func() {{.Type}}) {{.Type}} {
 }
 
 func (o {{.Name}}) encodeValue(encoder *msgpack.Encoder) error {
-	value, err := o.value.MarshalMsgpack()
+	value, err := {{ .CustomMarshalFunc }}
 	if err != nil {
 		return err
 	}
@@ -199,7 +199,7 @@ func (o *{{.Name}}) decodeValue(decoder *msgpack.Decoder) error {
 		return o.newDecodeError(err)
 	}
 
-	if err := o.value.UnmarshalMsgpack(a); err != nil {
+	if err := {{ .CustomUnmarshalFunc }}; err != nil {
 		return o.newDecodeError(err)
 	}