Skip to content

Commit 1d15d81

Browse files
trexemDagger Team
trexem
authored and
Dagger Team
committed
Internal changes
RELNOTES=N/A PiperOrigin-RevId: 846854424
1 parent e574adb commit 1d15d81

File tree

8 files changed

+57
-93
lines changed

8 files changed

+57
-93
lines changed

‎dagger-compiler/main/java/dagger/internal/codegen/writing/ProvisionBindingRepresentation.java‎

Lines changed: 36 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -26,6 +26,7 @@
2626
import dagger.internal.codegen.binding.BindingRequest;
2727
import dagger.internal.codegen.binding.ContributionBinding;
2828
import dagger.internal.codegen.binding.DelegateBinding;
29+
import dagger.internal.codegen.model.DependencyRequest;
2930
import dagger.internal.codegen.model.RequestKind;
3031
import dagger.internal.codegen.writing.ComponentImplementation.CompilerMode;
3132

@@ -80,6 +81,8 @@ private boolean usesDirectInstanceExpression(RequestKind requestKind) {
8081
}
8182

8283
switch (binding.kind()) {
84+
case SUBCOMPONENT_CREATOR:
85+
return true;
8386
case MEMBERS_INJECTOR:
8487
// Currently, we always use a framework instance for MembersInjectors, e.g.
8588
// InstanceFactory.create(Foo_MembersInjector.create(...)).
@@ -94,9 +97,19 @@ private boolean usesDirectInstanceExpression(RequestKind requestKind) {
9497
"Assisted injection binding shouldn't be requested with an instance request.");
9598
default:
9699
// We don't need to use Provider#get() if there's no caching, so use a direct instance.
97-
// TODO(bcorso): This can be optimized in cases where we know a Provider field already
98-
// exists, in which case even if it's not scoped we might as well call Provider#get().
99-
return !needsCaching(binding, graph);
100+
// However, if there's no caching needed but we already have a framework instance requested
101+
// for this binding, we can reuse that framework instance by calling Provider#get() instead
102+
// of generating a direct instance.
103+
// TODO(emjich): To be even more accurate, we should consider delegate bindings here
104+
// too. For example, if we have:
105+
// @Binds Foo -> @Binds FooIntermediate -> @Provides FooImpl
106+
// Then we technically should be checking all of bindings for hasFrameworkRequest,
107+
// e.g. if someone requests a Provider<Foo> we should be able to reuse that same
108+
// provider for FooIntermediate and FooImpl since they are all just delegates of
109+
// each other.
110+
return !needsCaching(binding, graph)
111+
&& !(graph.topLevelBindingGraph().hasFrameworkRequest(binding)
112+
&& bindingHasDependencies(binding, graph));
100113
}
101114
}
102115

@@ -116,6 +129,26 @@ static boolean needsCaching(ContributionBinding binding, BindingGraph graph) {
116129
return true;
117130
}
118131

132+
/**
133+
* Returns {@code true} if {@code binding} has dependencies.
134+
*
135+
* <p>If {@code binding} is a {@code DELEGATE}, it is only considered to have dependencies if the
136+
* binding it delegates to has dependencies. Otherwise, a binding has dependencies if {@code
137+
* binding.dependencies()} is not empty.
138+
*/
139+
private static boolean bindingHasDependencies(ContributionBinding binding, BindingGraph graph) {
140+
if (binding.dependencies().isEmpty()) {
141+
return false;
142+
}
143+
if (!binding.kind().equals(DELEGATE)) {
144+
return true;
145+
}
146+
return binding.dependencies().stream()
147+
.map(DependencyRequest::key)
148+
.map(graph::contributionBinding)
149+
.anyMatch(b -> bindingHasDependencies(b, graph));
150+
}
151+
119152
@AssistedFactory
120153
static interface Factory {
121154
ProvisionBindingRepresentation create(ContributionBinding binding);

‎javatests/dagger/internal/codegen/goldens/ComponentProcessorTest/providerComponentType/test.DaggerTestComponent_DEFAULT_MODE‎

Lines changed: 1 addition & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -50,18 +50,14 @@ public final class DaggerTestComponent {
5050

5151
}
5252

53-
Foo foo() {
54-
return new Foo(new Bar());
55-
}
56-
5753
@SuppressWarnings("unchecked")
5854
private void initialize() {
5955
this.fooProvider = Foo_Factory.create(Bar_Factory.create());
6056
}
6157

6258
@Override
6359
public SomeEntryPoint someEntryPoint() {
64-
return new SomeEntryPoint(foo(), fooProvider);
60+
return new SomeEntryPoint(fooProvider.get(), fooProvider);
6561
}
6662
}
6763
}

