When combining fx.As to annotate return type as interface with optional parameters nil value check is not working as expected

[kklimonda-fn]

Describe the bug When using an annotated return type of the function along with optional tag, the tagged parameter is not nil in a if b.Client == nil comparison

To Reproduce An example program:

package main

import (
    "context"
    "fmt"
    "log"
    "net/http"
    "reflect"

    "go.uber.org/fx"
)

func NewAProvide() (*http.Client, error) {
    return nil, nil
}

type B struct {
    Client HTTPClient
}

type BParams struct {
    fx.In

    Client HTTPClient `optional:"true"`
}

type HTTPClient interface {
    Do(req *http.Request) (*http.Response, error)
}

func NewBProvide(in BParams) (*B, error) {
    return &B{Client: in.Client}, nil
}

func main() {
    app := fx.New(
        fx.Provide(fx.Annotate(NewAProvide, fx.As(new(HTTPClient))), NewBProvide),
        //fx.Provide(NewAProvide, NewBProvide),
        fx.Invoke(func(b *B) {
            fmt.Printf("reflect.ValueOf(b.Client).IsNil() == %v\n", reflect.ValueOf(b.Client).IsNil())
            if b.Client == nil {
                log.Fatalf("B client is nil: %v (%v)", b.Client, reflect.TypeOf(b.Client))
            } else {
                log.Fatalf("B client is not nil: %v (%v)", b.Client, reflect.TypeOf(b.Client))
            }
        }))
    err := app.Start(context.Background())
    if err != nil {
        log.Fatalf("Error starting app: %v", err)
    }
}

Expected behavior I'd expect to see a message similar to:

B client is nil: <nil> (<nil>)

instead of

B client is not nil: <nil> (*http.Client)

Additional context Add any other context about the problem here.

[abhinav]

Hello! This is working as expected.

For background, the concept of typed nils comes from Go.

var v *http.Client = nil
var i HTTPClient = v
fmt.Println(v == nil) // true
fmt.Println(i == nil) // false

// https://go.dev/play/p/ZZS2T9XhMnb

It's a common gotcha, but it's completely valid to have a nil implementation in a non-nil interface.

type myClient struct{}

func (c *myClient) Do(req *http.Request) (*http.Response, error) {
    if c == nil {
        return http.DefaultClient.Do(req)
    }

    panic("TODO: custom logic here")
}

// Same as before:
var c *myClient = nil
var i HTTPClient = c
fmt.Println(i == nil) // false

// Can still send requests:
res, err := i.Do(req)
// ...

By providing a function that returns a nil *http.Client, and casting it to an HTTPClient, we're asking for a non-nil HTTPClient with a nil *http.Client inside it.

From Fx's point of view, this is behaving as expected. Fx should not be trying to glean the meaning of a typed nil. It should not discard my nil-safe implementation of an interface.