From 6f5a2172acd652bca6566663bfa1716b83bb17f9 Mon Sep 17 00:00:00 2001 From: Alexey Kudravtsev Date: Wed, 15 Oct 2014 15:11:49 +0400 Subject: [PATCH] moved more find usages-related stuff to idea-analysis for upsource --- .../codeInsight/JetFileReferencesResolver.kt | 2 +- .../plugin/codeInsight/ShortenReferences.kt | 4 +- .../codeInsight/shorten/shortenWaitingSet.kt | 72 +++++ .../findUsages/JetFindUsagesProvider.kt | 0 .../plugin/findUsages/KotlinWordsScanner.kt | 0 .../jet/plugin/findUsages/UsageTypeUtils.kt | 282 ++++++++++++++++++ .../plugin/quickfix/ImportInsertHelper.java | 44 +++ .../plugin/refactoring/fqName/fqNameUtil.kt | 76 +++++ .../references/JetArrayAccessReference.java | 0 .../references/JetForLoopInReference.kt | 0 .../JetInvokeFunctionReference.java | 0 .../JetMultiDeclarationReference.kt | 0 .../JetPropertyDelegationMethodsReference.kt | 0 .../references/JetReferenceContributor.kt | 2 +- .../references/JetSimpleNameReference.kt | 6 +- .../plugin/references/JetThisReference.java | 0 .../KotlinReferencesSearcher.java | 0 .../search/usagesSearch/commonFilters.kt | 2 +- .../plugin/search/usagesSearch/conventions.kt | 0 .../search/usagesSearch/searchHelpers.kt | 0 .../search/usagesSearch/usagesSearch.kt | 2 - .../jet/plugin/search/usagesSearch/utils.kt | 14 +- .../plugin/util/IdeDescriptorRenderers.java | 0 .../jetbrains/jet/plugin/util/stringUtil.kt | 0 idea/src/META-INF/plugin.xml | 2 + .../plugin/actions/JetAddImportAction.java | 2 +- .../KotlinCopyPasteReferenceProcessor.kt | 4 +- ...otlinShortenReferencesRefactoringHelper.kt | 51 +--- .../plugin/completion/CompletionSorting.kt | 4 +- .../handlers/KotlinCallableInsertHandler.kt | 2 +- .../plugin/findUsages/JetUsageTypeProvider.kt | 213 +++---------- .../plugin/imports/KotlinImportOptimizer.kt | 6 +- .../jet/plugin/quickfix/AutoImportFix.kt | 2 +- ...elper.java => ImportInsertHelperImpl.java} | 27 +- .../extractFunction/extractorUtil.kt | 2 +- .../plugin/refactoring/jetRefactoringUtil.kt | 44 --- .../MoveKotlinFileHandler.kt | 2 +- ...MoveKotlinTopLevelDeclarationsProcessor.kt | 5 +- .../jet/plugin/refactoring/move/moveUtils.kt | 4 +- ...AbstractEditorForEvaluateExpressionTest.kt | 2 +- .../imports/OptimizeImportsOnFlyTest.java | 2 +- .../quickfix/ImportClassHelperTest.java | 6 +- 42 files changed, 566 insertions(+), 320 deletions(-) rename idea/{ => idea-analysis}/src/org/jetbrains/jet/plugin/codeInsight/JetFileReferencesResolver.kt (99%) rename idea/{ => idea-analysis}/src/org/jetbrains/jet/plugin/codeInsight/ShortenReferences.kt (98%) create mode 100644 idea/idea-analysis/src/org/jetbrains/jet/plugin/codeInsight/shorten/shortenWaitingSet.kt rename idea/{ => idea-analysis}/src/org/jetbrains/jet/plugin/findUsages/JetFindUsagesProvider.kt (100%) rename idea/{ => idea-analysis}/src/org/jetbrains/jet/plugin/findUsages/KotlinWordsScanner.kt (100%) create mode 100644 idea/idea-analysis/src/org/jetbrains/jet/plugin/findUsages/UsageTypeUtils.kt create mode 100644 idea/idea-analysis/src/org/jetbrains/jet/plugin/quickfix/ImportInsertHelper.java create mode 100644 idea/idea-analysis/src/org/jetbrains/jet/plugin/refactoring/fqName/fqNameUtil.kt rename idea/{ => idea-analysis}/src/org/jetbrains/jet/plugin/references/JetArrayAccessReference.java (100%) rename idea/{ => idea-analysis}/src/org/jetbrains/jet/plugin/references/JetForLoopInReference.kt (100%) rename idea/{ => idea-analysis}/src/org/jetbrains/jet/plugin/references/JetInvokeFunctionReference.java (100%) rename idea/{ => idea-analysis}/src/org/jetbrains/jet/plugin/references/JetMultiDeclarationReference.kt (100%) rename idea/{ => idea-analysis}/src/org/jetbrains/jet/plugin/references/JetPropertyDelegationMethodsReference.kt (100%) rename idea/{ => idea-analysis}/src/org/jetbrains/jet/plugin/references/JetReferenceContributor.kt (99%) rename idea/{ => idea-analysis}/src/org/jetbrains/jet/plugin/references/JetSimpleNameReference.kt (96%) rename idea/{ => idea-analysis}/src/org/jetbrains/jet/plugin/references/JetThisReference.java (100%) rename idea/{ => idea-analysis}/src/org/jetbrains/jet/plugin/search/ideaExtensions/KotlinReferencesSearcher.java (100%) rename idea/{ => idea-analysis}/src/org/jetbrains/jet/plugin/search/usagesSearch/commonFilters.kt (98%) rename idea/{ => idea-analysis}/src/org/jetbrains/jet/plugin/search/usagesSearch/conventions.kt (100%) rename idea/{ => idea-analysis}/src/org/jetbrains/jet/plugin/search/usagesSearch/searchHelpers.kt (100%) rename idea/{ => idea-analysis}/src/org/jetbrains/jet/plugin/search/usagesSearch/usagesSearch.kt (98%) rename idea/{ => idea-analysis}/src/org/jetbrains/jet/plugin/search/usagesSearch/utils.kt (92%) rename idea/{ => idea-analysis}/src/org/jetbrains/jet/plugin/util/IdeDescriptorRenderers.java (100%) rename idea/{ => idea-analysis}/src/org/jetbrains/jet/plugin/util/stringUtil.kt (100%) rename idea/src/org/jetbrains/jet/plugin/quickfix/{ImportInsertHelper.java => ImportInsertHelperImpl.java} (83%) diff --git a/idea/src/org/jetbrains/jet/plugin/codeInsight/JetFileReferencesResolver.kt b/idea/idea-analysis/src/org/jetbrains/jet/plugin/codeInsight/JetFileReferencesResolver.kt similarity index 99% rename from idea/src/org/jetbrains/jet/plugin/codeInsight/JetFileReferencesResolver.kt rename to idea/idea-analysis/src/org/jetbrains/jet/plugin/codeInsight/JetFileReferencesResolver.kt index 6a6669111a5..fc75d7e5e91 100644 --- a/idea/src/org/jetbrains/jet/plugin/codeInsight/JetFileReferencesResolver.kt +++ b/idea/idea-analysis/src/org/jetbrains/jet/plugin/codeInsight/JetFileReferencesResolver.kt @@ -102,4 +102,4 @@ object JetFileReferencesResolver { } fun JetExpression.referenceExpression(): JetReferenceExpression? = - (if (this is JetCallExpression) getCalleeExpression() else this) as? JetReferenceExpression \ No newline at end of file + (if (this is JetCallExpression) getCalleeExpression() else this) as? JetReferenceExpression diff --git a/idea/src/org/jetbrains/jet/plugin/codeInsight/ShortenReferences.kt b/idea/idea-analysis/src/org/jetbrains/jet/plugin/codeInsight/ShortenReferences.kt similarity index 98% rename from idea/src/org/jetbrains/jet/plugin/codeInsight/ShortenReferences.kt rename to idea/idea-analysis/src/org/jetbrains/jet/plugin/codeInsight/ShortenReferences.kt index 06ae54e4d48..1fd0fd5a2f7 100644 --- a/idea/src/org/jetbrains/jet/plugin/codeInsight/ShortenReferences.kt +++ b/idea/idea-analysis/src/org/jetbrains/jet/plugin/codeInsight/ShortenReferences.kt @@ -99,7 +99,7 @@ public object ShortenReferences { private fun process(elements: Iterable, elementFilter: (PsiElement) -> FilterResult) { for ((file, fileElements) in elements.groupBy { element -> element.getContainingJetFile() }) { - ImportInsertHelper.optimizeImportsOnTheFly(file) + ImportInsertHelper.getInstance().optimizeImportsOnTheFly(file) // first resolve all qualified references - optimization val referenceToContext = JetFileReferencesResolver.resolve(file, fileElements, resolveShortNames = false) @@ -335,6 +335,6 @@ public object ShortenReferences { = "${getExtensionReceiver()}, ${getDispatchReceiver()} -> ${getResultingDescriptor()?.let {FQ_NAMES_IN_TYPES.render(it)}}" private fun addImport(descriptor: DeclarationDescriptor, file: JetFile) { - ImportInsertHelper.writeImportToFile(ImportPath(DescriptorUtils.getFqNameSafe(descriptor), false), file) + ImportInsertHelper.getInstance().writeImportToFile(ImportPath(DescriptorUtils.getFqNameSafe(descriptor), false), file) } } diff --git a/idea/idea-analysis/src/org/jetbrains/jet/plugin/codeInsight/shorten/shortenWaitingSet.kt b/idea/idea-analysis/src/org/jetbrains/jet/plugin/codeInsight/shorten/shortenWaitingSet.kt new file mode 100644 index 00000000000..3a6d9ca195a --- /dev/null +++ b/idea/idea-analysis/src/org/jetbrains/jet/plugin/codeInsight/shorten/shortenWaitingSet.kt @@ -0,0 +1,72 @@ +/* + * Copyright 2010-2014 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.plugin.codeInsight.shorten + +import com.intellij.openapi.project.Project +import com.intellij.psi.SmartPsiElementPointer +import org.jetbrains.jet.lang.psi.JetElement +import org.jetbrains.jet.lang.psi.UserDataProperty +import com.intellij.openapi.util.Key +import org.jetbrains.jet.lang.psi.NotNullableUserDataProperty +import java.util.HashSet +import com.intellij.openapi.application.ApplicationManager +import com.intellij.psi.SmartPointerManager +import com.intellij.openapi.diagnostic.Logger + +private var Project.elementsToShorten: MutableSet>? + by UserDataProperty(Key.create("ELEMENTS_TO_SHORTEN_KEY")) + +/* + * When one refactoring invokes another this value must be set to false so that shortening wait-set is not cleared + * and previously collected references are processed correctly. Afterwards it must be reset to original value + */ +public var Project.ensureElementsToShortenIsEmptyBeforeRefactoring: Boolean + by NotNullableUserDataProperty(Key.create("ENSURE_ELEMENTS_TO_SHORTEN_IS_EMPTY"), true) + +private fun Project.getOrCreateElementsToShorten(): MutableSet> { + var elements = elementsToShorten + if (elements == null) { + elements = HashSet() + elementsToShorten = elements + } + + return elements!! +} + +public fun JetElement.addToShorteningWaitSet() { + assert (ApplicationManager.getApplication()!!.isWriteAccessAllowed(), "Write access needed") + val project = getProject() + project.getOrCreateElementsToShorten().add(SmartPointerManager.getInstance(project).createSmartPsiElementPointer(this)) +} + +public fun withElementsToShorten(project: Project, f: (Set>) -> Unit) { + project.elementsToShorten?.let { bindRequests -> + project.elementsToShorten = null + f(bindRequests) + } + +} + +private val LOG = Logger.getInstance(javaClass().getCanonicalName()) + +public fun prepareElementsToShorten(project: Project) { + val elementsToShorten = project.elementsToShorten + if (project.ensureElementsToShortenIsEmptyBeforeRefactoring && elementsToShorten != null && !elementsToShorten.isEmpty()) { + LOG.warn("Waiting set for reference shortening is not empty") + project.elementsToShorten = null + } +} diff --git a/idea/src/org/jetbrains/jet/plugin/findUsages/JetFindUsagesProvider.kt b/idea/idea-analysis/src/org/jetbrains/jet/plugin/findUsages/JetFindUsagesProvider.kt similarity index 100% rename from idea/src/org/jetbrains/jet/plugin/findUsages/JetFindUsagesProvider.kt rename to idea/idea-analysis/src/org/jetbrains/jet/plugin/findUsages/JetFindUsagesProvider.kt diff --git a/idea/src/org/jetbrains/jet/plugin/findUsages/KotlinWordsScanner.kt b/idea/idea-analysis/src/org/jetbrains/jet/plugin/findUsages/KotlinWordsScanner.kt similarity index 100% rename from idea/src/org/jetbrains/jet/plugin/findUsages/KotlinWordsScanner.kt rename to idea/idea-analysis/src/org/jetbrains/jet/plugin/findUsages/KotlinWordsScanner.kt diff --git a/idea/idea-analysis/src/org/jetbrains/jet/plugin/findUsages/UsageTypeUtils.kt b/idea/idea-analysis/src/org/jetbrains/jet/plugin/findUsages/UsageTypeUtils.kt new file mode 100644 index 00000000000..6f4cb1987ae --- /dev/null +++ b/idea/idea-analysis/src/org/jetbrains/jet/plugin/findUsages/UsageTypeUtils.kt @@ -0,0 +1,282 @@ +/* + * Copyright 2010-2014 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.plugin.findUsages + +import com.intellij.psi.PsiElement +import org.jetbrains.jet.lang.psi.JetForExpression +import org.jetbrains.jet.lang.psi.JetMultiDeclaration +import org.jetbrains.jet.lang.psi.psiUtil.getParentByType +import org.jetbrains.jet.lang.psi.JetReferenceExpression +import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache +import org.jetbrains.jet.lang.psi.JetImportDirective +import org.jetbrains.jet.lang.psi.psiUtil.getParentByTypeAndBranch +import org.jetbrains.jet.lang.psi.JetCallableReferenceExpression +import org.jetbrains.jet.lang.psi.JetProperty +import org.jetbrains.jet.lang.psi.psiUtil.isAncestor +import org.jetbrains.jet.lang.psi.JetFunction +import org.jetbrains.jet.lang.psi.JetTypeParameter +import org.jetbrains.jet.lang.psi.JetTypeConstraint +import org.jetbrains.jet.lang.psi.JetDelegationSpecifier +import org.jetbrains.jet.lang.psi.JetTypedef +import org.jetbrains.jet.lang.psi.JetTypeProjection +import org.jetbrains.jet.lang.psi.JetParameter +import org.jetbrains.jet.lang.psi.JetIsExpression +import org.jetbrains.jet.lang.psi.JetBinaryExpressionWithTypeRHS +import org.jetbrains.jet.lexer.JetTokens +import org.jetbrains.jet.lang.psi.JetDotQualifiedExpression +import org.jetbrains.jet.lang.psi.JetSuperExpression +import org.jetbrains.jet.lang.psi.JetDelegatorByExpressionSpecifier +import org.jetbrains.jet.lang.psi.psiUtil.getParentByTypesAndPredicate +import org.jetbrains.jet.lang.psi.JetBinaryExpression +import org.jetbrains.jet.lang.psi.JetPsiUtil +import org.jetbrains.jet.lang.psi.JetSimpleNameExpression +import org.jetbrains.jet.lang.descriptors.FunctionDescriptor +import org.jetbrains.jet.plugin.references.JetArrayAccessReference +import org.jetbrains.jet.lang.resolve.BindingContext +import org.jetbrains.jet.plugin.references.JetInvokeFunctionReference +import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor +import org.jetbrains.jet.lang.psi.JetAnnotationEntry +import org.jetbrains.jet.lang.psi.JetCallExpression +import org.jetbrains.jet.lang.psi.JetUnaryExpression +import org.jetbrains.jet.lang.psi.JetWhenConditionInRange +import org.jetbrains.jet.lang.psi.JetPackageDirective +import org.jetbrains.jet.lang.psi.JetQualifiedExpression +import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor +import org.jetbrains.jet.lang.descriptors.ClassDescriptor +import org.jetbrains.jet.lang.descriptors.ClassKind +import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor +import com.intellij.psi.PsiPackage +import org.jetbrains.jet.lang.descriptors.VariableDescriptor +import org.jetbrains.jet.plugin.JetBundle +import org.jetbrains.jet.plugin.findUsages.UsageTypeEnum.* + +public object UsageTypeUtils { + public fun getUsageType(element: PsiElement?): UsageTypeEnum? { + when (element) { + is JetForExpression -> return IMPLICIT_ITERATION + is JetMultiDeclaration -> return READ + } + + val refExpr = element?.getParentByType(javaClass()) + if (refExpr == null) return null + + val context = AnalyzerFacadeWithCache.getContextForElement(refExpr) + + fun getCommonUsageType(): UsageTypeEnum? { + return when { + refExpr.getParentByType(javaClass()) != null -> + CLASS_IMPORT + refExpr.getParentByTypeAndBranch(javaClass()) { getCallableReference() } != null -> + CALLABLE_REFERENCE + else -> null + } + } + + fun getClassUsageType(): UsageTypeEnum? { + val property = refExpr.getParentByType(javaClass()) + if (property != null) { + when { + property.getTypeReference().isAncestor(refExpr) -> + return if (property.isLocal()) CLASS_LOCAL_VAR_DECLARATION else NON_LOCAL_PROPERTY_TYPE + + property.getReceiverTypeReference().isAncestor(refExpr) -> + return EXTENSION_RECEIVER_TYPE + } + } + + val function = refExpr.getParentByType(javaClass()) + if (function != null) { + when { + function.getTypeReference().isAncestor(refExpr) -> + return FUNCTION_RETURN_TYPE + function.getReceiverTypeReference().isAncestor(refExpr) -> + return EXTENSION_RECEIVER_TYPE + } + } + + return when { + refExpr.getParentByTypeAndBranch(javaClass()) { getExtendsBound() } != null + || refExpr.getParentByTypeAndBranch(javaClass()) { getBoundTypeReference() } != null -> + TYPE_CONSTRAINT + + refExpr is JetDelegationSpecifier + || refExpr.getParentByTypeAndBranch(javaClass()) { getTypeReference() } != null -> + SUPER_TYPE + + refExpr.getParentByTypeAndBranch(javaClass()) { getTypeReference() } != null -> + TYPE_DEFINITION + + refExpr.getParentByType(javaClass()) != null -> + TYPE_PARAMETER + + refExpr.getParentByTypeAndBranch(javaClass()) { getTypeReference() } != null -> + VALUE_PARAMETER_TYPE + + refExpr.getParentByTypeAndBranch(javaClass()) { getTypeReference() } != null -> + IS + + with(refExpr.getParentByTypeAndBranch(javaClass()) { getRight() }) { + val opType = this?.getOperationReference()?.getReferencedNameElementType() + opType == JetTokens.AS_KEYWORD || opType == JetTokens.AS_SAFE + } -> + CLASS_CAST_TO + + with(refExpr.getParentByType(javaClass())) { + if (this == null) false + else if (getReceiverExpression() == refExpr) true + else + getSelectorExpression() == refExpr + && getParentByTypeAndBranch(javaClass(), true) { getReceiverExpression() } != null + } -> + CLASS_OBJECT_ACCESS + + refExpr.getParentByTypeAndBranch(javaClass()) { getSuperTypeQualifier() } != null -> + SUPER_TYPE_QUALIFIER + + else -> null + } + } + + fun getVariableUsageType(): UsageTypeEnum? { + if (refExpr.getParentByTypeAndBranch(javaClass()) { getDelegateExpression() } != null) { + return DELEGATE + } + + val dotQualifiedExpression = refExpr.getParentByType(javaClass()) + + if (dotQualifiedExpression != null) { + val parent = dotQualifiedExpression.getParent() + when { + dotQualifiedExpression.getReceiverExpression().isAncestor(refExpr) -> + return RECEIVER + + parent is JetDotQualifiedExpression && parent.getReceiverExpression().isAncestor(refExpr) -> + return RECEIVER + } + } + + return when { + (refExpr.getParentByTypesAndPredicate(false, javaClass()) { JetPsiUtil.isAssignment(it) }) + ?.getLeft().isAncestor(refExpr) -> + WRITE + + refExpr.getParentByType(javaClass()) != null -> + READ + + else -> null + } + } + + fun getFunctionUsageType(descriptor: FunctionDescriptor): UsageTypeEnum? { + val ref = refExpr.getReference() + when (ref) { + is JetArrayAccessReference -> { + return when { + context[BindingContext.INDEXED_LVALUE_GET, refExpr] != null -> IMPLICIT_GET + context[BindingContext.INDEXED_LVALUE_SET, refExpr] != null -> IMPLICIT_SET + else -> null + } + } + is JetInvokeFunctionReference -> return IMPLICIT_INVOKE + } + + return when { + refExpr.getParentByTypeAndBranch(javaClass()) { getTypeReference() } != null -> + SUPER_TYPE + + descriptor is ConstructorDescriptor + && refExpr.getParentByTypeAndBranch(javaClass()) { getTypeReference() } != null -> + ANNOTATION + + with(refExpr.getParentByTypeAndBranch(javaClass()) { getCalleeExpression() }) { + this?.getCalleeExpression() is JetSimpleNameExpression + } -> + if (descriptor is ConstructorDescriptor) CLASS_NEW_OPERATOR else FUNCTION_CALL + + refExpr.getParentByTypeAndBranch(javaClass()) { getOperationReference() } != null, + refExpr.getParentByTypeAndBranch(javaClass()) { getOperationReference() } != null, + refExpr.getParentByTypeAndBranch(javaClass()) { getOperationReference() } != null -> + FUNCTION_CALL + + else -> null + } + } + + fun getPackageUsageType(): UsageTypeEnum? { + return when { + refExpr.getParentByType(javaClass()) != null -> PACKAGE_DIRECTIVE + refExpr.getParentByType(javaClass()) != null -> PACKAGE_MEMBER_ACCESS + else -> getClassUsageType() + } + } + + val usageType = getCommonUsageType() + if (usageType != null) return usageType + + val descriptor = context[BindingContext.REFERENCE_TARGET, refExpr] + + return when (descriptor) { + is ClassifierDescriptor -> when ((descriptor as? ClassDescriptor)?.getKind()) { + // Treat object accesses as variables to simulate the old behaviour (when variables were created for objects) + ClassKind.OBJECT, ClassKind.ENUM_ENTRY -> getVariableUsageType() + else -> getClassUsageType() + } + is PackageViewDescriptor -> { + if (refExpr.getReference()?.resolve() is PsiPackage) getPackageUsageType() else getClassUsageType() + } + is VariableDescriptor -> getVariableUsageType() + is FunctionDescriptor -> getFunctionUsageType(descriptor) + else -> null + } + } +} + +enum class UsageTypeEnum { + TYPE_CONSTRAINT + VALUE_PARAMETER_TYPE + NON_LOCAL_PROPERTY_TYPE + FUNCTION_RETURN_TYPE + SUPER_TYPE + TYPE_DEFINITION + IS + CLASS_OBJECT_ACCESS + EXTENSION_RECEIVER_TYPE + SUPER_TYPE_QUALIFIER + + FUNCTION_CALL + IMPLICIT_GET + IMPLICIT_SET + IMPLICIT_INVOKE + IMPLICIT_ITERATION + + RECEIVER + DELEGATE + + PACKAGE_DIRECTIVE + PACKAGE_MEMBER_ACCESS + + CALLABLE_REFERENCE + + READ + WRITE + CLASS_IMPORT + CLASS_LOCAL_VAR_DECLARATION + TYPE_PARAMETER + CLASS_CAST_TO + ANNOTATION + CLASS_NEW_OPERATOR +} \ No newline at end of file diff --git a/idea/idea-analysis/src/org/jetbrains/jet/plugin/quickfix/ImportInsertHelper.java b/idea/idea-analysis/src/org/jetbrains/jet/plugin/quickfix/ImportInsertHelper.java new file mode 100644 index 00000000000..eaf6859ecf2 --- /dev/null +++ b/idea/idea-analysis/src/org/jetbrains/jet/plugin/quickfix/ImportInsertHelper.java @@ -0,0 +1,44 @@ +/* + * Copyright 2010-2014 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.plugin.quickfix; + +import com.intellij.openapi.components.ServiceManager; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.psi.JetFile; +import org.jetbrains.jet.lang.psi.JetImportDirective; +import org.jetbrains.jet.lang.resolve.ImportPath; +import org.jetbrains.jet.lang.resolve.name.FqName; + +import java.util.List; + +public abstract class ImportInsertHelper { + public static ImportInsertHelper getInstance() { + return ServiceManager.getService(ImportInsertHelper.class); + } + + public abstract void addImportDirectiveIfNeeded(@NotNull FqName importFqn, @NotNull JetFile file); + + public abstract boolean isImportedWithDefault(@NotNull ImportPath importPath, @NotNull JetFile contextFile); + + public abstract boolean needImport(@NotNull FqName fqName, @NotNull JetFile file); + + public abstract boolean needImport(@NotNull ImportPath importPath, @NotNull JetFile file); + + public abstract boolean needImport(@NotNull ImportPath importPath, @NotNull JetFile file, List importDirectives); + public abstract void optimizeImportsOnTheFly(JetFile file); + public abstract void writeImportToFile(@NotNull ImportPath importPath, @NotNull JetFile file); +} diff --git a/idea/idea-analysis/src/org/jetbrains/jet/plugin/refactoring/fqName/fqNameUtil.kt b/idea/idea-analysis/src/org/jetbrains/jet/plugin/refactoring/fqName/fqNameUtil.kt new file mode 100644 index 00000000000..363e6dff70d --- /dev/null +++ b/idea/idea-analysis/src/org/jetbrains/jet/plugin/refactoring/fqName/fqNameUtil.kt @@ -0,0 +1,76 @@ +/* + * Copyright 2010-2014 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.plugin.refactoring.fqName + +import org.jetbrains.jet.asJava.namedUnwrappedElement +import com.intellij.psi.PsiElement +import org.jetbrains.jet.lang.resolve.name.FqName +import com.intellij.psi.PsiPackage +import com.intellij.psi.PsiClass +import com.intellij.psi.PsiMember +import org.jetbrains.jet.lang.psi.JetNamedDeclaration +import org.jetbrains.jet.lang.resolve.name.isOneSegmentFQN +import org.jetbrains.jet.lang.psi.psiUtil.getQualifiedElement +import org.jetbrains.jet.lang.psi.JetSimpleNameExpression +import org.jetbrains.jet.lang.psi.JetElement +import org.jetbrains.jet.lang.psi.JetCallExpression +import org.jetbrains.jet.lang.psi.JetUserType +import org.jetbrains.jet.lang.psi + +/** + * Returns FqName for given declaration (either Java or Kotlin) + */ +public fun PsiElement.getKotlinFqName(): FqName? { + val element = namedUnwrappedElement + return when (element) { + is PsiPackage -> FqName(element.getQualifiedName()) + is PsiClass -> element.getQualifiedName()?.let { FqName(it) } + is PsiMember -> (element : PsiMember).getName()?.let { name -> + val prefix = element.getContainingClass()?.getQualifiedName() + FqName(if (prefix != null) "$prefix.$name" else name) + } + is JetNamedDeclaration -> element.getFqName() + else -> null + } +} + +/** + * Replace [[JetSimpleNameExpression]] (and its enclosing qualifier) with qualified element given by FqName + * Result is either the same as original element, or [[JetQualifiedExpression]], or [[JetUserType]] + * Note that FqName may not be empty + */ +fun JetSimpleNameExpression.changeQualifiedName(fqName: FqName): JetElement { + assert (!fqName.isRoot(), "Can't set empty FqName for element $this") + + val shortName = fqName.shortName().asString() + val psiFactory = psi.JetPsiFactory(this) + val fqNameBase = (getParent() as? JetCallExpression)?.let { parent -> + val callCopy = parent.copy() as JetCallExpression + callCopy.getCalleeExpression()!!.replace(psiFactory.createSimpleName(shortName)).getParent()!!.getText() + } ?: shortName + + val text = if (!fqName.isOneSegmentFQN()) "${fqName.parent().asString()}.$fqNameBase" else fqNameBase + + val elementToReplace = getQualifiedElement() + return when (elementToReplace) { + is JetUserType -> { + val typeText = "$text${elementToReplace.getTypeArgumentList()?.getText() ?: ""}" + elementToReplace.replace(psiFactory.createType(typeText).getTypeElement()!!) + } + else -> elementToReplace.replace(psiFactory.createExpression(text)) + } as JetElement +} \ No newline at end of file diff --git a/idea/src/org/jetbrains/jet/plugin/references/JetArrayAccessReference.java b/idea/idea-analysis/src/org/jetbrains/jet/plugin/references/JetArrayAccessReference.java similarity index 100% rename from idea/src/org/jetbrains/jet/plugin/references/JetArrayAccessReference.java rename to idea/idea-analysis/src/org/jetbrains/jet/plugin/references/JetArrayAccessReference.java diff --git a/idea/src/org/jetbrains/jet/plugin/references/JetForLoopInReference.kt b/idea/idea-analysis/src/org/jetbrains/jet/plugin/references/JetForLoopInReference.kt similarity index 100% rename from idea/src/org/jetbrains/jet/plugin/references/JetForLoopInReference.kt rename to idea/idea-analysis/src/org/jetbrains/jet/plugin/references/JetForLoopInReference.kt diff --git a/idea/src/org/jetbrains/jet/plugin/references/JetInvokeFunctionReference.java b/idea/idea-analysis/src/org/jetbrains/jet/plugin/references/JetInvokeFunctionReference.java similarity index 100% rename from idea/src/org/jetbrains/jet/plugin/references/JetInvokeFunctionReference.java rename to idea/idea-analysis/src/org/jetbrains/jet/plugin/references/JetInvokeFunctionReference.java diff --git a/idea/src/org/jetbrains/jet/plugin/references/JetMultiDeclarationReference.kt b/idea/idea-analysis/src/org/jetbrains/jet/plugin/references/JetMultiDeclarationReference.kt similarity index 100% rename from idea/src/org/jetbrains/jet/plugin/references/JetMultiDeclarationReference.kt rename to idea/idea-analysis/src/org/jetbrains/jet/plugin/references/JetMultiDeclarationReference.kt diff --git a/idea/src/org/jetbrains/jet/plugin/references/JetPropertyDelegationMethodsReference.kt b/idea/idea-analysis/src/org/jetbrains/jet/plugin/references/JetPropertyDelegationMethodsReference.kt similarity index 100% rename from idea/src/org/jetbrains/jet/plugin/references/JetPropertyDelegationMethodsReference.kt rename to idea/idea-analysis/src/org/jetbrains/jet/plugin/references/JetPropertyDelegationMethodsReference.kt diff --git a/idea/src/org/jetbrains/jet/plugin/references/JetReferenceContributor.kt b/idea/idea-analysis/src/org/jetbrains/jet/plugin/references/JetReferenceContributor.kt similarity index 99% rename from idea/src/org/jetbrains/jet/plugin/references/JetReferenceContributor.kt rename to idea/idea-analysis/src/org/jetbrains/jet/plugin/references/JetReferenceContributor.kt index bb8adaacc66..faaa702b0d1 100644 --- a/idea/src/org/jetbrains/jet/plugin/references/JetReferenceContributor.kt +++ b/idea/idea-analysis/src/org/jetbrains/jet/plugin/references/JetReferenceContributor.kt @@ -59,4 +59,4 @@ public class JetReferenceContributor() : PsiReferenceContributor() { } }) } -} +} \ No newline at end of file diff --git a/idea/src/org/jetbrains/jet/plugin/references/JetSimpleNameReference.kt b/idea/idea-analysis/src/org/jetbrains/jet/plugin/references/JetSimpleNameReference.kt similarity index 96% rename from idea/src/org/jetbrains/jet/plugin/references/JetSimpleNameReference.kt rename to idea/idea-analysis/src/org/jetbrains/jet/plugin/references/JetSimpleNameReference.kt index 2745dac6e53..261d918239a 100644 --- a/idea/src/org/jetbrains/jet/plugin/references/JetSimpleNameReference.kt +++ b/idea/idea-analysis/src/org/jetbrains/jet/plugin/references/JetSimpleNameReference.kt @@ -23,11 +23,11 @@ import org.jetbrains.jet.lang.psi.* import org.jetbrains.jet.lang.resolve.name.FqName import org.jetbrains.jet.lexer.JetTokens import org.jetbrains.jet.plugin.codeInsight.ShortenReferences -import org.jetbrains.jet.plugin.refactoring.changeQualifiedName +import org.jetbrains.jet.plugin.refactoring.fqName.changeQualifiedName import org.jetbrains.jet.lang.psi.psiUtil.getQualifiedElementSelector import org.jetbrains.jet.lang.psi.psiUtil.getOutermostNonInterleavingQualifiedElement -import org.jetbrains.jet.plugin.codeInsight.addToShorteningWaitSet -import org.jetbrains.jet.plugin.refactoring.getKotlinFqName +import org.jetbrains.jet.plugin.codeInsight.shorten.addToShorteningWaitSet +import org.jetbrains.jet.plugin.refactoring.fqName.getKotlinFqName import org.jetbrains.jet.lang.types.expressions.OperatorConventions import org.jetbrains.jet.lexer.JetToken import org.jetbrains.jet.plugin.intentions.OperatorToFunctionIntention diff --git a/idea/src/org/jetbrains/jet/plugin/references/JetThisReference.java b/idea/idea-analysis/src/org/jetbrains/jet/plugin/references/JetThisReference.java similarity index 100% rename from idea/src/org/jetbrains/jet/plugin/references/JetThisReference.java rename to idea/idea-analysis/src/org/jetbrains/jet/plugin/references/JetThisReference.java diff --git a/idea/src/org/jetbrains/jet/plugin/search/ideaExtensions/KotlinReferencesSearcher.java b/idea/idea-analysis/src/org/jetbrains/jet/plugin/search/ideaExtensions/KotlinReferencesSearcher.java similarity index 100% rename from idea/src/org/jetbrains/jet/plugin/search/ideaExtensions/KotlinReferencesSearcher.java rename to idea/idea-analysis/src/org/jetbrains/jet/plugin/search/ideaExtensions/KotlinReferencesSearcher.java diff --git a/idea/src/org/jetbrains/jet/plugin/search/usagesSearch/commonFilters.kt b/idea/idea-analysis/src/org/jetbrains/jet/plugin/search/usagesSearch/commonFilters.kt similarity index 98% rename from idea/src/org/jetbrains/jet/plugin/search/usagesSearch/commonFilters.kt rename to idea/idea-analysis/src/org/jetbrains/jet/plugin/search/usagesSearch/commonFilters.kt index a830a893a8c..ea6b0f29f85 100644 --- a/idea/src/org/jetbrains/jet/plugin/search/usagesSearch/commonFilters.kt +++ b/idea/idea-analysis/src/org/jetbrains/jet/plugin/search/usagesSearch/commonFilters.kt @@ -1,5 +1,5 @@ /* - * Copyright 2010-2013 JetBrains s.r.o. + * Copyright 2010-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/idea/src/org/jetbrains/jet/plugin/search/usagesSearch/conventions.kt b/idea/idea-analysis/src/org/jetbrains/jet/plugin/search/usagesSearch/conventions.kt similarity index 100% rename from idea/src/org/jetbrains/jet/plugin/search/usagesSearch/conventions.kt rename to idea/idea-analysis/src/org/jetbrains/jet/plugin/search/usagesSearch/conventions.kt diff --git a/idea/src/org/jetbrains/jet/plugin/search/usagesSearch/searchHelpers.kt b/idea/idea-analysis/src/org/jetbrains/jet/plugin/search/usagesSearch/searchHelpers.kt similarity index 100% rename from idea/src/org/jetbrains/jet/plugin/search/usagesSearch/searchHelpers.kt rename to idea/idea-analysis/src/org/jetbrains/jet/plugin/search/usagesSearch/searchHelpers.kt diff --git a/idea/src/org/jetbrains/jet/plugin/search/usagesSearch/usagesSearch.kt b/idea/idea-analysis/src/org/jetbrains/jet/plugin/search/usagesSearch/usagesSearch.kt similarity index 98% rename from idea/src/org/jetbrains/jet/plugin/search/usagesSearch/usagesSearch.kt rename to idea/idea-analysis/src/org/jetbrains/jet/plugin/search/usagesSearch/usagesSearch.kt index 76d25cf64f8..a7b6abcb1bc 100644 --- a/idea/src/org/jetbrains/jet/plugin/search/usagesSearch/usagesSearch.kt +++ b/idea/idea-analysis/src/org/jetbrains/jet/plugin/search/usagesSearch/usagesSearch.kt @@ -30,7 +30,6 @@ import com.intellij.psi.search.searches.ReferenceDescriptor import com.intellij.util.containers.ContainerUtil import com.intellij.psi.search.UsageSearchContext import com.intellij.psi.PsiElement -import com.intellij.psi.search.RequestResultProcessor import com.intellij.util.Processor import com.intellij.openapi.application.QueryExecutorBase import com.intellij.psi.PsiReferenceService @@ -49,7 +48,6 @@ import com.intellij.util.indexing.FileBasedIndex import com.intellij.psi.impl.cache.impl.id.IdIndex import org.jetbrains.jet.plugin.util.application.runReadAction import com.intellij.psi.search.TextOccurenceProcessor -import org.jetbrains.jet.plugin.references.JetMultiDeclarationReference import com.intellij.psi.PsiManager import com.intellij.psi.impl.PsiManagerEx diff --git a/idea/src/org/jetbrains/jet/plugin/search/usagesSearch/utils.kt b/idea/idea-analysis/src/org/jetbrains/jet/plugin/search/usagesSearch/utils.kt similarity index 92% rename from idea/src/org/jetbrains/jet/plugin/search/usagesSearch/utils.kt rename to idea/idea-analysis/src/org/jetbrains/jet/plugin/search/usagesSearch/utils.kt index 4e2fb69df50..431b2e3537c 100644 --- a/idea/src/org/jetbrains/jet/plugin/search/usagesSearch/utils.kt +++ b/idea/idea-analysis/src/org/jetbrains/jet/plugin/search/usagesSearch/utils.kt @@ -1,5 +1,5 @@ /* - * Copyright 2010-2013 JetBrains s.r.o. + * Copyright 2010-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -24,13 +24,13 @@ import org.jetbrains.jet.lang.resolve.BindingContext import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache import com.intellij.psi.PsiReference import org.jetbrains.jet.lang.resolve.DescriptorUtils -import org.jetbrains.jet.plugin.findUsages.JetUsageTypeProvider -import com.intellij.usages.impl.rules.UsageType import org.jetbrains.jet.codegen.PropertyCodegen import org.jetbrains.jet.asJava.KotlinLightMethod import org.jetbrains.jet.lang.resolve.OverrideResolver import org.jetbrains.jet.lang.resolve.DescriptorToSourceUtils import org.jetbrains.jet.plugin.references.* +import org.jetbrains.jet.plugin.findUsages.UsageTypeUtils +import org.jetbrains.jet.plugin.findUsages.UsageTypeEnum val JetDeclaration.descriptor: DeclarationDescriptor? get() = AnalyzerFacadeWithCache.getContextForElement(this).get(BindingContext.DECLARATION_TO_DESCRIPTOR, this) @@ -106,7 +106,7 @@ fun PsiReference.isExtensionOfDeclarationClassUsage(declaration: JetNamedDeclara val containingDescriptor = targetDescriptor.getContainingDeclaration() containingDescriptor == receiverDescriptor - || (containingDescriptor is ClassDescriptor + || (containingDescriptor is ClassDescriptor && receiverDescriptor is ClassDescriptor && DescriptorUtils.isSubclass(containingDescriptor, receiverDescriptor)) } @@ -118,7 +118,7 @@ fun PsiReference.isExtensionOfDeclarationClassUsage(declaration: JetNamedDeclara fun PsiReference.isUsageInContainingDeclaration(declaration: JetNamedDeclaration): Boolean = checkUsageVsOriginalDescriptor(declaration) { (usageDescriptor, targetDescriptor) -> usageDescriptor != targetDescriptor - && usageDescriptor.getContainingDeclaration() == targetDescriptor.getContainingDeclaration() + && usageDescriptor.getContainingDeclaration() == targetDescriptor.getContainingDeclaration() } fun PsiReference.isCallableOverrideUsage(declaration: JetNamedDeclaration): Boolean { @@ -128,7 +128,7 @@ fun PsiReference.isCallableOverrideUsage(declaration: JetNamedDeclaration): Bool return checkUsageVsOriginalDescriptor(declaration, decl2Desc) { (usageDescriptor, targetDescriptor) -> usageDescriptor is CallableDescriptor && targetDescriptor is CallableDescriptor - && OverrideResolver.overrides(usageDescriptor, targetDescriptor) + && OverrideResolver.overrides(usageDescriptor, targetDescriptor) } } @@ -136,7 +136,7 @@ fun PsiReference.isCallableOverrideUsage(declaration: JetNamedDeclaration): Bool // Check if reference resolves to property getter // Works for JetProperty and JetParameter fun PsiReference.isPropertyReadOnlyUsage(): Boolean { - if (JetUsageTypeProvider.getUsageType(getElement()) == UsageType.READ) return true + if (UsageTypeUtils.getUsageType(getElement()) == UsageTypeEnum.READ) return true val refTarget = resolve() if (refTarget is KotlinLightMethod) { diff --git a/idea/src/org/jetbrains/jet/plugin/util/IdeDescriptorRenderers.java b/idea/idea-analysis/src/org/jetbrains/jet/plugin/util/IdeDescriptorRenderers.java similarity index 100% rename from idea/src/org/jetbrains/jet/plugin/util/IdeDescriptorRenderers.java rename to idea/idea-analysis/src/org/jetbrains/jet/plugin/util/IdeDescriptorRenderers.java diff --git a/idea/src/org/jetbrains/jet/plugin/util/stringUtil.kt b/idea/idea-analysis/src/org/jetbrains/jet/plugin/util/stringUtil.kt similarity index 100% rename from idea/src/org/jetbrains/jet/plugin/util/stringUtil.kt rename to idea/idea-analysis/src/org/jetbrains/jet/plugin/util/stringUtil.kt diff --git a/idea/src/META-INF/plugin.xml b/idea/src/META-INF/plugin.xml index 3e65e1e37e3..8bfd971c513 100644 --- a/idea/src/META-INF/plugin.xml +++ b/idea/src/META-INF/plugin.xml @@ -131,6 +131,8 @@ + diff --git a/idea/src/org/jetbrains/jet/plugin/actions/JetAddImportAction.java b/idea/src/org/jetbrains/jet/plugin/actions/JetAddImportAction.java index 9b852cbde6b..8c99657b069 100644 --- a/idea/src/org/jetbrains/jet/plugin/actions/JetAddImportAction.java +++ b/idea/src/org/jetbrains/jet/plugin/actions/JetAddImportAction.java @@ -157,7 +157,7 @@ public class JetAddImportAction implements QuestionAction { public void run() { PsiFile file = element.getContainingFile(); if (!(file instanceof JetFile)) return; - ImportInsertHelper.addImportDirectiveIfNeeded(selectedImport, (JetFile) file); + ImportInsertHelper.getInstance().addImportDirectiveIfNeeded(selectedImport, (JetFile) file); } }); } diff --git a/idea/src/org/jetbrains/jet/plugin/codeInsight/KotlinCopyPasteReferenceProcessor.kt b/idea/src/org/jetbrains/jet/plugin/codeInsight/KotlinCopyPasteReferenceProcessor.kt index 59633a62d2c..0387c7853df 100644 --- a/idea/src/org/jetbrains/jet/plugin/codeInsight/KotlinCopyPasteReferenceProcessor.kt +++ b/idea/src/org/jetbrains/jet/plugin/codeInsight/KotlinCopyPasteReferenceProcessor.kt @@ -223,7 +223,7 @@ public class KotlinCopyPasteReferenceProcessor() : CopyPastePostProcessor, file: JetFile) { for ((referenceExpression, fqName, shouldLengthen) in referencesToRestore) { if (!shouldLengthen) { - ImportInsertHelper.addImportDirectiveIfNeeded(fqName, file) + ImportInsertHelper.getInstance().addImportDirectiveIfNeeded(fqName, file) } else { //TODO: try to shorten reference after (sometimes is possible), need shorten reference to support all relevant cases diff --git a/idea/src/org/jetbrains/jet/plugin/codeInsight/KotlinShortenReferencesRefactoringHelper.kt b/idea/src/org/jetbrains/jet/plugin/codeInsight/KotlinShortenReferencesRefactoringHelper.kt index 0714a5cbf1c..8caac5e20f3 100644 --- a/idea/src/org/jetbrains/jet/plugin/codeInsight/KotlinShortenReferencesRefactoringHelper.kt +++ b/idea/src/org/jetbrains/jet/plugin/codeInsight/KotlinShortenReferencesRefactoringHelper.kt @@ -19,67 +19,24 @@ package org.jetbrains.jet.plugin.codeInsight import com.intellij.refactoring.RefactoringHelper import com.intellij.usageView.UsageInfo import com.intellij.openapi.project.Project -import java.util.HashSet -import com.intellij.openapi.util.Key import com.intellij.openapi.application.ApplicationManager -import com.intellij.psi.SmartPsiElementPointer -import org.jetbrains.jet.lang.psi.JetSimpleNameExpression -import com.intellij.openapi.diagnostic.Logger -import com.intellij.psi.SmartPointerManager -import org.jetbrains.jet.lang.psi.JetElement -import org.jetbrains.jet.lang.psi.JetQualifiedExpression -import org.jetbrains.jet.lang.psi.JetUserType -import org.jetbrains.jet.lang.psi.JetFile -import org.jetbrains.jet.lang.psi.UserDataProperty -import org.jetbrains.jet.lang.psi.NotNullableUserDataProperty +import org.jetbrains.jet.plugin.codeInsight.shorten.prepareElementsToShorten +import org.jetbrains.jet.plugin.codeInsight.shorten.withElementsToShorten public class KotlinShortenReferencesRefactoringHelper: RefactoringHelper { - private val LOG = Logger.getInstance(javaClass().getCanonicalName()) - override fun prepareOperation(usages: Array?): Any? { if (usages != null && usages.isNotEmpty()) { val project = usages[0].getProject() - val elementsToShorten = project.elementsToShorten - if (project.ensureElementsToShortenIsEmptyBeforeRefactoring && elementsToShorten != null && !elementsToShorten.isEmpty()) { - LOG.warn("Waiting set for reference shortening is not empty") - project.elementsToShorten = null - } + prepareElementsToShorten(project) } return null } override fun performOperation(project: Project, operationData: Any?) { ApplicationManager.getApplication()!!.runWriteAction { - project.elementsToShorten?.let { bindRequests -> - project.elementsToShorten = null + withElementsToShorten(project) { bindRequests -> ShortenReferences.process(bindRequests.map() { it.getElement() }.filterNotNull()) } } } } - -private var Project.elementsToShorten: MutableSet>? - by UserDataProperty(Key.create("ELEMENTS_TO_SHORTEN_KEY")) - -/* - * When one refactoring invokes another this value must be set to false so that shortening wait-set is not cleared - * and previously collected references are processed correctly. Afterwards it must be reset to original value - */ -public var Project.ensureElementsToShortenIsEmptyBeforeRefactoring: Boolean - by NotNullableUserDataProperty(Key.create("ENSURE_ELEMENTS_TO_SHORTEN_IS_EMPTY"), true) - -private fun Project.getOrCreateElementsToShorten(): MutableSet> { - var elements = elementsToShorten - if (elements == null) { - elements = HashSet() - elementsToShorten = elements - } - - return elements!! - } - -public fun JetElement.addToShorteningWaitSet() { - assert (ApplicationManager.getApplication()!!.isWriteAccessAllowed(), "Write access needed") - val project = getProject() - project.getOrCreateElementsToShorten().add(SmartPointerManager.getInstance(project).createSmartPsiElementPointer(this)) -} diff --git a/idea/src/org/jetbrains/jet/plugin/completion/CompletionSorting.kt b/idea/src/org/jetbrains/jet/plugin/completion/CompletionSorting.kt index de991ea204e..7fa9db5d7b3 100644 --- a/idea/src/org/jetbrains/jet/plugin/completion/CompletionSorting.kt +++ b/idea/src/org/jetbrains/jet/plugin/completion/CompletionSorting.kt @@ -126,8 +126,8 @@ private class JetDeclarationRemotenessWeigher(private val file: JetFile) : Looku if (isValidJavaFqName(fqName)) { val importPath = ImportPath(fqName) return when { - ImportInsertHelper.needImport(importPath, file) -> Weight.notImported - ImportInsertHelper.isImportedWithDefault(importPath, file) -> Weight.kotlinDefaultImport + ImportInsertHelper.getInstance().needImport(importPath, file) -> Weight.notImported + ImportInsertHelper.getInstance().isImportedWithDefault(importPath, file) -> Weight.kotlinDefaultImport else -> Weight.imported } } diff --git a/idea/src/org/jetbrains/jet/plugin/completion/handlers/KotlinCallableInsertHandler.kt b/idea/src/org/jetbrains/jet/plugin/completion/handlers/KotlinCallableInsertHandler.kt index 3c2bb6e7455..c38552752cb 100644 --- a/idea/src/org/jetbrains/jet/plugin/completion/handlers/KotlinCallableInsertHandler.kt +++ b/idea/src/org/jetbrains/jet/plugin/completion/handlers/KotlinCallableInsertHandler.kt @@ -67,7 +67,7 @@ public abstract class JetCallableInsertHandler : BaseDeclarationInsertHandler() if (DescriptorUtils.isTopLevelDeclaration(descriptor)) { ApplicationManager.getApplication()?.runWriteAction { - ImportInsertHelper.addImportDirectiveIfNeeded(DescriptorUtils.getFqNameSafe(descriptor), file) + ImportInsertHelper.getInstance().addImportDirectiveIfNeeded(DescriptorUtils.getFqNameSafe(descriptor), file) } } } diff --git a/idea/src/org/jetbrains/jet/plugin/findUsages/JetUsageTypeProvider.kt b/idea/src/org/jetbrains/jet/plugin/findUsages/JetUsageTypeProvider.kt index aaa7e0e0f2b..d139f333416 100644 --- a/idea/src/org/jetbrains/jet/plugin/findUsages/JetUsageTypeProvider.kt +++ b/idea/src/org/jetbrains/jet/plugin/findUsages/JetUsageTypeProvider.kt @@ -20,16 +20,8 @@ import com.intellij.psi.PsiElement import com.intellij.usages.UsageTarget import com.intellij.usages.impl.rules.UsageType import com.intellij.usages.impl.rules.UsageTypeProviderEx -import org.jetbrains.jet.lang.descriptors.* -import org.jetbrains.jet.lang.psi.* -import org.jetbrains.jet.lang.psi.psiUtil.* -import org.jetbrains.jet.lang.resolve.BindingContext -import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache import org.jetbrains.jet.plugin.JetBundle -import com.intellij.psi.PsiPackage -import org.jetbrains.jet.lexer.JetTokens -import org.jetbrains.jet.plugin.references.JetArrayAccessReference -import org.jetbrains.jet.plugin.references.JetInvokeFunctionReference +import org.jetbrains.jet.plugin.findUsages.UsageTypeEnum.* public object JetUsageTypeProvider : UsageTypeProviderEx { public override fun getUsageType(element: PsiElement?): UsageType? { @@ -37,181 +29,46 @@ public object JetUsageTypeProvider : UsageTypeProviderEx { } public override fun getUsageType(element: PsiElement?, targets: Array): UsageType? { - when (element) { - is JetForExpression -> return JetUsageTypes.IMPLICIT_ITERATION - is JetMultiDeclaration -> return UsageType.READ - } + val usageType = UsageTypeUtils.getUsageType(element) + if (usageType == null) return null + return convertEnumToUsageType(usageType) + } - val refExpr = element?.getParentByType(javaClass()) - if (refExpr == null) return null + fun convertEnumToUsageType(usageType: UsageTypeEnum): UsageType { + return when (usageType) { + TYPE_CONSTRAINT -> JetUsageTypes.TYPE_CONSTRAINT + VALUE_PARAMETER_TYPE -> JetUsageTypes.VALUE_PARAMETER_TYPE + NON_LOCAL_PROPERTY_TYPE -> JetUsageTypes.NON_LOCAL_PROPERTY_TYPE + FUNCTION_RETURN_TYPE -> JetUsageTypes.FUNCTION_RETURN_TYPE + SUPER_TYPE -> JetUsageTypes.SUPER_TYPE + TYPE_DEFINITION -> JetUsageTypes.TYPE_DEFINITION + IS -> JetUsageTypes.IS + CLASS_OBJECT_ACCESS -> JetUsageTypes.CLASS_OBJECT_ACCESS + EXTENSION_RECEIVER_TYPE -> JetUsageTypes.EXTENSION_RECEIVER_TYPE + SUPER_TYPE_QUALIFIER -> JetUsageTypes.SUPER_TYPE_QUALIFIER - val context = AnalyzerFacadeWithCache.getContextForElement(refExpr) + FUNCTION_CALL -> JetUsageTypes.FUNCTION_CALL + IMPLICIT_GET -> JetUsageTypes.IMPLICIT_GET + IMPLICIT_SET -> JetUsageTypes.IMPLICIT_SET + IMPLICIT_INVOKE -> JetUsageTypes.IMPLICIT_INVOKE + IMPLICIT_ITERATION -> JetUsageTypes.IMPLICIT_ITERATION - fun getCommonUsageType(): UsageType? { - return when { - refExpr.getParentByType(javaClass()) != null -> - UsageType.CLASS_IMPORT - refExpr.getParentByTypeAndBranch(javaClass()) { getCallableReference() } != null -> - JetUsageTypes.CALLABLE_REFERENCE - else -> null - } - } + RECEIVER -> JetUsageTypes.RECEIVER + DELEGATE -> JetUsageTypes.DELEGATE - fun getClassUsageType(): UsageType? { - val property = refExpr.getParentByType(javaClass()) - if (property != null) { - when { - property.getTypeReference().isAncestor(refExpr) -> - return if (property.isLocal()) UsageType.CLASS_LOCAL_VAR_DECLARATION else JetUsageTypes.NON_LOCAL_PROPERTY_TYPE + PACKAGE_DIRECTIVE -> JetUsageTypes.PACKAGE_DIRECTIVE + PACKAGE_MEMBER_ACCESS -> JetUsageTypes.PACKAGE_MEMBER_ACCESS - property.getReceiverTypeReference().isAncestor(refExpr) -> - return JetUsageTypes.EXTENSION_RECEIVER_TYPE - } - } + CALLABLE_REFERENCE -> JetUsageTypes.CALLABLE_REFERENCE - val function = refExpr.getParentByType(javaClass()) - if (function != null) { - when { - function.getTypeReference().isAncestor(refExpr) -> - return JetUsageTypes.FUNCTION_RETURN_TYPE - function.getReceiverTypeReference().isAncestor(refExpr) -> - return JetUsageTypes.EXTENSION_RECEIVER_TYPE - } - } - - return when { - refExpr.getParentByTypeAndBranch(javaClass()) { getExtendsBound() } != null - || refExpr.getParentByTypeAndBranch(javaClass()) { getBoundTypeReference() } != null -> - JetUsageTypes.TYPE_CONSTRAINT - - refExpr is JetDelegationSpecifier - || refExpr.getParentByTypeAndBranch(javaClass()) { getTypeReference() } != null -> - JetUsageTypes.SUPER_TYPE - - refExpr.getParentByTypeAndBranch(javaClass()) { getTypeReference() } != null -> - JetUsageTypes.TYPE_DEFINITION - - refExpr.getParentByType(javaClass()) != null -> - UsageType.TYPE_PARAMETER - - refExpr.getParentByTypeAndBranch(javaClass()) { getTypeReference() } != null -> - JetUsageTypes.VALUE_PARAMETER_TYPE - - refExpr.getParentByTypeAndBranch(javaClass()) { getTypeReference() } != null -> - JetUsageTypes.IS - - with(refExpr.getParentByTypeAndBranch(javaClass()) { getRight() }) { - val opType = this?.getOperationReference()?.getReferencedNameElementType() - opType == JetTokens.AS_KEYWORD || opType == JetTokens.AS_SAFE - } -> - UsageType.CLASS_CAST_TO - - with(refExpr.getParentByType(javaClass())) { - if (this == null) false - else if (getReceiverExpression() == refExpr) true - else - getSelectorExpression() == refExpr - && getParentByTypeAndBranch(javaClass(), true) { getReceiverExpression() } != null - } -> - JetUsageTypes.CLASS_OBJECT_ACCESS - - refExpr.getParentByTypeAndBranch(javaClass()) { getSuperTypeQualifier() } != null -> - JetUsageTypes.SUPER_TYPE_QUALIFIER - - else -> null - } - } - - fun getVariableUsageType(): UsageType? { - if (refExpr.getParentByTypeAndBranch(javaClass()) { getDelegateExpression() } != null) { - return JetUsageTypes.DELEGATE - } - - val dotQualifiedExpression = refExpr.getParentByType(javaClass()) - - if (dotQualifiedExpression != null) { - val parent = dotQualifiedExpression.getParent() - when { - dotQualifiedExpression.getReceiverExpression().isAncestor(refExpr) -> - return JetUsageTypes.RECEIVER - - parent is JetDotQualifiedExpression && parent.getReceiverExpression().isAncestor(refExpr) -> - return JetUsageTypes.RECEIVER - } - } - - return when { - (refExpr.getParentByTypesAndPredicate(false, javaClass()) { JetPsiUtil.isAssignment(it) }) - ?.getLeft().isAncestor(refExpr) -> - UsageType.WRITE - - refExpr.getParentByType(javaClass()) != null -> - UsageType.READ - - else -> null - } - } - - fun getFunctionUsageType(descriptor: FunctionDescriptor): UsageType? { - val ref = refExpr.getReference() - when (ref) { - is JetArrayAccessReference -> { - return when { - context[BindingContext.INDEXED_LVALUE_GET, refExpr] != null -> JetUsageTypes.IMPLICIT_GET - context[BindingContext.INDEXED_LVALUE_SET, refExpr] != null -> JetUsageTypes.IMPLICIT_SET - else -> null - } - } - is JetInvokeFunctionReference -> return JetUsageTypes.IMPLICIT_INVOKE - } - - return when { - refExpr.getParentByTypeAndBranch(javaClass()) { getTypeReference() } != null -> - JetUsageTypes.SUPER_TYPE - - descriptor is ConstructorDescriptor - && refExpr.getParentByTypeAndBranch(javaClass()) { getTypeReference() } != null -> - UsageType.ANNOTATION - - with(refExpr.getParentByTypeAndBranch(javaClass()) { getCalleeExpression() }) { - this?.getCalleeExpression() is JetSimpleNameExpression - } -> - if (descriptor is ConstructorDescriptor) UsageType.CLASS_NEW_OPERATOR else JetUsageTypes.FUNCTION_CALL - - refExpr.getParentByTypeAndBranch(javaClass()) { getOperationReference() } != null, - refExpr.getParentByTypeAndBranch(javaClass()) { getOperationReference() } != null, - refExpr.getParentByTypeAndBranch(javaClass()) { getOperationReference() } != null -> - JetUsageTypes.FUNCTION_CALL - - else -> null - } - } - - fun getPackageUsageType(): UsageType? { - return when { - refExpr.getParentByType(javaClass()) != null -> JetUsageTypes.PACKAGE_DIRECTIVE - refExpr.getParentByType(javaClass()) != null -> JetUsageTypes.PACKAGE_MEMBER_ACCESS - else -> getClassUsageType() - } - } - - val usageType = getCommonUsageType() - if (usageType != null) return usageType - - val descriptor = context[BindingContext.REFERENCE_TARGET, refExpr] - - return when (descriptor) { - is ClassifierDescriptor -> when ((descriptor as? ClassDescriptor)?.getKind()) { - // Treat object accesses as variables to simulate the old behaviour (when variables were created for objects) - ClassKind.OBJECT, ClassKind.ENUM_ENTRY -> getVariableUsageType() - else -> getClassUsageType() - } - is PackageViewDescriptor -> { - if (refExpr.getReference()?.resolve() is PsiPackage) getPackageUsageType() else getClassUsageType() - } - is VariableDescriptor -> getVariableUsageType() - is FunctionDescriptor -> getFunctionUsageType(descriptor) - else -> null + READ -> UsageType.READ + WRITE -> UsageType.WRITE + CLASS_IMPORT -> UsageType.CLASS_IMPORT + CLASS_LOCAL_VAR_DECLARATION -> UsageType.CLASS_LOCAL_VAR_DECLARATION + TYPE_PARAMETER -> UsageType.TYPE_PARAMETER + CLASS_CAST_TO -> UsageType.CLASS_CAST_TO + ANNOTATION -> UsageType.ANNOTATION + CLASS_NEW_OPERATOR -> UsageType.CLASS_NEW_OPERATOR } } } diff --git a/idea/src/org/jetbrains/jet/plugin/imports/KotlinImportOptimizer.kt b/idea/src/org/jetbrains/jet/plugin/imports/KotlinImportOptimizer.kt index dcaae99d31c..dee6b296c87 100644 --- a/idea/src/org/jetbrains/jet/plugin/imports/KotlinImportOptimizer.kt +++ b/idea/src/org/jetbrains/jet/plugin/imports/KotlinImportOptimizer.kt @@ -27,8 +27,8 @@ import org.jetbrains.jet.lang.resolve.ImportPath import org.jetbrains.jet.lang.resolve.name.* import org.jetbrains.jet.plugin.references.JetReference import java.util.HashSet -import org.jetbrains.jet.plugin.quickfix.ImportInsertHelper.needImport import java.util.ArrayList +import org.jetbrains.jet.plugin.quickfix.ImportInsertHelper public class KotlinImportOptimizer() : ImportOptimizer { @@ -54,8 +54,8 @@ public class KotlinImportOptimizer() : ImportOptimizer { } if (isUseful(importPath, usedQualifiedNames) - && needImport(importPath, jetFile, directivesBeforeCurrent) - && needImport(importPath, jetFile, directivesAfterCurrent) + && ImportInsertHelper.getInstance().needImport(importPath, jetFile, directivesBeforeCurrent) + && ImportInsertHelper.getInstance().needImport(importPath, jetFile, directivesAfterCurrent) ) { directivesBeforeCurrent.add(anImport) } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/AutoImportFix.kt b/idea/src/org/jetbrains/jet/plugin/quickfix/AutoImportFix.kt index 06b1e4e2a3d..692b404f587 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/AutoImportFix.kt +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/AutoImportFix.kt @@ -122,7 +122,7 @@ public class AutoImportFix(element: JetSimpleNameExpression) : JetHintAction defaultImports = ProjectStructureUtil.isJsKotlinModule(contextFile) ? TopDownAnalyzerFacadeForJS.DEFAULT_IMPORTS : TopDownAnalyzerFacadeForJVM.DEFAULT_IMPORTS; return NamePackage.isImported(importPath, defaultImports); } - public static boolean needImport(@NotNull FqName fqName, @NotNull JetFile file) { + @Override + public boolean needImport(@NotNull FqName fqName, @NotNull JetFile file) { return needImport(new ImportPath(fqName, false), file); } - public static boolean needImport(@NotNull ImportPath importPath, @NotNull JetFile file) { + @Override + public boolean needImport(@NotNull ImportPath importPath, @NotNull JetFile file) { return needImport(importPath, file, file.getImportDirectives()); } - public static boolean needImport(@NotNull ImportPath importPath, @NotNull JetFile file, List importDirectives) { + @Override + public boolean needImport(@NotNull ImportPath importPath, @NotNull JetFile file, List importDirectives) { if (isImportedByDefault(importPath, file)) { return false; } diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/extractFunction/extractorUtil.kt b/idea/src/org/jetbrains/jet/plugin/refactoring/extractFunction/extractorUtil.kt index 825792e927c..ed904792cc9 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/extractFunction/extractorUtil.kt +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/extractFunction/extractorUtil.kt @@ -508,7 +508,7 @@ fun ExtractableCodeDescriptor.generateDeclaration(options: ExtractionGeneratorOp if (options.inTempFile) return ExtractionResult(declaration, Collections.emptyMap(), nameByOffset) makeCall(this, declaration, controlFlow, extractionData.originalRange, parameters.map { it.argumentText }) - ShortenReferences.process(declaration) + ShortenReferences.process(declaration) val duplicateReplacers = duplicates.map { it.range to { makeCall(this, declaration, it.controlFlow, it.range, it.arguments) } }.toMap() return ExtractionResult(declaration, duplicateReplacers, nameByOffset) diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/jetRefactoringUtil.kt b/idea/src/org/jetbrains/jet/plugin/refactoring/jetRefactoringUtil.kt index f70ffa1dd57..2f495ed3518 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/jetRefactoringUtil.kt +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/jetRefactoringUtil.kt @@ -74,33 +74,6 @@ import com.intellij.openapi.util.text.StringUtil import javax.swing.Icon import org.jetbrains.jet.plugin.util.string.collapseSpaces -/** - * Replace [[JetSimpleNameExpression]] (and its enclosing qualifier) with qualified element given by FqName - * Result is either the same as original element, or [[JetQualifiedExpression]], or [[JetUserType]] - * Note that FqName may not be empty - */ -fun JetSimpleNameExpression.changeQualifiedName(fqName: FqName): JetElement { - assert (!fqName.isRoot(), "Can't set empty FqName for element $this") - - val shortName = fqName.shortName().asString() - val psiFactory = JetPsiFactory(this) - val fqNameBase = (getParent() as? JetCallExpression)?.let { parent -> - val callCopy = parent.copy() as JetCallExpression - callCopy.getCalleeExpression()!!.replace(psiFactory.createSimpleName(shortName)).getParent()!!.getText() - } ?: shortName - - val text = if (!fqName.isOneSegmentFQN()) "${fqName.parent().asString()}.$fqNameBase" else fqNameBase - - val elementToReplace = getQualifiedElement() - return when (elementToReplace) { - is JetUserType -> { - val typeText = "$text${elementToReplace.getTypeArgumentList()?.getText() ?: ""}" - elementToReplace.replace(psiFactory.createType(typeText).getTypeElement()!!) - } - else -> elementToReplace.replace(psiFactory.createExpression(text)) - } as JetElement -} - fun PsiElement.getAndRemoveCopyableUserData(key: Key): T? { val data = getCopyableUserData(key) putCopyableUserData(key, null) @@ -124,23 +97,6 @@ public fun File.toPsiFile(project: Project): PsiFile? { return toVirtualFile()?.let { vfile -> PsiManager.getInstance(project).findFile(vfile) } } -/** - * Returns FqName for given declaration (either Java or Kotlin) - */ -public fun PsiElement.getKotlinFqName(): FqName? { - val element = namedUnwrappedElement - return when (element) { - is PsiPackage -> FqName(element.getQualifiedName()) - is PsiClass -> element.getQualifiedName()?.let { FqName(it) } - is PsiMember -> (element : PsiMember).getName()?.let { name -> - val prefix = element.getContainingClass()?.getQualifiedName() - FqName(if (prefix != null) "$prefix.$name" else name) - } - is JetNamedDeclaration -> element.getFqName() - else -> null - } -} - public fun PsiElement.getUsageContext(): PsiElement { return when (this) { is JetElement -> PsiTreeUtil.getParentOfType(this, javaClass(), javaClass())!! diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/move/moveFilesOrDirectories/MoveKotlinFileHandler.kt b/idea/src/org/jetbrains/jet/plugin/refactoring/move/moveFilesOrDirectories/MoveKotlinFileHandler.kt index 3e2e3ddc928..85093e82aab 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/move/moveFilesOrDirectories/MoveKotlinFileHandler.kt +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/move/moveFilesOrDirectories/MoveKotlinFileHandler.kt @@ -36,7 +36,7 @@ import org.jetbrains.jet.plugin.refactoring.move.moveTopLevelDeclarations.MoveKo import com.intellij.refactoring.move.moveFilesOrDirectories.MoveFilesOrDirectoriesUtil import org.jetbrains.jet.plugin.refactoring.move.moveTopLevelDeclarations.DeferredJetFileKotlinMoveTarget import org.jetbrains.jet.plugin.refactoring.move.moveTopLevelDeclarations.Mover -import org.jetbrains.jet.plugin.codeInsight.ensureElementsToShortenIsEmptyBeforeRefactoring +import org.jetbrains.jet.plugin.codeInsight.shorten.ensureElementsToShortenIsEmptyBeforeRefactoring public class MoveKotlinFileHandler : MoveFileHandler() { private var packageNameInfo: PackageNameInfo? = null diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/move/moveTopLevelDeclarations/MoveKotlinTopLevelDeclarationsProcessor.kt b/idea/src/org/jetbrains/jet/plugin/refactoring/move/moveTopLevelDeclarations/MoveKotlinTopLevelDeclarationsProcessor.kt index 67377853bd7..773ff8d12bf 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/move/moveTopLevelDeclarations/MoveKotlinTopLevelDeclarationsProcessor.kt +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/move/moveTopLevelDeclarations/MoveKotlinTopLevelDeclarationsProcessor.kt @@ -38,7 +38,7 @@ import org.jetbrains.jet.lang.psi.psiUtil.getPackage import org.jetbrains.jet.lang.psi.JetFile import org.jetbrains.jet.plugin.refactoring.move.PackageNameInfo import org.jetbrains.jet.plugin.refactoring.createKotlinFile -import org.jetbrains.jet.plugin.codeInsight.addToShorteningWaitSet +import org.jetbrains.jet.plugin.codeInsight.shorten.addToShorteningWaitSet import org.jetbrains.jet.plugin.refactoring.move.getFileNameAfterMove import org.jetbrains.jet.lang.psi.JetNamedDeclaration import org.jetbrains.jet.asJava.toLightElements @@ -64,7 +64,6 @@ import com.intellij.psi.PsiModifierListOwner import com.intellij.psi.PsiModifier import com.intellij.util.VisibilityUtil import com.intellij.openapi.util.Ref -import org.jetbrains.jet.plugin.refactoring.getKotlinFqName import org.jetbrains.jet.plugin.search.projectScope import org.jetbrains.jet.plugin.refactoring.move.getInternalReferencesToUpdateOnPackageNameChange import org.jetbrains.jet.plugin.refactoring.move.createMoveUsageInfo @@ -72,7 +71,7 @@ import org.jetbrains.jet.plugin.refactoring.move.postProcessMoveUsages import org.jetbrains.jet.plugin.references.JetSimpleNameReference.ShorteningMode import org.jetbrains.jet.lang.psi.psiUtil.isAncestor import org.jetbrains.jet.plugin.refactoring.move.MoveRenameUsageInfoForExtension -import org.jetbrains.jet.lang.psi.JetDeclaration +import org.jetbrains.jet.plugin.refactoring.fqName.getKotlinFqName trait Mover: (originalElement: JetNamedDeclaration, targetFile: JetFile) -> JetNamedDeclaration { object Default: Mover { diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/move/moveUtils.kt b/idea/src/org/jetbrains/jet/plugin/refactoring/move/moveUtils.kt index da71ad067b3..c65adb8e0f8 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/move/moveUtils.kt +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/move/moveUtils.kt @@ -48,7 +48,7 @@ import org.jetbrains.jet.lang.psi.JetImportDirective import java.util.ArrayList import com.intellij.refactoring.util.NonCodeUsageInfo import org.jetbrains.jet.plugin.quickfix.ImportInsertHelper -import org.jetbrains.jet.plugin.refactoring.getKotlinFqName +import org.jetbrains.jet.plugin.refactoring.fqName.getKotlinFqName import org.jetbrains.jet.lang.psi.JetThisExpression import org.jetbrains.jet.plugin.references.JetSimpleNameReference.ShorteningMode import com.intellij.openapi.vfs.VirtualFile @@ -186,7 +186,7 @@ fun postProcessMoveUsages(usages: List, is MoveRenameUsageInfoForExtension -> { val element = counterpart(usage.getReferencedElement()!!) val file = with(usage) { if (addImportToOriginalFile) originalFile else counterpart(originalFile) } as JetFile - ImportInsertHelper.addImportDirectiveIfNeeded(element.getKotlinFqName()!!, file) + ImportInsertHelper.getInstance().addImportDirectiveIfNeeded(element.getKotlinFqName()!!, file) } is MoveRenameUsageInfo -> { diff --git a/idea/tests/org/jetbrains/jet/plugin/debugger/evaluate/AbstractEditorForEvaluateExpressionTest.kt b/idea/tests/org/jetbrains/jet/plugin/debugger/evaluate/AbstractEditorForEvaluateExpressionTest.kt index 34e2c6af392..1f763385079 100644 --- a/idea/tests/org/jetbrains/jet/plugin/debugger/evaluate/AbstractEditorForEvaluateExpressionTest.kt +++ b/idea/tests/org/jetbrains/jet/plugin/debugger/evaluate/AbstractEditorForEvaluateExpressionTest.kt @@ -42,7 +42,7 @@ public abstract class AbstractCodeFragmentHighlightingTest : AbstractJetPsiCheck ApplicationManager.getApplication()?.runWriteAction { val fileText = FileUtil.loadFile(File(filePath), true) InTextDirectivesUtils.findListWithPrefixes(fileText, "// IMPORT: ").forEach { - ImportInsertHelper.addImportDirectiveIfNeeded(FqName(it), (myFixture.getFile() as JetFile)) + ImportInsertHelper.getInstance().addImportDirectiveIfNeeded(FqName(it), (myFixture.getFile() as JetFile)) } } diff --git a/idea/tests/org/jetbrains/jet/plugin/imports/OptimizeImportsOnFlyTest.java b/idea/tests/org/jetbrains/jet/plugin/imports/OptimizeImportsOnFlyTest.java index 530289a8b00..bf1ee0294cf 100644 --- a/idea/tests/org/jetbrains/jet/plugin/imports/OptimizeImportsOnFlyTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/imports/OptimizeImportsOnFlyTest.java @@ -33,7 +33,7 @@ public class OptimizeImportsOnFlyTest extends LightDaemonAnalyzerTestCase { ApplicationManager.getApplication().runWriteAction(new Runnable() { @Override public void run() { - ImportInsertHelper.addImportDirectiveIfNeeded(new FqName("java.util.HashSet"), (JetFile) getFile()); + ImportInsertHelper.getInstance().addImportDirectiveIfNeeded(new FqName("java.util.HashSet"), (JetFile) getFile()); } }); } diff --git a/idea/tests/org/jetbrains/jet/plugin/quickfix/ImportClassHelperTest.java b/idea/tests/org/jetbrains/jet/plugin/quickfix/ImportClassHelperTest.java index 171b994c245..8bfc51d9f62 100644 --- a/idea/tests/org/jetbrains/jet/plugin/quickfix/ImportClassHelperTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/quickfix/ImportClassHelperTest.java @@ -46,7 +46,7 @@ public class ImportClassHelperTest extends LightDaemonAnalyzerTestCase { ApplicationManager.getApplication().runWriteAction(new Runnable() { @Override public void run() { - ImportInsertHelper.addImportDirectiveIfNeeded(new FqName("java.util.ArrayList"), (JetFile) getFile()); + ImportInsertHelper.getInstance().addImportDirectiveIfNeeded(new FqName("java.util.ArrayList"), (JetFile) getFile()); } }); @@ -58,7 +58,7 @@ public class ImportClassHelperTest extends LightDaemonAnalyzerTestCase { ApplicationManager.getApplication().runWriteAction(new Runnable() { @Override public void run() { - ImportInsertHelper.addImportDirectiveIfNeeded(new FqName("java.util.ArrayList"), (JetFile) getFile()); + ImportInsertHelper.getInstance().addImportDirectiveIfNeeded(new FqName("java.util.ArrayList"), (JetFile) getFile()); } }); @@ -70,7 +70,7 @@ public class ImportClassHelperTest extends LightDaemonAnalyzerTestCase { ApplicationManager.getApplication().runWriteAction(new Runnable() { @Override public void run() { - ImportInsertHelper.addImportDirectiveIfNeeded(new FqName(importString), (JetFile) getFile()); + ImportInsertHelper.getInstance().addImportDirectiveIfNeeded(new FqName(importString), (JetFile) getFile()); } }); checkResultByFile(getTestName(false) + ".kt.after");