From 0462a3d3b6368a317f606d3c8d9d766a51c6d6af Mon Sep 17 00:00:00 2001 From: Simon Ogorodnik Date: Wed, 26 Oct 2016 21:34:03 +0300 Subject: [PATCH] Workaround KT-14531, Partial fix for KT-13600, KT-11620 J2K: Invalid conversion context on plain text pasting For detailed info see KT-14531 --- .../copy/ConvertJavaCopyPasteProcessor.kt | 21 ++- .../copy/ConvertTextJavaCopyPasteProcessor.kt | 88 +++------ .../idea/conversion/copy/DataForConversion.kt | 18 +- .../conversion/copy/ElementAndTextList.kt | 68 +++++++ .../copy/PlainTextPasteImportResolver.kt | 172 ++++++++++++++++++ .../AsExpression.expected.kt | 4 +- .../AsExpressionBody.expected.kt | 4 +- .../ImportResolve.dependency.java | 34 ++++ .../ImportResolve.dependency.kt | 32 ++++ .../ImportResolve.expected.kt | 31 ++++ .../plainTextConversion/ImportResolve.to.kt | 3 + .../plainTextConversion/ImportResolve.txt | 22 +++ .../plainTextConversion/KT13529_1.expected.kt | 4 +- .../MembersIntoClass.expected.kt | 2 + .../MembersToTopLevel.expected.kt | 3 + .../StatementsIntoFunction.expected.kt | 2 + ...otlinCopyPasteConversionTestGenerated.java | 6 + 17 files changed, 436 insertions(+), 78 deletions(-) create mode 100644 idea/src/org/jetbrains/kotlin/idea/conversion/copy/ElementAndTextList.kt create mode 100644 idea/src/org/jetbrains/kotlin/idea/conversion/copy/PlainTextPasteImportResolver.kt create mode 100644 idea/testData/copyPaste/plainTextConversion/ImportResolve.dependency.java create mode 100644 idea/testData/copyPaste/plainTextConversion/ImportResolve.dependency.kt create mode 100644 idea/testData/copyPaste/plainTextConversion/ImportResolve.expected.kt create mode 100644 idea/testData/copyPaste/plainTextConversion/ImportResolve.to.kt create mode 100644 idea/testData/copyPaste/plainTextConversion/ImportResolve.txt diff --git a/idea/src/org/jetbrains/kotlin/idea/conversion/copy/ConvertJavaCopyPasteProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/conversion/copy/ConvertJavaCopyPasteProcessor.kt index e94d117215c..415969a0be2 100644 --- a/idea/src/org/jetbrains/kotlin/idea/conversion/copy/ConvertJavaCopyPasteProcessor.kt +++ b/idea/src/org/jetbrains/kotlin/idea/conversion/copy/ConvertJavaCopyPasteProcessor.kt @@ -86,7 +86,7 @@ class ConvertJavaCopyPasteProcessor : CopyPastePostProcessor, project: Project): ConversionResult { +internal fun ElementAndTextList.convertCodeToKotlin(project: Project): ConversionResult { val converter = JavaToKotlinConverter( project, ConverterSettings.defaultSettings, IdeaJavaToKotlinServices ) - val inputElements = elementsAndTexts.filterIsInstance() + val inputElements = this.toList().filterIsInstance() val results = converter.elementsToKotlin(inputElements).results val importsToAdd = LinkedHashSet() @@ -213,9 +213,9 @@ internal fun convertCopiedCodeToKotlin(elementsAndTexts: Collection, projec val convertedCodeBuilder = StringBuilder() val originalCodeBuilder = StringBuilder() var parseContext: ParseContext? = null - for (o in elementsAndTexts) { - if (o is PsiElement) { - val originalText = o.text + this.process(object : ElementsAndTextsProcessor { + override fun processElement(element: PsiElement) { + val originalText = element.text originalCodeBuilder.append(originalText) val result = results[resultIndex++] @@ -230,11 +230,12 @@ internal fun convertCopiedCodeToKotlin(elementsAndTexts: Collection, projec convertedCodeBuilder.append(originalText) } } - else { - originalCodeBuilder.append(o) - convertedCodeBuilder.append(o as String) + + override fun processText(string: String) { + originalCodeBuilder.append(string) + convertedCodeBuilder.append(string) } - } + }) val convertedCode = convertedCodeBuilder.toString() val originalCode = originalCodeBuilder.toString() diff --git a/idea/src/org/jetbrains/kotlin/idea/conversion/copy/ConvertTextJavaCopyPasteProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/conversion/copy/ConvertTextJavaCopyPasteProcessor.kt index b1bed56262e..c20a78d4314 100644 --- a/idea/src/org/jetbrains/kotlin/idea/conversion/copy/ConvertTextJavaCopyPasteProcessor.kt +++ b/idea/src/org/jetbrains/kotlin/idea/conversion/copy/ConvertTextJavaCopyPasteProcessor.kt @@ -27,22 +27,23 @@ import com.intellij.openapi.project.DumbService import com.intellij.openapi.project.Project import com.intellij.openapi.util.Ref import com.intellij.openapi.util.TextRange -import com.intellij.psi.* +import com.intellij.psi.PsiDocumentManager +import com.intellij.psi.PsiErrorElement +import com.intellij.psi.PsiFile +import com.intellij.psi.PsiFileFactory import com.intellij.util.LocalTimeCounter import org.jetbrains.annotations.TestOnly import org.jetbrains.kotlin.asJava.toLightClass import org.jetbrains.kotlin.idea.KotlinFileType -import org.jetbrains.kotlin.idea.codeInsight.referenceExpression import org.jetbrains.kotlin.idea.editor.KotlinEditorOptions import org.jetbrains.kotlin.idea.j2k.J2kPostProcessor -import org.jetbrains.kotlin.idea.references.mainReference import org.jetbrains.kotlin.idea.util.application.runWriteAction import org.jetbrains.kotlin.j2k.AfterConversionPass import org.jetbrains.kotlin.lexer.KtTokens import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.psi.psiUtil.anyDescendantOfType +import org.jetbrains.kotlin.psi.psiUtil.endOffset import org.jetbrains.kotlin.psi.psiUtil.getParentOfType -import org.jetbrains.kotlin.resolve.ImportPath import org.jetbrains.kotlin.utils.addToStdlib.check import org.jetbrains.kotlin.utils.addToStdlib.ifNotEmpty import java.awt.datatransfer.DataFlavor @@ -103,10 +104,21 @@ class ConvertTextJavaCopyPasteProcessor : CopyPastePostProcessor 0) + convertedImportsText = "\n" + convertedImportsText + if (convertedImportsText.isNotBlank()) + editor.document.insertString(importsInsertOffset, convertedImportsText) + val startOffset = bounds.startOffset editor.document.replaceString(startOffset, bounds.endOffset, convertedText) @@ -116,16 +128,15 @@ class ConvertTextJavaCopyPasteProcessor : CopyPastePostProcessor createCopiedJavaCode(prefix, "$classDef {\nObject field = $\n}", text) } + return copiedJavaCode } private fun createCopiedJavaCode(prefix: String, templateWithoutPrefix: String, text: String): CopiedJavaCode { - val template = "$prefix\n$templateWithoutPrefix" + val template = "$prefix$templateWithoutPrefix" val index = template.indexOf("$") assert(index >= 0) val fileText = template.substring(0, index) + text + template.substring(index + 1) diff --git a/idea/src/org/jetbrains/kotlin/idea/conversion/copy/DataForConversion.kt b/idea/src/org/jetbrains/kotlin/idea/conversion/copy/DataForConversion.kt index 3868045b5d4..44aa947ac2f 100644 --- a/idea/src/org/jetbrains/kotlin/idea/conversion/copy/DataForConversion.kt +++ b/idea/src/org/jetbrains/kotlin/idea/conversion/copy/DataForConversion.kt @@ -29,8 +29,9 @@ import org.jetbrains.kotlin.psi.psiUtil.siblings import java.util.* data class DataForConversion private constructor( - val elementsAndTexts: Collection /* list consisting of PsiElement's to convert and plain String's */, - val importsAndPackage: String + val elementsAndTexts: ElementAndTextList /* list consisting of PsiElement's to convert and plain String's */, + val importsAndPackage: String, + val file: PsiJavaFile ) { companion object { fun prepare(copiedCode: CopiedJavaCode, project: Project): DataForConversion { @@ -49,12 +50,12 @@ data class DataForConversion private constructor( file = PsiFileFactory.getInstance(project).createFileFromText(JavaLanguage.INSTANCE, newFileText) as PsiJavaFile } - val elementsAndTexts = ArrayList() + val elementsAndTexts = ElementAndTextList() for (i in startOffsets.indices) { elementsAndTexts.collectElementsToConvert(file, fileText, TextRange(startOffsets[i], endOffsets[i])) } - return DataForConversion(elementsAndTexts, importsAndPackage) + return DataForConversion(elementsAndTexts, importsAndPackage, file) } private fun clipTextIfNeeded(file: PsiJavaFile, fileText: String, startOffsets: IntArray, endOffsets: IntArray): String? { @@ -207,7 +208,7 @@ data class DataForConversion private constructor( return clipTo } - private fun MutableList.collectElementsToConvert( + private fun ElementAndTextList.collectElementsToConvert( file: PsiJavaFile, fileText: String, range: TextRange @@ -218,8 +219,11 @@ data class DataForConversion private constructor( } else { add(fileText.substring(range.start, elements.first().range.start)) - elements.flatMapTo(this) { - if (shouldExpandToChildren(it)) it.allChildren.toList() else listOf(it) + elements.forEach { + if (shouldExpandToChildren(it)) + this += it.allChildren.toList() + else + this += it } add(fileText.substring(elements.last().range.end, range.end)) } diff --git a/idea/src/org/jetbrains/kotlin/idea/conversion/copy/ElementAndTextList.kt b/idea/src/org/jetbrains/kotlin/idea/conversion/copy/ElementAndTextList.kt new file mode 100644 index 00000000000..9f3bcfe24db --- /dev/null +++ b/idea/src/org/jetbrains/kotlin/idea/conversion/copy/ElementAndTextList.kt @@ -0,0 +1,68 @@ +/* + * Copyright 2010-2016 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.kotlin.idea.conversion.copy + +import com.intellij.psi.PsiElement +import java.util.* + + +class ElementAndTextList() { + private val elementsAndTexts = ArrayList() + + constructor(elements: List) : this() { + elementsAndTexts.addAll(elements.filter { it is PsiElement || it is String }) + } + + fun add(a: String) = elementsAndTexts.add(a) + + fun add(a: PsiElement) = elementsAndTexts.add(a) + + operator fun plusAssign(other: String) = plusAssign(other as Any) + + operator fun plusAssign(other: PsiElement) = plusAssign(other as Any) + + private fun plusAssign(a: Any) { + elementsAndTexts.add(a) + } + + operator fun plusAssign(other: Collection): Unit { + elementsAndTexts.addAll(other) + } + + operator fun plus(other: ElementAndTextList): ElementAndTextList { + val newList = ElementAndTextList() + newList.elementsAndTexts.addAll(this.elementsAndTexts) + newList.elementsAndTexts.addAll(other.elementsAndTexts) + return newList + } + + fun toList(): List = elementsAndTexts.toList() + + fun process(processor: ElementsAndTextsProcessor) { + elementsAndTexts.forEach { + when (it) { + is PsiElement -> processor.processElement(it) + is String -> processor.processText(it) + } + } + } +} + +interface ElementsAndTextsProcessor { + fun processElement(element: PsiElement) + fun processText(string: String) +} \ No newline at end of file diff --git a/idea/src/org/jetbrains/kotlin/idea/conversion/copy/PlainTextPasteImportResolver.kt b/idea/src/org/jetbrains/kotlin/idea/conversion/copy/PlainTextPasteImportResolver.kt new file mode 100644 index 00000000000..5b244c6d08b --- /dev/null +++ b/idea/src/org/jetbrains/kotlin/idea/conversion/copy/PlainTextPasteImportResolver.kt @@ -0,0 +1,172 @@ +/* + * Copyright 2010-2016 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.kotlin.idea.conversion.copy + +import com.intellij.psi.* +import com.intellij.psi.search.PsiShortNamesCache +import com.intellij.psi.util.PsiTreeUtil +import org.jetbrains.kotlin.descriptors.DeclarationDescriptorWithVisibility +import org.jetbrains.kotlin.idea.caches.resolve.analyzeFully +import org.jetbrains.kotlin.idea.caches.resolve.getJavaMemberDescriptor +import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade +import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor +import org.jetbrains.kotlin.idea.codeInsight.referenceExpression +import org.jetbrains.kotlin.idea.core.isVisible +import org.jetbrains.kotlin.idea.imports.canBeReferencedViaImport +import org.jetbrains.kotlin.idea.references.mainReference +import org.jetbrains.kotlin.idea.util.application.runWriteAction +import org.jetbrains.kotlin.platform.JavaToKotlinClassMap +import org.jetbrains.kotlin.psi.KtDotQualifiedExpression +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.psi.KtImportDirective +import java.util.* + + +class PlainTextPasteImportResolver(dataForConversion: DataForConversion, val targetFile: KtFile) { + + private val file = dataForConversion.file + private val project = targetFile.project + + private val importList = file.importList!! + private val psiElementFactory = PsiElementFactory.SERVICE.getInstance(project) + + private val bindingContext by lazy { targetFile.analyzeFully() } + private val resolutionFacade = targetFile.getResolutionFacade() + + private val shortNameCache = PsiShortNamesCache.getInstance(project) + private val scope = file.resolveScope + + val failedToResolveReferenceNames = HashSet() + var ambiguityInResolution = false + var couldNotResolve = false + + val addedImports = ArrayList() + + private fun canBeImported(descriptor: DeclarationDescriptorWithVisibility?): Boolean { + return descriptor != null + && descriptor.canBeReferencedViaImport() + && descriptor.isVisible(targetFile, null, bindingContext, resolutionFacade) + } + + private fun addImport(importStatement: PsiImportStatementBase, shouldAddToTarget: Boolean = false) { + importList.add(importStatement) + if (shouldAddToTarget) + addedImports.add(importStatement) + } + + fun addImportsFromTargetFile() { + + fun tryConvertKotlinImport(importDirective: KtImportDirective) { + val importPath = importDirective.importPath + val importedReference = importDirective.importedReference + if (importPath != null && !importPath.hasAlias() && importedReference is KtDotQualifiedExpression) { + val receiver = importedReference + .receiverExpression + .referenceExpression() + ?.mainReference + ?.resolve() + val selector = importedReference + .selectorExpression + ?.referenceExpression() + ?.mainReference + ?.resolve() + + val isPackageReceiver = receiver is PsiPackage + val isClassReceiver = receiver is PsiClass + val isClassSelector = selector is PsiClass + + if (importPath.isAllUnder) { + if (isClassReceiver) + psiElementFactory.createImportStaticStatement(receiver as PsiClass, "*") + else if (isPackageReceiver) + psiElementFactory.createImportStatementOnDemand((receiver as PsiPackage).qualifiedName) + } + else { + if (isPackageReceiver && isClassSelector) + psiElementFactory.createImportStatement(selector as PsiClass) + else if (isClassReceiver) + psiElementFactory.createImportStaticStatement(receiver as PsiClass, importPath.importedName!!.asString()) + } + } + } + runWriteAction { + targetFile.importDirectives.forEach(::tryConvertKotlinImport) + } + } + + fun tryResolveReferences() { + + val elementsWithUnresolvedRef = PsiTreeUtil.collectElements(file) { + it.reference != null + && it.reference is PsiQualifiedReference + && it.reference?.resolve() == null + } + + fun tryResolveReference(reference: PsiQualifiedReference): Boolean { + if (reference.resolve() != null) return true + val referenceName = reference.referenceName!! + if (referenceName in failedToResolveReferenceNames) return false + val classes = shortNameCache.getClassesByName(referenceName, scope) + .map { it to it.resolveToDescriptor(resolutionFacade) } + .filter { canBeImported(it.second) } + + classes.find { (psiClass, descriptor) -> JavaToKotlinClassMap.INSTANCE.mapPlatformClass(descriptor!!).isNotEmpty() } + ?.let { (psiClass, descriptor) -> addImport(psiElementFactory.createImportStatement(psiClass)) } + if (reference.resolve() != null) return true + + classes.singleOrNull()?.let { (psiClass, descriptor) -> + addImport(psiElementFactory.createImportStatement(psiClass), true) + } + + if (reference.resolve() != null) return true + else { + if (classes.isNotEmpty()) { + ambiguityInResolution = true + return false + } + } + + val members = (shortNameCache.getMethodsByName(referenceName, scope).asList() + + shortNameCache.getFieldsByName(referenceName, scope).asList()) + .map { it as PsiMember } + .map { it to it.getJavaMemberDescriptor(resolutionFacade) as? DeclarationDescriptorWithVisibility } + .filter { canBeImported(it.second) } + + members.singleOrNull()?.let { (psiMember, descriptor) -> + addImport(psiElementFactory.createImportStaticStatement(psiMember.containingClass!!, psiMember.name!!), true) + } + + if (reference.resolve() != null) return false + else { + if (members.isNotEmpty()) { + ambiguityInResolution = true + } + else { + couldNotResolve = true + } + } + return false + } + + runWriteAction { + elementsWithUnresolvedRef.forEach { + val reference = it.reference as PsiQualifiedReference + if (!tryResolveReference(reference)) failedToResolveReferenceNames += reference.referenceName!! + } + } + } +} \ No newline at end of file diff --git a/idea/testData/copyPaste/plainTextConversion/AsExpression.expected.kt b/idea/testData/copyPaste/plainTextConversion/AsExpression.expected.kt index 7881a3de813..b3294905a13 100644 --- a/idea/testData/copyPaste/plainTextConversion/AsExpression.expected.kt +++ b/idea/testData/copyPaste/plainTextConversion/AsExpression.expected.kt @@ -1,3 +1,5 @@ +import java.util.ArrayList + fun foo() { bar(ArrayList()) -} +} \ No newline at end of file diff --git a/idea/testData/copyPaste/plainTextConversion/AsExpressionBody.expected.kt b/idea/testData/copyPaste/plainTextConversion/AsExpressionBody.expected.kt index 42368e65dc6..e5eae6beeae 100644 --- a/idea/testData/copyPaste/plainTextConversion/AsExpressionBody.expected.kt +++ b/idea/testData/copyPaste/plainTextConversion/AsExpressionBody.expected.kt @@ -1 +1,3 @@ -fun foo() = ArrayList() +import java.util.ArrayList + +fun foo() = ArrayList() \ No newline at end of file diff --git a/idea/testData/copyPaste/plainTextConversion/ImportResolve.dependency.java b/idea/testData/copyPaste/plainTextConversion/ImportResolve.dependency.java new file mode 100644 index 00000000000..e7213189c67 --- /dev/null +++ b/idea/testData/copyPaste/plainTextConversion/ImportResolve.dependency.java @@ -0,0 +1,34 @@ +package test; + +public class ToBeImportedJava { + public static final String TO_BE_IMPORTED_CONST = "!!!"; + + public static void staticMethod() { + } +} + +public interface IAmbiguousJava { + +} + +public interface AmbiguousJava { + +} + +public interface IAmbiguous { + +} + +public interface Ambiguous { + +} + +public class Z { + public interface IAmbiguousJava { + + } + + public interface AmbiguousJava { + + } +} diff --git a/idea/testData/copyPaste/plainTextConversion/ImportResolve.dependency.kt b/idea/testData/copyPaste/plainTextConversion/ImportResolve.dependency.kt new file mode 100644 index 00000000000..6540512c12e --- /dev/null +++ b/idea/testData/copyPaste/plainTextConversion/ImportResolve.dependency.kt @@ -0,0 +1,32 @@ +package test + +class ToBeImportedKotlin { + +} + +interface IAmbiguous { + +} + +interface Ambiguous { + +} + + +interface IAmbiguousKotlin { + +} + +interface AmbiguousKotlin { + +} + +class Z { + interface IAmbiguousKotlin { + + } + + interface AmbiguousKotlin { + + } +} \ No newline at end of file diff --git a/idea/testData/copyPaste/plainTextConversion/ImportResolve.expected.kt b/idea/testData/copyPaste/plainTextConversion/ImportResolve.expected.kt new file mode 100644 index 00000000000..d565fec1455 --- /dev/null +++ b/idea/testData/copyPaste/plainTextConversion/ImportResolve.expected.kt @@ -0,0 +1,31 @@ +import java.util.ArrayList +import test.ToBeImportedJava +import test.ToBeImportedKotlin +import java.util.HashMap +import test.ToBeImportedJava.TO_BE_IMPORTED_CONST +import test.ToBeImportedJava.staticMethod + +class Target { + var listOfPlatformType: List = ArrayList() + + var unresolved: UnresolvedInterface = UnresolvedImplementation() // Should not add import + + var hashMapOfNotImported: Map = HashMap() + + fun acceptKotlinClass(tbi: ToBeImportedKotlin) { + + } + + fun acceptJavaClass(tbi: ToBeImportedJava) { + + } + + var ambiguousKotlin: IAmbiguousKotlin = AmbiguousKotlin() // Should not add import in case of 2 declarations in Kotlin + var ambiguous: IAmbiguous = Ambiguous() // Should not add import in case of ambiguous declarations in Kotlin and in Java + var ambiguousJava: IAmbiguousJava = AmbiguousJava() // Should not add import in case of 2 declarations in Java + + fun workWithStatics() { + val a = TO_BE_IMPORTED_CONST + staticMethod() + } +} \ No newline at end of file diff --git a/idea/testData/copyPaste/plainTextConversion/ImportResolve.to.kt b/idea/testData/copyPaste/plainTextConversion/ImportResolve.to.kt new file mode 100644 index 00000000000..dee11740046 --- /dev/null +++ b/idea/testData/copyPaste/plainTextConversion/ImportResolve.to.kt @@ -0,0 +1,3 @@ +class Target { + +} \ No newline at end of file diff --git a/idea/testData/copyPaste/plainTextConversion/ImportResolve.txt b/idea/testData/copyPaste/plainTextConversion/ImportResolve.txt new file mode 100644 index 00000000000..97ffd68a1b6 --- /dev/null +++ b/idea/testData/copyPaste/plainTextConversion/ImportResolve.txt @@ -0,0 +1,22 @@ +public List listOfPlatformType = new ArrayList(); + +UnresolvedInterface unresolved = new UnresolvedImplementation<>(); // Should not add import + +Map hashMapOfNotImported = new HashMap<>(); + +void acceptKotlinClass(ToBeImportedKotlin tbi) { + +} + +void acceptJavaClass(ToBeImportedJava tbi) { + +} + +IAmbiguousKotlin ambiguousKotlin = new AmbiguousKotlin(); // Should not add import in case of 2 declarations in Kotlin +IAmbiguous ambiguous = new Ambiguous(); // Should not add import in case of ambiguous declarations in Kotlin and in Java +IAmbiguousJava ambiguousJava = new AmbiguousJava(); // Should not add import in case of 2 declarations in Java + +void workWithStatics() { + String a = TO_BE_IMPORTED_CONST; + staticMethod(); +} \ No newline at end of file diff --git a/idea/testData/copyPaste/plainTextConversion/KT13529_1.expected.kt b/idea/testData/copyPaste/plainTextConversion/KT13529_1.expected.kt index 334de42b719..2e132d117cb 100644 --- a/idea/testData/copyPaste/plainTextConversion/KT13529_1.expected.kt +++ b/idea/testData/copyPaste/plainTextConversion/KT13529_1.expected.kt @@ -1,3 +1,5 @@ +import java.util.ArrayList + fun foo() { bar(/*comment*/ArrayList()) -} +} \ No newline at end of file diff --git a/idea/testData/copyPaste/plainTextConversion/MembersIntoClass.expected.kt b/idea/testData/copyPaste/plainTextConversion/MembersIntoClass.expected.kt index 8de9d7aced5..adcbc18d45b 100644 --- a/idea/testData/copyPaste/plainTextConversion/MembersIntoClass.expected.kt +++ b/idea/testData/copyPaste/plainTextConversion/MembersIntoClass.expected.kt @@ -1,3 +1,5 @@ +import java.util.ArrayList + class A { fun foo() { val list = ArrayList() diff --git a/idea/testData/copyPaste/plainTextConversion/MembersToTopLevel.expected.kt b/idea/testData/copyPaste/plainTextConversion/MembersToTopLevel.expected.kt index 2da923a93a3..e2af8984348 100644 --- a/idea/testData/copyPaste/plainTextConversion/MembersToTopLevel.expected.kt +++ b/idea/testData/copyPaste/plainTextConversion/MembersToTopLevel.expected.kt @@ -1,5 +1,8 @@ package to +import java.util.ArrayList + + fun foo() { val list = ArrayList() list.add(1) diff --git a/idea/testData/copyPaste/plainTextConversion/StatementsIntoFunction.expected.kt b/idea/testData/copyPaste/plainTextConversion/StatementsIntoFunction.expected.kt index 572c0bbcba2..3ad7d6ab822 100644 --- a/idea/testData/copyPaste/plainTextConversion/StatementsIntoFunction.expected.kt +++ b/idea/testData/copyPaste/plainTextConversion/StatementsIntoFunction.expected.kt @@ -1,3 +1,5 @@ +import java.util.ArrayList + fun foo() { val list = ArrayList() list.add(1) diff --git a/idea/tests/org/jetbrains/kotlin/idea/conversion/copy/TextJavaToKotlinCopyPasteConversionTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/conversion/copy/TextJavaToKotlinCopyPasteConversionTestGenerated.java index 35674022806..2684a604f32 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/conversion/copy/TextJavaToKotlinCopyPasteConversionTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/conversion/copy/TextJavaToKotlinCopyPasteConversionTestGenerated.java @@ -47,6 +47,12 @@ public class TextJavaToKotlinCopyPasteConversionTestGenerated extends AbstractTe doTest(fileName); } + @TestMetadata("ImportResolve.txt") + public void testImportResolve() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/testData/copyPaste/plainTextConversion/ImportResolve.txt"); + doTest(fileName); + } + @TestMetadata("InsideIdentifier.txt") public void testInsideIdentifier() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("idea/testData/copyPaste/plainTextConversion/InsideIdentifier.txt");