KT-6671 Report unused constructor parameters

#KT-6671 fixed

compiler/frontend/src/org/jetbrains/kotlin/cfg/JetFlowInformationProvider.java

@@ -641,18 +641,22 @@ public class JetFlowInformationProvider {
                                     report(Errors.UNUSED_VARIABLE.on((JetNamedDeclaration) element, variableDescriptor), ctxt);
                                 }
                                 else if (element instanceof JetParameter) {
-                                    PsiElement psiElement = element.getParent().getParent();
+                                    PsiElement owner = element.getParent().getParent();
-                                    if (psiElement instanceof JetFunction) {
+                                    if (owner instanceof JetFunction) {
                                         MainFunctionDetector mainFunctionDetector = new MainFunctionDetector(trace.getBindingContext());
-                                        boolean isMain = (psiElement instanceof JetNamedFunction) && mainFunctionDetector.isMain((JetNamedFunction) psiElement);
+                                        boolean isMain = (owner instanceof JetNamedFunction) && mainFunctionDetector.isMain((JetNamedFunction) owner);
-                                        if (psiElement instanceof JetFunctionLiteral) return;
+                                        if (owner instanceof JetFunctionLiteral) return;
-                                        DeclarationDescriptor descriptor = trace.get(BindingContext.DECLARATION_TO_DESCRIPTOR, psiElement);
+                                        DeclarationDescriptor descriptor = trace.get(BindingContext.DECLARATION_TO_DESCRIPTOR, owner);
-                                        assert descriptor instanceof FunctionDescriptor : psiElement.getText();
+                                        assert descriptor instanceof FunctionDescriptor : owner.getText();
                                         FunctionDescriptor functionDescriptor = (FunctionDescriptor) descriptor;
                                         if (!isMain && !functionDescriptor.getModality().isOverridable()
                                                 && functionDescriptor.getOverriddenDescriptors().isEmpty()) {
                                             report(Errors.UNUSED_PARAMETER.on((JetParameter) element, variableDescriptor), ctxt);
                                         }
+                                    } else if (owner instanceof JetClass) {
+                                        if (!((JetParameter) element).hasValOrVarNode() && !((JetClass) owner).isAnnotation()) {
+                                            report(Errors.UNUSED_PARAMETER.on((JetParameter) element, variableDescriptor), ctxt);
+                                        }
                                     }
                                 }
                             }

compiler/testData/diagnostics/tests/Abstract.kt

