feat: lift interface{} params to Ref<T> for reflection decoders (#219)

Author: ivov

bindgen/bindgen.external.json

@@ -1813,6 +1813,44 @@
         "periph.io/x/conn/v3/pin": [
           "*"
         ]
+      },
+      "reflection_decode": {
+        "github.com/spf13/viper": [
+          "Unmarshal",
+          "UnmarshalKey",
+          "UnmarshalExact",
+          "Viper.Unmarshal",
+          "Viper.UnmarshalKey",
+          "Viper.UnmarshalExact"
+        ],
+        "gopkg.in/yaml.v3": [
+          "Unmarshal",
+          "Decoder.Decode"
+        ],
+        "gopkg.in/yaml.v2": [
+          "Unmarshal",
+          "UnmarshalStrict",
+          "Decoder.Decode"
+        ],
+        "github.com/goccy/go-yaml": [
+          "Unmarshal",
+          "UnmarshalWithOptions",
+          "Decoder.Decode"
+        ],
+        "github.com/BurntSushi/toml": [
+          "Unmarshal",
+          "Decoder.Decode"
+        ],
+        "github.com/pelletier/go-toml/v2": [
+          "Unmarshal",
+          "Decoder.Decode"
+        ],
+        "github.com/go-viper/mapstructure/v2": [
+          "Decode",
+          "WeakDecode",
+          "DecodeMetadata",
+          "WeakDecodeMetadata"
+        ]
       }
     }
   }

bindgen/bindgen.stdlib.json

@@ -379,6 +379,12 @@
         "image/color": ["*"],
         "io/ioutil": ["Discard"],
         "unicode": ["*"]
+      },
+      "reflection_decode": {
+        "encoding/json": ["Unmarshal", "Decoder.Decode"],
+        "encoding/xml": ["Unmarshal", "Decoder.Decode", "Decoder.DecodeElement"],
+        "encoding/gob": ["Decoder.Decode"],
+        "encoding/binary": ["Read"]
       }
     }
   }

bindgen/internal/config/config.go

@@ -39,6 +39,10 @@ type TypeOverrides struct {
 	// "absent" with `-1`. Bindgen rewrites the return to `Option<int>`
 	// and emits `#[go(sentinel_minus_one)]`.
 	SentinelMinusOne map[string][]string `json:"sentinel_minus_one"`
+	// ReflectionDecode declares functions whose `interface{}` params reach
+	// Go reflection; each such param is lifted to a fresh `T` and rewritten
+	// to `Ref<T>`.
+	ReflectionDecode map[string][]string `json:"reflection_decode"`
 }
 
 // LoadConfig loads bindgen configuration from the given path.
@@ -195,6 +199,20 @@ func (c *Config) SentinelInt(pkg, name string) (int, bool) {
 	return 0, false
 }
 
