diff --git a/kotlin-checks-test-sources/src/main/kotlin/checks/CollectionShouldBeImmutableCheckSample.kt b/kotlin-checks-test-sources/src/main/kotlin/checks/CollectionShouldBeImmutableCheckSample.kt
new file mode 100644
index 000000000..c6a460ca3
--- /dev/null
+++ b/kotlin-checks-test-sources/src/main/kotlin/checks/CollectionShouldBeImmutableCheckSample.kt
@@ -0,0 +1,228 @@
+package checks
+
+class CollectionShouldBeImmutableCheckSample {
+    fun MutableCollection<Int>.doSomething(): Unit {} // Noncompliant
+
+    //let also apply run with
+    fun nonCompliant(
+        x: MutableList<Int>, // Noncompliant {{Make this collection immutable.}}
+        y: MutableSet<String>,  // Noncompliant
+//      ^^^^^^^^^^^^^^^^^^^^^
+        z: MutableMap<Int, Int>, // Noncompliant
+        a: MutableList<Int>,  // compliant, FN
+        b: MutableList<Int>, // Noncompliant
+        c: MutableList<Int>, // compliant, FN
+    ): Unit {
+        baz(x.toList().toMutableList())
+        baz(doNothing(x).toMutableList())
+        doNothing(x)
+        x.reduce { acc, it -> acc + it }
+        x + 1
+        x.size
+        for (i in x) {
+            println(i)
+        }
+        x.foo()
+        id(x + listOf(1, 2, 3))
+        y.contains("a")
+        y.map { it + "a" }
+        z[1]
+        doNothing(x, y, z)
+        a.let { it.size }
+        a.let { it.also { with(it, { this.size }) } }
+        Pair(1, b.reduce { acc, i -> i + acc })
+        id(c)
+    }
+
+    fun List<Int>.toList(): List<Int> = this // compliant
+    fun baz(list : MutableList<Int>): Unit {} // Noncompliant
+
+    fun List<Int>.foo(): Unit {} // Compliant
+    fun doNothing(a : List<Int>, b : Set<String>, c : Map<Int,Int>): Unit {}
+    fun doNothing(a : List<Int>): List<Int> { return a } // Compliant
+
+    fun <A>id(a : A): A = a // Compliant
+
+    fun compliantScopedFunctions(
+        a: MutableList<Int>, // Compliant
+        b: MutableList<Int>, // Compliant
+        c: MutableList<Int>, // Compliant
+        d: MutableList<Int>, // Compliant
+        e: MutableList<Int>, // Compliant
+        f: MutableList<Int>, // Compliant
+        crazy: MutableList<Int>,
+    ): Unit { // Compliant
+        a.let { it.add(1) }
+        b.also { it.add(1) }
+        c.apply { add(1) }
+        d.run { add(1) }
+        with(e) { add(1) }
+        f.let { it.let { it.let { it.add(1) } } }
+        crazy.let { it.also { it.apply { it.run { with(this) { it.add(1) } } } } }
+    }
+
+    fun MutableList<Int>.doSomething2(): MutableList<Int> { return this } // Noncompliant
+
+    fun compliantFunctionsCalledOn(
+        a: MutableList<Int>, // Compliant
+        b: MutableList<Int>, // Compliant
+        c: List<Int>, // Compliant
+        d: MutableList<Int>, // Compliant
+        e: MutableMap<Int, Int>, // Compliant
+        f: MutableList<Int>, // Compliant
+        g: MutableList<Int>, // Compliant
+        h: MutableSet<Int>, // Compliant
+        i: MutableList<Int>, // Compliant
+        j: MutableList<Int>, // Compliant
+        k: MutableList<Int>, // Compliant
+        l: MutableList<Int>, // Compliant
+        m: MutableList<Int>, // Compliant
+        n: MutableList<Int>, // Compliant
+    ): Unit {
+        a.add(1)
+        b.iterator()
+        c.map { it + 1}
+        d.add(1)
+        e.remove(1)
+        f.doSomething()
+        g.doSomething2()
+        h.doSomething()
+        ((i)).doSomething()
+        j.doSomething2().doSomething2().doSomething2()
+        when (k) {
+            is MutableList<Int> -> k.doSomething()
+        }
+        l!!.doSomething()
+        m?.doSomething()
+        if(true){n}else{n}.doSomething()
+    }
+
+
+    fun compliantBinaryExprCalledOn(
+        c: List<Int>, // Compliant
+        d: MutableList<Int>, // Compliant
+        e: MutableList<Int>, // Compliant
+        f: MutableList<Int>, // Compliant
+        g: MutableList<Int>, // Compliant
+    ): Unit {
+        c[0]
+        d += 1
+        e -= 1
+        f[0] = 1
+        (g)[0] = 1
+    }
+
+
+
+    fun compliantCalledInFun(
+        a: MutableList<Int>, // Compliant
+        b: MutableList<Int>, // Compliant
+        c: MutableList<Int>, // Compliant
+        d: MutableList<Int>, // Compliant
+        e: MutableList<Int>, // Compliant
+        f: MutableList<Int> // Compliant
+    ): Unit {
+        foo_(a)
+        foo2(b)
+        foo_(((c)))
+        foo_(d!!)
+        foo_(if(true){e}else{e})
+        Pair(f, 1)
+    }
+
+    fun foo_(x : MutableList<Int>): Unit {} // Noncompliant {{Make this collection immutable.}}
+    fun foo2(x : MutableCollection<Int>): Unit {} // Noncompliant
+
+
+    fun nonCompliantParameter(list: MutableList<Int>): Int { // Noncompliant
+        return list.reduce { acc, it -> acc + it}
+    }
+
+    fun compliantParameter(list: List<Int>): Int { // Compliant
+        return list.reduce { acc, it -> acc + it}
+    }
+
+    fun MutableList<Int>.compliantDelegate(): Int { // Compliant
+        this.add(1)
+        return reduce { acc, it -> acc + it }
+    }
+
+
+    fun MutableList<Int>.compliantDelegate2(): Unit { // Compliant
+        foo_(this)
+    }
+
+    fun MutableList<Int>.compliantDelegate3(): Unit { // Compliant
+        foo_(this)
+        add(1)
+    }
+
+    fun MutableList<Int>.compliantDelegate4(): Unit { // Compliant
+        if(add(1)) {}
+    }
+
+    fun MutableList<Int>.noncompliantDelegate(): Int { // Noncompliant
+//      ^^^^^^^^^^^^^^^^
+        return reduce { acc, it -> acc + it}
+    }
+
+    fun MutableList<Int>.noncompliantDelegate2(): Int { // compliant, FN
+        var list = mutableListOf(1, 2, 3) // we should change noReciever to check that it is called on this
+        list.add(1)
+        return reduce { acc, it -> acc + it}
+    }
+
+
+
+    class AMutableCollections : MutableCollection<Int> {
+        override val size: Int
+            get() = TODO()
+
+        override fun contains(element: Int): Boolean {
+            TODO()
+        }
+
+        override fun containsAll(elements: Collection<Int>): Boolean {
+            TODO()
+        }
+
+        override fun isEmpty(): Boolean {
+            TODO()
+        }
+
+        override fun add(element: Int): Boolean {
+            TODO()
+        }
+
+        override fun addAll(elements: Collection<Int>): Boolean {
+            TODO()
+        }
+
+        override fun clear() {
+            TODO()
+        }
+
+        override fun iterator(): MutableIterator<Int> {
+            TODO()
+        }
+
+        override fun remove(element: Int): Boolean {
+            TODO()
+        }
+
+        override fun removeAll(elements: Collection<Int>): Boolean {
+            TODO()
+        }
+
+        override fun retainAll(elements: Collection<Int>): Boolean {
+            TODO()
+        }
+    }
+
+    fun id(x : AMutableCollections): AMutableCollections = x // compliant, for now don't know how to check that is subtype of MutableCollection
+
+
+    fun foo(configure: (MutableMap<String, Any?>) -> Unit): Unit { // compliant
+    }
+
+}
\ No newline at end of file
diff --git a/kotlin-checks-test-sources/src/main/kotlin/checks/CollectionShouldBeImmutableCheckSampleNoSemantics.kt b/kotlin-checks-test-sources/src/main/kotlin/checks/CollectionShouldBeImmutableCheckSampleNoSemantics.kt
new file mode 100644
index 000000000..a7202c085
--- /dev/null
+++ b/kotlin-checks-test-sources/src/main/kotlin/checks/CollectionShouldBeImmutableCheckSampleNoSemantics.kt
@@ -0,0 +1,215 @@
+package checks
+
+class CollectionShouldBeImmutableCheckSampleNoSemantics {
+    fun MutableCollection<Int>.doSomething(): Unit {}
+
+    //let also apply run with
+    fun nonCompliant(
+        x: MutableList<Int>,
+        y: MutableSet<String>,
+        z: MutableMap<Int, Int>,
+        a: MutableList<Int>,
+        b: MutableList<Int>,
+        c: MutableList<Int>,
+    ): Unit {
+        baz(x.toList().toMutableList())
+        baz(doNothing(x).toMutableList())
+        doNothing(x)
+        x.reduce { acc, it -> acc + it }
+        x + 1
+        x.size
+        for (i in x) {
+            println(i)
+        }
+        x.foo()
+        id(x + listOf(1, 2, 3))
+        y.contains("a")
+        y.map { it + "a" }
+        z[1]
+        doNothing(x, y, z)
+        a.let { it.size }
+        a.let { it.also { with(it, { this.size }) } }
+        Pair(1, b.reduce { acc, i -> i + acc })
+        id(c)
+    }
+
+    fun List<Int>.toList(): List<Int> = this // compliant
+    fun baz(list : MutableList<Int>): Unit {}
+
+    fun List<Int>.foo(): Unit {} // Compliant
+    fun doNothing(a : List<Int>, b : Set<String>, c : Map<Int,Int>): Unit {}
+    fun doNothing(a : List<Int>): List<Int> { return a } // Compliant
+
+    fun <A>id(a : A): A = a // Compliant
+
+    fun compliantScopedFunctions(
+        a: MutableList<Int>, // Compliant
+        b: MutableList<Int>, // Compliant
+        c: MutableList<Int>, // Compliant
+        d: MutableList<Int>, // Compliant
+        e: MutableList<Int>, // Compliant
+        f: MutableList<Int>, // Compliant
+        crazy: MutableList<Int>,
+    ): Unit { // Compliant
+        a.let { it.add(1) }
+        b.also { it.add(1) }
+        c.apply { add(1) }
+        d.run { add(1) }
+        with(e) { add(1) }
+        f.let { it.let { it.let { it.add(1) } } }
+        crazy.let { it.also { it.apply { it.run { with(this) { it.add(1) } } } } }
+    }
+
+    fun MutableList<Int>.doSomething2(): MutableList<Int> { return this }
+
+    fun compliantFunctionsCalledOn(
+        a: MutableList<Int>, // Compliant
+        b: MutableList<Int>, // Compliant
+        c: List<Int>, // Compliant
+        d: MutableList<Int>, // Compliant
+        e: MutableMap<Int, Int>, // Compliant
+        f: MutableList<Int>, // Compliant
+        g: MutableList<Int>, // Compliant
+        h: MutableSet<Int>, // Compliant
+        i: MutableList<Int>, // Compliant
+        j: MutableList<Int>, // Compliant
+        k: MutableList<Int>, // Compliant
+        l: MutableList<Int>, // Compliant
+        m: MutableList<Int>, // Compliant
+        n: MutableList<Int>, // Compliant
+    ): Unit {
+        a.add(1)
+        b.iterator()
+        c.map { it + 1}
+        d.add(1)
+        e.remove(1)
+        f.doSomething()
+        g.doSomething2()
+        h.doSomething()
+        ((i)).doSomething()
+        j.doSomething2().doSomething2().doSomething2()
+        when (k) {
+            is MutableList<Int> -> k.doSomething()
+        }
+        l!!.doSomething()
+        m?.doSomething()
+        if(true){n}else{n}.doSomething()
+    }
+
+
+    fun compliantBinaryExprCalledOn(
+        c: List<Int>, // Compliant
+        d: MutableList<Int>, // Compliant
+        e: MutableList<Int>, // Compliant
+        f: MutableList<Int>, // Compliant
+        g: MutableList<Int>, // Compliant
+    ): Unit {
+        c[0]
+        d += 1
+        e -= 1
+        f[0] = 1
+        (g)[0] = 1
+    }
+
+
+
+    fun compliantCalledInFun(
+        a: MutableList<Int>, // Compliant
+        b: MutableList<Int>, // Compliant
+        c: MutableList<Int>, // Compliant
+        d: MutableList<Int>, // Compliant
+        e: MutableList<Int>, // Compliant
+        f: MutableList<Int> // Compliant
+    ): Unit {
+        foo_(a)
+        foo2(b)
+        foo_(((c)))
+        foo_(d!!)
+        foo_(if(true){e}else{e})
+        Pair(f, 1)
+    }
+
+    fun foo_(x : MutableList<Int>): Unit {}
+    fun foo2(x : MutableCollection<Int>): Unit {}
+
+
+    fun nonCompliantParameter(list: MutableList<Int>): Int {
+        return list.reduce { acc, it -> acc + it}
+    }
+
+    fun compliantParameter(list: List<Int>): Int { // Compliant
+        return list.reduce { acc, it -> acc + it}
+    }
+
+    fun MutableList<Int>.compliantDelegate(): Int { // Compliant
+        this.add(1)
+        return reduce { acc, it -> acc + it }
+    }
+
+
+    fun MutableList<Int>.compliantDelegate2(): Unit { // Compliant
+        foo_(this)
+    }
+
+    fun MutableList<Int>.compliantDelegate3(): Unit { // Compliant
+        foo_(this)
+        add(1)
+    }
+
+    fun MutableList<Int>.noncompliantDelegate(): Int {
+        return reduce { acc, it -> acc + it}
+    }
+
+
+    class AMutableCollections : MutableCollection<Int> {
+        override val size: Int
+            get() = TODO()
+
+        override fun contains(element: Int): Boolean {
+            TODO()
+        }
+
+        override fun containsAll(elements: Collection<Int>): Boolean {
+            TODO()
+        }
+
+        override fun isEmpty(): Boolean {
+            TODO()
+        }
+
+        override fun add(element: Int): Boolean {
+            TODO()
+        }
+
+        override fun addAll(elements: Collection<Int>): Boolean {
+            TODO()
+        }
+
+        override fun clear() {
+            TODO()
+        }
+
+        override fun iterator(): MutableIterator<Int> {
+            TODO()
+        }
+
+        override fun remove(element: Int): Boolean {
+            TODO()
+        }
+
+        override fun removeAll(elements: Collection<Int>): Boolean {
+            TODO()
+        }
+
+        override fun retainAll(elements: Collection<Int>): Boolean {
+            TODO()
+        }
+    }
+
+    fun id(x : AMutableCollections): AMutableCollections = x // compliant, for now don't know how to check that is subtype of MutableCollection
+
+
+    fun foo(configure: (MutableMap<String, Any?>) -> Unit): Unit { // compliant
+    }
+
+}
\ No newline at end of file
diff --git a/sonar-kotlin-api/src/main/java/org/sonarsource/kotlin/api/checks/ApiExtensions.kt b/sonar-kotlin-api/src/main/java/org/sonarsource/kotlin/api/checks/ApiExtensions.kt
index 24251072c..c1e15f002 100644
--- a/sonar-kotlin-api/src/main/java/org/sonarsource/kotlin/api/checks/ApiExtensions.kt
+++ b/sonar-kotlin-api/src/main/java/org/sonarsource/kotlin/api/checks/ApiExtensions.kt
@@ -328,6 +328,9 @@ private fun KtProperty.determineType(bindingContext: BindingContext) =
 fun KtProperty.determineTypeAsString(bindingContext: BindingContext, printTypeArguments: Boolean = false) =
     determineType(bindingContext)?.getKotlinTypeFqName(printTypeArguments)
 
