Reformat: ReplaceWithAnnotationAnalyzer

idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/ReplaceWithAnnotationAnalyzer.kt

@@ -52,10 +52,10 @@ object ReplaceWithAnnotationAnalyzer {
         resolutionFacade: ResolutionFacade,
         reformat: Boolean
     ): CodeToInline? {
-        val originalDescriptor = (if (symbolDescriptor is CallableMemberDescriptor)
+        val originalDescriptor = when (symbolDescriptor) {
-            DescriptorUtils.unwrapFakeOverride(symbolDescriptor)
+            is CallableMemberDescriptor -> DescriptorUtils.unwrapFakeOverride(symbolDescriptor)
-        else
+            else -> symbolDescriptor
-            symbolDescriptor).original
+        }.original
         return analyzeOriginal(annotation, originalDescriptor, resolutionFacade, reformat)
     }
 
@@ -68,8 +68,7 @@ object ReplaceWithAnnotationAnalyzer {
         val psiFactory = KtPsiFactory(resolutionFacade.project)
         val expression = try {
             psiFactory.createExpression(annotation.pattern)
-        }
+        } catch (t: Throwable) {
-        catch(t: Throwable) {
             return null
         }
 
@@ -78,8 +77,10 @@ object ReplaceWithAnnotationAnalyzer {
         val defaultImportsScopes = buildDefaultImportsScopes(resolutionFacade, module)
 
         val languageVersionSettings = resolutionFacade.getFrontendService(LanguageVersionSettings::class.java)
-        val scope = getResolutionScope(symbolDescriptor, symbolDescriptor,
+        val scope = getResolutionScope(
-                                       listOf(explicitImportsScope) + defaultImportsScopes, languageVersionSettings) ?: return null
+            symbolDescriptor, symbolDescriptor,
+            listOf(explicitImportsScope) + defaultImportsScopes, languageVersionSettings
+        ) ?: return null
 
         val expressionTypingServices = resolutionFacade.getFrontendService(module, ExpressionTypingServices::class.java)
 
@@ -97,8 +98,7 @@ object ReplaceWithAnnotationAnalyzer {
         val psiFactory = KtPsiFactory(resolutionFacade.project)
         val typeReference = try {
             psiFactory.createType(annotation.pattern)
-        }
+        } catch (e: Exception) {
-        catch(e: Exception) {
             return null
         }
         if (typeReference.typeElement !is KtUserType) return null
@@ -123,7 +123,8 @@ object ReplaceWithAnnotationAnalyzer {
         typeReference.forEachDescendantOfType<KtNameReferenceExpression> { expression ->
             val parentType = expression.parent as? KtUserType ?: return@forEachDescendantOfType
             if (parentType.qualifier != null) return@forEachDescendantOfType
-            val targetClass = bindingTrace.bindingContext[BindingContext.REFERENCE_TARGET, expression] as? ClassDescriptor ?: return@forEachDescendantOfType
+            val targetClass = bindingTrace.bindingContext[BindingContext.REFERENCE_TARGET, expression] as? ClassDescriptor
+                    ?: return@forEachDescendantOfType
             val fqName = targetClass.fqNameUnsafe
             if (fqName.isSafe) {
                 typesToQualify.add(expression to fqName.toSafe())
@@ -146,11 +147,19 @@ object ReplaceWithAnnotationAnalyzer {
                 allUnderImports.map { module.getPackage(it.fqName).memberScope.memberScopeAsImportingScope() }.asReversed()
     }
 
-    private fun buildExplicitImportsScope(annotation: ReplaceWith, resolutionFacade: ResolutionFacade, module: ModuleDescriptor): ExplicitImportsScope {
+    private fun buildExplicitImportsScope(
+        annotation: ReplaceWith,
+        resolutionFacade: ResolutionFacade,
+        module: ModuleDescriptor
+    ): ExplicitImportsScope {
         return buildExplicitImportsScope(importFqNames(annotation), resolutionFacade, module)
     }
 
-    private fun buildExplicitImportsScope(importFqNames: List<FqName>, resolutionFacade: ResolutionFacade, module: ModuleDescriptor): ExplicitImportsScope {
+    private fun buildExplicitImportsScope(
+        importFqNames: List<FqName>,
+        resolutionFacade: ResolutionFacade,
+        module: ModuleDescriptor
+    ): ExplicitImportsScope {
         val importedSymbols = importFqNames.flatMap { resolutionFacade.resolveImportReference(module, it) }
         return ExplicitImportsScope(importedSymbols)
     }
@@ -172,23 +181,44 @@ object ReplaceWithAnnotationAnalyzer {
         return when (descriptor) {
             is PackageFragmentDescriptor -> {
                 val moduleDescriptor = descriptor.containingDeclaration
-                getResolutionScope(moduleDescriptor.getPackage(descriptor.fqName), ownerDescriptor, additionalScopes, languageVersionSettings)
+                getResolutionScope(
+                    moduleDescriptor.getPackage(descriptor.fqName),
+                    ownerDescriptor,
+                    additionalScopes,
+                    languageVersionSettings
+                )
             }
 
             is PackageViewDescriptor -> {
                 LexicalScope.Base(
                     chainImportingScopes(listOf(descriptor.memberScope.memberScopeAsImportingScope()) + additionalScopes)!!,
-                        ownerDescriptor)
+                    ownerDescriptor
+                )
             }
 
             is ClassDescriptor -> {
-                val outerScope = getResolutionScope(descriptor.containingDeclaration, ownerDescriptor, additionalScopes, languageVersionSettings) ?: return null
+                val outerScope = getResolutionScope(
-                ClassResolutionScopesSupport(descriptor, LockBasedStorageManager.NO_LOCKS, languageVersionSettings, { outerScope }).scopeForMemberDeclarationResolution()
+                    descriptor.containingDeclaration, ownerDescriptor, additionalScopes, languageVersionSettings
+                ) ?: return null
+                ClassResolutionScopesSupport(
+                    descriptor,
+                    LockBasedStorageManager.NO_LOCKS,
+                    languageVersionSettings
+                ) { outerScope }.scopeForMemberDeclarationResolution()
             }
 
             is TypeAliasDescriptor -> {
-                val outerScope = getResolutionScope(descriptor.containingDeclaration, ownerDescriptor, additionalScopes, languageVersionSettings) ?: return null
+                val outerScope = getResolutionScope(
-                LexicalScopeImpl(outerScope, descriptor, false, null, LexicalScopeKind.TYPE_ALIAS_HEADER, LocalRedeclarationChecker.DO_NOTHING) {
+                    descriptor.containingDeclaration, ownerDescriptor, additionalScopes, languageVersionSettings
+                ) ?: return null
+                LexicalScopeImpl(
+                    outerScope,
+                    descriptor,
+                    false,
+                    null,
+                    LexicalScopeKind.TYPE_ALIAS_HEADER,
+                    LocalRedeclarationChecker.DO_NOTHING
+                ) {
                     for (typeParameter in descriptor.declaredTypeParameters) {
                         addClassifierDescriptor(typeParameter)
                     }
@@ -196,14 +226,24 @@ object ReplaceWithAnnotationAnalyzer {
             }
 
             is FunctionDescriptor -> {
-                val outerScope = getResolutionScope(descriptor.containingDeclaration, ownerDescriptor, additionalScopes, languageVersionSettings) ?: return null
+                val outerScope = getResolutionScope(
+                    descriptor.containingDeclaration, ownerDescriptor, additionalScopes, languageVersionSettings
+                ) ?: return null
                 FunctionDescriptorUtil.getFunctionInnerScope(outerScope, descriptor, LocalRedeclarationChecker.DO_NOTHING)
             }
 
             is PropertyDescriptor -> {
-                val outerScope = getResolutionScope(descriptor.containingDeclaration, ownerDescriptor, additionalScopes, languageVersionSettings) ?: return null
+                val outerScope = getResolutionScope(
+                    descriptor.containingDeclaration, ownerDescriptor, additionalScopes, languageVersionSettings
+                ) ?: return null
                 val propertyHeader = ScopeUtils.makeScopeForPropertyHeader(outerScope, descriptor)
-                LexicalScopeImpl(propertyHeader, descriptor, false, descriptor.extensionReceiverParameter, LexicalScopeKind.PROPERTY_ACCESSOR_BODY)
+                LexicalScopeImpl(
+                    propertyHeader,
+                    descriptor,
+                    false,
+                    descriptor.extensionReceiverParameter,
+                    LexicalScopeKind.PROPERTY_ACCESSOR_BODY
+                )
             }
 
             else -> return null // something local, should not work with ReplaceWith