Validate that the target component is a parent of the scope (#52)

Author: ansman

compiler/src/main/kotlin/se/ansman/dagger/auto/compiler/Errors.kt

@@ -31,6 +31,9 @@ object Errors {
         fun invalidComponent(component: String): String =
             "The specified component $component isn't a Dagger component"
 
+        fun parentComponent(installIn: String, inferredComponent: String): String =
+            "The installIn component $installIn is a parent component of $inferredComponent and cannot be used as installIn for @AutoBind"
+
         fun nonStandardScope(scope: String): String =
             "Scope $scope is not a standard scope so you must specify a component explicitly using the `inComponent` parameter."
 

compiler/src/main/kotlin/se/ansman/dagger/auto/compiler/processors/AutoBindProcessor.kt

@@ -212,7 +212,7 @@ class AutoBindProcessor<N, TypeName : Any, ClassName : TypeName, AnnotationSpec,
     private fun ClassDeclaration<N, TypeName, ClassName, AnnotationSpec>.guessComponent(): ClassName {
         val scope = annotations.find { it.isAnnotatedWith(Scope::class) }
             ?: return environment.renderEngine.className(SingletonComponent::class)
-        return scopeToComponent(scope) ?: run {
+        return scope.guessComponent() ?: run {
             logger?.error(Errors.AutoBind.nonStandardScope(scope.qualifiedName), this)
             throw AbortProcessingError()
         }
@@ -222,9 +222,40 @@ class AutoBindProcessor<N, TypeName : Any, ClassName : TypeName, AnnotationSpec,
         resolver: AutoDaggerResolver<N, TypeName, ClassName, AnnotationSpec>,
         component: ClassName,
     ) {
-        if (!resolver.lookupType(component).isAnnotatedWith(DefineComponent::class)) {
+        val defineComponent = resolver.lookupType(component)
+            .getAnnotation(DefineComponent::class)
+        if (defineComponent == null) {
             logger?.error(Errors.AutoBind.invalidComponent(component.toString()), this)
+            return
+        }
+        val scope = annotations.find { it.isAnnotatedWith(Scope::class) }
+            ?: return
+        val inferredComponent = scope.guessComponent() ?: return
+        if (isComponentChildComponent(resolver, component, inferredComponent)) {
+            logger?.error(
+                message = Errors.AutoBind.parentComponent(
+                    installIn = resolver.environment.renderEngine.simpleName(component),
+                    inferredComponent = resolver.environment.renderEngine.simpleName(inferredComponent)
+                ),
+                node = this
+            )
+        }
+    }
+
+    private fun isComponentChildComponent(
+        resolver: AutoDaggerResolver<N, TypeName, ClassName, AnnotationSpec>,
+        installInComponent: ClassName,
+        inferredComponent: ClassName,
+    ): Boolean {
+        var c = inferredComponent
+        while (c != installInComponent) {
+            c = resolver.lookupType(c)
+                .getAnnotation(DefineComponent::class)
+                ?.getValue<ClassDeclaration<N, TypeName, ClassName, AnnotationSpec>>("parent")
+                ?.className
+                ?: return false
         }
+        return true
     }
 
     fun getBoundSupertypes(
@@ -249,7 +280,7 @@ class AutoBindProcessor<N, TypeName : Any, ClassName : TypeName, AnnotationSpec,
 
                         else -> logger?.error(Errors.AutoBind.multipleSuperTypes, type)
                     }
-            }
+                }
 
         val supertypes = type.supertypes.associateByTo(mutableMapOf()) {
             environment.renderEngine.rawType(it.toTypeName())
@@ -267,8 +298,8 @@ class AutoBindProcessor<N, TypeName : Any, ClassName : TypeName, AnnotationSpec,
         return supertypes.values
     }
 
-    private fun scopeToComponent(scope: AnnotationModel<*, *>): ClassName? =
-        when (scope.qualifiedName) {
+    private fun AnnotationModel<*, *>.guessComponent(): ClassName? =
+        when (qualifiedName) {
             Singleton::class.java.name,
             Reusable::class.java.name ->
                 environment.renderEngine.className(SingletonComponent::class)

compiler/src/test/java/dagger/hilt/android/components/ActivityComponent.java

@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2019 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.hilt.android.components;
+
+import dagger.hilt.DefineComponent;
+import dagger.hilt.android.scopes.FragmentScoped;
+import dagger.hilt.components.SingletonComponent;
+
+@FragmentScoped
+@DefineComponent(parent = SingletonComponent.class)
+public interface ActivityComponent {}

compiler/src/test/java/dagger/hilt/android/components/FragmentComponent.java

@@ -18,8 +18,7 @@
 
 import dagger.hilt.DefineComponent;
 import dagger.hilt.android.scopes.FragmentScoped;
-import dagger.hilt.components.SingletonComponent;
 
 @FragmentScoped
-@DefineComponent(parent = SingletonComponent.class)
+@DefineComponent(parent = ActivityComponent.class)
 public interface FragmentComponent {}

compiler/src/test/java/dagger/hilt/android/scopes/ActivityScoped.java

@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2020 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.hilt.android.scopes;
+
+import static java.lang.annotation.RetentionPolicy.CLASS;
+
+import java.lang.annotation.Retention;
+
+import javax.inject.Scope;
+
+@Scope
+@Retention(CLASS)
+public @interface ActivityScoped {}

compiler/src/test/kotlin/se/ansman/dagger/auto/compiler/BaseTest.kt

@@ -285,6 +285,49 @@ abstract class BaseTest(
                 )
                 .assertFailedWithMessage(Errors.AutoBind.multipleSuperTypes)
         }
+
+        @Test
+        fun `prevents binding into parent or unrelated components`(@TempDir tempDirectory: File) {
+            compilation(tempDirectory)
+                .compile(
+                    """
+                    package se.ansman
+
+                    interface Repository
+     
+                    @se.ansman.dagger.auto.AutoBind(inComponent = dagger.hilt.components.SingletonComponent::class)
+                    @dagger.hilt.android.scopes.ActivityScoped
+                    class ActivityRepository @javax.inject.Inject constructor() : Repository
+                    """
+                )
+                .assertFailedWithMessage(Errors.AutoBind.parentComponent("SingletonComponent", "ActivityComponent"))
+            compilation(tempDirectory)
+                .compile(
+                    """
+                    package se.ansman
+
+                    interface Repository
+     
+                    @se.ansman.dagger.auto.AutoBind(inComponent = dagger.hilt.android.components.ActivityComponent::class)
+                    @dagger.hilt.android.scopes.FragmentScoped
+                    class FragmentRepository @javax.inject.Inject constructor() : Repository
+                    """
+                )
+                .assertFailedWithMessage(Errors.AutoBind.parentComponent("ActivityComponent", "FragmentComponent"))
+            compilation(tempDirectory)
+                .compile(
+                    """
+                    package se.ansman
+
+                    interface Repository
+     
+                    @se.ansman.dagger.auto.AutoBind(inComponent = dagger.hilt.components.SingletonComponent::class)
+                    @dagger.hilt.android.scopes.FragmentScoped
+                    class FragmentRepository @javax.inject.Inject constructor() : Repository
+                    """
+                )
+                .assertFailedWithMessage(Errors.AutoBind.parentComponent("SingletonComponent", "FragmentComponent"))
+        }
     }
 
     @Nested

compiler/src/test/resources/tests/auto_bind/child_component/Repsitory.kt

@@ -0,0 +1,21 @@
+package tests.auto_bind.child_component
+
+import dagger.hilt.android.components.ActivityComponent
+import dagger.hilt.android.components.FragmentComponent
+import se.ansman.dagger.auto.AutoBind
+import javax.inject.Inject
+import javax.inject.Singleton
+
+interface Repository
+
+@AutoBind
+@Singleton
+class GlobalRepository @Inject constructor() : Repository
+
+@AutoBind(inComponent = ActivityComponent::class)
+@Singleton
+class ActivityRepository @Inject constructor() : Repository
+
+@AutoBind(inComponent = FragmentComponent::class)
+@Singleton
+class FragmentRepository @Inject constructor() : Repository

compiler/src/test/resources/tests/auto_bind/child_component/kapt/AutoBindActivityRepositoryActivityModule.java.txt

@@ -0,0 +1,22 @@
+// Code generated by Auto Dagger. Do not edit.
+package tests.auto_bind.child_component;
+
+import dagger.Binds;
+import dagger.Module;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ActivityComponent;
+import dagger.hilt.codegen.OriginatingElement;
+
+@Module
+@InstallIn(ActivityComponent.class)
+@OriginatingElement(
+    topLevelClass = ActivityRepository.class
+)
+public abstract class AutoBindActivityRepositoryActivityModule {
+  private AutoBindActivityRepositoryActivityModule() {
+  }
+
+  @Binds
+  public abstract Repository bindActivityRepositoryAsRepository(
+      ActivityRepository activityRepository);
+}

compiler/src/test/resources/tests/auto_bind/child_component/kapt/AutoBindFragmentRepositoryFragmentModule.java.txt

@@ -0,0 +1,22 @@
+// Code generated by Auto Dagger. Do not edit.
+package tests.auto_bind.child_component;
+
+import dagger.Binds;
+import dagger.Module;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.FragmentComponent;
+import dagger.hilt.codegen.OriginatingElement;
+
+@Module
+@InstallIn(FragmentComponent.class)
+@OriginatingElement(
+    topLevelClass = FragmentRepository.class
+)
+public abstract class AutoBindFragmentRepositoryFragmentModule {
+  private AutoBindFragmentRepositoryFragmentModule() {
+  }
+
+  @Binds
+  public abstract Repository bindFragmentRepositoryAsRepository(
+      FragmentRepository fragmentRepository);
+}

compiler/src/test/resources/tests/auto_bind/child_component/kapt/AutoBindGlobalRepositorySingletonModule.java.txt

@@ -0,0 +1,21 @@
+// Code generated by Auto Dagger. Do not edit.
+package tests.auto_bind.child_component;
+
+import dagger.Binds;
+import dagger.Module;
+import dagger.hilt.InstallIn;
+import dagger.hilt.codegen.OriginatingElement;
+import dagger.hilt.components.SingletonComponent;
+
+@Module
+@InstallIn(SingletonComponent.class)
+@OriginatingElement(
+    topLevelClass = GlobalRepository.class
+)
+public abstract class AutoBindGlobalRepositorySingletonModule {
+  private AutoBindGlobalRepositorySingletonModule() {
+  }
+
+  @Binds
+  public abstract Repository bindGlobalRepositoryAsRepository(GlobalRepository globalRepository);
+}