+fun KtExpression.determineTypeAsString(bindingContext: BindingContext, printTypeArguments: Boolean = false) =
+    determineType(bindingContext)?.getKotlinTypeFqName(printTypeArguments)
+
 private fun KtParameter.determineType(bindingContext: BindingContext) =
     bindingContext[BindingContext.TYPE, typeReference]
 
diff --git a/sonar-kotlin-api/src/test/java/org/sonarsource/kotlin/api/checks/ApiExtensionsKtTest.kt b/sonar-kotlin-api/src/test/java/org/sonarsource/kotlin/api/checks/ApiExtensionsKtTest.kt
index 7b67ffd92..02f494021 100644
--- a/sonar-kotlin-api/src/test/java/org/sonarsource/kotlin/api/checks/ApiExtensionsKtTest.kt
+++ b/sonar-kotlin-api/src/test/java/org/sonarsource/kotlin/api/checks/ApiExtensionsKtTest.kt
@@ -424,6 +424,10 @@ class ApiExtensionsKtDetermineTypeTest {
         val expr = ktFile.findDescendantOfType<KtBlockExpression> { it.text == "{ 1 }" }!!
         assertThat(expr.determineType(bindingContext)!!.getKotlinTypeFqName(false))
             .isEqualTo("kotlin.Int")
+        assertThat(expr.determineTypeAsString(bindingContext))
+            .isEqualTo("kotlin.Int")
+        val missingContext = BindingContext.EMPTY
+        assertThat(expr.determineTypeAsString(missingContext)).isNull()
     }
 
     @Test
