Fixed CAPTURED_IN_CLOSURE marker for primary constructor argument

#KT-7131 Fixed

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/CapturingInClosureChecker.kt

@@ -16,22 +16,19 @@
 
 package org.jetbrains.kotlin.resolve.calls.checkers
 
-import org.jetbrains.kotlin.descriptors.CallableDescriptor
-import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
-import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext
-import org.jetbrains.kotlin.resolve.BindingTrace
-import org.jetbrains.kotlin.resolve.scopes.JetScope
-import org.jetbrains.kotlin.descriptors.VariableDescriptor
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.resolve.BindingContext.CAPTURED_IN_CLOSURE
-import org.jetbrains.kotlin.types.expressions.CaptureKind
-import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
+import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.psi.JetFunctionLiteral
 import org.jetbrains.kotlin.psi.JetFunctionLiteralExpression
-import org.jetbrains.kotlin.resolve.calls.callUtil.*
-import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.BindingContext.CAPTURED_IN_CLOSURE
+import org.jetbrains.kotlin.resolve.BindingTrace
+import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
+import org.jetbrains.kotlin.resolve.calls.callUtil.getParentResolvedCall
+import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext
+import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.calls.model.VariableAsFunctionResolvedCall
+import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.types.expressions.CaptureKind
 
 class CapturingInClosureChecker : CallChecker {
     override fun <F : CallableDescriptor> check(resolvedCall: ResolvedCall<F>, context: BasicCallResolutionContext) {
@@ -45,7 +42,7 @@ class CapturingInClosureChecker : CallChecker {
     private fun checkCapturingInClosure(variable: VariableDescriptor, trace: BindingTrace, scope: JetScope) {
         val variableParent = variable.getContainingDeclaration()
         val scopeContainer = scope.getContainingDeclaration()
-        if (scopeContainer != variableParent && variableParent is CallableDescriptor) {
+        if (isCapturedVariable(variableParent, scopeContainer)) {
             if (trace.get(CAPTURED_IN_CLOSURE, variable) != CaptureKind.NOT_INLINE) {
                 val inline = isCapturedInInline(trace.getBindingContext(), scopeContainer, variableParent)
                 trace.record(CAPTURED_IN_CLOSURE, variable, if (inline) CaptureKind.INLINE_ONLY else CaptureKind.NOT_INLINE)
@@ -53,6 +50,18 @@ class CapturingInClosureChecker : CallChecker {
         }
     }
 
+    private fun isCapturedVariable(variableParent: DeclarationDescriptor, scopeContainer: DeclarationDescriptor): Boolean {
+        if (variableParent !is FunctionDescriptor || scopeContainer == variableParent) return false
+
+        if (variableParent is ConstructorDescriptor) {
+            val classDescriptor = variableParent.getContainingDeclaration()
+
+            if (scopeContainer == classDescriptor) return false
+            if (scopeContainer is PropertyDescriptor && scopeContainer.getContainingDeclaration() == classDescriptor) return false
+        }
+        return true
+    }
+
     private fun isCapturedInInline(
             context: BindingContext, scopeContainer: DeclarationDescriptor, variableParent: DeclarationDescriptor
     ): Boolean {
@@ -68,7 +77,7 @@ class CapturingInClosureChecker : CallChecker {
         if (callable is SimpleFunctionDescriptor && callable.getInlineStrategy().isInline()) {
             val scopeContainerParent = scopeContainer.getContainingDeclaration()
             assert(scopeContainerParent != null) { "parent is null for " + scopeContainer }
-            return scopeContainerParent == variableParent || isCapturedInInline(context, scopeContainerParent, variableParent)
+            return !isCapturedVariable(variableParent, scopeContainerParent) || isCapturedInInline(context, scopeContainerParent, variableParent)
         }
         return false
     }

idea/testData/checker/infos/CapturedConstructorParameter.kt

@@ -0,0 +1,52 @@
+trait T
+class T1(<warning>t</warning>: Int): T
+
+inline fun <T> run(f: () -> T) = f()
+
+
+class Delegate(<warning>d</warning>: Int) {
+    fun get(k: Any, m: PropertyMetadata) {}
+}
+
+class A(y: Int, t: Int, d: Int): T <info>by</info> T1(t) {
+    val <info>a</info> = y
+    val b <info>by</info> Delegate(d)
+}
+
+class A2<T>(x: Int, y: Int, t: T) {
+    val <info>t1</info>: T = t
+
+    val <info>x1</info> = run { x }
+    <info>init</info> {
+        run {
+            y
+        }
+    }
+}
+
+
+//captured
+
+class B(
+        <info descr="Value captured in a closure">x</info>: Int,
+        <info descr="Value captured in a closure">y</info>: Int,
+        <info descr="Value captured in a closure">t</info>: Int,
+        <info descr="Value captured in a closure">d</info>: Int
+) {
+    <info>init</info> {
+        class C(<warning>a</warning>: Int = <info>x</info>): T <info>by</info> T1(<info>t</info>) {
+            val <info>a</info> = <info>y</info>
+            val b <info>by</info> Delegate(<info>d</info>)
+        }
+    }
+}
+
+class B2(<info descr="Value captured in a closure">x</info>: Int, <info descr="Value captured in a closure">y</info>: Int) {
+
+    val <info>x1</info> =  { <info>x</info> }()
+    <info>init</info> {
+        {
+            <info>y</info>
+        }()
+    }
+}

idea/testData/checker/infos/PropertiesWithBackingFields.kt

@@ -42,12 +42,12 @@
 
 <info>open</info> class Super(<warning>i</warning> : Int)
 
-class TestPCParameters(<info>w</info> : Int, <warning>x</warning> : Int, val <info>y</info> : Int, var <info>z</info> : Int) : Super(<info>w</info>) {
+class TestPCParameters(w : Int, <warning>x</warning> : Int, val <info>y</info> : Int, var <info>z</info> : Int) : Super(w) {
 
-  val <info>xx</info> = <info descr="Value captured in a closure">w</info>
+  val <info>xx</info> = w
 
   <info>init</info> {
-    <info>w</info> + 1
+    w + 1
   }
 
   fun foo() = <error>x</error>

idea/tests/org/jetbrains/kotlin/checkers/JetPsiCheckerTestGenerated.java

@@ -681,6 +681,12 @@ public class JetPsiCheckerTestGenerated extends AbstractJetPsiCheckerTest {
             JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/checker/infos"), Pattern.compile("^(.+)\\.kt$"), true);
         }
 
+        @TestMetadata("CapturedConstructorParameter.kt")
+        public void testCapturedConstructorParameter() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("idea/testData/checker/infos/CapturedConstructorParameter.kt");
+            doTestWithInfos(fileName);
+        }
+
         @TestMetadata("CapturedInInlinedClosure.kt")
         public void testCapturedInInlinedClosure() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("idea/testData/checker/infos/CapturedInInlinedClosure.kt");