‎javatests/dagger/internal/codegen/goldens/ComponentProcessorTest/providerComponentType/test.DaggerTestComponent_KT_DEFAULT_MODE‎

Lines changed: 3 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -43,8 +43,8 @@ public final class DaggerTestComponent {
4343
private final TestComponentImpl testComponentImpl = this;
4444

4545
/**
46-
* {@code Provider<Foo>}
47-
*/
46+
* {@code Provider<Foo>}
47+
*/
4848
Provider<?> fooProvider;
4949

5050
TestComponentImpl() {
@@ -53,18 +53,14 @@ public final class DaggerTestComponent {
5353

5454
}
5555

56-
Object foo() {
57-
return Foo_Factory.newInstance(Bar_Factory.newInstance());
58-
}
59-
6056
@SuppressWarnings("unchecked")
6157
private void initialize() {
6258
this.fooProvider = Foo_Factory.create(Bar_Factory.create());
6359
}
6460

6561
@Override
6662
public SomeEntryPoint someEntryPoint() {
67-
return (SomeEntryPoint) ((Object) (SomeEntryPoint_Factory.newInstance(foo(), fooProvider)));
63+
return (SomeEntryPoint) ((Object) (SomeEntryPoint_Factory.newInstance(fooProvider.get(), fooProvider)));
6864
}
6965
}
7066
}

‎javatests/dagger/internal/codegen/goldens/LazyClassKeyMapBindingComponentProcessorTest/mapBindingsWithInaccessibleKeys/test.DaggerTestComponent_DEFAULT_MODE‎

Lines changed: 2 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,14 +1,12 @@
11
package test;
22

