From 8c7873998384dc0db5a8de0ab0c97b02a8cda352 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Wed, 29 Apr 2015 20:54:13 +0300 Subject: [PATCH] Proper enhancement for type parameters --- .../load/java/components/typeEnhancement.kt | 17 ++++++++----- .../diagnostics/tests/j+k/types/arrayList.kt | 15 ++++++++++++ .../diagnostics/tests/j+k/types/arrayList.txt | 24 +++++++++++++++++++ .../tests/j+k/types/typeParameter.kt | 11 +++++++++ .../tests/j+k/types/typeParameter.txt | 15 ++++++++++++ .../propagation/return/TypeParamOfClass.txt | 2 +- .../return/TypeParamOfClassSubstituted.txt | 2 +- .../propagation/return/TypeParamOfFun.txt | 4 ++-- .../checkers/JetDiagnosticsTestGenerated.java | 12 ++++++++++ 9 files changed, 92 insertions(+), 10 deletions(-) create mode 100644 compiler/testData/diagnostics/tests/j+k/types/arrayList.kt create mode 100644 compiler/testData/diagnostics/tests/j+k/types/arrayList.txt create mode 100644 compiler/testData/diagnostics/tests/j+k/types/typeParameter.kt create mode 100644 compiler/testData/diagnostics/tests/j+k/types/typeParameter.txt diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/typeEnhancement.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/typeEnhancement.kt index e54514c5f8b..bcf098a9610 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/typeEnhancement.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/typeEnhancement.kt @@ -17,6 +17,8 @@ package org.jetbrains.kotlin.load.java.components import org.jetbrains.kotlin.descriptors.ClassDescriptor +import org.jetbrains.kotlin.descriptors.ClassifierDescriptor +import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor import org.jetbrains.kotlin.load.java.components.MutabilityQualifier.MUTABLE import org.jetbrains.kotlin.load.java.components.MutabilityQualifier.READ_ONLY import org.jetbrains.kotlin.load.java.components.NullabilityQualifier.NOT_NULL @@ -62,18 +64,18 @@ private fun JetType.enhanceInflexible(qualifiers: (Int) -> JavaTypeQualifiers, i val shouldEnhance = position.shouldEnhance() if (!shouldEnhance && getArguments().isEmpty()) return Result(this, 1) - val originalClass = getConstructor().getDeclarationDescriptor() as? ClassDescriptor + val originalClass = getConstructor().getDeclarationDescriptor() ?: return Result(this, 1) val effectiveQualifiers = qualifiers(index) - val enhancedClass = originalClass.enhanceMutability(effectiveQualifiers, position) + val enhancedClassifier = originalClass.enhanceMutability(effectiveQualifiers, position) var globalArgIndex = index + 1 val enhancedArguments = getArguments().mapIndexed { localArgIndex, arg -> if (arg.isStarProjection()) { globalArgIndex++ - TypeUtils.makeStarProjection(enhancedClass.getTypeConstructor().getParameters()[localArgIndex]) + TypeUtils.makeStarProjection(enhancedClassifier.getTypeConstructor().getParameters()[localArgIndex]) } else { val (enhancedType, subtreeSize) = arg.getType().enhancePossiblyFlexible(qualifiers, globalArgIndex) @@ -87,18 +89,21 @@ private fun JetType.enhanceInflexible(qualifiers: (Int) -> JavaTypeQualifiers, i val enhancedType = JetTypeImpl( getAnnotations(), - enhancedClass.getTypeConstructor(), + enhancedClassifier.getTypeConstructor(), this.getEnhancedNullability(effectiveQualifiers, position), enhancedArguments, - enhancedClass.getMemberScope(enhancedArguments) + if (enhancedClassifier is ClassDescriptor) + enhancedClassifier.getMemberScope(enhancedArguments) + else enhancedClassifier.getDefaultType().getMemberScope() ) return Result(enhancedType, globalArgIndex - index) } private fun TypeComponentPosition.shouldEnhance() = this != TypeComponentPosition.INFLEXIBLE -private fun ClassDescriptor.enhanceMutability(qualifiers: JavaTypeQualifiers, position: TypeComponentPosition): ClassDescriptor { +private fun ClassifierDescriptor.enhanceMutability(qualifiers: JavaTypeQualifiers, position: TypeComponentPosition): ClassifierDescriptor { if (!position.shouldEnhance()) return this + if (this !is ClassDescriptor) return this // mutability is not applicable for type parameters val mapping = JavaToKotlinClassMap.INSTANCE diff --git a/compiler/testData/diagnostics/tests/j+k/types/arrayList.kt b/compiler/testData/diagnostics/tests/j+k/types/arrayList.kt new file mode 100644 index 00000000000..107e4068059 --- /dev/null +++ b/compiler/testData/diagnostics/tests/j+k/types/arrayList.kt @@ -0,0 +1,15 @@ +// FILE: k.kt + +trait ML { + public fun foo(): MutableList +} + +class K : J(), ML + +// FILE: J.java + +import java.util.*; + +class J extends ML { + public List foo() { return null; } +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/j+k/types/arrayList.txt b/compiler/testData/diagnostics/tests/j+k/types/arrayList.txt new file mode 100644 index 00000000000..36f1fa464ad --- /dev/null +++ b/compiler/testData/diagnostics/tests/j+k/types/arrayList.txt @@ -0,0 +1,24 @@ +package + +public/*package*/ open class J : ML { + public/*package*/ constructor J() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ fun foo(): kotlin.MutableList + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +internal final class K : J, ML { + public constructor K() + public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*2*/ /*fake_override*/ fun foo(): kotlin.MutableList + public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String +} + +internal trait ML { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public abstract fun foo(): kotlin.MutableList + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/testData/diagnostics/tests/j+k/types/typeParameter.kt b/compiler/testData/diagnostics/tests/j+k/types/typeParameter.kt new file mode 100644 index 00000000000..3aac76a2aad --- /dev/null +++ b/compiler/testData/diagnostics/tests/j+k/types/typeParameter.kt @@ -0,0 +1,11 @@ +// FILE: k.kt + +trait K { + fun foo(t: T) +} + +// FILE: J.java + +interface J extends K { + void foo(T t); +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/j+k/types/typeParameter.txt b/compiler/testData/diagnostics/tests/j+k/types/typeParameter.txt new file mode 100644 index 00000000000..836bc55a09d --- /dev/null +++ b/compiler/testData/diagnostics/tests/j+k/types/typeParameter.txt @@ -0,0 +1,15 @@ +package + +public/*package*/ trait J : K { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public abstract override /*1*/ fun foo(/*0*/ t: T): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +internal trait K { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + internal abstract fun foo(/*0*/ t: T): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfClass.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfClass.txt index 192d611dfa4..73432c13ca7 100644 --- a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfClass.txt +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfClass.txt @@ -9,6 +9,6 @@ public interface TypeParamOfClass { public interface Super { public abstract fun dummy(): kotlin.Unit - org.jetbrains.annotations.NotNull() public abstract fun foo(): T! + org.jetbrains.annotations.NotNull() public abstract fun foo(): T } } diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.txt index 1c759f64976..2a7210129e7 100644 --- a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.txt +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfClassSubstituted.txt @@ -9,6 +9,6 @@ public interface TypeParamOfClassSubstituted { public interface Super { public abstract fun dummy(): kotlin.Unit - org.jetbrains.annotations.NotNull() public abstract fun foo(): T! + org.jetbrains.annotations.NotNull() public abstract fun foo(): T } } diff --git a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfFun.txt b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfFun.txt index 283136f6ebb..cf25cb6eb92 100644 --- a/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfFun.txt +++ b/compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return/TypeParamOfFun.txt @@ -4,11 +4,11 @@ public interface TypeParamOfFun { public interface Sub : test.TypeParamOfFun.Super { public abstract override /*1*/ /*fake_override*/ fun dummy(): kotlin.Unit - public abstract override /*1*/ fun foo(): E! + public abstract override /*1*/ fun foo(): E } public interface Super { public abstract fun dummy(): kotlin.Unit - org.jetbrains.annotations.NotNull() public abstract fun foo(): T! + org.jetbrains.annotations.NotNull() public abstract fun foo(): T } } diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/JetDiagnosticsTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/checkers/JetDiagnosticsTestGenerated.java index 1ae5226e81f..b5529a443fa 100644 --- a/compiler/tests/org/jetbrains/kotlin/checkers/JetDiagnosticsTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/checkers/JetDiagnosticsTestGenerated.java @@ -8192,6 +8192,12 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/types"), Pattern.compile("^(.+)\\.kt$"), true); } + @TestMetadata("arrayList.kt") + public void testArrayList() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/types/arrayList.kt"); + doTest(fileName); + } + @TestMetadata("returnCollection.kt") public void testReturnCollection() throws Exception { String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/types/returnCollection.kt"); @@ -8209,6 +8215,12 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest { String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/types/shapeMismatchInCovariantPositionGeneric.kt"); doTest(fileName); } + + @TestMetadata("typeParameter.kt") + public void testTypeParameter() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/j+k/types/typeParameter.kt"); + doTest(fileName); + } } }