From 0d1790a4f488c377af30f3308fd40ae5356c70e9 Mon Sep 17 00:00:00 2001 From: Svetlana Isakova Date: Thu, 13 Sep 2012 15:13:28 +0400 Subject: [PATCH] alternative signature applies for names mapped in standard library (and differs from auto transformed Java signature) e.g.Collections.copy(MutableList, List) --- .../java/AlternativeSignatureData.java | 32 +++++++++++++++---- .../jdk-annotations/iteratingOverHashMap.kt | 25 +++++++++++++++ .../MethodWithMappedClasses.java | 12 +++++++ .../MethodWithMappedClasses.kt | 7 ++++ .../MethodWithMappedClasses.txt | 6 ++++ .../jet/codegen/JdkAnnotationsTest.java | 4 +++ .../jvm/compiler/LoadJavaTestGenerated.java | 5 +++ ...esolveNamespaceComparingTestGenerated.java | 5 +++ .../specifyType/afterLoopParameter.kt | 2 +- 9 files changed, 91 insertions(+), 7 deletions(-) create mode 100644 compiler/testData/codegen/jdk-annotations/iteratingOverHashMap.kt create mode 100644 compiler/testData/loadJava/kotlinSignature/MethodWithMappedClasses.java create mode 100644 compiler/testData/loadJava/kotlinSignature/MethodWithMappedClasses.kt create mode 100644 compiler/testData/loadJava/kotlinSignature/MethodWithMappedClasses.txt diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AlternativeSignatureData.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AlternativeSignatureData.java index 0af86ba25d1..dae8a27240e 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AlternativeSignatureData.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AlternativeSignatureData.java @@ -25,6 +25,7 @@ import com.intellij.util.Function; import com.intellij.util.containers.ComparatorUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.asm4.Type; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.AnalyzingUtils; @@ -36,10 +37,7 @@ import org.jetbrains.jet.lang.types.lang.JetStandardClasses; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import org.jetbrains.jet.resolve.DescriptorRenderer; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; +import java.util.*; /** * @author Evgeny Gerashchenko @@ -173,7 +171,8 @@ class AlternativeSignatureData { ClassifierDescriptor declarationDescriptor = originalTypeConstructor.getDeclarationDescriptor(); assert declarationDescriptor != null; String fqName = DescriptorUtils.getFQName(declarationDescriptor).toSafe().getFqName(); - if (!fqName.equals(expectedFqNamePostfix) && !fqName.endsWith("." + expectedFqNamePostfix)) { + ClassDescriptor classFromLibrary = getExpectedFromLibrary(expectedFqNamePostfix); + if (!fqName.equals(expectedFqNamePostfix) && !fqName.endsWith("." + expectedFqNamePostfix) && classFromLibrary == null) { fail("Alternative signature type mismatch, expected: %s, actual: %s", expectedFqNamePostfix, fqName); } @@ -213,7 +212,13 @@ class AlternativeSignatureData { altArguments.add(new TypeProjection(variance, alternativeType)); } - TypeConstructor typeConstructor = originalTypeConstructor; + TypeConstructor typeConstructor; + if (classFromLibrary != null) { + typeConstructor = classFromLibrary.getTypeConstructor(); + } + else { + typeConstructor = originalTypeConstructor; + } ClassifierDescriptor typeConstructorClassifier = typeConstructor.getDeclarationDescriptor(); if (typeConstructorClassifier instanceof TypeParameterDescriptor && originalToAltTypeParameters.containsKey(typeConstructorClassifier)) { @@ -234,6 +239,21 @@ class AlternativeSignatureData { altArguments, memberScope); } + @Nullable + private ClassDescriptor getExpectedFromLibrary(String expectedFqNamePostfix) { + Type javaAnalog = KotlinToJavaTypesMap.getInstance().getJavaAnalog(autoType); + if (javaAnalog == null || javaAnalog.getSort() != Type.OBJECT) return null; + Collection descriptors = + JavaToKotlinClassMap.getInstance().mapPlatformClass(JvmClassName.byType(javaAnalog).getFqName()); + for (ClassDescriptor descriptor : descriptors) { + String fqName = DescriptorUtils.getFQName(descriptor).getFqName(); + if (fqName.endsWith("." + expectedFqNamePostfix)) { + return descriptor; + } + } + return null; + } + @Override public JetType visitSelfType(JetSelfType type, Void data) { throw new UnsupportedOperationException("Self-types are not supported yet"); diff --git a/compiler/testData/codegen/jdk-annotations/iteratingOverHashMap.kt b/compiler/testData/codegen/jdk-annotations/iteratingOverHashMap.kt new file mode 100644 index 00000000000..091041e1d3d --- /dev/null +++ b/compiler/testData/codegen/jdk-annotations/iteratingOverHashMap.kt @@ -0,0 +1,25 @@ +import java.util.HashMap + +fun box() : String { + if (!testIteratingOverMap1()) return "fail 1" + if (!testIteratingOverMap2()) return "fail 2" + return "OK" +} + +fun testIteratingOverMap1() : Boolean { + val map = HashMap() + map.put("a", 1) + for (entry in map.entrySet()) { + entry.setValue(2) + } + return map.get("a") == 2 +} + +fun testIteratingOverMap2() : Boolean { + val map : MutableMap = HashMap() + map.put("a", 1) + for (entry in map.entrySet()) { + entry.setValue(2) + } + return map.get("a") == 2 +} \ No newline at end of file diff --git a/compiler/testData/loadJava/kotlinSignature/MethodWithMappedClasses.java b/compiler/testData/loadJava/kotlinSignature/MethodWithMappedClasses.java new file mode 100644 index 00000000000..a243e3e199e --- /dev/null +++ b/compiler/testData/loadJava/kotlinSignature/MethodWithMappedClasses.java @@ -0,0 +1,12 @@ +package test; + +import java.lang.UnsupportedOperationException; +import java.util.*; +import jet.runtime.typeinfo.KotlinSignature; + +public class MethodWithMappedClasses { + @KotlinSignature("fun copy(dest : MutableList, src : List)") + public void copy(List dest, List src) { + throw new UnsupportedOperationException(); + } +} diff --git a/compiler/testData/loadJava/kotlinSignature/MethodWithMappedClasses.kt b/compiler/testData/loadJava/kotlinSignature/MethodWithMappedClasses.kt new file mode 100644 index 00000000000..4de303b8576 --- /dev/null +++ b/compiler/testData/loadJava/kotlinSignature/MethodWithMappedClasses.kt @@ -0,0 +1,7 @@ +package test + +import java.util.* + +public open class MethodWithMappedClasses : Object() { + public open fun copy(p0 : MutableList, p1 : List) {} +} diff --git a/compiler/testData/loadJava/kotlinSignature/MethodWithMappedClasses.txt b/compiler/testData/loadJava/kotlinSignature/MethodWithMappedClasses.txt new file mode 100644 index 00000000000..2d362e74797 --- /dev/null +++ b/compiler/testData/loadJava/kotlinSignature/MethodWithMappedClasses.txt @@ -0,0 +1,6 @@ +namespace test + +public open class test.MethodWithMappedClasses : java.lang.Object { + public final /*constructor*/ fun (): test.MethodWithMappedClasses + public open fun copy(/*0*/ p0: jet.MutableList, /*1*/ p1: jet.List): jet.Tuple0 +} diff --git a/compiler/tests/org/jetbrains/jet/codegen/JdkAnnotationsTest.java b/compiler/tests/org/jetbrains/jet/codegen/JdkAnnotationsTest.java index c457470ef54..a9e76168764 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/JdkAnnotationsTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/JdkAnnotationsTest.java @@ -43,4 +43,8 @@ public class JdkAnnotationsTest extends CodegenTestCase { public void testKt1397() { blackBoxFile("regressions/kt1397.kt"); } + + public void testIteratingOverHashMap() { + blackBoxFile("jdk-annotations/iteratingOverHashMap.kt"); + } } diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java index 715196ce9f0..bcfff22f01a 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java @@ -250,6 +250,11 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { doTest("compiler/testData/loadJava/kotlinSignature/MethodWithGenerics.java"); } + @TestMetadata("MethodWithMappedClasses.java") + public void testMethodWithMappedClasses() throws Exception { + doTest("compiler/testData/loadJava/kotlinSignature/MethodWithMappedClasses.java"); + } + @TestMetadata("MethodWithTupleType.java") public void testMethodWithTupleType() throws Exception { doTest("compiler/testData/loadJava/kotlinSignature/MethodWithTupleType.java"); diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java index 41da7cd2d03..7f912f53e60 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java @@ -1125,6 +1125,11 @@ public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyReso doTestSinglePackage("compiler/testData/loadJava/kotlinSignature/MethodWithGenerics.kt"); } + @TestMetadata("MethodWithMappedClasses.kt") + public void testMethodWithMappedClasses() throws Exception { + doTestSinglePackage("compiler/testData/loadJava/kotlinSignature/MethodWithMappedClasses.kt"); + } + @TestMetadata("MethodWithTupleType.kt") public void testMethodWithTupleType() throws Exception { doTestSinglePackage("compiler/testData/loadJava/kotlinSignature/MethodWithTupleType.kt"); diff --git a/idea/testData/intentions/specifyType/afterLoopParameter.kt b/idea/testData/intentions/specifyType/afterLoopParameter.kt index ee698f5c443..387bb82fbd1 100644 --- a/idea/testData/intentions/specifyType/afterLoopParameter.kt +++ b/idea/testData/intentions/specifyType/afterLoopParameter.kt @@ -2,7 +2,7 @@ import java.util.HashMap fun foo(map : HashMap) { - for (entry : Map.Entry in map.entrySet()) { + for (entry : MutableMap.MutableEntry in map.entrySet()) { } } \ No newline at end of file