3-
import com.google.common.collect.ImmutableMap;
43
import dagger.internal.DaggerGenerated;
54
import dagger.internal.LazyClassKeyMap;
65
import dagger.internal.MapFactory;
76
import dagger.internal.Provider;
87
import java.util.Map;
98
import javax.annotation.processing.Generated;
109
import mapkeys.MapKeys;
11-
import mapkeys.MapModule;
1210
import mapkeys.MapModule_ClassKeyFactory;
1311
import mapkeys.MapModule_ClassKey_LazyMapKey;
1412
import mapkeys.MapModule_ComplexKeyWithInaccessibleAnnotationValueFactory;
@@ -88,7 +86,7 @@ final class DaggerTestComponent {
8886

8987
@Override
9088
public Map<Class<?>, Integer> classKey() {
91-
return LazyClassKeyMap.<Integer>of(ImmutableMap.<String, Integer>of(MapModule_ClassKey_LazyMapKey.lazyClassKeyName, MapModule.classKey()));
89+
return mapOfClassOfAndIntegerProvider.get();
9290
}
9391

9492
@Override
@@ -98,7 +96,7 @@ final class DaggerTestComponent {
9896

9997
@Override
10098
public Map<MapKeys.ComplexKey, Integer> complexKey() {
101-
return ImmutableMap.<MapKeys.ComplexKey, Integer>of(MapModule_ComplexKeyWithInaccessibleValueMapKey.create(), MapModule.complexKeyWithInaccessibleValue(), MapModule_ComplexKeyWithInaccessibleArrayValueMapKey.create(), MapModule.complexKeyWithInaccessibleArrayValue(), MapModule_ComplexKeyWithInaccessibleAnnotationValueMapKey.create(), MapModule.complexKeyWithInaccessibleAnnotationValue());
99+
return mapOfComplexKeyAndIntegerProvider.get();
102100
}
103101

104102
@Override

‎javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest/mapBindingsWithInaccessibleKeys/test.DaggerTestComponent_DEFAULT_MODE‎

Lines changed: 3 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -1,13 +1,11 @@
11
package test;
22

3-
import com.google.common.collect.ImmutableMap;
43
import dagger.internal.DaggerGenerated;
54
import dagger.internal.MapFactory;
65
import dagger.internal.Provider;
76
import java.util.Map;
87
import javax.annotation.processing.Generated;
98
import mapkeys.MapKeys;
10-
import mapkeys.MapModule;
119
import mapkeys.MapModule_ClassKeyFactory;
1210
import mapkeys.MapModule_ClassKeyMapKey;
1311
import mapkeys.MapModule_ComplexKeyWithInaccessibleAnnotationValueFactory;
@@ -70,10 +68,6 @@ final class DaggerTestComponent {
7068

7169
}
7270

73-
Map mapOfPackagePrivateEnumAndInteger() {
74-
return ImmutableMap.of(MapModule_EnumKeyMapKey.create(), MapModule.enumKey());
75-
}
76-
7771
@SuppressWarnings("unchecked")
7872
private void initialize() {
7973
this.mapOfClassOfAndIntegerProvider = mapOfClassOfAndIntegerBuilder();
@@ -103,7 +97,7 @@ final class DaggerTestComponent {
10397

10498
@Override
10599
public Map<Class<?>, Integer> classKey() {
106-
return ImmutableMap.<Class<?>, Integer>of(MapModule_ClassKeyMapKey.create(), MapModule.classKey());
100+
return mapOfClassOfAndIntegerProvider.get();
107101
}
108102

109103
@Override
@@ -113,7 +107,7 @@ final class DaggerTestComponent {
113107

114108
@Override
115109
public Object inaccessibleEnum() {
116-
return mapOfPackagePrivateEnumAndInteger();
110+
return mapOfPackagePrivateEnumAndIntegerProvider.get();
117111
}
118112

119113
@Override
@@ -123,7 +117,7 @@ final class DaggerTestComponent {
123117

124118
@Override
125119
public Map<MapKeys.ComplexKey, Integer> complexKey() {
126-
return ImmutableMap.<MapKeys.ComplexKey, Integer>of(MapModule_ComplexKeyWithInaccessibleValueMapKey.create(), MapModule.complexKeyWithInaccessibleValue(), MapModule_ComplexKeyWithInaccessibleArrayValueMapKey.create(), MapModule.complexKeyWithInaccessibleArrayValue(), MapModule_ComplexKeyWithInaccessibleAnnotationValueMapKey.create(), MapModule.complexKeyWithInaccessibleAnnotationValue());
120+
return mapOfComplexKeyAndIntegerProvider.get();
127121
}
128122

129123
@Override

‎javatests/dagger/internal/codegen/goldens/MapRequestRepresentationTest/lazyMaps/test.DaggerTestComponent_DEFAULT_MODE‎

Lines changed: 6 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -2,12 +2,9 @@ package test;
22

33
import dagger.Lazy;
44
import dagger.internal.DaggerGenerated;
5-
import dagger.internal.DoubleCheck;
6-
import dagger.internal.MapBuilder;
75
import dagger.internal.MapLazyFactory;
86
import dagger.internal.MapProviderLazyFactory;
97
import dagger.internal.Provider;
10-
import dagger.internal.ProviderOfLazy;
118
import java.util.Map;
129
import javax.annotation.processing.Generated;
1310

@@ -59,37 +56,21 @@ final class DaggerTestComponent {
5956

6057
}
6158

62-
Map mapOfStringAndLazyOfIntegerBuilder() {
63-
MapBuilder mapBuilder = MapBuilder.<String, Lazy<Integer>>newMapBuilder(3);
64-
mapBuilder.put("key0", DoubleCheck.lazy(LazyMaps_TestModule_Int0Factory.create()));
65-
mapBuilder.put("key1", DoubleCheck.lazy(LazyMaps_TestModule_Int1Factory.create()));
66-
mapBuilder.put("key2", DoubleCheck.lazy(LazyMaps_TestModule_Int2Factory.create()));
67-
return mapBuilder.build();
68-
}
69-
70-
Map mapOfStringAndProviderOfLazyOfIntegerBuilder() {
71-
MapBuilder mapBuilder = MapBuilder.<String, javax.inject.Provider<Lazy<Integer>>>newMapBuilder(3);
72-
mapBuilder.put("key0", ProviderOfLazy.create(LazyMaps_TestModule_Int0Factory.create()));
73-
mapBuilder.put("key1", ProviderOfLazy.create(LazyMaps_TestModule_Int1Factory.create()));
74-
mapBuilder.put("key2", ProviderOfLazy.create(LazyMaps_TestModule_Int2Factory.create()));
75-
return mapBuilder.build();
76-
}
77-
7859
@SuppressWarnings("unchecked")
7960
private void initialize() {
80-
this.mapOfStringAndLazyOfIntegerProvider = mapOfStringAndLazyOfIntegerBuilder2();
81-
this.mapOfStringAndProviderOfLazyOfIntegerProvider = mapOfStringAndProviderOfLazyOfIntegerBuilder2();
61+
this.mapOfStringAndLazyOfIntegerProvider = mapOfStringAndLazyOfIntegerBuilder();
62+
this.mapOfStringAndProviderOfLazyOfIntegerProvider = mapOfStringAndProviderOfLazyOfIntegerBuilder();
8263
}
8364

84-
MapLazyFactory<String, Integer> mapOfStringAndLazyOfIntegerBuilder2() {
65+
MapLazyFactory<String, Integer> mapOfStringAndLazyOfIntegerBuilder() {
8566
MapLazyFactory.Builder<String, Integer> builder = MapLazyFactory.builder(3);
8667
builder.put("key0", LazyMaps_TestModule_Int0Factory.create());
8768
builder.put("key1", LazyMaps_TestModule_Int1Factory.create());
8869
builder.put("key2", LazyMaps_TestModule_Int2Factory.create());
8970
return builder.build();
9071
}
9172

92-
MapProviderLazyFactory<String, Integer> mapOfStringAndProviderOfLazyOfIntegerBuilder2() {
73+
MapProviderLazyFactory<String, Integer> mapOfStringAndProviderOfLazyOfIntegerBuilder() {
9374
MapProviderLazyFactory.Builder<String, Integer> builder = MapProviderLazyFactory.builder(3);
9475
builder.put("key0", LazyMaps_TestModule_Int0Factory.create());
9576
builder.put("key1", LazyMaps_TestModule_Int1Factory.create());
@@ -99,12 +80,12 @@ final class DaggerTestComponent {
9980

10081
@Override
10182
public Map<String, Lazy<Integer>> mapOfLazy() {
102-
return mapOfStringAndLazyOfIntegerBuilder();
83+
return mapOfStringAndLazyOfIntegerProvider.get();
10384
}
10485

10586
@Override
10687
public Map<String, javax.inject.Provider<Lazy<Integer>>> mapOfProviderOfLazy() {
107-
return mapOfStringAndProviderOfLazyOfIntegerBuilder();
88+
return (Map<String, javax.inject.Provider<Lazy<Integer>>>) (mapOfStringAndProviderOfLazyOfIntegerProvider.get());
10889
}
10990

11091
@Override

‎javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest/lazyMaps/test.DaggerTestComponent_DEFAULT_MODE‎

Lines changed: 3 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,6 @@ import dagger.internal.DoubleCheck;
77
import dagger.internal.MapLazyFactory;
88
import dagger.internal.MapProviderLazyFactory;
99
import dagger.internal.Provider;
10-
import dagger.internal.ProviderOfLazy;
1110
import java.util.Map;
1211
import java.util.concurrent.atomic.AtomicInteger;
1312
import javax.annotation.processing.Generated;
@@ -70,22 +69,6 @@ final class DaggerTestComponent {
7069

7170
}
7271

73-
String string() {
74-
return LazyMaps_TestModule_ProvideStringFactory.provideString(provideAtomicIntegerProvider.get());
75-
}
76-
77-
String string0() {
78-
return LazyMaps_TestModule_String0Factory.string0(string());
79-
}
80-
81-
String string1() {
82-
return LazyMaps_TestModule_String1Factory.string1(string());
83-
}
84-
85-
String string2() {
86-
return LazyMaps_TestModule_String2Factory.string2(string());
87-
}
88-
8972
@SuppressWarnings("unchecked")
9073
private void initialize() {
9174
this.provideAtomicIntegerProvider = DoubleCheck.provider(LazyMaps_TestModule_ProvideAtomicIntegerFactory.create());
@@ -115,17 +98,17 @@ final class DaggerTestComponent {
11598

11699
@Override
117100
public Map<String, String> mapOfString() {
118-
return ImmutableMap.<String, String>of("key0", string0(), "key1", string1(), "key2", string2());
101+
return ImmutableMap.<String, String>of("key0", string0Provider.get(), "key1", string1Provider.get(), "key2", string2Provider.get());
119102
}
120103

121104
@Override
122105
public Map<String, Lazy<String>> mapOfLazy() {
123-
return ImmutableMap.<String, Lazy<String>>of("key0", DoubleCheck.lazy(string0Provider), "key1", DoubleCheck.lazy(string1Provider), "key2", DoubleCheck.lazy(string2Provider));
106+
return mapOfStringAndLazyOfStringProvider.get();
124107
}
125108

126109
@Override
127110
public Map<String, javax.inject.Provider<Lazy<String>>> mapOfProviderOfLazy() {
128-
return ImmutableMap.<String, javax.inject.Provider<Lazy<String>>>of("key0", ProviderOfLazy.create(string0Provider), "key1", ProviderOfLazy.create(string1Provider), "key2", ProviderOfLazy.create(string2Provider));
111+
return (Map<String, javax.inject.Provider<Lazy<String>>>) (mapOfStringAndProviderOfLazyOfStringProvider.get());
129112
}
130113

131114
@Override

‎javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest/lazyMaps/test.DaggerTestComponent_KT_DEFAULT_MODE‎

Lines changed: 3 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,6 @@ import dagger.internal.DoubleCheck;
77
import dagger.internal.MapLazyFactory;
88
import dagger.internal.MapProviderLazyFactory;
99
import dagger.internal.Provider;
10-
import dagger.internal.ProviderOfLazy;
1110
import java.util.Map;
1211
import javax.annotation.processing.Generated;
1312

@@ -90,22 +89,6 @@ final class DaggerTestComponent {
9089

9190
}
9291

93-
Object string() {
94-
return LazyMaps_TestModule_ProvideStringFactory.provideString(provideAtomicIntegerProvider.get());
95-
}
96-
97-
Object string0() {
98-
return LazyMaps_TestModule_String0Factory.string0(string());
99-
}
100-
101-
Object string1() {
102-
return LazyMaps_TestModule_String1Factory.string1(string());
103-
}
104-
105-
Object string2() {
106-
return LazyMaps_TestModule_String2Factory.string2(string());
107-
}
108-
10992
@SuppressWarnings("unchecked")
11093
private void initialize() {
11194
this.provideAtomicIntegerProvider = DoubleCheck.provider(LazyMaps_TestModule_ProvideAtomicIntegerFactory.create());
@@ -135,17 +118,17 @@ final class DaggerTestComponent {
135118

136119
@Override
137120
public Map<String, String> mapOfString() {
138-
return (Map<String, String>) ((Object) (ImmutableMap.of("key0", string0(), "key1", string1(), "key2", string2())));
121+
return (Map<String, String>) ((Object) (ImmutableMap.of("key0", string0Provider.get(), "key1", string1Provider.get(), "key2", string2Provider.get())));
139122
}
140123

141124
@Override
142125
public Map<String, Lazy<String>> mapOfLazy() {
143-
return (Map<String, Lazy<String>>) ((Object) (ImmutableMap.of("key0", DoubleCheck.lazy(string0Provider), "key1", DoubleCheck.lazy(string1Provider), "key2", DoubleCheck.lazy(string2Provider))));
126+
return (Map<String, Lazy<String>>) ((Object) (mapOfStringAndLazyOfStringProvider.get()));
144127
}
145128

146129
@Override
147130
public Map<String, javax.inject.Provider<Lazy<String>>> mapOfProviderOfLazy() {
148-
return (Map<String, javax.inject.Provider<Lazy<String>>>) ((Object) (ImmutableMap.of("key0", ProviderOfLazy.create(string0Provider), "key1", ProviderOfLazy.create(string1Provider), "key2", ProviderOfLazy.create(string2Provider))));
131+
return (Map<String, javax.inject.Provider<Lazy<String>>>) ((Object) ((Map<String, javax.inject.Provider<Lazy<String>>>) (mapOfStringAndProviderOfLazyOfStringProvider.get())));
149132
}
150133

151134
@Override

0 commit comments

Comments
 (0)