Modify various usages of old PSI structure of primary ctor

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

@@ -671,8 +671,10 @@ public class JetFlowInformationProvider {
                                             return;
                                         }
                                         report(Errors.UNUSED_PARAMETER.on((JetParameter) element, variableDescriptor), ctxt);
-                                    } else if (owner instanceof JetClass) {
+                                    }
-                                        if (!((JetParameter) element).hasValOrVarNode() && !((JetClass) owner).isAnnotation()) {
+                                    else if (owner instanceof JetPrimaryConstructor) {
+                                        if (!((JetParameter) element).hasValOrVarNode() &&
+                                            !((JetPrimaryConstructor) owner).getContainingClass().isAnnotation()) {
                                             report(Errors.UNUSED_PARAMETER.on((JetParameter) element, variableDescriptor), ctxt);
                                         }
                                     }

compiler/frontend/src/org/jetbrains/kotlin/psi/JetPsiFactory.kt

@@ -309,8 +309,8 @@ public class JetPsiFactory(private val project: Project) {
         return importDirective.getParent() as JetImportList
     }
 
-    public fun createPrimaryConstructor(): PsiElement {
+    public fun createPrimaryConstructor(): JetPrimaryConstructor {
-        return createClass("class A()").findElementAt(7)!!.getParent()!!
+        return createClass("class A()").getPrimaryConstructor()!!
     }
 
     public fun createClassLabel(labelName: String): JetSimpleNameExpression {

compiler/frontend/src/org/jetbrains/kotlin/psi/JetPsiUtil.java

@@ -451,9 +451,9 @@ public class JetPsiUtil {
     @Nullable
     public static JetClass getClassIfParameterIsProperty(@NotNull JetParameter jetParameter) {
         if (jetParameter.hasValOrVarNode()) {
-            PsiElement parent = jetParameter.getParent();
+            PsiElement grandParent = jetParameter.getParent().getParent();
-            if (parent instanceof JetParameterList && parent.getParent() instanceof JetClass) {
+            if (grandParent instanceof JetPrimaryConstructor) {
-                return (JetClass) parent.getParent();
+                return ((JetPrimaryConstructor) grandParent).getContainingClassOrNull();
             }
         }
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyDeclarationResolver.java

@@ -141,8 +141,8 @@ public class LazyDeclarationResolver {
             @Override
             public DeclarationDescriptor visitParameter(@NotNull JetParameter parameter, Void data) {
                 PsiElement grandFather = parameter.getParent().getParent();
-                if (grandFather instanceof JetClass) {
+                if (grandFather instanceof JetPrimaryConstructor) {
-                    JetClass jetClass = (JetClass) grandFather;
+                    JetClass jetClass = ((JetPrimaryConstructor) grandFather).getContainingClass();
                     // This is a primary constructor parameter
                     ClassDescriptor classDescriptor = getClassDescriptor(jetClass);
                     if (parameter.hasValOrVarNode()) {

compiler/light-classes/src/org/jetbrains/kotlin/asJava/duplicateJvmSignatureUtil.kt

@@ -18,20 +18,15 @@ package org.jetbrains.kotlin.asJava
 
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.psi.JetClassBody
-import org.jetbrains.kotlin.psi.JetClassOrObject
 import com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.kotlin.psi.JetPropertyAccessor
 import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm.*
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.ConflictingJvmDeclarationsData
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKind.*
 import org.jetbrains.kotlin.diagnostics.Errors.*
 import org.jetbrains.kotlin.diagnostics.DiagnosticFactory.*
-import org.jetbrains.kotlin.psi.JetParameter
-import org.jetbrains.kotlin.psi.JetClass
 import org.jetbrains.kotlin.diagnostics.DiagnosticFactory
+import org.jetbrains.kotlin.psi.*
 
 public fun getJvmSignatureDiagnostics(element: PsiElement, otherDiagnostics: Diagnostics, moduleScope: GlobalSearchScope): Diagnostics? {
     fun getDiagnosticsForPackage(file: JetFile): Diagnostics? {
@@ -51,7 +46,7 @@ public fun getJvmSignatureDiagnostics(element: PsiElement, otherDiagnostics: Dia
         }
         if (element is JetParameter && element.getValOrVarNode() != null) {
             // property declared in constructor
-            val parentClass = parent?.getParent() as? JetClass
+            val parentClass = (parent?.getParent()?.getParent() as? JetClass)
             if (parentClass != null) {
                 return getDiagnosticsForClass(parentClass)
             }

compiler/light-classes/src/org/jetbrains/kotlin/asJava/lightClassUtils.kt

@@ -75,7 +75,7 @@ public fun JetParameter.toPsiParameter(): PsiParameter? {
     val method: PsiMethod? = when (owner) {
         is JetFunction -> LightClassUtil.getLightClassMethod(owner)
         is JetPropertyAccessor -> LightClassUtil.getLightClassAccessorMethod(owner)
-        is JetClass -> LightClassUtil.getPsiClass(owner)?.getConstructors()?.let { constructors ->
+        is JetPrimaryConstructor -> LightClassUtil.getPsiClass(owner.getContainingClass())?.getConstructors()?.let { constructors ->
             if (constructors.isNotEmpty()) constructors[0] else null
         }
         else -> null

idea/src/org/jetbrains/kotlin/idea/inspections/UnusedSymbolInspection.kt

@@ -104,7 +104,7 @@ public class UnusedSymbolInspection : AbstractKotlinInspection() {
                 if (declaration is JetEnumEntry) return
                 if (declaration.hasModifier(JetTokens.OVERRIDE_KEYWORD)) return
                 if (declaration is JetProperty && declaration.isLocal()) return
-                if (declaration is JetParameter && (declaration.getParent()?.getParent() !is JetClass || !declaration.hasValOrVarNode())) return
+                if (declaration is JetParameter && (declaration.getParent()?.getParent() !is JetPrimaryConstructor || !declaration.hasValOrVarNode())) return
                 if (declaration is JetNamedFunction && isConventionalName(declaration)) return
 
                 // More expensive, resolve-based checks

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetFunctionDefinitionUsage.java

@@ -285,7 +285,11 @@ public class JetFunctionDefinitionUsage<T extends PsiElement> extends JetUsageIn
                     anchor = ((JetClass) element).getNameIdentifier();
                 }
                 if (anchor != null) {
-                    newParameterList = (JetParameterList) element.addAfter(newParameterList, anchor);
+                    JetPrimaryConstructor constructor =
+                            (JetPrimaryConstructor) element.addAfter(psiFactory.createPrimaryConstructor(), anchor);
+                    JetParameterList oldParameterList = constructor.getValueParameterList();
+                    assert oldParameterList != null : "primary constructor from factory has parameter list";
+                    newParameterList = (JetParameterList) oldParameterList.replace(newParameterList);
                 }
             }
             else if (isLambda) {
@@ -339,7 +343,9 @@ public class JetFunctionDefinitionUsage<T extends PsiElement> extends JetUsageIn
             ((JetFunction)element).addModifier(newVisibilityToken);
         }
         else {
-            ((JetClass)element).addPrimaryConstructorModifier(newVisibilityToken);
+            JetPrimaryConstructor constructor = ((JetClass) element).getPrimaryConstructor();
+            assert constructor != null : "Primary constructor should be created before changing visibility";
+            constructor.addModifier(newVisibilityToken);
         }
     }