+// IsReflectionDecode reports whether the given function or method is
+// configured to lift its `interface{}` params to `Ref<T>`. Uses "Type.Method"
+// dot notation for methods.
+func (c *Config) IsReflectionDecode(pkg, name string) bool {
+	if c == nil {
+		return false
+	}
+	names, ok := lookupWithGlob(c.Overrides.Types.ReflectionDecode, pkg)
+	if !ok {
+		return false
+	}
+	return matchesWildcard(names, name)
+}
+
 // IsNeverReturn returns true if the given function or method in the given
 // package never returns normally (e.g., os.Exit, log.Fatal).
 func (c *Config) IsNeverReturn(pkg, name string) bool {

bindgen/internal/convert/converters.go

@@ -39,6 +39,62 @@ func isReferenceType(typeStr string) bool {
 	return strings.HasPrefix(typeStr, "Slice<") || strings.HasPrefix(typeStr, "Map<")
 }
 
+// liftReflectionDecodeParams returns (specs, nil) when not whitelisted or no
+// `interface{}` params are liftable; the index map encodes per-param Ref<T>
+// rewrites for the caller to apply during the param loop.
+func (c *Converter) liftReflectionDecodeParams(
+	sig *types.Signature,
+	qualifiedName string,
+	specs TypeParamSpecs,
+) (TypeParamSpecs, map[int]string) {
+	if !c.cfg.IsReflectionDecode(c.currentPkgPath, qualifiedName) {
+		return specs, nil
+	}
+	used := make(map[string]bool, len(specs))
+	for _, s := range specs {
+		used[s.Name] = true
+	}
+	var overrides map[int]string
+	params := sig.Params()
+	for i := 0; i < params.Len(); i++ {
+		if sig.Variadic() && i == params.Len()-1 {
+			continue
+		}
+		t := params.At(i).Type()
+		for {
+			alias, ok := t.(*types.Alias)
+			if !ok {
+				break
+			}
+			t = alias.Rhs()
+		}
+		iface, ok := t.(*types.Interface)
+		if !ok || !iface.Empty() || isErrorInterface(iface) {
+			continue
+		}
+		name := freshTypeParamName(used)
+		used[name] = true
+		specs = append(specs, TypeParamSpec{Name: name})
+		if overrides == nil {
+			overrides = make(map[int]string)
+		}
+		overrides[i] = fmt.Sprintf("Ref<%s>", name)
+	}
+	return specs, overrides
+}
+
+func freshTypeParamName(used map[string]bool) string {
+	if !used["T"] {
+		return "T"
+	}
+	for n := 2; ; n++ {
+		candidate := fmt.Sprintf("T%d", n)
+		if !used[candidate] {
+			return candidate
+		}
+	}
+}
+
 func (c *Converter) convertFunction(result *ConvertResult, symbolExport extract.SymbolExport) {
 	signature, ok := symbolExport.GoType.(*types.Signature)
 	if !ok {
@@ -58,6 +114,9 @@ func (c *Converter) convertFunction(result *ConvertResult, symbolExport extract.
 	c.typeParamSubstitutions = substitutions
 	defer func() { c.typeParamSubstitutions = prevSubs }()
 
+	liftedSpecs, paramOverrides := c.liftReflectionDecodeParams(signature, result.Name, result.TypeParams)
+	result.TypeParams = liftedSpecs
+
 	mutParams := c.cfg.MutatingParams(c.currentPkgPath, result.Name)
 
 	params := signature.Params()
@@ -73,6 +132,9 @@ func (c *Converter) convertFunction(result *ConvertResult, symbolExport extract.
 		if signature.Variadic() && i == params.Len()-1 {
 			typeStr = sliceToVarArgs(typeStr)
 		}
+		if override, ok := paramOverrides[i]; ok {
+			typeStr = override
+		}
 
 		name := param.Name()
 		if name == "" {
@@ -204,6 +266,13 @@ func (c *Converter) convertMethod(result *ConvertResult, symbolExport extract.Sy
 		qualifiedName = result.Receiver.BaseTypeName + "." + result.Name
 	}
 
+	methodSpecs, _, skip := collectTypeParams(signature.TypeParams(), false, c)
+	if skip != nil {
+		result.SkipReason = skip
+		return
+	}
+	liftedSpecs, paramOverrides := c.liftReflectionDecodeParams(signature, qualifiedName, methodSpecs)
+
 	mutParams := c.cfg.MutatingParams(c.currentPkgPath, qualifiedName)
 
 	params := signature.Params()
@@ -219,6 +288,9 @@ func (c *Converter) convertMethod(result *ConvertResult, symbolExport extract.Sy
 		if signature.Variadic() && i == params.Len()-1 {
 			typeStr = sliceToVarArgs(typeStr)
 		}
+		if override, ok := paramOverrides[i]; ok {
+			typeStr = override
+		}
 
 		name := param.Name()
 		if name == "" {
@@ -290,12 +362,7 @@ func (c *Converter) convertMethod(result *ConvertResult, symbolExport extract.Sy
 		}
 	}
 
-	methodSpecs, _, skip := collectTypeParams(signature.TypeParams(), false, c)
-	if skip != nil {
-		result.SkipReason = skip
-		return
-	}
-	result.TypeParams = methodSpecs
+	result.TypeParams = liftedSpecs
 
 	if isFluentBuilderCandidate(result, symbolExport, signature) {
 		if fn := c.findFuncDecl(symbolExport.Obj); fn != nil && isFluentMethod(fn, ncGetReceiverName(fn)) {

bindgen/tests/bindgen_test.go

@@ -10,6 +10,7 @@ import (
 	"testing"
 
 	"github.com/ivov/lisette/bindgen/internal/cli"
+	"github.com/ivov/lisette/bindgen/internal/config"
 )
 
 var update = flag.Bool("update", false, "update snapshot files")
@@ -84,7 +85,17 @@ func snapshotPathFor(fixturePath string) string {
 }
 
 func runBindgen(t *testing.T, pkgPath string) []byte {
-	result, err := cli.GeneratePkg("./"+pkgPath, "0.0.0", "0.0.0", nil)
+	var cfg *config.Config
+	cfgPath := filepath.Join(pkgPath, "bindgen.json")
+	if _, err := os.Stat(cfgPath); err == nil {
+		loaded, err := config.LoadConfig(cfgPath, nil)
+		if err != nil {
+			t.Fatalf("failed to load fixture config %s: %v", cfgPath, err)
+		}
+		cfg = &loaded
+	}
+
+	result, err := cli.GeneratePkg("./"+pkgPath, "0.0.0", "0.0.0", cfg)
 	if err != nil {
 		t.Fatalf("bindgen failed: %v", err)
 	}

bindgen/tests/testdata/fixtures/reflection_decode/bindgen.json

@@ -0,0 +1,18 @@
+{
+  "overrides": {
+    "types": {
+      "reflection_decode": {
+        "github.com/ivov/lisette/bindgen/tests/testdata/fixtures/reflection_decode": [
+          "Unmarshal",
+          "UnmarshalKey",
+          "DecodeBoth",
+          "ScanRow",
+          "DecodeWithErr",
+          "DecodeAny",
+          "Decoder.Decode",
+          "Codec.Unmarshal"
+        ]
+      }
+    }
+  }
+}

bindgen/tests/testdata/fixtures/reflection_decode/reflection_decode.go

@@ -0,0 +1,35 @@
+package reflection_decode
+
+// Pointer-out shape: json.Unmarshal-like.
+func Unmarshal(data []byte, v interface{}) error { return nil }
+
+// Key + pointer-out shape: viper.UnmarshalKey-like.
+func UnmarshalKey(key string, v interface{}) error { return nil }
+
+// Multiple interface{} params: each lifts to its own T_n.
+func DecodeBoth(src interface{}, dst interface{}) error { return nil }
+
+// Variadic interface{} is intentionally NOT lifted (sql.Rows.Scan-shape).
+func ScanRow(dest ...interface{}) error { return nil }
+
+// Method on a value receiver.
+type Decoder struct{}
+
+func (d Decoder) Decode(v interface{}) error { return nil }
+
+// Method on a pointer receiver, plus a non-whitelisted method that should
+// keep its `interface{}` param as `Unknown`.
+type Codec struct{}
+
+func (c *Codec) Unmarshal(data []byte, v interface{}) error { return nil }
+
+func (c *Codec) Set(v interface{}) {}
+
+// Non-whitelisted free function with `interface{}` — stays `Unknown`.
+func Log(v interface{}) {}
+
+// `error` interface must NOT be lifted, even when whitelisted.
+func DecodeWithErr(v interface{}, err error) error { return err }
+
+// Param typed as `any` (alias for `interface{}`) must also be lifted.
+func DecodeAny(v any) error { return nil }

bindgen/tests/testdata/snapshots/reflection_decode.d.lis

@@ -0,0 +1,41 @@
+// Generated by Lisette bindgen
+// Source: ./testdata/fixtures/reflection_decode (local)
+// Go: 0.0.0
+// Lisette: 0.0.0
+
+/// Param typed as `any` (alias for `interface{}`) must also be lifted.
+pub fn DecodeAny<T>(v: Ref<T>) -> Result<(), error>
+
+/// Multiple interface{} params: each lifts to its own T_n.
+pub fn DecodeBoth<T, T2>(src: Ref<T>, dst: Ref<T2>) -> Result<(), error>
+
+/// `error` interface must NOT be lifted, even when whitelisted.
+pub fn DecodeWithErr<T>(v: Ref<T>, err: error) -> Result<(), error>
+
+/// Non-whitelisted free function with `interface{}` — stays `Unknown`.
+pub fn Log(v: Unknown)
+
+/// Variadic interface{} is intentionally NOT lifted (sql.Rows.Scan-shape).
+pub fn ScanRow(dest: VarArgs<Unknown>) -> Result<(), error>
+
+/// Pointer-out shape: json.Unmarshal-like.
+pub fn Unmarshal<T>(data: Slice<uint8>, v: Ref<T>) -> Result<(), error>
+
+/// Key + pointer-out shape: viper.UnmarshalKey-like.
+pub fn UnmarshalKey<T>(key: string, v: Ref<T>) -> Result<(), error>
+
+/// Method on a pointer receiver, plus a non-whitelisted method that should
+/// keep its `interface{}` param as `Unknown`.
+pub type Codec
+
+/// Method on a value receiver.
+pub type Decoder
+
+impl Codec {
+  fn Set(self: Ref<Codec>, v: Unknown)
+  fn Unmarshal<T>(self: Ref<Codec>, data: Slice<uint8>, v: Ref<T>) -> Result<(), error>
+}
+
+impl Decoder {
+  fn Decode<T>(self, v: Ref<T>) -> Result<(), error>
+}

crates/stdlib/typedefs/encoding/binary.d.lis

@@ -55,7 +55,7 @@ pub fn PutVarint(mut buf: Slice<uint8>, x: int64) -> int
 /// The error is [io.EOF] only if no bytes were read.
 /// If an [io.EOF] happens after reading some but not all the bytes,
 /// Read returns [io.ErrUnexpectedEOF].
-pub fn Read(r: io.Reader, order: ByteOrder, data: Unknown) -> Result<(), error>
+pub fn Read<T>(r: io.Reader, order: ByteOrder, data: Ref<T>) -> Result<(), error>
 
 /// ReadUvarint reads an encoded unsigned integer from r and returns it as a uint64.
 /// The error is [io.EOF] only if no bytes were read.

crates/stdlib/typedefs/encoding/gob.d.lis

@@ -74,7 +74,7 @@ impl Decoder {
   /// correct type for the next data item received.
   /// If the input is at EOF, Decode returns [io.EOF] and
   /// does not modify e.
-  fn Decode(self: Ref<Decoder>, e: Unknown) -> Result<(), error>
+  fn Decode<T>(self: Ref<Decoder>, e: Ref<T>) -> Result<(), error>
 
   /// DecodeValue reads the next value from the input stream.
   /// If v is the zero reflect.Value (v.Kind() == Invalid), DecodeValue discards the value.