[kotlin][k2] allow to analyze from write action in some places

Such places should be rewritten in the future ^KT-60586 GitOrigin-RevId: 44766131fd99d4b172a27d314071083261161746
2026-04-19 13:02:30 +07:00 · 2023-07-20 17:38:58 +02:00
parent 19beb256de
commit 4bcc07c36c
40 changed files with 378 additions and 150 deletions
--- a/plugins/devkit/intellij.kotlin.devkit/intellij.kotlin.devkit.iml
+++ b/plugins/devkit/intellij.kotlin.devkit/intellij.kotlin.devkit.iml
@@ -1,5 +1,21 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <module type="JAVA_MODULE" version="4">
+  <component name="FacetManager">
+    <facet type="kotlin-language" name="Kotlin">
+      <configuration version="5" platform="JVM 17" allPlatforms="JVM [17]" useProjectSettings="false">
+        <compilerSettings>
+          <option name="additionalArguments" value="-Xjvm-default=all -opt-in=com.intellij.openapi.util.IntellijInternalApi -opt-in=org.jetbrains.kotlin.utils.addToStdlib.UnsafeCastFunction -opt-in=org.jetbrains.kotlin.analysis.api.lifetime.KtAllowProhibitedAnalyzeFromWriteAction" />
+        </compilerSettings>
+        <compilerArguments>
+          <stringArguments>
+            <stringArg name="jvmTarget" arg="17" />
+            <stringArg name="apiVersion" arg="1.8" />
+            <stringArg name="languageVersion" arg="1.8" />
+          </stringArguments>
+        </compilerArguments>
+      </configuration>
+    </facet>
+  </component>
  <component name="NewModuleRootManager" inherit-compiler-output="true">
    <exclude-output />
    <content url="file://$MODULE_DIR$">
--- a/plugins/devkit/intellij.kotlin.devkit/src/inspections/KtAppServiceAsStaticFinalFieldFixProvider.kt
+++ b/plugins/devkit/intellij.kotlin.devkit/src/inspections/KtAppServiceAsStaticFinalFieldFixProvider.kt
@@ -10,8 +10,10 @@ import com.intellij.psi.util.PsiEditorUtil
 import com.intellij.psi.util.parentOfType
 import org.jetbrains.idea.devkit.inspections.quickfix.AppServiceAsStaticFinalFieldFixProvider
 import org.jetbrains.idea.devkit.inspections.quickfix.WrapInSupplierQuickFix
+import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.analyze
+import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.types.KtNonErrorClassType
 import org.jetbrains.kotlin.idea.base.codeInsight.KotlinNameSuggester
