The function had grown too long. Several related cleanups:
- Factored out the function return value logic, which had been
duplicated between providers and injectors.
- Moved code generation for different provider call types into separate
functions. This moves injector-specific state to a new type
injectorGen to keep the parameter count down.
- Since it's infeasible to keep the "shadow pass" collecting import
identifiers in sync the spread out logic, the injector code
generation is just run twice, with initial output discarded.
- Removed the zero value logic left over from Optional.
Reviewed-by: Tuo Shan <shantuo@google.com>
Previously, goose would ignore declarations in the //+build gooseinject
files that were not injectors. This meant that if you wanted to write
application-specific providers, you would need to place them in a
separate file, away from the goose injectors. This means that a typical
application would have three handwritten files: one for the abstract
business logic, one for the platform-specific providers, one for the
platform-specific injector declarations.
This change allows the two platform-specific files to be merged into
one: the //+build gooseinject file. goose will now copy these
declarations out to goose_gen.go. This requires a bit of hackery, since
the generated file may have different identifiers for the imported
packages, so goose will do some light AST rewriting to address these
cases.
(Historical note: this was the first change made externally, so also in
here are the copyright headers and other housekeeping changes.)
Reviewed-by: Tuo Shan <shantuo@google.com>
Reviewed-by: kokoro <noreply+kokoro@google.com>
To avoid making this CL too large, I did not migrate the existing goose
comments through the repository. This will be addressed in a subsequent
CL.
Reviewed-by: Tuo Shan <shantuo@google.com>
Lists provider sets in packages given on the command line, including
outputs grouped by what is needed to obtain them.
The goose package now exports the loading phase as an API.
Example output: https://paste.googleplex.com/5509965720584192
Reviewed-by: Tuo Shan <shantuo@google.com>
An interface binding instructs goose that a concrete type should be used
to satisfy a dependency on an interface type. goose could determine this
implicitly, but having an explicit directive makes the provider author's
intent clear and allows different concrete types to satisfy different
smaller interfaces.
Reviewed-by: Tuo Shan <shantuo@google.com>
Names are inferred from types most of the time, but have a fallback for
a non-named type. Names are now also disambiguated from symbols in the
same scope.
Reviewed-by: Tuo Shan <shantuo@google.com>
Reviewed-by: Herbie Ong <herbie@google.com>
Since tests are all written in terms of Go source, it makes tests easier
to write. They still need to be arranged in a GOPATH for go build, but
tests that just call Generate can operate in-place because I've faked
the filesystem.
Reviewed-by: Tuo Shan <shantuo@google.com>
Reviewed-by: Herbie Ong <herbie@google.com>
Learn this one weird trick to make goose an order of magnitude faster!
Reviewed-by: Herbie Ong <herbie@google.com>
Reviewed-by: Tuo Shan <shantuo@google.com>
Single-element provider sets are frequently useful enough to warrant
being a default. Larger groupings within a package are less frequent.
Reviewed-by: Herbie Ong <herbie@google.com>
Reviewed-by: Tuo Shan <shantuo@google.com>
