Add some local mutability analysis to hide the intention when class is 100% mutable

Author: vldF

src/main/kotlin/com/vk/kphpstorm/intentions/AddImmutableClassAnnotationIntention.kt

@@ -6,6 +6,10 @@ import com.intellij.codeInspection.util.IntentionName
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiElement
+import com.intellij.psi.search.LocalSearchScope
+import com.intellij.psi.search.searches.ReferencesSearch
+import com.intellij.psi.util.findParentInFile
+import com.jetbrains.php.lang.psi.elements.AssignmentExpression
 import com.jetbrains.php.lang.psi.elements.PhpClass
 import com.vk.kphpstorm.inspections.helpers.PhpDocPsiBuilder
 import com.vk.kphpstorm.kphptags.KphpImmutableClassDocTag
@@ -24,10 +28,46 @@ class AddImmutableClassAnnotationIntention : PsiElementBaseIntentionAction() {
         }
 
         val klass = element.parent as PhpClass
-        val klassDocNode = klass.docComment ?: return true
+        val klassDocNode = klass.docComment
 
         // do not suggest if already present
-        return !KphpImmutableClassDocTag.existsInDocComment(klassDocNode)
+        if (klassDocNode != null && KphpImmutableClassDocTag.existsInDocComment(klassDocNode)) {
+            return false
+        }
+
+        return !isClassLocallyImmutable(klass)
+    }
+
+    /**
+     * Simple local class mutability check. If there is any field mutation in class,
+     * the class is mutable. The only exception is the class constructor
+     */
+    private fun isClassLocallyImmutable(klass: PhpClass): Boolean {
+        val searchScope = LocalSearchScope(klass)
+        for (field in klass.fields) {
+            val hasAnyMutation = ReferencesSearch.search(field, searchScope).any { ref ->
+                val element = ref.element
+
+                isMutatingOp(element) && !isInClassConstructor(klass, element)
+            }
+
+            if (hasAnyMutation) {
+                return true
+            }
+        }
+
+        return false
+    }
+
+    private fun isMutatingOp(psiElement: PsiElement): Boolean {
+        val parent = psiElement.parent
+
+        return parent is AssignmentExpression
+    }
+
+    private fun isInClassConstructor(klass: PhpClass, psiElement: PsiElement): Boolean {
+        val classConstructor = klass.constructor
+        return classConstructor != null && psiElement.findParentInFile { e -> e == classConstructor } != null
     }
 
     override fun invoke(

src/test/fixtures/kphp_intentions/immutable_class_intention-5.nointention.php

@@ -0,0 +1,9 @@
+<?php
+
+class <caret>C1 {
+    public int $field;
+
+    public function foo() {
+        $this->field = 1; // mutate the field
+    }
+}

src/test/fixtures/kphp_intentions/immutable_class_intention-6.fixture.php

@@ -0,0 +1,10 @@
+<?php
+
+class <caret>C1 {
+    public int $field;
+
+    public function __construct(int $arg)
+    {
+        $this->field = $arg; // field mutation in constructor, that's ok
+    }
+}

src/test/fixtures/kphp_intentions/immutable_class_intention-6.qf.php

@@ -0,0 +1,13 @@
+<?php
+
+/**
+ * @kphp-immutable-class
+ */
+class <caret>C1 {
+    public int $field;
+
+    public function __construct(int $arg)
+    {
+        $this->field = $arg; // field mutation in constructor, that's ok
+    }
+}

src/test/fixtures/kphp_intentions/immutable_class_intention-7.fixture.php

@@ -0,0 +1,11 @@
+<?php
+
+class <caret>C1 {
+    public int $field;
+}
+
+public function foo()
+{
+    $v = new C1();
+    $v->field = 1; // mutation outside of a class, that's ok
+}

src/test/fixtures/kphp_intentions/immutable_class_intention-7.qf.php

@@ -0,0 +1,14 @@
+<?php
+
+/**
+ * @kphp-immutable-class
+ */
+class <caret>C1 {
+    public int $field;
+}
+
+public function foo()
+{
+    $v = new C1();
+    $v->field = 1; // mutation outside of a class, that's ok
+}

src/test/kotlin/com/vk/kphpstorm/testing/tests/AddImmutableAnnoIntentionTest.kt

@@ -19,4 +19,16 @@ class AddImmutableAnnoIntentionTest : IntentionTestBase(AddImmutableClassAnnotat
     fun testAddImmutableAnno4() {
         assertNoIntention("kphp_intentions/immutable_class_intention-4.nointention.php")
     }
+
+    fun testAddImmutableAnno5() {
+        assertNoIntention("kphp_intentions/immutable_class_intention-5.nointention.php")
+    }
+
+    fun testAddImmutableAnno6() {
+        runIntention("kphp_intentions/immutable_class_intention-6.fixture.php")
+    }
+
+    fun testAddImmutableAnno7() {
+        runIntention("kphp_intentions/immutable_class_intention-7.fixture.php")
+    }
 }