Change Log

Dagger 2 (Components)

Enables @Binds usage with multibinding annotations (@IntoSet, @ElementsIntoSet, and @IntoMap)
Adds @Multibinds API to replace @Multibindings interfaces
@Component.Builder methods for abstract modules are no longer allowed
Performance improvements for @IntoSet usage. Provided objects are no longer wrapped in a wasteful Collections.singleton()
Compilation speed improvements for large graphs
@Scopes are no longer allowed on @Produces methods
Adds state checking to scoped providers to make sure a circular dependency does not create multiple instances
Producers optimizations: Each @Produces method now generates 1 class instead of 2
Fix: Requests for Map<K, V> now include both @Provides @IntoMap and @Produces @IntoMap values

Adds @Binds API for delegating one binding to another
Adds @IntoSet, @ElementsIntoSet and @IntoMap to replace @Provides(type = ...) and @Produces(type = ...)
Allow injection of Provider<Lazy<Foo>>
Report an error if a @Scope annotation is applied to an @Inject constructor
Remove the ability to set the production executor on a component builder.
Ensure that no binding methods are binding framework types.
New format of dependency traces in error messages
Fixed bug: Exception when a binding in a parent that is used only in a subcomponent depends on a binding in the subcomponent
Update to JavaPoet 1.6.1 and Google Java Format 1.0
- Fixes NoSuchMethodError from Issue #356

dagger.mapkeys moved to dagger.multibindings and all @MapKey implementations now correctly have @Beta applied
Better error messages for multibindings
Compiler bug fixes!

Correctly handle @Components that inject generated types
Adds @ProductionSubcomponent and @ProductionScope
Allow the production Executor to be bound with @Production
Allow multiple scope annotations on components
A component's subcomponents’ (and their subcomponents’) simple names no longer need to be unique
Adds the ability to depend on subcomponent builders
GWT Integration
Producers monitoring
Multibindings for producers
Add common @MapKey annotations to dagger.mapkeys. These annotations are not, but should be marked @Beta (since the @MapKey itself is beta).
Lots of bug fixes!

A patch release, most crucially including:

A fix to the way processor validation of types is done that permits dagger to play more nicely with other processors, avoiding over-validating aspects that it doesn't need, which may yet not have been generated by other processors in a different round of processing.
Some improved error reporting for edge-cases
Fix to prevent incompatible versions of Guava on the classpath from blowing up processing
Support a more robust set of types for map keys in map bindings (primitive types, etc.)

A maintenance release fixing immediate issues following the Dagger 2.0 release, including:

Speed up Graph Validation (reduce build times by 10s of seconds on sampled large projects)
Generate correct code for @MapKey annotation types (beta)
Fix to properly emit code for class literal values in @MapKey annotations.
Fix for injecting component dependencies
Fixes to generated code to account for differences in generics handling in ecg vs. javac.
Subcomponents can now be abstract classes.
Subcomponents now properly build the object graph in some cases involving explicit bindings and (sub)components without scope.
Improve runtime performance of SetFactory (set multibindings)
Other smaller fixes, refactorings, etc.

The initial release of the 2.0 code-line, supporting:

@Component interfaces representing a custom API to access a graph of objects
JSR-330 injection automation using @Inject signals, @Qualifiers
Simple bindings of implementations to interfaces, custom provision of objects, and set-bindings
Compile-time validation of graph structure (cycles, missing bindings, duplicate bindings)
Generation of
- backing implementations for components
- factories for @Inject constructors and modules
- members-injectors for @Inject methods and fields
Beta support for
- Map bindings
- Producers

==============================================================

Numerous performance improvements in both the compiler and runtime.
- Use more efficient String concatenation.
- Module adapters are now stateless.
- Use read/write locks over global locks.
- Reflective constructor invocation is now cached with Class.newInstance.
- Avoid re-linking all bindings when calling .plus().
Set bindings are now unioned when calling .plus().
Fix: Tolerate missing type information during compilation by deferring writing module adapters.

Module loading now requires code generation via the 'dagger-compiler' artifact.
Allow multiple contributions to Set binding via Provides.Type.SET_VALUES.
Request classloading from the classloader of the requesting object, not the current thread's context classloader.
Cache class loading at the root injector to reduce costs of loading adapters.
Fix: Primitive array types are no longer incorrectly changed to their boxed type.
Update JavaWriter to 2.1.1.

Explicitly forbid declaring @Inject on a class type (e.g., @Inject class Foo {}).
Update JavaWriter to 1.0.5.

Initial release.