fix: skip methods with unmockable interface args in smoke tests

Methods taking non-IBinder interface arguments (or structs containing
them) would panic on nil dereference — a test limitation, not a codegen
bug. Now detected and skipped. Methods with only mockable arguments
still get panic-checked, catching genuine codegen bugs.

Author: xaionaro@dx.center

tools/pkg/testutil/smoke.go

@@ -63,19 +63,27 @@ func SmokeTestAllMethods(
 			continue
 		}
 
-		result.Total++
 		methodName := method.Name
 		methodValue := v.Method(i)
 		methodType := methodValue.Type()
 
+		if hasUnmockableArgs(methodType) {
+			t.Run(methodName, func(t *testing.T) {
+				t.Skipf("method %s skipped (has unmockable interface args)", methodName)
+			})
+			continue
+		}
+
+		result.Total++
+
 		t.Run(methodName, func(t *testing.T) {
 			args := buildZeroArgs(methodType)
 
 			outcome := callWithRecover(methodValue, args)
 			switch outcome {
 			case outcomePanicked:
 				result.Panicked++
-				t.Logf("method %s panicked (nil interface arg)", methodName)
+				t.Errorf("method %s panicked unexpectedly", methodName)
 			case outcomeFailed:
 				result.Failed++
 				t.Logf("method %s returned an error", methodName)
@@ -141,6 +149,55 @@ var (
 	iBinderType = reflect.TypeOf((*binder.IBinder)(nil)).Elem()
 )
 
+// hasUnmockableArgs returns true if the method has arguments containing
+// interface types that buildZeroArgs cannot provide a non-nil value for.
+// This includes direct interface arguments and struct fields that are
+// interfaces (e.g., union types with binder interface fields).
+func hasUnmockableArgs(methodType reflect.Type) bool {
+	for i := 0; i < methodType.NumIn(); i++ {
+		if typeContainsUnmockableInterface(methodType.In(i)) {
+			return true
+		}
+	}
+	return false
+}
+
+// typeContainsUnmockableInterface checks whether a type is or contains
+// an interface that buildZeroArgs cannot mock. The visited map prevents
+// infinite recursion on self-referencing struct types.
+func typeContainsUnmockableInterface(t reflect.Type) bool {
+	return typeContainsUnmockableInterfaceVisited(t, map[reflect.Type]bool{})
+}
+
+func typeContainsUnmockableInterfaceVisited(t reflect.Type, visited map[reflect.Type]bool) bool {
+	if visited[t] {
+		return false
+	}
+	visited[t] = true
+
+	switch t.Kind() {
+	case reflect.Interface:
+		if t.Implements(contextType) {
+			return false
+		}
+		if t.Implements(iBinderType) || t == iBinderType {
+			return false
+		}
+		return true
+	case reflect.Struct:
+		for i := 0; i < t.NumField(); i++ {
+			if typeContainsUnmockableInterfaceVisited(t.Field(i).Type, visited) {
+				return true
+			}
+		}
+	case reflect.Ptr:
+		return typeContainsUnmockableInterfaceVisited(t.Elem(), visited)
+	case reflect.Slice, reflect.Array:
+		return typeContainsUnmockableInterfaceVisited(t.Elem(), visited)
+	}
+	return false
+}
+
 // buildZeroArgs builds zero-value arguments for a method.
 // context.Context parameters get context.Background().
 // binder.IBinder parameters get a MockBinder.

tools/pkg/testutil/smoke_test.go

@@ -104,9 +104,9 @@ func TestSmokeTestAllMethods(t *testing.T) {
 
 	result := SmokeTestAllMethods(t, proxy)
 
-	assert.Equal(t, 4, result.Total, "should test 4 methods (AsBinder is skipped)")
+	assert.Equal(t, 3, result.Total, "should test 3 methods (AsBinder skipped, PanicMethod skipped for unmockable interface)")
 	assert.Equal(t, 0, result.Passed, "no methods should pass (mock returns SecurityException)")
-	assert.Equal(t, 1, result.Panicked, "PanicMethod should panic on nil interface")
+	assert.Equal(t, 0, result.Panicked, "no panics expected (unmockable methods are skipped)")
 	assert.Equal(t, 3, result.Failed, "SimpleMethod, MethodWithArgs, and MethodWithIBinder should fail (SecurityException)")
 }