Reformat: ReplaceWithAnnotationAnalyzer

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

@@ -47,29 +47,28 @@ data class ReplaceWith(val pattern: String, val imports: List<String>)
 
 object ReplaceWithAnnotationAnalyzer {
     fun analyzeCallableReplacement(
-            annotation: ReplaceWith,
+        annotation: ReplaceWith,
-            symbolDescriptor: CallableDescriptor,
+        symbolDescriptor: CallableDescriptor,
-            resolutionFacade: ResolutionFacade,
+        resolutionFacade: ResolutionFacade,
-            reformat: Boolean
+        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)
     }
 
     private fun analyzeOriginal(
-            annotation: ReplaceWith,
+        annotation: ReplaceWith,
-            symbolDescriptor: CallableDescriptor,
+        symbolDescriptor: CallableDescriptor,
-            resolutionFacade: ResolutionFacade,
+        resolutionFacade: ResolutionFacade,
-            reformat: Boolean
+        reformat: Boolean
     ): CodeToInline? {
         val psiFactory = KtPsiFactory(resolutionFacade.project)
         val expression = try {
             psiFactory.createExpression(annotation.pattern)
-        }
+        } catch (t: Throwable) {
-        catch(t: Throwable) {
             return null
         }
 
@@ -78,27 +77,28 @@ 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)
 
         fun analyzeExpression() = expression.analyzeInContext(scope, expressionTypingServices = expressionTypingServices)
 
         return CodeToInlineBuilder(symbolDescriptor, resolutionFacade)
-                .prepareCodeToInline(expression, emptyList(), ::analyzeExpression, reformat)
+            .prepareCodeToInline(expression, emptyList(), ::analyzeExpression, reformat)
     }
 
     fun analyzeClassifierReplacement(
-            annotation: ReplaceWith,
+        annotation: ReplaceWith,
-            symbolDescriptor: ClassifierDescriptorWithTypeParameters,
+        symbolDescriptor: ClassifierDescriptorWithTypeParameters,
-            resolutionFacade: ResolutionFacade
+        resolutionFacade: ResolutionFacade
     ): KtUserType? {
         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
@@ -108,10 +108,10 @@ object ReplaceWithAnnotationAnalyzer {
         val explicitImportsScope = buildExplicitImportsScope(annotation, resolutionFacade, module)
         val defaultImportScopes = buildDefaultImportsScopes(resolutionFacade, module)
         val scope = getResolutionScope(
-                symbolDescriptor,
+            symbolDescriptor,
-                symbolDescriptor,
+            symbolDescriptor,
-                listOf(explicitImportsScope) + defaultImportScopes,
+            listOf(explicitImportsScope) + defaultImportScopes,
-                resolutionFacade.getFrontendService(LanguageVersionSettings::class.java)
+            resolutionFacade.getFrontendService(LanguageVersionSettings::class.java)
         ) ?: return null
 
         val typeResolver = resolutionFacade.getFrontendService(TypeResolver::class.java)
@@ -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())
@@ -143,52 +144,81 @@ object ReplaceWithAnnotationAnalyzer {
         // TODO: Create import directives from ImportPath, create ImportResolver, create LazyResolverScope, see FileScopeProviderImpl
 
         return listOf(buildExplicitImportsScope(aliasImports.map { it.fqName }, resolutionFacade, module)) +
-               allUnderImports.map { module.getPackage(it.fqName).memberScope.memberScopeAsImportingScope() }.asReversed()
+                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)
     }
 
     private fun importFqNames(annotation: ReplaceWith): List<FqName> {
         return annotation.imports
-                .filter { FqNameUnsafe.isValid(it) }
+            .filter { FqNameUnsafe.isValid(it) }
-                .map(::FqNameUnsafe)
+            .map(::FqNameUnsafe)
-                .filter(FqNameUnsafe::isSafe)
+            .filter(FqNameUnsafe::isSafe)
-                .map(FqNameUnsafe::toSafe)
+            .map(FqNameUnsafe::toSafe)
     }
 
     private fun getResolutionScope(
-            descriptor: DeclarationDescriptor,
+        descriptor: DeclarationDescriptor,
-            ownerDescriptor: DeclarationDescriptor,
+        ownerDescriptor: DeclarationDescriptor,
-            additionalScopes: Collection<ImportingScope>,
+        additionalScopes: Collection<ImportingScope>,
-            languageVersionSettings: LanguageVersionSettings
+        languageVersionSettings: LanguageVersionSettings
     ): LexicalScope? {
         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)!!,
+                    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