@@ -51,9 +53,12 @@ private class KtWrapInSupplierQuickFix(ktProperty: KtProperty) : WrapInSupplierQ
    // can be called both from EDT and from the preview
    @OptIn(KtAllowAnalysisOnEdt::class)
    val ktPropertyType = allowAnalysisOnEdt {
-      analyze(element) {
-        val returnType = element.getReturnKtType().lowerBoundIfFlexible()
-        (returnType as? KtNonErrorClassType)?.classId
+      @OptIn(KtAllowAnalysisFromWriteAction::class)
+      allowAnalysisFromWriteAction {
+        analyze(element) {
+          val returnType = element.getReturnKtType().lowerBoundIfFlexible()
+          (returnType as? KtNonErrorClassType)?.classId
+        }
      }
    }

--- a/plugins/kotlin/base/analysis-api/analysis-api-utils/kotlin.base.analysis-api.utils.iml
+++ b/plugins/kotlin/base/analysis-api/analysis-api-utils/kotlin.base.analysis-api.utils.iml
@@ -4,7 +4,7 @@
    <facet type="kotlin-language" name="Kotlin">
      <configuration version="5" platform="JVM 17" allPlatforms="JVM [17]" useProjectSettings="false">
        <compilerSettings>
-          <option name="additionalArguments" value="-Xjvm-default=all -opt-in=com.intellij.openapi.util.IntellijInternalApi -Xcontext-receivers" />
+          <option name="additionalArguments" value="-Xjvm-default=all -opt-in=com.intellij.openapi.util.IntellijInternalApi -Xcontext-receivers -opt-in=org.jetbrains.kotlin.analysis.api.lifetime.KtAllowProhibitedAnalyzeFromWriteAction" />
        </compilerSettings>
        <compilerArguments>
          <stringArguments>
--- a/plugins/kotlin/base/analysis-api/analysis-api-utils/src/org/jetbrains/kotlin/idea/base/analysis/api/utils/shortenUtils.kt
+++ b/plugins/kotlin/base/analysis-api/analysis-api-utils/src/org/jetbrains/kotlin/idea/base/analysis/api/utils/shortenUtils.kt
@@ -5,11 +5,13 @@ package org.jetbrains.kotlin.idea.base.analysis.api.utils
 import com.intellij.openapi.util.TextRange
 import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisOnEdt
 import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.analyze
 import org.jetbrains.kotlin.analysis.api.components.ShortenCommand
 import org.jetbrains.kotlin.analysis.api.components.ShortenOption
 import org.jetbrains.kotlin.analysis.api.components.ShortenOption.Companion.defaultCallableShortenOption
 import org.jetbrains.kotlin.analysis.api.components.ShortenOption.Companion.defaultClassShortenOption
+import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtClassLikeSymbol
@@ -52,11 +54,15 @@ fun shortenReferencesInRange(
    classShortenOption: (KtClassLikeSymbol) -> ShortenOption = defaultClassShortenOption,
    callableShortenOption: (KtCallableSymbol) -> ShortenOption = defaultCallableShortenOption
 ): PsiElement? {
-     val shortenCommand = allowAnalysisOnEdt {
-        analyze(file) {
-            collectPossibleReferenceShortenings(file, range, classShortenOption, callableShortenOption)
+    val shortenCommand = allowAnalysisOnEdt {
+        @OptIn(KtAllowAnalysisFromWriteAction::class)
+        allowAnalysisFromWriteAction {
+            analyze(file) {
+                collectPossibleReferenceShortenings(file, range, classShortenOption, callableShortenOption)
+            }
        }
    }
+
    return shortenCommand.invokeShortening().firstOrNull()
 }

--- a/plugins/kotlin/code-insight/api/kotlin.code-insight.api.iml
+++ b/plugins/kotlin/code-insight/api/kotlin.code-insight.api.iml
@@ -4,7 +4,7 @@
    <facet type="kotlin-language" name="Kotlin">
      <configuration version="5" platform="JVM 17" allPlatforms="JVM [17]" useProjectSettings="false">
        <compilerSettings>
-          <option name="additionalArguments" value="-Xjvm-default=all -opt-in=com.intellij.openapi.util.IntellijInternalApi -opt-in=org.jetbrains.kotlin.utils.addToStdlib.UnsafeCastFunction -Xcontext-receivers" />
+          <option name="additionalArguments" value="-Xjvm-default=all -opt-in=com.intellij.openapi.util.IntellijInternalApi -opt-in=org.jetbrains.kotlin.utils.addToStdlib.UnsafeCastFunction -Xcontext-receivers -opt-in=org.jetbrains.kotlin.analysis.api.lifetime.KtAllowProhibitedAnalyzeFromWriteAction" />
        </compilerSettings>
        <compilerArguments>
          <stringArguments>
--- a/plugins/kotlin/code-insight/api/src/org/jetbrains/kotlin/idea/codeinsight/api/applicable/KotlinApplicableTool.kt
+++ b/plugins/kotlin/code-insight/api/src/org/jetbrains/kotlin/idea/codeinsight/api/applicable/KotlinApplicableTool.kt
@@ -4,9 +4,11 @@ package org.jetbrains.kotlin.idea.codeinsight.api.applicable
 import com.intellij.codeInspection.util.IntentionName
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.project.Project
+import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.analyze
+import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisOnEdt
 import org.jetbrains.kotlin.psi.KtElement

@@ -45,5 +47,8 @@ internal fun <ELEMENT : KtElement> KotlinApplicableTool<ELEMENT>.isApplicableWit
@OptIn(KtAllowAnalysisOnEdt::class)
 internal fun <ELEMENT : KtElement> KotlinApplicableTool<ELEMENT>.isApplicableWithAnalyzeAllowEdt(element: ELEMENT): Boolean =
    allowAnalysisOnEdt {
-        isApplicableWithAnalyze(element)
+        @OptIn(KtAllowAnalysisFromWriteAction::class)
+        allowAnalysisFromWriteAction {
+            isApplicableWithAnalyze(element)
+        }
    }
--- a/plugins/kotlin/code-insight/impl-base/kotlin.code-insight.impl-base.iml
+++ b/plugins/kotlin/code-insight/impl-base/kotlin.code-insight.impl-base.iml
@@ -4,7 +4,7 @@
    <facet type="kotlin-language" name="Kotlin">
      <configuration version="5" platform="JVM 17" allPlatforms="JVM [17]" useProjectSettings="false">
        <compilerSettings>
-          <option name="additionalArguments" value="-Xjvm-default=all -opt-in=com.intellij.openapi.util.IntellijInternalApi -opt-in=org.jetbrains.kotlin.utils.addToStdlib.UnsafeCastFunction -Xskip-prerelease-check -Xcontext-receivers" />
+          <option name="additionalArguments" value="-Xjvm-default=all -opt-in=com.intellij.openapi.util.IntellijInternalApi -opt-in=org.jetbrains.kotlin.utils.addToStdlib.UnsafeCastFunction -Xskip-prerelease-check -Xcontext-receivers -opt-in=org.jetbrains.kotlin.analysis.api.lifetime.KtAllowProhibitedAnalyzeFromWriteAction" />
        </compilerSettings>
        <compilerArguments>
          <stringArguments>
--- a/plugins/kotlin/code-insight/impl-base/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/KotlinExpressionSurrounder.kt
+++ b/plugins/kotlin/code-insight/impl-base/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/KotlinExpressionSurrounder.kt
@@ -6,8 +6,10 @@ import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.TextRange
 import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.analyze
+import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.types.KtErrorType
 import org.jetbrains.kotlin.psi.KtCallExpression
@@ -29,12 +31,16 @@ abstract class KotlinExpressionSurrounder : Surrounder {
  @OptIn(KtAllowAnalysisOnEdt::class)
  protected open fun isApplicable(expression: KtExpression): Boolean {
      allowAnalysisOnEdt {
-          return analyze(expression) {
-              val type = expression.getKtType()
-              if (type == null || type is KtErrorType || type.isUnit && isApplicableToStatements) {
-                  false
+          @OptIn(KtAllowAnalysisFromWriteAction::class)
+          allowAnalysisFromWriteAction {
+              return analyze(expression) {
+                  val type = expression.getKtType()
+                  if (type == null || type is KtErrorType || type.isUnit && isApplicableToStatements) {
+                      false
+                  } else {
+                      isApplicableToStatements || expression.isUsedAsExpression()
+                  }
              }
-              else isApplicableToStatements || expression.isUsedAsExpression()
          }
      }
  }
--- a/plugins/kotlin/code-insight/impl-base/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/MoveDeclarationsOutHelper.kt
+++ b/plugins/kotlin/code-insight/impl-base/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/MoveDeclarationsOutHelper.kt
@@ -7,8 +7,10 @@ import com.intellij.psi.search.LocalSearchScope
 import com.intellij.psi.search.SearchScope
 import com.intellij.psi.search.searches.ReferencesSearch
 import com.intellij.psi.util.PsiUtilCore
+import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.analyze
+import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.renderer.declarations.impl.KtDeclarationRendererForSource
 import org.jetbrains.kotlin.analysis.api.types.KtErrorType
@@ -116,32 +118,36 @@ private fun createVariableAssignment(property: KtProperty): KtBinaryExpression {
@OptIn(KtAllowAnalysisOnEdt::class)
 private fun createVariableDeclaration(property: KtProperty, generateDefaultInitializers: Boolean): KtProperty {
    allowAnalysisOnEdt {
-        analyze(property) {
-            val propertyType = property.getReturnKtType()
+        @OptIn(KtAllowAnalysisFromWriteAction::class)
+        allowAnalysisFromWriteAction {
+            analyze(property) {
+                val propertyType = property.getReturnKtType()

-            var defaultInitializer: String? = null
-            if (generateDefaultInitializers && property.isVar) {
-                defaultInitializer = propertyType.defaultInitializer
+                var defaultInitializer: String? = null
+                if (generateDefaultInitializers && property.isVar) {
+                    defaultInitializer = propertyType.defaultInitializer

+                }
+                val typeRef = property.typeReference
+                val typeString = when {
+                    typeRef != null -> typeRef.text
+                    propertyType !is KtErrorType -> propertyType.render(
+                        KtDeclarationRendererForSource.WITH_QUALIFIED_NAMES.typeRenderer, Variance.INVARIANT
+                    )
+
+                    else -> null
+                }
+
+                return KtPsiFactory(property.project).createProperty(property.name!!, typeString, property.isVar, defaultInitializer)
            }
-            val typeRef = property.typeReference
-            val typeString = when {
-                typeRef != null -> typeRef.text
-                propertyType !is KtErrorType -> propertyType.render(
-                    KtDeclarationRendererForSource.WITH_QUALIFIED_NAMES.typeRenderer, Variance.INVARIANT
-                )
-
-                else -> null
-            }
-
-            return KtPsiFactory(property.project).createProperty(property.name!!, typeString, property.isVar, defaultInitializer)
        }
    }
 }

 private fun needToDeclareOut(element: PsiElement, lastStatementOffset: Int, scope: SearchScope): Boolean {
    if (element is KtProperty || element is KtClassOrObject || element is KtFunction) {
-        val refs = ReferencesSearch.search(element, scope, false).toArray(PsiReference.EMPTY_ARRAY)
+        @OptIn(KtAllowAnalysisFromWriteAction::class)
+        val refs = allowAnalysisFromWriteAction { ReferencesSearch.search(element, scope, false).toArray(PsiReference.EMPTY_ARRAY) }
        if (refs.isNotEmpty()) {
            val lastRef = refs.maxByOrNull { it.element.textOffset } ?: return false
            if (lastRef.element.textOffset > lastStatementOffset) {
--- a/plugins/kotlin/code-insight/impl-base/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinWhenSurrounder.kt
+++ b/plugins/kotlin/code-insight/impl-base/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinWhenSurrounder.kt
@@ -7,8 +7,10 @@ import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.NlsSafe
 import com.intellij.openapi.util.TextRange
 import com.intellij.refactoring.suggested.startOffset
+import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.analyze
+import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisOnEdt
 import org.jetbrains.kotlin.diagnostics.WhenMissingCase
 import org.jetbrains.kotlin.idea.base.psi.replaced
@@ -32,9 +34,12 @@ class KotlinWhenSurrounder : KotlinExpressionSurrounder() {
            }

        val remainingBranches = allowAnalysisOnEdt {
-            analyze(whenExpression) {
-                whenExpression.getMissingCases().takeIf {
-                    it.isNotEmpty() && it.singleOrNull() != WhenMissingCase.Unknown
+            @OptIn(KtAllowAnalysisFromWriteAction::class)
+            allowAnalysisFromWriteAction {
+                analyze(whenExpression) {
+                    whenExpression.getMissingCases().takeIf {
+                        it.isNotEmpty() && it.singleOrNull() != WhenMissingCase.Unknown
+                    }
                }
            }
        }
--- a/plugins/kotlin/code-insight/impl-base/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinWithIfExpressionSurrounder.kt
+++ b/plugins/kotlin/code-insight/impl-base/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinWithIfExpressionSurrounder.kt
@@ -7,8 +7,10 @@ import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.NlsSafe
 import com.intellij.openapi.util.TextRange
+import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.analyze
+import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisOnEdt
 import org.jetbrains.kotlin.idea.codeInsight.surroundWith.KotlinExpressionSurrounder
 import org.jetbrains.kotlin.psi.*
@@ -18,10 +20,12 @@ class KotlinWithIfExpressionSurrounder(val withElse: Boolean) : KotlinExpression
    @OptIn(KtAllowAnalysisOnEdt::class)
    override fun isApplicable(expression: KtExpression): Boolean {
        allowAnalysisOnEdt {
-            return super.isApplicable(expression) &&
-                    analyze(expression) {
-                        expression.getKtType()?.isBoolean ?: false
-                    }
+            @OptIn(KtAllowAnalysisFromWriteAction::class)
+            allowAnalysisFromWriteAction {
+                return super.isApplicable(expression) && analyze(expression) {
+                    expression.getKtType()?.isBoolean == true
+                }
+            }
        }
    }

--- a/plugins/kotlin/code-insight/impl-base/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/statement/KotlinStatementsSurrounder.kt
+++ b/plugins/kotlin/code-insight/impl-base/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/statement/KotlinStatementsSurrounder.kt
@@ -7,8 +7,10 @@ import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.TextRange
 import com.intellij.psi.PsiElement
 import com.intellij.util.IncorrectOperationException
+import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.analyze
+import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisOnEdt
 import org.jetbrains.kotlin.psi.KtExpression

@@ -22,8 +24,11 @@ abstract class KotlinStatementsSurrounder : Surrounder {
            val expr = elements[0] as KtExpression
            if (!isApplicableWhenUsedAsExpression) {
                allowAnalysisOnEdt {
-                    if (analyze(expr) { expr.isUsedAsExpression() }) {
-                        return false
+                    @OptIn(KtAllowAnalysisFromWriteAction::class)
+                    allowAnalysisFromWriteAction {
+                        if (analyze(expr) { expr.isUsedAsExpression() }) {
+                            return false
+                        }
                    }
                }
            }
--- a/plugins/kotlin/code-insight/inspections-k2/kotlin.code-insight.inspections-k2.iml
+++ b/plugins/kotlin/code-insight/inspections-k2/kotlin.code-insight.inspections-k2.iml
@@ -4,7 +4,7 @@
    <facet type="kotlin-language" name="Kotlin">
      <configuration version="5" platform="JVM 17" allPlatforms="JVM [17]" useProjectSettings="false">
        <compilerSettings>
-          <option name="additionalArguments" value="-Xjvm-default=all -opt-in=com.intellij.openapi.util.IntellijInternalApi -Xcontext-receivers" />
+          <option name="additionalArguments" value="-Xjvm-default=all -opt-in=com.intellij.openapi.util.IntellijInternalApi -Xcontext-receivers -opt-in=org.jetbrains.kotlin.analysis.api.lifetime.KtAllowProhibitedAnalyzeFromWriteAction" />
        </compilerSettings>
        <compilerArguments>
          <stringArguments>
--- a/plugins/kotlin/code-insight/inspections-k2/src/org/jetbrains/kotlin/idea/k2/codeinsight/inspections/expressions/WhenWithOnlyElseInspection.kt
+++ b/plugins/kotlin/code-insight/inspections-k2/src/org/jetbrains/kotlin/idea/k2/codeinsight/inspections/expressions/WhenWithOnlyElseInspection.kt
@@ -8,8 +8,10 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.SmartPsiElementPointer
 import com.intellij.psi.search.searches.ReferencesSearch
 import com.intellij.refactoring.suggested.startOffset
+import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.components.KtConstantEvaluationMode
+import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisFromWriteAction
 import org.jetbrains.kotlin.idea.base.analysis.api.utils.shortenReferencesInRange
 import org.jetbrains.kotlin.idea.base.resources.KotlinBundle
 import org.jetbrains.kotlin.idea.codeinsight.api.applicable.inspections.AbstractKotlinApplicableInspectionWithContext
@@ -127,7 +129,8 @@ internal class WhenWithOnlyElseInspection
        val subjectVariable = info.subjectVariable.dereference() ?: return null
        val initializer = info.initializer.dereference() ?: return null
        val isInitializerPure = info.isInitializerPure
-        val references = ReferencesSearch.search(subjectVariable).findAll()
+        @OptIn(KtAllowAnalysisFromWriteAction::class)
+        val references = allowAnalysisFromWriteAction { ReferencesSearch.search(subjectVariable).findAll() }
        val occurrences = references.size
        return when {
            occurrences == 0 && isInitializerPure ->
--- a/plugins/kotlin/code-insight/live-templates-shared/kotlin.code-insight.live-templates-shared.iml
+++ b/plugins/kotlin/code-insight/live-templates-shared/kotlin.code-insight.live-templates-shared.iml
@@ -1,5 +1,21 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <module type="JAVA_MODULE" version="4">
+  <component name="FacetManager">
+    <facet type="kotlin-language" name="Kotlin">
+      <configuration version="5" platform="JVM 17" allPlatforms="JVM [17]" useProjectSettings="false">
+        <compilerSettings>
+          <option name="additionalArguments" value="-Xjvm-default=all -opt-in=com.intellij.openapi.util.IntellijInternalApi -opt-in=org.jetbrains.kotlin.utils.addToStdlib.UnsafeCastFunction -opt-in=org.jetbrains.kotlin.analysis.api.lifetime.KtAllowProhibitedAnalyzeFromWriteAction" />
+        </compilerSettings>
+        <compilerArguments>
+          <stringArguments>
+            <stringArg name="jvmTarget" arg="17" />
+            <stringArg name="apiVersion" arg="1.8" />
+            <stringArg name="languageVersion" arg="1.8" />
+          </stringArguments>
+        </compilerArguments>
+      </configuration>
+    </facet>
+  </component>
  <component name="NewModuleRootManager" inherit-compiler-output="true">
    <exclude-output />
    <content url="file://$MODULE_DIR$">
--- a/plugins/kotlin/code-insight/live-templates-shared/src/org/jetbrains/kotlin/idea/liveTemplates/macro/AnonymousTemplateEditingListener.kt
+++ b/plugins/kotlin/code-insight/live-templates-shared/src/org/jetbrains/kotlin/idea/liveTemplates/macro/AnonymousTemplateEditingListener.kt
@@ -12,9 +12,11 @@ import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.Key
 import com.intellij.psi.PsiDocumentManager
 import com.intellij.psi.PsiFile
+import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.analyze
+import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.symbols.KtClassKind
 import org.jetbrains.kotlin.analysis.api.symbols.KtConstructorSymbol
@@ -41,8 +43,11 @@ internal class AnonymousTemplateEditingListener(private val psiFile: PsiFile, pr
        val referenceExpression = identifier.parent as? KtReferenceExpression ?: return

        allowAnalysisOnEdt {
-            analyze(referenceExpression) {
-                subtypeInfo = resolveSubtypeInfo(referenceExpression)
+            @OptIn(KtAllowAnalysisFromWriteAction::class)
+            allowAnalysisFromWriteAction {
+                analyze(referenceExpression) {
+                    subtypeInfo = resolveSubtypeInfo(referenceExpression)
+                }
            }
        }
    }
--- a/plugins/kotlin/code-insight/override-implement-k2/kotlin.code-insight.override-implement-k2.iml
+++ b/plugins/kotlin/code-insight/override-implement-k2/kotlin.code-insight.override-implement-k2.iml
@@ -4,7 +4,7 @@
    <facet type="kotlin-language" name="Kotlin">
      <configuration version="5" platform="JVM 17" allPlatforms="JVM [17]" useProjectSettings="false">
        <compilerSettings>
-          <option name="additionalArguments" value="-Xjvm-default=all -opt-in=com.intellij.openapi.util.IntellijInternalApi -Xcontext-receivers" />
+          <option name="additionalArguments" value="-Xjvm-default=all -opt-in=com.intellij.openapi.util.IntellijInternalApi -Xcontext-receivers -opt-in=org.jetbrains.kotlin.analysis.api.lifetime.KtAllowProhibitedAnalyzeFromWriteAction" />
        </compilerSettings>
        <compilerArguments>
          <stringArguments>
--- a/plugins/kotlin/code-insight/override-implement-k2/src/org/jetbrains/kotlin/idea/core/overrideImplement/KtGenerateMembersHandler.kt
+++ b/plugins/kotlin/code-insight/override-implement-k2/src/org/jetbrains/kotlin/idea/core/overrideImplement/KtGenerateMembersHandler.kt
@@ -10,11 +10,13 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.SmartPsiElementPointer
 import com.intellij.psi.codeStyle.CodeStyleManager
 import org.jetbrains.annotations.ApiStatus
+import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisOnEdt
 import org.jetbrains.kotlin.idea.core.insertMembersAfter
 import org.jetbrains.kotlin.idea.core.moveCaretIntoGeneratedElement
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.analyze
+import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.renderer.base.annotations.KtRendererAnnotationsFilter
 import org.jetbrains.kotlin.analysis.api.renderer.declarations.impl.KtDeclarationRendererForSource
@@ -45,21 +47,25 @@ abstract class KtGenerateMembersHandler(
    ) {
        // Using allowAnalysisOnEdt here because we don't want to pre-populate all possible textual overrides before user selection.
        val (commands, insertedBlocks) = allowAnalysisOnEdt {
-            val entryMembers = analyze(classOrObject) {
-                this.generateMembers(editor, classOrObject, selectedElements, copyDoc)
-            }
-            val insertedBlocks = insertMembersAccordingToPreferredOrder(entryMembers, editor, classOrObject)
-            // Reference shortening is done in a separate analysis session because the session need to be aware of the newly generated
-            // members.
-            val commands = analyze(classOrObject) {
-                insertedBlocks.mapNotNull { block ->
-                    val declarations = block.declarations.mapNotNull { it.element }
-                    val first = declarations.firstOrNull() ?: return@mapNotNull null
-                    val last = declarations.last()
-                    collectPossibleReferenceShortenings(first.containingKtFile, TextRange(first.startOffset, last.endOffset))
+            @OptIn(KtAllowAnalysisFromWriteAction::class)
+            allowAnalysisFromWriteAction {
+                val entryMembers = analyze(classOrObject) {
+                    this.generateMembers(editor, classOrObject, selectedElements, copyDoc)
                }
+                val insertedBlocks = insertMembersAccordingToPreferredOrder(entryMembers, editor, classOrObject)
+                // Reference shortening is done in a separate analysis session because the session need to be aware of the newly generated
+                // members.
+                val commands = analyze(classOrObject) {
+                    insertedBlocks.mapNotNull { block ->
+                        val declarations = block.declarations.mapNotNull { it.element }
+                        val first = declarations.firstOrNull() ?: return@mapNotNull null
+                        val last = declarations.last()
+                        collectPossibleReferenceShortenings(first.containingKtFile, TextRange(first.startOffset, last.endOffset))
+                    }
+                }
+
+                commands to insertedBlocks
            }
-            commands to insertedBlocks
        }
        runWriteAction {
            commands.forEach { it.invokeShortening() }
--- a/plugins/kotlin/code-insight/utils/kotlin.code-insight.utils.iml
+++ b/plugins/kotlin/code-insight/utils/kotlin.code-insight.utils.iml
@@ -4,7 +4,7 @@
    <facet type="kotlin-language" name="Kotlin">
      <configuration version="5" platform="JVM 17" allPlatforms="JVM [17]" useProjectSettings="false">
        <compilerSettings>
-          <option name="additionalArguments" value="-Xjvm-default=all -Xcontext-receivers" />
+          <option name="additionalArguments" value="-Xjvm-default=all -Xcontext-receivers -opt-in=org.jetbrains.kotlin.analysis.api.lifetime.KtAllowProhibitedAnalyzeFromWriteAction" />
        </compilerSettings>
        <compilerArguments>
          <stringArguments>
--- a/plugins/kotlin/code-insight/utils/src/org/jetbrains/kotlin/idea/codeinsight/utils/ExpressionSimplificationUtils.kt
+++ b/plugins/kotlin/code-insight/utils/src/org/jetbrains/kotlin/idea/codeinsight/utils/ExpressionSimplificationUtils.kt
@@ -2,8 +2,10 @@
 package org.jetbrains.kotlin.idea.codeinsight.utils

 import com.intellij.psi.tree.IElementType
+import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.analyze
+import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.lexer.KtSingleValueToken
@@ -23,9 +25,12 @@ object NegatedBinaryExpressionSimplificationUtils {

        @OptIn(KtAllowAnalysisOnEdt::class)
        allowAnalysisOnEdt {
-            analyze(expression) {
-                fun KtType?.isFloatingPoint() = this != null && (isFloat || isDouble)
-                return !expression.left?.getKtType().isFloatingPoint() && !expression.right?.getKtType().isFloatingPoint()
+            @OptIn(KtAllowAnalysisFromWriteAction::class)
+            allowAnalysisFromWriteAction {
+                analyze(expression) {
+                    fun KtType?.isFloatingPoint() = this != null && (isFloat || isDouble)
+                    return !expression.left?.getKtType().isFloatingPoint() && !expression.right?.getKtType().isFloatingPoint()
+                }
            }
        }
    }
--- a/plugins/kotlin/completion/impl-k2/kotlin.completion.impl-k2.iml
+++ b/plugins/kotlin/completion/impl-k2/kotlin.completion.impl-k2.iml
@@ -4,7 +4,7 @@
    <facet type="kotlin-language" name="Kotlin">
      <configuration version="5" platform="JVM 17" allPlatforms="JVM [17]" useProjectSettings="false">
        <compilerSettings>
-          <option name="additionalArguments" value="-Xjvm-default=all -Xopt-in=com.intellij.openapi.util.IntellijInternalApi -Xcontext-receivers" />
+          <option name="additionalArguments" value="-Xjvm-default=all -Xopt-in=com.intellij.openapi.util.IntellijInternalApi -Xcontext-receivers -opt-in=org.jetbrains.kotlin.analysis.api.lifetime.KtAllowProhibitedAnalyzeFromWriteAction" />
        </compilerSettings>
        <compilerArguments>
          <stringArguments>
--- a/plugins/kotlin/completion/impl-k2/src/org/jetbrains/kotlin/idea/completion/impl/k2/contributors/keywords/OverrideKeywordHandler.kt
+++ b/plugins/kotlin/completion/impl-k2/src/org/jetbrains/kotlin/idea/completion/impl/k2/contributors/keywords/OverrideKeywordHandler.kt
@@ -7,9 +7,11 @@ import com.intellij.codeInsight.lookup.LookupElement
 import com.intellij.icons.AllIcons
 import com.intellij.openapi.project.Project
 import com.intellij.ui.RowIcon
+import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.analyze
+import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.renderer.base.annotations.KtRendererAnnotationsFilter
 import org.jetbrains.kotlin.analysis.api.renderer.declarations.impl.KtDeclarationRendererForSource
@@ -25,6 +27,7 @@ import org.jetbrains.kotlin.idea.base.analysis.api.utils.shortenReferencesInRang
 import org.jetbrains.kotlin.idea.completion.OverridesCompletionLookupElementDecorator
 import org.jetbrains.kotlin.idea.completion.context.FirBasicCompletionContext
 import org.jetbrains.kotlin.idea.completion.keywords.CompletionKeywordHandler
+import org.jetbrains.kotlin.idea.completion.lookups.withAllowedResolve
 import org.jetbrains.kotlin.idea.core.overrideImplement.BodyType
 import org.jetbrains.kotlin.idea.core.overrideImplement.KtClassMember
 import org.jetbrains.kotlin.idea.core.overrideImplement.KtOverrideMembersHandler
@@ -160,11 +163,11 @@ internal class OverrideKeywordHandler(
        classOrObject: KtClassOrObject,
        member: KtClassMember,
        project: Project
-    ) = allowAnalysisOnEdt {
+    ) = withAllowedResolve {
        analyze(classOrObject) {
            val symbolPointer = member.memberInfo.symbolPointer
            val symbol = symbolPointer.restoreSymbol()
-            requireNotNull(symbol) { "${symbolPointer::class} can't be restored"}
+            requireNotNull(symbol) { "${symbolPointer::class} can't be restored" }
            generateMember(
                project,
                member,
--- a/plugins/kotlin/completion/impl-k2/src/org/jetbrains/kotlin/idea/completion/impl/k2/lookups/utils.kt
+++ b/plugins/kotlin/completion/impl-k2/src/org/jetbrains/kotlin/idea/completion/impl/k2/lookups/utils.kt
@@ -10,8 +10,10 @@ import com.intellij.psi.util.nextLeaf
 import com.intellij.psi.util.prevLeaf
 import com.intellij.refactoring.suggested.endOffset
 import com.intellij.refactoring.suggested.startOffset
+import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.signatures.KtCallableSignature
 import org.jetbrains.kotlin.analysis.api.symbols.KtClassifierSymbol
@@ -47,7 +49,10 @@ internal fun KtAnalysisSession.withCallableSignatureInfo(
 // FIXME: This is a hack, we should think how we can get rid of it
@OptIn(KtAllowAnalysisOnEdt::class)
 internal inline fun <T> withAllowedResolve(action: () -> T): T {
-    return allowAnalysisOnEdt(action)
+    @OptIn(KtAllowAnalysisFromWriteAction::class)
+    allowAnalysisFromWriteAction {
+        return allowAnalysisOnEdt(action)
+    }
 }

 internal fun CharSequence.skipSpaces(index: Int): Int =
--- a/plugins/kotlin/kotlin.searching/base/kotlin.searching.base.iml
+++ b/plugins/kotlin/kotlin.searching/base/kotlin.searching.base.iml
@@ -1,5 +1,21 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <module type="JAVA_MODULE" version="4">
+  <component name="FacetManager">
+    <facet type="kotlin-language" name="Kotlin">
+      <configuration version="5" platform="JVM 17" allPlatforms="JVM [17]" useProjectSettings="false">
+        <compilerSettings>
+          <option name="additionalArguments" value="-Xjvm-default=all -opt-in=com.intellij.openapi.util.IntellijInternalApi -opt-in=org.jetbrains.kotlin.utils.addToStdlib.UnsafeCastFunction -opt-in=org.jetbrains.kotlin.analysis.api.lifetime.KtAllowProhibitedAnalyzeFromWriteAction" />
+        </compilerSettings>
+        <compilerArguments>
+          <stringArguments>
+            <stringArg name="jvmTarget" arg="17" />
+            <stringArg name="apiVersion" arg="1.8" />
+            <stringArg name="languageVersion" arg="1.8" />
+          </stringArguments>
+        </compilerArguments>
+      </configuration>
+    </facet>
+  </component>
  <component name="NewModuleRootManager" inherit-compiler-output="true">
    <exclude-output />
    <content url="file://$MODULE_DIR$">
--- a/plugins/kotlin/kotlin.searching/base/src/org/jetbrains/kotlin/idea/base/searching/KotlinAnnotatedElementsSearcher.kt
+++ b/plugins/kotlin/kotlin.searching/base/src/org/jetbrains/kotlin/idea/base/searching/KotlinAnnotatedElementsSearcher.kt
@@ -14,10 +14,12 @@ import com.intellij.psi.util.PsiUtilCore
 import com.intellij.util.Processor
 import com.intellij.util.QueryExecutor
 import com.intellij.util.indexing.FileBasedIndex
+import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.analyze
 import org.jetbrains.kotlin.analysis.api.calls.singleConstructorCallOrNull
 import org.jetbrains.kotlin.analysis.api.calls.symbol
+import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.symbols.KtConstructorSymbol
 import org.jetbrains.kotlin.analysis.api.types.KtNonErrorClassType
@@ -109,12 +111,15 @@ class KotlinAnnotatedElementsSearcher : QueryExecutor<PsiModifierListOwner, Anno
                    if (psiBasedResolveResult == ImpreciseResolveResult.UNSURE) {
                        @OptIn(KtAllowAnalysisOnEdt::class)
                        allowAnalysisOnEdt {
-                            analyze(elt) {
-                                val annotationSymbol = elt.resolveCall()?.singleConstructorCallOrNull()?.symbol
-                                    ?: return false
-                                val annotationType = annotationSymbol.returnType as? KtNonErrorClassType ?: return false
-                                val fqName = annotationType.classId.asFqNameString()
-                                if (fqName != annotationFQN) return true
+                            @OptIn(KtAllowAnalysisFromWriteAction::class)
+                            allowAnalysisFromWriteAction {
+                                analyze(elt) {
+                                    val annotationSymbol = elt.resolveCall()?.singleConstructorCallOrNull()?.symbol
+                                        ?: return false
+                                    val annotationType = annotationSymbol.returnType as? KtNonErrorClassType ?: return false
+                                    val fqName = annotationType.classId.asFqNameString()
+                                    if (fqName != annotationFQN) return true
+                                }
                            }
                        }
                    }
--- a/plugins/kotlin/navigation/kotlin.navigation.iml
+++ b/plugins/kotlin/navigation/kotlin.navigation.iml
@@ -1,5 +1,21 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <module type="JAVA_MODULE" version="4">
+  <component name="FacetManager">
+    <facet type="kotlin-language" name="Kotlin">
+      <configuration version="5" platform="JVM 17" allPlatforms="JVM [17]" useProjectSettings="false">
+        <compilerSettings>
+          <option name="additionalArguments" value="-Xjvm-default=all -opt-in=com.intellij.openapi.util.IntellijInternalApi -opt-in=org.jetbrains.kotlin.utils.addToStdlib.UnsafeCastFunction -opt-in=org.jetbrains.kotlin.analysis.api.lifetime.KtAllowProhibitedAnalyzeFromWriteAction" />
+        </compilerSettings>
+        <compilerArguments>
+          <stringArguments>
+            <stringArg name="jvmTarget" arg="17" />
+            <stringArg name="apiVersion" arg="1.8" />
+            <stringArg name="languageVersion" arg="1.8" />
+          </stringArguments>
+        </compilerArguments>
+      </configuration>
+    </facet>
+  </component>
  <component name="NewModuleRootManager" inherit-compiler-output="true">
    <exclude-output />
    <content url="file://$MODULE_DIR$">
--- a/plugins/kotlin/navigation/src/org/jetbrains/kotlin/idea/navigation/KotlinAnalysisApiBasedDeclarationNavigationPolicyImpl.kt
+++ b/plugins/kotlin/navigation/src/org/jetbrains/kotlin/idea/navigation/KotlinAnalysisApiBasedDeclarationNavigationPolicyImpl.kt
@@ -3,8 +3,10 @@ package org.jetbrains.kotlin.idea.navigation

 import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
+import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.analyze
+import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.renderer.types.impl.KtTypeRendererForSource
 import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol
@@ -215,15 +217,18 @@ internal class KotlinAnalysisApiBasedDeclarationNavigationPolicyImpl : KotlinDec
    // Maybe called from EDT by IJ Platfrom :(
    @OptIn(KtAllowAnalysisOnEdt::class)
    private fun renderTypesForComparasion(declaration: KtCallableDeclaration) = allowAnalysisOnEdt {
-        analyze(declaration) {
-            buildString {
-                val symbol = declaration.getSymbol() as KtCallableSymbol
-                symbol.receiverType?.let { receiverType ->
-                    append(receiverType.render(renderer, position = Variance.INVARIANT))
-                    append('.')
-                }
-                if (symbol is KtFunctionLikeSymbol) {
-                    symbol.valueParameters.joinTo(this) { it.returnType.render(renderer, position = Variance.INVARIANT) }
+        @OptIn(KtAllowAnalysisFromWriteAction::class)
+        allowAnalysisFromWriteAction {
+            analyze(declaration) {
+                buildString {
+                    val symbol = declaration.getSymbol() as KtCallableSymbol
+                    symbol.receiverType?.let { receiverType ->
+                        append(receiverType.render(renderer, position = Variance.INVARIANT))
+                        append('.')
+                    }
+                    if (symbol is KtFunctionLikeSymbol) {
+                        symbol.valueParameters.joinTo(this) { it.returnType.render(renderer, position = Variance.INVARIANT) }
+                    }
                }
            }
        }
--- a/plugins/kotlin/refactorings/kotlin.refactorings.common/kotlin.refactorings.common.iml
+++ b/plugins/kotlin/refactorings/kotlin.refactorings.common/kotlin.refactorings.common.iml
@@ -4,7 +4,7 @@
    <facet type="kotlin-language" name="Kotlin">
      <configuration version="5" platform="JVM 17" allPlatforms="JVM [17]" useProjectSettings="false">
        <compilerSettings>
-          <option name="additionalArguments" value="-Xjvm-default=all -opt-in=com.intellij.openapi.util.IntellijInternalApi -opt-in=org.jetbrains.kotlin.utils.addToStdlib.UnsafeCastFunction -Xcontext-receivers" />
+          <option name="additionalArguments" value="-Xjvm-default=all -opt-in=com.intellij.openapi.util.IntellijInternalApi -opt-in=org.jetbrains.kotlin.utils.addToStdlib.UnsafeCastFunction -Xcontext-receivers -opt-in=org.jetbrains.kotlin.analysis.api.lifetime.KtAllowProhibitedAnalyzeFromWriteAction" />
        </compilerSettings>
        <compilerArguments>
          <stringArguments>
--- a/plugins/kotlin/refactorings/kotlin.refactorings.common/src/org/jetbrains/kotlin/idea/refactoring/helper/KotlinOptimizeImportsRefactoringHelper.kt
+++ b/plugins/kotlin/refactorings/kotlin.refactorings.common/src/org/jetbrains/kotlin/idea/refactoring/helper/KotlinOptimizeImportsRefactoringHelper.kt
@@ -17,8 +17,10 @@ import com.intellij.psi.util.PsiUtilCore
 import com.intellij.refactoring.RefactoringHelper
 import com.intellij.usageView.UsageInfo
 import com.intellij.util.IncorrectOperationException
+import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.analyze
+import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisOnEdt
 import org.jetbrains.kotlin.idea.base.resources.KotlinBundle
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
@@ -40,23 +42,26 @@ class KotlinOptimizeImportsRefactoringHelper : RefactoringHelper<Set<KtFile>> {

        @OptIn(KtAllowAnalysisOnEdt::class)
        override fun run(indicator: ProgressIndicator) = allowAnalysisOnEdt {
-            indicator.isIndeterminate = false
+            @OptIn(KtAllowAnalysisFromWriteAction::class)
+            allowAnalysisFromWriteAction {
+                indicator.isIndeterminate = false

-            val myTotalCount = operationData.size
-            for ((counter, file) in operationData.withIndex()) {
-                ReadAction.nonBlocking {
-                    val virtualFile = file.virtualFile ?: return@nonBlocking
+                val myTotalCount = operationData.size
+                for ((counter, file) in operationData.withIndex()) {
+                    ReadAction.nonBlocking {
+                        val virtualFile = file.virtualFile ?: return@nonBlocking

-                    indicator.fraction = counter.toDouble() / myTotalCount
-                    indicator.text2 = virtualFile.presentableUrl
-                    analyze(file) {
-                        analyseImports(file).unusedImports.mapTo(unusedImports) { it.createSmartPointer() }
+                        indicator.fraction = counter.toDouble() / myTotalCount
+                        indicator.text2 = virtualFile.presentableUrl
+                        analyze(file) {
+                            analyseImports(file).unusedImports.mapTo(unusedImports) { it.createSmartPointer() }
+                        }
                    }
+                        .inSmartMode(project)
+                        .wrapProgress(indicator)
+                        .expireWhen { !file.isValid || project.isDisposed() }
+                        .executeSynchronously()
                }
-                    .inSmartMode(project)
-                    .wrapProgress(indicator)
-                    .expireWhen { !file.isValid || project.isDisposed() }
-                    .executeSynchronously()
            }
        }
    }
--- a/plugins/kotlin/refactorings/kotlin.refactorings.common/src/org/jetbrains/kotlin/idea/refactoring/intentions/OperatorToFunctionConverter.kt
+++ b/plugins/kotlin/refactorings/kotlin.refactorings.common/src/org/jetbrains/kotlin/idea/refactoring/intentions/OperatorToFunctionConverter.kt
@@ -2,10 +2,12 @@
 package org.jetbrains.kotlin.idea.refactoring.intentions

 import org.jetbrains.annotations.NonNls
+import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.analyze
 import org.jetbrains.kotlin.analysis.api.calls.singleFunctionCallOrNull
 import org.jetbrains.kotlin.analysis.api.calls.symbol
+import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtNamedSymbol
 import org.jetbrains.kotlin.config.LanguageFeature
@@ -140,18 +142,24 @@ object OperatorToFunctionConverter {

    @OptIn(KtAllowAnalysisOnEdt::class)
    private fun isOfNullableType(expression: KtExpression): Boolean? = allowAnalysisOnEdt {
-        analyze(expression) {
-            expression.getKtType()?.isMarkedNullable
+        @OptIn(KtAllowAnalysisFromWriteAction::class)
+        allowAnalysisFromWriteAction {
+            analyze(expression) {
+                expression.getKtType()?.isMarkedNullable
+            }
        }
    }

    @OptIn(KtAllowAnalysisOnEdt::class)
    private fun getCalledFunctionName(element: KtBinaryExpression): Name? = allowAnalysisOnEdt {
-        analyze(element) {
-            val resolvedCall = element.resolveCall()?.singleFunctionCallOrNull()
-            val targetSymbol = resolvedCall?.partiallyAppliedSymbol?.symbol
+        @OptIn(KtAllowAnalysisFromWriteAction::class)
+        allowAnalysisFromWriteAction {
+            analyze(element) {
+                val resolvedCall = element.resolveCall()?.singleFunctionCallOrNull()
+                val targetSymbol = resolvedCall?.partiallyAppliedSymbol?.symbol

-            (targetSymbol as? KtNamedSymbol)?.name
+                (targetSymbol as? KtNamedSymbol)?.name
+            }
        }
    }

--- a/plugins/kotlin/refactorings/kotlin.refactorings.common/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinPropertyProcessor.kt
+++ b/plugins/kotlin/refactorings/kotlin.refactorings.common/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinPropertyProcessor.kt
@@ -16,6 +16,8 @@ import com.intellij.refactoring.rename.RenameUtil
 import com.intellij.refactoring.util.MoveRenameUsageInfo
 import com.intellij.refactoring.util.RefactoringUtil
 import com.intellij.usageView.UsageInfo
+import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisFromWriteAction
+import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisFromWriteAction
 import org.jetbrains.kotlin.asJava.*
 import org.jetbrains.kotlin.asJava.elements.KtLightDeclaration
 import org.jetbrains.kotlin.asJava.elements.KtLightMethod
@@ -376,33 +378,39 @@ class RenameKotlinPropertyProcessor : RenameKotlinPsiProcessor() {
      }
    }

-    val adjustedUsages = if (element is KtParameter) usages.filterNot {
-      val refTarget = it.reference?.resolve()
-      refTarget is KtLightMethod && DataClassResolver.isComponentLike(Name.guessByFirstCharacter(refTarget.name))
-    }
-    else usages.toList()
+      val (adjustedUsages, refKindUsages) = @OptIn(KtAllowAnalysisFromWriteAction::class) allowAnalysisFromWriteAction {
+          val adjustedUsages = if (element is KtParameter) {
+              usages.filterNot {
+                  val refTarget = it.reference?.resolve()
+                  refTarget is KtLightMethod && DataClassResolver.isComponentLike(Name.guessByFirstCharacter(refTarget.name))
+              }
+          } else {
+              usages.toList()
+          }

-    val refKindUsages = adjustedUsages.groupBy { usage: UsageInfo ->
-      val refElement = usage.reference?.resolve()
-      if (refElement is PsiMethod) {
-        val refElementName = refElement.name
-        val refElementNameToCheck = (
-                                      if (usage is MangledJavaRefUsageInfo)
-                                        renameRefactoringSupport.demangleInternalName(refElementName)
-                                      else
-                                        null
-                                    ) ?: refElementName
+          val refKindUsages = adjustedUsages.groupBy { usage: UsageInfo ->
+              val refElement = usage.reference?.resolve()
+              if (refElement is PsiMethod) {
+                  val refElementName = refElement.name
+                  val refElementNameToCheck = (
+                          if (usage is MangledJavaRefUsageInfo)
+                              renameRefactoringSupport.demangleInternalName(refElementName)
+                          else
+                              null
+                          ) ?: refElementName

-        when (refElementNameToCheck) {
-          oldGetterName -> UsageKind.GETTER_USAGE
-          oldSetterName -> UsageKind.SETTER_USAGE
-          else -> UsageKind.SIMPLE_PROPERTY_USAGE
-        }
+                  when (refElementNameToCheck) {
+                      oldGetterName -> UsageKind.GETTER_USAGE
+                      oldSetterName -> UsageKind.SETTER_USAGE
+                      else -> UsageKind.SIMPLE_PROPERTY_USAGE
+                  }
+              } else {
+                  UsageKind.SIMPLE_PROPERTY_USAGE
+              }
+          }
+
+          adjustedUsages to refKindUsages
      }
-      else {
-        UsageKind.SIMPLE_PROPERTY_USAGE
-      }
-    }

    super.renameElement(
      element.copy(), JvmAbi.setterName(newNameUnquoted).quoteIfNeeded(),
--- a/plugins/kotlin/refactorings/kotlin.refactorings.common/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinPsiProcessor.kt
+++ b/plugins/kotlin/refactorings/kotlin.refactorings.common/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinPsiProcessor.kt
@@ -13,6 +13,8 @@ import com.intellij.refactoring.rename.RenamePsiElementProcessor
 import com.intellij.refactoring.rename.RenameUtil
 import com.intellij.refactoring.util.MoveRenameUsageInfo
 import com.intellij.usageView.UsageInfo
+import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisFromWriteAction
+import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisFromWriteAction
 import org.jetbrains.kotlin.asJava.classes.KtLightClass
 import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade
 import org.jetbrains.kotlin.asJava.elements.KtLightMethod
@@ -226,7 +228,9 @@ abstract class RenameKotlinPsiProcessor : RenamePsiElementProcessor() {
        return Runnable {
            element.ambiguousImportUsages?.forEach {
                val ref = it.reference as? PsiPolyVariantReference ?: return@forEach
-                if (ref.multiResolve(false).isEmpty()) {
+                @OptIn(KtAllowAnalysisFromWriteAction::class)
+                val multiResolve = allowAnalysisFromWriteAction { ref.multiResolve(false) }
+                if (multiResolve.isEmpty()) {
                    if (!renameMangledUsageIfPossible(it, element, newName)) {
                        ref.handleElementRename(newName)
                    }
--- a/plugins/kotlin/refactorings/kotlin.refactorings.common/src/org/jetbrains/kotlin/idea/refactoring/rename/handlers/RenameKotlinImplicitLambdaParameter.kt
+++ b/plugins/kotlin/refactorings/kotlin.refactorings.common/src/org/jetbrains/kotlin/idea/refactoring/rename/handlers/RenameKotlinImplicitLambdaParameter.kt
@@ -9,8 +9,10 @@ import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiDocumentManager
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiFile
+import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.analyze
+import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.symbols.KtAnonymousFunctionSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
@@ -56,7 +58,9 @@ class RenameKotlinImplicitLambdaParameter : KotlinVariableInplaceRenameHandler()

 private fun KtNameReferenceExpression.createExplicitLambdaParameterByImplicitOne(editor: Editor): KtParameter? {
    if (getReferencedNameAsName() != StandardNames.IMPLICIT_LAMBDA_PARAMETER_NAME) return null
-    val functionLiteral = getFunctionLiteralByImplicitLambdaParameter() ?: return null
+    val functionLiteral = @OptIn(KtAllowAnalysisFromWriteAction::class) allowAnalysisFromWriteAction {
+        getFunctionLiteralByImplicitLambdaParameter() ?: return null
+    }

    val project = project

--- a/plugins/kotlin/refactorings/kotlin.refactorings.k2/kotlin.refactorings.k2.iml
+++ b/plugins/kotlin/refactorings/kotlin.refactorings.k2/kotlin.refactorings.k2.iml
@@ -1,5 +1,21 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <module type="JAVA_MODULE" version="4">
+  <component name="FacetManager">
+    <facet type="kotlin-language" name="Kotlin">
+      <configuration version="5" platform="JVM 17" allPlatforms="JVM [17]" useProjectSettings="false">
+        <compilerSettings>
+          <option name="additionalArguments" value="-Xjvm-default=all -opt-in=com.intellij.openapi.util.IntellijInternalApi -opt-in=org.jetbrains.kotlin.utils.addToStdlib.UnsafeCastFunction -opt-in=org.jetbrains.kotlin.analysis.api.lifetime.KtAllowProhibitedAnalyzeFromWriteAction" />
+        </compilerSettings>
+        <compilerArguments>
+          <stringArguments>
+            <stringArg name="jvmTarget" arg="17" />
+            <stringArg name="apiVersion" arg="1.8" />
+            <stringArg name="languageVersion" arg="1.8" />
+          </stringArguments>
+        </compilerArguments>
+      </configuration>
+    </facet>
+  </component>
  <component name="NewModuleRootManager" inherit-compiler-output="true">
    <exclude-output />
    <content url="file://$MODULE_DIR$">
--- a/plugins/kotlin/refactorings/kotlin.refactorings.k2/src/org/jetbrains/kotlin/idea/k2/refactoring/K2ReferenceMutateService.kt
+++ b/plugins/kotlin/refactorings/kotlin.refactorings.k2/src/org/jetbrains/kotlin/idea/k2/refactoring/K2ReferenceMutateService.kt
@@ -5,9 +5,11 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.util.parentOfType
 import com.intellij.util.IncorrectOperationException
 import com.intellij.util.concurrency.annotations.RequiresWriteLock
+import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.KtSymbolBasedReference
 import org.jetbrains.kotlin.analysis.api.analyze
+import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.symbols.KtSyntheticJavaPropertySymbol
 import org.jetbrains.kotlin.idea.base.analysis.api.utils.invokeShortening
@@ -57,12 +59,18 @@ internal class K2ReferenceMutateService : KtReferenceMutateServiceBase() {
            it.delete()
        }

-        val newShortenings = analyze(newElement) { collectPossibleReferenceShorteningsInElement(newElement) }
+        val newShortenings = @OptIn(KtAllowAnalysisFromWriteAction::class) allowAnalysisFromWriteAction {
+            analyze(newElement) { collectPossibleReferenceShorteningsInElement(newElement) }
+        }
+
        return newShortenings.invokeShortening().firstOrNull() ?: newElement
    }

    private fun KtFile.unusedImports(): Set<KtImportDirective> = analyze(this) {
-        analyseImports(this@unusedImports).unusedImports
+        @OptIn(KtAllowAnalysisFromWriteAction::class)
+        allowAnalysisFromWriteAction {
+            analyseImports(this@unusedImports).unusedImports
+        }
    }

    private fun KtTypeElement.replaceWith(fqName: FqName): KtTypeElement {
@@ -109,19 +117,23 @@ internal class K2ReferenceMutateService : KtReferenceMutateServiceBase() {

    override fun handleElementRename(ktReference: KtReference, newElementName: String): PsiElement? {
        val newName = (ktReference as? KtSimpleReference<KtNameReferenceExpression>)?.getAdjustedNewName(newElementName)
-        if (newName == null && ktReference is KtSymbolBasedReference) {
-            @OptIn(KtAllowAnalysisOnEdt::class)
-            allowAnalysisOnEdt {
-                analyze(ktReference.element) {
-                    val symbol = ktReference.resolveToSymbol() as? KtSyntheticJavaPropertySymbol
-                    if (symbol != null) {
-                        return (ktReference as? KtSimpleReference<KtNameReferenceExpression>)?.renameToOrdinaryMethod(newElementName)
+
+        @OptIn(KtAllowAnalysisFromWriteAction::class)
+        allowAnalysisFromWriteAction {
+            if (newName == null && ktReference is KtSymbolBasedReference) {
+                @OptIn(KtAllowAnalysisOnEdt::class)
+                allowAnalysisOnEdt {
+                    analyze(ktReference.element) {
+                        val symbol = ktReference.resolveToSymbol() as? KtSyntheticJavaPropertySymbol
+                        if (symbol != null) {
+                            return (ktReference as? KtSimpleReference<KtNameReferenceExpression>)?.renameToOrdinaryMethod(newElementName)
+                        }
                    }
                }
            }
-        }

-        return super.handleElementRename(ktReference, newName?.asString() ?: newElementName)
+            return super.handleElementRename(ktReference, newName?.asString() ?: newElementName)
+        }
    }

    override fun replaceWithImplicitInvokeInvocation(newExpression: KtDotQualifiedExpression): KtExpression? =
--- a/plugins/kotlin/refactorings/rename.k2/kotlin.refactorings.rename.k2.iml
+++ b/plugins/kotlin/refactorings/rename.k2/kotlin.refactorings.rename.k2.iml
@@ -1,5 +1,21 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <module type="JAVA_MODULE" version="4">
+  <component name="FacetManager">
+    <facet type="kotlin-language" name="Kotlin">
+      <configuration version="5" platform="JVM 17" allPlatforms="JVM [17]" useProjectSettings="false">
+        <compilerSettings>
+          <option name="additionalArguments" value="-Xjvm-default=all -opt-in=com.intellij.openapi.util.IntellijInternalApi -opt-in=org.jetbrains.kotlin.utils.addToStdlib.UnsafeCastFunction -opt-in=org.jetbrains.kotlin.analysis.api.lifetime.KtAllowProhibitedAnalyzeFromWriteAction" />
+        </compilerSettings>
+        <compilerArguments>
+          <stringArguments>
+            <stringArg name="jvmTarget" arg="17" />
+            <stringArg name="apiVersion" arg="1.8" />
+            <stringArg name="languageVersion" arg="1.8" />
+          </stringArguments>
+        </compilerArguments>
+      </configuration>
+    </facet>
+  </component>
  <component name="NewModuleRootManager" inherit-compiler-output="true">
    <exclude-output />
    <content url="file://$MODULE_DIR$">
--- a/plugins/kotlin/refactorings/rename.k2/src/org/jetbrains/kotlin/idea/k2/refactoring/rename/K2RenameRefactoringSupport.kt
+++ b/plugins/kotlin/refactorings/rename.k2/src/org/jetbrains/kotlin/idea/k2/refactoring/rename/K2RenameRefactoringSupport.kt
@@ -9,9 +9,11 @@ import com.intellij.psi.search.SearchScope
 import com.intellij.psi.search.searches.OverridingMethodsSearch
 import com.intellij.usageView.UsageInfo
 import com.intellij.util.IncorrectOperationException
+import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.analyze
+import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.symbols.*
 import org.jetbrains.kotlin.asJava.classes.KtLightClass
@@ -112,14 +114,17 @@ internal class K2RenameRefactoringSupport : KotlinRenameRefactoringSupport {
        fun KtCallableDeclaration.overridesNothing(): Boolean {
            val declaration = this

-            analyze(this) {
-                val declarationSymbol = declaration.getSymbol() as? KtCallableSymbol ?: return false
+            @OptIn(KtAllowAnalysisFromWriteAction::class)
+            allowAnalysisFromWriteAction {
+                analyze(this) {
+                    val declarationSymbol = declaration.getSymbol() as? KtCallableSymbol ?: return false

-                val callableSymbol = when (declarationSymbol) {
-                    is KtValueParameterSymbol -> declarationSymbol.generatedPrimaryConstructorProperty ?: return false
-                    else -> declarationSymbol
+                    val callableSymbol = when (declarationSymbol) {
+                        is KtValueParameterSymbol -> declarationSymbol.generatedPrimaryConstructorProperty ?: return false
+                        else -> declarationSymbol
+                    }
+                    return callableSymbol.getDirectlyOverriddenSymbols().isEmpty()
                }
-                return callableSymbol.getDirectlyOverriddenSymbols().isEmpty()
            }
        }

--- a/plugins/kotlin/uast/uast-kotlin-fir/kotlin.uast.uast-kotlin-fir.iml
+++ b/plugins/kotlin/uast/uast-kotlin-fir/kotlin.uast.uast-kotlin-fir.iml
@@ -4,7 +4,7 @@
    <facet type="kotlin-language" name="Kotlin">
      <configuration version="5" platform="JVM 11" allPlatforms="JVM [11]" useProjectSettings="false">
        <compilerSettings>
-          <option name="additionalArguments" value="-Xjvm-default=all -opt-in=com.intellij.openapi.util.IntellijInternalApi -Xcontext-receivers" />
+          <option name="additionalArguments" value="-Xjvm-default=all -opt-in=com.intellij.openapi.util.IntellijInternalApi -Xcontext-receivers -opt-in=org.jetbrains.kotlin.analysis.api.lifetime.KtAllowProhibitedAnalyzeFromWriteAction" />
        </compilerSettings>
        <compilerArguments>
          <stringArguments>
--- a/plugins/kotlin/uast/uast-kotlin-fir/src/org/jetbrains/uast/kotlin/FirKotlinUastCodeGenerationPlugin.kt
+++ b/plugins/kotlin/uast/uast-kotlin-fir/src/org/jetbrains/uast/kotlin/FirKotlinUastCodeGenerationPlugin.kt
@@ -4,23 +4,25 @@ package org.jetbrains.uast.kotlin
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiType
+import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.analyze
+import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisOnEdt
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.uast.generate.UastElementFactory
 import org.jetbrains.uast.kotlin.generate.KotlinUastBaseCodeGenerationPlugin
 import org.jetbrains.uast.kotlin.generate.KotlinUastElementFactory
+import org.jetbrains.uast.kotlin.internal.analyzeForUast

 class FirKotlinUastCodeGenerationPlugin : KotlinUastBaseCodeGenerationPlugin() {
  @OptIn(KtAllowAnalysisOnEdt::class)
  override fun shortenReference(sourcePsi: KtElement): PsiElement {
    val ktFile = sourcePsi.containingKtFile
-    allowAnalysisOnEdt {
-      analyze(ktFile) {
+    analyzeForUast(ktFile) {
        collectPossibleReferenceShortenings(ktFile, sourcePsi.textRange)
-      }
    }
+
    //todo apply shortening
    return sourcePsi
  }
--- a/plugins/kotlin/uast/uast-kotlin-fir/src/org/jetbrains/uast/kotlin/internal/firKotlinInternalUastUtils.kt
+++ b/plugins/kotlin/uast/uast-kotlin-fir/src/org/jetbrains/uast/kotlin/internal/firKotlinInternalUastUtils.kt
@@ -5,12 +5,14 @@ package org.jetbrains.uast.kotlin.internal
 import com.intellij.openapi.project.Project
 import com.intellij.psi.*
 import com.intellij.psi.util.PsiTypesUtil
+import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.analyze
 import org.jetbrains.kotlin.analysis.api.calls.KtCallableMemberCall
 import org.jetbrains.kotlin.analysis.api.components.buildClassType
 import org.jetbrains.kotlin.analysis.api.getModule
+import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisFromWriteAction
 import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.symbols.*
 import org.jetbrains.kotlin.analysis.api.types.*
@@ -40,7 +42,10 @@ internal inline fun <R> analyzeForUast(
    useSiteKtElement: KtElement,
    action: KtAnalysisSession.() -> R
 ): R = allowAnalysisOnEdt {
-    analyze(useSiteKtElement, action)
+    @OptIn(KtAllowAnalysisFromWriteAction::class)
+    allowAnalysisFromWriteAction {
+        analyze(useSiteKtElement, action)
+    }
 }

 internal fun KtAnalysisSession.containingKtClass(