KT-2643 Support multi-declarations in Data-Flow analysis

#KT-2643 fixed

compiler/testData/cfg/MultiDecl.instructions

@@ -0,0 +1,40 @@
+== C ==
+class C {
+    fun component1() = 1
+    fun component2() = 2
+}
+---------------------
+l0:
+    <START>    NEXT:[<END>]     PREV:[]
+l1:
+    <END>      NEXT:[<SINK>]    PREV:[<START>]
+error:
+    <ERROR>    NEXT:[<SINK>]    PREV:[]
+sink:
+    <SINK>     NEXT:[]          PREV:[<ERROR>, <END>]
+=====================
+== test ==
+fun test(c: C) {
+    val (a, b) = c
+    val d = 1
+}
+---------------------
+l0:
+    <START>         NEXT:[v(c: C)]         PREV:[]
+    v(c: C)         NEXT:[w(c)]            PREV:[<START>]
+    w(c)            NEXT:[r(c)]            PREV:[v(c: C)]
+    r(c)            NEXT:[v(a)]            PREV:[w(c)]
+    v(a)            NEXT:[w(a)]            PREV:[r(c)]
+    w(a)            NEXT:[v(b)]            PREV:[v(a)]
+    v(b)            NEXT:[w(b)]            PREV:[w(a)]
+    w(b)            NEXT:[v(val d = 1)]    PREV:[v(b)]
+    v(val d = 1)    NEXT:[r(1)]            PREV:[w(b)]
+    r(1)            NEXT:[w(d)]            PREV:[v(val d = 1)]
+    w(d)            NEXT:[<END>]           PREV:[r(1)]
+l1:
+    <END>           NEXT:[<SINK>]          PREV:[w(d)]
+error:
+    <ERROR>         NEXT:[<SINK>]          PREV:[]
+sink:
+    <SINK>          NEXT:[]                PREV:[<ERROR>, <END>]
+=====================

compiler/testData/cfg/MultiDecl.jet

@@ -0,0 +1,11 @@
+package n
+
+class C {
+    fun component1() = 1
+    fun component2() = 2
+}
+
+fun test(c: C) {
+    val (a, b) = c
+    val d = 1
+}

compiler/testData/diagnostics/tests/declarationChecks/ComponentFunctionReturnTypeMismatch.kt

@@ -3,6 +3,6 @@ class A {
     fun component2() : Int = 2
 }
 
-fun a(<!UNUSED_PARAMETER!>aa<!> : A) {
-    val (a: String, b1: String) = <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH, COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>aa<!>
+fun a(aa : A) {
+    val (<!UNUSED_VARIABLE!>a<!>: String, <!UNUSED_VARIABLE!>b1<!>: String) = <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH, COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>aa<!>
 }

compiler/testData/diagnostics/tests/declarationChecks/DataFlowInfoInMultiDecl.kt

@@ -5,10 +5,10 @@ class A {
 
 fun a(aa : A?, b : Any) {
     if (aa != null) {
-        val (a1, b1) = aa;
+        val (<!UNUSED_VARIABLE!>a1<!>, <!UNUSED_VARIABLE!>b1<!>) = aa;
     }
 
     if (b is A) {
-        val (a1, b1) = b;
+        val (<!UNUSED_VARIABLE!>a1<!>, <!UNUSED_VARIABLE!>b1<!>) = b;
     }
-}
+}

compiler/testData/diagnostics/tests/declarationChecks/MultiDeclarationErrors.kt

@@ -9,7 +9,7 @@ class MyClass2 {}
 <!CONFLICTING_OVERLOADS!>fun MyClass2.component1()<!> = 1.2
 <!CONFLICTING_OVERLOADS!>fun MyClass2.component1()<!> = 1.3
 
-fun test(<!UNUSED_PARAMETER!>mc1<!>: MyClass, <!UNUSED_PARAMETER!>mc2<!>: MyClass2) {
+fun test(mc1: MyClass, mc2: MyClass2) {
     val (a, b) = <!COMPONENT_FUNCTION_MISSING, COMPONENT_FUNCTION_MISSING!>mc1<!>
     val (c) = <!COMPONENT_FUNCTION_AMBIGUITY!>mc2<!>
 

compiler/testData/diagnostics/tests/declarationChecks/RedeclarationsInMultiDecl.kt

@@ -4,11 +4,11 @@ class A {
 }
 
 fun a() {
-    val (<!REDECLARATION!>a<!>, <!REDECLARATION!>a<!>) = A()
-    val (x, <!REDECLARATION!>y<!>) = A();
+    val (<!REDECLARATION, UNUSED_VARIABLE!>a<!>, <!REDECLARATION, UNUSED_VARIABLE!>a<!>) = A()
+    val (<!UNUSED_VARIABLE!>x<!>, <!REDECLARATION, UNUSED_VARIABLE!>y<!>) = A();
     val <!REDECLARATION!>b<!> = 1
     use(b)
-    val (<!REDECLARATION!>b<!>, <!REDECLARATION!>y<!>) = A();
+    val (<!REDECLARATION, UNUSED_VARIABLE!>b<!>, <!REDECLARATION, UNUSED_VARIABLE!>y<!>) = A();
 }
 
 

compiler/testData/diagnostics/tests/declarationChecks/kt2631_MultipleDeclaration.kt

@@ -10,7 +10,7 @@ class MyClass2 {}
 
 fun MyClass2.component1() = 1.2
 
-fun test(<!UNUSED_PARAMETER!>mc1<!>: MyClass, <!UNUSED_PARAMETER!>mc2<!>: MyClass2) {
+fun test(mc1: MyClass, mc2: MyClass2) {
     val (a, b) = mc1
     a : Int
     b : String

compiler/testData/diagnostics/tests/declarationChecks/kt2643MultiDeclInControlFlow.kt

@@ -0,0 +1,27 @@
+//KT-2643 Support multi-declarations in Data-Flow analysis
+package n
+
+class C {
+    fun component1() = 1
+    fun component2() = 2
+}
+
+fun test1(c: C) {
+    val (<!UNUSED_VARIABLE!>a<!>, <!UNUSED_VARIABLE!>b<!>) = c
+}
+
+fun test2(c: C) {
+    val (a, <!UNUSED_VARIABLE!>b<!>) = c
+    a + 3
+}
+
+fun test3(c: C) {
+    var (<!ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE!>a<!>, <!UNUSED_VARIABLE!>b<!>) = c
+    a = <!UNUSED_VALUE!>3<!>
+}
+
+fun test4(c: C) {
+    var (<!VARIABLE_WITH_REDUNDANT_INITIALIZER!>a<!>, <!UNUSED_VARIABLE!>b<!>) = c
+    a = 3
+    a + 1
+}