Application fails to start with fx.Annotate + fx.As + fx.In + fx.Out

[noam-ma-ma]

Describe the bug
Application fails to start when using fx.In + fx.Out parameters with fx.Annotate and fx.As with error of fx.In structs cannot be annotated.

I've tried to use fx.Annotate(ProvideConcreteType, fx.As(new(interface)), but when using fx.In and fx.Out the error occurs.

To overcome this - I've used fx.ParamTags, but from what I read from the documentation - it should be working both ways.

fx.Annotate(
		CreateGreaterWorks,
		fx.ParamTags(`name:"helloTo"`),
		fx.As(new(Greater))),

To Reproduce
This code snippet shows 2 working applications and a failed one (the current bug) -

1. fx.In + fx.ParamTags and interface (works)
2. fx.In + fx.Out without interface (works)
3. fx.In + fx.Out with interface (doesn't work)

package main

import (
	"context"
	"fmt"
	"go.uber.org/fx"
	"time"
)

type Greater interface {
	SayHello()
}

type ConcreteGreater struct {
	helloTo string
}

func (c ConcreteGreater) SayHello() {
	fmt.Printf("Hello %s", c.helloTo)
}

type Params struct {
	fx.In
	HelloTo string `name:"helloTo"`
}

func CreateGreater(params Params) ConcreteGreater {
	return ConcreteGreater{helloTo: params.HelloTo}
}

func CreateGreaterWorks(helloTo string) ConcreteGreater {
	return ConcreteGreater{helloTo: helloTo}
}

type OutParams struct {
	fx.Out
	HelloTo string `name:"helloTo"`
}

func NewParams() OutParams {
	return OutParams{HelloTo: "world"}
}

func main() {
	appWorks := fx.New(
		fx.Provide(
			NewParams,
			fx.Annotate(
				CreateGreaterWorks,
				fx.ParamTags(`name:"helloTo"`),
				fx.As(new(Greater))),
		),
		fx.Invoke(func(greater Greater) { greater.SayHello() }),
	)

	if err := appWorks.Start(context.Background()); err != nil {
		panic("failed to start application")
	}
	defer appWorks.Stop(context.Background())
	fmt.Printf("Started application with ParamTags")
	time.Sleep(time.Second * 3)

	appWorksWithoutInterface := fx.New(
		fx.Provide(
			NewParams,
			CreateGreater,
		),
		fx.Invoke(func(greater ConcreteGreater) { greater.SayHello() }),
	)
	if err := appWorksWithoutInterface.Start(context.Background()); err != nil {
		panic("failed to application with fx.In params")
	}
	defer appWorksWithoutInterface.Stop(context.Background())
	fmt.Printf("Started application with fx.In and fx.Out without interface")
	time.Sleep(time.Second * 3)

	appFail := fx.New(
		fx.Provide(
			NewParams,
			fx.Annotate(CreateGreater, fx.As(new(Greater))),
		),
		fx.Invoke(func(greater Greater) { greater.SayHello() }),
	)
	if err := appFail.Start(context.Background()); err != nil {
		panic("failed to application with fx.In + fx.Out params with interface")
	}
	defer appFail.Stop(context.Background())
}

Expected behavior
The application with fx.In + fx.Out and fx.As works the same as fx.ParamTags, as describe in the documentation of fx.Annotate:

Additional context
Thanks!

[EstebanOlmedo]

Hi @noam-ma-ma, thanks for reach out! It seems like the error you're running into is the actual expected behavior of fx. fx.Annotate is meant to be an alternative way of declaring values with annotations without having to wrap them up in a separate structure.

[silverspace]

I too encountered this issue where fx.Annotate() cannot be used on a constructor which takes a fx.In params struct, and I would argue that this is unexpected behavior from a developer's perspective.

For example, consider the case where I have a constructor that returns a concrete type instead of an interface (as is the best practice in golang), and I want to use fx.As() to provide the interface. This call to fx.Annotate() fails if the constructor happens to take a params struct that embeds fx.In:

fx.Provide(fx.Annotate(constructorThatTakesFxInParams, fx.As(new(Interface)))),

I can understand why this is failing, due to the way fx.Annotate() is implemented, but the result is that legitimate looking usages of the API fail unexpectedly.

[sywhang]

Sorry if this behavior was unexpected. I thought the documentation is pretty clear on what fx.Annotate does, but I guess it can be confusing. Agreed with @silverspace, this may come across as a surprising behavior if you misunderstand what the documentation meant to say.

The docs say:

Annotate lets you annotate a function's parameters and returns without you having to declare separate struct definitions for them.

To give you a little bit of background, Annotate() was added so that it can be used instead of fx.In or fx.Out structs. It was never meant to be a complementary thing.

Then, fx.As came along, and we added it as part of the fx.Annotate annotations set.

Technically, you can still do what fx.As does without using fx.Annotate - at Uber we noticed people were using fx.In and fx.Out structs to inject parameters as interfaces by using converter methods -- declaring an fx.In parameter that takes contains implementation types that returns its parameter as an fx.Out struct that contains the interface types. Say:

type Animal interface { SayHello() string }
type Dog struct { ... }
func (*Dog) SayHello() string { ... }

type Params struct {
  fx.In
  dogs []Dog `group:"dogs"`
}

type Result struct {
  fx.Out
  animals []Animal `group:"animals"`
}

fx.Provide(
  ... 
  func(p Param) Result {
    return Result {
      animals: p.Dogs,
    }
  },

Of course, using fx.As with fx.Annotate is the much less verbose & less boilerplate way of doing the same thing.

Hope that clarifies things, and I will go add some more notes to fx.Annotate's documentation to make this less confusing.