diff options
Diffstat (limited to 'javatests/dagger/internal')
360 files changed, 2839 insertions, 1608 deletions
diff --git a/javatests/dagger/internal/DoubleCheckTest.java b/javatests/dagger/internal/DoubleCheckTest.java index e36c1bcee..6bf220d36 100644 --- a/javatests/dagger/internal/DoubleCheckTest.java +++ b/javatests/dagger/internal/DoubleCheckTest.java @@ -32,7 +32,6 @@ import java.util.concurrent.Executors; import java.util.concurrent.Future; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicReference; -import javax.inject.Provider; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; diff --git a/javatests/dagger/internal/MapProviderFactoryTest.java b/javatests/dagger/internal/MapProviderFactoryTest.java index c55bee3ab..e64df8dad 100644 --- a/javatests/dagger/internal/MapProviderFactoryTest.java +++ b/javatests/dagger/internal/MapProviderFactoryTest.java @@ -21,7 +21,6 @@ import static com.google.common.truth.Truth.assertThat; import java.util.LinkedHashMap; import java.util.Map; import java.util.concurrent.atomic.AtomicInteger; -import javax.inject.Provider; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; diff --git a/javatests/dagger/internal/SetFactoryTest.java b/javatests/dagger/internal/SetFactoryTest.java index 0032578c6..5e109ddb6 100644 --- a/javatests/dagger/internal/SetFactoryTest.java +++ b/javatests/dagger/internal/SetFactoryTest.java @@ -23,7 +23,6 @@ import java.util.Arrays; import java.util.LinkedHashSet; import java.util.Set; import java.util.concurrent.atomic.AtomicInteger; -import javax.inject.Provider; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; diff --git a/javatests/dagger/internal/codegen/AssistedFactoryTest.java b/javatests/dagger/internal/codegen/AssistedFactoryTest.java index 18de701a4..6f38f8f7d 100644 --- a/javatests/dagger/internal/codegen/AssistedFactoryTest.java +++ b/javatests/dagger/internal/codegen/AssistedFactoryTest.java @@ -326,4 +326,110 @@ public class AssistedFactoryTest { subject.generatedSource(goldenFileRule.goldenSource("test/DaggerTestComponent")); }); } + + // This is a regression test for b/305748522 + // The important thing for this test is that we have two assisted factories for the same assisted + // injection class and that they are requested in different components. + @Test + public void testMultipleAssistedFactoryInDifferentComponents() throws Exception { + Source component = + CompilerTests.javaSource( + "test.MyComponent", + "package test;", + "", + "import dagger.Component;", + "", + "@Component", + "interface MyComponent {", + " MyComponentAssistedFactory myComponentAssistedFactory();", + " MySubcomponent mySubcomponent();", + "}"); + Source subcomponent = + CompilerTests.javaSource( + "test.MySubcomponent", + "package test;", + "", + "import dagger.Subcomponent;", + "", + "@Subcomponent", + "interface MySubcomponent {", + " MySubcomponentAssistedFactory mySubcomponentAssistedFactory();", + "}"); + Source assistedClass = + CompilerTests.javaSource( + "test.MyAssistedClass", + "package test;", + "", + "import dagger.assisted.Assisted;", + "import dagger.assisted.AssistedInject;", + "", + "final class MyAssistedClass {", + " private final Foo foo;", + " private final Bar bar;", + "", + " @AssistedInject", + " MyAssistedClass(@Assisted Foo foo, Baz baz, @Assisted Bar bar) {", + " this.foo = foo;", + " this.bar = bar;", + " }", + "}"); + Source componentAssistedFactory = + CompilerTests.javaSource( + "test.MyComponentAssistedFactory", + "package test;", + "", + "import dagger.assisted.AssistedFactory;", + "", + "@AssistedFactory", + "interface MyComponentAssistedFactory {", + " MyAssistedClass create(Bar bar, Foo foo);", + "}"); + Source subcomponentAssistedFactory = + CompilerTests.javaSource( + "test.MySubcomponentAssistedFactory", + "package test;", + "", + "import dagger.assisted.AssistedFactory;", + "", + "@AssistedFactory", + "interface MySubcomponentAssistedFactory {", + " MyAssistedClass create(Bar bar, Foo foo);", + "}"); + Source foo = + CompilerTests.javaSource( + "test.Foo", + "package test;", + "final class Foo {}"); + Source bar = + CompilerTests.javaSource( + "test.Bar", + "package test;", + "final class Bar {}"); + Source baz = + CompilerTests.javaSource( + "test.Baz", + "package test;", + "", + "import javax.inject.Inject;", + "", + "final class Baz {", + " @Inject Baz() {}", + "}"); + + CompilerTests.daggerCompiler( + component, + subcomponent, + assistedClass, + componentAssistedFactory, + subcomponentAssistedFactory, + foo, + bar, + baz) + .withProcessingOptions(compilerMode.processorOptions()) + .compile( + subject -> { + subject.hasErrorCount(0); + subject.generatedSource(goldenFileRule.goldenSource("test/DaggerMyComponent")); + }); + } } diff --git a/javatests/dagger/internal/codegen/AssistedInjectErrorsTest.java b/javatests/dagger/internal/codegen/AssistedInjectErrorsTest.java index 1d3628e46..e8e7fd7e9 100644 --- a/javatests/dagger/internal/codegen/AssistedInjectErrorsTest.java +++ b/javatests/dagger/internal/codegen/AssistedInjectErrorsTest.java @@ -243,4 +243,66 @@ public class AssistedInjectErrorsTest { .withProcessingOptions(compilerMode.processorOptions()) .compile(subject -> subject.hasErrorCount(0)); } + + @Test + public void testMultipleInjectedConstructors() { + Source foo = + CompilerTests.kotlinSource( + "test.Foo.kt", + "package test;", + "", + "import dagger.assisted.Assisted", + "import dagger.assisted.AssistedInject", + "import dagger.assisted.AssistedFactory", + "import javax.inject.Inject", + "", + "class Foo @AssistedInject constructor(@Assisted i: Int) {", + "", + " @Inject", + " constructor(s: String, @Assisted i: Int): this(i) {}", + "}"); + + CompilerTests.daggerCompiler(foo) + .withProcessingOptions(compilerMode.processorOptions()) + .compile( + subject -> { + subject.hasErrorCount(2); + subject.hasErrorContaining( + "Type test.Foo may only contain one injected constructor." + + " Found: [@Inject test.Foo(String, int)," + + " @dagger.assisted.AssistedInject test.Foo(int)]"); + subject.hasErrorContaining( + "@Assisted parameters can only be used within an" + + " @AssistedInject-annotated constructor."); + }); + } + + @Test + public void testMultipleAssistedInjectedConstructors() { + Source foo = + CompilerTests.kotlinSource( + "test.Foo.kt", + "package test;", + "", + "import dagger.assisted.Assisted", + "import dagger.assisted.AssistedInject", + "import dagger.assisted.AssistedFactory", + "", + "class Foo @AssistedInject constructor(@Assisted i: Int) {", + "", + " @AssistedInject", + " constructor(s: String, @Assisted i: Int): this(i) {}", + "}"); + + CompilerTests.daggerCompiler(foo) + .withProcessingOptions(compilerMode.processorOptions()) + .compile( + subject -> { + subject.hasErrorCount(1); + subject.hasErrorContaining( + "Type test.Foo may only contain one injected constructor." + + " Found: [@dagger.assisted.AssistedInject test.Foo(int)," + + " @dagger.assisted.AssistedInject test.Foo(String, int)]"); + }); + } } diff --git a/javatests/dagger/internal/codegen/BUILD b/javatests/dagger/internal/codegen/BUILD index 5984e5378..b189fe5b3 100644 --- a/javatests/dagger/internal/codegen/BUILD +++ b/javatests/dagger/internal/codegen/BUILD @@ -51,74 +51,137 @@ java_library( srcs = [ "CompilerMode.java", "Compilers.java", + "ComponentCreatorTestHelper.java", + "DaggerModuleMethodSubject.java", + "GeneratingProcessingStep.java", "JavaFileBuilder.java", + "TestUtils.java", ], deps = [ + "//java/dagger:core", "//java/dagger/internal/codegen:package_info", "//java/dagger/internal/codegen:processor", + "//java/dagger/internal/codegen/base", + "//java/dagger/internal/codegen/binding", + "//java/dagger/internal/codegen/xprocessing", "//java/dagger/internal/codegen/xprocessing:xprocessing-testing", + "//java/dagger/producers", "//java/dagger/testing/compile", "//third_party/java/compile_testing", "//third_party/java/guava/base", "//third_party/java/guava/collect", + "//third_party/java/javapoet", + "//third_party/java/truth", "@com_google_auto_value_auto_value//jar", ], ) +# These are tests with over 25 test cases. +LARGE_TESTS = [ + "ComponentCreatorTest.java", + "ComponentProcessorTest.java", + "InjectConstructorFactoryGeneratorTest.java", + "MembersInjectionTest.java", + "MissingBindingValidationTest.java", + "ModuleFactoryGeneratorTest.java", + "ProducerModuleFactoryGeneratorTest.java", + "SubcomponentCreatorValidationTest.java", +] + +# These are tests with over 10 test cases +MEDIUM_TESTS = [ + "BindsMethodValidationTest.java", + "DaggerSuperficialValidationTest.java", + "DelegateRequestRepresentationTest.java", + "DuplicateBindingsValidationTest.java", + "IgnoreProvisionKeyWildcardsTest.java", + "MapMultibindingValidationTest.java", + "MultibindsValidationTest.java", + "ProductionComponentProcessorTest.java", + "ProductionGraphValidationTest.java", + "SubcomponentValidationTest.java", +] + +DEPS = [ + ":compilers", + ":java_lib_no_dagger_compiler", + ":kt_lib_no_dagger_compiler", + "//third_party/java/guava/base", + "//third_party/java/guava/collect", + "//third_party/java/guava/util/concurrent", + "//third_party/java/auto:value", + "@com_google_auto_value_auto_value//jar", + "//third_party/java/auto:common", + "//third_party/java/compile_testing", + "//third_party/java/javapoet", + "//third_party/java/jsr250_annotations", # Include @Generated in generated files. + "//third_party/java/jsr330_inject", + "//third_party/java/junit", + "//third_party/java/mockito", + "//third_party/java/truth", + "//java/dagger:core", + "//java/dagger/internal/codegen:package_info", + "//java/dagger/internal/codegen:processor", + "//java/dagger/internal/codegen/base", + "//java/dagger/internal/codegen/binding", + "//java/dagger/internal/codegen/bindinggraphvalidation", + "//java/dagger/internal/codegen/compileroption", + "//java/dagger/internal/codegen/extension", + "//java/dagger/internal/codegen/javac", + "//java/dagger/internal/codegen/javapoet", + "//java/dagger/internal/codegen/kotlin", + "//java/dagger/internal/codegen/langmodel", + "//java/dagger/internal/codegen/model", + "//java/dagger/internal/codegen/validation", + "//java/dagger/internal/codegen/writing", + "//java/dagger/internal/codegen/xprocessing", + "//java/dagger/internal/codegen/xprocessing:xprocessing-testing", + "//java/dagger/model/testing", + "//java/dagger/producers", + "//java/dagger/spi", + "//java/dagger/spi/model/testing", + "//java/dagger/testing/compile", + "//java/dagger/testing/golden", +] + +GenJavaTests( + name = "large_compiler_tests", + srcs = LARGE_TESTS, + functional = False, + javacopts = DOCLINT_HTML_AND_SYNTAX, + plugins = ["//java/dagger/internal/codegen/bootstrap"], + shard_count = 7, + deps = DEPS, +) + +GenJavaTests( + name = "medium_compiler_tests", + srcs = MEDIUM_TESTS, + functional = False, + javacopts = DOCLINT_HTML_AND_SYNTAX, + plugins = ["//java/dagger/internal/codegen/bootstrap"], + shard_count = 3, + deps = DEPS, +) + GenJavaTests( name = "compiler_tests", srcs = glob( ["*.java"], exclude = [ - "ComponentProcessorTestClasses.java", "CompilerMode.java", "Compilers.java", + "ComponentCreatorTestHelper.java", + "ComponentProcessorTestClasses.java", + "DaggerModuleMethodSubject.java", + "GeneratingProcessingStep.java", "InvalidInjectConstructor.java", "JavaFileBuilder.java", - ], + "TestUtils.java", + ] + LARGE_TESTS + MEDIUM_TESTS, ), functional = False, javacopts = DOCLINT_HTML_AND_SYNTAX, plugins = ["//java/dagger/internal/codegen/bootstrap"], - deps = [ - ":compilers", - ":java_lib_no_dagger_compiler", - ":kt_lib_no_dagger_compiler", - "//java/dagger:core", - "//java/dagger/internal/codegen:package_info", - "//java/dagger/internal/codegen:processor", - "//java/dagger/internal/codegen/base", - "//java/dagger/internal/codegen/binding", - "//java/dagger/internal/codegen/bindinggraphvalidation", - "//java/dagger/internal/codegen/compileroption", - "//java/dagger/internal/codegen/extension", - "//java/dagger/internal/codegen/javac", - "//java/dagger/internal/codegen/javapoet", - "//java/dagger/internal/codegen/kotlin", - "//java/dagger/internal/codegen/langmodel", - "//java/dagger/internal/codegen/model", - "//java/dagger/internal/codegen/validation", - "//java/dagger/internal/codegen/writing", - "//java/dagger/internal/codegen/xprocessing", - "//java/dagger/internal/codegen/xprocessing:xprocessing-testing", - "//java/dagger/model/testing", - "//java/dagger/producers", - "//java/dagger/spi", - "//java/dagger/spi/model/testing", - "//java/dagger/testing/compile", - "//java/dagger/testing/golden", - "//third_party/java/auto:common", - "//third_party/java/auto:value", - "//third_party/java/compile_testing", - "//third_party/java/guava/base", - "//third_party/java/guava/collect", - "//third_party/java/guava/util/concurrent", - "//third_party/java/javapoet", - "//third_party/java/jsr250_annotations", # Include @Generated in generated files. - "//third_party/java/jsr330_inject", - "//third_party/java/junit", - "//third_party/java/mockito", - "//third_party/java/truth", - "@com_google_auto_value_auto_value//jar", - ], + deps = DEPS, ) diff --git a/javatests/dagger/internal/codegen/BindsMethodValidationTest.java b/javatests/dagger/internal/codegen/BindsMethodValidationTest.java index b7c8e1371..cb94f7567 100644 --- a/javatests/dagger/internal/codegen/BindsMethodValidationTest.java +++ b/javatests/dagger/internal/codegen/BindsMethodValidationTest.java @@ -53,6 +53,70 @@ public class BindsMethodValidationTest { } @Test + public void noExtensionForBinds() { + Source module = + CompilerTests.kotlinSource( + "test.TestModule.kt", + "package test", + "", + "import dagger.Binds", + "", + moduleAnnotation, + "interface TestModule {", + " @Binds fun FooImpl.bindObject(): Foo", + "}"); + Source foo = + CompilerTests.javaSource( + "test.Foo", // Prevents formatting onto a single line + "package test;", + "", + "interface Foo {}"); + Source fooImpl = + CompilerTests.javaSource( + "test.FooImpl", // Prevents formatting onto a single line + "package test;", + "", + "class FooImpl implements Foo {", + " @Inject FooImpl() {}", + "}"); + CompilerTests.daggerCompiler(module, foo, fooImpl) + .compile( + subject -> { + subject.hasErrorCount(1); + subject.hasErrorContaining("@Binds methods can not be an extension function"); + }); + } + + @Test + public void noExtensionForProvides() { + Source module = + CompilerTests.kotlinSource( + "test.TestModule.kt", + "package test", + "", + "import dagger.Provides", + "", + moduleAnnotation, + "object TestModule {", + " @Provides fun Foo.providesString(): String = \"hello\"", + "}"); + Source foo = + CompilerTests.javaSource( + "test.Foo", // Prevents formatting onto a single line + "package test;", + "", + "class Foo {", + " @Inject Foo() {}", + "}"); + CompilerTests.daggerCompiler(module, foo) + .compile( + subject -> { + subject.hasErrorCount(1); + subject.hasErrorContaining("@Provides methods can not be an extension function"); + }); + } + + @Test public void nonAbstract() { assertThatMethod("@Binds Object concrete(String impl) { return null; }") .hasError("must be abstract"); diff --git a/javatests/dagger/internal/codegen/ComponentProcessorTest.java b/javatests/dagger/internal/codegen/ComponentProcessorTest.java index e7f9b8ed5..90c7b2925 100644 --- a/javatests/dagger/internal/codegen/ComponentProcessorTest.java +++ b/javatests/dagger/internal/codegen/ComponentProcessorTest.java @@ -16,7 +16,12 @@ package dagger.internal.codegen; +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; + +import androidx.room.compiler.processing.util.CompilationResultSubject; import androidx.room.compiler.processing.util.Source; +import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; import com.squareup.javapoet.AnnotationSpec; import com.squareup.javapoet.MethodSpec; @@ -27,6 +32,7 @@ import dagger.testing.compile.CompilerTests; import dagger.testing.golden.GoldenFileRule; import java.util.Collection; import javax.inject.Inject; +import javax.tools.Diagnostic; import org.junit.Rule; import org.junit.Test; import org.junit.runner.RunWith; @@ -1380,21 +1386,57 @@ public class ComponentProcessorTest { subject -> { subject.hasErrorCount(0); subject.hasWarningCount(0); - subject.hasNoteContaining( - String.format( - "Generating a MembersInjector for dagger.internal.codegen.%s.", - "ComponentProcessorTestClasses.LocalInjectMemberNoConstructor")); - subject.hasNoteContaining( - String.format( - "Generating a MembersInjector for dagger.internal.codegen.%s.", - "ComponentProcessorTestClasses.LocalInjectMemberWithConstructor")); - subject.hasNoteContaining( - String.format( - "Generating a MembersInjector for dagger.internal.codegen.%s.", - "ComponentProcessorTestClasses.ParentInjectMemberWithConstructor")); + + String generatedFileTemplate = + "dagger/internal/codegen/ComponentProcessorTestClasses_%s_MembersInjector.java"; + String noteTemplate = + "Generating a MembersInjector for " + + "dagger.internal.codegen.ComponentProcessorTestClasses.%s."; + + // Assert that we generate sources and notes for the following classes. + ImmutableList.of( + "LocalInjectMemberNoConstructor", + "LocalInjectMemberWithConstructor", + "ParentInjectMemberWithConstructor") + .forEach( + className -> { + subject.generatedSourceFileWithPath( + String.format(generatedFileTemplate, className)); + subject.hasNoteContaining(String.format(noteTemplate, className)); + }); + + // Assert that we **do not** generate sources and notes for the following classes. + ImmutableList.of( + "ParentInjectMemberNoConstructor", + "NoInjectMemberNoConstructor", + "NoInjectMemberWithConstructor") + .forEach( + className -> { + assertFileNotGenerated( + subject, String.format(generatedFileTemplate, className)); + assertDoesNotHaveNoteContaining( + subject, String.format(noteTemplate, className)); + }); }); } + private void assertFileNotGenerated(CompilationResultSubject subject, String filePath) { + // TODO(b/303653163): replace this with better XProcessing API once we have the ability to get a + // list of all generated sources. + AssertionError error = + assertThrows( + AssertionError.class, + () -> subject.generatedSourceFileWithPath(filePath)); + assertThat(error).hasMessageThat().contains("Didn't generate file"); + } + + private void assertDoesNotHaveNoteContaining(CompilationResultSubject subject, String content) { + assertThat( + subject.getCompilationResult().getDiagnostics().get(Diagnostic.Kind.NOTE).stream() + .filter(diagnostic -> diagnostic.getMsg().contains(content))) + .isEmpty(); + } + @Test public void scopeAnnotationOnInjectConstructorNotValid() { Source aScope = @@ -2045,4 +2087,76 @@ public class ComponentProcessorTest { subject.hasWarningCount(0); }); } + + @Test + public void abstractVarFieldInComponent_failsValidation() { + Source component = + CompilerTests.kotlinSource( + "test.TestComponent.kt", + "package test", + "", + "import dagger.Component", + "", + "@Component(modules = [TestModule::class])", + "interface TestComponent {", + " var foo: String", + "}"); + + Source module = + CompilerTests.javaSource( + "test.TestModule", + "package test;", + "", + "import dagger.Module;", + "import dagger.Provides;", + "", + "@Module", + "abstract class TestModule {", + " @Provides", + " static String provideString() { return \"hello\"; }", + "}"); + + CompilerTests.daggerCompiler(component, module) + .withProcessingOptions(compilerMode.processorOptions()) + .compile( + subject -> { + subject.hasErrorCount(1); + subject.hasErrorContaining( + "Cannot use 'abstract var' property in a component declaration to get a binding." + + " Use 'val' or 'fun' instead: foo"); + }); + } + + @Test + public void nonAbstractVarFieldInComponent_passesValidation() { + Source component = + CompilerTests.kotlinSource( + "test.TestComponent.kt", + "package test", + "", + "import dagger.Component", + "", + "@Component(modules = [TestModule::class])", + "abstract class TestComponent {", + " var foo: String = \"hello\"", + "}"); + + Source module = + CompilerTests.javaSource( + "test.TestModule", + "package test;", + "", + "import dagger.Module;", + "import dagger.Provides;", + "", + "@Module", + "abstract class TestModule {", + " @Provides", + " static String provideString() { return \"hello\"; }", + "}"); + + CompilerTests.daggerCompiler(component, module) + .withProcessingOptions(compilerMode.processorOptions()) + .compile(subject -> subject.hasErrorCount(0)); + } } diff --git a/javatests/dagger/internal/codegen/DuplicateBindingsValidationTest.java b/javatests/dagger/internal/codegen/DuplicateBindingsValidationTest.java index b45357cd6..c352a2810 100644 --- a/javatests/dagger/internal/codegen/DuplicateBindingsValidationTest.java +++ b/javatests/dagger/internal/codegen/DuplicateBindingsValidationTest.java @@ -1052,9 +1052,8 @@ public class DuplicateBindingsValidationTest { CompilerTests.daggerCompiler(foo, injected1, injected2, provided1, provided2) .compile( subject -> { - subject.hasErrorCount(0); - subject.hasWarningCount(1); - subject.hasWarningContaining( + subject.hasErrorCount(1); + subject.hasErrorContaining( message( "Foo is bound multiple times:", " @Inject Foo(Set<String>) [Injected1]", diff --git a/javatests/dagger/internal/codegen/FrameworkFieldTest.java b/javatests/dagger/internal/codegen/FrameworkFieldTest.java index be495d79b..ba5b88f8c 100644 --- a/javatests/dagger/internal/codegen/FrameworkFieldTest.java +++ b/javatests/dagger/internal/codegen/FrameworkFieldTest.java @@ -24,6 +24,7 @@ import static dagger.internal.codegen.javapoet.TypeNames.providerOf; import com.google.testing.compile.CompilationRule; import com.squareup.javapoet.ClassName; +import com.squareup.javapoet.ParameterizedTypeName; import dagger.internal.codegen.binding.FrameworkField; import javax.inject.Inject; import org.junit.Before; @@ -47,16 +48,20 @@ public class FrameworkFieldTest { } @Test public void frameworkType() { - assertThat(FrameworkField.create(PROVIDER, xTypeName, "test").type()) + assertThat(FrameworkField.create(ParameterizedTypeName.get(PROVIDER, xTypeName), "test").type()) .isEqualTo(providerOf(xTypeName)); - assertThat(FrameworkField.create(MEMBERS_INJECTOR, xTypeName, "test").type()) + assertThat( + FrameworkField.create(ParameterizedTypeName.get(MEMBERS_INJECTOR, xTypeName), "test") + .type()) .isEqualTo(membersInjectorOf(xTypeName)); } @Test public void nameSuffix() { - assertThat(FrameworkField.create(PROVIDER, xTypeName, "foo").name()) + assertThat(FrameworkField.create(ParameterizedTypeName.get(PROVIDER, xTypeName), "foo").name()) .isEqualTo("fooProvider"); - assertThat(FrameworkField.create(PROVIDER, xTypeName, "fooProvider").name()) + assertThat( + FrameworkField.create(ParameterizedTypeName.get(PROVIDER, xTypeName), "fooProvider") + .name()) .isEqualTo("fooProvider"); } diff --git a/javatests/dagger/internal/codegen/GeneratedLines.java b/javatests/dagger/internal/codegen/GeneratedLines.java index 308904a33..d8a038825 100644 --- a/javatests/dagger/internal/codegen/GeneratedLines.java +++ b/javatests/dagger/internal/codegen/GeneratedLines.java @@ -33,7 +33,7 @@ public final class GeneratedLines { private static final String SUPPRESS_WARNINGS_ANNOTATION = "@SuppressWarnings({" - + "\"unchecked\", \"rawtypes\", \"KotlinInternal\", \"KotlinInternalInJava\"" + + "\"unchecked\", \"rawtypes\", \"KotlinInternal\", \"KotlinInternalInJava\", \"cast\"" + "})"; private static final String IMPORT_DAGGER_GENERATED = "import dagger.internal.DaggerGenerated;"; diff --git a/javatests/dagger/internal/codegen/HjarTest.java b/javatests/dagger/internal/codegen/HjarTest.java new file mode 100644 index 000000000..e8f67b725 --- /dev/null +++ b/javatests/dagger/internal/codegen/HjarTest.java @@ -0,0 +1,92 @@ +/* + * Copyright (C) 2014 The Dagger Authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package dagger.internal.codegen; + +import androidx.room.compiler.processing.util.Source; +import com.google.common.collect.ImmutableMap; +import dagger.testing.compile.CompilerTests; +import dagger.testing.compile.CompilerTests.DaggerCompiler; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +/** Tests compilation with the {@code experimental_turbine_hjar} flag enabled. */ +@RunWith(JUnit4.class) +public class HjarTest { + /** Returns a {@link DaggerCompiler} with hjar generation enabled. */ + private static DaggerCompiler daggerCompiler(Source... sources) { + return CompilerTests.daggerCompiler(sources) + .withProcessingOptions(ImmutableMap.of("experimental_turbine_hjar", "")); + } + + @Test + public void componentTest() { + Source component = + CompilerTests.javaSource( + "test.MyComponent", + "package test;", + "", + "import dagger.Component;", + "", + "@Component", + "interface MyComponent {", + " String getString();", + " int getInt();", + " void inject(String str);", + "}"); + daggerCompiler(component).compile(subject -> subject.hasErrorCount(0)); + } + + @Test + public void moduleTest() { + Source module = + CompilerTests.javaSource( + "test.MyModule", + "package test;", + "", + "import dagger.Module;", + "import dagger.Provides;", + "", + "@Module", + "interface MyModule {", + " @Provides static int provideInt() { return 0; }", + " @Provides static String provideString() { return null; }", + " @Provides static String[] provideStringArray() { return null; }", + " @Provides static int[] provideIntArray() { return null; }", + " @Provides static boolean provideBoolean() { return false; }", + "}"); + daggerCompiler(module).compile(subject -> subject.hasErrorCount(0)); + } + + @Test + public void producerModuleTest() { + Source module = + CompilerTests.javaSource( + "test.MyModule", + "package test;", + "", + "import com.google.common.util.concurrent.ListenableFuture;", + "import dagger.producers.ProducerModule;", + "import dagger.producers.Produces;", + "", + "@ProducerModule", + "interface MyModule {", + " @Produces static ListenableFuture<String> produceString() { return null; }", + "}"); + daggerCompiler(module).compile(subject -> subject.hasErrorCount(0)); + } +} diff --git a/javatests/dagger/internal/codegen/IgnoreProvisionKeyWildcardsTest.java b/javatests/dagger/internal/codegen/IgnoreProvisionKeyWildcardsTest.java index 008a0a866..7b1705858 100644 --- a/javatests/dagger/internal/codegen/IgnoreProvisionKeyWildcardsTest.java +++ b/javatests/dagger/internal/codegen/IgnoreProvisionKeyWildcardsTest.java @@ -16,7 +16,6 @@ package dagger.internal.codegen; -import androidx.room.compiler.processing.XProcessingEnv; import androidx.room.compiler.processing.util.CompilationResultSubject; import com.google.common.base.Joiner; import com.google.common.collect.ImmutableList; @@ -57,7 +56,7 @@ public class IgnoreProvisionKeyWildcardsTest { processingOptions = isIgnoreProvisionKeyWildcardsEnabled ? ImmutableMap.of("dagger.ignoreProvisionKeyWildcards", "enabled") - : ImmutableMap.of(); + : ImmutableMap.of("dagger.ignoreProvisionKeyWildcards", "disabled"); } @Test @@ -219,8 +218,7 @@ public class IgnoreProvisionKeyWildcardsTest { @Test public void testProvidesMultibindsSetContributionsWithDifferentTypeVariances() { compile( - /* javaComponentClass = */ - NEW_LINES.join( + /* javaComponentClass= */ NEW_LINES.join( "@Component(modules = MyModule.class)", "interface MyComponent {", " Set<Foo<? extends Bar>> setExtends();", @@ -231,8 +229,7 @@ public class IgnoreProvisionKeyWildcardsTest { " @Provides @IntoSet static Foo<? extends Bar> setExtends() { return null; }", " @Provides @IntoSet static Foo<Bar> set() { return null; }", "}"), - /* kotlinComponentClass = */ - NEW_LINES.join( + /* kotlinComponentClass= */ NEW_LINES.join( "@Component(modules = [MyModule::class])", "interface MyComponent {", " fun setExtends(): Set<Foo<out Bar>>", @@ -247,14 +244,12 @@ public class IgnoreProvisionKeyWildcardsTest { if (isIgnoreProvisionKeyWildcardsEnabled) { subject.hasErrorCount(1); subject.hasErrorContaining( - String.format( - NEW_LINES_FOR_ERROR_MSG.join( - "Set<Foo<? extends Bar>> has incompatible bindings or declarations:", - " Set bindings and declarations:", - " %1$s Foo<Bar> MyModule.set()", - " %1$s Foo<? extends Bar> MyModule.setExtends()", - " in component: [MyComponent]"), - isKapt(subject) ? "@IntoSet @Provides" : "@Provides @IntoSet")); + NEW_LINES_FOR_ERROR_MSG.join( + "Set<Foo<? extends Bar>> has incompatible bindings or declarations:", + " Set bindings and declarations:", + " @Provides @IntoSet Foo<Bar> MyModule.set()", + " @Provides @IntoSet Foo<? extends Bar> MyModule.setExtends()", + " in component: [MyComponent]")); } else { subject.hasErrorCount(0); } @@ -300,9 +295,8 @@ public class IgnoreProvisionKeyWildcardsTest { "Set<Foo<? extends Bar>> has incompatible bindings or declarations:", " Set bindings and declarations:", " @Multibinds Set<Foo<Bar>> MyModule.mulitbindSet()", - " %s Foo<? extends Bar> %s.setExtends()", + " @Provides @IntoSet Foo<? extends Bar> %s.setExtends()", " in component: [MyComponent]"), - isKapt(subject) ? "@IntoSet @Provides" : "@Provides @IntoSet", sourceKind == SourceKind.KOTLIN ? "MyModule.Companion" : "MyModule")); } else { subject.hasErrorCount(0); @@ -313,8 +307,7 @@ public class IgnoreProvisionKeyWildcardsTest { @Test public void testProvidesIntoSetAndElementsIntoSetContributionsWithDifferentVariances() { compile( - /* javaComponentClass = */ - NEW_LINES.join( + /* javaComponentClass= */ NEW_LINES.join( "@Component(modules = MyModule.class)", "interface MyComponent {", " Set<Foo<? extends Bar>> setExtends();", @@ -328,8 +321,7 @@ public class IgnoreProvisionKeyWildcardsTest { " @ElementsIntoSet", " static Set<Foo<Bar>> set() { return null; }", "}"), - /* kotlinComponentClass = */ - NEW_LINES.join( + /* kotlinComponentClass= */ NEW_LINES.join( "@Component(modules = [MyModule::class])", "interface MyComponent {", " fun setExtends(): Set<Foo<out Bar>>", @@ -344,15 +336,12 @@ public class IgnoreProvisionKeyWildcardsTest { if (isIgnoreProvisionKeyWildcardsEnabled) { subject.hasErrorCount(1); subject.hasErrorContaining( - String.format( - NEW_LINES_FOR_ERROR_MSG.join( - "Set<Foo<? extends Bar>> has incompatible bindings or declarations:", - " Set bindings and declarations:", - " %s Set<Foo<Bar>> MyModule.set()", - " %s Foo<? extends Bar> MyModule.setExtends()", - " in component: [MyComponent]"), - isKapt(subject) ? "@ElementsIntoSet @Provides" : "@Provides @ElementsIntoSet", - isKapt(subject) ? "@IntoSet @Provides" : "@Provides @IntoSet")); + NEW_LINES_FOR_ERROR_MSG.join( + "Set<Foo<? extends Bar>> has incompatible bindings or declarations:", + " Set bindings and declarations:", + " @Provides @ElementsIntoSet Set<Foo<Bar>> MyModule.set()", + " @Provides @IntoSet Foo<? extends Bar> MyModule.setExtends()", + " in component: [MyComponent]")); } else { subject.hasErrorCount(0); } @@ -526,12 +515,8 @@ public class IgnoreProvisionKeyWildcardsTest { " %s Foo<Bar> MyModule.foo()", " %s Foo<? extends Bar> MyModule.fooExtends()", " in component: [MyComponent]"), - isKapt(subject) - ? "@StringKey(\"foo\") @IntoMap @Provides" - : "@Provides @IntoMap @StringKey(\"foo\")", - isKapt(subject) - ? "@StringKey(\"fooExtends\") @IntoMap @Provides" - : "@Provides @IntoMap @StringKey(\"fooExtends\")")); + "@Provides @IntoMap @StringKey(\"foo\")", + "@Provides @IntoMap @StringKey(\"fooExtends\")")); } else { subject.hasErrorCount(0); } @@ -584,6 +569,27 @@ public class IgnoreProvisionKeyWildcardsTest { String javaComponentClass, String kotlinComponentClass, Consumer<CompilationResultSubject> onCompilationResult) { + compileInternal( + javaComponentClass, + kotlinComponentClass, + subject -> { + if (!isIgnoreProvisionKeyWildcardsEnabled) { + if (CompilerTests.backend(subject) == + androidx.room.compiler.processing.XProcessingEnv.Backend.KSP) { + subject.hasErrorCount(1); + subject.hasErrorContaining( + "When using KSP, you must also enable the 'dagger.ignoreProvisionKeyWildcards'"); + return; + } + } + onCompilationResult.accept(subject); + }); + } + + private void compileInternal( + String javaComponentClass, + String kotlinComponentClass, + Consumer<CompilationResultSubject> onCompilationResult) { if (sourceKind == SourceKind.JAVA) { // Compile with Java sources CompilerTests.daggerCompiler( @@ -649,9 +655,4 @@ public class IgnoreProvisionKeyWildcardsTest { .compile(onCompilationResult); } } - - private boolean isKapt(CompilationResultSubject subject) { - return sourceKind == SourceKind.KOTLIN - && CompilerTests.backend(subject) == XProcessingEnv.Backend.JAVAC; - } } diff --git a/javatests/dagger/internal/codegen/LazyClassKeyMapBindingComponentProcessorTest.java b/javatests/dagger/internal/codegen/LazyClassKeyMapBindingComponentProcessorTest.java new file mode 100644 index 000000000..9937d05ed --- /dev/null +++ b/javatests/dagger/internal/codegen/LazyClassKeyMapBindingComponentProcessorTest.java @@ -0,0 +1,191 @@ +/* + * Copyright (C) 2024 The Dagger Authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package dagger.internal.codegen; + +import static com.google.testing.compile.CompilationSubject.assertThat; + +import androidx.room.compiler.processing.util.Source; +import com.google.testing.compile.Compilation; +import com.google.testing.compile.JavaFileObjects; +import dagger.testing.compile.CompilerTests; +import dagger.testing.golden.GoldenFileRule; +import java.util.Collection; +import javax.tools.JavaFileObject; +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; +import org.junit.runners.Parameterized.Parameters; + +@RunWith(Parameterized.class) +public class LazyClassKeyMapBindingComponentProcessorTest { + @Parameters(name = "{0}") + public static Collection<Object[]> parameters() { + return CompilerMode.TEST_PARAMETERS; + } + + @Rule public GoldenFileRule goldenFileRule = new GoldenFileRule(); + + private final CompilerMode compilerMode; + + public LazyClassKeyMapBindingComponentProcessorTest(CompilerMode compilerMode) { + this.compilerMode = compilerMode; + } + + // Cannot convert to use ksp as this test relies on AutoAnnotationProcessor. + @Test + public void mapBindingsWithInaccessibleKeys() throws Exception { + JavaFileObject mapKeys = + JavaFileObjects.forSourceLines( + "mapkeys.MapKeys", + "package mapkeys;", + "", + "import dagger.MapKey;", + "import dagger.multibindings.LazyClassKey;", + "", + "public class MapKeys {", + " @MapKey(unwrapValue = false)", + " public @interface ComplexKey {", + " Class<?>[] manyClasses();", + " Class<?> oneClass();", + " LazyClassKey annotation();", + " }", + "", + " interface Inaccessible {}", + "}"); + JavaFileObject moduleFile = + JavaFileObjects.forSourceLines( + "mapkeys.MapModule", + "package mapkeys;", + "", + "import dagger.Binds;", + "import dagger.Module;", + "import dagger.Provides;", + "import dagger.multibindings.LazyClassKey;", + "import dagger.multibindings.IntoMap;", + "import java.util.Map;", + "import javax.inject.Provider;", + "", + "@Module", + "public interface MapModule {", + " @Provides @IntoMap @LazyClassKey(MapKeys.Inaccessible.class)", + " static int classKey() { return 1; }", + "", + " @Provides @IntoMap", + " @MapKeys.ComplexKey(", + " manyClasses = {java.lang.Object.class, java.lang.String.class},", + " oneClass = MapKeys.Inaccessible.class,", + " annotation = @LazyClassKey(java.lang.Object.class)", + " )", + " static int complexKeyWithInaccessibleValue() { return 1; }", + "", + " @Provides @IntoMap", + " @MapKeys.ComplexKey(", + " manyClasses = {MapKeys.Inaccessible.class, java.lang.String.class},", + " oneClass = java.lang.String.class,", + " annotation = @LazyClassKey(java.lang.Object.class)", + " )", + " static int complexKeyWithInaccessibleArrayValue() { return 1; }", + "", + " @Provides @IntoMap", + " @MapKeys.ComplexKey(", + " manyClasses = {java.lang.String.class},", + " oneClass = java.lang.String.class,", + " annotation = @LazyClassKey(MapKeys.Inaccessible.class)", + " )", + " static int complexKeyWithInaccessibleAnnotationValue() { return 1; }", + "}"); + JavaFileObject componentFile = + JavaFileObjects.forSourceLines( + "test.TestComponent", + "package test;", + "", + "import dagger.Component;", + "import java.util.Map;", + "import javax.inject.Provider;", + "import mapkeys.MapKeys;", + "import mapkeys.MapModule;", + "", + "@Component(modules = MapModule.class)", + "interface TestComponent {", + " Map<Class<?>, Integer> classKey();", + " Provider<Map<Class<?>, Integer>> classKeyProvider();", + "", + " Map<MapKeys.ComplexKey, Integer> complexKey();", + " Provider<Map<MapKeys.ComplexKey, Integer>> complexKeyProvider();", + "}"); + Compilation compilation = + Compilers.compilerWithOptions(compilerMode.javacopts()) + .compile(mapKeys, moduleFile, componentFile); + assertThat(compilation).succeeded(); + assertThat(compilation) + .generatedSourceFile("test.DaggerTestComponent") + .hasSourceEquivalentTo(goldenFileRule.goldenFile("test.DaggerTestComponent")); + assertThat(compilation) + .generatedSourceFile( + "mapkeys.MapModule_ComplexKeyWithInaccessibleAnnotationValueMapKey") + .hasSourceEquivalentTo( + goldenFileRule.goldenFile( + "mapkeys.MapModule_ComplexKeyWithInaccessibleAnnotationValueMapKey")); + assertThat(compilation) + .generatedSourceFile("mapkeys.MapModule_ClassKeyMapKey") + .hasSourceEquivalentTo(goldenFileRule.goldenFile("mapkeys.MapModule_ClassKeyMapKey")); + } + + @Test + public void lazyClassKeySimilarQualifiedName_doesNotConflict() throws Exception { + Source fooBar = + CompilerTests.javaSource("test.Foo_Bar", "package test;", "", "interface Foo_Bar {}"); + Source fooBar2 = + CompilerTests.javaSource( + "test.Foo", "package test;", "", "interface Foo { interface Bar {} }"); + Source mapKeyBindingsModule = + CompilerTests.javaSource( + "test.MapKeyBindingsModule", + "package test;", + "", + "import dagger.Module;", + "import dagger.Provides;", + "import dagger.multibindings.LazyClassKey;", + "import dagger.multibindings.IntoMap;", + "", + "@Module", + "public interface MapKeyBindingsModule {", + " @Provides @IntoMap @LazyClassKey(test.Foo_Bar.class)", + " static int classKey() { return 1; }", + "", + " @Provides @IntoMap @LazyClassKey(test.Foo.Bar.class)", + " static int classKey2() { return 1; }", + "}"); + + Source componentFile = + CompilerTests.javaSource( + "test.TestComponent", + "package test;", + "", + "import dagger.Component;", + "import java.util.Map;", + "", + "@Component(modules = MapKeyBindingsModule.class)", + "interface TestComponent {", + " Map<Class<?>, Integer> classKey();", + "}"); + CompilerTests.daggerCompiler(fooBar, fooBar2, mapKeyBindingsModule, componentFile) + .withProcessingOptions(compilerMode.processorOptions()) + .compile(subject -> subject.hasErrorCount(0)); + } +} diff --git a/javatests/dagger/internal/codegen/MembersInjectionTest.java b/javatests/dagger/internal/codegen/MembersInjectionTest.java index 8d2ff0b9f..4748853fb 100644 --- a/javatests/dagger/internal/codegen/MembersInjectionTest.java +++ b/javatests/dagger/internal/codegen/MembersInjectionTest.java @@ -46,6 +46,88 @@ public class MembersInjectionTest { } @Test + public void injectKotlinProtectField_fails() { + Source injectFieldSrc = + CompilerTests.kotlinSource( + "MyClass.kt", + "package test", + "", + "import javax.inject.Inject", + "", + "class MyClass @Inject constructor() {", + " @Inject protected lateinit var protectedField: String", + "}"); + Source moduleSrc = + CompilerTests.kotlinSource( + "MyModule.kt", + "package test", + "", + "import dagger.Module", + "import dagger.Provides", + "", + "@Module", + "object MyModule {", + " @Provides", + " fun providesString() = \"hello\"", + "}"); + Source componentSrc = + CompilerTests.kotlinSource( + "MyComponent.kt", + "package test", + "", + "import dagger.Component", + "@Component(modules = [MyModule::class])", + "interface MyComponent {}"); + CompilerTests.daggerCompiler(injectFieldSrc, moduleSrc, componentSrc) + .withProcessingOptions(compilerMode.processorOptions()) + .compile( + subject -> { + subject.hasErrorCount(1); + subject.hasErrorContaining( + "Dagger injector does not have access to kotlin protected fields"); + }); + } + + @Test + public void injectJavaProtectField_succeeds() { + Source injectFieldSrc = + CompilerTests.javaSource( + "test.MyClass", + "package test;", + "", + "import javax.inject.Inject;", + "", + "public final class MyClass {", + " @Inject MyClass() {}", + " @Inject protected String protectedField;", + "}"); + Source moduleSrc = + CompilerTests.kotlinSource( + "MyModule.kt", + "package test", + "", + "import dagger.Module", + "import dagger.Provides", + "", + "@Module", + "object MyModule {", + " @Provides", + " fun providesString() = \"hello\"", + "}"); + Source componentSrc = + CompilerTests.kotlinSource( + "MyComponent.kt", + "package test", + "", + "import dagger.Component", + "@Component(modules = [MyModule::class])", + "interface MyComponent {}"); + CompilerTests.daggerCompiler(injectFieldSrc, moduleSrc, componentSrc) + .withProcessingOptions(compilerMode.processorOptions()) + .compile(subject -> subject.hasErrorCount(0)); + } + + @Test public void parentClass_noInjectedMembers() throws Exception { Source childFile = CompilerTests.javaSource( @@ -159,7 +241,8 @@ public class MembersInjectionTest { .compile( subject -> { subject.hasErrorCount(0); - subject.generatedSource(goldenFileRule.goldenSource("test/GenericClass_MembersInjector")); + subject.generatedSource( + goldenFileRule.goldenSource("test/GenericClass_MembersInjector")); }); } diff --git a/javatests/dagger/internal/codegen/MissingBindingSuggestionsTest.java b/javatests/dagger/internal/codegen/MissingBindingSuggestionsTest.java deleted file mode 100644 index 5e64c12a7..000000000 --- a/javatests/dagger/internal/codegen/MissingBindingSuggestionsTest.java +++ /dev/null @@ -1,352 +0,0 @@ -/* - * Copyright (C) 2015 The Dagger Authors. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package dagger.internal.codegen; - -import androidx.room.compiler.processing.util.Source; -import com.google.common.collect.ImmutableList; -import dagger.testing.compile.CompilerTests; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.junit.runners.Parameterized; -import org.junit.runners.Parameterized.Parameters; - -@RunWith(Parameterized.class) -public class MissingBindingSuggestionsTest { - @Parameters(name = "{0}") - public static ImmutableList<Object[]> parameters() { - return CompilerMode.TEST_PARAMETERS; - } - - private final CompilerMode compilerMode; - - public MissingBindingSuggestionsTest(CompilerMode compilerMode) { - this.compilerMode = compilerMode; - } - - private static Source injectable(String className, String constructorParams) { - return CompilerTests.javaSource( - "test." + className, - "package test;", - "", - "import javax.inject.Inject;", - "", - "class " + className + " {", - " @Inject " + className + "(" + constructorParams + ") {}", - "}"); - } - - private static Source emptyInterface(String interfaceName) { - return CompilerTests.javaSource( - "test." + interfaceName, - "package test;", - "", - "import javax.inject.Inject;", - "", - "interface " + interfaceName + " {}"); - } - - @Test public void suggestsBindingInSeparateComponent() { - Source fooComponent = - CompilerTests.javaSource( - "test.FooComponent", - "package test;", - "", - "import dagger.Subcomponent;", - "", - "@Subcomponent", - "interface FooComponent {", - " Foo getFoo();", - "}"); - Source barModule = - CompilerTests.javaSource( - "test.BarModule", - "package test;", - "", - "import dagger.Provides;", - "import javax.inject.Inject;", - "", - "@dagger.Module", - "final class BarModule {", - " @Provides Bar provideBar() {return null;}", - "}"); - Source barComponent = - CompilerTests.javaSource( - "test.BarComponent", - "package test;", - "", - "import dagger.Subcomponent;", - "", - "@Subcomponent(modules = {BarModule.class})", - "interface BarComponent {", - " Bar getBar();", - "}"); - Source foo = injectable("Foo", "Bar bar"); - Source bar = emptyInterface("Bar"); - - Source topComponent = - CompilerTests.javaSource( - "test.TopComponent", - "package test;", - "", - "import dagger.Component;", - "", - "@Component", - "interface TopComponent {", - " FooComponent getFoo();", - " BarComponent getBar(BarModule barModule);", - "}"); - - CompilerTests.daggerCompiler(fooComponent, barComponent, topComponent, foo, bar, barModule) - .withProcessingOptions(compilerMode.processorOptions()) - .compile( - subject -> { - subject.hasErrorCount(1); - subject.hasErrorContaining("A binding for Bar exists in BarComponent:"); - }); - } - - @Test public void suggestsBindingInNestedSubcomponent() { - Source fooComponent = - CompilerTests.javaSource( - "test.FooComponent", - "package test;", - "", - "import dagger.Subcomponent;", - "", - "@Subcomponent", - "interface FooComponent {", - " Foo getFoo();", - "}"); - Source barComponent = - CompilerTests.javaSource( - "test.BarComponent", - "package test;", - "", - "import dagger.Subcomponent;", - "", - "@Subcomponent()", - "interface BarComponent {", - " BazComponent getBaz();", - "}"); - Source bazModule = - CompilerTests.javaSource( - "test.BazModule", - "package test;", - "", - "import dagger.Provides;", - "import javax.inject.Inject;", - "", - "@dagger.Module", - "final class BazModule {", - " @Provides Baz provideBaz() {return null;}", - "}"); - Source bazComponent = - CompilerTests.javaSource( - "test.BazComponent", - "package test;", - "", - "import dagger.Subcomponent;", - "", - "@Subcomponent(modules = {BazModule.class})", - "interface BazComponent {", - " Baz getBaz();", - "}"); - Source foo = injectable("Foo", "Baz baz"); - Source baz = emptyInterface("Baz"); - - Source topComponent = - CompilerTests.javaSource( - "test.TopComponent", - "package test;", - "", - "import dagger.Component;", - "", - "@Component", - "interface TopComponent {", - " FooComponent getFoo();", - " BarComponent getBar();", - "}"); - - CompilerTests.daggerCompiler( - fooComponent, barComponent, bazComponent, topComponent, foo, baz, bazModule) - .withProcessingOptions(compilerMode.processorOptions()) - .compile( - subject -> { - subject.hasErrorCount(1); - subject.hasErrorContaining("A binding for Baz exists in BazComponent:"); - }); - } - - @Test - public void missingBindingInParentComponent() { - Source parent = - CompilerTests.javaSource( - "Parent", - "import dagger.Component;", - "", - "@Component", - "interface Parent {", - " Foo foo();", - " Bar bar();", - " Child child();", - "}"); - Source child = - CompilerTests.javaSource( - "Child", - "import dagger.Subcomponent;", - "", - "@Subcomponent(modules=BazModule.class)", - "interface Child {", - " Foo foo();", - " Baz baz();", - "}"); - Source foo = - CompilerTests.javaSource( - "Foo", - "import javax.inject.Inject;", - "", - "class Foo {", - " @Inject Foo(Bar bar) {}", - "}"); - Source bar = - CompilerTests.javaSource( - "Bar", - "import javax.inject.Inject;", - "", - "class Bar {", - " @Inject Bar(Baz baz) {}", - "}"); - Source baz = CompilerTests.javaSource("Baz", "class Baz {}"); - Source bazModule = - CompilerTests.javaSource( - "BazModule", - "import dagger.Module;", - "import dagger.Provides;", - "import javax.inject.Inject;", - "", - "@Module", - "final class BazModule {", - " @Provides Baz provideBaz() {return new Baz();}", - "}"); - - CompilerTests.daggerCompiler(parent, child, foo, bar, baz, bazModule) - .withProcessingOptions(compilerMode.processorOptions()) - .compile( - subject -> { - subject.hasErrorCount(1); - subject.hasErrorContaining( - "\033[1;31m[Dagger/MissingBinding]\033[0m Baz cannot be provided without an " - + "@Inject constructor or an @Provides-annotated method."); - subject.hasErrorContaining("A binding for Baz exists in Child:"); - subject.hasErrorContaining(" Baz is injected at"); - subject.hasErrorContaining(" [Parent] Bar(baz)"); - subject.hasErrorContaining(" Bar is requested at"); - subject.hasErrorContaining(" [Parent] Parent.bar()"); - subject.hasErrorContaining("The following other entry points also depend on it:"); - subject.hasErrorContaining(" Parent.foo()"); - subject.hasErrorContaining(" Child.foo() [Parent → Child]") - .onSource(parent) - .onLineContaining("interface Parent"); - }); - } - - @Test - public void missingBindingInSiblingComponent() { - Source parent = - CompilerTests.javaSource( - "Parent", - "import dagger.Component;", - "", - "@Component", - "interface Parent {", - " Foo foo();", - " Bar bar();", - " Child1 child1();", - " Child2 child2();", - "}"); - Source child1 = - CompilerTests.javaSource( - "Child1", - "import dagger.Subcomponent;", - "", - "@Subcomponent", - "interface Child1 {", - " Foo foo();", - " Baz baz();", - "}"); - Source child2 = - CompilerTests.javaSource( - "Child2", - "import dagger.Subcomponent;", - "", - "@Subcomponent(modules = BazModule.class)", - "interface Child2 {", - " Foo foo();", - " Baz baz();", - "}"); - Source foo = - CompilerTests.javaSource( - "Foo", - "import javax.inject.Inject;", - "", - "class Foo {", - " @Inject Foo(Bar bar) {}", - "}"); - Source bar = - CompilerTests.javaSource( - "Bar", - "import javax.inject.Inject;", - "", - "class Bar {", - " @Inject Bar(Baz baz) {}", - "}"); - Source baz = CompilerTests.javaSource("Baz", "class Baz {}"); - Source bazModule = - CompilerTests.javaSource( - "BazModule", - "import dagger.Module;", - "import dagger.Provides;", - "import javax.inject.Inject;", - "", - "@Module", - "final class BazModule {", - " @Provides Baz provideBaz() {return new Baz();}", - "}"); - - CompilerTests.daggerCompiler(parent, child1, child2, foo, bar, baz, bazModule) - .withProcessingOptions(compilerMode.processorOptions()) - .compile( - subject -> { - subject.hasErrorCount(1); - subject.hasErrorContaining( - "\033[1;31m[Dagger/MissingBinding]\033[0m Baz cannot be provided without an " - + "@Inject constructor or an @Provides-annotated method."); - subject.hasErrorContaining("A binding for Baz exists in Child2:"); - subject.hasErrorContaining(" Baz is injected at"); - subject.hasErrorContaining(" [Parent] Bar(baz)"); - subject.hasErrorContaining(" Bar is requested at"); - subject.hasErrorContaining(" [Parent] Parent.bar()"); - subject.hasErrorContaining("The following other entry points also depend on it:"); - subject.hasErrorContaining(" Parent.foo()"); - subject.hasErrorContaining(" Child1.foo() [Parent → Child1]"); - subject.hasErrorContaining(" Child2.foo() [Parent → Child2]"); - subject.hasErrorContaining(" Child1.baz() [Parent → Child1]") - .onSource(parent) - .onLineContaining("interface Parent"); - }); - } -} diff --git a/javatests/dagger/internal/codegen/MissingBindingValidationTest.java b/javatests/dagger/internal/codegen/MissingBindingValidationTest.java index 919700ee5..8250861d8 100644 --- a/javatests/dagger/internal/codegen/MissingBindingValidationTest.java +++ b/javatests/dagger/internal/codegen/MissingBindingValidationTest.java @@ -18,6 +18,7 @@ package dagger.internal.codegen; import static com.google.common.truth.Truth.assertThat; +import androidx.room.compiler.processing.XProcessingEnv; import androidx.room.compiler.processing.util.DiagnosticMessage; import androidx.room.compiler.processing.util.Source; import com.google.common.collect.ImmutableList; @@ -348,18 +349,21 @@ public class MissingBindingValidationTest { subject -> { subject.hasErrorCount(1); subject.hasErrorContaining( - "TestClass.A cannot be provided without an @Provides-annotated method."); - subject.hasErrorContaining(" TestClass.A is injected at"); - subject.hasErrorContaining(" TestClass.B(a)"); - subject.hasErrorContaining(" TestClass.B is injected at"); - subject.hasErrorContaining(" TestClass.C.b"); - subject.hasErrorContaining(" TestClass.C is injected at"); - subject.hasErrorContaining(" TestClass.AComponent.injectC(TestClass.C)"); - subject.hasErrorContaining("The following other entry points also depend on it:"); - subject.hasErrorContaining(" TestClass.AComponent.getFoo()"); - subject.hasErrorContaining(" TestClass.AComponent.cProvider()"); - subject.hasErrorContaining(" TestClass.AComponent.lazyC()"); - subject.hasErrorContaining(" TestClass.AComponent.lazyCProvider()") + String.join( + "\n", + "TestClass.A cannot be provided without an @Provides-annotated method.", + "", + " TestClass.A is injected at", + " [TestClass.AComponent] TestClass.B(a)", + " TestClass.B is injected at", + " [TestClass.AComponent] TestClass.C.b", + " TestClass.C is injected at", + " [TestClass.AComponent] TestClass.AComponent.injectC(TestClass.C)", + "The following other entry points also depend on it:", + " TestClass.AComponent.getFoo()", + " TestClass.AComponent.cProvider()", + " TestClass.AComponent.lazyC()", + " TestClass.AComponent.lazyCProvider()")) .onSource(component) .onLineContaining("interface AComponent"); }); @@ -403,14 +407,17 @@ public class MissingBindingValidationTest { subject -> { subject.hasErrorCount(1); subject.hasErrorContaining( - "String cannot be provided without an @Inject constructor or an " - + "@Provides-annotated method."); - subject.hasErrorContaining(" String is injected at"); - subject.hasErrorContaining(" TestImplementation(missingBinding)"); - subject.hasErrorContaining(" TestImplementation is injected at"); - subject.hasErrorContaining(" TestModule.bindTestInterface(implementation)"); - subject.hasErrorContaining(" TestInterface is requested at"); - subject.hasErrorContaining(" TestComponent.testInterface()") + String.join( + "\n", + "String cannot be provided without an @Inject constructor or an " + + "@Provides-annotated method.", + "", + " String is injected at", + " [TestComponent] TestImplementation(missingBinding)", + " TestImplementation is injected at", + " [TestComponent] TestModule.bindTestInterface(implementation)", + " TestInterface is requested at", + " [TestComponent] TestComponent.testInterface()")) .onSource(component) .onLineContaining("interface TestComponent"); }); @@ -463,15 +470,18 @@ public class MissingBindingValidationTest { subject -> { subject.hasErrorCount(1); subject.hasErrorContaining( - "List cannot be provided without an @Provides-annotated method."); - subject.hasErrorContaining(" List is injected at"); - subject.hasErrorContaining(" TestClass(list)"); - subject.hasErrorContaining(" TestClass is injected at"); - subject.hasErrorContaining(" Generic(t)"); - subject.hasErrorContaining(" Generic<TestClass> is injected at"); - subject.hasErrorContaining(" UsesTest(genericTestClass)"); - subject.hasErrorContaining(" UsesTest is requested at"); - subject.hasErrorContaining(" TestComponent.usesTest()"); + String.join( + "\n", + "List cannot be provided without an @Provides-annotated method.", + "", + " List is injected at", + " [TestComponent] TestClass(list)", + " TestClass is injected at", + " [TestComponent] Generic(t)", + " Generic<TestClass> is injected at", + " [TestComponent] UsesTest(genericTestClass)", + " UsesTest is requested at", + " [TestComponent] TestComponent.usesTest()")); }); } @@ -527,15 +537,18 @@ public class MissingBindingValidationTest { subject -> { subject.hasErrorCount(1); subject.hasErrorContaining( - "List cannot be provided without an @Provides-annotated method."); - subject.hasErrorContaining(" List is injected at"); - subject.hasErrorContaining(" TestClass(list)"); - subject.hasErrorContaining(" TestClass is injected at"); - subject.hasErrorContaining(" Generic.t"); - subject.hasErrorContaining(" Generic<TestClass> is injected at"); - subject.hasErrorContaining(" UsesTest(genericTestClass)"); - subject.hasErrorContaining(" UsesTest is requested at"); - subject.hasErrorContaining(" TestComponent.usesTest()"); + String.join( + "\n", + "List cannot be provided without an @Provides-annotated method.", + "", + " List is injected at", + " [TestComponent] TestClass(list)", + " TestClass is injected at", + " [TestComponent] Generic.t", + " Generic<TestClass> is injected at", + " [TestComponent] UsesTest(genericTestClass)", + " UsesTest is requested at", + " [TestComponent] TestComponent.usesTest()")); }); } @@ -669,16 +682,19 @@ public class MissingBindingValidationTest { subject.hasErrorCount(1); // TODO(b/243720787): Replace with CompilationResultSubject#hasErrorContainingMatch() subject.hasErrorContaining( - "Double cannot be provided without an @Inject constructor or an " - + "@Provides-annotated method."); - subject.hasErrorContaining("Double is injected at"); - subject.hasErrorContaining(" ParentModule.missingDependency(dub)"); - subject.hasErrorContaining("Integer is injected at"); - subject.hasErrorContaining(" ChildModule.contributesToSet(i)"); - subject.hasErrorContaining("Set<String> is injected at"); - subject.hasErrorContaining(" ParentModule.dependsOnSet(strings)"); - subject.hasErrorContaining("Object is requested at"); - subject.hasErrorContaining(" Grandchild.object() [Parent → Child → Grandchild]") + String.join( + "\n", + "Double cannot be provided without an @Inject constructor or an " + + "@Provides-annotated method.", + "", + " Double is injected at", + " [Parent] ParentModule.missingDependency(dub)", + " Integer is injected at", + " [Child] ChildModule.contributesToSet(i)", + " Set<String> is injected at", + " [Child] ParentModule.dependsOnSet(strings)", + " Object is requested at", + " [Grandchild] Grandchild.object() [Parent → Child → Grandchild]")) .onSource(parent) .onLineContaining("interface Parent"); }); @@ -727,16 +743,18 @@ public class MissingBindingValidationTest { subject -> { subject.hasErrorCount(1); subject.hasErrorContaining( - "\033[1;31m[Dagger/MissingBinding]\033[0m " - + "NotBound cannot be provided without an @Provides-annotated method."); - subject.hasErrorContaining(" NotBound is injected at"); - subject.hasErrorContaining(" TestModule.object(notBound)"); - subject.hasErrorContaining(" Object is requested at"); - subject.hasErrorContaining(" TestComponent.object()"); - subject.hasErrorContaining("It is also requested at:"); - subject.hasErrorContaining(" TestModule.string(notBound, …)"); - subject.hasErrorContaining("The following other entry points also depend on it:"); - subject.hasErrorContaining(" TestComponent.string()") + String.join( + "\n", + "NotBound cannot be provided without an @Provides-annotated method.", + "", + " NotBound is injected at", + " [TestComponent] TestModule.object(notBound)", + " Object is requested at", + " [TestComponent] TestComponent.object()", + "It is also requested at:", + " TestModule.string(notBound, …)", + "The following other entry points also depend on it:", + " TestComponent.string()")) .onSource(component) .onLineContaining("interface TestComponent"); }); @@ -787,22 +805,27 @@ public class MissingBindingValidationTest { subject -> { subject.hasErrorCount(1); subject.hasErrorContaining( - "\033[1;31m[Dagger/MissingBinding]\033[0m String cannot be provided without an " - + "@Inject constructor or an @Provides-annotated method."); - subject.hasErrorContaining(" String is requested at"); - subject.hasErrorContaining(" TestComponent.string()"); - subject.hasErrorContaining("It is also requested at:"); - subject.hasErrorContaining(" Foo(one, …)"); - subject.hasErrorContaining(" Foo(…, two, …)"); - subject.hasErrorContaining(" Foo(…, three, …)"); - subject.hasErrorContaining(" Foo(…, four, …)"); - subject.hasErrorContaining(" Foo(…, five, …)"); - subject.hasErrorContaining(" Foo(…, six, …)"); - subject.hasErrorContaining(" Foo(…, seven, …)"); - subject.hasErrorContaining(" Foo(…, eight, …)"); - subject.hasErrorContaining(" Foo(…, nine, …)"); - subject.hasErrorContaining(" Foo(…, ten, …)"); - subject.hasErrorContaining(" and 3 others") + String.join( + "\n", + "String cannot be provided without an @Inject constructor or an " + + "@Provides-annotated method.", + "", + " String is requested at", + " [TestComponent] TestComponent.string()", + "It is also requested at:", + " Foo(one, …)", + " Foo(…, two, …)", + " Foo(…, three, …)", + " Foo(…, four, …)", + " Foo(…, five, …)", + " Foo(…, six, …)", + " Foo(…, seven, …)", + " Foo(…, eight, …)", + " Foo(…, nine, …)", + " Foo(…, ten, …)", + " and 3 others", + "The following other entry points also depend on it:", + " TestComponent.foo()")) .onSource(component) .onLineContaining("interface TestComponent"); }); @@ -839,22 +862,25 @@ public class MissingBindingValidationTest { subject -> { subject.hasErrorCount(1); subject.hasErrorContaining( - "\033[1;31m[Dagger/MissingBinding]\033[0m String cannot be provided without an " - + "@Inject constructor or an @Provides-annotated method."); - subject.hasErrorContaining(" String is requested at"); - subject.hasErrorContaining(" TestComponent.string1()"); - subject.hasErrorContaining("The following other entry points also depend on it:"); - subject.hasErrorContaining(" TestComponent.string2()"); - subject.hasErrorContaining(" TestComponent.string3()"); - subject.hasErrorContaining(" TestComponent.string4()"); - subject.hasErrorContaining(" TestComponent.string5()"); - subject.hasErrorContaining(" TestComponent.string6()"); - subject.hasErrorContaining(" TestComponent.string7()"); - subject.hasErrorContaining(" TestComponent.string8()"); - subject.hasErrorContaining(" TestComponent.string9()"); - subject.hasErrorContaining(" TestComponent.string10()"); - subject.hasErrorContaining(" TestComponent.string11()"); - subject.hasErrorContaining(" and 1 other") + String.join( + "\n", + "String cannot be provided without an @Inject constructor or an " + + "@Provides-annotated method.", + "", + " String is requested at", + " [TestComponent] TestComponent.string1()", + "The following other entry points also depend on it:", + " TestComponent.string2()", + " TestComponent.string3()", + " TestComponent.string4()", + " TestComponent.string5()", + " TestComponent.string6()", + " TestComponent.string7()", + " TestComponent.string8()", + " TestComponent.string9()", + " TestComponent.string10()", + " TestComponent.string11()", + " and 1 other")) .onSource(component) .onLineContaining("interface TestComponent"); }); @@ -908,16 +934,19 @@ public class MissingBindingValidationTest { subject -> { subject.hasErrorCount(1); subject.hasErrorContaining( - "\033[1;31m[Dagger/MissingBinding]\033[0m Baz cannot be provided without an " - + "@Inject constructor or an @Provides-annotated method."); - subject.hasErrorContaining(" Baz is injected at"); - subject.hasErrorContaining(" Bar(baz)"); - subject.hasErrorContaining(" Bar is requested at"); - subject.hasErrorContaining(" Parent.bar()"); - subject.hasErrorContaining("The following other entry points also depend on it:"); - subject.hasErrorContaining(" Parent.foo()"); - subject.hasErrorContaining(" Child.foo() [Parent → Child]"); - subject.hasErrorContaining(" Child.baz() [Parent → Child]") + String.join( + "\n", + "Baz cannot be provided without an @Inject constructor or an " + + "@Provides-annotated method.", + "", + " Baz is injected at", + " [Parent] Bar(baz)", + " Bar is requested at", + " [Parent] Parent.bar()", + "The following other entry points also depend on it:", + " Parent.foo()", + " Child.foo() [Parent → Child]", + " Child.baz() [Parent → Child]")) .onSource(parent) .onLineContaining("interface Parent"); }); @@ -1061,9 +1090,14 @@ public class MissingBindingValidationTest { subject.hasErrorContaining( String.join( "\n", - "A binding for Object exists in Child2:", - "Object is requested at", - "[Child1] Child1.getObject() [Parent → Child1]")); + "Object cannot be provided without an @Inject constructor or an " + + "@Provides-annotated method.", + "", + " Object is requested at", + " [Child1] Child1.getObject() [Parent → Child1]", + "", + "Note: Object is provided in the following other components:", + " [Child2] Child2Module.provideObject()")); }); } @@ -1174,10 +1208,17 @@ public class MissingBindingValidationTest { subject -> { subject.hasErrorCount(1); subject.hasErrorContaining( - "A binding for Object exists in [Parent → Child2 → RepeatedSub]:"); - subject.hasErrorContaining( - "[Parent → Child1 → RepeatedSub] RepeatedSub.getObject() [Parent → Child1 →" - + " RepeatedSub]"); + String.join( + "\n", + "Object cannot be provided without an @Inject constructor or an " + + "@Provides-annotated method.", + "", + " Object is requested at", + " [RepeatedSub] RepeatedSub.getObject() " + + "[Parent → Child1 → RepeatedSub]", + "", + "Note: Object is provided in the following other components:", + " [Child2] Child2Module.provideObject(…)")); }); } @@ -1298,9 +1339,17 @@ public class MissingBindingValidationTest { .compile( subject -> { subject.hasErrorCount(1); - subject.hasErrorContaining("A binding for Object exists in bar.Sub:"); subject.hasErrorContaining( - "[foo.Sub] foo.Sub.getObject() [Parent → Child1 → foo.Sub]"); + String.join( + "\n", + "Object cannot be provided without an @Inject constructor or an " + + "@Provides-annotated method.", + "", + " Object is requested at", + " [Sub] Sub.getObject() [Parent → Child1 → Sub]", + "", + "Note: Object is provided in the following other components:", + " [Child2] Child2Module.provideObject(…)")); }); } @@ -1384,11 +1433,25 @@ public class MissingBindingValidationTest { subject -> { subject.hasErrorCount(1); subject - .hasErrorContaining("Found similar bindings:") + .hasErrorContaining( + String.join( + "\n", + "Set<? extends Bar> cannot be provided without an @Provides-annotated " + + "method.", + "", + " Set<? extends Bar> is injected at", + " [MyComponent] Foo(bar)", + " Foo is requested at", + " [MyComponent] MyComponent.getFoo()", + "", + "Note: Set<? extends Bar> is provided in the following other components:", + " [Child] ChildModule.provideBar()", + "", + "Note: A similar binding is provided in the following other components:", + " Set<Bar> is provided at:", + " [MyComponent] Dagger-generated binding for Set<Bar>")) .onSource(component) .onLineContaining("interface MyComponent"); - subject.hasErrorContaining("Set<Bar> in [MyComponent"); - subject.hasErrorContaining("Set<? extends Bar> in [MyComponent → Child]"); }); } @@ -1443,7 +1506,20 @@ public class MissingBindingValidationTest { subject -> { subject.hasErrorCount(1); subject - .hasErrorContaining("Set<Bar> in [MyComponent]") + .hasErrorContaining( + String.join( + "\n", + "Set<? extends Bar> cannot be provided without an @Provides-annotated " + + "method.", + "", + " Set<? extends Bar> is injected at", + " [MyComponent] Foo(bar)", + " Foo is requested at", + " [MyComponent] MyComponent.getFoo()", + "", + "Note: A similar binding is provided in the following other components:", + " Set<Bar> is provided at:", + " [MyComponent] Dagger-generated binding for Set<Bar>")) .onSource(component) .onLineContaining("interface MyComponent"); }); @@ -1503,10 +1579,22 @@ public class MissingBindingValidationTest { subject -> { subject.hasErrorCount(1); subject - .hasErrorContaining("Found similar bindings:") + .hasErrorContaining( + String.join( + "\n", + "Set<? extends Bar> cannot be provided without an @Provides-annotated " + + "method.", + "", + " Set<? extends Bar> is injected at", + " [MyComponent] Foo.bar", + " Foo is requested at", + " [MyComponent] MyComponent.getFoo()", + "", + "Note: A similar binding is provided in the following other components:", + " Set<Bar> is provided at:", + " [MyComponent] Dagger-generated binding for Set<Bar>")) .onSource(component) .onLineContaining("interface MyComponent"); - subject.hasErrorContaining("Set<Bar> in [MyComponent]"); }); } @@ -1554,10 +1642,21 @@ public class MissingBindingValidationTest { subject -> { subject.hasErrorCount(1); subject - .hasErrorContaining("Found similar bindings:") + .hasErrorContaining( + String.join( + "\n", + "List<Bar> cannot be provided without an @Provides-annotated method.", + "", + " List<Bar> is injected at", + " [MyComponent] Foo(bar)", + " Foo is requested at", + " [MyComponent] MyComponent.getFoo()", + "", + "Note: A similar binding is provided in the following other components:", + " List<? extends Bar> is provided at:", + " [MyComponent] TestModule.provideBars()")) .onSource(component) .onLineContaining("interface MyComponent"); - subject.hasErrorContaining("List<? extends Bar> in [MyComponent]"); }); } @@ -1613,7 +1712,24 @@ public class MissingBindingValidationTest { subject -> { subject.hasErrorCount(1); subject - .hasErrorContaining("Bar<Baz,Baz,Set<Baz>> in [MyComponent]") + .hasErrorContaining( + String.join( + "\n", + // TODO(b/324325095): Align KSP and KAPT error message. + CompilerTests.backend(subject) == XProcessingEnv.Backend.KSP + ? "Bar<? extends Baz,Baz,Set<Baz>> cannot be provided without an " + + "@Inject constructor or an @Provides-annotated method." + : "Bar<? extends Baz,Baz,Set<Baz>> cannot be provided without an " + + "@Provides-annotated method.", + "", + " Bar<? extends Baz,Baz,Set<Baz>> is injected at", + " [MyComponent] Foo(bar)", + " Foo is requested at", + " [MyComponent] MyComponent.getFoo()", + "", + "Note: A similar binding is provided in the following other components:", + " Bar<Baz,Baz,Set<Baz>> is provided at:", + " [MyComponent] TestModule.provideBar()")) .onSource(component) .onLineContaining("interface MyComponent"); }); @@ -1733,8 +1849,23 @@ public class MissingBindingValidationTest { .compile( subject -> { subject.hasErrorCount(1); - subject.hasErrorContaining("Found similar bindings:"); - subject.hasErrorContaining("Bar in [MyComponent]"); + subject.hasErrorContaining( + String.join( + "\n", + // TODO(b/324325095): Align KSP and KAPT error message. + CompilerTests.backend(subject) == XProcessingEnv.Backend.KSP + ? "Bar<?> cannot be provided without an @Inject constructor or an " + + "@Provides-annotated method." + : "Bar<?> cannot be provided without an @Provides-annotated method.", + "", + " Bar<?> is injected at", + " [MyComponent] Foo(bar)", + " Foo is requested at", + " [MyComponent] MyComponent.getFoo()", + "", + "Note: A similar binding is provided in the following other components:", + " Bar is provided at:", + " [MyComponent] TestModule.provideBar()")); }); } diff --git a/javatests/dagger/internal/codegen/ProductionComponentProcessorTest.java b/javatests/dagger/internal/codegen/ProductionComponentProcessorTest.java index b9758c121..39e63c99e 100644 --- a/javatests/dagger/internal/codegen/ProductionComponentProcessorTest.java +++ b/javatests/dagger/internal/codegen/ProductionComponentProcessorTest.java @@ -202,6 +202,51 @@ public class ProductionComponentProcessorTest { } @Test + public void dependsOnProductionSubcomponentWithPluginsVisitFullBindingGraphs() throws Exception { + Source myComponent = + CompilerTests.javaSource( + "test.MyComponent", + "package test;", + "", + "import dagger.Component;", + "", + "@Component(modules = MyModule.class)", + "interface MyComponent {}"); + Source myModule = + CompilerTests.javaSource( + "test.MyModule", + "package test;", + "", + "import dagger.Component;", + "import dagger.Module;", + "", + "@Module(subcomponents = MyProductionSubcomponent.class)", + "interface MyModule {}"); + Source myProductionSubcomponent = + CompilerTests.javaSource( + "test.MyProductionSubcomponent", + "package test;", + "", + "import dagger.producers.ProductionSubcomponent;", + "", + "@ProductionSubcomponent", + "interface MyProductionSubcomponent {", + " @ProductionSubcomponent.Builder", + " interface Builder {", + " MyProductionSubcomponent build();", + " }", + "}"); + + CompilerTests.daggerCompiler(myComponent, myModule, myProductionSubcomponent) + .withProcessingOptions( + ImmutableMap.<String, String>builder() + .putAll(compilerMode.processorOptions()) + .put("dagger.pluginsVisitFullBindingGraphs", "ENABLED") + .buildOrThrow()) + .compile(subject -> subject.hasErrorCount(0)); + } + + @Test public void simpleComponent() throws Exception { Source component = CompilerTests.javaSource( diff --git a/javatests/dagger/internal/codegen/ProductionGraphValidationTest.java b/javatests/dagger/internal/codegen/ProductionGraphValidationTest.java index 1b0b85bbd..cfcf8ee88 100644 --- a/javatests/dagger/internal/codegen/ProductionGraphValidationTest.java +++ b/javatests/dagger/internal/codegen/ProductionGraphValidationTest.java @@ -195,14 +195,11 @@ public class ProductionGraphValidationTest { .buildOrThrow()) .compile( subject -> { - subject.hasErrorCount(2); + subject.hasErrorCount(1); subject.hasErrorContaining( "TestClass.A is a provision, which cannot depend on a production.") .onSource(component) .onLineContaining("class AModule"); - subject.hasErrorContaining("test.TestClass.AModule has errors") - .onSource(component) - .onLineContaining("@ProductionComponent"); }); } diff --git a/javatests/dagger/internal/codegen/bindinggraphvalidation/NullableBindingValidationKotlinTest.java b/javatests/dagger/internal/codegen/bindinggraphvalidation/NullableBindingValidationKotlinTest.java index 6b63b7c9b..4b49e1660 100644 --- a/javatests/dagger/internal/codegen/bindinggraphvalidation/NullableBindingValidationKotlinTest.java +++ b/javatests/dagger/internal/codegen/bindinggraphvalidation/NullableBindingValidationKotlinTest.java @@ -18,7 +18,6 @@ package dagger.internal.codegen.bindinggraphvalidation; import static dagger.internal.codegen.bindinggraphvalidation.NullableBindingValidator.nullableToNonNullable; -import androidx.room.compiler.processing.XProcessingEnv; import androidx.room.compiler.processing.util.Source; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; @@ -83,12 +82,7 @@ public class NullableBindingValidationKotlinTest { subject.hasErrorContaining( nullableToNonNullable( "String", - CompilerTests.backend(subject) == XProcessingEnv.Backend.JAVAC - ? "@Nullable @Provides String TestModule.provideString()" - // TODO(b/268550160): For KSP, we should be including the kotlin typename - // in the error message, e.g. "String?" otherwise the message doesn't make - // a lot of sense. - : "@Provides String TestModule.provideString()")); + "@Provides @Nullable String TestModule.provideString()")); }); // but if we disable the validation, then it compiles fine. @@ -144,12 +138,7 @@ public class NullableBindingValidationKotlinTest { subject.hasErrorContaining( nullableToNonNullable( "String", - CompilerTests.backend(subject) == XProcessingEnv.Backend.JAVAC - ? "@Nullable @Provides String TestModule.provideString()" - // TODO(b/268550160): For KSP, we should be including the kotlin typename - // in the error message, e.g. "String?" otherwise the message doesn't make - // a lot of sense. - : "@Provides String TestModule.provideString()")); + "@Provides @Nullable String TestModule.provideString()")); }); // but if we disable the validation, then it compiles fine. @@ -205,12 +194,7 @@ public class NullableBindingValidationKotlinTest { subject.hasErrorContaining( nullableToNonNullable( "String", - CompilerTests.backend(subject) == XProcessingEnv.Backend.JAVAC - ? "@Nullable @Provides String TestModule.provideString()" - // TODO(b/268550160): For KSP, we should be including the kotlin typename - // in the error message, e.g. "String?" otherwise the message doesn't make - // a lot of sense. - : "@Provides String TestModule.provideString()")); + "@Provides @Nullable String TestModule.provideString()")); }); // but if we disable the validation, then it compiles fine. @@ -255,12 +239,7 @@ public class NullableBindingValidationKotlinTest { subject.hasErrorContaining( nullableToNonNullable( "String", - CompilerTests.backend(subject) == XProcessingEnv.Backend.JAVAC - ? "@Nullable @Provides String TestModule.provideString()" - // TODO(b/268550160): For KSP, we should be including the kotlin typename - // in the error message, e.g. "String?" otherwise the message doesn't make - // a lot of sense. - : "@Provides String TestModule.provideString()")); + "@Provides @Nullable String TestModule.provideString()")); }); // but if we disable the validation, then it compiles fine. @@ -320,12 +299,7 @@ public class NullableBindingValidationKotlinTest { subject.hasErrorContaining( nullableToNonNullable( "String", - CompilerTests.backend(subject) == XProcessingEnv.Backend.JAVAC - ? "@Nullable @Provides String TestModule.Companion.provideString()" - // TODO(b/268550160): For KSP, we should be including the kotlin typename - // in the error message, e.g. "String?" otherwise the message doesn't make - // a lot of sense. - : "@Provides String TestModule.Companion.provideString()")); + "@Provides @Nullable String TestModule.Companion.provideString()")); }); } @@ -496,12 +470,7 @@ public class NullableBindingValidationKotlinTest { subject.hasErrorContaining( nullableToNonNullable( "String", - CompilerTests.backend(subject) == XProcessingEnv.Backend.JAVAC - ? "@Nullable @Provides String TestModule.Companion.nullableString()" - // TODO(b/268550160): For KSP, we should be including the kotlin typename - // in the error message, e.g. "String?" otherwise the message doesn't make - // a lot of sense. - : "@Provides String TestModule.Companion.nullableString()")); + "@Provides @Nullable String TestModule.Companion.nullableString()")); }); } } diff --git a/javatests/dagger/internal/codegen/bindinggraphvalidation/SetMultibindingValidationTest.java b/javatests/dagger/internal/codegen/bindinggraphvalidation/SetMultibindingValidationTest.java index 8eaccaede..e68099ae4 100644 --- a/javatests/dagger/internal/codegen/bindinggraphvalidation/SetMultibindingValidationTest.java +++ b/javatests/dagger/internal/codegen/bindinggraphvalidation/SetMultibindingValidationTest.java @@ -95,6 +95,85 @@ public class SetMultibindingValidationTest { }); } + // Regression test for b/316582741 to ensure the duplicate binding gets reported rather than + // causing a crash. + @Test public void testSetBindingsToDuplicateBinding() { + Source module = + CompilerTests.javaSource( + "test.TestModule", + "package test;", + "", + "import dagger.Binds;", + "import dagger.Module;", + "import dagger.Provides;", + "import dagger.multibindings.IntoSet;", + "", + "@Module", + "interface TestModule {", + " @Binds @IntoSet Foo bindFoo(FooImpl impl);", + "", + " @Provides static FooImpl provideFooImpl() { return null; }", + "", + " @Provides static FooImpl provideFooImplAgain() { return null; }", + "}"); + Source component = + CompilerTests.javaSource( + "test.TestComponent", + "package test;", + "", + "import dagger.Component;", + "import java.util.Set;", + "", + "@Component(modules = TestModule.class)", + "interface TestComponent {", + " Set<Foo> setOfFoo();", + "}"); + CompilerTests.daggerCompiler(FOO, FOO_IMPL, module, component) + .withProcessingOptions(compilerMode.processorOptions()) + .compile( + subject -> { + subject.hasErrorCount(1); + subject.hasErrorContaining("FooImpl is bound multiple times"); + }); + } + + @Test public void testSetBindingsToMissingBinding() { + Source module = + CompilerTests.javaSource( + "test.TestModule", + "package test;", + "", + "import dagger.Binds;", + "import dagger.Module;", + "import dagger.multibindings.IntoSet;", + "", + "@Module", + "interface TestModule {", + " @Binds @IntoSet Foo bindFoo(MissingFooImpl impl);", + "", + " static class MissingFooImpl implements Foo {}", + "}"); + Source component = + CompilerTests.javaSource( + "test.TestComponent", + "package test;", + "", + "import dagger.Component;", + "import java.util.Set;", + "", + "@Component(modules = TestModule.class)", + "interface TestComponent {", + " Set<Foo> setOfFoo();", + "}"); + CompilerTests.daggerCompiler(FOO, module, component) + .withProcessingOptions(compilerMode.processorOptions()) + .compile( + subject -> { + subject.hasErrorCount(1); + subject.hasErrorContaining("MissingFooImpl cannot be provided"); + }); + } + @Test public void testMultipleSetBindingsToSameFooThroughMultipleBinds() { Source module = CompilerTests.javaSource( diff --git a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_assistedParamConflictsWithComponentFieldName_successfulyDeduped_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_assistedParamConflictsWithComponentFieldName_successfulyDeduped_DEFAULT_MODE_test.DaggerTestComponent index 20f38ddd0..ebea812d2 100644 --- a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_assistedParamConflictsWithComponentFieldName_successfulyDeduped_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_assistedParamConflictsWithComponentFieldName_successfulyDeduped_DEFAULT_MODE_test.DaggerTestComponent @@ -1,8 +1,8 @@ package test; import dagger.internal.DaggerGenerated; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -13,7 +13,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -52,7 +53,7 @@ final class DaggerTestComponent { @SuppressWarnings("unchecked") private void initialize() { this.fooProvider = Foo_Factory.create(Bar_Factory.create()); - this.fooFactoryProvider = FooFactory_Impl.create(fooProvider); + this.fooFactoryProvider = FooFactory_Impl.createFactoryProvider(fooProvider); } @Override diff --git a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_assistedParamConflictsWithComponentFieldName_successfulyDeduped_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_assistedParamConflictsWithComponentFieldName_successfulyDeduped_FAST_INIT_MODE_test.DaggerTestComponent index c76a5fbdd..f522a426d 100644 --- a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_assistedParamConflictsWithComponentFieldName_successfulyDeduped_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_assistedParamConflictsWithComponentFieldName_successfulyDeduped_FAST_INIT_MODE_test.DaggerTestComponent @@ -1,9 +1,9 @@ package test; import dagger.internal.DaggerGenerated; +import dagger.internal.Provider; import dagger.internal.SingleCheck; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -14,7 +14,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testAssistedFactoryCycle_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testAssistedFactoryCycle_DEFAULT_MODE_test.DaggerTestComponent index 7b22b0018..bdd35a5fc 100644 --- a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testAssistedFactoryCycle_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testAssistedFactoryCycle_DEFAULT_MODE_test.DaggerTestComponent @@ -2,8 +2,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DelegateFactory; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -14,7 +14,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -57,7 +58,7 @@ final class DaggerTestComponent { this.fooFactoryProvider = new DelegateFactory<>(); this.barProvider = Bar_Factory.create(fooFactoryProvider); this.fooProvider = Foo_Factory.create(barProvider); - DelegateFactory.setDelegate(fooFactoryProvider, FooFactory_Impl.create(fooProvider)); + DelegateFactory.setDelegate(fooFactoryProvider, FooFactory_Impl.createFactoryProvider(fooProvider)); } @Override diff --git a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testAssistedFactoryCycle_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testAssistedFactoryCycle_FAST_INIT_MODE_test.DaggerTestComponent index 48f517401..2d5efe691 100644 --- a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testAssistedFactoryCycle_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testAssistedFactoryCycle_FAST_INIT_MODE_test.DaggerTestComponent @@ -2,9 +2,9 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DelegateFactory; +import dagger.internal.Provider; import dagger.internal.SingleCheck; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -15,7 +15,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testAssistedFactory_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testAssistedFactory_DEFAULT_MODE_test.DaggerTestComponent index 20f38ddd0..ebea812d2 100644 --- a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testAssistedFactory_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testAssistedFactory_DEFAULT_MODE_test.DaggerTestComponent @@ -1,8 +1,8 @@ package test; import dagger.internal.DaggerGenerated; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -13,7 +13,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -52,7 +53,7 @@ final class DaggerTestComponent { @SuppressWarnings("unchecked") private void initialize() { this.fooProvider = Foo_Factory.create(Bar_Factory.create()); - this.fooFactoryProvider = FooFactory_Impl.create(fooProvider); + this.fooFactoryProvider = FooFactory_Impl.createFactoryProvider(fooProvider); } @Override diff --git a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testAssistedFactory_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testAssistedFactory_FAST_INIT_MODE_test.DaggerTestComponent index 72f16729c..db44f08dd 100644 --- a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testAssistedFactory_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testAssistedFactory_FAST_INIT_MODE_test.DaggerTestComponent @@ -1,9 +1,9 @@ package test; import dagger.internal.DaggerGenerated; +import dagger.internal.Provider; import dagger.internal.SingleCheck; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -14,7 +14,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testFactoryGeneratorDuplicatedParamNames_DEFAULT_MODE_test.Foo_Factory b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testFactoryGeneratorDuplicatedParamNames_DEFAULT_MODE_test.Foo_Factory index ed8f09856..0ae501c07 100644 --- a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testFactoryGeneratorDuplicatedParamNames_DEFAULT_MODE_test.Foo_Factory +++ b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testFactoryGeneratorDuplicatedParamNames_DEFAULT_MODE_test.Foo_Factory @@ -17,7 +17,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class Foo_Factory { private final Provider<Bar> argProvider; diff --git a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testFactoryGeneratorDuplicatedParamNames_FAST_INIT_MODE_test.Foo_Factory b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testFactoryGeneratorDuplicatedParamNames_FAST_INIT_MODE_test.Foo_Factory index ed8f09856..0ae501c07 100644 --- a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testFactoryGeneratorDuplicatedParamNames_FAST_INIT_MODE_test.Foo_Factory +++ b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testFactoryGeneratorDuplicatedParamNames_FAST_INIT_MODE_test.Foo_Factory @@ -17,7 +17,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class Foo_Factory { private final Provider<Bar> argProvider; diff --git a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testMultipleAssistedFactoryInDifferentComponents_DEFAULT_MODE_test.DaggerMyComponent b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testMultipleAssistedFactoryInDifferentComponents_DEFAULT_MODE_test.DaggerMyComponent new file mode 100644 index 000000000..b3fc31665 --- /dev/null +++ b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testMultipleAssistedFactoryInDifferentComponents_DEFAULT_MODE_test.DaggerMyComponent @@ -0,0 +1,98 @@ +package test; + +import dagger.internal.DaggerGenerated; +import dagger.internal.Provider; +import javax.annotation.processing.Generated; + +@DaggerGenerated +@Generated( + value = "dagger.internal.codegen.ComponentProcessor", + comments = "https://dagger.dev" +) +@SuppressWarnings({ + "unchecked", + "rawtypes", + "KotlinInternal", + "KotlinInternalInJava", + "cast" +}) +final class DaggerMyComponent { + private DaggerMyComponent() { + } + + public static Builder builder() { + return new Builder(); + } + + public static MyComponent create() { + return new Builder().build(); + } + + static final class Builder { + private Builder() { + } + + public MyComponent build() { + return new MyComponentImpl(); + } + } + + private static final class MySubcomponentImpl implements MySubcomponent { + private final MyComponentImpl myComponentImpl; + + private final MySubcomponentImpl mySubcomponentImpl = this; + + private MyAssistedClass_Factory myAssistedClassProvider; + + private Provider<MySubcomponentAssistedFactory> mySubcomponentAssistedFactoryProvider; + + private MySubcomponentImpl(MyComponentImpl myComponentImpl) { + this.myComponentImpl = myComponentImpl; + + initialize(); + + } + + @SuppressWarnings("unchecked") + private void initialize() { + this.myAssistedClassProvider = MyAssistedClass_Factory.create(Baz_Factory.create()); + this.mySubcomponentAssistedFactoryProvider = MySubcomponentAssistedFactory_Impl.createFactoryProvider(myAssistedClassProvider); + } + + @Override + public MySubcomponentAssistedFactory mySubcomponentAssistedFactory() { + return mySubcomponentAssistedFactoryProvider.get(); + } + } + + private static final class MyComponentImpl implements MyComponent { + private final MyComponentImpl myComponentImpl = this; + + private MyAssistedClass_Factory myAssistedClassProvider; + + private Provider<MyComponentAssistedFactory> myComponentAssistedFactoryProvider; + + private MyComponentImpl() { + + initialize(); + + } + + @SuppressWarnings("unchecked") + private void initialize() { + this.myAssistedClassProvider = MyAssistedClass_Factory.create(Baz_Factory.create()); + this.myComponentAssistedFactoryProvider = MyComponentAssistedFactory_Impl.createFactoryProvider(myAssistedClassProvider); + } + + @Override + public MyComponentAssistedFactory myComponentAssistedFactory() { + return myComponentAssistedFactoryProvider.get(); + } + + @Override + public MySubcomponent mySubcomponent() { + return new MySubcomponentImpl(myComponentImpl); + } + } +} + diff --git a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testMultipleAssistedFactoryInDifferentComponents_FAST_INIT_MODE_test.DaggerMyComponent b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testMultipleAssistedFactoryInDifferentComponents_FAST_INIT_MODE_test.DaggerMyComponent new file mode 100644 index 000000000..68c5a77d0 --- /dev/null +++ b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testMultipleAssistedFactoryInDifferentComponents_FAST_INIT_MODE_test.DaggerMyComponent @@ -0,0 +1,151 @@ +package test; + +import dagger.internal.DaggerGenerated; +import dagger.internal.Provider; +import dagger.internal.SingleCheck; +import javax.annotation.processing.Generated; + +@DaggerGenerated +@Generated( + value = "dagger.internal.codegen.ComponentProcessor", + comments = "https://dagger.dev" +) +@SuppressWarnings({ + "unchecked", + "rawtypes", + "KotlinInternal", + "KotlinInternalInJava", + "cast" +}) +final class DaggerMyComponent { + private DaggerMyComponent() { + } + + public static Builder builder() { + return new Builder(); + } + + public static MyComponent create() { + return new Builder().build(); + } + + static final class Builder { + private Builder() { + } + + public MyComponent build() { + return new MyComponentImpl(); + } + } + + private static final class MySubcomponentImpl implements MySubcomponent { + private final MyComponentImpl myComponentImpl; + + private final MySubcomponentImpl mySubcomponentImpl = this; + + private Provider<MySubcomponentAssistedFactory> mySubcomponentAssistedFactoryProvider; + + private MySubcomponentImpl(MyComponentImpl myComponentImpl) { + this.myComponentImpl = myComponentImpl; + + initialize(); + + } + + @SuppressWarnings("unchecked") + private void initialize() { + this.mySubcomponentAssistedFactoryProvider = SingleCheck.provider(new SwitchingProvider<MySubcomponentAssistedFactory>(myComponentImpl, mySubcomponentImpl, 0)); + } + + @Override + public MySubcomponentAssistedFactory mySubcomponentAssistedFactory() { + return mySubcomponentAssistedFactoryProvider.get(); + } + + private static final class SwitchingProvider<T> implements Provider<T> { + private final MyComponentImpl myComponentImpl; + + private final MySubcomponentImpl mySubcomponentImpl; + + private final int id; + + SwitchingProvider(MyComponentImpl myComponentImpl, MySubcomponentImpl mySubcomponentImpl, + int id) { + this.myComponentImpl = myComponentImpl; + this.mySubcomponentImpl = mySubcomponentImpl; + this.id = id; + } + + @SuppressWarnings("unchecked") + @Override + public T get() { + switch (id) { + case 0: // test.MySubcomponentAssistedFactory + return (T) new MySubcomponentAssistedFactory() { + @Override + public MyAssistedClass create(Bar bar, Foo foo) { + return new MyAssistedClass(foo, new Baz(), bar); + } + }; + + default: throw new AssertionError(id); + } + } + } + } + + private static final class MyComponentImpl implements MyComponent { + private final MyComponentImpl myComponentImpl = this; + + private Provider<MyComponentAssistedFactory> myComponentAssistedFactoryProvider; + + private MyComponentImpl() { + + initialize(); + + } + + @SuppressWarnings("unchecked") + private void initialize() { + this.myComponentAssistedFactoryProvider = SingleCheck.provider(new SwitchingProvider<MyComponentAssistedFactory>(myComponentImpl, 0)); + } + + @Override + public MyComponentAssistedFactory myComponentAssistedFactory() { + return myComponentAssistedFactoryProvider.get(); + } + + @Override + public MySubcomponent mySubcomponent() { + return new MySubcomponentImpl(myComponentImpl); + } + + private static final class SwitchingProvider<T> implements Provider<T> { + private final MyComponentImpl myComponentImpl; + + private final int id; + + SwitchingProvider(MyComponentImpl myComponentImpl, int id) { + this.myComponentImpl = myComponentImpl; + this.id = id; + } + + @SuppressWarnings("unchecked") + @Override + public T get() { + switch (id) { + case 0: // test.MyComponentAssistedFactory + return (T) new MyComponentAssistedFactory() { + @Override + public MyAssistedClass create(Bar bar, Foo foo) { + return new MyAssistedClass(foo, new Baz(), bar); + } + }; + + default: throw new AssertionError(id); + } + } + } + } +} + diff --git a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testParameterizedAssistParam_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testParameterizedAssistParam_DEFAULT_MODE_test.DaggerTestComponent index da1f53e75..f94d608f7 100644 --- a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testParameterizedAssistParam_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testParameterizedAssistParam_DEFAULT_MODE_test.DaggerTestComponent @@ -1,8 +1,8 @@ package test; import dagger.internal.DaggerGenerated; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -13,7 +13,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -52,7 +53,7 @@ final class DaggerTestComponent { @SuppressWarnings("unchecked") private void initialize() { this.fooProvider = Foo_Factory.create(); - this.fooFactoryProvider = FooFactory_Impl.create(fooProvider); + this.fooFactoryProvider = FooFactory_Impl.createFactoryProvider(fooProvider); } @Override diff --git a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testParameterizedAssistParam_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testParameterizedAssistParam_FAST_INIT_MODE_test.DaggerTestComponent index a56b3e084..0726e0fe2 100644 --- a/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testParameterizedAssistParam_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/AssistedFactoryTest_testParameterizedAssistParam_FAST_INIT_MODE_test.DaggerTestComponent @@ -1,9 +1,9 @@ package test; import dagger.internal.DaggerGenerated; +import dagger.internal.Provider; import dagger.internal.SingleCheck; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -14,7 +14,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentBuilderTest_testUsesBuildAndSetterNames_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentBuilderTest_testUsesBuildAndSetterNames_DEFAULT_MODE_test.DaggerTestComponent index f5524ec83..7aed6ce53 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentBuilderTest_testUsesBuildAndSetterNames_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentBuilderTest_testUsesBuildAndSetterNames_DEFAULT_MODE_test.DaggerTestComponent @@ -13,7 +13,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentBuilderTest_testUsesBuildAndSetterNames_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentBuilderTest_testUsesBuildAndSetterNames_FAST_INIT_MODE_test.DaggerTestComponent index f5524ec83..7aed6ce53 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentBuilderTest_testUsesBuildAndSetterNames_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentBuilderTest_testUsesBuildAndSetterNames_FAST_INIT_MODE_test.DaggerTestComponent @@ -13,7 +13,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCanInstantiateModulesUserCannotSet_compilerMode=DEFAULT_MODE, creatorKind=dagger.Component.Builder_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCanInstantiateModulesUserCannotSet_compilerMode=DEFAULT_MODE, creatorKind=dagger.Component.Builder_test.DaggerTestComponent index fd3b2dde2..384875abb 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCanInstantiateModulesUserCannotSet_compilerMode=DEFAULT_MODE, creatorKind=dagger.Component.Builder_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCanInstantiateModulesUserCannotSet_compilerMode=DEFAULT_MODE, creatorKind=dagger.Component.Builder_test.DaggerTestComponent @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCanInstantiateModulesUserCannotSet_compilerMode=DEFAULT_MODE, creatorKind=dagger.Component.Factory_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCanInstantiateModulesUserCannotSet_compilerMode=DEFAULT_MODE, creatorKind=dagger.Component.Factory_test.DaggerTestComponent index e2e2d9383..b4fa61912 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCanInstantiateModulesUserCannotSet_compilerMode=DEFAULT_MODE, creatorKind=dagger.Component.Factory_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCanInstantiateModulesUserCannotSet_compilerMode=DEFAULT_MODE, creatorKind=dagger.Component.Factory_test.DaggerTestComponent @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCanInstantiateModulesUserCannotSet_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Component.Builder_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCanInstantiateModulesUserCannotSet_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Component.Builder_test.DaggerTestComponent index fd3b2dde2..384875abb 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCanInstantiateModulesUserCannotSet_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Component.Builder_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCanInstantiateModulesUserCannotSet_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Component.Builder_test.DaggerTestComponent @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCanInstantiateModulesUserCannotSet_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Component.Factory_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCanInstantiateModulesUserCannotSet_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Component.Factory_test.DaggerTestComponent index e2e2d9383..b4fa61912 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCanInstantiateModulesUserCannotSet_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Component.Factory_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCanInstantiateModulesUserCannotSet_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Component.Factory_test.DaggerTestComponent @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCreatorWithBindsInstanceNoStaticCreateGenerated_compilerMode=DEFAULT_MODE, creatorKind=dagger.Component.Builder_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCreatorWithBindsInstanceNoStaticCreateGenerated_compilerMode=DEFAULT_MODE, creatorKind=dagger.Component.Builder_test.DaggerSimpleComponent index dd9662b7c..510db53fb 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCreatorWithBindsInstanceNoStaticCreateGenerated_compilerMode=DEFAULT_MODE, creatorKind=dagger.Component.Builder_test.DaggerSimpleComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCreatorWithBindsInstanceNoStaticCreateGenerated_compilerMode=DEFAULT_MODE, creatorKind=dagger.Component.Builder_test.DaggerSimpleComponent @@ -13,7 +13,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerSimpleComponent { private DaggerSimpleComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCreatorWithBindsInstanceNoStaticCreateGenerated_compilerMode=DEFAULT_MODE, creatorKind=dagger.Component.Factory_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCreatorWithBindsInstanceNoStaticCreateGenerated_compilerMode=DEFAULT_MODE, creatorKind=dagger.Component.Factory_test.DaggerSimpleComponent index 05ac4a822..c31b4abaf 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCreatorWithBindsInstanceNoStaticCreateGenerated_compilerMode=DEFAULT_MODE, creatorKind=dagger.Component.Factory_test.DaggerSimpleComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCreatorWithBindsInstanceNoStaticCreateGenerated_compilerMode=DEFAULT_MODE, creatorKind=dagger.Component.Factory_test.DaggerSimpleComponent @@ -13,7 +13,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerSimpleComponent { private DaggerSimpleComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCreatorWithBindsInstanceNoStaticCreateGenerated_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Component.Builder_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCreatorWithBindsInstanceNoStaticCreateGenerated_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Component.Builder_test.DaggerSimpleComponent index dd9662b7c..510db53fb 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCreatorWithBindsInstanceNoStaticCreateGenerated_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Component.Builder_test.DaggerSimpleComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCreatorWithBindsInstanceNoStaticCreateGenerated_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Component.Builder_test.DaggerSimpleComponent @@ -13,7 +13,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerSimpleComponent { private DaggerSimpleComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCreatorWithBindsInstanceNoStaticCreateGenerated_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Component.Factory_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCreatorWithBindsInstanceNoStaticCreateGenerated_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Component.Factory_test.DaggerSimpleComponent index 05ac4a822..c31b4abaf 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCreatorWithBindsInstanceNoStaticCreateGenerated_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Component.Factory_test.DaggerSimpleComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCreatorWithBindsInstanceNoStaticCreateGenerated_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Component.Factory_test.DaggerSimpleComponent @@ -13,7 +13,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerSimpleComponent { private DaggerSimpleComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCreatorWithPrimitiveBindsInstance_compilerMode=DEFAULT_MODE, creatorKind=dagger.Component.Builder_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCreatorWithPrimitiveBindsInstance_compilerMode=DEFAULT_MODE, creatorKind=dagger.Component.Builder_test.DaggerSimpleComponent index bbfedd0e1..77058c340 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCreatorWithPrimitiveBindsInstance_compilerMode=DEFAULT_MODE, creatorKind=dagger.Component.Builder_test.DaggerSimpleComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCreatorWithPrimitiveBindsInstance_compilerMode=DEFAULT_MODE, creatorKind=dagger.Component.Builder_test.DaggerSimpleComponent @@ -13,7 +13,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerSimpleComponent { private DaggerSimpleComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCreatorWithPrimitiveBindsInstance_compilerMode=DEFAULT_MODE, creatorKind=dagger.Component.Factory_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCreatorWithPrimitiveBindsInstance_compilerMode=DEFAULT_MODE, creatorKind=dagger.Component.Factory_test.DaggerSimpleComponent index fb85bebc1..6583a231d 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCreatorWithPrimitiveBindsInstance_compilerMode=DEFAULT_MODE, creatorKind=dagger.Component.Factory_test.DaggerSimpleComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCreatorWithPrimitiveBindsInstance_compilerMode=DEFAULT_MODE, creatorKind=dagger.Component.Factory_test.DaggerSimpleComponent @@ -13,7 +13,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerSimpleComponent { private DaggerSimpleComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCreatorWithPrimitiveBindsInstance_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Component.Builder_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCreatorWithPrimitiveBindsInstance_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Component.Builder_test.DaggerSimpleComponent index bbfedd0e1..77058c340 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCreatorWithPrimitiveBindsInstance_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Component.Builder_test.DaggerSimpleComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCreatorWithPrimitiveBindsInstance_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Component.Builder_test.DaggerSimpleComponent @@ -13,7 +13,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerSimpleComponent { private DaggerSimpleComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCreatorWithPrimitiveBindsInstance_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Component.Factory_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCreatorWithPrimitiveBindsInstance_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Component.Factory_test.DaggerSimpleComponent index fb85bebc1..6583a231d 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCreatorWithPrimitiveBindsInstance_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Component.Factory_test.DaggerSimpleComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testCreatorWithPrimitiveBindsInstance_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Component.Factory_test.DaggerSimpleComponent @@ -13,7 +13,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerSimpleComponent { private DaggerSimpleComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testEmptyCreator_compilerMode=DEFAULT_MODE, creatorKind=dagger.Component.Builder_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testEmptyCreator_compilerMode=DEFAULT_MODE, creatorKind=dagger.Component.Builder_test.DaggerSimpleComponent index b117ad872..5040a7824 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testEmptyCreator_compilerMode=DEFAULT_MODE, creatorKind=dagger.Component.Builder_test.DaggerSimpleComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testEmptyCreator_compilerMode=DEFAULT_MODE, creatorKind=dagger.Component.Builder_test.DaggerSimpleComponent @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerSimpleComponent { private DaggerSimpleComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testEmptyCreator_compilerMode=DEFAULT_MODE, creatorKind=dagger.Component.Factory_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testEmptyCreator_compilerMode=DEFAULT_MODE, creatorKind=dagger.Component.Factory_test.DaggerSimpleComponent index 3e078be16..10bc3656c 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testEmptyCreator_compilerMode=DEFAULT_MODE, creatorKind=dagger.Component.Factory_test.DaggerSimpleComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testEmptyCreator_compilerMode=DEFAULT_MODE, creatorKind=dagger.Component.Factory_test.DaggerSimpleComponent @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerSimpleComponent { private DaggerSimpleComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testEmptyCreator_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Component.Builder_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testEmptyCreator_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Component.Builder_test.DaggerSimpleComponent index b117ad872..5040a7824 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testEmptyCreator_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Component.Builder_test.DaggerSimpleComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testEmptyCreator_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Component.Builder_test.DaggerSimpleComponent @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerSimpleComponent { private DaggerSimpleComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testEmptyCreator_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Component.Factory_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testEmptyCreator_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Component.Factory_test.DaggerSimpleComponent index 3e078be16..10bc3656c 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testEmptyCreator_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Component.Factory_test.DaggerSimpleComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentCreatorTest_testEmptyCreator_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Component.Factory_test.DaggerSimpleComponent @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerSimpleComponent { private DaggerSimpleComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentFactoryTest_testUsesParameterNames_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentFactoryTest_testUsesParameterNames_DEFAULT_MODE_test.DaggerTestComponent index d91808344..ac6ba38c2 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentFactoryTest_testUsesParameterNames_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentFactoryTest_testUsesParameterNames_DEFAULT_MODE_test.DaggerTestComponent @@ -13,7 +13,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentFactoryTest_testUsesParameterNames_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentFactoryTest_testUsesParameterNames_FAST_INIT_MODE_test.DaggerTestComponent index d91808344..ac6ba38c2 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentFactoryTest_testUsesParameterNames_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentFactoryTest_testUsesParameterNames_FAST_INIT_MODE_test.DaggerTestComponent @@ -13,7 +13,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_arrayComponentDependency_DEFAULT_MODE_test.DaggerBComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_arrayComponentDependency_DEFAULT_MODE_test.DaggerBComponent index a3127fbf0..dc3a6e78e 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_arrayComponentDependency_DEFAULT_MODE_test.DaggerBComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_arrayComponentDependency_DEFAULT_MODE_test.DaggerBComponent @@ -2,8 +2,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.Preconditions; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -14,7 +14,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerBComponent { private DaggerBComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_arrayComponentDependency_FAST_INIT_MODE_test.DaggerBComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_arrayComponentDependency_FAST_INIT_MODE_test.DaggerBComponent index bb09e8b6e..87aba7d21 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_arrayComponentDependency_FAST_INIT_MODE_test.DaggerBComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_arrayComponentDependency_FAST_INIT_MODE_test.DaggerBComponent @@ -2,8 +2,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.Preconditions; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -14,7 +14,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerBComponent { private DaggerBComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentDependency_DEFAULT_MODE_test.DaggerBComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentDependency_DEFAULT_MODE_test.DaggerBComponent index eb9476a7b..0626b32cd 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentDependency_DEFAULT_MODE_test.DaggerBComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentDependency_DEFAULT_MODE_test.DaggerBComponent @@ -2,8 +2,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.Preconditions; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -14,7 +14,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerBComponent { private DaggerBComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentDependency_FAST_INIT_MODE_test.DaggerBComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentDependency_FAST_INIT_MODE_test.DaggerBComponent index 7a97ba515..26b5f28dc 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentDependency_FAST_INIT_MODE_test.DaggerBComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentDependency_FAST_INIT_MODE_test.DaggerBComponent @@ -2,8 +2,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.Preconditions; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -14,7 +14,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerBComponent { private DaggerBComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentInjection_DEFAULT_MODE_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentInjection_DEFAULT_MODE_test.DaggerSimpleComponent index e32f689d6..66af8f585 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentInjection_DEFAULT_MODE_test.DaggerSimpleComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentInjection_DEFAULT_MODE_test.DaggerSimpleComponent @@ -2,8 +2,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.InstanceFactory; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -14,7 +14,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerSimpleComponent { private DaggerSimpleComponent() { @@ -59,7 +60,7 @@ final class DaggerSimpleComponent { } @Override - public Provider<SimpleComponent> selfProvider() { + public javax.inject.Provider<SimpleComponent> selfProvider() { return simpleComponentProvider; } } diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentInjection_FAST_INIT_MODE_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentInjection_FAST_INIT_MODE_test.DaggerSimpleComponent index 4f9289e45..4ce6af3aa 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentInjection_FAST_INIT_MODE_test.DaggerSimpleComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentInjection_FAST_INIT_MODE_test.DaggerSimpleComponent @@ -2,8 +2,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.InstanceFactory; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -14,7 +14,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerSimpleComponent { private DaggerSimpleComponent() { @@ -59,7 +60,7 @@ final class DaggerSimpleComponent { } @Override - public Provider<SimpleComponent> selfProvider() { + public javax.inject.Provider<SimpleComponent> selfProvider() { return simpleComponentProvider; } } diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentMethodInChildCallsComponentMethodInParent_DEFAULT_MODE_test.DaggerParent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentMethodInChildCallsComponentMethodInParent_DEFAULT_MODE_test.DaggerParent index 1d5bc09cb..2f1124bd2 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentMethodInChildCallsComponentMethodInParent_DEFAULT_MODE_test.DaggerParent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentMethodInChildCallsComponentMethodInParent_DEFAULT_MODE_test.DaggerParent @@ -2,8 +2,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -14,7 +14,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerParent { private DaggerParent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentMethodInChildCallsComponentMethodInParent_FAST_INIT_MODE_test.DaggerParent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentMethodInChildCallsComponentMethodInParent_FAST_INIT_MODE_test.DaggerParent index af0cdb92e..7d9a5d3c9 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentMethodInChildCallsComponentMethodInParent_FAST_INIT_MODE_test.DaggerParent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentMethodInChildCallsComponentMethodInParent_FAST_INIT_MODE_test.DaggerParent @@ -2,8 +2,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -14,7 +14,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerParent { private DaggerParent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentWithAbstractModule_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentWithAbstractModule_DEFAULT_MODE_test.DaggerTestComponent index 8726e7218..03fcd70cf 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentWithAbstractModule_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentWithAbstractModule_DEFAULT_MODE_test.DaggerTestComponent @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentWithAbstractModule_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentWithAbstractModule_FAST_INIT_MODE_test.DaggerTestComponent index 8726e7218..03fcd70cf 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentWithAbstractModule_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentWithAbstractModule_FAST_INIT_MODE_test.DaggerTestComponent @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentWithModule_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentWithModule_DEFAULT_MODE_test.DaggerTestComponent index fddeb7c1c..8d8ddad62 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentWithModule_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentWithModule_DEFAULT_MODE_test.DaggerTestComponent @@ -13,7 +13,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentWithModule_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentWithModule_FAST_INIT_MODE_test.DaggerTestComponent index fddeb7c1c..8d8ddad62 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentWithModule_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentWithModule_FAST_INIT_MODE_test.DaggerTestComponent @@ -13,7 +13,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentWithScope_DEFAULT_MODE_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentWithScope_DEFAULT_MODE_test.DaggerSimpleComponent index 76f413869..b79b07de8 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentWithScope_DEFAULT_MODE_test.DaggerSimpleComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentWithScope_DEFAULT_MODE_test.DaggerSimpleComponent @@ -3,8 +3,8 @@ package test; import dagger.Lazy; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -15,7 +15,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerSimpleComponent { private DaggerSimpleComponent() { @@ -65,7 +66,7 @@ final class DaggerSimpleComponent { } @Override - public Provider<SomeInjectableType> someInjectableTypeProvider() { + public javax.inject.Provider<SomeInjectableType> someInjectableTypeProvider() { return someInjectableTypeProvider; } } diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentWithScope_FAST_INIT_MODE_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentWithScope_FAST_INIT_MODE_test.DaggerSimpleComponent index 20d695da5..e89783cc9 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentWithScope_FAST_INIT_MODE_test.DaggerSimpleComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_componentWithScope_FAST_INIT_MODE_test.DaggerSimpleComponent @@ -3,8 +3,8 @@ package test; import dagger.Lazy; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -15,7 +15,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerSimpleComponent { private DaggerSimpleComponent() { @@ -65,7 +66,7 @@ final class DaggerSimpleComponent { } @Override - public Provider<SomeInjectableType> someInjectableTypeProvider() { + public javax.inject.Provider<SomeInjectableType> someInjectableTypeProvider() { return someInjectableTypeProvider; } diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_dependencyNameCollision_DEFAULT_MODE_test.DaggerBComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_dependencyNameCollision_DEFAULT_MODE_test.DaggerBComponent index b8284979d..a2d1d8595 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_dependencyNameCollision_DEFAULT_MODE_test.DaggerBComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_dependencyNameCollision_DEFAULT_MODE_test.DaggerBComponent @@ -2,8 +2,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.Preconditions; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; import pkg1.A; import pkg1.AComponent; @@ -16,7 +16,8 @@ import pkg1.AComponent; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerBComponent { private DaggerBComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_dependencyNameCollision_FAST_INIT_MODE_test.DaggerBComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_dependencyNameCollision_FAST_INIT_MODE_test.DaggerBComponent index 99a7e4271..42a0386cb 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_dependencyNameCollision_FAST_INIT_MODE_test.DaggerBComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_dependencyNameCollision_FAST_INIT_MODE_test.DaggerBComponent @@ -2,8 +2,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.Preconditions; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; import pkg1.A; import pkg1.AComponent; @@ -16,7 +16,8 @@ import pkg1.AComponent; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerBComponent { private DaggerBComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_ignoresDependencyMethodsFromObject_DEFAULT_MODE_test.DaggerBComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_ignoresDependencyMethodsFromObject_DEFAULT_MODE_test.DaggerBComponent index 0373c5369..b284dbdbf 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_ignoresDependencyMethodsFromObject_DEFAULT_MODE_test.DaggerBComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_ignoresDependencyMethodsFromObject_DEFAULT_MODE_test.DaggerBComponent @@ -13,7 +13,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerBComponent { private DaggerBComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_ignoresDependencyMethodsFromObject_FAST_INIT_MODE_test.DaggerBComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_ignoresDependencyMethodsFromObject_FAST_INIT_MODE_test.DaggerBComponent index 0373c5369..b284dbdbf 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_ignoresDependencyMethodsFromObject_FAST_INIT_MODE_test.DaggerBComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_ignoresDependencyMethodsFromObject_FAST_INIT_MODE_test.DaggerBComponent @@ -13,7 +13,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerBComponent { private DaggerBComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_justInTimeAtInjectConstructor_hasGeneratedQualifier_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_justInTimeAtInjectConstructor_hasGeneratedQualifier_DEFAULT_MODE_test.DaggerTestComponent index 264aeb32e..898e8772a 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_justInTimeAtInjectConstructor_hasGeneratedQualifier_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_justInTimeAtInjectConstructor_hasGeneratedQualifier_DEFAULT_MODE_test.DaggerTestComponent @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_justInTimeAtInjectConstructor_hasGeneratedQualifier_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_justInTimeAtInjectConstructor_hasGeneratedQualifier_FAST_INIT_MODE_test.DaggerTestComponent index 264aeb32e..898e8772a 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_justInTimeAtInjectConstructor_hasGeneratedQualifier_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_justInTimeAtInjectConstructor_hasGeneratedQualifier_FAST_INIT_MODE_test.DaggerTestComponent @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_membersInjection_DEFAULT_MODE_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_membersInjection_DEFAULT_MODE_test.DaggerSimpleComponent index e4330ef54..d991e42c0 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_membersInjection_DEFAULT_MODE_test.DaggerSimpleComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_membersInjection_DEFAULT_MODE_test.DaggerSimpleComponent @@ -13,7 +13,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerSimpleComponent { private DaggerSimpleComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_membersInjection_FAST_INIT_MODE_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_membersInjection_FAST_INIT_MODE_test.DaggerSimpleComponent index e4330ef54..d991e42c0 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_membersInjection_FAST_INIT_MODE_test.DaggerSimpleComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_membersInjection_FAST_INIT_MODE_test.DaggerSimpleComponent @@ -13,7 +13,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerSimpleComponent { private DaggerSimpleComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_moduleHasGeneratedQualifier_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_moduleHasGeneratedQualifier_DEFAULT_MODE_test.DaggerTestComponent index f7515ed3a..dd932010a 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_moduleHasGeneratedQualifier_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_moduleHasGeneratedQualifier_DEFAULT_MODE_test.DaggerTestComponent @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_moduleHasGeneratedQualifier_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_moduleHasGeneratedQualifier_FAST_INIT_MODE_test.DaggerTestComponent index f7515ed3a..dd932010a 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_moduleHasGeneratedQualifier_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_moduleHasGeneratedQualifier_FAST_INIT_MODE_test.DaggerTestComponent @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_moduleNameCollision_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_moduleNameCollision_DEFAULT_MODE_test.DaggerTestComponent index 137e599c5..872646f4a 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_moduleNameCollision_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_moduleNameCollision_DEFAULT_MODE_test.DaggerTestComponent @@ -13,7 +13,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_moduleNameCollision_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_moduleNameCollision_FAST_INIT_MODE_test.DaggerTestComponent index 137e599c5..872646f4a 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_moduleNameCollision_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_moduleNameCollision_FAST_INIT_MODE_test.DaggerTestComponent @@ -13,7 +13,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_nullCheckingIgnoredWhenProviderReturnsPrimitive_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_nullCheckingIgnoredWhenProviderReturnsPrimitive_DEFAULT_MODE_test.DaggerTestComponent index 0aaa8d869..b9a27ebd0 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_nullCheckingIgnoredWhenProviderReturnsPrimitive_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_nullCheckingIgnoredWhenProviderReturnsPrimitive_DEFAULT_MODE_test.DaggerTestComponent @@ -13,7 +13,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_nullCheckingIgnoredWhenProviderReturnsPrimitive_DEFAULT_MODE_test.TestModule_PrimitiveIntegerFactory b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_nullCheckingIgnoredWhenProviderReturnsPrimitive_DEFAULT_MODE_test.TestModule_PrimitiveIntegerFactory index 4b0e55769..4caa6e1ac 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_nullCheckingIgnoredWhenProviderReturnsPrimitive_DEFAULT_MODE_test.TestModule_PrimitiveIntegerFactory +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_nullCheckingIgnoredWhenProviderReturnsPrimitive_DEFAULT_MODE_test.TestModule_PrimitiveIntegerFactory @@ -17,7 +17,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class TestModule_PrimitiveIntegerFactory implements Factory<Integer> { @Override diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_nullCheckingIgnoredWhenProviderReturnsPrimitive_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_nullCheckingIgnoredWhenProviderReturnsPrimitive_FAST_INIT_MODE_test.DaggerTestComponent index 0aaa8d869..b9a27ebd0 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_nullCheckingIgnoredWhenProviderReturnsPrimitive_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_nullCheckingIgnoredWhenProviderReturnsPrimitive_FAST_INIT_MODE_test.DaggerTestComponent @@ -13,7 +13,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_nullCheckingIgnoredWhenProviderReturnsPrimitive_FAST_INIT_MODE_test.TestModule_PrimitiveIntegerFactory b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_nullCheckingIgnoredWhenProviderReturnsPrimitive_FAST_INIT_MODE_test.TestModule_PrimitiveIntegerFactory index 4b0e55769..4caa6e1ac 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_nullCheckingIgnoredWhenProviderReturnsPrimitive_FAST_INIT_MODE_test.TestModule_PrimitiveIntegerFactory +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_nullCheckingIgnoredWhenProviderReturnsPrimitive_FAST_INIT_MODE_test.TestModule_PrimitiveIntegerFactory @@ -17,7 +17,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class TestModule_PrimitiveIntegerFactory implements Factory<Integer> { @Override diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_nullIncorrectlyReturnedFromNonNullableInlinedProvider_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_nullIncorrectlyReturnedFromNonNullableInlinedProvider_DEFAULT_MODE_test.DaggerTestComponent index 17727c090..54425a70b 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_nullIncorrectlyReturnedFromNonNullableInlinedProvider_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_nullIncorrectlyReturnedFromNonNullableInlinedProvider_DEFAULT_MODE_test.DaggerTestComponent @@ -13,7 +13,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_nullIncorrectlyReturnedFromNonNullableInlinedProvider_DEFAULT_MODE_test.TestModule_NonNullableStringFactory b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_nullIncorrectlyReturnedFromNonNullableInlinedProvider_DEFAULT_MODE_test.TestModule_NonNullableStringFactory index a19af9696..96e870822 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_nullIncorrectlyReturnedFromNonNullableInlinedProvider_DEFAULT_MODE_test.TestModule_NonNullableStringFactory +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_nullIncorrectlyReturnedFromNonNullableInlinedProvider_DEFAULT_MODE_test.TestModule_NonNullableStringFactory @@ -18,7 +18,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class TestModule_NonNullableStringFactory implements Factory<String> { @Override diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_nullIncorrectlyReturnedFromNonNullableInlinedProvider_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_nullIncorrectlyReturnedFromNonNullableInlinedProvider_FAST_INIT_MODE_test.DaggerTestComponent index 17727c090..54425a70b 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_nullIncorrectlyReturnedFromNonNullableInlinedProvider_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_nullIncorrectlyReturnedFromNonNullableInlinedProvider_FAST_INIT_MODE_test.DaggerTestComponent @@ -13,7 +13,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_nullIncorrectlyReturnedFromNonNullableInlinedProvider_FAST_INIT_MODE_test.TestModule_NonNullableStringFactory b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_nullIncorrectlyReturnedFromNonNullableInlinedProvider_FAST_INIT_MODE_test.TestModule_NonNullableStringFactory index a19af9696..96e870822 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_nullIncorrectlyReturnedFromNonNullableInlinedProvider_FAST_INIT_MODE_test.TestModule_NonNullableStringFactory +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_nullIncorrectlyReturnedFromNonNullableInlinedProvider_FAST_INIT_MODE_test.TestModule_NonNullableStringFactory @@ -18,7 +18,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class TestModule_NonNullableStringFactory implements Factory<String> { @Override diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_primitiveComponentDependency_DEFAULT_MODE_test.DaggerBComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_primitiveComponentDependency_DEFAULT_MODE_test.DaggerBComponent index 755b402f9..c1a2108c7 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_primitiveComponentDependency_DEFAULT_MODE_test.DaggerBComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_primitiveComponentDependency_DEFAULT_MODE_test.DaggerBComponent @@ -2,8 +2,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.Preconditions; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -14,7 +14,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerBComponent { private DaggerBComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_primitiveComponentDependency_FAST_INIT_MODE_test.DaggerBComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_primitiveComponentDependency_FAST_INIT_MODE_test.DaggerBComponent index 6ce1e2451..d88c74ec3 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_primitiveComponentDependency_FAST_INIT_MODE_test.DaggerBComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_primitiveComponentDependency_FAST_INIT_MODE_test.DaggerBComponent @@ -2,8 +2,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.Preconditions; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -14,7 +14,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerBComponent { private DaggerBComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_privateMethodUsedOnlyInChildDoesNotUseQualifiedThis_DEFAULT_MODE_test.DaggerParent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_privateMethodUsedOnlyInChildDoesNotUseQualifiedThis_DEFAULT_MODE_test.DaggerParent index f26d8a5bb..73f067ba2 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_privateMethodUsedOnlyInChildDoesNotUseQualifiedThis_DEFAULT_MODE_test.DaggerParent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_privateMethodUsedOnlyInChildDoesNotUseQualifiedThis_DEFAULT_MODE_test.DaggerParent @@ -2,8 +2,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -14,7 +14,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerParent { private DaggerParent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_privateMethodUsedOnlyInChildDoesNotUseQualifiedThis_FAST_INIT_MODE_test.DaggerParent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_privateMethodUsedOnlyInChildDoesNotUseQualifiedThis_FAST_INIT_MODE_test.DaggerParent index 5edc873ff..c20b8f062 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_privateMethodUsedOnlyInChildDoesNotUseQualifiedThis_FAST_INIT_MODE_test.DaggerParent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_privateMethodUsedOnlyInChildDoesNotUseQualifiedThis_FAST_INIT_MODE_test.DaggerParent @@ -2,8 +2,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -14,7 +14,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerParent { private DaggerParent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_providerComponentType_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_providerComponentType_DEFAULT_MODE_test.DaggerTestComponent index 19c4c90bf..5558c81a8 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_providerComponentType_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_providerComponentType_DEFAULT_MODE_test.DaggerTestComponent @@ -1,8 +1,8 @@ package test; import dagger.internal.DaggerGenerated; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -13,7 +13,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_providerComponentType_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_providerComponentType_FAST_INIT_MODE_test.DaggerTestComponent index 0af158555..e19505d67 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_providerComponentType_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_providerComponentType_FAST_INIT_MODE_test.DaggerTestComponent @@ -1,8 +1,8 @@ package test; import dagger.internal.DaggerGenerated; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -13,7 +13,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_publicComponentType_DEFAULT_MODE_test.DaggerPublicComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_publicComponentType_DEFAULT_MODE_test.DaggerPublicComponent index 71341f026..48c0f34a9 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_publicComponentType_DEFAULT_MODE_test.DaggerPublicComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_publicComponentType_DEFAULT_MODE_test.DaggerPublicComponent @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class DaggerPublicComponent { private DaggerPublicComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_publicComponentType_FAST_INIT_MODE_test.DaggerPublicComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_publicComponentType_FAST_INIT_MODE_test.DaggerPublicComponent index 71341f026..48c0f34a9 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_publicComponentType_FAST_INIT_MODE_test.DaggerPublicComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_publicComponentType_FAST_INIT_MODE_test.DaggerPublicComponent @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class DaggerPublicComponent { private DaggerPublicComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_resolutionOrder_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_resolutionOrder_DEFAULT_MODE_test.DaggerTestComponent index 6841e9363..22771bbf0 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_resolutionOrder_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_resolutionOrder_DEFAULT_MODE_test.DaggerTestComponent @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_resolutionOrder_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_resolutionOrder_FAST_INIT_MODE_test.DaggerTestComponent index 6841e9363..22771bbf0 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_resolutionOrder_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_resolutionOrder_FAST_INIT_MODE_test.DaggerTestComponent @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_simpleComponentWithNesting_DEFAULT_MODE_test.DaggerOuterType_SimpleComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_simpleComponentWithNesting_DEFAULT_MODE_test.DaggerOuterType_SimpleComponent index 37ea93066..1a79810f8 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_simpleComponentWithNesting_DEFAULT_MODE_test.DaggerOuterType_SimpleComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_simpleComponentWithNesting_DEFAULT_MODE_test.DaggerOuterType_SimpleComponent @@ -13,7 +13,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerOuterType_SimpleComponent { private DaggerOuterType_SimpleComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_simpleComponentWithNesting_FAST_INIT_MODE_test.DaggerOuterType_SimpleComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_simpleComponentWithNesting_FAST_INIT_MODE_test.DaggerOuterType_SimpleComponent index 37ea93066..1a79810f8 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_simpleComponentWithNesting_FAST_INIT_MODE_test.DaggerOuterType_SimpleComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_simpleComponentWithNesting_FAST_INIT_MODE_test.DaggerOuterType_SimpleComponent @@ -13,7 +13,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerOuterType_SimpleComponent { private DaggerOuterType_SimpleComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_simpleComponent_DEFAULT_MODE_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_simpleComponent_DEFAULT_MODE_test.DaggerSimpleComponent index 9e46639a8..e1e3f6442 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_simpleComponent_DEFAULT_MODE_test.DaggerSimpleComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_simpleComponent_DEFAULT_MODE_test.DaggerSimpleComponent @@ -15,7 +15,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerSimpleComponent { private DaggerSimpleComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_simpleComponent_FAST_INIT_MODE_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_simpleComponent_FAST_INIT_MODE_test.DaggerSimpleComponent index d92a70e85..094c1ff24 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_simpleComponent_FAST_INIT_MODE_test.DaggerSimpleComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_simpleComponent_FAST_INIT_MODE_test.DaggerSimpleComponent @@ -3,8 +3,8 @@ package test; import dagger.Lazy; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -15,7 +15,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerSimpleComponent { private DaggerSimpleComponent() { @@ -65,7 +66,7 @@ final class DaggerSimpleComponent { } @Override - public Provider<SomeInjectableType> someInjectableTypeProvider() { + public javax.inject.Provider<SomeInjectableType> someInjectableTypeProvider() { return someInjectableTypeProvider; } diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_simpleComponent_inheritedComponentMethodDep_DEFAULT_MODE_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_simpleComponent_inheritedComponentMethodDep_DEFAULT_MODE_test.DaggerSimpleComponent index 630073e96..108b13d68 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_simpleComponent_inheritedComponentMethodDep_DEFAULT_MODE_test.DaggerSimpleComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_simpleComponent_inheritedComponentMethodDep_DEFAULT_MODE_test.DaggerSimpleComponent @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerSimpleComponent { private DaggerSimpleComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_simpleComponent_inheritedComponentMethodDep_FAST_INIT_MODE_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_simpleComponent_inheritedComponentMethodDep_FAST_INIT_MODE_test.DaggerSimpleComponent index 630073e96..108b13d68 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_simpleComponent_inheritedComponentMethodDep_FAST_INIT_MODE_test.DaggerSimpleComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_simpleComponent_inheritedComponentMethodDep_FAST_INIT_MODE_test.DaggerSimpleComponent @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerSimpleComponent { private DaggerSimpleComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_simpleComponent_redundantComponentMethod_DEFAULT_MODE_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_simpleComponent_redundantComponentMethod_DEFAULT_MODE_test.DaggerSimpleComponent index 630073e96..108b13d68 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_simpleComponent_redundantComponentMethod_DEFAULT_MODE_test.DaggerSimpleComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_simpleComponent_redundantComponentMethod_DEFAULT_MODE_test.DaggerSimpleComponent @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerSimpleComponent { private DaggerSimpleComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_simpleComponent_redundantComponentMethod_FAST_INIT_MODE_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_simpleComponent_redundantComponentMethod_FAST_INIT_MODE_test.DaggerSimpleComponent index 630073e96..108b13d68 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_simpleComponent_redundantComponentMethod_FAST_INIT_MODE_test.DaggerSimpleComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_simpleComponent_redundantComponentMethod_FAST_INIT_MODE_test.DaggerSimpleComponent @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerSimpleComponent { private DaggerSimpleComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_subcomponentNotGeneratedIfNotUsedInGraph_DEFAULT_MODE_test.DaggerParent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_subcomponentNotGeneratedIfNotUsedInGraph_DEFAULT_MODE_test.DaggerParent index 9447a4730..c630533eb 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_subcomponentNotGeneratedIfNotUsedInGraph_DEFAULT_MODE_test.DaggerParent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_subcomponentNotGeneratedIfNotUsedInGraph_DEFAULT_MODE_test.DaggerParent @@ -1,7 +1,6 @@ package test; import dagger.internal.DaggerGenerated; -import dagger.internal.Preconditions; import javax.annotation.processing.Generated; @DaggerGenerated @@ -13,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerParent { private DaggerParent() { @@ -31,15 +31,6 @@ final class DaggerParent { private Builder() { } - /** - * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://dagger.dev/unused-modules. - */ - @Deprecated - public Builder parentModule(ParentModule parentModule) { - Preconditions.checkNotNull(parentModule); - return this; - } - public Parent build() { return new ParentImpl(); } diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_subcomponentNotGeneratedIfNotUsedInGraph_FAST_INIT_MODE_test.DaggerParent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_subcomponentNotGeneratedIfNotUsedInGraph_FAST_INIT_MODE_test.DaggerParent index 9447a4730..c630533eb 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_subcomponentNotGeneratedIfNotUsedInGraph_FAST_INIT_MODE_test.DaggerParent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_subcomponentNotGeneratedIfNotUsedInGraph_FAST_INIT_MODE_test.DaggerParent @@ -1,7 +1,6 @@ package test; import dagger.internal.DaggerGenerated; -import dagger.internal.Preconditions; import javax.annotation.processing.Generated; @DaggerGenerated @@ -13,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerParent { private DaggerParent() { @@ -31,15 +31,6 @@ final class DaggerParent { private Builder() { } - /** - * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://dagger.dev/unused-modules. - */ - @Deprecated - public Builder parentModule(ParentModule parentModule) { - Preconditions.checkNotNull(parentModule); - return this; - } - public Parent build() { return new ParentImpl(); } diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_transitiveModuleDeps_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_transitiveModuleDeps_DEFAULT_MODE_test.DaggerTestComponent index ec93b6ca0..7b077e72b 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_transitiveModuleDeps_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_transitiveModuleDeps_DEFAULT_MODE_test.DaggerTestComponent @@ -1,7 +1,6 @@ package test; import dagger.internal.DaggerGenerated; -import dagger.internal.Preconditions; import javax.annotation.processing.Generated; @DaggerGenerated @@ -13,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -31,60 +31,6 @@ final class DaggerTestComponent { private Builder() { } - /** - * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://dagger.dev/unused-modules. - */ - @Deprecated - public Builder testModule(TestModule testModule) { - Preconditions.checkNotNull(testModule); - return this; - } - - /** - * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://dagger.dev/unused-modules. - */ - @Deprecated - public Builder parentTestIncluded(ParentTestIncluded parentTestIncluded) { - Preconditions.checkNotNull(parentTestIncluded); - return this; - } - - /** - * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://dagger.dev/unused-modules. - */ - @Deprecated - public Builder alwaysIncluded(AlwaysIncluded alwaysIncluded) { - Preconditions.checkNotNull(alwaysIncluded); - return this; - } - - /** - * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://dagger.dev/unused-modules. - */ - @Deprecated - public Builder depModule(DepModule depModule) { - Preconditions.checkNotNull(depModule); - return this; - } - - /** - * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://dagger.dev/unused-modules. - */ - @Deprecated - public Builder parentDepIncluded(ParentDepIncluded parentDepIncluded) { - Preconditions.checkNotNull(parentDepIncluded); - return this; - } - - /** - * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://dagger.dev/unused-modules. - */ - @Deprecated - public Builder refByDep(RefByDep refByDep) { - Preconditions.checkNotNull(refByDep); - return this; - } - public TestComponent build() { return new TestComponentImpl(); } diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_transitiveModuleDeps_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_transitiveModuleDeps_FAST_INIT_MODE_test.DaggerTestComponent index ec93b6ca0..7b077e72b 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_transitiveModuleDeps_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_transitiveModuleDeps_FAST_INIT_MODE_test.DaggerTestComponent @@ -1,7 +1,6 @@ package test; import dagger.internal.DaggerGenerated; -import dagger.internal.Preconditions; import javax.annotation.processing.Generated; @DaggerGenerated @@ -13,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -31,60 +31,6 @@ final class DaggerTestComponent { private Builder() { } - /** - * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://dagger.dev/unused-modules. - */ - @Deprecated - public Builder testModule(TestModule testModule) { - Preconditions.checkNotNull(testModule); - return this; - } - - /** - * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://dagger.dev/unused-modules. - */ - @Deprecated - public Builder parentTestIncluded(ParentTestIncluded parentTestIncluded) { - Preconditions.checkNotNull(parentTestIncluded); - return this; - } - - /** - * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://dagger.dev/unused-modules. - */ - @Deprecated - public Builder alwaysIncluded(AlwaysIncluded alwaysIncluded) { - Preconditions.checkNotNull(alwaysIncluded); - return this; - } - - /** - * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://dagger.dev/unused-modules. - */ - @Deprecated - public Builder depModule(DepModule depModule) { - Preconditions.checkNotNull(depModule); - return this; - } - - /** - * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://dagger.dev/unused-modules. - */ - @Deprecated - public Builder parentDepIncluded(ParentDepIncluded parentDepIncluded) { - Preconditions.checkNotNull(parentDepIncluded); - return this; - } - - /** - * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://dagger.dev/unused-modules. - */ - @Deprecated - public Builder refByDep(RefByDep refByDep) { - Preconditions.checkNotNull(refByDep); - return this; - } - public TestComponent build() { return new TestComponentImpl(); } diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_unusedSubcomponents_dontResolveExtraBindingsInParentComponents_DEFAULT_MODE_test.DaggerParent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_unusedSubcomponents_dontResolveExtraBindingsInParentComponents_DEFAULT_MODE_test.DaggerParent index 89764b99a..9fcf3dcaf 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_unusedSubcomponents_dontResolveExtraBindingsInParentComponents_DEFAULT_MODE_test.DaggerParent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_unusedSubcomponents_dontResolveExtraBindingsInParentComponents_DEFAULT_MODE_test.DaggerParent @@ -1,7 +1,6 @@ package test; import dagger.internal.DaggerGenerated; -import dagger.internal.Preconditions; import javax.annotation.processing.Generated; @DaggerGenerated @@ -13,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerParent { private DaggerParent() { @@ -31,15 +31,6 @@ final class DaggerParent { private Builder() { } - /** - * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://dagger.dev/unused-modules. - */ - @Deprecated - public Builder testModule(TestModule testModule) { - Preconditions.checkNotNull(testModule); - return this; - } - public Parent build() { return new ParentImpl(); } diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_unusedSubcomponents_dontResolveExtraBindingsInParentComponents_FAST_INIT_MODE_test.DaggerParent b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_unusedSubcomponents_dontResolveExtraBindingsInParentComponents_FAST_INIT_MODE_test.DaggerParent index 89764b99a..9fcf3dcaf 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_unusedSubcomponents_dontResolveExtraBindingsInParentComponents_FAST_INIT_MODE_test.DaggerParent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProcessorTest_unusedSubcomponents_dontResolveExtraBindingsInParentComponents_FAST_INIT_MODE_test.DaggerParent @@ -1,7 +1,6 @@ package test; import dagger.internal.DaggerGenerated; -import dagger.internal.Preconditions; import javax.annotation.processing.Generated; @DaggerGenerated @@ -13,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerParent { private DaggerParent() { @@ -31,15 +31,6 @@ final class DaggerParent { private Builder() { } - /** - * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://dagger.dev/unused-modules. - */ - @Deprecated - public Builder testModule(TestModule testModule) { - Preconditions.checkNotNull(testModule); - return this; - } - public Parent build() { return new ParentImpl(); } diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProtectedTypeTest_componentAccessesProtectedType_succeeds_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentProtectedTypeTest_componentAccessesProtectedType_succeeds_DEFAULT_MODE_test.DaggerTestComponent index 98c9ea783..a03654654 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProtectedTypeTest_componentAccessesProtectedType_succeeds_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProtectedTypeTest_componentAccessesProtectedType_succeeds_DEFAULT_MODE_test.DaggerTestComponent @@ -2,8 +2,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; import test.sub.TestComponentBase_Dep_Factory; import test.sub.TestComponentBase_ProtectedType_Factory; @@ -16,7 +16,8 @@ import test.sub.TestComponentBase_ProtectedType_Factory; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentProtectedTypeTest_componentAccessesProtectedType_succeeds_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentProtectedTypeTest_componentAccessesProtectedType_succeeds_FAST_INIT_MODE_test.DaggerTestComponent index 441b713d4..7defcfc8a 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentProtectedTypeTest_componentAccessesProtectedType_succeeds_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentProtectedTypeTest_componentAccessesProtectedType_succeeds_FAST_INIT_MODE_test.DaggerTestComponent @@ -2,8 +2,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; import test.sub.TestComponentBase_Dep_Factory; import test.sub.TestComponentBase_ProtectedType_Factory; @@ -16,7 +16,8 @@ import test.sub.TestComponentBase_ProtectedType_Factory; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_bindsInstance_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_bindsInstance_DEFAULT_MODE_test.DaggerTestComponent index 0999a8b5e..bbe89b976 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_bindsInstance_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_bindsInstance_DEFAULT_MODE_test.DaggerTestComponent @@ -14,7 +14,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_bindsInstance_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_bindsInstance_FAST_INIT_MODE_test.DaggerTestComponent index 0999a8b5e..bbe89b976 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_bindsInstance_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_bindsInstance_FAST_INIT_MODE_test.DaggerTestComponent @@ -14,7 +14,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_componentInstances_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_componentInstances_DEFAULT_MODE_test.DaggerTestComponent index 7f50d88a8..98ba4b605 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_componentInstances_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_componentInstances_DEFAULT_MODE_test.DaggerTestComponent @@ -13,7 +13,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_componentInstances_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_componentInstances_FAST_INIT_MODE_test.DaggerTestComponent index 7f50d88a8..98ba4b605 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_componentInstances_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_componentInstances_FAST_INIT_MODE_test.DaggerTestComponent @@ -13,7 +13,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_componentRequirementNeededInFactoryCreationOfSubcomponent_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_componentRequirementNeededInFactoryCreationOfSubcomponent_DEFAULT_MODE_test.DaggerTestComponent index 78ff25e66..9b3981664 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_componentRequirementNeededInFactoryCreationOfSubcomponent_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_componentRequirementNeededInFactoryCreationOfSubcomponent_DEFAULT_MODE_test.DaggerTestComponent @@ -2,10 +2,10 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.Preconditions; +import dagger.internal.Provider; import dagger.internal.SetFactory; import java.util.Set; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -16,7 +16,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -72,7 +73,7 @@ final class DaggerTestComponent { } @Override - public Provider<Object> dependsOnMultibinding() { + public javax.inject.Provider<Object> dependsOnMultibinding() { return reliesOnMultibindingProvider; } } @@ -99,7 +100,7 @@ final class DaggerTestComponent { } @Override - public Provider<Object> dependsOnMultibinding() { + public javax.inject.Provider<Object> dependsOnMultibinding() { return reliesOnMultibindingProvider; } diff --git a/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_componentRequirementNeededInFactoryCreationOfSubcomponent_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_componentRequirementNeededInFactoryCreationOfSubcomponent_FAST_INIT_MODE_test.DaggerTestComponent index 5eb16adf8..94ebb33ce 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_componentRequirementNeededInFactoryCreationOfSubcomponent_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_componentRequirementNeededInFactoryCreationOfSubcomponent_FAST_INIT_MODE_test.DaggerTestComponent @@ -3,9 +3,9 @@ package test; import com.google.common.collect.ImmutableSet; import dagger.internal.DaggerGenerated; import dagger.internal.Preconditions; +import dagger.internal.Provider; import java.util.Set; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -16,7 +16,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -73,7 +74,7 @@ final class DaggerTestComponent { } @Override - public Provider<Object> dependsOnMultibinding() { + public javax.inject.Provider<Object> dependsOnMultibinding() { return reliesOnMultibindingProvider; } @@ -127,7 +128,7 @@ final class DaggerTestComponent { } @Override - public Provider<Object> dependsOnMultibinding() { + public javax.inject.Provider<Object> dependsOnMultibinding() { return reliesOnMultibindingProvider; } diff --git a/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_instanceModuleMethod_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_instanceModuleMethod_DEFAULT_MODE_test.DaggerTestComponent index 36c3a11f2..99caa0746 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_instanceModuleMethod_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_instanceModuleMethod_DEFAULT_MODE_test.DaggerTestComponent @@ -15,7 +15,8 @@ import other.OtherPackageModule_LFactory; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_instanceModuleMethod_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_instanceModuleMethod_FAST_INIT_MODE_test.DaggerTestComponent index 36c3a11f2..99caa0746 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_instanceModuleMethod_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentRequirementFieldTest_instanceModuleMethod_FAST_INIT_MODE_test.DaggerTestComponent @@ -15,7 +15,8 @@ import other.OtherPackageModule_LFactory; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardCreatedWithDependencies_DEFAULT_MODE_dagger.internal.codegen.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardCreatedWithDependencies_DEFAULT_MODE_dagger.internal.codegen.DaggerTestComponent index d5a2af096..a2c9032bc 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardCreatedWithDependencies_DEFAULT_MODE_dagger.internal.codegen.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardCreatedWithDependencies_DEFAULT_MODE_dagger.internal.codegen.DaggerTestComponent @@ -3,8 +3,8 @@ package dagger.internal.codegen; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; import dagger.internal.Preconditions; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -15,7 +15,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -81,17 +82,17 @@ final class DaggerTestComponent { } @Override - public Provider<Binding1> providerBinding1() { + public javax.inject.Provider<Binding1> providerBinding1() { return binding1Provider; } @Override - public Provider<Binding2> providerBinding2() { + public javax.inject.Provider<Binding2> providerBinding2() { return binding2Provider; } @Override - public Provider<Binding3> providerBinding3() { + public javax.inject.Provider<Binding3> providerBinding3() { return testComponentImpl.testComponentImplShard.binding3Provider; } diff --git a/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardCreatedWithDependencies_FAST_INIT_MODE_dagger.internal.codegen.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardCreatedWithDependencies_FAST_INIT_MODE_dagger.internal.codegen.DaggerTestComponent index e09bb44be..5d58c6e6c 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardCreatedWithDependencies_FAST_INIT_MODE_dagger.internal.codegen.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardCreatedWithDependencies_FAST_INIT_MODE_dagger.internal.codegen.DaggerTestComponent @@ -3,8 +3,8 @@ package dagger.internal.codegen; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; import dagger.internal.Preconditions; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -15,7 +15,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -81,17 +82,17 @@ final class DaggerTestComponent { } @Override - public Provider<Binding1> providerBinding1() { + public javax.inject.Provider<Binding1> providerBinding1() { return binding1Provider; } @Override - public Provider<Binding2> providerBinding2() { + public javax.inject.Provider<Binding2> providerBinding2() { return binding2Provider; } @Override - public Provider<Binding3> providerBinding3() { + public javax.inject.Provider<Binding3> providerBinding3() { return testComponentImpl.testComponentImplShard.binding3Provider; } diff --git a/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardCreated_DEFAULT_MODE_dagger.internal.codegen.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardCreated_DEFAULT_MODE_dagger.internal.codegen.DaggerTestComponent index de033d5dc..59a7cae85 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardCreated_DEFAULT_MODE_dagger.internal.codegen.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardCreated_DEFAULT_MODE_dagger.internal.codegen.DaggerTestComponent @@ -3,8 +3,8 @@ package dagger.internal.codegen; import dagger.internal.DaggerGenerated; import dagger.internal.DelegateFactory; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -15,7 +15,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -98,37 +99,37 @@ final class DaggerTestComponent { } @Override - public Provider<Binding1> providerBinding1() { + public javax.inject.Provider<Binding1> providerBinding1() { return testComponentImpl.testComponentImplShard2.binding1Provider; } @Override - public Provider<Binding2> providerBinding2() { + public javax.inject.Provider<Binding2> providerBinding2() { return testComponentImpl.testComponentImplShard.binding2Provider; } @Override - public Provider<Binding3> providerBinding3() { + public javax.inject.Provider<Binding3> providerBinding3() { return testComponentImpl.testComponentImplShard.binding3Provider; } @Override - public Provider<Binding4> providerBinding4() { + public javax.inject.Provider<Binding4> providerBinding4() { return testComponentImpl.testComponentImplShard.binding4Provider; } @Override - public Provider<Binding5> providerBinding5() { + public javax.inject.Provider<Binding5> providerBinding5() { return testComponentImpl.testComponentImplShard.binding5Provider; } @Override - public Provider<Binding6> providerBinding6() { + public javax.inject.Provider<Binding6> providerBinding6() { return binding6Provider; } @Override - public Provider<Binding7> providerBinding7() { + public javax.inject.Provider<Binding7> providerBinding7() { return binding7Provider; } } diff --git a/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardCreated_FAST_INIT_MODE_dagger.internal.codegen.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardCreated_FAST_INIT_MODE_dagger.internal.codegen.DaggerTestComponent index 81056e24f..9a84c8545 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardCreated_FAST_INIT_MODE_dagger.internal.codegen.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardCreated_FAST_INIT_MODE_dagger.internal.codegen.DaggerTestComponent @@ -3,8 +3,8 @@ package dagger.internal.codegen; import dagger.internal.DaggerGenerated; import dagger.internal.DelegateFactory; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -15,7 +15,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -98,37 +99,37 @@ final class DaggerTestComponent { } @Override - public Provider<Binding1> providerBinding1() { + public javax.inject.Provider<Binding1> providerBinding1() { return testComponentImpl.testComponentImplShard2.binding1Provider; } @Override - public Provider<Binding2> providerBinding2() { + public javax.inject.Provider<Binding2> providerBinding2() { return testComponentImpl.testComponentImplShard.binding2Provider; } @Override - public Provider<Binding3> providerBinding3() { + public javax.inject.Provider<Binding3> providerBinding3() { return testComponentImpl.testComponentImplShard.binding3Provider; } @Override - public Provider<Binding4> providerBinding4() { + public javax.inject.Provider<Binding4> providerBinding4() { return testComponentImpl.testComponentImplShard.binding4Provider; } @Override - public Provider<Binding5> providerBinding5() { + public javax.inject.Provider<Binding5> providerBinding5() { return testComponentImpl.testComponentImplShard.binding5Provider; } @Override - public Provider<Binding6> providerBinding6() { + public javax.inject.Provider<Binding6> providerBinding6() { return binding6Provider; } @Override - public Provider<Binding7> providerBinding7() { + public javax.inject.Provider<Binding7> providerBinding7() { return binding7Provider; } diff --git a/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardSubcomponentCreated_DEFAULT_MODE_dagger.internal.codegen.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardSubcomponentCreated_DEFAULT_MODE_dagger.internal.codegen.DaggerTestComponent index 86b5db46d..13f15e0b8 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardSubcomponentCreated_DEFAULT_MODE_dagger.internal.codegen.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardSubcomponentCreated_DEFAULT_MODE_dagger.internal.codegen.DaggerTestComponent @@ -2,8 +2,8 @@ package dagger.internal.codegen; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -14,7 +14,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -77,17 +78,17 @@ final class DaggerTestComponent { } @Override - public Provider<Binding1> providerBinding1() { + public javax.inject.Provider<Binding1> providerBinding1() { return binding1Provider; } @Override - public Provider<Binding2> providerBinding2() { + public javax.inject.Provider<Binding2> providerBinding2() { return binding2Provider; } @Override - public Provider<Binding3> providerBinding3() { + public javax.inject.Provider<Binding3> providerBinding3() { return testSubcomponentImpl.testSubcomponentImplShard.binding3Provider; } } diff --git a/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardSubcomponentCreated_FAST_INIT_MODE_dagger.internal.codegen.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardSubcomponentCreated_FAST_INIT_MODE_dagger.internal.codegen.DaggerTestComponent index 5a675bae8..f2a4aa6ac 100644 --- a/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardSubcomponentCreated_FAST_INIT_MODE_dagger.internal.codegen.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/ComponentShardTest_testNewShardSubcomponentCreated_FAST_INIT_MODE_dagger.internal.codegen.DaggerTestComponent @@ -2,8 +2,8 @@ package dagger.internal.codegen; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -14,7 +14,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -77,17 +78,17 @@ final class DaggerTestComponent { } @Override - public Provider<Binding1> providerBinding1() { + public javax.inject.Provider<Binding1> providerBinding1() { return binding1Provider; } @Override - public Provider<Binding2> providerBinding2() { + public javax.inject.Provider<Binding2> providerBinding2() { return binding2Provider; } @Override - public Provider<Binding3> providerBinding3() { + public javax.inject.Provider<Binding3> providerBinding3() { return testSubcomponentImpl.testSubcomponentImplShard.binding3Provider; } diff --git a/javatests/dagger/internal/codegen/goldens/DaggerProcessingOptionsTest_testCmdLineOptionEnabledPrecedesAnnotationDisabled_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/DaggerProcessingOptionsTest_testCmdLineOptionEnabledPrecedesAnnotationDisabled_test.DaggerSimpleComponent index d92a70e85..094c1ff24 100644 --- a/javatests/dagger/internal/codegen/goldens/DaggerProcessingOptionsTest_testCmdLineOptionEnabledPrecedesAnnotationDisabled_test.DaggerSimpleComponent +++ b/javatests/dagger/internal/codegen/goldens/DaggerProcessingOptionsTest_testCmdLineOptionEnabledPrecedesAnnotationDisabled_test.DaggerSimpleComponent @@ -3,8 +3,8 @@ package test; import dagger.Lazy; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -15,7 +15,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerSimpleComponent { private DaggerSimpleComponent() { @@ -65,7 +66,7 @@ final class DaggerSimpleComponent { } @Override - public Provider<SomeInjectableType> someInjectableTypeProvider() { + public javax.inject.Provider<SomeInjectableType> someInjectableTypeProvider() { return someInjectableTypeProvider; } diff --git a/javatests/dagger/internal/codegen/goldens/DaggerProcessingOptionsTest_testFastInitEnabledFromAnnotationSucceeded_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/DaggerProcessingOptionsTest_testFastInitEnabledFromAnnotationSucceeded_test.DaggerSimpleComponent index d92a70e85..094c1ff24 100644 --- a/javatests/dagger/internal/codegen/goldens/DaggerProcessingOptionsTest_testFastInitEnabledFromAnnotationSucceeded_test.DaggerSimpleComponent +++ b/javatests/dagger/internal/codegen/goldens/DaggerProcessingOptionsTest_testFastInitEnabledFromAnnotationSucceeded_test.DaggerSimpleComponent @@ -3,8 +3,8 @@ package test; import dagger.Lazy; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -15,7 +15,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerSimpleComponent { private DaggerSimpleComponent() { @@ -65,7 +66,7 @@ final class DaggerSimpleComponent { } @Override - public Provider<SomeInjectableType> someInjectableTypeProvider() { + public javax.inject.Provider<SomeInjectableType> someInjectableTypeProvider() { return someInjectableTypeProvider; } diff --git a/javatests/dagger/internal/codegen/goldens/DaggerProcessingOptionsTest_testFastInitaDisabledFromAnnotationSucceeded_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/DaggerProcessingOptionsTest_testFastInitaDisabledFromAnnotationSucceeded_test.DaggerSimpleComponent index 9e46639a8..e1e3f6442 100644 --- a/javatests/dagger/internal/codegen/goldens/DaggerProcessingOptionsTest_testFastInitaDisabledFromAnnotationSucceeded_test.DaggerSimpleComponent +++ b/javatests/dagger/internal/codegen/goldens/DaggerProcessingOptionsTest_testFastInitaDisabledFromAnnotationSucceeded_test.DaggerSimpleComponent @@ -15,7 +15,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerSimpleComponent { private DaggerSimpleComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_castNeeded_rawTypes_Provider_get_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_castNeeded_rawTypes_Provider_get_DEFAULT_MODE_test.DaggerTestComponent index 87f55ab41..0cf470e1b 100644 --- a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_castNeeded_rawTypes_Provider_get_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_castNeeded_rawTypes_Provider_get_DEFAULT_MODE_test.DaggerTestComponent @@ -2,8 +2,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; import other.Subtype_Factory; import other.Supertype; @@ -16,7 +16,8 @@ import other.Supertype; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_castNeeded_rawTypes_Provider_get_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_castNeeded_rawTypes_Provider_get_FAST_INIT_MODE_test.DaggerTestComponent index 06e4298ff..f7bd4485a 100644 --- a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_castNeeded_rawTypes_Provider_get_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_castNeeded_rawTypes_Provider_get_FAST_INIT_MODE_test.DaggerTestComponent @@ -2,8 +2,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; import other.Subtype_Factory; import other.Supertype; @@ -16,7 +16,8 @@ import other.Supertype; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_castedToRawType_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_castedToRawType_DEFAULT_MODE_test.DaggerTestComponent index 6bdd833da..d5ebea6d6 100644 --- a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_castedToRawType_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_castedToRawType_DEFAULT_MODE_test.DaggerTestComponent @@ -13,7 +13,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -46,7 +47,7 @@ final class DaggerTestComponent { @Override public Provider<CharSequence> charSequence() { - return ((Provider) TestModule_ProvideStringFactory.create()); + return ((dagger.internal.Provider) TestModule_ProvideStringFactory.create()); } @Override diff --git a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_castedToRawType_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_castedToRawType_FAST_INIT_MODE_test.DaggerTestComponent index f186b844c..dda883661 100644 --- a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_castedToRawType_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_castedToRawType_FAST_INIT_MODE_test.DaggerTestComponent @@ -1,8 +1,8 @@ package test; import dagger.internal.DaggerGenerated; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -13,7 +13,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -53,7 +54,7 @@ final class DaggerTestComponent { } @Override - public Provider<CharSequence> charSequence() { + public javax.inject.Provider<CharSequence> charSequence() { return ((Provider) provideStringProvider); } @@ -63,7 +64,7 @@ final class DaggerTestComponent { } @Override - public Provider<String> namedString() { + public javax.inject.Provider<String> namedString() { return provideStringProvider; } diff --git a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_doubleBinds_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_doubleBinds_DEFAULT_MODE_test.DaggerTestComponent index 578eaf46f..8a2c7de07 100644 --- a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_doubleBinds_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_doubleBinds_DEFAULT_MODE_test.DaggerTestComponent @@ -13,7 +13,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -46,12 +47,12 @@ final class DaggerTestComponent { @Override public Provider<CharSequence> charSequence() { - return ((Provider) TestModule_ProvideStringFactory.create()); + return ((dagger.internal.Provider) TestModule_ProvideStringFactory.create()); } @Override public Provider<Object> object() { - return ((Provider) TestModule_ProvideStringFactory.create()); + return ((dagger.internal.Provider) TestModule_ProvideStringFactory.create()); } } } diff --git a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_doubleBinds_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_doubleBinds_FAST_INIT_MODE_test.DaggerTestComponent index 310f8a1d8..5c9ce8ab8 100644 --- a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_doubleBinds_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_doubleBinds_FAST_INIT_MODE_test.DaggerTestComponent @@ -1,8 +1,8 @@ package test; import dagger.internal.DaggerGenerated; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -13,7 +13,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -53,12 +54,12 @@ final class DaggerTestComponent { } @Override - public Provider<CharSequence> charSequence() { + public javax.inject.Provider<CharSequence> charSequence() { return ((Provider) provideStringProvider); } @Override - public Provider<Object> object() { + public javax.inject.Provider<Object> object() { return ((Provider) provideStringProvider); } diff --git a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_inlineFactoryOfInacessibleType_DEFAULT_MODE_test.DaggerRequestsSubtypeAsProvider b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_inlineFactoryOfInacessibleType_DEFAULT_MODE_test.DaggerRequestsSubtypeAsProvider index 193724a41..a8ad72f6b 100644 --- a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_inlineFactoryOfInacessibleType_DEFAULT_MODE_test.DaggerRequestsSubtypeAsProvider +++ b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_inlineFactoryOfInacessibleType_DEFAULT_MODE_test.DaggerRequestsSubtypeAsProvider @@ -15,7 +15,8 @@ import other.Supertype; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerRequestsSubtypeAsProvider { private DaggerRequestsSubtypeAsProvider() { @@ -48,7 +49,7 @@ final class DaggerRequestsSubtypeAsProvider { @Override public Provider<Supertype> supertypeProvider() { - return ((Provider) Subtype_Factory.create()); + return ((dagger.internal.Provider) Subtype_Factory.create()); } } } diff --git a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_inlineFactoryOfInacessibleType_FAST_INIT_MODE_test.DaggerRequestsSubtypeAsProvider b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_inlineFactoryOfInacessibleType_FAST_INIT_MODE_test.DaggerRequestsSubtypeAsProvider index 0d3233a98..6f6e32c93 100644 --- a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_inlineFactoryOfInacessibleType_FAST_INIT_MODE_test.DaggerRequestsSubtypeAsProvider +++ b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_inlineFactoryOfInacessibleType_FAST_INIT_MODE_test.DaggerRequestsSubtypeAsProvider @@ -1,8 +1,8 @@ package test; import dagger.internal.DaggerGenerated; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; import other.Subtype_Factory; import other.Supertype; @@ -15,7 +15,8 @@ import other.Supertype; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerRequestsSubtypeAsProvider { private DaggerRequestsSubtypeAsProvider() { @@ -56,7 +57,7 @@ final class DaggerRequestsSubtypeAsProvider { } @Override - public Provider<Supertype> supertypeProvider() { + public javax.inject.Provider<Supertype> supertypeProvider() { return subtypeProvider; } diff --git a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_noCast_rawTypes_Provider_get_toInaccessibleType_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_noCast_rawTypes_Provider_get_toInaccessibleType_DEFAULT_MODE_test.DaggerTestComponent index b1c1c2c87..9e96fba0b 100644 --- a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_noCast_rawTypes_Provider_get_toInaccessibleType_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_noCast_rawTypes_Provider_get_toInaccessibleType_DEFAULT_MODE_test.DaggerTestComponent @@ -2,8 +2,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; import other.Subtype_Factory; import other.UsesSupertype; import other.UsesSupertype_Factory; @@ -17,7 +17,8 @@ import other.UsesSupertype_Factory; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_noCast_rawTypes_Provider_get_toInaccessibleType_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_noCast_rawTypes_Provider_get_toInaccessibleType_FAST_INIT_MODE_test.DaggerTestComponent index e076a1dc6..059eaab2b 100644 --- a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_noCast_rawTypes_Provider_get_toInaccessibleType_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_noCast_rawTypes_Provider_get_toInaccessibleType_FAST_INIT_MODE_test.DaggerTestComponent @@ -2,8 +2,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; import other.Subtype_Factory; import other.UsesSupertype; import other.UsesSupertype_Factory; @@ -17,7 +17,8 @@ import other.UsesSupertype_Factory; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_providerWhenBindsScopeGreaterThanDependencyScope_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_providerWhenBindsScopeGreaterThanDependencyScope_DEFAULT_MODE_test.DaggerTestComponent index 149a5fe68..a8a4aad74 100644 --- a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_providerWhenBindsScopeGreaterThanDependencyScope_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_providerWhenBindsScopeGreaterThanDependencyScope_DEFAULT_MODE_test.DaggerTestComponent @@ -2,9 +2,9 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import dagger.internal.SingleCheck; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -15,7 +15,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -58,7 +59,7 @@ final class DaggerTestComponent { } @Override - public Provider<Object> object() { + public javax.inject.Provider<Object> object() { return bindStringProvider; } } diff --git a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_providerWhenBindsScopeGreaterThanDependencyScope_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_providerWhenBindsScopeGreaterThanDependencyScope_FAST_INIT_MODE_test.DaggerTestComponent index 09600ed69..40dcf73e4 100644 --- a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_providerWhenBindsScopeGreaterThanDependencyScope_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_providerWhenBindsScopeGreaterThanDependencyScope_FAST_INIT_MODE_test.DaggerTestComponent @@ -2,9 +2,9 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import dagger.internal.SingleCheck; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -15,7 +15,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -58,7 +59,7 @@ final class DaggerTestComponent { } @Override - public Provider<Object> object() { + public javax.inject.Provider<Object> object() { return bindStringProvider; } diff --git a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toDoubleCheck_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toDoubleCheck_DEFAULT_MODE_test.DaggerTestComponent index 61f28ddf7..4877c334f 100644 --- a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toDoubleCheck_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toDoubleCheck_DEFAULT_MODE_test.DaggerTestComponent @@ -2,9 +2,9 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import dagger.internal.SingleCheck; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -15,7 +15,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toDoubleCheck_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toDoubleCheck_FAST_INIT_MODE_test.DaggerTestComponent index 323f241f2..08c584464 100644 --- a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toDoubleCheck_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toDoubleCheck_FAST_INIT_MODE_test.DaggerTestComponent @@ -2,9 +2,9 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import dagger.internal.SingleCheck; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -15,7 +15,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toSingleCheck_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toSingleCheck_DEFAULT_MODE_test.DaggerTestComponent index ccbf8fc06..e04aae669 100644 --- a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toSingleCheck_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toSingleCheck_DEFAULT_MODE_test.DaggerTestComponent @@ -2,9 +2,9 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import dagger.internal.SingleCheck; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -15,7 +15,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toSingleCheck_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toSingleCheck_FAST_INIT_MODE_test.DaggerTestComponent index 1b7c50552..2ca627d02 100644 --- a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toSingleCheck_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toSingleCheck_FAST_INIT_MODE_test.DaggerTestComponent @@ -2,9 +2,9 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import dagger.internal.SingleCheck; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -15,7 +15,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toUnscoped_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toUnscoped_DEFAULT_MODE_test.DaggerTestComponent index 227bed0a8..e3d5bf697 100644 --- a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toUnscoped_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toUnscoped_DEFAULT_MODE_test.DaggerTestComponent @@ -2,9 +2,9 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import dagger.internal.SingleCheck; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -15,7 +15,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toUnscoped_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toUnscoped_FAST_INIT_MODE_test.DaggerTestComponent index dea546e94..93973b689 100644 --- a/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toUnscoped_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/DelegateRequestRepresentationTest_toUnscoped_FAST_INIT_MODE_test.DaggerTestComponent @@ -2,9 +2,9 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import dagger.internal.SingleCheck; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -15,7 +15,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_scopedBinding_onlyUsedInSubcomponent_DEFAULT_MODE_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_scopedBinding_onlyUsedInSubcomponent_DEFAULT_MODE_test.DaggerSimpleComponent index cb7a35d2c..416d9c23a 100644 --- a/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_scopedBinding_onlyUsedInSubcomponent_DEFAULT_MODE_test.DaggerSimpleComponent +++ b/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_scopedBinding_onlyUsedInSubcomponent_DEFAULT_MODE_test.DaggerSimpleComponent @@ -2,8 +2,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -14,7 +14,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerSimpleComponent { private DaggerSimpleComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_scopedBinding_onlyUsedInSubcomponent_FAST_INIT_MODE_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_scopedBinding_onlyUsedInSubcomponent_FAST_INIT_MODE_test.DaggerSimpleComponent index 94c174c71..64762bdcf 100644 --- a/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_scopedBinding_onlyUsedInSubcomponent_FAST_INIT_MODE_test.DaggerSimpleComponent +++ b/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_scopedBinding_onlyUsedInSubcomponent_FAST_INIT_MODE_test.DaggerSimpleComponent @@ -2,8 +2,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -14,7 +14,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerSimpleComponent { private DaggerSimpleComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_simpleComponent_DEFAULT_MODE_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_simpleComponent_DEFAULT_MODE_test.DaggerSimpleComponent index a5f9992c9..39dc9c5a4 100644 --- a/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_simpleComponent_DEFAULT_MODE_test.DaggerSimpleComponent +++ b/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_simpleComponent_DEFAULT_MODE_test.DaggerSimpleComponent @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerSimpleComponent { private DaggerSimpleComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_simpleComponent_FAST_INIT_MODE_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_simpleComponent_FAST_INIT_MODE_test.DaggerSimpleComponent index a5f9992c9..39dc9c5a4 100644 --- a/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_simpleComponent_FAST_INIT_MODE_test.DaggerSimpleComponent +++ b/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_simpleComponent_FAST_INIT_MODE_test.DaggerSimpleComponent @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerSimpleComponent { private DaggerSimpleComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_simpleComponent_injectsProviderOf_dependsOnScoped_DEFAULT_MODE_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_simpleComponent_injectsProviderOf_dependsOnScoped_DEFAULT_MODE_test.DaggerSimpleComponent index 32382c8cf..d11d1ab9c 100644 --- a/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_simpleComponent_injectsProviderOf_dependsOnScoped_DEFAULT_MODE_test.DaggerSimpleComponent +++ b/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_simpleComponent_injectsProviderOf_dependsOnScoped_DEFAULT_MODE_test.DaggerSimpleComponent @@ -2,8 +2,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -14,7 +14,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerSimpleComponent { private DaggerSimpleComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_simpleComponent_injectsProviderOf_dependsOnScoped_FAST_INIT_MODE_test.DaggerSimpleComponent b/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_simpleComponent_injectsProviderOf_dependsOnScoped_FAST_INIT_MODE_test.DaggerSimpleComponent index 381eeebf9..acf83f2df 100644 --- a/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_simpleComponent_injectsProviderOf_dependsOnScoped_FAST_INIT_MODE_test.DaggerSimpleComponent +++ b/javatests/dagger/internal/codegen/goldens/ElidedFactoriesTest_simpleComponent_injectsProviderOf_dependsOnScoped_FAST_INIT_MODE_test.DaggerSimpleComponent @@ -2,8 +2,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -14,7 +14,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerSimpleComponent { private DaggerSimpleComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoopScoped_DEFAULT_JAVA7_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoopScoped_DEFAULT_JAVA7_MODE_test.DaggerTestComponent index 9e10117e4..e752840df 100644 --- a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoopScoped_DEFAULT_JAVA7_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoopScoped_DEFAULT_JAVA7_MODE_test.DaggerTestComponent @@ -3,8 +3,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DelegateFactory; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import javax.annotation.Generated; -import javax.inject.Provider; import other.FooImpl_Factory; import other.OtherEntryPoint; import other.OtherEntryPoint_Factory; @@ -18,7 +18,8 @@ import other.OtherEntryPoint_Factory; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -71,4 +72,4 @@ final class DaggerTestComponent { return OtherEntryPoint_Factory.newInstance(fooImpl()); } } -}
\ No newline at end of file +} diff --git a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoopScoped_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoopScoped_DEFAULT_MODE_test.DaggerTestComponent index 9c2506681..799007973 100644 --- a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoopScoped_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoopScoped_DEFAULT_MODE_test.DaggerTestComponent @@ -3,8 +3,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DelegateFactory; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; import other.FooImpl_Factory; import other.OtherEntryPoint; import other.OtherEntryPoint_Factory; @@ -18,7 +18,8 @@ import other.OtherEntryPoint_Factory; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoopScoped_FAST_INIT_JAVA7_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoopScoped_FAST_INIT_JAVA7_MODE_test.DaggerTestComponent index 9642f3381..bf80e634f 100644 --- a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoopScoped_FAST_INIT_JAVA7_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoopScoped_FAST_INIT_JAVA7_MODE_test.DaggerTestComponent @@ -3,8 +3,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DelegateFactory; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import javax.annotation.Generated; -import javax.inject.Provider; import other.FooImpl_Factory; import other.OtherEntryPoint; import other.OtherEntryPoint_Factory; @@ -18,7 +18,8 @@ import other.OtherEntryPoint_Factory; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -93,4 +94,4 @@ final class DaggerTestComponent { } } } -}
\ No newline at end of file +} diff --git a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoopScoped_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoopScoped_FAST_INIT_MODE_test.DaggerTestComponent index a18b8a4c4..f92f5585d 100644 --- a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoopScoped_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoopScoped_FAST_INIT_MODE_test.DaggerTestComponent @@ -3,8 +3,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DelegateFactory; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; import other.FooImpl_Factory; import other.OtherEntryPoint; import other.OtherEntryPoint_Factory; @@ -18,7 +18,8 @@ import other.OtherEntryPoint_Factory; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoop_DEFAULT_JAVA7_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoop_DEFAULT_JAVA7_MODE_test.DaggerTestComponent index e377365d4..f13d94ad1 100644 --- a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoop_DEFAULT_JAVA7_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoop_DEFAULT_JAVA7_MODE_test.DaggerTestComponent @@ -2,8 +2,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DelegateFactory; +import dagger.internal.Provider; import javax.annotation.Generated; -import javax.inject.Provider; import other.FooImpl_Factory; import other.OtherEntryPoint; import other.OtherEntryPoint_Factory; @@ -17,7 +17,8 @@ import other.OtherEntryPoint_Factory; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -67,4 +68,4 @@ final class DaggerTestComponent { return OtherEntryPoint_Factory.newInstance(fooImpl()); } } -}
\ No newline at end of file +} diff --git a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoop_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoop_DEFAULT_MODE_test.DaggerTestComponent index c1345ad1c..30be4f105 100644 --- a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoop_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoop_DEFAULT_MODE_test.DaggerTestComponent @@ -2,8 +2,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DelegateFactory; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; import other.FooImpl_Factory; import other.OtherEntryPoint; import other.OtherEntryPoint_Factory; @@ -17,7 +17,8 @@ import other.OtherEntryPoint_Factory; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoop_FAST_INIT_JAVA7_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoop_FAST_INIT_JAVA7_MODE_test.DaggerTestComponent index c6db8da9b..27a30fb98 100644 --- a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoop_FAST_INIT_JAVA7_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoop_FAST_INIT_JAVA7_MODE_test.DaggerTestComponent @@ -2,8 +2,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DelegateFactory; +import dagger.internal.Provider; import javax.annotation.Generated; -import javax.inject.Provider; import other.FooImpl_Factory; import other.OtherEntryPoint; import other.OtherEntryPoint_Factory; @@ -17,7 +17,8 @@ import other.OtherEntryPoint_Factory; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -89,4 +90,4 @@ final class DaggerTestComponent { } } } -}
\ No newline at end of file +} diff --git a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoop_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoop_FAST_INIT_MODE_test.DaggerTestComponent index 8e2e95981..7146c06e3 100644 --- a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoop_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_inaccessibleTypeBoundInALoop_FAST_INIT_MODE_test.DaggerTestComponent @@ -2,8 +2,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DelegateFactory; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; import other.FooImpl_Factory; import other.OtherEntryPoint; import other.OtherEntryPoint_Factory; @@ -17,7 +17,8 @@ import other.OtherEntryPoint_Factory; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_scopedInaccessibleTypeBound_DEFAULT_JAVA7_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_scopedInaccessibleTypeBound_DEFAULT_JAVA7_MODE_test.DaggerTestComponent index d39656c9b..01ffe8668 100644 --- a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_scopedInaccessibleTypeBound_DEFAULT_JAVA7_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_scopedInaccessibleTypeBound_DEFAULT_JAVA7_MODE_test.DaggerTestComponent @@ -2,8 +2,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import javax.annotation.Generated; -import javax.inject.Provider; import other.FooImpl_Factory; @DaggerGenerated @@ -15,7 +15,8 @@ import other.FooImpl_Factory; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -59,4 +60,4 @@ final class DaggerTestComponent { return bindProvider.get(); } } -}
\ No newline at end of file +} diff --git a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_scopedInaccessibleTypeBound_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_scopedInaccessibleTypeBound_DEFAULT_MODE_test.DaggerTestComponent index 73dda53a9..ca51d3f3e 100644 --- a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_scopedInaccessibleTypeBound_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_scopedInaccessibleTypeBound_DEFAULT_MODE_test.DaggerTestComponent @@ -2,8 +2,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; import other.FooImpl_Factory; @DaggerGenerated @@ -15,7 +15,8 @@ import other.FooImpl_Factory; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_scopedInaccessibleTypeBound_FAST_INIT_JAVA7_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_scopedInaccessibleTypeBound_FAST_INIT_JAVA7_MODE_test.DaggerTestComponent index 7c0c68df2..ce6bcdff6 100644 --- a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_scopedInaccessibleTypeBound_FAST_INIT_JAVA7_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_scopedInaccessibleTypeBound_FAST_INIT_JAVA7_MODE_test.DaggerTestComponent @@ -2,8 +2,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import javax.annotation.Generated; -import javax.inject.Provider; import other.FooImpl_Factory; @DaggerGenerated @@ -15,7 +15,8 @@ import other.FooImpl_Factory; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -85,4 +86,4 @@ final class DaggerTestComponent { } } } -}
\ No newline at end of file +} diff --git a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_scopedInaccessibleTypeBound_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_scopedInaccessibleTypeBound_FAST_INIT_MODE_test.DaggerTestComponent index 84ae12fed..c39381bc4 100644 --- a/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_scopedInaccessibleTypeBound_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/InaccessibleTypeBindsTest_scopedInaccessibleTypeBound_FAST_INIT_MODE_test.DaggerTestComponent @@ -2,8 +2,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; import other.FooImpl_Factory; @DaggerGenerated @@ -15,7 +15,8 @@ import other.FooImpl_Factory; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_basicNameCollision_test.InjectConstructor_Factory b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_basicNameCollision_test.InjectConstructor_Factory index 00ee9afe8..8488abaa4 100644 --- a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_basicNameCollision_test.InjectConstructor_Factory +++ b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_basicNameCollision_test.InjectConstructor_Factory @@ -18,7 +18,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class InjectConstructor_Factory implements Factory<InjectConstructor> { private final Provider<other.pkg.Factory> factoryProvider; diff --git a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_boundedGenerics_test.GenericClass_Factory b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_boundedGenerics_test.GenericClass_Factory index 012d3d040..143d1ed7c 100644 --- a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_boundedGenerics_test.GenericClass_Factory +++ b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_boundedGenerics_test.GenericClass_Factory @@ -19,7 +19,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class GenericClass_Factory<A extends Number & Comparable<A>, B extends List<? extends String>, C extends List<? super String>> implements Factory<GenericClass<A, B, C>> { private final Provider<A> aProvider; diff --git a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_fieldAndMethodGenerics_test.GenericClass_Factory b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_fieldAndMethodGenerics_test.GenericClass_Factory index a3d5bf2ac..ab6d9aef3 100644 --- a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_fieldAndMethodGenerics_test.GenericClass_Factory +++ b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_fieldAndMethodGenerics_test.GenericClass_Factory @@ -18,7 +18,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class GenericClass_Factory<A, B> implements Factory<GenericClass<A, B>> { private final Provider<A> aProvider; diff --git a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_genericClassWithNoDependencies_test.GenericClass_Factory b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_genericClassWithNoDependencies_test.GenericClass_Factory index d43e19f10..95e00381d 100644 --- a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_genericClassWithNoDependencies_test.GenericClass_Factory +++ b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_genericClassWithNoDependencies_test.GenericClass_Factory @@ -17,7 +17,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class GenericClass_Factory<T> implements Factory<GenericClass<T>> { @Override diff --git a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_injectConstructorAndMembersInjection_test.AllInjections_Factory b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_injectConstructorAndMembersInjection_test.AllInjections_Factory index 71d791bc1..0c2475c7a 100644 --- a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_injectConstructorAndMembersInjection_test.AllInjections_Factory +++ b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_injectConstructorAndMembersInjection_test.AllInjections_Factory @@ -18,7 +18,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class AllInjections_Factory implements Factory<AllInjections> { private final Provider<String> sProvider; diff --git a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_injectConstructorOnGenericClass_test.GenericClass_Factory b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_injectConstructorOnGenericClass_test.GenericClass_Factory index 67d5808a5..6ac47e92e 100644 --- a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_injectConstructorOnGenericClass_test.GenericClass_Factory +++ b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_injectConstructorOnGenericClass_test.GenericClass_Factory @@ -18,7 +18,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class GenericClass_Factory<T> implements Factory<GenericClass<T>> { private final Provider<T> tProvider; diff --git a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_injectConstructor_test.InjectConstructor_Factory b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_injectConstructor_test.InjectConstructor_Factory index bf20ec4ef..638815ea9 100644 --- a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_injectConstructor_test.InjectConstructor_Factory +++ b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_injectConstructor_test.InjectConstructor_Factory @@ -18,7 +18,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class InjectConstructor_Factory implements Factory<InjectConstructor> { private final Provider<String> sProvider; diff --git a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_multipleSameTypesWithGenericsAndQualifiersAndLazies_test.GenericClass_Factory b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_multipleSameTypesWithGenericsAndQualifiersAndLazies_test.GenericClass_Factory index bfc28d062..a5b93b8e8 100644 --- a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_multipleSameTypesWithGenericsAndQualifiersAndLazies_test.GenericClass_Factory +++ b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_multipleSameTypesWithGenericsAndQualifiersAndLazies_test.GenericClass_Factory @@ -20,7 +20,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class GenericClass_Factory<A, B> implements Factory<GenericClass<A, B>> { private final Provider<A> aProvider; diff --git a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_nestedNameCollision_test.InjectConstructor_Factory b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_nestedNameCollision_test.InjectConstructor_Factory index aba20cef2..f3337a1c8 100644 --- a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_nestedNameCollision_test.InjectConstructor_Factory +++ b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_nestedNameCollision_test.InjectConstructor_Factory @@ -19,7 +19,8 @@ import other.pkg.Outer; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class InjectConstructor_Factory implements Factory<InjectConstructor> { private final Provider<Outer.Factory> factoryProvider; diff --git a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_noDeps_test.SimpleType_Factory b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_noDeps_test.SimpleType_Factory index 67f856c2c..41c6c72a4 100644 --- a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_noDeps_test.SimpleType_Factory +++ b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_noDeps_test.SimpleType_Factory @@ -17,7 +17,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class SimpleType_Factory implements Factory<SimpleType> { @Override diff --git a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_samePackageNameCollision_test.InjectConstructor_Factory b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_samePackageNameCollision_test.InjectConstructor_Factory index 0e22f2d66..f65c9c550 100644 --- a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_samePackageNameCollision_test.InjectConstructor_Factory +++ b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_samePackageNameCollision_test.InjectConstructor_Factory @@ -18,7 +18,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class InjectConstructor_Factory implements Factory<InjectConstructor> { private final Provider<other.pkg.CommonName> otherPackageProvider; diff --git a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_simpleComponentWithNesting_test.OuterType_A_Factory b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_simpleComponentWithNesting_test.OuterType_A_Factory index 371c71688..424c614d9 100644 --- a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_simpleComponentWithNesting_test.OuterType_A_Factory +++ b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_simpleComponentWithNesting_test.OuterType_A_Factory @@ -17,7 +17,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class OuterType_A_Factory implements Factory<OuterType.A> { @Override diff --git a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testBaseClassQualifierMetadata_test.FooBase_Factory b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testBaseClassQualifierMetadata_test.FooBase_Factory index e2b44b501..1f00f95b6 100644 --- a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testBaseClassQualifierMetadata_test.FooBase_Factory +++ b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testBaseClassQualifierMetadata_test.FooBase_Factory @@ -18,7 +18,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class FooBase_Factory implements Factory<FooBase> { private final Provider<Integer> iProvider; diff --git a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testBaseClassQualifierMetadata_test.FooBase_MembersInjector b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testBaseClassQualifierMetadata_test.FooBase_MembersInjector index e93005b17..5e865ffab 100644 --- a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testBaseClassQualifierMetadata_test.FooBase_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testBaseClassQualifierMetadata_test.FooBase_MembersInjector @@ -20,7 +20,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class FooBase_MembersInjector implements MembersInjector<FooBase> { private final Provider<String> injectFieldProvider; diff --git a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testBaseClassQualifierMetadata_test.Foo_Factory b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testBaseClassQualifierMetadata_test.Foo_Factory index 69bc96234..48d9102ec 100644 --- a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testBaseClassQualifierMetadata_test.Foo_Factory +++ b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testBaseClassQualifierMetadata_test.Foo_Factory @@ -18,7 +18,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class Foo_Factory implements Factory<Foo> { private final Provider<Integer> iProvider; diff --git a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testBaseClassQualifierMetadata_test.Foo_MembersInjector b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testBaseClassQualifierMetadata_test.Foo_MembersInjector index 36d5b1da1..748583647 100644 --- a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testBaseClassQualifierMetadata_test.Foo_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testBaseClassQualifierMetadata_test.Foo_MembersInjector @@ -20,7 +20,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class Foo_MembersInjector implements MembersInjector<Foo> { private final Provider<String> injectFieldProvider; diff --git a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testComplexQualifierMetadata_test.SomeBinding_Factory b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testComplexQualifierMetadata_test.SomeBinding_Factory index 9a4b6e67a..2d100f6ff 100644 --- a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testComplexQualifierMetadata_test.SomeBinding_Factory +++ b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testComplexQualifierMetadata_test.SomeBinding_Factory @@ -21,7 +21,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class SomeBinding_Factory implements Factory<SomeBinding> { private final Provider<String> str1Provider; diff --git a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testComplexQualifierMetadata_test.SomeBinding_MembersInjector b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testComplexQualifierMetadata_test.SomeBinding_MembersInjector index a30a9dfb0..a5707af6e 100644 --- a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testComplexQualifierMetadata_test.SomeBinding_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testComplexQualifierMetadata_test.SomeBinding_MembersInjector @@ -20,7 +20,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class SomeBinding_MembersInjector implements MembersInjector<SomeBinding> { private final Provider<String> injectFieldProvider; diff --git a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testQualifierMetadata_test.SomeBinding_Factory b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testQualifierMetadata_test.SomeBinding_Factory index f8308661e..40690b35a 100644 --- a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testQualifierMetadata_test.SomeBinding_Factory +++ b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testQualifierMetadata_test.SomeBinding_Factory @@ -18,7 +18,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class SomeBinding_Factory implements Factory<SomeBinding> { private final Provider<Double> dProvider; diff --git a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testQualifierMetadata_test.SomeBinding_MembersInjector b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testQualifierMetadata_test.SomeBinding_MembersInjector index f17203dd2..a8ca78019 100644 --- a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testQualifierMetadata_test.SomeBinding_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testQualifierMetadata_test.SomeBinding_MembersInjector @@ -20,7 +20,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class SomeBinding_MembersInjector implements MembersInjector<SomeBinding> { private final Provider<String> injectFieldProvider; diff --git a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testScopedMetadataWithCustomScope_test.ScopedBinding_Factory b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testScopedMetadataWithCustomScope_test.ScopedBinding_Factory index 8220ee617..d949bdd26 100644 --- a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testScopedMetadataWithCustomScope_test.ScopedBinding_Factory +++ b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testScopedMetadataWithCustomScope_test.ScopedBinding_Factory @@ -17,7 +17,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class ScopedBinding_Factory implements Factory<ScopedBinding> { @Override diff --git a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testScopedMetadata_test.ScopedBinding_Factory b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testScopedMetadata_test.ScopedBinding_Factory index 871fe75c3..5682bb07b 100644 --- a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testScopedMetadata_test.ScopedBinding_Factory +++ b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_testScopedMetadata_test.ScopedBinding_Factory @@ -17,7 +17,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class ScopedBinding_Factory implements Factory<ScopedBinding> { @Override diff --git a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_twoGenericTypes_test.GenericClass_Factory b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_twoGenericTypes_test.GenericClass_Factory index 39e73daff..116df17b3 100644 --- a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_twoGenericTypes_test.GenericClass_Factory +++ b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_twoGenericTypes_test.GenericClass_Factory @@ -18,7 +18,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class GenericClass_Factory<A, B> implements Factory<GenericClass<A, B>> { private final Provider<A> aProvider; diff --git a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_wildcardDependency_test.InjectConstructor_Factory b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_wildcardDependency_test.InjectConstructor_Factory index d5758e71d..681a4b6d9 100644 --- a/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_wildcardDependency_test.InjectConstructor_Factory +++ b/javatests/dagger/internal/codegen/goldens/InjectConstructorFactoryGeneratorTest_wildcardDependency_test.InjectConstructor_Factory @@ -19,7 +19,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class InjectConstructor_Factory implements Factory<InjectConstructor> { private final Provider<List<?>> objectsProvider; diff --git a/javatests/dagger/internal/codegen/goldens/LazyClassKeyMapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_DEFAULT_MODE_mapkeys.MapModule_ClassKeyMapKey b/javatests/dagger/internal/codegen/goldens/LazyClassKeyMapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_DEFAULT_MODE_mapkeys.MapModule_ClassKeyMapKey new file mode 100644 index 000000000..63a07ab64 --- /dev/null +++ b/javatests/dagger/internal/codegen/goldens/LazyClassKeyMapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_DEFAULT_MODE_mapkeys.MapModule_ClassKeyMapKey @@ -0,0 +1,30 @@ +package mapkeys; + +import dagger.internal.DaggerGenerated; +import dagger.internal.KeepFieldType; +import javax.annotation.processing.Generated; + +@DaggerGenerated +@Generated( + value = "dagger.internal.codegen.ComponentProcessor", + comments = "https://dagger.dev" +) +@SuppressWarnings({ + "unchecked", + "rawtypes", + "KotlinInternal", + "KotlinInternalInJava", + "cast" +}) +public final class MapModule_ClassKeyMapKey { + @KeepFieldType + MapKeys.Inaccessible className; + + private MapModule_ClassKeyMapKey() { + } + + public static Class<?> create() { + return MapKeys.Inaccessible.class; + } +} + diff --git a/javatests/dagger/internal/codegen/goldens/LazyClassKeyMapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_DEFAULT_MODE_mapkeys.MapModule_ComplexKeyWithInaccessibleAnnotationValueMapKey b/javatests/dagger/internal/codegen/goldens/LazyClassKeyMapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_DEFAULT_MODE_mapkeys.MapModule_ComplexKeyWithInaccessibleAnnotationValueMapKey new file mode 100644 index 000000000..3e00ffd48 --- /dev/null +++ b/javatests/dagger/internal/codegen/goldens/LazyClassKeyMapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_DEFAULT_MODE_mapkeys.MapModule_ComplexKeyWithInaccessibleAnnotationValueMapKey @@ -0,0 +1,26 @@ +package mapkeys; + +import dagger.internal.DaggerGenerated; +import javax.annotation.processing.Generated; + +@DaggerGenerated +@Generated( + value = "dagger.internal.codegen.ComponentProcessor", + comments = "https://dagger.dev" +) +@SuppressWarnings({ + "unchecked", + "rawtypes", + "KotlinInternal", + "KotlinInternalInJava", + "cast" +}) +public final class MapModule_ComplexKeyWithInaccessibleAnnotationValueMapKey { + private MapModule_ComplexKeyWithInaccessibleAnnotationValueMapKey() { + } + + public static MapKeys.ComplexKey create() { + return MapKeys_ComplexKeyCreator.createComplexKey(new Class[] {String.class}, String.class, MapKeys_ComplexKeyCreator.createLazyClassKey(MapKeys.Inaccessible.class)); + } +} + diff --git a/javatests/dagger/internal/codegen/goldens/LazyClassKeyMapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/LazyClassKeyMapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_DEFAULT_MODE_test.DaggerTestComponent new file mode 100644 index 000000000..eff6a40b8 --- /dev/null +++ b/javatests/dagger/internal/codegen/goldens/LazyClassKeyMapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_DEFAULT_MODE_test.DaggerTestComponent @@ -0,0 +1,99 @@ +package test; + +import com.google.common.collect.ImmutableMap; +import dagger.internal.DaggerGenerated; +import dagger.internal.IdentifierNameString; +import dagger.internal.LazyClassKeyMap; +import dagger.internal.MapFactory; +import dagger.internal.Provider; +import java.util.Map; +import javax.annotation.processing.Generated; +import mapkeys.MapKeys; +import mapkeys.MapModule; +import mapkeys.MapModule_ClassKeyFactory; +import mapkeys.MapModule_ComplexKeyWithInaccessibleAnnotationValueFactory; +import mapkeys.MapModule_ComplexKeyWithInaccessibleAnnotationValueMapKey; +import mapkeys.MapModule_ComplexKeyWithInaccessibleArrayValueFactory; +import mapkeys.MapModule_ComplexKeyWithInaccessibleArrayValueMapKey; +import mapkeys.MapModule_ComplexKeyWithInaccessibleValueFactory; +import mapkeys.MapModule_ComplexKeyWithInaccessibleValueMapKey; + +@DaggerGenerated +@Generated( + value = "dagger.internal.codegen.ComponentProcessor", + comments = "https://dagger.dev" +) +@SuppressWarnings({ + "unchecked", + "rawtypes", + "KotlinInternal", + "KotlinInternalInJava", + "cast" +}) +final class DaggerTestComponent { + private DaggerTestComponent() { + } + + public static Builder builder() { + return new Builder(); + } + + public static TestComponent create() { + return new Builder().build(); + } + + static final class Builder { + private Builder() { + } + + public TestComponent build() { + return new TestComponentImpl(); + } + } + + private static final class TestComponentImpl implements TestComponent { + private final TestComponentImpl testComponentImpl = this; + + private Provider<Map<Class<?>, Integer>> mapOfClassOfAndIntegerProvider; + + private Provider<Map<MapKeys.ComplexKey, Integer>> mapOfComplexKeyAndIntegerProvider; + + private TestComponentImpl() { + + initialize(); + + } + + @SuppressWarnings("unchecked") + private void initialize() { + this.mapOfClassOfAndIntegerProvider = LazyClassKeyMap.Factory.<Integer>of(MapFactory.<String, Integer>builder(1).put(LazyClassKeyProvider.mapkeys_MapKeys_Inaccessible, MapModule_ClassKeyFactory.create()).build()); + this.mapOfComplexKeyAndIntegerProvider = MapFactory.<MapKeys.ComplexKey, Integer>builder(3).put(MapModule_ComplexKeyWithInaccessibleValueMapKey.create(), MapModule_ComplexKeyWithInaccessibleValueFactory.create()).put(MapModule_ComplexKeyWithInaccessibleArrayValueMapKey.create(), MapModule_ComplexKeyWithInaccessibleArrayValueFactory.create()).put(MapModule_ComplexKeyWithInaccessibleAnnotationValueMapKey.create(), MapModule_ComplexKeyWithInaccessibleAnnotationValueFactory.create()).build(); + } + + @Override + public Map<Class<?>, Integer> classKey() { + return LazyClassKeyMap.<Integer>of(ImmutableMap.<String, Integer>of(LazyClassKeyProvider.mapkeys_MapKeys_Inaccessible, MapModule.classKey())); + } + + @Override + public javax.inject.Provider<Map<Class<?>, Integer>> classKeyProvider() { + return mapOfClassOfAndIntegerProvider; + } + + @Override + public Map<MapKeys.ComplexKey, Integer> complexKey() { + return ImmutableMap.<MapKeys.ComplexKey, Integer>of(MapModule_ComplexKeyWithInaccessibleValueMapKey.create(), MapModule.complexKeyWithInaccessibleValue(), MapModule_ComplexKeyWithInaccessibleArrayValueMapKey.create(), MapModule.complexKeyWithInaccessibleArrayValue(), MapModule_ComplexKeyWithInaccessibleAnnotationValueMapKey.create(), MapModule.complexKeyWithInaccessibleAnnotationValue()); + } + + @Override + public javax.inject.Provider<Map<MapKeys.ComplexKey, Integer>> complexKeyProvider() { + return mapOfComplexKeyAndIntegerProvider; + } + + @IdentifierNameString + private static final class LazyClassKeyProvider { + static String mapkeys_MapKeys_Inaccessible = "mapkeys.MapKeys$Inaccessible"; + } + } +} + diff --git a/javatests/dagger/internal/codegen/goldens/LazyClassKeyMapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_FAST_INIT_MODE_mapkeys.MapModule_ClassKeyMapKey b/javatests/dagger/internal/codegen/goldens/LazyClassKeyMapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_FAST_INIT_MODE_mapkeys.MapModule_ClassKeyMapKey new file mode 100644 index 000000000..63a07ab64 --- /dev/null +++ b/javatests/dagger/internal/codegen/goldens/LazyClassKeyMapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_FAST_INIT_MODE_mapkeys.MapModule_ClassKeyMapKey @@ -0,0 +1,30 @@ +package mapkeys; + +import dagger.internal.DaggerGenerated; +import dagger.internal.KeepFieldType; +import javax.annotation.processing.Generated; + +@DaggerGenerated +@Generated( + value = "dagger.internal.codegen.ComponentProcessor", + comments = "https://dagger.dev" +) +@SuppressWarnings({ + "unchecked", + "rawtypes", + "KotlinInternal", + "KotlinInternalInJava", + "cast" +}) +public final class MapModule_ClassKeyMapKey { + @KeepFieldType + MapKeys.Inaccessible className; + + private MapModule_ClassKeyMapKey() { + } + + public static Class<?> create() { + return MapKeys.Inaccessible.class; + } +} + diff --git a/javatests/dagger/internal/codegen/goldens/LazyClassKeyMapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_FAST_INIT_MODE_mapkeys.MapModule_ComplexKeyWithInaccessibleAnnotationValueMapKey b/javatests/dagger/internal/codegen/goldens/LazyClassKeyMapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_FAST_INIT_MODE_mapkeys.MapModule_ComplexKeyWithInaccessibleAnnotationValueMapKey new file mode 100644 index 000000000..3e00ffd48 --- /dev/null +++ b/javatests/dagger/internal/codegen/goldens/LazyClassKeyMapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_FAST_INIT_MODE_mapkeys.MapModule_ComplexKeyWithInaccessibleAnnotationValueMapKey @@ -0,0 +1,26 @@ +package mapkeys; + +import dagger.internal.DaggerGenerated; +import javax.annotation.processing.Generated; + +@DaggerGenerated +@Generated( + value = "dagger.internal.codegen.ComponentProcessor", + comments = "https://dagger.dev" +) +@SuppressWarnings({ + "unchecked", + "rawtypes", + "KotlinInternal", + "KotlinInternalInJava", + "cast" +}) +public final class MapModule_ComplexKeyWithInaccessibleAnnotationValueMapKey { + private MapModule_ComplexKeyWithInaccessibleAnnotationValueMapKey() { + } + + public static MapKeys.ComplexKey create() { + return MapKeys_ComplexKeyCreator.createComplexKey(new Class[] {String.class}, String.class, MapKeys_ComplexKeyCreator.createLazyClassKey(MapKeys.Inaccessible.class)); + } +} + diff --git a/javatests/dagger/internal/codegen/goldens/LazyClassKeyMapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/LazyClassKeyMapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_FAST_INIT_MODE_test.DaggerTestComponent new file mode 100644 index 000000000..478b0101d --- /dev/null +++ b/javatests/dagger/internal/codegen/goldens/LazyClassKeyMapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_FAST_INIT_MODE_test.DaggerTestComponent @@ -0,0 +1,119 @@ +package test; + +import com.google.common.collect.ImmutableMap; +import dagger.internal.DaggerGenerated; +import dagger.internal.IdentifierNameString; +import dagger.internal.LazyClassKeyMap; +import dagger.internal.Provider; +import java.util.Map; +import javax.annotation.processing.Generated; +import mapkeys.MapKeys; +import mapkeys.MapModule; +import mapkeys.MapModule_ComplexKeyWithInaccessibleAnnotationValueMapKey; +import mapkeys.MapModule_ComplexKeyWithInaccessibleArrayValueMapKey; +import mapkeys.MapModule_ComplexKeyWithInaccessibleValueMapKey; + +@DaggerGenerated +@Generated( + value = "dagger.internal.codegen.ComponentProcessor", + comments = "https://dagger.dev" +) +@SuppressWarnings({ + "unchecked", + "rawtypes", + "KotlinInternal", + "KotlinInternalInJava", + "cast" +}) +final class DaggerTestComponent { + private DaggerTestComponent() { + } + + public static Builder builder() { + return new Builder(); + } + + public static TestComponent create() { + return new Builder().build(); + } + + static final class Builder { + private Builder() { + } + + public TestComponent build() { + return new TestComponentImpl(); + } + } + + private static final class TestComponentImpl implements TestComponent { + private final TestComponentImpl testComponentImpl = this; + + private Provider<Map<Class<?>, Integer>> mapOfClassOfAndIntegerProvider; + + private Provider<Map<MapKeys.ComplexKey, Integer>> mapOfComplexKeyAndIntegerProvider; + + private TestComponentImpl() { + + initialize(); + + } + + @SuppressWarnings("unchecked") + private void initialize() { + this.mapOfClassOfAndIntegerProvider = new SwitchingProvider<>(testComponentImpl, 0); + this.mapOfComplexKeyAndIntegerProvider = new SwitchingProvider<>(testComponentImpl, 1); + } + + @Override + public Map<Class<?>, Integer> classKey() { + return mapOfClassOfAndIntegerProvider.get(); + } + + @Override + public javax.inject.Provider<Map<Class<?>, Integer>> classKeyProvider() { + return mapOfClassOfAndIntegerProvider; + } + + @Override + public Map<MapKeys.ComplexKey, Integer> complexKey() { + return mapOfComplexKeyAndIntegerProvider.get(); + } + + @Override + public javax.inject.Provider<Map<MapKeys.ComplexKey, Integer>> complexKeyProvider() { + return mapOfComplexKeyAndIntegerProvider; + } + + private static final class SwitchingProvider<T> implements Provider<T> { + private final TestComponentImpl testComponentImpl; + + private final int id; + + SwitchingProvider(TestComponentImpl testComponentImpl, int id) { + this.testComponentImpl = testComponentImpl; + this.id = id; + } + + @SuppressWarnings("unchecked") + @Override + public T get() { + switch (id) { + case 0: // java.util.Map<java.lang.Class<?>,java.lang.Integer> + return (T) LazyClassKeyMap.<Integer>of(ImmutableMap.<String, Integer>of(LazyClassKeyProvider.mapkeys_MapKeys_Inaccessible, MapModule.classKey())); + + case 1: // java.util.Map<mapkeys.MapKeys.ComplexKey,java.lang.Integer> + return (T) ImmutableMap.<MapKeys.ComplexKey, Integer>of(MapModule_ComplexKeyWithInaccessibleValueMapKey.create(), MapModule.complexKeyWithInaccessibleValue(), MapModule_ComplexKeyWithInaccessibleArrayValueMapKey.create(), MapModule.complexKeyWithInaccessibleArrayValue(), MapModule_ComplexKeyWithInaccessibleAnnotationValueMapKey.create(), MapModule.complexKeyWithInaccessibleAnnotationValue()); + + default: throw new AssertionError(id); + } + } + } + + @IdentifierNameString + private static final class LazyClassKeyProvider { + static String mapkeys_MapKeys_Inaccessible = "mapkeys.MapKeys$Inaccessible"; + } + } +} + diff --git a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_injectMapWithoutMapBinding_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_injectMapWithoutMapBinding_DEFAULT_MODE_test.DaggerTestComponent index 227404c19..b348b61de 100644 --- a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_injectMapWithoutMapBinding_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_injectMapWithoutMapBinding_DEFAULT_MODE_test.DaggerTestComponent @@ -14,7 +14,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_injectMapWithoutMapBinding_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_injectMapWithoutMapBinding_FAST_INIT_MODE_test.DaggerTestComponent index 227404c19..b348b61de 100644 --- a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_injectMapWithoutMapBinding_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_injectMapWithoutMapBinding_FAST_INIT_MODE_test.DaggerTestComponent @@ -14,7 +14,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithEnumKey_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithEnumKey_DEFAULT_MODE_test.DaggerTestComponent index 88153bcb5..dbffeddd7 100644 --- a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithEnumKey_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithEnumKey_DEFAULT_MODE_test.DaggerTestComponent @@ -3,9 +3,9 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.MapProviderFactory; import dagger.internal.Preconditions; +import dagger.internal.Provider; import java.util.Map; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -16,7 +16,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -66,7 +67,7 @@ final class DaggerTestComponent { private Provider<Handler> provideLoginHandlerProvider; - private Provider<Map<PathEnum, Provider<Handler>>> mapOfPathEnumAndProviderOfHandlerProvider; + private Provider mapOfPathEnumAndProviderOfHandlerProvider; private TestComponentImpl(MapModuleOne mapModuleOneParam, MapModuleTwo mapModuleTwoParam) { @@ -83,7 +84,7 @@ final class DaggerTestComponent { } @Override - public Provider<Map<PathEnum, Provider<Handler>>> dispatcher() { + public javax.inject.Provider<Map<PathEnum, javax.inject.Provider<Handler>>> dispatcher() { return mapOfPathEnumAndProviderOfHandlerProvider; } } diff --git a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithEnumKey_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithEnumKey_FAST_INIT_MODE_test.DaggerTestComponent index ac0e74e19..54f6250f7 100644 --- a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithEnumKey_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithEnumKey_FAST_INIT_MODE_test.DaggerTestComponent @@ -3,9 +3,9 @@ package test; import com.google.common.collect.ImmutableMap; import dagger.internal.DaggerGenerated; import dagger.internal.Preconditions; +import dagger.internal.Provider; import java.util.Map; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -16,7 +16,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -70,7 +71,7 @@ final class DaggerTestComponent { private Provider<Handler> provideLoginHandlerProvider; - private Provider<Map<PathEnum, Provider<Handler>>> mapOfPathEnumAndProviderOfHandlerProvider; + private Provider mapOfPathEnumAndProviderOfHandlerProvider; private TestComponentImpl(MapModuleOne mapModuleOneParam, MapModuleTwo mapModuleTwoParam) { this.mapModuleOne = mapModuleOneParam; @@ -88,7 +89,7 @@ final class DaggerTestComponent { } @Override - public Provider<Map<PathEnum, Provider<Handler>>> dispatcher() { + public javax.inject.Provider<Map<PathEnum, javax.inject.Provider<Handler>>> dispatcher() { return mapOfPathEnumAndProviderOfHandlerProvider; } @@ -107,7 +108,7 @@ final class DaggerTestComponent { public T get() { switch (id) { case 0: // java.util.Map<test.PathEnum,javax.inject.Provider<test.Handler>> - return (T) ImmutableMap.<PathEnum, Provider<Handler>>of(PathEnum.ADMIN, testComponentImpl.provideAdminHandlerProvider, PathEnum.LOGIN, testComponentImpl.provideLoginHandlerProvider); + return (T) ImmutableMap.<PathEnum, javax.inject.Provider<Handler>>of(PathEnum.ADMIN, testComponentImpl.provideAdminHandlerProvider, PathEnum.LOGIN, testComponentImpl.provideLoginHandlerProvider); case 1: // java.util.Map<test.PathEnum,javax.inject.Provider<test.Handler>> test.MapModuleOne#provideAdminHandler return (T) MapModuleOne_ProvideAdminHandlerFactory.provideAdminHandler(testComponentImpl.mapModuleOne); diff --git a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_DEFAULT_MODE_mapkeys.MapModule_ClassKeyMapKey b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_DEFAULT_MODE_mapkeys.MapModule_ClassKeyMapKey index 252d0073f..209220e95 100644 --- a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_DEFAULT_MODE_mapkeys.MapModule_ClassKeyMapKey +++ b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_DEFAULT_MODE_mapkeys.MapModule_ClassKeyMapKey @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class MapModule_ClassKeyMapKey { private MapModule_ClassKeyMapKey() { diff --git a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_DEFAULT_MODE_mapkeys.MapModule_ComplexKeyWithInaccessibleAnnotationValueMapKey b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_DEFAULT_MODE_mapkeys.MapModule_ComplexKeyWithInaccessibleAnnotationValueMapKey index 34cbcbad0..f65280bb3 100644 --- a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_DEFAULT_MODE_mapkeys.MapModule_ComplexKeyWithInaccessibleAnnotationValueMapKey +++ b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_DEFAULT_MODE_mapkeys.MapModule_ComplexKeyWithInaccessibleAnnotationValueMapKey @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class MapModule_ComplexKeyWithInaccessibleAnnotationValueMapKey { private MapModule_ComplexKeyWithInaccessibleAnnotationValueMapKey() { diff --git a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_DEFAULT_MODE_test.DaggerTestComponent index 1d9618dd2..2b35d4612 100644 --- a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_DEFAULT_MODE_test.DaggerTestComponent @@ -3,9 +3,9 @@ package test; import com.google.common.collect.ImmutableMap; import dagger.internal.DaggerGenerated; import dagger.internal.MapFactory; +import dagger.internal.Provider; import java.util.Map; import javax.annotation.processing.Generated; -import javax.inject.Provider; import mapkeys.MapKeys; import mapkeys.MapModule; import mapkeys.MapModule_ClassKeyFactory; @@ -28,7 +28,8 @@ import mapkeys.MapModule_EnumKeyMapKey; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -84,7 +85,7 @@ final class DaggerTestComponent { } @Override - public Provider<Map<Class<?>, Integer>> classKeyProvider() { + public javax.inject.Provider<Map<Class<?>, Integer>> classKeyProvider() { return mapOfClassOfAndIntegerProvider; } @@ -94,7 +95,7 @@ final class DaggerTestComponent { } @Override - public Provider<Object> inaccessibleEnumProvider() { + public javax.inject.Provider<Object> inaccessibleEnumProvider() { return mapOfPackagePrivateEnumAndIntegerProvider; } @@ -104,7 +105,7 @@ final class DaggerTestComponent { } @Override - public Provider<Map<MapKeys.ComplexKey, Integer>> complexKeyProvider() { + public javax.inject.Provider<Map<MapKeys.ComplexKey, Integer>> complexKeyProvider() { return mapOfComplexKeyAndIntegerProvider; } } diff --git a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_FAST_INIT_MODE_mapkeys.MapModule_ClassKeyMapKey b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_FAST_INIT_MODE_mapkeys.MapModule_ClassKeyMapKey index 252d0073f..209220e95 100644 --- a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_FAST_INIT_MODE_mapkeys.MapModule_ClassKeyMapKey +++ b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_FAST_INIT_MODE_mapkeys.MapModule_ClassKeyMapKey @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class MapModule_ClassKeyMapKey { private MapModule_ClassKeyMapKey() { diff --git a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_FAST_INIT_MODE_mapkeys.MapModule_ComplexKeyWithInaccessibleAnnotationValueMapKey b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_FAST_INIT_MODE_mapkeys.MapModule_ComplexKeyWithInaccessibleAnnotationValueMapKey index 34cbcbad0..f65280bb3 100644 --- a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_FAST_INIT_MODE_mapkeys.MapModule_ComplexKeyWithInaccessibleAnnotationValueMapKey +++ b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_FAST_INIT_MODE_mapkeys.MapModule_ComplexKeyWithInaccessibleAnnotationValueMapKey @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class MapModule_ComplexKeyWithInaccessibleAnnotationValueMapKey { private MapModule_ComplexKeyWithInaccessibleAnnotationValueMapKey() { diff --git a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_FAST_INIT_MODE_test.DaggerTestComponent index 1d9618dd2..2b35d4612 100644 --- a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithInaccessibleKeys_FAST_INIT_MODE_test.DaggerTestComponent @@ -3,9 +3,9 @@ package test; import com.google.common.collect.ImmutableMap; import dagger.internal.DaggerGenerated; import dagger.internal.MapFactory; +import dagger.internal.Provider; import java.util.Map; import javax.annotation.processing.Generated; -import javax.inject.Provider; import mapkeys.MapKeys; import mapkeys.MapModule; import mapkeys.MapModule_ClassKeyFactory; @@ -28,7 +28,8 @@ import mapkeys.MapModule_EnumKeyMapKey; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -84,7 +85,7 @@ final class DaggerTestComponent { } @Override - public Provider<Map<Class<?>, Integer>> classKeyProvider() { + public javax.inject.Provider<Map<Class<?>, Integer>> classKeyProvider() { return mapOfClassOfAndIntegerProvider; } @@ -94,7 +95,7 @@ final class DaggerTestComponent { } @Override - public Provider<Object> inaccessibleEnumProvider() { + public javax.inject.Provider<Object> inaccessibleEnumProvider() { return mapOfPackagePrivateEnumAndIntegerProvider; } @@ -104,7 +105,7 @@ final class DaggerTestComponent { } @Override - public Provider<Map<MapKeys.ComplexKey, Integer>> complexKeyProvider() { + public javax.inject.Provider<Map<MapKeys.ComplexKey, Integer>> complexKeyProvider() { return mapOfComplexKeyAndIntegerProvider; } } diff --git a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithNonProviderValue_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithNonProviderValue_DEFAULT_MODE_test.DaggerTestComponent index b2e7cf5fd..e2d93ecd6 100644 --- a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithNonProviderValue_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithNonProviderValue_DEFAULT_MODE_test.DaggerTestComponent @@ -3,9 +3,9 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.MapFactory; import dagger.internal.Preconditions; +import dagger.internal.Provider; import java.util.Map; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -16,7 +16,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -83,7 +84,7 @@ final class DaggerTestComponent { } @Override - public Provider<Map<PathEnum, Handler>> dispatcher() { + public javax.inject.Provider<Map<PathEnum, Handler>> dispatcher() { return mapOfPathEnumAndHandlerProvider; } } diff --git a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithNonProviderValue_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithNonProviderValue_FAST_INIT_MODE_test.DaggerTestComponent index 4e898edfa..c3f057811 100644 --- a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithNonProviderValue_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithNonProviderValue_FAST_INIT_MODE_test.DaggerTestComponent @@ -3,9 +3,9 @@ package test; import com.google.common.collect.ImmutableMap; import dagger.internal.DaggerGenerated; import dagger.internal.Preconditions; +import dagger.internal.Provider; import java.util.Map; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -16,7 +16,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -82,7 +83,7 @@ final class DaggerTestComponent { } @Override - public Provider<Map<PathEnum, Handler>> dispatcher() { + public javax.inject.Provider<Map<PathEnum, Handler>> dispatcher() { return mapOfPathEnumAndHandlerProvider; } diff --git a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithStringKey_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithStringKey_DEFAULT_MODE_test.DaggerTestComponent index 0b463f566..cd24892bd 100644 --- a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithStringKey_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithStringKey_DEFAULT_MODE_test.DaggerTestComponent @@ -3,9 +3,9 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.MapProviderFactory; import dagger.internal.Preconditions; +import dagger.internal.Provider; import java.util.Map; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -16,7 +16,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -66,7 +67,7 @@ final class DaggerTestComponent { private Provider<Handler> provideLoginHandlerProvider; - private Provider<Map<String, Provider<Handler>>> mapOfStringAndProviderOfHandlerProvider; + private Provider mapOfStringAndProviderOfHandlerProvider; private TestComponentImpl(MapModuleOne mapModuleOneParam, MapModuleTwo mapModuleTwoParam) { @@ -83,7 +84,7 @@ final class DaggerTestComponent { } @Override - public Provider<Map<String, Provider<Handler>>> dispatcher() { + public javax.inject.Provider<Map<String, javax.inject.Provider<Handler>>> dispatcher() { return mapOfStringAndProviderOfHandlerProvider; } } diff --git a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithStringKey_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithStringKey_FAST_INIT_MODE_test.DaggerTestComponent index 65513bb7e..47a7d8baa 100644 --- a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithStringKey_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithStringKey_FAST_INIT_MODE_test.DaggerTestComponent @@ -3,9 +3,9 @@ package test; import com.google.common.collect.ImmutableMap; import dagger.internal.DaggerGenerated; import dagger.internal.Preconditions; +import dagger.internal.Provider; import java.util.Map; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -16,7 +16,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -70,7 +71,7 @@ final class DaggerTestComponent { private Provider<Handler> provideLoginHandlerProvider; - private Provider<Map<String, Provider<Handler>>> mapOfStringAndProviderOfHandlerProvider; + private Provider mapOfStringAndProviderOfHandlerProvider; private TestComponentImpl(MapModuleOne mapModuleOneParam, MapModuleTwo mapModuleTwoParam) { this.mapModuleOne = mapModuleOneParam; @@ -88,7 +89,7 @@ final class DaggerTestComponent { } @Override - public Provider<Map<String, Provider<Handler>>> dispatcher() { + public javax.inject.Provider<Map<String, javax.inject.Provider<Handler>>> dispatcher() { return mapOfStringAndProviderOfHandlerProvider; } @@ -107,7 +108,7 @@ final class DaggerTestComponent { public T get() { switch (id) { case 0: // java.util.Map<java.lang.String,javax.inject.Provider<test.Handler>> - return (T) ImmutableMap.<String, Provider<Handler>>of("Admin", testComponentImpl.provideAdminHandlerProvider, "Login", testComponentImpl.provideLoginHandlerProvider); + return (T) ImmutableMap.<String, javax.inject.Provider<Handler>>of("Admin", testComponentImpl.provideAdminHandlerProvider, "Login", testComponentImpl.provideLoginHandlerProvider); case 1: // java.util.Map<java.lang.String,javax.inject.Provider<test.Handler>> test.MapModuleOne#provideAdminHandler return (T) MapModuleOne_ProvideAdminHandlerFactory.provideAdminHandler(testComponentImpl.mapModuleOne); diff --git a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithWrappedKey_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithWrappedKey_DEFAULT_MODE_test.DaggerTestComponent index 47847a7dc..bbba316c9 100644 --- a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithWrappedKey_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithWrappedKey_DEFAULT_MODE_test.DaggerTestComponent @@ -3,9 +3,9 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.MapProviderFactory; import dagger.internal.Preconditions; +import dagger.internal.Provider; import java.util.Map; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -16,7 +16,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -66,7 +67,7 @@ final class DaggerTestComponent { private Provider<Handler> provideLoginHandlerProvider; - private Provider<Map<WrappedClassKey, Provider<Handler>>> mapOfWrappedClassKeyAndProviderOfHandlerProvider; + private Provider mapOfWrappedClassKeyAndProviderOfHandlerProvider; private TestComponentImpl(MapModuleOne mapModuleOneParam, MapModuleTwo mapModuleTwoParam) { @@ -83,7 +84,8 @@ final class DaggerTestComponent { } @Override - public Provider<Map<WrappedClassKey, Provider<Handler>>> dispatcher() { + public javax.inject.Provider<Map<WrappedClassKey, javax.inject.Provider<Handler>>> dispatcher( + ) { return mapOfWrappedClassKeyAndProviderOfHandlerProvider; } } diff --git a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithWrappedKey_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithWrappedKey_FAST_INIT_MODE_test.DaggerTestComponent index 3180571c2..d057b50ae 100644 --- a/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithWrappedKey_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/MapBindingComponentProcessorTest_mapBindingsWithWrappedKey_FAST_INIT_MODE_test.DaggerTestComponent @@ -3,9 +3,9 @@ package test; import com.google.common.collect.ImmutableMap; import dagger.internal.DaggerGenerated; import dagger.internal.Preconditions; +import dagger.internal.Provider; import java.util.Map; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -16,7 +16,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -70,7 +71,7 @@ final class DaggerTestComponent { private Provider<Handler> provideLoginHandlerProvider; - private Provider<Map<WrappedClassKey, Provider<Handler>>> mapOfWrappedClassKeyAndProviderOfHandlerProvider; + private Provider mapOfWrappedClassKeyAndProviderOfHandlerProvider; private TestComponentImpl(MapModuleOne mapModuleOneParam, MapModuleTwo mapModuleTwoParam) { this.mapModuleOne = mapModuleOneParam; @@ -88,7 +89,8 @@ final class DaggerTestComponent { } @Override - public Provider<Map<WrappedClassKey, Provider<Handler>>> dispatcher() { + public javax.inject.Provider<Map<WrappedClassKey, javax.inject.Provider<Handler>>> dispatcher( + ) { return mapOfWrappedClassKeyAndProviderOfHandlerProvider; } @@ -107,7 +109,7 @@ final class DaggerTestComponent { public T get() { switch (id) { case 0: // java.util.Map<test.WrappedClassKey,javax.inject.Provider<test.Handler>> - return (T) ImmutableMap.<WrappedClassKey, Provider<Handler>>of(WrappedClassKeyCreator.createWrappedClassKey(Integer.class), testComponentImpl.provideAdminHandlerProvider, WrappedClassKeyCreator.createWrappedClassKey(Long.class), testComponentImpl.provideLoginHandlerProvider); + return (T) ImmutableMap.<WrappedClassKey, javax.inject.Provider<Handler>>of(WrappedClassKeyCreator.createWrappedClassKey(Integer.class), testComponentImpl.provideAdminHandlerProvider, WrappedClassKeyCreator.createWrappedClassKey(Long.class), testComponentImpl.provideLoginHandlerProvider); case 1: // java.util.Map<test.WrappedClassKey,javax.inject.Provider<test.Handler>> test.MapModuleOne#provideAdminHandler return (T) MapModuleOne_ProvideAdminHandlerFactory.provideAdminHandler(testComponentImpl.mapModuleOne); diff --git a/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationTest_inaccessible_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationTest_inaccessible_DEFAULT_MODE_test.DaggerTestComponent index 390f13a8c..37bbf7913 100644 --- a/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationTest_inaccessible_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationTest_inaccessible_DEFAULT_MODE_test.DaggerTestComponent @@ -16,7 +16,8 @@ import other.UsesInaccessible_Factory; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationTest_inaccessible_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationTest_inaccessible_FAST_INIT_MODE_test.DaggerTestComponent index 390f13a8c..37bbf7913 100644 --- a/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationTest_inaccessible_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationTest_inaccessible_FAST_INIT_MODE_test.DaggerTestComponent @@ -16,7 +16,8 @@ import other.UsesInaccessible_Factory; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationTest_mapBindings_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationTest_mapBindings_DEFAULT_MODE_test.DaggerTestComponent index 79ac59f39..f47f08125 100644 --- a/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationTest_mapBindings_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationTest_mapBindings_DEFAULT_MODE_test.DaggerTestComponent @@ -16,7 +16,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationTest_mapBindings_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationTest_mapBindings_FAST_INIT_MODE_test.DaggerTestComponent index 0010e588c..0acd7f17a 100644 --- a/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationTest_mapBindings_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationTest_mapBindings_FAST_INIT_MODE_test.DaggerTestComponent @@ -2,10 +2,10 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.MapBuilder; +import dagger.internal.Provider; import java.util.Collections; import java.util.Map; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -16,7 +16,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -70,8 +71,8 @@ final class DaggerTestComponent { } @Override - public Map<String, Provider<String>> providerStrings() { - return Collections.<String, Provider<String>>emptyMap(); + public Map<String, javax.inject.Provider<String>> providerStrings() { + return Collections.<String, javax.inject.Provider<String>>emptyMap(); } @Override @@ -80,8 +81,8 @@ final class DaggerTestComponent { } @Override - public Map<Integer, Provider<Integer>> providerInts() { - return Collections.<Integer, Provider<Integer>>singletonMap(0, provideIntProvider); + public Map<Integer, javax.inject.Provider<Integer>> providerInts() { + return Collections.<Integer, javax.inject.Provider<Integer>>singletonMap(0, provideIntProvider); } @Override @@ -90,8 +91,8 @@ final class DaggerTestComponent { } @Override - public Map<Long, Provider<Long>> providerLongs() { - return MapBuilder.<Long, Provider<Long>>newMapBuilder(3).put(0L, provideLong0Provider).put(1L, provideLong1Provider).put(2L, provideLong2Provider).build(); + public Map<Long, javax.inject.Provider<Long>> providerLongs() { + return MapBuilder.<Long, javax.inject.Provider<Long>>newMapBuilder(3).put(0L, provideLong0Provider).put(1L, provideLong1Provider).put(2L, provideLong2Provider).build(); } private static final class SwitchingProvider<T> implements Provider<T> { diff --git a/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationTest_productionComponents_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationTest_productionComponents_DEFAULT_MODE_test.DaggerTestComponent index 635667fe1..8ae5d82d6 100644 --- a/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationTest_productionComponents_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationTest_productionComponents_DEFAULT_MODE_test.DaggerTestComponent @@ -17,7 +17,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationTest_productionComponents_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationTest_productionComponents_FAST_INIT_MODE_test.DaggerTestComponent index 635667fe1..8ae5d82d6 100644 --- a/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationTest_productionComponents_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationTest_productionComponents_FAST_INIT_MODE_test.DaggerTestComponent @@ -17,7 +17,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationTest_subcomponentOmitsInheritedBindings_DEFAULT_MODE_test.DaggerParent b/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationTest_subcomponentOmitsInheritedBindings_DEFAULT_MODE_test.DaggerParent index e9f21dd47..f4f656470 100644 --- a/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationTest_subcomponentOmitsInheritedBindings_DEFAULT_MODE_test.DaggerParent +++ b/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationTest_subcomponentOmitsInheritedBindings_DEFAULT_MODE_test.DaggerParent @@ -15,7 +15,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerParent { private DaggerParent() { diff --git a/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationTest_subcomponentOmitsInheritedBindings_FAST_INIT_MODE_test.DaggerParent b/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationTest_subcomponentOmitsInheritedBindings_FAST_INIT_MODE_test.DaggerParent index e9f21dd47..f4f656470 100644 --- a/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationTest_subcomponentOmitsInheritedBindings_FAST_INIT_MODE_test.DaggerParent +++ b/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationTest_subcomponentOmitsInheritedBindings_FAST_INIT_MODE_test.DaggerParent @@ -15,7 +15,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerParent { private DaggerParent() { diff --git a/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest_inaccessible_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest_inaccessible_DEFAULT_MODE_test.DaggerTestComponent index 1f1d76a1e..24c561912 100644 --- a/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest_inaccessible_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest_inaccessible_DEFAULT_MODE_test.DaggerTestComponent @@ -16,7 +16,8 @@ import other.UsesInaccessible_Factory; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest_inaccessible_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest_inaccessible_FAST_INIT_MODE_test.DaggerTestComponent index 1f1d76a1e..24c561912 100644 --- a/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest_inaccessible_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest_inaccessible_FAST_INIT_MODE_test.DaggerTestComponent @@ -16,7 +16,8 @@ import other.UsesInaccessible_Factory; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest_mapBindings_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest_mapBindings_DEFAULT_MODE_test.DaggerTestComponent index e6f96d5f7..55202813e 100644 --- a/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest_mapBindings_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest_mapBindings_DEFAULT_MODE_test.DaggerTestComponent @@ -15,7 +15,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest_mapBindings_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest_mapBindings_FAST_INIT_MODE_test.DaggerTestComponent index e99a9639e..12346c8b3 100644 --- a/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest_mapBindings_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest_mapBindings_FAST_INIT_MODE_test.DaggerTestComponent @@ -2,9 +2,9 @@ package test; import com.google.common.collect.ImmutableMap; import dagger.internal.DaggerGenerated; +import dagger.internal.Provider; import java.util.Map; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -15,7 +15,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -69,8 +70,8 @@ final class DaggerTestComponent { } @Override - public Map<Long, Provider<Long>> providerLongs() { - return ImmutableMap.<Long, Provider<Long>>builderWithExpectedSize(6).put(0L, testComponentImpl.provideLong0Provider).put(1L, testComponentImpl.provideLong1Provider).put(2L, testComponentImpl.provideLong2Provider).put(3L, provideLong3Provider).put(4L, provideLong4Provider).put(5L, provideLong5Provider).build(); + public Map<Long, javax.inject.Provider<Long>> providerLongs() { + return ImmutableMap.<Long, javax.inject.Provider<Long>>builderWithExpectedSize(6).put(0L, testComponentImpl.provideLong0Provider).put(1L, testComponentImpl.provideLong1Provider).put(2L, testComponentImpl.provideLong2Provider).put(3L, provideLong3Provider).put(4L, provideLong4Provider).put(5L, provideLong5Provider).build(); } private static final class SwitchingProvider<T> implements Provider<T> { @@ -136,8 +137,8 @@ final class DaggerTestComponent { } @Override - public Map<String, Provider<String>> providerStrings() { - return ImmutableMap.<String, Provider<String>>of(); + public Map<String, javax.inject.Provider<String>> providerStrings() { + return ImmutableMap.<String, javax.inject.Provider<String>>of(); } @Override @@ -146,8 +147,8 @@ final class DaggerTestComponent { } @Override - public Map<Integer, Provider<Integer>> providerInts() { - return ImmutableMap.<Integer, Provider<Integer>>of(0, provideIntProvider); + public Map<Integer, javax.inject.Provider<Integer>> providerInts() { + return ImmutableMap.<Integer, javax.inject.Provider<Integer>>of(0, provideIntProvider); } @Override @@ -156,8 +157,8 @@ final class DaggerTestComponent { } @Override - public Map<Long, Provider<Long>> providerLongs() { - return ImmutableMap.<Long, Provider<Long>>of(0L, provideLong0Provider, 1L, provideLong1Provider, 2L, provideLong2Provider); + public Map<Long, javax.inject.Provider<Long>> providerLongs() { + return ImmutableMap.<Long, javax.inject.Provider<Long>>of(0L, provideLong0Provider, 1L, provideLong1Provider, 2L, provideLong2Provider); } @Override diff --git a/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest_productionComponents_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest_productionComponents_DEFAULT_MODE_test.DaggerTestComponent index 26b3dfd76..dc297087b 100644 --- a/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest_productionComponents_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest_productionComponents_DEFAULT_MODE_test.DaggerTestComponent @@ -17,7 +17,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest_productionComponents_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest_productionComponents_FAST_INIT_MODE_test.DaggerTestComponent index 26b3dfd76..dc297087b 100644 --- a/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest_productionComponents_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest_productionComponents_FAST_INIT_MODE_test.DaggerTestComponent @@ -17,7 +17,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest_subcomponentOmitsInheritedBindings_DEFAULT_MODE_test.DaggerParent b/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest_subcomponentOmitsInheritedBindings_DEFAULT_MODE_test.DaggerParent index eb764709a..0ac6e9f88 100644 --- a/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest_subcomponentOmitsInheritedBindings_DEFAULT_MODE_test.DaggerParent +++ b/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest_subcomponentOmitsInheritedBindings_DEFAULT_MODE_test.DaggerParent @@ -15,7 +15,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerParent { private DaggerParent() { diff --git a/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest_subcomponentOmitsInheritedBindings_FAST_INIT_MODE_test.DaggerParent b/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest_subcomponentOmitsInheritedBindings_FAST_INIT_MODE_test.DaggerParent index eb764709a..0ac6e9f88 100644 --- a/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest_subcomponentOmitsInheritedBindings_FAST_INIT_MODE_test.DaggerParent +++ b/javatests/dagger/internal/codegen/goldens/MapRequestRepresentationWithGuavaTest_subcomponentOmitsInheritedBindings_FAST_INIT_MODE_test.DaggerParent @@ -15,7 +15,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerParent { private DaggerParent() { diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_accessibility_DEFAULT_MODE_other.Inaccessible_MembersInjector b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_accessibility_DEFAULT_MODE_other.Inaccessible_MembersInjector index 0bf65b2b0..cc45f79ed 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_accessibility_DEFAULT_MODE_other.Inaccessible_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_accessibility_DEFAULT_MODE_other.Inaccessible_MembersInjector @@ -17,7 +17,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class Inaccessible_MembersInjector implements MembersInjector<Inaccessible> { private final Provider<Foo> fooProvider; diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_accessibility_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_accessibility_DEFAULT_MODE_test.DaggerTestComponent index 4ecf3f572..5f232b192 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_accessibility_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_accessibility_DEFAULT_MODE_test.DaggerTestComponent @@ -18,7 +18,8 @@ import other.UsesInaccessible_Factory; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_accessibility_FAST_INIT_MODE_other.Inaccessible_MembersInjector b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_accessibility_FAST_INIT_MODE_other.Inaccessible_MembersInjector index 0bf65b2b0..cc45f79ed 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_accessibility_FAST_INIT_MODE_other.Inaccessible_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_accessibility_FAST_INIT_MODE_other.Inaccessible_MembersInjector @@ -17,7 +17,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class Inaccessible_MembersInjector implements MembersInjector<Inaccessible> { private final Provider<Foo> fooProvider; diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_accessibility_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_accessibility_FAST_INIT_MODE_test.DaggerTestComponent index 4ecf3f572..5f232b192 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_accessibility_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_accessibility_FAST_INIT_MODE_test.DaggerTestComponent @@ -18,7 +18,8 @@ import other.UsesInaccessible_Factory; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_accessibleRawType_ofInaccessibleType_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_accessibleRawType_ofInaccessibleType_DEFAULT_MODE_test.DaggerTestComponent index 5cb03e884..c17dea0d5 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_accessibleRawType_ofInaccessibleType_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_accessibleRawType_ofInaccessibleType_DEFAULT_MODE_test.DaggerTestComponent @@ -3,11 +3,9 @@ package test; import com.google.errorprone.annotations.CanIgnoreReturnValue; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; -import dagger.internal.Preconditions; +import dagger.internal.Provider; import java.util.List; import javax.annotation.processing.Generated; -import javax.inject.Provider; -import other.InaccessiblesModule; import other.InaccessiblesModule_InaccessiblesFactory; import other.UsesInaccessibles; import other.UsesInaccessibles_Factory; @@ -22,7 +20,8 @@ import other.UsesInaccessibles_MembersInjector; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -40,15 +39,6 @@ final class DaggerTestComponent { private Builder() { } - /** - * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://dagger.dev/unused-modules. - */ - @Deprecated - public Builder inaccessiblesModule(InaccessiblesModule inaccessiblesModule) { - Preconditions.checkNotNull(inaccessiblesModule); - return this; - } - public TestComponent build() { return new TestComponentImpl(); } diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_accessibleRawType_ofInaccessibleType_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_accessibleRawType_ofInaccessibleType_FAST_INIT_MODE_test.DaggerTestComponent index 02230a628..854a42927 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_accessibleRawType_ofInaccessibleType_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_accessibleRawType_ofInaccessibleType_FAST_INIT_MODE_test.DaggerTestComponent @@ -3,11 +3,9 @@ package test; import com.google.errorprone.annotations.CanIgnoreReturnValue; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; -import dagger.internal.Preconditions; +import dagger.internal.Provider; import java.util.List; import javax.annotation.processing.Generated; -import javax.inject.Provider; -import other.InaccessiblesModule; import other.InaccessiblesModule_InaccessiblesFactory; import other.UsesInaccessibles; import other.UsesInaccessibles_Factory; @@ -22,7 +20,8 @@ import other.UsesInaccessibles_MembersInjector; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -40,15 +39,6 @@ final class DaggerTestComponent { private Builder() { } - /** - * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://dagger.dev/unused-modules. - */ - @Deprecated - public Builder inaccessiblesModule(InaccessiblesModule inaccessiblesModule) { - Preconditions.checkNotNull(inaccessiblesModule); - return this; - } - public TestComponent build() { return new TestComponentImpl(); } diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_componentWithNestingAndGeneratedType_DEFAULT_MODE_test.OuterType_B_MembersInjector b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_componentWithNestingAndGeneratedType_DEFAULT_MODE_test.OuterType_B_MembersInjector index 72b876ef0..5b4932f1c 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_componentWithNestingAndGeneratedType_DEFAULT_MODE_test.OuterType_B_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_componentWithNestingAndGeneratedType_DEFAULT_MODE_test.OuterType_B_MembersInjector @@ -17,7 +17,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class OuterType_B_MembersInjector implements MembersInjector<OuterType.B> { private final Provider<OuterType.A> aProvider; diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_componentWithNestingAndGeneratedType_FAST_INIT_MODE_test.OuterType_B_MembersInjector b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_componentWithNestingAndGeneratedType_FAST_INIT_MODE_test.OuterType_B_MembersInjector index 72b876ef0..5b4932f1c 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_componentWithNestingAndGeneratedType_FAST_INIT_MODE_test.OuterType_B_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_componentWithNestingAndGeneratedType_FAST_INIT_MODE_test.OuterType_B_MembersInjector @@ -17,7 +17,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class OuterType_B_MembersInjector implements MembersInjector<OuterType.B> { private final Provider<OuterType.A> aProvider; diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_fieldAndMethodGenerics_DEFAULT_MODE_test.GenericClass_MembersInjector b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_fieldAndMethodGenerics_DEFAULT_MODE_test.GenericClass_MembersInjector index e3a70356d..70415a8fd 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_fieldAndMethodGenerics_DEFAULT_MODE_test.GenericClass_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_fieldAndMethodGenerics_DEFAULT_MODE_test.GenericClass_MembersInjector @@ -17,7 +17,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class GenericClass_MembersInjector<A, B> implements MembersInjector<GenericClass<A, B>> { private final Provider<A> aProvider; diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_fieldAndMethodGenerics_FAST_INIT_MODE_test.GenericClass_MembersInjector b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_fieldAndMethodGenerics_FAST_INIT_MODE_test.GenericClass_MembersInjector index e3a70356d..70415a8fd 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_fieldAndMethodGenerics_FAST_INIT_MODE_test.GenericClass_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_fieldAndMethodGenerics_FAST_INIT_MODE_test.GenericClass_MembersInjector @@ -17,7 +17,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class GenericClass_MembersInjector<A, B> implements MembersInjector<GenericClass<A, B>> { private final Provider<A> aProvider; diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_fieldInjectionForShadowedMember_DEFAULT_MODE_test.Child_MembersInjector b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_fieldInjectionForShadowedMember_DEFAULT_MODE_test.Child_MembersInjector index 36f5651a8..2f69706c0 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_fieldInjectionForShadowedMember_DEFAULT_MODE_test.Child_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_fieldInjectionForShadowedMember_DEFAULT_MODE_test.Child_MembersInjector @@ -17,7 +17,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class Child_MembersInjector implements MembersInjector<Child> { private final Provider<Foo> objectProvider; diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_fieldInjectionForShadowedMember_FAST_INIT_MODE_test.Child_MembersInjector b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_fieldInjectionForShadowedMember_FAST_INIT_MODE_test.Child_MembersInjector index 36f5651a8..2f69706c0 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_fieldInjectionForShadowedMember_FAST_INIT_MODE_test.Child_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_fieldInjectionForShadowedMember_FAST_INIT_MODE_test.Child_MembersInjector @@ -17,7 +17,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class Child_MembersInjector implements MembersInjector<Child> { private final Provider<Foo> objectProvider; diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_fieldInjectionWithQualifier_DEFAULT_MODE_test.FieldInjectionWithQualifier_MembersInjector b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_fieldInjectionWithQualifier_DEFAULT_MODE_test.FieldInjectionWithQualifier_MembersInjector index 7d5b2776e..46faeb8fd 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_fieldInjectionWithQualifier_DEFAULT_MODE_test.FieldInjectionWithQualifier_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_fieldInjectionWithQualifier_DEFAULT_MODE_test.FieldInjectionWithQualifier_MembersInjector @@ -18,7 +18,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class FieldInjectionWithQualifier_MembersInjector implements MembersInjector<FieldInjectionWithQualifier> { private final Provider<String> aProvider; diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_fieldInjectionWithQualifier_FAST_INIT_MODE_test.FieldInjectionWithQualifier_MembersInjector b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_fieldInjectionWithQualifier_FAST_INIT_MODE_test.FieldInjectionWithQualifier_MembersInjector index 7d5b2776e..46faeb8fd 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_fieldInjectionWithQualifier_FAST_INIT_MODE_test.FieldInjectionWithQualifier_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_fieldInjectionWithQualifier_FAST_INIT_MODE_test.FieldInjectionWithQualifier_MembersInjector @@ -18,7 +18,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class FieldInjectionWithQualifier_MembersInjector implements MembersInjector<FieldInjectionWithQualifier> { private final Provider<String> aProvider; diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_fieldInjection_DEFAULT_MODE_test.FieldInjection_MembersInjector b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_fieldInjection_DEFAULT_MODE_test.FieldInjection_MembersInjector index 7c3425a73..b0af86500 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_fieldInjection_DEFAULT_MODE_test.FieldInjection_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_fieldInjection_DEFAULT_MODE_test.FieldInjection_MembersInjector @@ -19,7 +19,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class FieldInjection_MembersInjector implements MembersInjector<FieldInjection> { private final Provider<String> stringProvider; diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_fieldInjection_FAST_INIT_MODE_test.FieldInjection_MembersInjector b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_fieldInjection_FAST_INIT_MODE_test.FieldInjection_MembersInjector index 7c3425a73..b0af86500 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_fieldInjection_FAST_INIT_MODE_test.FieldInjection_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_fieldInjection_FAST_INIT_MODE_test.FieldInjection_MembersInjector @@ -19,7 +19,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class FieldInjection_MembersInjector implements MembersInjector<FieldInjection> { private final Provider<String> stringProvider; diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_injectConstructorAndMembersInjection_DEFAULT_MODE_test.AllInjections_MembersInjector b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_injectConstructorAndMembersInjection_DEFAULT_MODE_test.AllInjections_MembersInjector index 479cf0702..0c67f5925 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_injectConstructorAndMembersInjection_DEFAULT_MODE_test.AllInjections_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_injectConstructorAndMembersInjection_DEFAULT_MODE_test.AllInjections_MembersInjector @@ -17,7 +17,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class AllInjections_MembersInjector implements MembersInjector<AllInjections> { private final Provider<String> sProvider; diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_injectConstructorAndMembersInjection_FAST_INIT_MODE_test.AllInjections_MembersInjector b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_injectConstructorAndMembersInjection_FAST_INIT_MODE_test.AllInjections_MembersInjector index 479cf0702..0c67f5925 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_injectConstructorAndMembersInjection_FAST_INIT_MODE_test.AllInjections_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_injectConstructorAndMembersInjection_FAST_INIT_MODE_test.AllInjections_MembersInjector @@ -17,7 +17,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class AllInjections_MembersInjector implements MembersInjector<AllInjections> { private final Provider<String> sProvider; diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_injectsPrimitive_DEFAULT_MODE_test.InjectedType_Factory b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_injectsPrimitive_DEFAULT_MODE_test.InjectedType_Factory index 8851616a8..b63c40869 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_injectsPrimitive_DEFAULT_MODE_test.InjectedType_Factory +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_injectsPrimitive_DEFAULT_MODE_test.InjectedType_Factory @@ -18,7 +18,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class InjectedType_Factory implements Factory<InjectedType> { private final Provider<Integer> primitiveIntProvider; diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_injectsPrimitive_DEFAULT_MODE_test.InjectedType_MembersInjector b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_injectsPrimitive_DEFAULT_MODE_test.InjectedType_MembersInjector index 91f6586b4..f28869798 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_injectsPrimitive_DEFAULT_MODE_test.InjectedType_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_injectsPrimitive_DEFAULT_MODE_test.InjectedType_MembersInjector @@ -17,7 +17,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class InjectedType_MembersInjector implements MembersInjector<InjectedType> { private final Provider<Integer> primitiveIntProvider; diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_injectsPrimitive_FAST_INIT_MODE_test.InjectedType_Factory b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_injectsPrimitive_FAST_INIT_MODE_test.InjectedType_Factory index 8851616a8..b63c40869 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_injectsPrimitive_FAST_INIT_MODE_test.InjectedType_Factory +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_injectsPrimitive_FAST_INIT_MODE_test.InjectedType_Factory @@ -18,7 +18,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class InjectedType_Factory implements Factory<InjectedType> { private final Provider<Integer> primitiveIntProvider; diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_injectsPrimitive_FAST_INIT_MODE_test.InjectedType_MembersInjector b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_injectsPrimitive_FAST_INIT_MODE_test.InjectedType_MembersInjector index 91f6586b4..f28869798 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_injectsPrimitive_FAST_INIT_MODE_test.InjectedType_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_injectsPrimitive_FAST_INIT_MODE_test.InjectedType_MembersInjector @@ -17,7 +17,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class InjectedType_MembersInjector implements MembersInjector<InjectedType> { private final Provider<Integer> primitiveIntProvider; diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_methodInjection_DEFAULT_MODE_test.MethodInjection_MembersInjector b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_methodInjection_DEFAULT_MODE_test.MethodInjection_MembersInjector index 3fcbb904b..9d11248f0 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_methodInjection_DEFAULT_MODE_test.MethodInjection_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_methodInjection_DEFAULT_MODE_test.MethodInjection_MembersInjector @@ -18,7 +18,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class MethodInjection_MembersInjector implements MembersInjector<MethodInjection> { private final Provider<String> stringProvider; diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_methodInjection_FAST_INIT_MODE_test.MethodInjection_MembersInjector b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_methodInjection_FAST_INIT_MODE_test.MethodInjection_MembersInjector index 3fcbb904b..9d11248f0 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_methodInjection_FAST_INIT_MODE_test.MethodInjection_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_methodInjection_FAST_INIT_MODE_test.MethodInjection_MembersInjector @@ -18,7 +18,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class MethodInjection_MembersInjector implements MembersInjector<MethodInjection> { private final Provider<String> stringProvider; diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_middleClassNoFieldInjection_DEFAULT_MODE_test.A_MembersInjector b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_middleClassNoFieldInjection_DEFAULT_MODE_test.A_MembersInjector index f06dabebe..86589c7a2 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_middleClassNoFieldInjection_DEFAULT_MODE_test.A_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_middleClassNoFieldInjection_DEFAULT_MODE_test.A_MembersInjector @@ -17,7 +17,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class A_MembersInjector implements MembersInjector<A> { private final Provider<String> valueCProvider; diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_middleClassNoFieldInjection_DEFAULT_MODE_test.C_MembersInjector b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_middleClassNoFieldInjection_DEFAULT_MODE_test.C_MembersInjector index 1b862a731..9c181789c 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_middleClassNoFieldInjection_DEFAULT_MODE_test.C_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_middleClassNoFieldInjection_DEFAULT_MODE_test.C_MembersInjector @@ -17,7 +17,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class C_MembersInjector implements MembersInjector<C> { private final Provider<String> valueCProvider; diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_middleClassNoFieldInjection_FAST_INIT_MODE_test.A_MembersInjector b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_middleClassNoFieldInjection_FAST_INIT_MODE_test.A_MembersInjector index f06dabebe..86589c7a2 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_middleClassNoFieldInjection_FAST_INIT_MODE_test.A_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_middleClassNoFieldInjection_FAST_INIT_MODE_test.A_MembersInjector @@ -17,7 +17,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class A_MembersInjector implements MembersInjector<A> { private final Provider<String> valueCProvider; diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_middleClassNoFieldInjection_FAST_INIT_MODE_test.C_MembersInjector b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_middleClassNoFieldInjection_FAST_INIT_MODE_test.C_MembersInjector index 1b862a731..9c181789c 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_middleClassNoFieldInjection_FAST_INIT_MODE_test.C_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_middleClassNoFieldInjection_FAST_INIT_MODE_test.C_MembersInjector @@ -17,7 +17,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class C_MembersInjector implements MembersInjector<C> { private final Provider<String> valueCProvider; diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_mixedMemberInjection_DEFAULT_MODE_test.MixedMemberInjection_MembersInjector b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_mixedMemberInjection_DEFAULT_MODE_test.MixedMemberInjection_MembersInjector index e12de5ca8..ba590b851 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_mixedMemberInjection_DEFAULT_MODE_test.MixedMemberInjection_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_mixedMemberInjection_DEFAULT_MODE_test.MixedMemberInjection_MembersInjector @@ -17,7 +17,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class MixedMemberInjection_MembersInjector implements MembersInjector<MixedMemberInjection> { private final Provider<String> stringProvider; diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_mixedMemberInjection_FAST_INIT_MODE_test.MixedMemberInjection_MembersInjector b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_mixedMemberInjection_FAST_INIT_MODE_test.MixedMemberInjection_MembersInjector index e12de5ca8..ba590b851 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_mixedMemberInjection_FAST_INIT_MODE_test.MixedMemberInjection_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_mixedMemberInjection_FAST_INIT_MODE_test.MixedMemberInjection_MembersInjector @@ -17,7 +17,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class MixedMemberInjection_MembersInjector implements MembersInjector<MixedMemberInjection> { private final Provider<String> stringProvider; diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_parentClass_injectedMembersInSupertype_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_parentClass_injectedMembersInSupertype_DEFAULT_MODE_test.DaggerTestComponent index 2bcafb9b7..88e7fa573 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_parentClass_injectedMembersInSupertype_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_parentClass_injectedMembersInSupertype_DEFAULT_MODE_test.DaggerTestComponent @@ -13,7 +13,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_parentClass_injectedMembersInSupertype_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_parentClass_injectedMembersInSupertype_FAST_INIT_MODE_test.DaggerTestComponent index 2bcafb9b7..88e7fa573 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_parentClass_injectedMembersInSupertype_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_parentClass_injectedMembersInSupertype_FAST_INIT_MODE_test.DaggerTestComponent @@ -13,7 +13,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_parentClass_noInjectedMembers_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_parentClass_noInjectedMembers_DEFAULT_MODE_test.DaggerTestComponent index 9549f7be5..c4c4b0759 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_parentClass_noInjectedMembers_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_parentClass_noInjectedMembers_DEFAULT_MODE_test.DaggerTestComponent @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_parentClass_noInjectedMembers_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_parentClass_noInjectedMembers_FAST_INIT_MODE_test.DaggerTestComponent index 9549f7be5..c4c4b0759 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_parentClass_noInjectedMembers_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_parentClass_noInjectedMembers_FAST_INIT_MODE_test.DaggerTestComponent @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_publicSupertypeHiddenSubtype_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_publicSupertypeHiddenSubtype_DEFAULT_MODE_test.DaggerTestComponent index 560506bf0..04a41311e 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_publicSupertypeHiddenSubtype_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_publicSupertypeHiddenSubtype_DEFAULT_MODE_test.DaggerTestComponent @@ -19,7 +19,8 @@ import other.Supertype_MembersInjector; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_publicSupertypeHiddenSubtype_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_publicSupertypeHiddenSubtype_FAST_INIT_MODE_test.DaggerTestComponent index 560506bf0..04a41311e 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_publicSupertypeHiddenSubtype_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_publicSupertypeHiddenSubtype_FAST_INIT_MODE_test.DaggerTestComponent @@ -19,7 +19,8 @@ import other.Supertype_MembersInjector; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_simpleComponentWithNesting_DEFAULT_MODE_test.OuterType_B_MembersInjector b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_simpleComponentWithNesting_DEFAULT_MODE_test.OuterType_B_MembersInjector index 72b876ef0..5b4932f1c 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_simpleComponentWithNesting_DEFAULT_MODE_test.OuterType_B_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_simpleComponentWithNesting_DEFAULT_MODE_test.OuterType_B_MembersInjector @@ -17,7 +17,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class OuterType_B_MembersInjector implements MembersInjector<OuterType.B> { private final Provider<OuterType.A> aProvider; diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_simpleComponentWithNesting_FAST_INIT_MODE_test.OuterType_B_MembersInjector b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_simpleComponentWithNesting_FAST_INIT_MODE_test.OuterType_B_MembersInjector index 72b876ef0..5b4932f1c 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_simpleComponentWithNesting_FAST_INIT_MODE_test.OuterType_B_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_simpleComponentWithNesting_FAST_INIT_MODE_test.OuterType_B_MembersInjector @@ -17,7 +17,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class OuterType_B_MembersInjector implements MembersInjector<OuterType.B> { private final Provider<OuterType.A> aProvider; diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_subclassedGenericMembersInjectors_DEFAULT_MODE_test.Child_MembersInjector b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_subclassedGenericMembersInjectors_DEFAULT_MODE_test.Child_MembersInjector index 19d0335fd..6040966cf 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_subclassedGenericMembersInjectors_DEFAULT_MODE_test.Child_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_subclassedGenericMembersInjectors_DEFAULT_MODE_test.Child_MembersInjector @@ -17,7 +17,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class Child_MembersInjector<T> implements MembersInjector<Child<T>> { private final Provider<T> xProvider; diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_subclassedGenericMembersInjectors_FAST_INIT_MODE_test.Child_MembersInjector b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_subclassedGenericMembersInjectors_FAST_INIT_MODE_test.Child_MembersInjector index 19d0335fd..6040966cf 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_subclassedGenericMembersInjectors_FAST_INIT_MODE_test.Child_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_subclassedGenericMembersInjectors_FAST_INIT_MODE_test.Child_MembersInjector @@ -17,7 +17,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class Child_MembersInjector<T> implements MembersInjector<Child<T>> { private final Provider<T> xProvider; diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_supertypeMembersInjection_DEFAULT_MODE_test.B_MembersInjector b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_supertypeMembersInjection_DEFAULT_MODE_test.B_MembersInjector index 048997088..01f787bd0 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_supertypeMembersInjection_DEFAULT_MODE_test.B_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_supertypeMembersInjection_DEFAULT_MODE_test.B_MembersInjector @@ -17,7 +17,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class B_MembersInjector implements MembersInjector<B> { private final Provider<String> sProvider; diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_supertypeMembersInjection_FAST_INIT_MODE_test.B_MembersInjector b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_supertypeMembersInjection_FAST_INIT_MODE_test.B_MembersInjector index 048997088..01f787bd0 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_supertypeMembersInjection_FAST_INIT_MODE_test.B_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_supertypeMembersInjection_FAST_INIT_MODE_test.B_MembersInjector @@ -17,7 +17,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class B_MembersInjector implements MembersInjector<B> { private final Provider<String> sProvider; diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_testConstructorInjectedFieldInjection_DEFAULT_MODE_test.A_MembersInjector b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_testConstructorInjectedFieldInjection_DEFAULT_MODE_test.A_MembersInjector index 5db62ea1f..f12625126 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_testConstructorInjectedFieldInjection_DEFAULT_MODE_test.A_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_testConstructorInjectedFieldInjection_DEFAULT_MODE_test.A_MembersInjector @@ -16,7 +16,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class A_MembersInjector implements MembersInjector<A> { private final Provider<String> valueBProvider; diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_testConstructorInjectedFieldInjection_DEFAULT_MODE_test.B_MembersInjector b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_testConstructorInjectedFieldInjection_DEFAULT_MODE_test.B_MembersInjector index 6a818515c..192947e29 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_testConstructorInjectedFieldInjection_DEFAULT_MODE_test.B_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_testConstructorInjectedFieldInjection_DEFAULT_MODE_test.B_MembersInjector @@ -17,7 +17,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class B_MembersInjector implements MembersInjector<B> { private final Provider<String> valueBProvider; diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_testConstructorInjectedFieldInjection_FAST_INIT_MODE_test.A_MembersInjector b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_testConstructorInjectedFieldInjection_FAST_INIT_MODE_test.A_MembersInjector index 5db62ea1f..f12625126 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_testConstructorInjectedFieldInjection_FAST_INIT_MODE_test.A_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_testConstructorInjectedFieldInjection_FAST_INIT_MODE_test.A_MembersInjector @@ -16,7 +16,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class A_MembersInjector implements MembersInjector<A> { private final Provider<String> valueBProvider; diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_testConstructorInjectedFieldInjection_FAST_INIT_MODE_test.B_MembersInjector b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_testConstructorInjectedFieldInjection_FAST_INIT_MODE_test.B_MembersInjector index 6a818515c..192947e29 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_testConstructorInjectedFieldInjection_FAST_INIT_MODE_test.B_MembersInjector +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_testConstructorInjectedFieldInjection_FAST_INIT_MODE_test.B_MembersInjector @@ -17,7 +17,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class B_MembersInjector implements MembersInjector<B> { private final Provider<String> valueBProvider; diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_testMembersInjectionBindingExistsInParentComponent_DEFAULT_MODE_test.DaggerMyComponent b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_testMembersInjectionBindingExistsInParentComponent_DEFAULT_MODE_test.DaggerMyComponent index c20059fe4..c563a1a1b 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_testMembersInjectionBindingExistsInParentComponent_DEFAULT_MODE_test.DaggerMyComponent +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_testMembersInjectionBindingExistsInParentComponent_DEFAULT_MODE_test.DaggerMyComponent @@ -15,7 +15,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class DaggerMyComponent { private DaggerMyComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_testMembersInjectionBindingExistsInParentComponent_FAST_INIT_MODE_test.DaggerMyComponent b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_testMembersInjectionBindingExistsInParentComponent_FAST_INIT_MODE_test.DaggerMyComponent index c20059fe4..c563a1a1b 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_testMembersInjectionBindingExistsInParentComponent_FAST_INIT_MODE_test.DaggerMyComponent +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_testMembersInjectionBindingExistsInParentComponent_FAST_INIT_MODE_test.DaggerMyComponent @@ -15,7 +15,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class DaggerMyComponent { private DaggerMyComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_testMembersInjectionBindingSharesInjectMethodsWithProvisionBinding_DEFAULT_MODE_test.DaggerMyComponent b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_testMembersInjectionBindingSharesInjectMethodsWithProvisionBinding_DEFAULT_MODE_test.DaggerMyComponent index a352ab616..72140b34b 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_testMembersInjectionBindingSharesInjectMethodsWithProvisionBinding_DEFAULT_MODE_test.DaggerMyComponent +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_testMembersInjectionBindingSharesInjectMethodsWithProvisionBinding_DEFAULT_MODE_test.DaggerMyComponent @@ -13,7 +13,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class DaggerMyComponent { private DaggerMyComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_testMembersInjectionBindingSharesInjectMethodsWithProvisionBinding_FAST_INIT_MODE_test.DaggerMyComponent b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_testMembersInjectionBindingSharesInjectMethodsWithProvisionBinding_FAST_INIT_MODE_test.DaggerMyComponent index a352ab616..72140b34b 100644 --- a/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_testMembersInjectionBindingSharesInjectMethodsWithProvisionBinding_FAST_INIT_MODE_test.DaggerMyComponent +++ b/javatests/dagger/internal/codegen/goldens/MembersInjectionTest_testMembersInjectionBindingSharesInjectMethodsWithProvisionBinding_FAST_INIT_MODE_test.DaggerMyComponent @@ -13,7 +13,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class DaggerMyComponent { private DaggerMyComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_genericSubclassedModule_test.ChildIntegerModule_ProvideIntegerFactory b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_genericSubclassedModule_test.ChildIntegerModule_ProvideIntegerFactory index 622314a01..8b9a451f2 100644 --- a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_genericSubclassedModule_test.ChildIntegerModule_ProvideIntegerFactory +++ b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_genericSubclassedModule_test.ChildIntegerModule_ProvideIntegerFactory @@ -18,7 +18,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class ChildIntegerModule_ProvideIntegerFactory implements Factory<Integer> { private final ChildIntegerModule module; diff --git a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_genericSubclassedModule_test.ChildNumberModule_ProvideNumberFactory b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_genericSubclassedModule_test.ChildNumberModule_ProvideNumberFactory index b9067499f..d662cc604 100644 --- a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_genericSubclassedModule_test.ChildNumberModule_ProvideNumberFactory +++ b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_genericSubclassedModule_test.ChildNumberModule_ProvideNumberFactory @@ -18,7 +18,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class ChildNumberModule_ProvideNumberFactory implements Factory<Number> { private final ChildNumberModule module; diff --git a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_genericSubclassedModule_test.ParentModule_ProvideBElementFactory b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_genericSubclassedModule_test.ParentModule_ProvideBElementFactory index 967f5f222..d669e2a92 100644 --- a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_genericSubclassedModule_test.ParentModule_ProvideBElementFactory +++ b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_genericSubclassedModule_test.ParentModule_ProvideBElementFactory @@ -19,7 +19,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class ParentModule_ProvideBElementFactory<A extends CharSequence, B, C extends Number & Comparable<C>> implements Factory<B> { private final ParentModule<A, B, C> module; diff --git a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_genericSubclassedModule_test.ParentModule_ProvideBEntryFactory b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_genericSubclassedModule_test.ParentModule_ProvideBEntryFactory index d518c0505..35052f405 100644 --- a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_genericSubclassedModule_test.ParentModule_ProvideBEntryFactory +++ b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_genericSubclassedModule_test.ParentModule_ProvideBEntryFactory @@ -19,7 +19,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class ParentModule_ProvideBEntryFactory<A extends CharSequence, B, C extends Number & Comparable<C>> implements Factory<B> { private final ParentModule<A, B, C> module; diff --git a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_genericSubclassedModule_test.ParentModule_ProvideListBFactory b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_genericSubclassedModule_test.ParentModule_ProvideListBFactory index 405bdda7d..a36bf2620 100644 --- a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_genericSubclassedModule_test.ParentModule_ProvideListBFactory +++ b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_genericSubclassedModule_test.ParentModule_ProvideListBFactory @@ -20,7 +20,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class ParentModule_ProvideListBFactory<A extends CharSequence, B, C extends Number & Comparable<C>> implements Factory<List<B>> { private final ParentModule<A, B, C> module; diff --git a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_multipleProvidesMethods_test.TestModule_ProvideObjectsFactory b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_multipleProvidesMethods_test.TestModule_ProvideObjectsFactory index d0147f70d..63ae5bf3d 100644 --- a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_multipleProvidesMethods_test.TestModule_ProvideObjectsFactory +++ b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_multipleProvidesMethods_test.TestModule_ProvideObjectsFactory @@ -24,7 +24,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class TestModule_ProvideObjectsFactory implements Factory<List<Object>> { private final TestModule module; diff --git a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_nullableProvides_test.TestModule_ProvideStringFactory b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_nullableProvides_test.TestModule_ProvideStringFactory index cbc4dc1f8..8e3b1cd13 100644 --- a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_nullableProvides_test.TestModule_ProvideStringFactory +++ b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_nullableProvides_test.TestModule_ProvideStringFactory @@ -17,7 +17,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class TestModule_ProvideStringFactory implements Factory<String> { private final TestModule module; diff --git a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_parameterizedModuleWithStaticProvidesMethodOfGenericType_test.ParameterizedModule_ProvideMapStringNumberFactory b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_parameterizedModuleWithStaticProvidesMethodOfGenericType_test.ParameterizedModule_ProvideMapStringNumberFactory index 397def820..9185ad3dc 100644 --- a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_parameterizedModuleWithStaticProvidesMethodOfGenericType_test.ParameterizedModule_ProvideMapStringNumberFactory +++ b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_parameterizedModuleWithStaticProvidesMethodOfGenericType_test.ParameterizedModule_ProvideMapStringNumberFactory @@ -19,7 +19,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class ParameterizedModule_ProvideMapStringNumberFactory implements Factory<Map<String, Number>> { @Override diff --git a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_parameterizedModuleWithStaticProvidesMethodOfGenericType_test.ParameterizedModule_ProvideNonGenericTypeFactory b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_parameterizedModuleWithStaticProvidesMethodOfGenericType_test.ParameterizedModule_ProvideNonGenericTypeFactory index c5a0f3092..29bea60b7 100644 --- a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_parameterizedModuleWithStaticProvidesMethodOfGenericType_test.ParameterizedModule_ProvideNonGenericTypeFactory +++ b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_parameterizedModuleWithStaticProvidesMethodOfGenericType_test.ParameterizedModule_ProvideNonGenericTypeFactory @@ -18,7 +18,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class ParameterizedModule_ProvideNonGenericTypeFactory implements Factory<Object> { @Override diff --git a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_parameterizedModuleWithStaticProvidesMethodOfGenericType_test.ParameterizedModule_ProvideNonGenericTypeWithDepsFactory b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_parameterizedModuleWithStaticProvidesMethodOfGenericType_test.ParameterizedModule_ProvideNonGenericTypeWithDepsFactory index 019f5f266..4f9137642 100644 --- a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_parameterizedModuleWithStaticProvidesMethodOfGenericType_test.ParameterizedModule_ProvideNonGenericTypeWithDepsFactory +++ b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_parameterizedModuleWithStaticProvidesMethodOfGenericType_test.ParameterizedModule_ProvideNonGenericTypeWithDepsFactory @@ -19,7 +19,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class ParameterizedModule_ProvideNonGenericTypeWithDepsFactory implements Factory<String> { private final Provider<Object> oProvider; diff --git a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_providesSetElementWildcard_test.TestModule_ProvideWildcardListFactory b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_providesSetElementWildcard_test.TestModule_ProvideWildcardListFactory index bb66ad317..6fabfaa79 100644 --- a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_providesSetElementWildcard_test.TestModule_ProvideWildcardListFactory +++ b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_providesSetElementWildcard_test.TestModule_ProvideWildcardListFactory @@ -19,7 +19,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class TestModule_ProvideWildcardListFactory implements Factory<List<List<?>>> { private final TestModule module; diff --git a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_providesSetElement_test.TestModule_ProvideStringFactory b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_providesSetElement_test.TestModule_ProvideStringFactory index 835bb72f8..6675a4129 100644 --- a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_providesSetElement_test.TestModule_ProvideStringFactory +++ b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_providesSetElement_test.TestModule_ProvideStringFactory @@ -18,7 +18,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class TestModule_ProvideStringFactory implements Factory<String> { private final TestModule module; diff --git a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_providesSetValues_test.TestModule_ProvideStringsFactory b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_providesSetValues_test.TestModule_ProvideStringsFactory index 459a1a8a7..240620f55 100644 --- a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_providesSetValues_test.TestModule_ProvideStringsFactory +++ b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_providesSetValues_test.TestModule_ProvideStringsFactory @@ -19,7 +19,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class TestModule_ProvideStringsFactory implements Factory<Set<String>> { private final TestModule module; diff --git a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_proxyMethodsConflictWithOtherFactoryMethods_test.TestModule_CreateFactory b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_proxyMethodsConflictWithOtherFactoryMethods_test.TestModule_CreateFactory index 061a827ee..9250da8c0 100644 --- a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_proxyMethodsConflictWithOtherFactoryMethods_test.TestModule_CreateFactory +++ b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_proxyMethodsConflictWithOtherFactoryMethods_test.TestModule_CreateFactory @@ -17,7 +17,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class TestModule_CreateFactory implements Factory<Boolean> { @Override diff --git a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_proxyMethodsConflictWithOtherFactoryMethods_test.TestModule_GetFactory b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_proxyMethodsConflictWithOtherFactoryMethods_test.TestModule_GetFactory index 7d9d3c5ca..52eb22859 100644 --- a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_proxyMethodsConflictWithOtherFactoryMethods_test.TestModule_GetFactory +++ b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_proxyMethodsConflictWithOtherFactoryMethods_test.TestModule_GetFactory @@ -17,7 +17,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class TestModule_GetFactory implements Factory<Integer> { @Override diff --git a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_singleProvidesMethodNoArgs_disableNullable_test.TestModule_ProvideStringFactory b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_singleProvidesMethodNoArgs_disableNullable_test.TestModule_ProvideStringFactory index 4515d0aad..975588734 100644 --- a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_singleProvidesMethodNoArgs_disableNullable_test.TestModule_ProvideStringFactory +++ b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_singleProvidesMethodNoArgs_disableNullable_test.TestModule_ProvideStringFactory @@ -17,7 +17,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class TestModule_ProvideStringFactory implements Factory<String> { private final TestModule module; diff --git a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_singleProvidesMethodNoArgs_test.TestModule_ProvideStringFactory b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_singleProvidesMethodNoArgs_test.TestModule_ProvideStringFactory index 835bb72f8..6675a4129 100644 --- a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_singleProvidesMethodNoArgs_test.TestModule_ProvideStringFactory +++ b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_singleProvidesMethodNoArgs_test.TestModule_ProvideStringFactory @@ -18,7 +18,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class TestModule_ProvideStringFactory implements Factory<String> { private final TestModule module; diff --git a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_testQualifierMetadataOnProvides_test.MyModule_ProvideStringFactory b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_testQualifierMetadataOnProvides_test.MyModule_ProvideStringFactory index 64da8b3eb..e62e7b9b0 100644 --- a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_testQualifierMetadataOnProvides_test.MyModule_ProvideStringFactory +++ b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_testQualifierMetadataOnProvides_test.MyModule_ProvideStringFactory @@ -22,7 +22,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class MyModule_ProvideStringFactory implements Factory<String> { private final Provider<Integer> iProvider; diff --git a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_testScopeMetadataWithCustomScope_test.MyModule_ProvideStringFactory b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_testScopeMetadataWithCustomScope_test.MyModule_ProvideStringFactory index d9b71ef85..8ec360d2d 100644 --- a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_testScopeMetadataWithCustomScope_test.MyModule_ProvideStringFactory +++ b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_testScopeMetadataWithCustomScope_test.MyModule_ProvideStringFactory @@ -18,7 +18,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class MyModule_ProvideStringFactory implements Factory<String> { @Override diff --git a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_testScopedMetadataOnNonStaticProvides_test.MyModule_ProvideStringFactory b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_testScopedMetadataOnNonStaticProvides_test.MyModule_ProvideStringFactory index bd6c23753..e5a04c565 100644 --- a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_testScopedMetadataOnNonStaticProvides_test.MyModule_ProvideStringFactory +++ b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_testScopedMetadataOnNonStaticProvides_test.MyModule_ProvideStringFactory @@ -18,7 +18,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class MyModule_ProvideStringFactory implements Factory<String> { private final MyModule module; diff --git a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_testScopedMetadataOnStaticProvides_test.MyModule_ProvideStringFactory b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_testScopedMetadataOnStaticProvides_test.MyModule_ProvideStringFactory index 591f9ac4f..b88b3e345 100644 --- a/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_testScopedMetadataOnStaticProvides_test.MyModule_ProvideStringFactory +++ b/javatests/dagger/internal/codegen/goldens/ModuleFactoryGeneratorTest_testScopedMetadataOnStaticProvides_test.MyModule_ProvideStringFactory @@ -18,7 +18,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class MyModule_ProvideStringFactory implements Factory<String> { @Override diff --git a/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_inlinedOptionalBindings_DEFAULT_JAVA7_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_inlinedOptionalBindings_DEFAULT_JAVA7_MODE_test.DaggerTestComponent index 3f21b64db..37c1bb80f 100644 --- a/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_inlinedOptionalBindings_DEFAULT_JAVA7_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_inlinedOptionalBindings_DEFAULT_JAVA7_MODE_test.DaggerTestComponent @@ -3,7 +3,6 @@ package test; import com.google.common.base.Optional; import dagger.Lazy; import dagger.internal.DaggerGenerated; -import dagger.internal.Preconditions; import dagger.internal.ProviderOfLazy; import javax.annotation.Generated; import javax.inject.Provider; @@ -20,7 +19,8 @@ import other.Maybe_MaybeModule_ProvideMaybeFactory; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -38,15 +38,6 @@ final class DaggerTestComponent { private Builder() { } - /** - * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://dagger.dev/unused-modules. - */ - @Deprecated - public Builder maybeModule(Maybe.MaybeModule maybeModule) { - Preconditions.checkNotNull(maybeModule); - return this; - } - public TestComponent build() { return new TestComponentImpl(); } @@ -67,7 +58,7 @@ final class DaggerTestComponent { @Override public Optional<Provider<Lazy<Maybe>>> providerOfLazyOfMaybe() { - return Optional.of(ProviderOfLazy.create(Maybe_MaybeModule_ProvideMaybeFactory.create())); + return (Optional) Optional.of(ProviderOfLazy.create(Maybe_MaybeModule_ProvideMaybeFactory.create())); } @Override @@ -77,7 +68,7 @@ final class DaggerTestComponent { @Override public Optional<Provider<Lazy<DefinitelyNot>>> providerOfLazyOfDefinitelyNot() { - return Optional.<Provider<Lazy<DefinitelyNot>>>absent(); + return (Optional) Optional.<Provider<Lazy<DefinitelyNot>>>absent(); } } } diff --git a/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_inlinedOptionalBindings_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_inlinedOptionalBindings_DEFAULT_MODE_test.DaggerTestComponent index 72d51f348..0884286cb 100644 --- a/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_inlinedOptionalBindings_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_inlinedOptionalBindings_DEFAULT_MODE_test.DaggerTestComponent @@ -3,7 +3,6 @@ package test; import com.google.common.base.Optional; import dagger.Lazy; import dagger.internal.DaggerGenerated; -import dagger.internal.Preconditions; import dagger.internal.ProviderOfLazy; import javax.annotation.processing.Generated; import javax.inject.Provider; @@ -20,7 +19,8 @@ import other.Maybe_MaybeModule_ProvideMaybeFactory; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -38,15 +38,6 @@ final class DaggerTestComponent { private Builder() { } - /** - * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://dagger.dev/unused-modules. - */ - @Deprecated - public Builder maybeModule(Maybe.MaybeModule maybeModule) { - Preconditions.checkNotNull(maybeModule); - return this; - } - public TestComponent build() { return new TestComponentImpl(); } diff --git a/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_inlinedOptionalBindings_FAST_INIT_JAVA7_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_inlinedOptionalBindings_FAST_INIT_JAVA7_MODE_test.DaggerTestComponent index f99b125cc..f1ab21401 100644 --- a/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_inlinedOptionalBindings_FAST_INIT_JAVA7_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_inlinedOptionalBindings_FAST_INIT_JAVA7_MODE_test.DaggerTestComponent @@ -3,10 +3,9 @@ package test; import com.google.common.base.Optional; import dagger.Lazy; import dagger.internal.DaggerGenerated; -import dagger.internal.Preconditions; +import dagger.internal.Provider; import dagger.internal.ProviderOfLazy; import javax.annotation.Generated; -import javax.inject.Provider; import other.DefinitelyNot; import other.Maybe; import other.Maybe_MaybeModule_ProvideMaybeFactory; @@ -20,7 +19,8 @@ import other.Maybe_MaybeModule_ProvideMaybeFactory; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -38,15 +38,6 @@ final class DaggerTestComponent { private Builder() { } - /** - * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://dagger.dev/unused-modules. - */ - @Deprecated - public Builder maybeModule(Maybe.MaybeModule maybeModule) { - Preconditions.checkNotNull(maybeModule); - return this; - } - public TestComponent build() { return new TestComponentImpl(); } @@ -74,8 +65,8 @@ final class DaggerTestComponent { } @Override - public Optional<Provider<Lazy<Maybe>>> providerOfLazyOfMaybe() { - return Optional.of(ProviderOfLazy.create(provideMaybeProvider)); + public Optional<javax.inject.Provider<Lazy<Maybe>>> providerOfLazyOfMaybe() { + return (Optional) Optional.of(ProviderOfLazy.create(provideMaybeProvider)); } @Override @@ -84,8 +75,8 @@ final class DaggerTestComponent { } @Override - public Optional<Provider<Lazy<DefinitelyNot>>> providerOfLazyOfDefinitelyNot() { - return Optional.<Provider<Lazy<DefinitelyNot>>>absent(); + public Optional<javax.inject.Provider<Lazy<DefinitelyNot>>> providerOfLazyOfDefinitelyNot() { + return (Optional) Optional.<javax.inject.Provider<Lazy<DefinitelyNot>>>absent(); } private static final class SwitchingProvider<T> implements Provider<T> { diff --git a/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_inlinedOptionalBindings_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_inlinedOptionalBindings_FAST_INIT_MODE_test.DaggerTestComponent index 5d4406344..83b8f8114 100644 --- a/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_inlinedOptionalBindings_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_inlinedOptionalBindings_FAST_INIT_MODE_test.DaggerTestComponent @@ -3,10 +3,9 @@ package test; import com.google.common.base.Optional; import dagger.Lazy; import dagger.internal.DaggerGenerated; -import dagger.internal.Preconditions; +import dagger.internal.Provider; import dagger.internal.ProviderOfLazy; import javax.annotation.processing.Generated; -import javax.inject.Provider; import other.DefinitelyNot; import other.Maybe; import other.Maybe_MaybeModule_ProvideMaybeFactory; @@ -20,7 +19,8 @@ import other.Maybe_MaybeModule_ProvideMaybeFactory; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -38,15 +38,6 @@ final class DaggerTestComponent { private Builder() { } - /** - * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://dagger.dev/unused-modules. - */ - @Deprecated - public Builder maybeModule(Maybe.MaybeModule maybeModule) { - Preconditions.checkNotNull(maybeModule); - return this; - } - public TestComponent build() { return new TestComponentImpl(); } @@ -74,7 +65,7 @@ final class DaggerTestComponent { } @Override - public Optional<Provider<Lazy<Maybe>>> providerOfLazyOfMaybe() { + public Optional<javax.inject.Provider<Lazy<Maybe>>> providerOfLazyOfMaybe() { return Optional.of(ProviderOfLazy.create(provideMaybeProvider)); } @@ -84,7 +75,7 @@ final class DaggerTestComponent { } @Override - public Optional<Provider<Lazy<DefinitelyNot>>> providerOfLazyOfDefinitelyNot() { + public Optional<javax.inject.Provider<Lazy<DefinitelyNot>>> providerOfLazyOfDefinitelyNot() { return Optional.absent(); } diff --git a/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_requestForFuture_DEFAULT_JAVA7_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_requestForFuture_DEFAULT_JAVA7_MODE_test.DaggerTestComponent index 7325da92c..9d278cb34 100644 --- a/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_requestForFuture_DEFAULT_JAVA7_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_requestForFuture_DEFAULT_JAVA7_MODE_test.DaggerTestComponent @@ -4,7 +4,6 @@ import com.google.common.base.Optional; import com.google.common.util.concurrent.Futures; import com.google.common.util.concurrent.ListenableFuture; import dagger.internal.DaggerGenerated; -import dagger.internal.Preconditions; import dagger.producers.internal.CancellationListener; import javax.annotation.Generated; import other.DefinitelyNot; @@ -20,7 +19,8 @@ import other.Maybe_MaybeModule_ProvideMaybeFactory; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -38,15 +38,6 @@ final class DaggerTestComponent { private Builder() { } - /** - * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://dagger.dev/unused-modules. - */ - @Deprecated - public Builder maybeModule(Maybe.MaybeModule maybeModule) { - Preconditions.checkNotNull(maybeModule); - return this; - } - public TestComponent build() { return new TestComponentImpl(); } diff --git a/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_requestForFuture_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_requestForFuture_DEFAULT_MODE_test.DaggerTestComponent index 0e2bb0f67..e6e1d5aab 100644 --- a/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_requestForFuture_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_requestForFuture_DEFAULT_MODE_test.DaggerTestComponent @@ -4,7 +4,6 @@ import com.google.common.base.Optional; import com.google.common.util.concurrent.Futures; import com.google.common.util.concurrent.ListenableFuture; import dagger.internal.DaggerGenerated; -import dagger.internal.Preconditions; import dagger.producers.internal.CancellationListener; import javax.annotation.processing.Generated; import other.DefinitelyNot; @@ -20,7 +19,8 @@ import other.Maybe_MaybeModule_ProvideMaybeFactory; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -38,15 +38,6 @@ final class DaggerTestComponent { private Builder() { } - /** - * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://dagger.dev/unused-modules. - */ - @Deprecated - public Builder maybeModule(Maybe.MaybeModule maybeModule) { - Preconditions.checkNotNull(maybeModule); - return this; - } - public TestComponent build() { return new TestComponentImpl(); } diff --git a/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_requestForFuture_FAST_INIT_JAVA7_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_requestForFuture_FAST_INIT_JAVA7_MODE_test.DaggerTestComponent index 7325da92c..9d278cb34 100644 --- a/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_requestForFuture_FAST_INIT_JAVA7_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_requestForFuture_FAST_INIT_JAVA7_MODE_test.DaggerTestComponent @@ -4,7 +4,6 @@ import com.google.common.base.Optional; import com.google.common.util.concurrent.Futures; import com.google.common.util.concurrent.ListenableFuture; import dagger.internal.DaggerGenerated; -import dagger.internal.Preconditions; import dagger.producers.internal.CancellationListener; import javax.annotation.Generated; import other.DefinitelyNot; @@ -20,7 +19,8 @@ import other.Maybe_MaybeModule_ProvideMaybeFactory; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -38,15 +38,6 @@ final class DaggerTestComponent { private Builder() { } - /** - * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://dagger.dev/unused-modules. - */ - @Deprecated - public Builder maybeModule(Maybe.MaybeModule maybeModule) { - Preconditions.checkNotNull(maybeModule); - return this; - } - public TestComponent build() { return new TestComponentImpl(); } diff --git a/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_requestForFuture_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_requestForFuture_FAST_INIT_MODE_test.DaggerTestComponent index 0e2bb0f67..e6e1d5aab 100644 --- a/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_requestForFuture_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/OptionalBindingRequestFulfillmentTest_requestForFuture_FAST_INIT_MODE_test.DaggerTestComponent @@ -4,7 +4,6 @@ import com.google.common.base.Optional; import com.google.common.util.concurrent.Futures; import com.google.common.util.concurrent.ListenableFuture; import dagger.internal.DaggerGenerated; -import dagger.internal.Preconditions; import dagger.producers.internal.CancellationListener; import javax.annotation.processing.Generated; import other.DefinitelyNot; @@ -20,7 +19,8 @@ import other.Maybe_MaybeModule_ProvideMaybeFactory; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -38,15 +38,6 @@ final class DaggerTestComponent { private Builder() { } - /** - * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://dagger.dev/unused-modules. - */ - @Deprecated - public Builder maybeModule(Maybe.MaybeModule maybeModule) { - Preconditions.checkNotNull(maybeModule); - return this; - } - public TestComponent build() { return new TestComponentImpl(); } diff --git a/javatests/dagger/internal/codegen/goldens/ProducerModuleFactoryGeneratorTest_singleProducesMethodNoArgsFutureWithProducerName_test.TestModule_ProduceStringFactory b/javatests/dagger/internal/codegen/goldens/ProducerModuleFactoryGeneratorTest_singleProducesMethodNoArgsFutureWithProducerName_test.TestModule_ProduceStringFactory index bf59a062c..048cdc8c3 100644 --- a/javatests/dagger/internal/codegen/goldens/ProducerModuleFactoryGeneratorTest_singleProducesMethodNoArgsFutureWithProducerName_test.TestModule_ProduceStringFactory +++ b/javatests/dagger/internal/codegen/goldens/ProducerModuleFactoryGeneratorTest_singleProducesMethodNoArgsFutureWithProducerName_test.TestModule_ProduceStringFactory @@ -20,7 +20,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class TestModule_ProduceStringFactory extends AbstractProducesMethodProducer<Void, String> { private final TestModule module; diff --git a/javatests/dagger/internal/codegen/goldens/ProducerModuleFactoryGeneratorTest_singleProducesMethodNoArgsFuture_test.TestModule_ProduceStringFactory b/javatests/dagger/internal/codegen/goldens/ProducerModuleFactoryGeneratorTest_singleProducesMethodNoArgsFuture_test.TestModule_ProduceStringFactory index cf94c2df4..248ceb1d3 100644 --- a/javatests/dagger/internal/codegen/goldens/ProducerModuleFactoryGeneratorTest_singleProducesMethodNoArgsFuture_test.TestModule_ProduceStringFactory +++ b/javatests/dagger/internal/codegen/goldens/ProducerModuleFactoryGeneratorTest_singleProducesMethodNoArgsFuture_test.TestModule_ProduceStringFactory @@ -20,7 +20,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) public final class TestModule_ProduceStringFactory extends AbstractProducesMethodProducer<Void, String> { private final TestModule module; diff --git a/javatests/dagger/internal/codegen/goldens/ProductionComponentProcessorTest_productionScope_injectConstructor_DEFAULT_MODE_test.DaggerParent b/javatests/dagger/internal/codegen/goldens/ProductionComponentProcessorTest_productionScope_injectConstructor_DEFAULT_MODE_test.DaggerParent index 11af50c5f..3b72cd404 100644 --- a/javatests/dagger/internal/codegen/goldens/ProductionComponentProcessorTest_productionScope_injectConstructor_DEFAULT_MODE_test.DaggerParent +++ b/javatests/dagger/internal/codegen/goldens/ProductionComponentProcessorTest_productionScope_injectConstructor_DEFAULT_MODE_test.DaggerParent @@ -2,9 +2,9 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import dagger.producers.internal.CancellationListener; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -15,7 +15,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerParent { private DaggerParent() { diff --git a/javatests/dagger/internal/codegen/goldens/ProductionComponentProcessorTest_productionScope_injectConstructor_FAST_INIT_MODE_test.DaggerParent b/javatests/dagger/internal/codegen/goldens/ProductionComponentProcessorTest_productionScope_injectConstructor_FAST_INIT_MODE_test.DaggerParent index 5d0b797d5..ab89babec 100644 --- a/javatests/dagger/internal/codegen/goldens/ProductionComponentProcessorTest_productionScope_injectConstructor_FAST_INIT_MODE_test.DaggerParent +++ b/javatests/dagger/internal/codegen/goldens/ProductionComponentProcessorTest_productionScope_injectConstructor_FAST_INIT_MODE_test.DaggerParent @@ -2,9 +2,9 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import dagger.producers.internal.CancellationListener; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -15,7 +15,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerParent { private DaggerParent() { diff --git a/javatests/dagger/internal/codegen/goldens/ProductionComponentProcessorTest_simpleComponent_DEFAULT_MODE_test.DaggerTestClass_SimpleComponent b/javatests/dagger/internal/codegen/goldens/ProductionComponentProcessorTest_simpleComponent_DEFAULT_MODE_test.DaggerTestClass_SimpleComponent index d55cd3735..61460047a 100644 --- a/javatests/dagger/internal/codegen/goldens/ProductionComponentProcessorTest_simpleComponent_DEFAULT_MODE_test.DaggerTestClass_SimpleComponent +++ b/javatests/dagger/internal/codegen/goldens/ProductionComponentProcessorTest_simpleComponent_DEFAULT_MODE_test.DaggerTestClass_SimpleComponent @@ -5,6 +5,7 @@ import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; import dagger.internal.InstanceFactory; import dagger.internal.Preconditions; +import dagger.internal.Provider; import dagger.internal.SetFactory; import dagger.producers.Producer; import dagger.producers.internal.CancellationListener; @@ -12,7 +13,6 @@ import dagger.producers.internal.Producers; import dagger.producers.monitoring.ProductionComponentMonitor; import java.util.concurrent.Executor; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -23,7 +23,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestClass_SimpleComponent { private DaggerTestClass_SimpleComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/ProductionComponentProcessorTest_simpleComponent_FAST_INIT_MODE_test.DaggerTestClass_SimpleComponent b/javatests/dagger/internal/codegen/goldens/ProductionComponentProcessorTest_simpleComponent_FAST_INIT_MODE_test.DaggerTestClass_SimpleComponent index 9ad6e6fa2..c5df7dce1 100644 --- a/javatests/dagger/internal/codegen/goldens/ProductionComponentProcessorTest_simpleComponent_FAST_INIT_MODE_test.DaggerTestClass_SimpleComponent +++ b/javatests/dagger/internal/codegen/goldens/ProductionComponentProcessorTest_simpleComponent_FAST_INIT_MODE_test.DaggerTestClass_SimpleComponent @@ -5,6 +5,7 @@ import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; import dagger.internal.InstanceFactory; import dagger.internal.Preconditions; +import dagger.internal.Provider; import dagger.internal.SetFactory; import dagger.producers.Producer; import dagger.producers.internal.CancellationListener; @@ -12,7 +13,6 @@ import dagger.producers.internal.Producers; import dagger.producers.monitoring.ProductionComponentMonitor; import java.util.concurrent.Executor; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -23,7 +23,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestClass_SimpleComponent { private DaggerTestClass_SimpleComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentTest_inaccessible_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentTest_inaccessible_DEFAULT_MODE_test.DaggerTestComponent index 7d8595248..988302c7e 100644 --- a/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentTest_inaccessible_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentTest_inaccessible_DEFAULT_MODE_test.DaggerTestComponent @@ -18,7 +18,8 @@ import other.UsesInaccessible_Factory; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentTest_inaccessible_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentTest_inaccessible_FAST_INIT_MODE_test.DaggerTestComponent index 7d8595248..988302c7e 100644 --- a/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentTest_inaccessible_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentTest_inaccessible_FAST_INIT_MODE_test.DaggerTestComponent @@ -18,7 +18,8 @@ import other.UsesInaccessible_Factory; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentTest_productionComponents_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentTest_productionComponents_DEFAULT_MODE_test.DaggerTestComponent index d174c1f9f..f56f0e62c 100644 --- a/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentTest_productionComponents_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentTest_productionComponents_DEFAULT_MODE_test.DaggerTestComponent @@ -17,7 +17,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentTest_productionComponents_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentTest_productionComponents_FAST_INIT_MODE_test.DaggerTestComponent index d174c1f9f..f56f0e62c 100644 --- a/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentTest_productionComponents_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentTest_productionComponents_FAST_INIT_MODE_test.DaggerTestComponent @@ -17,7 +17,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentTest_setBindings_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentTest_setBindings_DEFAULT_MODE_test.DaggerTestComponent index 829486b19..e69fffee6 100644 --- a/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentTest_setBindings_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentTest_setBindings_DEFAULT_MODE_test.DaggerTestComponent @@ -1,7 +1,6 @@ package test; import dagger.internal.DaggerGenerated; -import dagger.internal.Preconditions; import dagger.internal.SetBuilder; import java.util.Collections; import java.util.Set; @@ -16,7 +15,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -34,15 +34,6 @@ final class DaggerTestComponent { private Builder() { } - /** - * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://dagger.dev/unused-modules. - */ - @Deprecated - public Builder setModule(SetModule setModule) { - Preconditions.checkNotNull(setModule); - return this; - } - public TestComponent build() { return new TestComponentImpl(); } diff --git a/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentTest_setBindings_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentTest_setBindings_FAST_INIT_MODE_test.DaggerTestComponent index 829486b19..e69fffee6 100644 --- a/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentTest_setBindings_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentTest_setBindings_FAST_INIT_MODE_test.DaggerTestComponent @@ -1,7 +1,6 @@ package test; import dagger.internal.DaggerGenerated; -import dagger.internal.Preconditions; import dagger.internal.SetBuilder; import java.util.Collections; import java.util.Set; @@ -16,7 +15,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -34,15 +34,6 @@ final class DaggerTestComponent { private Builder() { } - /** - * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://dagger.dev/unused-modules. - */ - @Deprecated - public Builder setModule(SetModule setModule) { - Preconditions.checkNotNull(setModule); - return this; - } - public TestComponent build() { return new TestComponentImpl(); } diff --git a/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentTest_subcomponentOmitsInheritedBindings_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentTest_subcomponentOmitsInheritedBindings_DEFAULT_MODE_test.DaggerTestComponent index 24b2d569f..2ffdfd2e7 100644 --- a/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentTest_subcomponentOmitsInheritedBindings_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentTest_subcomponentOmitsInheritedBindings_DEFAULT_MODE_test.DaggerTestComponent @@ -1,7 +1,6 @@ package test; import dagger.internal.DaggerGenerated; -import dagger.internal.Preconditions; import java.util.Collections; import java.util.Set; import javax.annotation.processing.Generated; @@ -15,7 +14,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerParent { private DaggerParent() { @@ -33,15 +33,6 @@ final class DaggerParent { private Builder() { } - /** - * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://dagger.dev/unused-modules. - */ - @Deprecated - public Builder parentModule(ParentModule parentModule) { - Preconditions.checkNotNull(parentModule); - return this; - } - public Parent build() { return new ParentImpl(); } diff --git a/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentTest_subcomponentOmitsInheritedBindings_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentTest_subcomponentOmitsInheritedBindings_FAST_INIT_MODE_test.DaggerTestComponent index 24b2d569f..2ffdfd2e7 100644 --- a/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentTest_subcomponentOmitsInheritedBindings_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentTest_subcomponentOmitsInheritedBindings_FAST_INIT_MODE_test.DaggerTestComponent @@ -1,7 +1,6 @@ package test; import dagger.internal.DaggerGenerated; -import dagger.internal.Preconditions; import java.util.Collections; import java.util.Set; import javax.annotation.processing.Generated; @@ -15,7 +14,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerParent { private DaggerParent() { @@ -33,15 +33,6 @@ final class DaggerParent { private Builder() { } - /** - * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://dagger.dev/unused-modules. - */ - @Deprecated - public Builder parentModule(ParentModule parentModule) { - Preconditions.checkNotNull(parentModule); - return this; - } - public Parent build() { return new ParentImpl(); } diff --git a/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentWithGuavaTest_inaccessible_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentWithGuavaTest_inaccessible_DEFAULT_MODE_test.DaggerTestComponent index fb9fffb5d..1d16978ae 100644 --- a/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentWithGuavaTest_inaccessible_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentWithGuavaTest_inaccessible_DEFAULT_MODE_test.DaggerTestComponent @@ -17,7 +17,8 @@ import other.UsesInaccessible_Factory; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentWithGuavaTest_inaccessible_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentWithGuavaTest_inaccessible_FAST_INIT_MODE_test.DaggerTestComponent index fb9fffb5d..1d16978ae 100644 --- a/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentWithGuavaTest_inaccessible_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentWithGuavaTest_inaccessible_FAST_INIT_MODE_test.DaggerTestComponent @@ -17,7 +17,8 @@ import other.UsesInaccessible_Factory; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentWithGuavaTest_productionComponents_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentWithGuavaTest_productionComponents_DEFAULT_MODE_test.DaggerTestComponent index 5df3e4df4..a6836ce31 100644 --- a/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentWithGuavaTest_productionComponents_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentWithGuavaTest_productionComponents_DEFAULT_MODE_test.DaggerTestComponent @@ -17,7 +17,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentWithGuavaTest_productionComponents_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentWithGuavaTest_productionComponents_FAST_INIT_MODE_test.DaggerTestComponent index 5df3e4df4..a6836ce31 100644 --- a/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentWithGuavaTest_productionComponents_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentWithGuavaTest_productionComponents_FAST_INIT_MODE_test.DaggerTestComponent @@ -17,7 +17,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentWithGuavaTest_setBindings_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentWithGuavaTest_setBindings_DEFAULT_MODE_test.DaggerTestComponent index ef0830982..e2ff2df65 100644 --- a/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentWithGuavaTest_setBindings_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentWithGuavaTest_setBindings_DEFAULT_MODE_test.DaggerTestComponent @@ -2,7 +2,6 @@ package test; import com.google.common.collect.ImmutableSet; import dagger.internal.DaggerGenerated; -import dagger.internal.Preconditions; import java.util.Set; import javax.annotation.processing.Generated; @@ -15,7 +14,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -33,15 +33,6 @@ final class DaggerTestComponent { private Builder() { } - /** - * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://dagger.dev/unused-modules. - */ - @Deprecated - public Builder setModule(SetModule setModule) { - Preconditions.checkNotNull(setModule); - return this; - } - public TestComponent build() { return new TestComponentImpl(); } diff --git a/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentWithGuavaTest_setBindings_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentWithGuavaTest_setBindings_FAST_INIT_MODE_test.DaggerTestComponent index ef0830982..e2ff2df65 100644 --- a/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentWithGuavaTest_setBindings_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentWithGuavaTest_setBindings_FAST_INIT_MODE_test.DaggerTestComponent @@ -2,7 +2,6 @@ package test; import com.google.common.collect.ImmutableSet; import dagger.internal.DaggerGenerated; -import dagger.internal.Preconditions; import java.util.Set; import javax.annotation.processing.Generated; @@ -15,7 +14,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -33,15 +33,6 @@ final class DaggerTestComponent { private Builder() { } - /** - * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://dagger.dev/unused-modules. - */ - @Deprecated - public Builder setModule(SetModule setModule) { - Preconditions.checkNotNull(setModule); - return this; - } - public TestComponent build() { return new TestComponentImpl(); } diff --git a/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentWithGuavaTest_subcomponentOmitsInheritedBindings_DEFAULT_MODE_test.DaggerParent b/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentWithGuavaTest_subcomponentOmitsInheritedBindings_DEFAULT_MODE_test.DaggerParent index 36e87af44..9b03019f2 100644 --- a/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentWithGuavaTest_subcomponentOmitsInheritedBindings_DEFAULT_MODE_test.DaggerParent +++ b/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentWithGuavaTest_subcomponentOmitsInheritedBindings_DEFAULT_MODE_test.DaggerParent @@ -2,7 +2,6 @@ package test; import com.google.common.collect.ImmutableSet; import dagger.internal.DaggerGenerated; -import dagger.internal.Preconditions; import java.util.Set; import javax.annotation.processing.Generated; @@ -15,7 +14,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerParent { private DaggerParent() { @@ -33,15 +33,6 @@ final class DaggerParent { private Builder() { } - /** - * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://dagger.dev/unused-modules. - */ - @Deprecated - public Builder parentModule(ParentModule parentModule) { - Preconditions.checkNotNull(parentModule); - return this; - } - public Parent build() { return new ParentImpl(); } diff --git a/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentWithGuavaTest_subcomponentOmitsInheritedBindings_FAST_INIT_MODE_test.DaggerParent b/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentWithGuavaTest_subcomponentOmitsInheritedBindings_FAST_INIT_MODE_test.DaggerParent index 36e87af44..9b03019f2 100644 --- a/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentWithGuavaTest_subcomponentOmitsInheritedBindings_FAST_INIT_MODE_test.DaggerParent +++ b/javatests/dagger/internal/codegen/goldens/SetBindingRequestFulfillmentWithGuavaTest_subcomponentOmitsInheritedBindings_FAST_INIT_MODE_test.DaggerParent @@ -2,7 +2,6 @@ package test; import com.google.common.collect.ImmutableSet; import dagger.internal.DaggerGenerated; -import dagger.internal.Preconditions; import java.util.Set; import javax.annotation.processing.Generated; @@ -15,7 +14,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerParent { private DaggerParent() { @@ -33,15 +33,6 @@ final class DaggerParent { private Builder() { } - /** - * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://dagger.dev/unused-modules. - */ - @Deprecated - public Builder parentModule(ParentModule parentModule) { - Preconditions.checkNotNull(parentModule); - return this; - } - public Parent build() { return new ParentImpl(); } diff --git a/javatests/dagger/internal/codegen/goldens/SubcomponentCreatorRequestFulfillmentTest_testInlinedSubcomponentCreators_componentMethod_compilerMode=DEFAULT_MODE, creatorKind=dagger.Subcomponent.Builder_test.DaggerC b/javatests/dagger/internal/codegen/goldens/SubcomponentCreatorRequestFulfillmentTest_testInlinedSubcomponentCreators_componentMethod_compilerMode=DEFAULT_MODE, creatorKind=dagger.Subcomponent.Builder_test.DaggerC index cac6863d8..a2352f628 100644 --- a/javatests/dagger/internal/codegen/goldens/SubcomponentCreatorRequestFulfillmentTest_testInlinedSubcomponentCreators_componentMethod_compilerMode=DEFAULT_MODE, creatorKind=dagger.Subcomponent.Builder_test.DaggerC +++ b/javatests/dagger/internal/codegen/goldens/SubcomponentCreatorRequestFulfillmentTest_testInlinedSubcomponentCreators_componentMethod_compilerMode=DEFAULT_MODE, creatorKind=dagger.Subcomponent.Builder_test.DaggerC @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerC { private DaggerC() { diff --git a/javatests/dagger/internal/codegen/goldens/SubcomponentCreatorRequestFulfillmentTest_testInlinedSubcomponentCreators_componentMethod_compilerMode=DEFAULT_MODE, creatorKind=dagger.Subcomponent.Factory_test.DaggerC b/javatests/dagger/internal/codegen/goldens/SubcomponentCreatorRequestFulfillmentTest_testInlinedSubcomponentCreators_componentMethod_compilerMode=DEFAULT_MODE, creatorKind=dagger.Subcomponent.Factory_test.DaggerC index bb85c82cf..a0c70805b 100644 --- a/javatests/dagger/internal/codegen/goldens/SubcomponentCreatorRequestFulfillmentTest_testInlinedSubcomponentCreators_componentMethod_compilerMode=DEFAULT_MODE, creatorKind=dagger.Subcomponent.Factory_test.DaggerC +++ b/javatests/dagger/internal/codegen/goldens/SubcomponentCreatorRequestFulfillmentTest_testInlinedSubcomponentCreators_componentMethod_compilerMode=DEFAULT_MODE, creatorKind=dagger.Subcomponent.Factory_test.DaggerC @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerC { private DaggerC() { diff --git a/javatests/dagger/internal/codegen/goldens/SubcomponentCreatorRequestFulfillmentTest_testInlinedSubcomponentCreators_componentMethod_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Subcomponent.Builder_test.DaggerC b/javatests/dagger/internal/codegen/goldens/SubcomponentCreatorRequestFulfillmentTest_testInlinedSubcomponentCreators_componentMethod_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Subcomponent.Builder_test.DaggerC index cac6863d8..a2352f628 100644 --- a/javatests/dagger/internal/codegen/goldens/SubcomponentCreatorRequestFulfillmentTest_testInlinedSubcomponentCreators_componentMethod_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Subcomponent.Builder_test.DaggerC +++ b/javatests/dagger/internal/codegen/goldens/SubcomponentCreatorRequestFulfillmentTest_testInlinedSubcomponentCreators_componentMethod_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Subcomponent.Builder_test.DaggerC @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerC { private DaggerC() { diff --git a/javatests/dagger/internal/codegen/goldens/SubcomponentCreatorRequestFulfillmentTest_testInlinedSubcomponentCreators_componentMethod_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Subcomponent.Factory_test.DaggerC b/javatests/dagger/internal/codegen/goldens/SubcomponentCreatorRequestFulfillmentTest_testInlinedSubcomponentCreators_componentMethod_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Subcomponent.Factory_test.DaggerC index bb85c82cf..a0c70805b 100644 --- a/javatests/dagger/internal/codegen/goldens/SubcomponentCreatorRequestFulfillmentTest_testInlinedSubcomponentCreators_componentMethod_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Subcomponent.Factory_test.DaggerC +++ b/javatests/dagger/internal/codegen/goldens/SubcomponentCreatorRequestFulfillmentTest_testInlinedSubcomponentCreators_componentMethod_compilerMode=FAST_INIT_MODE, creatorKind=dagger.Subcomponent.Factory_test.DaggerC @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerC { private DaggerC() { diff --git a/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_delegateFactoryNotCreatedForSubcomponentWhenProviderExistsInParent_DEFAULT_MODE_test.DaggerParentComponent b/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_delegateFactoryNotCreatedForSubcomponentWhenProviderExistsInParent_DEFAULT_MODE_test.DaggerParentComponent index b05b85f06..3a24c10c8 100644 --- a/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_delegateFactoryNotCreatedForSubcomponentWhenProviderExistsInParent_DEFAULT_MODE_test.DaggerParentComponent +++ b/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_delegateFactoryNotCreatedForSubcomponentWhenProviderExistsInParent_DEFAULT_MODE_test.DaggerParentComponent @@ -3,8 +3,8 @@ package test; import com.google.errorprone.annotations.CanIgnoreReturnValue; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -15,7 +15,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerParentComponent { private DaggerParentComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_delegateFactoryNotCreatedForSubcomponentWhenProviderExistsInParent_FAST_INIT_MODE_test.DaggerParentComponent b/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_delegateFactoryNotCreatedForSubcomponentWhenProviderExistsInParent_FAST_INIT_MODE_test.DaggerParentComponent index 6311a200c..4cbe54367 100644 --- a/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_delegateFactoryNotCreatedForSubcomponentWhenProviderExistsInParent_FAST_INIT_MODE_test.DaggerParentComponent +++ b/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_delegateFactoryNotCreatedForSubcomponentWhenProviderExistsInParent_FAST_INIT_MODE_test.DaggerParentComponent @@ -3,8 +3,8 @@ package test; import com.google.errorprone.annotations.CanIgnoreReturnValue; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -15,7 +15,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerParentComponent { private DaggerParentComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_multipleSubcomponentsWithSameSimpleNamesCanExistInSameComponent_DEFAULT_MODE_test.DaggerParentComponent b/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_multipleSubcomponentsWithSameSimpleNamesCanExistInSameComponent_DEFAULT_MODE_test.DaggerParentComponent index 5e80c3697..245871b86 100644 --- a/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_multipleSubcomponentsWithSameSimpleNamesCanExistInSameComponent_DEFAULT_MODE_test.DaggerParentComponent +++ b/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_multipleSubcomponentsWithSameSimpleNamesCanExistInSameComponent_DEFAULT_MODE_test.DaggerParentComponent @@ -13,7 +13,8 @@ import test.subpackage.Sub; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerParentComponent { private DaggerParentComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_multipleSubcomponentsWithSameSimpleNamesCanExistInSameComponent_FAST_INIT_MODE_test.DaggerParentComponent b/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_multipleSubcomponentsWithSameSimpleNamesCanExistInSameComponent_FAST_INIT_MODE_test.DaggerParentComponent index 5e80c3697..245871b86 100644 --- a/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_multipleSubcomponentsWithSameSimpleNamesCanExistInSameComponent_FAST_INIT_MODE_test.DaggerParentComponent +++ b/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_multipleSubcomponentsWithSameSimpleNamesCanExistInSameComponent_FAST_INIT_MODE_test.DaggerParentComponent @@ -13,7 +13,8 @@ import test.subpackage.Sub; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerParentComponent { private DaggerParentComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentBuilderNamesShouldNotConflict_DEFAULT_MODE_test.DaggerC b/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentBuilderNamesShouldNotConflict_DEFAULT_MODE_test.DaggerC index ad51478c6..c866218de 100644 --- a/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentBuilderNamesShouldNotConflict_DEFAULT_MODE_test.DaggerC +++ b/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentBuilderNamesShouldNotConflict_DEFAULT_MODE_test.DaggerC @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerC { private DaggerC() { diff --git a/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentBuilderNamesShouldNotConflict_FAST_INIT_MODE_test.DaggerC b/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentBuilderNamesShouldNotConflict_FAST_INIT_MODE_test.DaggerC index ad51478c6..c866218de 100644 --- a/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentBuilderNamesShouldNotConflict_FAST_INIT_MODE_test.DaggerC +++ b/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentBuilderNamesShouldNotConflict_FAST_INIT_MODE_test.DaggerC @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerC { private DaggerC() { diff --git a/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentImplNameUsesFullyQualifiedClassNameIfNecessary_DEFAULT_MODE_test.DaggerParentComponent b/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentImplNameUsesFullyQualifiedClassNameIfNecessary_DEFAULT_MODE_test.DaggerParentComponent index fc75681bb..a778a058c 100644 --- a/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentImplNameUsesFullyQualifiedClassNameIfNecessary_DEFAULT_MODE_test.DaggerParentComponent +++ b/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentImplNameUsesFullyQualifiedClassNameIfNecessary_DEFAULT_MODE_test.DaggerParentComponent @@ -13,7 +13,8 @@ import top1.a.b.c.d.E; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerParentComponent { private DaggerParentComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentImplNameUsesFullyQualifiedClassNameIfNecessary_FAST_INIT_MODE_test.DaggerParentComponent b/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentImplNameUsesFullyQualifiedClassNameIfNecessary_FAST_INIT_MODE_test.DaggerParentComponent index fc75681bb..a778a058c 100644 --- a/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentImplNameUsesFullyQualifiedClassNameIfNecessary_FAST_INIT_MODE_test.DaggerParentComponent +++ b/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentImplNameUsesFullyQualifiedClassNameIfNecessary_FAST_INIT_MODE_test.DaggerParentComponent @@ -13,7 +13,8 @@ import top1.a.b.c.d.E; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerParentComponent { private DaggerParentComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentNamesShouldNotConflictWithParent_DEFAULT_MODE_test.DaggerC b/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentNamesShouldNotConflictWithParent_DEFAULT_MODE_test.DaggerC index 69f480fb1..e2c98e3d4 100644 --- a/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentNamesShouldNotConflictWithParent_DEFAULT_MODE_test.DaggerC +++ b/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentNamesShouldNotConflictWithParent_DEFAULT_MODE_test.DaggerC @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerC { private DaggerC() { diff --git a/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentNamesShouldNotConflictWithParent_FAST_INIT_MODE_test.DaggerC b/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentNamesShouldNotConflictWithParent_FAST_INIT_MODE_test.DaggerC index 69f480fb1..e2c98e3d4 100644 --- a/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentNamesShouldNotConflictWithParent_FAST_INIT_MODE_test.DaggerC +++ b/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentNamesShouldNotConflictWithParent_FAST_INIT_MODE_test.DaggerC @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerC { private DaggerC() { diff --git a/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentSimpleNamesDisambiguatedInRoot_DEFAULT_MODE_DaggerParentComponent b/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentSimpleNamesDisambiguatedInRoot_DEFAULT_MODE_DaggerParentComponent index 33e45bf6b..7b47466d6 100644 --- a/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentSimpleNamesDisambiguatedInRoot_DEFAULT_MODE_DaggerParentComponent +++ b/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentSimpleNamesDisambiguatedInRoot_DEFAULT_MODE_DaggerParentComponent @@ -10,7 +10,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerParentComponent { private DaggerParentComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentSimpleNamesDisambiguatedInRoot_FAST_INIT_MODE_DaggerParentComponent b/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentSimpleNamesDisambiguatedInRoot_FAST_INIT_MODE_DaggerParentComponent index 33e45bf6b..7b47466d6 100644 --- a/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentSimpleNamesDisambiguatedInRoot_FAST_INIT_MODE_DaggerParentComponent +++ b/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentSimpleNamesDisambiguatedInRoot_FAST_INIT_MODE_DaggerParentComponent @@ -10,7 +10,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerParentComponent { private DaggerParentComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentSimpleNamesDisambiguated_DEFAULT_MODE_test.DaggerParentComponent b/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentSimpleNamesDisambiguated_DEFAULT_MODE_test.DaggerParentComponent index 9f50fa921..6a9942d83 100644 --- a/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentSimpleNamesDisambiguated_DEFAULT_MODE_test.DaggerParentComponent +++ b/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentSimpleNamesDisambiguated_DEFAULT_MODE_test.DaggerParentComponent @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerParentComponent { private DaggerParentComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentSimpleNamesDisambiguated_FAST_INIT_MODE_test.DaggerParentComponent b/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentSimpleNamesDisambiguated_FAST_INIT_MODE_test.DaggerParentComponent index 9f50fa921..6a9942d83 100644 --- a/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentSimpleNamesDisambiguated_FAST_INIT_MODE_test.DaggerParentComponent +++ b/javatests/dagger/internal/codegen/goldens/SubcomponentValidationTest_subcomponentSimpleNamesDisambiguated_FAST_INIT_MODE_test.DaggerParentComponent @@ -12,7 +12,8 @@ import javax.annotation.processing.Generated; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerParentComponent { private DaggerParentComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_emptyMultibindings_avoidSwitchProviders_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_emptyMultibindings_avoidSwitchProviders_DEFAULT_MODE_test.DaggerTestComponent index 7b26af182..0ac7a6deb 100644 --- a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_emptyMultibindings_avoidSwitchProviders_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_emptyMultibindings_avoidSwitchProviders_DEFAULT_MODE_test.DaggerTestComponent @@ -17,7 +17,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_emptyMultibindings_avoidSwitchProviders_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_emptyMultibindings_avoidSwitchProviders_FAST_INIT_MODE_test.DaggerTestComponent index 7b26af182..0ac7a6deb 100644 --- a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_emptyMultibindings_avoidSwitchProviders_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_emptyMultibindings_avoidSwitchProviders_FAST_INIT_MODE_test.DaggerTestComponent @@ -17,7 +17,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_memberInjectors_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_memberInjectors_DEFAULT_MODE_test.DaggerTestComponent index e0230e0c7..db768e1fa 100644 --- a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_memberInjectors_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_memberInjectors_DEFAULT_MODE_test.DaggerTestComponent @@ -4,8 +4,8 @@ import dagger.MembersInjector; import dagger.internal.DaggerGenerated; import dagger.internal.InstanceFactory; import dagger.internal.MembersInjectors; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -16,7 +16,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -56,7 +57,7 @@ final class DaggerTestComponent { } @Override - public Provider<MembersInjector<Foo>> providerOfMembersInjector() { + public javax.inject.Provider<MembersInjector<Foo>> providerOfMembersInjector() { return fooMembersInjectorProvider; } } diff --git a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_memberInjectors_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_memberInjectors_FAST_INIT_MODE_test.DaggerTestComponent index e0230e0c7..db768e1fa 100644 --- a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_memberInjectors_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_memberInjectors_FAST_INIT_MODE_test.DaggerTestComponent @@ -4,8 +4,8 @@ import dagger.MembersInjector; import dagger.internal.DaggerGenerated; import dagger.internal.InstanceFactory; import dagger.internal.MembersInjectors; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -16,7 +16,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -56,7 +57,7 @@ final class DaggerTestComponent { } @Override - public Provider<MembersInjector<Foo>> providerOfMembersInjector() { + public javax.inject.Provider<MembersInjector<Foo>> providerOfMembersInjector() { return fooMembersInjectorProvider; } } diff --git a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_optionals_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_optionals_DEFAULT_MODE_test.DaggerTestComponent index 904fb4aea..c474dc4f3 100644 --- a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_optionals_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_optionals_DEFAULT_MODE_test.DaggerTestComponent @@ -3,9 +3,9 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.InstanceFactory; import dagger.internal.Preconditions; +import dagger.internal.Provider; import java.util.Optional; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -16,7 +16,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { /** @@ -94,12 +95,12 @@ final class DaggerTestComponent { } @Override - public Provider<Optional<Present>> providerOfOptionalOfPresent() { + public javax.inject.Provider<Optional<Present>> providerOfOptionalOfPresent() { return optionalOfPresentProvider; } @Override - public Provider<Optional<Absent>> providerOfOptionalOfAbsent() { + public javax.inject.Provider<Optional<Absent>> providerOfOptionalOfAbsent() { return optionalOfAbsentProvider; } } diff --git a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_optionals_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_optionals_FAST_INIT_MODE_test.DaggerTestComponent index 1e46fdee1..54d032d0f 100644 --- a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_optionals_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_optionals_FAST_INIT_MODE_test.DaggerTestComponent @@ -2,9 +2,9 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.InstanceFactory; +import dagger.internal.Provider; import java.util.Optional; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -15,7 +15,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { /** @@ -73,12 +74,12 @@ final class DaggerTestComponent { } @Override - public Provider<Optional<Present>> providerOfOptionalOfPresent() { + public javax.inject.Provider<Optional<Present>> providerOfOptionalOfPresent() { return optionalOfPresentProvider; } @Override - public Provider<Optional<Absent>> providerOfOptionalOfAbsent() { + public javax.inject.Provider<Optional<Absent>> providerOfOptionalOfAbsent() { return optionalOfAbsentProvider; } diff --git a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_scopedBinds_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_scopedBinds_DEFAULT_MODE_test.DaggerTestComponent index d3f68be07..ab66d4e37 100644 --- a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_scopedBinds_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_scopedBinds_DEFAULT_MODE_test.DaggerTestComponent @@ -2,8 +2,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -14,7 +14,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -54,12 +55,12 @@ final class DaggerTestComponent { } @Override - public Provider<Object> objectProvider() { + public javax.inject.Provider<Object> objectProvider() { return ((Provider) cProvider); } @Override - public Provider<CharSequence> charSequenceProvider() { + public javax.inject.Provider<CharSequence> charSequenceProvider() { return cProvider; } } diff --git a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_scopedBinds_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_scopedBinds_FAST_INIT_MODE_test.DaggerTestComponent index 440def076..0a7cdb22f 100644 --- a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_scopedBinds_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_scopedBinds_FAST_INIT_MODE_test.DaggerTestComponent @@ -2,8 +2,8 @@ package test; import dagger.internal.DaggerGenerated; import dagger.internal.DoubleCheck; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -14,7 +14,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -57,12 +58,12 @@ final class DaggerTestComponent { } @Override - public Provider<Object> objectProvider() { + public javax.inject.Provider<Object> objectProvider() { return ((Provider) cProvider); } @Override - public Provider<CharSequence> charSequenceProvider() { + public javax.inject.Provider<CharSequence> charSequenceProvider() { return cProvider; } diff --git a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_switchingProviderTest_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_switchingProviderTest_DEFAULT_MODE_test.DaggerTestComponent index c04beefef..ade9e533f 100644 --- a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_switchingProviderTest_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_switchingProviderTest_DEFAULT_MODE_test.DaggerTestComponent @@ -13,7 +13,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { diff --git a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_switchingProviderTest_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_switchingProviderTest_FAST_INIT_MODE_test.DaggerTestComponent index c2bcf9116..e225c47ff 100644 --- a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_switchingProviderTest_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_switchingProviderTest_FAST_INIT_MODE_test.DaggerTestComponent @@ -1,8 +1,8 @@ package test; import dagger.internal.DaggerGenerated; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -13,7 +13,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -358,507 +359,507 @@ final class DaggerTestComponent { } @Override - public Provider<Binding0> getBinding0Provider() { + public javax.inject.Provider<Binding0> getBinding0Provider() { return binding0Provider; } @Override - public Provider<Binding1> getBinding1Provider() { + public javax.inject.Provider<Binding1> getBinding1Provider() { return binding1Provider; } @Override - public Provider<Binding2> getBinding2Provider() { + public javax.inject.Provider<Binding2> getBinding2Provider() { return binding2Provider; } @Override - public Provider<Binding3> getBinding3Provider() { + public javax.inject.Provider<Binding3> getBinding3Provider() { return binding3Provider; } @Override - public Provider<Binding4> getBinding4Provider() { + public javax.inject.Provider<Binding4> getBinding4Provider() { return binding4Provider; } @Override - public Provider<Binding5> getBinding5Provider() { + public javax.inject.Provider<Binding5> getBinding5Provider() { return binding5Provider; } @Override - public Provider<Binding6> getBinding6Provider() { + public javax.inject.Provider<Binding6> getBinding6Provider() { return binding6Provider; } @Override - public Provider<Binding7> getBinding7Provider() { + public javax.inject.Provider<Binding7> getBinding7Provider() { return binding7Provider; } @Override - public Provider<Binding8> getBinding8Provider() { + public javax.inject.Provider<Binding8> getBinding8Provider() { return binding8Provider; } @Override - public Provider<Binding9> getBinding9Provider() { + public javax.inject.Provider<Binding9> getBinding9Provider() { return binding9Provider; } @Override - public Provider<Binding10> getBinding10Provider() { + public javax.inject.Provider<Binding10> getBinding10Provider() { return binding10Provider; } @Override - public Provider<Binding11> getBinding11Provider() { + public javax.inject.Provider<Binding11> getBinding11Provider() { return binding11Provider; } @Override - public Provider<Binding12> getBinding12Provider() { + public javax.inject.Provider<Binding12> getBinding12Provider() { return binding12Provider; } @Override - public Provider<Binding13> getBinding13Provider() { + public javax.inject.Provider<Binding13> getBinding13Provider() { return binding13Provider; } @Override - public Provider<Binding14> getBinding14Provider() { + public javax.inject.Provider<Binding14> getBinding14Provider() { return binding14Provider; } @Override - public Provider<Binding15> getBinding15Provider() { + public javax.inject.Provider<Binding15> getBinding15Provider() { return binding15Provider; } @Override - public Provider<Binding16> getBinding16Provider() { + public javax.inject.Provider<Binding16> getBinding16Provider() { return binding16Provider; } @Override - public Provider<Binding17> getBinding17Provider() { + public javax.inject.Provider<Binding17> getBinding17Provider() { return binding17Provider; } @Override - public Provider<Binding18> getBinding18Provider() { + public javax.inject.Provider<Binding18> getBinding18Provider() { return binding18Provider; } @Override - public Provider<Binding19> getBinding19Provider() { + public javax.inject.Provider<Binding19> getBinding19Provider() { return binding19Provider; } @Override - public Provider<Binding20> getBinding20Provider() { + public javax.inject.Provider<Binding20> getBinding20Provider() { return binding20Provider; } @Override - public Provider<Binding21> getBinding21Provider() { + public javax.inject.Provider<Binding21> getBinding21Provider() { return binding21Provider; } @Override - public Provider<Binding22> getBinding22Provider() { + public javax.inject.Provider<Binding22> getBinding22Provider() { return binding22Provider; } @Override - public Provider<Binding23> getBinding23Provider() { + public javax.inject.Provider<Binding23> getBinding23Provider() { return binding23Provider; } @Override - public Provider<Binding24> getBinding24Provider() { + public javax.inject.Provider<Binding24> getBinding24Provider() { return binding24Provider; } @Override - public Provider<Binding25> getBinding25Provider() { + public javax.inject.Provider<Binding25> getBinding25Provider() { return binding25Provider; } @Override - public Provider<Binding26> getBinding26Provider() { + public javax.inject.Provider<Binding26> getBinding26Provider() { return binding26Provider; } @Override - public Provider<Binding27> getBinding27Provider() { + public javax.inject.Provider<Binding27> getBinding27Provider() { return binding27Provider; } @Override - public Provider<Binding28> getBinding28Provider() { + public javax.inject.Provider<Binding28> getBinding28Provider() { return binding28Provider; } @Override - public Provider<Binding29> getBinding29Provider() { + public javax.inject.Provider<Binding29> getBinding29Provider() { return binding29Provider; } @Override - public Provider<Binding30> getBinding30Provider() { + public javax.inject.Provider<Binding30> getBinding30Provider() { return binding30Provider; } @Override - public Provider<Binding31> getBinding31Provider() { + public javax.inject.Provider<Binding31> getBinding31Provider() { return binding31Provider; } @Override - public Provider<Binding32> getBinding32Provider() { + public javax.inject.Provider<Binding32> getBinding32Provider() { return binding32Provider; } @Override - public Provider<Binding33> getBinding33Provider() { + public javax.inject.Provider<Binding33> getBinding33Provider() { return binding33Provider; } @Override - public Provider<Binding34> getBinding34Provider() { + public javax.inject.Provider<Binding34> getBinding34Provider() { return binding34Provider; } @Override - public Provider<Binding35> getBinding35Provider() { + public javax.inject.Provider<Binding35> getBinding35Provider() { return binding35Provider; } @Override - public Provider<Binding36> getBinding36Provider() { + public javax.inject.Provider<Binding36> getBinding36Provider() { return binding36Provider; } @Override - public Provider<Binding37> getBinding37Provider() { + public javax.inject.Provider<Binding37> getBinding37Provider() { return binding37Provider; } @Override - public Provider<Binding38> getBinding38Provider() { + public javax.inject.Provider<Binding38> getBinding38Provider() { return binding38Provider; } @Override - public Provider<Binding39> getBinding39Provider() { + public javax.inject.Provider<Binding39> getBinding39Provider() { return binding39Provider; } @Override - public Provider<Binding40> getBinding40Provider() { + public javax.inject.Provider<Binding40> getBinding40Provider() { return binding40Provider; } @Override - public Provider<Binding41> getBinding41Provider() { + public javax.inject.Provider<Binding41> getBinding41Provider() { return binding41Provider; } @Override - public Provider<Binding42> getBinding42Provider() { + public javax.inject.Provider<Binding42> getBinding42Provider() { return binding42Provider; } @Override - public Provider<Binding43> getBinding43Provider() { + public javax.inject.Provider<Binding43> getBinding43Provider() { return binding43Provider; } @Override - public Provider<Binding44> getBinding44Provider() { + public javax.inject.Provider<Binding44> getBinding44Provider() { return binding44Provider; } @Override - public Provider<Binding45> getBinding45Provider() { + public javax.inject.Provider<Binding45> getBinding45Provider() { return binding45Provider; } @Override - public Provider<Binding46> getBinding46Provider() { + public javax.inject.Provider<Binding46> getBinding46Provider() { return binding46Provider; } @Override - public Provider<Binding47> getBinding47Provider() { + public javax.inject.Provider<Binding47> getBinding47Provider() { return binding47Provider; } @Override - public Provider<Binding48> getBinding48Provider() { + public javax.inject.Provider<Binding48> getBinding48Provider() { return binding48Provider; } @Override - public Provider<Binding49> getBinding49Provider() { + public javax.inject.Provider<Binding49> getBinding49Provider() { return binding49Provider; } @Override - public Provider<Binding50> getBinding50Provider() { + public javax.inject.Provider<Binding50> getBinding50Provider() { return binding50Provider; } @Override - public Provider<Binding51> getBinding51Provider() { + public javax.inject.Provider<Binding51> getBinding51Provider() { return binding51Provider; } @Override - public Provider<Binding52> getBinding52Provider() { + public javax.inject.Provider<Binding52> getBinding52Provider() { return binding52Provider; } @Override - public Provider<Binding53> getBinding53Provider() { + public javax.inject.Provider<Binding53> getBinding53Provider() { return binding53Provider; } @Override - public Provider<Binding54> getBinding54Provider() { + public javax.inject.Provider<Binding54> getBinding54Provider() { return binding54Provider; } @Override - public Provider<Binding55> getBinding55Provider() { + public javax.inject.Provider<Binding55> getBinding55Provider() { return binding55Provider; } @Override - public Provider<Binding56> getBinding56Provider() { + public javax.inject.Provider<Binding56> getBinding56Provider() { return binding56Provider; } @Override - public Provider<Binding57> getBinding57Provider() { + public javax.inject.Provider<Binding57> getBinding57Provider() { return binding57Provider; } @Override - public Provider<Binding58> getBinding58Provider() { + public javax.inject.Provider<Binding58> getBinding58Provider() { return binding58Provider; } @Override - public Provider<Binding59> getBinding59Provider() { + public javax.inject.Provider<Binding59> getBinding59Provider() { return binding59Provider; } @Override - public Provider<Binding60> getBinding60Provider() { + public javax.inject.Provider<Binding60> getBinding60Provider() { return binding60Provider; } @Override - public Provider<Binding61> getBinding61Provider() { + public javax.inject.Provider<Binding61> getBinding61Provider() { return binding61Provider; } @Override - public Provider<Binding62> getBinding62Provider() { + public javax.inject.Provider<Binding62> getBinding62Provider() { return binding62Provider; } @Override - public Provider<Binding63> getBinding63Provider() { + public javax.inject.Provider<Binding63> getBinding63Provider() { return binding63Provider; } @Override - public Provider<Binding64> getBinding64Provider() { + public javax.inject.Provider<Binding64> getBinding64Provider() { return binding64Provider; } @Override - public Provider<Binding65> getBinding65Provider() { + public javax.inject.Provider<Binding65> getBinding65Provider() { return binding65Provider; } @Override - public Provider<Binding66> getBinding66Provider() { + public javax.inject.Provider<Binding66> getBinding66Provider() { return binding66Provider; } @Override - public Provider<Binding67> getBinding67Provider() { + public javax.inject.Provider<Binding67> getBinding67Provider() { return binding67Provider; } @Override - public Provider<Binding68> getBinding68Provider() { + public javax.inject.Provider<Binding68> getBinding68Provider() { return binding68Provider; } @Override - public Provider<Binding69> getBinding69Provider() { + public javax.inject.Provider<Binding69> getBinding69Provider() { return binding69Provider; } @Override - public Provider<Binding70> getBinding70Provider() { + public javax.inject.Provider<Binding70> getBinding70Provider() { return binding70Provider; } @Override - public Provider<Binding71> getBinding71Provider() { + public javax.inject.Provider<Binding71> getBinding71Provider() { return binding71Provider; } @Override - public Provider<Binding72> getBinding72Provider() { + public javax.inject.Provider<Binding72> getBinding72Provider() { return binding72Provider; } @Override - public Provider<Binding73> getBinding73Provider() { + public javax.inject.Provider<Binding73> getBinding73Provider() { return binding73Provider; } @Override - public Provider<Binding74> getBinding74Provider() { + public javax.inject.Provider<Binding74> getBinding74Provider() { return binding74Provider; } @Override - public Provider<Binding75> getBinding75Provider() { + public javax.inject.Provider<Binding75> getBinding75Provider() { return binding75Provider; } @Override - public Provider<Binding76> getBinding76Provider() { + public javax.inject.Provider<Binding76> getBinding76Provider() { return binding76Provider; } @Override - public Provider<Binding77> getBinding77Provider() { + public javax.inject.Provider<Binding77> getBinding77Provider() { return binding77Provider; } @Override - public Provider<Binding78> getBinding78Provider() { + public javax.inject.Provider<Binding78> getBinding78Provider() { return binding78Provider; } @Override - public Provider<Binding79> getBinding79Provider() { + public javax.inject.Provider<Binding79> getBinding79Provider() { return binding79Provider; } @Override - public Provider<Binding80> getBinding80Provider() { + public javax.inject.Provider<Binding80> getBinding80Provider() { return binding80Provider; } @Override - public Provider<Binding81> getBinding81Provider() { + public javax.inject.Provider<Binding81> getBinding81Provider() { return binding81Provider; } @Override - public Provider<Binding82> getBinding82Provider() { + public javax.inject.Provider<Binding82> getBinding82Provider() { return binding82Provider; } @Override - public Provider<Binding83> getBinding83Provider() { + public javax.inject.Provider<Binding83> getBinding83Provider() { return binding83Provider; } @Override - public Provider<Binding84> getBinding84Provider() { + public javax.inject.Provider<Binding84> getBinding84Provider() { return binding84Provider; } @Override - public Provider<Binding85> getBinding85Provider() { + public javax.inject.Provider<Binding85> getBinding85Provider() { return binding85Provider; } @Override - public Provider<Binding86> getBinding86Provider() { + public javax.inject.Provider<Binding86> getBinding86Provider() { return binding86Provider; } @Override - public Provider<Binding87> getBinding87Provider() { + public javax.inject.Provider<Binding87> getBinding87Provider() { return binding87Provider; } @Override - public Provider<Binding88> getBinding88Provider() { + public javax.inject.Provider<Binding88> getBinding88Provider() { return binding88Provider; } @Override - public Provider<Binding89> getBinding89Provider() { + public javax.inject.Provider<Binding89> getBinding89Provider() { return binding89Provider; } @Override - public Provider<Binding90> getBinding90Provider() { + public javax.inject.Provider<Binding90> getBinding90Provider() { return binding90Provider; } @Override - public Provider<Binding91> getBinding91Provider() { + public javax.inject.Provider<Binding91> getBinding91Provider() { return binding91Provider; } @Override - public Provider<Binding92> getBinding92Provider() { + public javax.inject.Provider<Binding92> getBinding92Provider() { return binding92Provider; } @Override - public Provider<Binding93> getBinding93Provider() { + public javax.inject.Provider<Binding93> getBinding93Provider() { return binding93Provider; } @Override - public Provider<Binding94> getBinding94Provider() { + public javax.inject.Provider<Binding94> getBinding94Provider() { return binding94Provider; } @Override - public Provider<Binding95> getBinding95Provider() { + public javax.inject.Provider<Binding95> getBinding95Provider() { return binding95Provider; } @Override - public Provider<Binding96> getBinding96Provider() { + public javax.inject.Provider<Binding96> getBinding96Provider() { return binding96Provider; } @Override - public Provider<Binding97> getBinding97Provider() { + public javax.inject.Provider<Binding97> getBinding97Provider() { return binding97Provider; } @Override - public Provider<Binding98> getBinding98Provider() { + public javax.inject.Provider<Binding98> getBinding98Provider() { return binding98Provider; } @Override - public Provider<Binding99> getBinding99Provider() { + public javax.inject.Provider<Binding99> getBinding99Provider() { return binding99Provider; } @Override - public Provider<Binding100> getBinding100Provider() { + public javax.inject.Provider<Binding100> getBinding100Provider() { return binding100Provider; } diff --git a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_unscopedBinds_DEFAULT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_unscopedBinds_DEFAULT_MODE_test.DaggerTestComponent index 00679b417..b2933ae32 100644 --- a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_unscopedBinds_DEFAULT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_unscopedBinds_DEFAULT_MODE_test.DaggerTestComponent @@ -13,7 +13,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -46,12 +47,12 @@ final class DaggerTestComponent { @Override public Provider<Object> objectProvider() { - return ((Provider) TestModule_SFactory.create()); + return ((dagger.internal.Provider) TestModule_SFactory.create()); } @Override public Provider<CharSequence> charSequenceProvider() { - return ((Provider) TestModule_SFactory.create()); + return ((dagger.internal.Provider) TestModule_SFactory.create()); } } } diff --git a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_unscopedBinds_FAST_INIT_MODE_test.DaggerTestComponent b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_unscopedBinds_FAST_INIT_MODE_test.DaggerTestComponent index 2970ba6f6..eef5afc71 100644 --- a/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_unscopedBinds_FAST_INIT_MODE_test.DaggerTestComponent +++ b/javatests/dagger/internal/codegen/goldens/SwitchingProviderTest_unscopedBinds_FAST_INIT_MODE_test.DaggerTestComponent @@ -1,8 +1,8 @@ package test; import dagger.internal.DaggerGenerated; +import dagger.internal.Provider; import javax.annotation.processing.Generated; -import javax.inject.Provider; @DaggerGenerated @Generated( @@ -13,7 +13,8 @@ import javax.inject.Provider; "unchecked", "rawtypes", "KotlinInternal", - "KotlinInternalInJava" + "KotlinInternalInJava", + "cast" }) final class DaggerTestComponent { private DaggerTestComponent() { @@ -53,12 +54,12 @@ final class DaggerTestComponent { } @Override - public Provider<Object> objectProvider() { + public javax.inject.Provider<Object> objectProvider() { return ((Provider) sProvider); } @Override - public Provider<CharSequence> charSequenceProvider() { + public javax.inject.Provider<CharSequence> charSequenceProvider() { return ((Provider) sProvider); } diff --git a/javatests/dagger/internal/codegen/kotlin/KspComponentProcessorTest.java b/javatests/dagger/internal/codegen/kotlin/KspComponentProcessorTest.java index cc4f5a155..20a57f1a4 100644 --- a/javatests/dagger/internal/codegen/kotlin/KspComponentProcessorTest.java +++ b/javatests/dagger/internal/codegen/kotlin/KspComponentProcessorTest.java @@ -57,7 +57,8 @@ public final class KspComponentProcessorTest { " \"unchecked\",", " \"rawtypes\",", " \"KotlinInternal\",", - " \"KotlinInternalInJava\"", + " \"KotlinInternalInJava\",", + " \"cast\"", "})", "public final class DaggerMyComponent {", " private DaggerMyComponent() {", @@ -160,7 +161,8 @@ public final class KspComponentProcessorTest { " \"unchecked\",", " \"rawtypes\",", " \"KotlinInternal\",", - " \"KotlinInternalInJava\"", + " \"KotlinInternalInJava\",", + " \"cast\"", "})", "public final class DaggerMyComponent {", " private DaggerMyComponent() {", @@ -230,8 +232,8 @@ public final class KspComponentProcessorTest { "package test;", "", "import dagger.internal.DaggerGenerated;", + "import dagger.internal.Provider;", "import javax.annotation.processing.Generated;", - "import javax.inject.Provider;", "", "@DaggerGenerated", "@Generated(", @@ -242,7 +244,8 @@ public final class KspComponentProcessorTest { " \"unchecked\",", " \"rawtypes\",", " \"KotlinInternal\",", - " \"KotlinInternalInJava\"", + " \"KotlinInternalInJava\",", + " \"cast\"", "})", "public final class DaggerMyComponent {", " private DaggerMyComponent() {", @@ -283,7 +286,7 @@ public final class KspComponentProcessorTest { " }", "", " @Override", - " public Provider<Foo> foo() {", + " public javax.inject.Provider<Foo> foo() {", " return fooProvider;", " }", " }", @@ -342,7 +345,8 @@ public final class KspComponentProcessorTest { " \"unchecked\",", " \"rawtypes\",", " \"KotlinInternal\",", - " \"KotlinInternalInJava\"", + " \"KotlinInternalInJava\",", + " \"cast\"", "})", "public final class DaggerMyComponent {", " private DaggerMyComponent() {", @@ -448,7 +452,8 @@ public final class KspComponentProcessorTest { " \"unchecked\",", " \"rawtypes\",", " \"KotlinInternal\",", - " \"KotlinInternalInJava\"", + " \"KotlinInternalInJava\",", + " \"cast\"", "})", "public final class DaggerMyComponent {", " private DaggerMyComponent() {", @@ -560,7 +565,8 @@ public final class KspComponentProcessorTest { " \"unchecked\",", " \"rawtypes\",", " \"KotlinInternal\",", - " \"KotlinInternalInJava\"", + " \"KotlinInternalInJava\",", + " \"cast\"", "})", "public final class DaggerMyComponent {", " private DaggerMyComponent() {", |