wire: wire.Value is not forbidding references to names introduced in function scope

[vangent]

See
https://github.com/vangent/go-cloud/tree/wirebug/wire/internal/wire/testdata/ValueFromStructField
for an example.

func newMainService(cfg *MainConfig) *MainService {
      wire.Build(
		MainService{},
		foo.New,
		wire.Value(cfg.Foo),
		bar.New,
		wire.Value(cfg.Bar),
		baz.New,
		wire.Value(cfg.Baz),
	)
        return nil
}

results in generated code

            // Injectors from wire.go:                                                                                                                
                                                                                                                                                      
            func newMainService(cfg *MainConfig) *MainService {                                                                                       
                config := _wireConfigValue                                                                                                            
                service := foo.New(config)                                                                                                            
                config2 := _wireConfigValue2                                                                                                          
                service2 := bar.New(config2, service)                                                                                                 
                config3 := _wireConfigValue3                                                                                                          
                service3 := baz.New(config3, service2)                                                                                                
                mainService := &MainService{                                                                                                          
                        Foo: service,                                                                                                                 
                        Bar: service2,                                                                                                                
                        Baz: service3,                                                                                                                
                }
                return mainService
            }

            var (
                _wireConfigValue  = cfg.Foo
                _wireConfigValue2 = cfg.Bar
                _wireConfigValue3 = cfg.Baz
            )

            // wire.go:

which fails with

    wire_test.go:110: go build check failed: build: exit status 2; output:                                                                        
        # example.com/main                                                                                                                        
        ./wire_gen.go:33:22: undefined: cfg                                                                                                       
        ./wire_gen.go:34:22: undefined: cfg                                                                                                       
        ./wire_gen.go:35:22: undefined: cfg 

cfg is out of scope in the generated code.

[vangent]

The README for wire says "It's important to note that the expression will be copied to the injector's package; references to variables will be evaluated during the injector package's initialization." So maybe this is not supported? The error message could be better.

[zombiezen]

Link for sample is broken, and the imports are really relevant here. This sounds like a legit bug, though (the Wire value initialization time stuff is pretty now). Can you check that link?

[vangent]

The new testcase MultipleSimilarPackages is easily modified to demonstrate this:

vangent/go-cloud@ecd11e6#diff-08ca43f68146628973a3c5efdcb374e7

[zombiezen]

Ohhh. The issue is that Wire is not forbidding references to names introduced in function scope. Wire should throw an error in this case and not generate the code. I modified the issue description to make this more clear.

[vangent]

Yea, the README explicitly says it's not supported but the error message doesn't tell you what you did wrong.

Why can't we support this?

[zombiezen]

It is technically feasible, but it makes the rule of "wire.Value is for constants" no longer true, and thus more complex to the user.