@@ -52,7 +52,7 @@ abstract class B1(
 
 class B2() : B1(1, "r") {}
 
-abstract class B3(i: Int) {
+abstract class B3(<!UNUSED_PARAMETER!>i<!>: Int) {
 }
 
 fun foo(<!UNUSED_PARAMETER!>c<!>: B3) {

compiler/testData/diagnostics/tests/Constructors.kt

@@ -10,7 +10,7 @@ class WithC2() : <!SUPERTYPE_NOT_INITIALIZED!>WithC1<!>
 class WithPC0() {
 }
 
-class WithPC1(a : Int) {
+class WithPC1(<!UNUSED_PARAMETER!>a<!> : Int) {
 }
 
 
@@ -18,7 +18,7 @@ class Foo() : <!SUPERTYPE_NOT_INITIALIZED, FINAL_SUPERTYPE!>WithPC0<!>, <!SYNTAX
 
 }
 
-class WithCPI_Dup(x : Int) {
+class WithCPI_Dup(<!UNUSED_PARAMETER!>x<!> : Int) {
   <!MUST_BE_INITIALIZED_OR_BE_ABSTRACT!>var x : Int<!>
 }
 

compiler/testData/diagnostics/tests/DefaultValuesTypechecking.kt

@@ -6,7 +6,7 @@ fun bar(x : Int = <!TYPE_MISMATCH!>""<!>, y : Int = x, <!UNUSED_PARAMETER!>z<!>
 
 // KT-371 Resolve default parameters for constructors
 
-class A(x : Int = <!UNINITIALIZED_PARAMETER!>y<!>, y : Int = x) { // None of the references is resolved, no types checked
+class A(x : Int = <!UNINITIALIZED_PARAMETER!>y<!>, <!UNUSED_PARAMETER!>y<!> : Int = x) { // None of the references is resolved, no types checked
     fun foo(<!UNUSED_PARAMETER!>bool<!>: Boolean, a: Int = <!TYPE_MISMATCH, UNINITIALIZED_PARAMETER!>b<!>, <!UNUSED_PARAMETER!>b<!>: String = <!TYPE_MISMATCH!>a<!>) {}
 }
 

compiler/testData/diagnostics/tests/UnusedParameters.kt

@@ -0,0 +1,15 @@
+class C(a: Int, b: Int, c: Int, d: Int, <!UNUSED_PARAMETER!>e<!>: Int = d, val f: String) {
+    {
+        a + a
+    }
+
+    val g = b
+
+    {
+        c + c
+    }
+}
+
+fun f(a: Int, b: Int, <!UNUSED_PARAMETER!>c<!>: Int = b) {
+    a + a
+}

compiler/testData/diagnostics/tests/UnusedParameters.txt

@@ -0,0 +1,12 @@
+package
+
+internal fun f(/*0*/ a: kotlin.Int, /*1*/ b: kotlin.Int, /*2*/ c: kotlin.Int = ...): kotlin.Unit
+
+internal final class C {
+    public constructor C(/*0*/ a: kotlin.Int, /*1*/ b: kotlin.Int, /*2*/ c: kotlin.Int, /*3*/ d: kotlin.Int, /*4*/ e: kotlin.Int = ..., /*5*/ f: kotlin.String)
+    internal final val f: kotlin.String
+    internal final val g: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/tests/annotations/kt1860-negative.kt

@@ -5,5 +5,5 @@ var bar : Int = 1
 
 val x : (Int) -> Int = {([<!UNRESOLVED_REFERENCE!>varargs<!>] x : Int) -> x}
 
-class Hello(<!UNRESOLVED_REFERENCE!>varargs<!> args: Any) {
+class Hello(<!UNRESOLVED_REFERENCE!>varargs<!> <!UNUSED_PARAMETER!>args<!>: Any) {
 }

compiler/testData/diagnostics/tests/annotations/kt1860-positive.kt

@@ -7,5 +7,5 @@ var bar : Int = 1
 
 val x : (Int) -> Int = {([test] x : Int) -> x}
 
-class Hello(test args: Any) {
+class Hello(test <!UNUSED_PARAMETER!>args<!>: Any) {
 }

compiler/testData/diagnostics/tests/classObjects/classObjectHeader.kt

@@ -1,6 +1,6 @@
 package test
 
-open class ToResolve<SomeClass>(f : (Int) -> Int)
+open class ToResolve<SomeClass>(<!UNUSED_PARAMETER!>f<!> : (Int) -> Int)
 fun testFun(<!UNUSED_PARAMETER!>a<!> : Int) = 12
 
 class TestSome<P> {

compiler/testData/diagnostics/tests/controlFlowAnalysis/UninitializedOrReassignedVariables.kt

@@ -192,7 +192,7 @@ fun reassignFunParams(a: Int) {
     <!VAL_REASSIGNMENT!>a<!> = <!UNUSED_VALUE!>1<!>
 }
 
-open class Open(a: Int, w: Int) {}
+open class Open(<!UNUSED_PARAMETER!>a<!>: Int, <!UNUSED_PARAMETER!>w<!>: Int) {}
 
 class LocalValsVsProperties(val a: Int, w: Int) : Open(a, w) {
     val x : Int

compiler/testData/diagnostics/tests/controlStructures/kt657.kt

@@ -1,7 +1,7 @@
 //KT-657 Semantic checks for when without condition
 package kt657
 
-class Pair<A, B>(a: A, b: B)
+class Pair<A, B>(<!UNUSED_PARAMETER!>a<!>: A, <!UNUSED_PARAMETER!>b<!>: B)
 
 fun foo() =
     when {

compiler/testData/diagnostics/tests/controlStructures/when.kt234.kt973.kt

@@ -3,7 +3,7 @@
 
 package kt234_kt973
 
-class Pair<A, B>(a: A, b: B)
+class Pair<A, B>(<!UNUSED_PARAMETER!>a<!>: A, <!UNUSED_PARAMETER!>b<!>: B)
 
 fun test(t : Pair<Int, Int>) : Int {
     when (t) {

compiler/testData/diagnostics/tests/dataClasses/bothParamsAreNotProperties.kt

@@ -1,4 +1,4 @@
-data class A(x: Int, y: String)
+data class A(<!UNUSED_PARAMETER!>x<!>: Int, <!UNUSED_PARAMETER!>y<!>: String)
 
 fun foo(a: A) {
     a.<!UNRESOLVED_REFERENCE!>component1<!>()

compiler/testData/diagnostics/tests/dataClasses/firstParamIsVal.kt

@@ -1,4 +1,4 @@
-data class A(val x: Int, y: String)
+data class A(val x: Int, <!UNUSED_PARAMETER!>y<!>: String)
 
 fun foo(a: A) {
     a.component1() : Int

compiler/testData/diagnostics/tests/dataClasses/firstParamIsVar.kt

@@ -1,4 +1,4 @@
-data class A(var x: Int, y: String)
+data class A(var x: Int, <!UNUSED_PARAMETER!>y<!>: String)
 
 fun foo(a: A) {
     a.component1() : Int

compiler/testData/diagnostics/tests/dataClasses/secondParamIsVal.kt

@@ -1,4 +1,4 @@
-data class A(x: Int, val y: String)
+data class A(<!UNUSED_PARAMETER!>x<!>: Int, val y: String)
 
 fun foo(a: A) {
     a.component1() : String

compiler/testData/diagnostics/tests/dataClasses/secondParamIsVar.kt

@@ -1,4 +1,4 @@
-data class A(x: Int, var y: String)
+data class A(<!UNUSED_PARAMETER!>x<!>: Int, var y: String)
 
 fun foo(a: A) {
     a.component1() : String

compiler/testData/diagnostics/tests/dataFlow/local/LocalClassBase.kt

@@ -1,4 +1,4 @@
-open class Base(x: String, y: Int)
+open class Base(<!UNUSED_PARAMETER!>x<!>: String, <!UNUSED_PARAMETER!>y<!>: Int)
 
 fun test(x: Any, y: Int?) {
   if (x !is String) return

compiler/testData/diagnostics/tests/dataFlow/local/LocalClassDefaultParameters.kt

@@ -1,7 +1,7 @@
 fun test(x: Any) {
   if (x !is String) return
 
-  class Local(s: String = <!DEBUG_INFO_SMARTCAST!>x<!>) {
+  class Local(<!UNUSED_PARAMETER!>s<!>: String = <!DEBUG_INFO_SMARTCAST!>x<!>) {
     fun foo(s: String = <!DEBUG_INFO_SMARTCAST!>x<!>): String = s
   }
 }

compiler/testData/diagnostics/tests/dataFlow/local/LocalClassInitializer.kt

@@ -13,4 +13,4 @@ fun f(a: Any?) {
 trait B {
   fun foo() {}
 }
-open class X(b: B)
+open class X(<!UNUSED_PARAMETER!>b<!>: B)

compiler/testData/diagnostics/tests/dataFlow/local/LocalObject.kt

@@ -6,4 +6,4 @@ fun foo(x: Any?) {
     }
 }
 
-open class Base(s: String)
+open class Base(<!UNUSED_PARAMETER!>s<!>: String)

compiler/testData/diagnostics/tests/delegatedProperty/genericGetter.kt

@@ -1,6 +1,6 @@
 val a: Int by A(1)
 
-class A<T: Any>(i: T) {
+class A<T: Any>(<!UNUSED_PARAMETER!>i<!>: T) {
   fun get(t: Any?, p: PropertyMetadata): T {
     t.equals(p) // to avoid UNUSED_PARAMETER warning
     throw Exception()

compiler/testData/diagnostics/tests/delegatedProperty/recursiveType.kt

@@ -5,7 +5,7 @@ val b by Delegate(<!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>b<!>)
 val c by <!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!>d<!>
 val d by <!TYPECHECKER_HAS_RUN_INTO_RECURSIVE_PROBLEM!>c<!>
 
-class Delegate(i: Int) {
+class Delegate(<!UNUSED_PARAMETER!>i<!>: Int) {
   fun get(t: Any?, p: PropertyMetadata): Int {
     t.equals(p) // to avoid UNUSED_PARAMETER warning
     return 1

compiler/testData/diagnostics/tests/delegatedProperty/thisInDelegate.kt

@@ -4,7 +4,7 @@ class A {
   val Int.a by Delegate(<!TYPE_MISMATCH!>this<!>)
 }
 
-class Delegate(i: Int) {
+class Delegate(<!UNUSED_PARAMETER!>i<!>: Int) {
   fun get(t: Any?, p: PropertyMetadata): Int {
     t.equals(p) // to avoid UNUSED_PARAMETER warning
     return 1

compiler/testData/diagnostics/tests/delegation/DelegationAndOverriding.kt

@@ -5,7 +5,7 @@ trait T {
     val v : Int
 }
 
-open <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class Br<!>(t : T) : T {
+open <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>class Br<!>(<!UNUSED_PARAMETER!>t<!> : T) : T {
 
 }
 

compiler/testData/diagnostics/tests/extensions/kt3563.kt

@@ -4,7 +4,7 @@ package bar
 
 import java.io.File
 
-class Customer(name: String)
+class Customer(<!UNUSED_PARAMETER!>name<!>: String)
 
 fun foo(f: File, c: Customer) {
     f.name

compiler/testData/diagnostics/tests/inference/constraints/kt6320.kt

@@ -3,7 +3,7 @@
 
 class A<X, Y : X>
 
-class B<X, Y : X>(foo: A<X, Y>) {
+class B<X, Y : X>(<!UNUSED_PARAMETER!>foo<!>: A<X, Y>) {
     fun test1(a: A<X, Y>) {
         B(a)
         val b: B<X, Y> = B(a)
@@ -13,7 +13,7 @@ class B<X, Y : X>(foo: A<X, Y>) {
 
 class C<X, Z, Y : X>
 
-class D<X, Z, Y : X>(foo: C<X, Z, Y>) {
+class D<X, Z, Y : X>(<!UNUSED_PARAMETER!>foo<!>: C<X, Z, Y>) {
     fun test(a: C<Y, Y, Y>) {
         val d: D<X, Y, Y> = <!TYPE_MISMATCH!>D(a)<!>
     }

compiler/testData/diagnostics/tests/inference/dependantOnVariance.kt

@@ -1,6 +1,6 @@
 package a
 
-class MyList<T>(t: T) {}
+class MyList<T>(<!UNUSED_PARAMETER!>t<!>: T) {}
 
 fun <T> getMyList(t: T)           : MyList<    T> = MyList(t)
 fun <T> getMyListToWriteTo(t: T)  : MyList< in T> = MyList(t)

compiler/testData/diagnostics/tests/inference/upperBounds/useBoundsIfUnknownParameters.kt

@@ -3,7 +3,7 @@ package Hello
 open class Base<T>
 class StringBase : Base<String>()
 
-class Client<T, X: Base<T>>(x: X)
+class Client<T, X: Base<T>>(<!UNUSED_PARAMETER!>x<!>: X)
 
 fun test() {
     val c = Client(StringBase()) // Type inference fails here for T.

compiler/testData/diagnostics/tests/infos/PropertiesWithBackingFields.kt

@@ -44,9 +44,9 @@ abstract class Test() {
 
 }
 
-open class Super(i : Int)
+open class Super(<!UNUSED_PARAMETER!>i<!> : Int)
 
-class TestPCParameters(w : Int, x : Int, val y : Int, var z : Int) : Super(w) {
+class TestPCParameters(w : Int, <!UNUSED_PARAMETER!>x<!> : Int, val y : Int, var z : Int) : Super(w) {
 
   val xx = w
 

compiler/testData/diagnostics/tests/inline/constructor.kt

@@ -1,4 +1,4 @@
-class Z(s: (Int) -> Int) {
+class Z(<!UNUSED_PARAMETER!>s<!>: (Int) -> Int) {
 
 }
 

compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.kt

@@ -27,20 +27,20 @@ class FinalClass() {
 annotation class annotated(val text: String = "not given")
 
 //Check legal modifiers in constructor
-class LegalModifier(val a: Int, annotated private var b: String, annotated vararg v: Int)
+class LegalModifier(val a: Int, annotated private var b: String, annotated vararg <!UNUSED_PARAMETER!>v<!>: Int)
 
 //Check illegal modifier in constructor parameters
-class IllegalModifiers1(<!ILLEGAL_MODIFIER!>private<!> a: Int)
+class IllegalModifiers1(<!ILLEGAL_MODIFIER!>private<!> <!UNUSED_PARAMETER!>a<!>: Int)
 
 //Check multiple illegal modifiers in constructor
-class IllegalModifiers2(<!ILLEGAL_MODIFIER!>private<!> <!ILLEGAL_MODIFIER!>abstract<!> a: Int)
+class IllegalModifiers2(<!ILLEGAL_MODIFIER!>private<!> <!ILLEGAL_MODIFIER!>abstract<!> <!UNUSED_PARAMETER!>a<!>: Int)
 
 
 //Check annotations with illegal modifiers in constructor
-class IllegalModifiers3(annotated <!ILLEGAL_MODIFIER!>public<!> <!ILLEGAL_MODIFIER!>abstract<!> b: String)
+class IllegalModifiers3(annotated <!ILLEGAL_MODIFIER!>public<!> <!ILLEGAL_MODIFIER!>abstract<!> <!UNUSED_PARAMETER!>b<!>: String)
 
 //Check annotations and vararg with illegal modifiers in constructor
-class IllegalModifiers4(val a: Int, annotated("a text") <!ILLEGAL_MODIFIER!>protected<!> vararg v: Int)
+class IllegalModifiers4(val a: Int, annotated("a text") <!ILLEGAL_MODIFIER!>protected<!> vararg <!UNUSED_PARAMETER!>v<!>: Int)
 
 //Check illegal modifiers for functions and catch block
 abstract class IllegalModifiers5() {

compiler/testData/diagnostics/tests/objects/Objects.kt

@@ -1,6 +1,6 @@
 package toplevelObjectDeclarations
 
-  open class Foo(y : Int) {
+  open class Foo(<!UNUSED_PARAMETER!>y<!> : Int) {
     open fun foo() : Int = 1
   }
 

compiler/testData/diagnostics/tests/platformTypes/methodCall/multipleExactBounds.kt

@@ -6,8 +6,8 @@ trait ResolverForModule
 trait ResolverForProject<M1, R1>
 
 class ResolverForProjectImpl<M : ModuleInfo, R : ResolverForModule>(
-        descriptorByModule: Map<M, ModuleDescriptorImpl>,
+        <!UNUSED_PARAMETER!>descriptorByModule<!>: Map<M, ModuleDescriptorImpl>,
-        delegateResolver: ResolverForProject<M, R>
+        <!UNUSED_PARAMETER!>delegateResolver<!>: ResolverForProject<M, R>
 ) : ResolverForProject<M, R>
 
 fun <M2: ModuleInfo, A: ResolverForModule> foo(delegateResolver: ResolverForProject<M2, A>): ResolverForProject<M2, A> {

compiler/testData/diagnostics/tests/platformTypes/methodCall/multipleExactBoundsNullable.kt

@@ -5,8 +5,8 @@ trait ResolverForProject<M1> {
 }
 
 class ResolverForProjectImpl<M>(
-        descriptorByModule: Map<M, String>,
+        <!UNUSED_PARAMETER!>descriptorByModule<!>: Map<M, String>,
-        delegateResolver: ResolverForProject<M>
+        <!UNUSED_PARAMETER!>delegateResolver<!>: ResolverForProject<M>
 ) : ResolverForProject<M>
 
 trait WithFoo {

compiler/testData/diagnostics/tests/resolve/incompleteConstructorInvocation.kt

@@ -1,6 +1,6 @@
 package p
 
-class X<V>(provider: () -> V, trackValue: Boolean) {
+class X<V>(<!UNUSED_PARAMETER!>provider<!>: () -> V, <!UNUSED_PARAMETER!>trackValue<!>: Boolean) {
 }
 
 class B {

compiler/testData/diagnostics/tests/scopes/kt250.617.10.kt

@@ -5,15 +5,15 @@ import java.util.HashMap
 
 //KT-250 Incorrect variable resolve in constructor arguments of superclass
 open class A(val x: Int)
-class B(y: Int) : A(<!UNRESOLVED_REFERENCE!>x<!>)  //x is resolved as a property in a, so no error is generated
+class B(<!UNUSED_PARAMETER!>y<!>: Int) : A(<!UNRESOLVED_REFERENCE!>x<!>)  //x is resolved as a property in a, so no error is generated
 
 //KT-617 Prohibit dollars in call to superclass constructors
-open class M(p: Int)
+open class M(<!UNUSED_PARAMETER!>p<!>: Int)
 class N(val p: Int) : A(<!UNRESOLVED_REFERENCE!>$p<!>)
 
 //KT-10 Don't allow to use properties in supertype initializers
 open class Element()
-class TextElement(name: String) : Element()
+class TextElement(<!UNUSED_PARAMETER!>name<!>: String) : Element()
 
 abstract class Tag(val name : String) {
   val children = ArrayList<Element>()
@@ -36,7 +36,7 @@ class Body1() : BodyTag(<!NO_THIS!>this<!>.<!DEBUG_INFO_ELEMENT_WITH_ERROR_TYPE!
 
 //more tests
 
-open class X(p: Int, r: Int) {
+open class X(<!UNUSED_PARAMETER!>p<!>: Int, <!UNUSED_PARAMETER!>r<!>: Int) {
     val s = "s"
 }
 

compiler/testData/diagnostics/tests/smartCasts/inference/kt2746.kt

@@ -1,6 +1,6 @@
 //KT-2746 Do.smartcasts in inference
 
-class C<T>(t :T)
+class C<T>(<!UNUSED_PARAMETER!>t<!> :T)
 
 fun test1(a: Any) {
     if (a is String) {

compiler/testData/diagnostics/tests/substitutions/kt4887.kt

@@ -1,6 +1,6 @@
 package h
 
-public class MyClass<S, T>(param: MyClass<S, T>) {
+public class MyClass<S, T>(<!UNUSED_PARAMETER!>param<!>: MyClass<S, T>) {
     fun test() {
         val result: MyClass<Any, Any>? = null
         MyClass<S, Any>(result <!CAST_NEVER_SUCCEEDS!>as<!> MyClass<S, Any>)

compiler/testData/diagnostics/tests/varargs/varargsAndPair.kt

@@ -1,6 +1,6 @@
 fun foo<T: Any>(vararg <!UNUSED_PARAMETER!>ts<!>: T): T? = null
 
-class Pair<A>(a: A)
+class Pair<A>(<!UNUSED_PARAMETER!>a<!>: A)
 
 fun test() {
     val v = foo(Pair(1))

compiler/testData/diagnostics/tests/variance/PrimaryConstructor.kt

@@ -17,9 +17,9 @@ class Test<in I, out O, P>(
         var type9: In<<!TYPE_VARIANCE_CONFLICT(I; in; invariant; In<I>)!>I<!>>,
         var type0: In<<!TYPE_VARIANCE_CONFLICT(O; out; invariant; In<O>)!>O<!>>,
 
-        type11: I,
+        <!UNUSED_PARAMETER!>type11<!>: I,
-        type12: O,
+        <!UNUSED_PARAMETER!>type12<!>: O,
-        type13: P,
+        <!UNUSED_PARAMETER!>type13<!>: P,
-        type14: In<I>,
+        <!UNUSED_PARAMETER!>type14<!>: In<I>,
-        type15: In<O>
+        <!UNUSED_PARAMETER!>type15<!>: In<O>
 )

compiler/tests/org/jetbrains/kotlin/checkers/JetDiagnosticsTestGenerated.java

@@ -526,6 +526,12 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
             doTest(fileName);
         }
 
+        @TestMetadata("UnusedParameters.kt")
+        public void testUnusedParameters() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/UnusedParameters.kt");
+            doTest(fileName);
+        }
+
         @TestMetadata("UnusedVariables.kt")
         public void testUnusedVariables() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/UnusedVariables.kt");

idea/testData/checker/Abstract.kt

@@ -164,7 +164,7 @@ abstract class B1(
 
 class B2() : B1(1, "r") {}
 
-abstract class B3(i: Int) {
+abstract class B3(<warning>i</warning>: Int) {
 }
 
 fun foo(<warning>a</warning>: B3) {

idea/testData/checker/Constructors.kt

@@ -14,7 +14,7 @@ class NoPC {
 class WithPC0() {
 }
 
-class WithPC1(a : Int) {
+class WithPC1(<warning>a</warning> : Int) {
 }
 
 
@@ -22,7 +22,7 @@ class Foo() : <error>WithPC0</error>(), <error>this</error>() {
 
 }
 
-class WithCPI_Dup(x : Int) {
+class WithCPI_Dup(<warning>x</warning> : Int) {
   <error>var x : Int</error>
 }
 

idea/testData/checker/Objects.kt

@@ -1,5 +1,5 @@
 package toplevelObjectDeclarations
-  open class Foo(y : Int) {
+  open class Foo(<warning>y</warning> : Int) {
     open fun foo() : Int = 1
   }
 

idea/testData/checker/Unresolved.kt

@@ -1,6 +1,6 @@
 package unresolved
 
-class Pair<A, B>(a: A, b: B)
+class Pair<A, B>(<warning>a</warning>: A, <warning>b</warning>: B)
 
 fun testGenericArgumentsCount() {
     val <warning>p1</warning>: Pair<error><Int></error> = Pair(2, 2)

idea/testData/checker/infos/PropertiesWithBackingFields.kt

@@ -40,9 +40,9 @@
 
 }
 
-<info>open</info> class Super(i : Int)
+<info>open</info> class Super(<warning>i</warning> : Int)
 
-class TestPCParameters(w : Int, x : Int, val <info>y</info> : Int, var <info>z</info> : Int) : Super(w) {
+class TestPCParameters(w : Int, <warning>x</warning> : Int, val <info>y</info> : Int, var <info>z</info> : Int) : Super(w) {
 
   val <info>xx</info> = w
 

idea/testData/highlighter/deprecated/Class.kt

@@ -14,7 +14,7 @@ fun test() {
 
 class Test(): <warning descr="'test.MyClass' is deprecated. Use A instead">MyClass</warning>() {}
 
-class Test2(param: <warning descr="'test.MyClass' is deprecated. Use A instead">MyClass</warning>) {}
+class Test2(<warning>param</warning>: <warning descr="'test.MyClass' is deprecated. Use A instead">MyClass</warning>) {}
 
 // NO_CHECK_INFOS
 // NO_CHECK_WEAK_WARNINGS

idea/testData/highlighter/deprecated/Trait.kt

@@ -8,7 +8,7 @@ fun test() {
 
 class Test(): <warning descr="'MyTrait' is deprecated. Use A instead">MyTrait</warning> { }
 
-class Test2(param: <warning descr="'MyTrait' is deprecated. Use A instead">MyTrait</warning>) {}
+class Test2(<warning>param</warning>: <warning descr="'MyTrait' is deprecated. Use A instead">MyTrait</warning>) {}
 
 // NO_CHECK_INFOS
 // NO_CHECK_WEAK_WARNINGS