diff --git a/sonar-kotlin-checks/src/main/java/org/sonarsource/kotlin/checks/CollectionShouldBeImmutableCheck.kt b/sonar-kotlin-checks/src/main/java/org/sonarsource/kotlin/checks/CollectionShouldBeImmutableCheck.kt
new file mode 100644
index 000000000..e81184972
--- /dev/null
+++ b/sonar-kotlin-checks/src/main/java/org/sonarsource/kotlin/checks/CollectionShouldBeImmutableCheck.kt
@@ -0,0 +1,184 @@
+/*
+ * SonarSource Kotlin
+ * Copyright (C) 2018-2023 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonarsource.kotlin.checks
+
+import org.jetbrains.kotlin.com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.js.descriptorUtils.getKotlinTypeFqName
+import org.jetbrains.kotlin.psi.KtBinaryExpression
+import org.jetbrains.kotlin.psi.KtCallExpression
+import org.jetbrains.kotlin.psi.KtDotQualifiedExpression
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtNameReferenceExpression
+import org.jetbrains.kotlin.psi.KtNamedDeclaration
+import org.jetbrains.kotlin.psi.KtNamedFunction
+import org.jetbrains.kotlin.psi.KtQualifiedExpression
+import org.jetbrains.kotlin.psi.psiUtil.collectDescendantsOfType
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.BindingContext.DECLARATION_TO_DESCRIPTOR
+import org.jetbrains.kotlin.resolve.calls.util.getResolvedCall
+import org.jetbrains.kotlin.resolve.descriptorUtil.isExtension
+import org.jetbrains.kotlin.types.KotlinType
+import org.sonar.check.Rule
+import org.sonarsource.kotlin.api.checks.AbstractCheck
+import org.sonarsource.kotlin.api.checks.determineTypeAsString
+import org.sonarsource.kotlin.api.frontend.KotlinFileContext
+
+@Rule(key = "S6524")
+class CollectionShouldBeImmutableCheck : AbstractCheck() {
+    private val mutableCollections =
+        setOf(
+            "kotlin.collections.MutableList",
+            "kotlin.collections.MutableSet",
+            "kotlin.collections.MutableMap",
+            "kotlin.collections.MutableCollection"
+        )
+
+
+    override fun visitNamedFunction(function: KtNamedFunction, context: KotlinFileContext) {
+        val bindingContext = context.bindingContext
+
+        val referencesToMutableCollections = collectReferenceToMutatedCollections(function, bindingContext)
+        val mutatedNames = referencesToMutableCollections.map { it.getReferencedName() }.toSet()
+        val mutatedDeclarations =
+            referencesToMutableCollections.mapNotNull { it.getResolvedCall(bindingContext)?.resultingDescriptor?.original }.toSet()
+
+        reportPropertiesAndParameters(function, mutatedDeclarations, bindingContext, context)
+
+        if (function.receiverTypeReference?.determineTypeAsString(bindingContext) in mutableCollections) {
+            reportForExtensionFunction(function, bindingContext, mutatedNames, context)
+        }
+    }
+
+    private fun reportPropertiesAndParameters(
+        function: KtNamedFunction,
+        mutatedDeclarations: Set<CallableDescriptor>,
+        bindingContext: BindingContext,
+        context: KotlinFileContext,
+    ) {
+        function.valueParameters
+            .filter { it.isMutableCollection(bindingContext) }
+            .filter { it.isNotReferenced(mutatedDeclarations, bindingContext) }
+            .forEach { context.reportIssue(it, "Make this collection immutable.") }
+    }
+
+    private fun KtNamedDeclaration.isMutableCollection(bindingContext: BindingContext): Boolean =
+        this.determineTypeAsString(bindingContext) in mutableCollections
+
+    private fun KtNamedDeclaration.isNotReferenced(
+        mutatedDeclarations: Set<CallableDescriptor>,
+        bindingContext: BindingContext,
+    ): Boolean {
+        val descriptor = bindingContext[DECLARATION_TO_DESCRIPTOR, this]
+        //descriptor is never null because we need the descriptor to know if we will consider the declaration
+        //no need to return false if descriptor is null
+        return !mutatedDeclarations.contains(descriptor)
+    }
+
+    private fun reportForExtensionFunction(
+        function: KtNamedFunction,
+        bindingContext: BindingContext,
+        mutatedNames: Set<String>,
+        context: KotlinFileContext,
+    ) {
+        val functionsCalledOnThis = function
+            .collectDescendantsOfType<KtCallExpression> { it.noReceiver() }
+
+        if (functionsCalledOnThis.none { it.mutatesCollection(bindingContext) } && "this" !in mutatedNames) {
+            context.reportIssue(function.receiverTypeReference!!.navigationElement, "Make this collection immutable.")
+        }
+    }
+
+    private fun KtCallExpression.noReceiver(): Boolean {
+        return this.parent !is KtQualifiedExpression
+    }
+
+    private fun collectReferenceToMutatedCollections(
+        function: KtNamedFunction,
+        bindingContext: BindingContext,
+    ): List<KtNameReferenceExpression> {
+        val mutablePropertiesReceiver: List<KtNameReferenceExpression> = function
+            .collectDescendantsOfType<KtQualifiedExpression> { it.mutatesCollection(bindingContext) }
+            .flatMap { findReferenceExpressions(it.receiverExpression) }
+
+        val mutablePropertiesInBinaryExpression: List<KtNameReferenceExpression> = function
+            .collectDescendantsOfType<KtBinaryExpression> { it.mutatesCollection(bindingContext) }
+            .flatMap { findReferenceExpressions(it.left!!) }
+
+        val mutablePropertiesInFunctionCalls: List<KtNameReferenceExpression> = function
+            .collectDescendantsOfType<KtCallExpression>()
+            .flatMap { call ->
+                val functionDescriptor = call.getResolvedCall(bindingContext)?.resultingDescriptor
+                val parameterTypes = functionDescriptor?.valueParameters
+                if (parameterTypes != null) {
+                    val fullyQualifiedTypes = parameterTypes.map { it.type.getKotlinTypeFqName(false) }
+                    call.valueArguments.zip(fullyQualifiedTypes).filter { it.second in mutableCollections }.map { it.first }
+                } else {
+                    call.valueArguments
+                }
+            }
+            .flatMap { findReferenceExpressions(it.getArgumentExpression()!!) }
+
+        return mutablePropertiesReceiver + mutablePropertiesInBinaryExpression + mutablePropertiesInFunctionCalls
+    }
+
+    private fun findReferenceExpressions(
+        expression: KtExpression,
+    ): List<KtNameReferenceExpression> {
+        return expression.collectDescendantsOfType<KtNameReferenceExpression>(::considerElement) { true }
+    }
+
+    private fun considerElement(element: PsiElement): Boolean {
+        return when (element) {
+            is KtCallExpression -> false
+            is KtDotQualifiedExpression -> false
+            else -> true
+        }
+    }
+
+    private fun KtQualifiedExpression.mutatesCollection(bindingContext: BindingContext): Boolean {
+        return if (this.selectorExpression is KtCallExpression) {
+            val selectorExpression = this.selectorExpression as KtCallExpression
+            selectorExpression.mutatesCollection(bindingContext)
+        } else {
+            false
+        }
+    }
+
+    private fun KtElement.mutatesCollection(bindingContext: BindingContext): Boolean {
+        val functionDescriptor = this.getResolvedCall(bindingContext)?.resultingDescriptor
+        val receiverType = functionDescriptor?.receiverType()
+        return if (receiverType?.constructor?.declarationDescriptor != null) {
+            receiverType.getKotlinTypeFqName(false) in mutableCollections
+        } else {
+            true
+        }
+    }
+
+    private fun CallableDescriptor.receiverType(): KotlinType? {
+        return if (this.isExtension) {
+            this.extensionReceiverParameter?.type
+        } else {
+            this.dispatchReceiverParameter?.type
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/sonar-kotlin-checks/src/test/java/org/sonarsource/kotlin/checks/CollectionShouldBeImmutableCheckTest.kt b/sonar-kotlin-checks/src/test/java/org/sonarsource/kotlin/checks/CollectionShouldBeImmutableCheckTest.kt
new file mode 100644
index 000000000..6bb503eac
--- /dev/null
+++ b/sonar-kotlin-checks/src/test/java/org/sonarsource/kotlin/checks/CollectionShouldBeImmutableCheckTest.kt
@@ -0,0 +1,22 @@
+/*
+ * SonarSource Kotlin
+ * Copyright (C) 2018-2023 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonarsource.kotlin.checks
+
+internal class CollectionShouldBeImmutableCheckTest : CheckTestWithNoSemantics(CollectionShouldBeImmutableCheck())
\ No newline at end of file
diff --git a/sonar-kotlin-plugin/src/main/java/org/sonarsource/kotlin/plugin/KotlinCheckList.kt b/sonar-kotlin-plugin/src/main/java/org/sonarsource/kotlin/plugin/KotlinCheckList.kt
index fb2049261..271991d12 100644
--- a/sonar-kotlin-plugin/src/main/java/org/sonarsource/kotlin/plugin/KotlinCheckList.kt
+++ b/sonar-kotlin-plugin/src/main/java/org/sonarsource/kotlin/plugin/KotlinCheckList.kt
@@ -37,6 +37,7 @@ import org.sonarsource.kotlin.checks.CodeAfterJumpCheck
 import org.sonarsource.kotlin.checks.CollapsibleIfStatementsCheck
 import org.sonarsource.kotlin.checks.CollectionCallingItselfCheck
 import org.sonarsource.kotlin.checks.CollectionInappropriateCallsCheck
+import org.sonarsource.kotlin.checks.CollectionShouldBeImmutableCheck
 import org.sonarsource.kotlin.checks.CollectionSizeAndArrayLengthCheck
 import org.sonarsource.kotlin.checks.CommentedCodeCheck
 import org.sonarsource.kotlin.checks.CoroutineScopeFunSuspendingCheck
@@ -169,6 +170,7 @@ val KOTLIN_CHECKS = listOf(
     CodeAfterJumpCheck::class.java,
     CollapsibleIfStatementsCheck::class.java,
     CollectionCallingItselfCheck::class.java,
+    CollectionShouldBeImmutableCheck::class.java,
     CollectionSizeAndArrayLengthCheck::class.java,
     CollectionInappropriateCallsCheck::class.java,
     CoroutineScopeFunSuspendingCheck::class.java,
diff --git a/sonar-kotlin-plugin/src/main/resources/org/sonar/l10n/kotlin/rules/kotlin/S6524.html b/sonar-kotlin-plugin/src/main/resources/org/sonar/l10n/kotlin/rules/kotlin/S6524.html
new file mode 100644
index 000000000..d47a3734e
--- /dev/null
+++ b/sonar-kotlin-plugin/src/main/resources/org/sonar/l10n/kotlin/rules/kotlin/S6524.html
@@ -0,0 +1,65 @@
+<h2>Why is this an issue?</h2>
+<p>If a mutable collection type is used but no mutating functions such as <code>add</code> or <code>remove</code> are ever called, and the collection
+instance does not leave the scope of the function, it can be replaced with the corresponding immutable collection type.</p>
+<p>This is similar to why <code>val</code> should be used instead of <code>var</code> for local variables that are never re-assigned.</p>
+<h3>What is the potential impact?</h3>
+<h4>Readability and Understanding</h4>
+<p>If an immutable collection type is used, it is evident to the readers that its content is never changed. This makes it easier to understand the
+code because readers do not need to keep track of possible state changes of the collection.</p>
+<h4>Performance</h4>
+<p>In some cases, optimized implementation variants of collection classes can be used when the collection is immutable.</p>
+<h4>Wrong code</h4>
+<p>Developers might intend for a collection to remain unchanged and have their code relying on that constraint. For example, a map could be expected
+to contain specific elements. Changing the contents of a collection breaks that constraint. Also, users of an API might otherwise downcast an
+immutable collection they got from a library into a mutable collection, and so cause unforeseen side effects.</p>
+<p>Declare collections that remain unchanged as immutable to avoid these mistakes.</p>
+<h2>How to fix it</h2>
+<p>Replace mutable collection type names such as <code>MutableList</code> or <code>MutableMap</code> with their immutable equivalents, such as
+<code>List</code> or <code>map</code>.</p>
+<p>Replace builder functions that return mutable collection instances, such as <code>mutableListOf</code> with their immutable counterparts, such as
+<code>listOf</code>.</p>
+<h3>Code examples</h3>
+<h4>Noncompliant code example</h4>
+<pre data-diff-id="1" data-diff-type="noncompliant">
+fun sum123(): Int {
+    val list = mutableListOf(1,2,3) // Noncompliant, can be immutable
+    return list.reduce { acc, it -&gt; acc + it}
+}
+</pre>
+<h4>Compliant solution</h4>
+<pre data-diff-id="1" data-diff-type="compliant">
+fun sum123(): Int {
+    val list = listOf(1,2,3) // Compliant
+    return list.reduce { acc, it -&gt; acc + it}
+}
+</pre>
+<h4>Noncompliant code example</h4>
+<pre data-diff-id="2" data-diff-type="noncompliant">
+fun sumList(list: MutableList&lt;Int&gt;): Int { // Noncompliant, can be immutable
+    return list.reduce { acc, it -&gt; acc + it}
+}
+</pre>
+<h4>Compliant solution</h4>
+<pre data-diff-id="2" data-diff-type="compliant">
+fun sumList(list: List&lt;Int&gt;): Int { // Compliant
+    return list.reduce { acc, it -&gt; acc + it}
+}
+</pre>
+<h4>Noncompliant code example</h4>
+<pre data-diff-id="3" data-diff-type="noncompliant">
+fun MutableList&lt;Int&gt;.sum(): Int { // Noncompliant, can be immutable
+    return reduce { acc, it -&gt; acc + it}
+}
+</pre>
+<h4>Compliant solution</h4>
+<pre data-diff-id="3" data-diff-type="compliant">
+fun List&lt;Int&gt;.sum(): Int { // Compliant
+    return reduce { acc, it -&gt; acc + it}
+}
+</pre>
+<h2>Resources</h2>
+<h3>Articles &amp; blog posts</h3>
+<ul>
+  <li> <a href="https://www.baeldung.com/kotlin/immutable-collections">Baeldung, Kotlin Immutable Collections</a> </li>
+</ul>
+
diff --git a/sonar-kotlin-plugin/src/main/resources/org/sonar/l10n/kotlin/rules/kotlin/S6524.json b/sonar-kotlin-plugin/src/main/resources/org/sonar/l10n/kotlin/rules/kotlin/S6524.json
new file mode 100644
index 000000000..a8574b8b2
--- /dev/null
+++ b/sonar-kotlin-plugin/src/main/resources/org/sonar/l10n/kotlin/rules/kotlin/S6524.json
@@ -0,0 +1,21 @@
+{
+  "title": "Collection should be immutable if contents is not changed",
+  "type": "CODE_SMELL",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "MEDIUM"
+    },
+    "attribute": "CLEAR"
+  },
+  "status": "ready",
+  "remediation": {
+    "func": "Constant\/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [],
+  "defaultSeverity": "Minor",
+  "ruleSpecification": "RSPEC-6524",
+  "sqKey": "S6524",
+  "scope": "All",
+  "quickfix": "unknown"
+}
diff --git a/sonar-kotlin-plugin/src/main/resources/org/sonar/l10n/kotlin/rules/kotlin/Sonar_way_profile.json b/sonar-kotlin-plugin/src/main/resources/org/sonar/l10n/kotlin/rules/kotlin/Sonar_way_profile.json
index b7776631e..dbc6310ad 100644
--- a/sonar-kotlin-plugin/src/main/resources/org/sonar/l10n/kotlin/rules/kotlin/Sonar_way_profile.json
+++ b/sonar-kotlin-plugin/src/main/resources/org/sonar/l10n/kotlin/rules/kotlin/Sonar_way_profile.json
@@ -106,6 +106,7 @@
     "S6517",
     "S6518",
     "S6519",
+    "S6524",
     "S6526",
     "S6527",
     "S6528",