Fix compile error when accessing parent scoped dependency in cycle run block

Fixes #279

Author: evant

integration-tests/common/src/test/kotlin/me/tatarka/inject/test/RecursiveTest.kt

@@ -93,6 +93,24 @@ abstract class OptimizedCycleComponent {
     abstract val baz: CycleBaz
 }
 
+@CustomScope
+@Inject
+class ScopeBar(val foo: ScopeFoo)
+
+@Inject
+class ScopeFoo(val bar: Lazy<ScopeBar>)
+
+@Component
+@CustomScope
+abstract class ParentCycleComponent
+
+@Component
+abstract class ChildCycleComponent(
+    @Component val parent: ParentCycleComponent,
+) {
+    abstract val foo: ScopeFoo
+}
+
 class RecursiveTest {
 
     @Test
@@ -152,4 +170,14 @@ class RecursiveTest {
             assertThat(baz.foo).isSameAs(baz.foo.bar.foo())
         }
     }
+
+    @Test
+    fun generates_a_component_with_a_scoped_parent_dependency_recursively() {
+        val component = ChildCycleComponent::class.create(ParentCycleComponent::class.create())
+        val foo = component.foo
+        val bar = foo.bar.value
+
+        assertThat(foo).isSameAs(foo.bar.value.foo)
+        assertThat(bar).isSameAs(bar.foo.bar.value)
+    }
 }

kotlin-inject-compiler/core/src/main/kotlin/me/tatarka/inject/compiler/TypeResultGenerator.kt

@@ -155,6 +155,7 @@ data class TypeResultGenerator(val options: Options, val implicitAccessor: Acces
                             add("$paramName = ")
                             add(param.generate())
                         }
+
                         else -> add(param.generate())
                     }
                 }
@@ -197,13 +198,15 @@ data class TypeResultGenerator(val options: Options, val implicitAccessor: Acces
                 } else {
                     add("%T::class.java.name", typeName)
                 }
+
                 is ParameterizedTypeName -> {
                     addTypeName(typeName.rawType)
                     for (arg in typeName.typeArguments) {
                         add("+")
                         addTypeName(arg)
                     }
                 }
+
                 is LambdaTypeName -> {
                     val functionName = if (typeName.isSuspending) {
                         ClassName("kotlin.coroutines", "SuspendFunction${typeName.parameters.size}")
@@ -219,6 +222,7 @@ data class TypeResultGenerator(val options: Options, val implicitAccessor: Acces
                     add("+")
                     addTypeName(typeName.returnType)
                 }
+
                 else -> add("%S", typeName)
             }
         } else {
@@ -323,8 +327,14 @@ data class TypeResultGenerator(val options: Options, val implicitAccessor: Acces
 
     private fun TypeResult.LateInit.generate(): CodeBlock {
         return CodeBlock.builder().apply {
-            beginControlFlow("run")
-            addStatement("lateinit var %N: %T", name, result.key.type.toTypeName())
+            // Using the run extension method creates a new 'this' scope which causes kotlin's type inference for the
+            // current 'this' to be dropped. This breaks scoped parent resolution as we use
+            // require(parent is ScopedComponent) to access the parent scope.
+            // To work around this we explicitly pass the return type to ensure it calls the top-level run overload
+            // instead of the extension method.
+            val returnType = result.key.type.toTypeName()
+            beginControlFlow("run<%T>", returnType)
+            addStatement("lateinit var %N: %T", name, returnType)
             add(result.generate())
             beginControlFlow(".also")
             addStatement("%N = it", name)