Slightly misleading FAQ in documentation

[arxeiss]

In https://uber-go.github.io/fx/faq.html, the first question is Does the order of fx.Options matter?

The answer is No, the order in which you provide Fx options to fx.Options, fx.New, fx.Module, and others does not matter.

However, later is this

Consuming values: Operations like fx.Invoke and fx.Populate are run after their dependencies have been satisfied: after fx.Provides.

Relative to each other, invokes are run in the order they were specified.

So suddenly order matters. And what is more important, if I have Invoke inside Modules which are all passed via fx.New(). Then order in fx.New matters not for Provide, but for Invoke.

Simple example. Where enqeue is made from worker. So Provide is called always to satisfy dependencies.
However order really matters regarding which StopHook will be called first.

Should documentation be changed?

package main

import (
	"context"
	"fmt"

	"go.uber.org/fx"
)

type (
	storage     struct{}
	worker      struct{}
	enqueueFunc func()
)

func onStop(lc fx.Lifecycle, name string) {
	fmt.Println("registering OnStop:", name)
	lc.Append(fx.Hook{OnStop: func(context.Context) error {
		fmt.Println("OnStop fired:", name)
		return nil
	}})
}

// worm provides the storage, worker (needs storage), subscriber the enqueue
// func (needs worker) - same dependency shape as the real modules.
var (
	worm = fx.Module("worm",
		fx.Provide(func() *storage { return &storage{} }),
	)
	workerModule = fx.Module("worker",
		fx.Provide(func(*storage) *worker { return &worker{} }),
		fx.Invoke(func(lc fx.Lifecycle, _ *worker) { onStop(lc, "worker (Shutdown NACKs pending batches)") }),
	)
	subscriber = fx.Module("subscriber",
		fx.Provide(func(*worker) enqueueFunc { return func() {} }),
		fx.Invoke(func(lc fx.Lifecycle, _ enqueueFunc) { onStop(lc, "subscriber (receiver stops delivering)") }),
	)
)

func main() {
	// Module order decides invoke order, and OnStop fires in reverse registration order.
	app := fx.New(worm, subscriber, workerModule, fx.NopLogger)

	ctx := context.Background()
	if err := app.Start(ctx); err != nil {
		panic(err)
	}
	fmt.Println("--- stopping ---")
	if err := app.Stop(ctx); err != nil {
		panic(err)
	}
}