diff --git a/compiler/psi/src/org/jetbrains/kotlin/psi/KtClassBody.kt b/compiler/psi/src/org/jetbrains/kotlin/psi/KtClassBody.kt index c2f3ca6d323..3e4b7ea1e78 100644 --- a/compiler/psi/src/org/jetbrains/kotlin/psi/KtClassBody.kt +++ b/compiler/psi/src/org/jetbrains/kotlin/psi/KtClassBody.kt @@ -46,7 +46,7 @@ class KtClassBody : KtElementImplStub>, KtDec val properties: List get() = getStubOrPsiChildrenAsList(KtStubElementTypes.PROPERTY) - val functions: List + val functions: List get() = getStubOrPsiChildrenAsList(KtStubElementTypes.FUNCTION) val enumEntries: List diff --git a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/BoundTypeCalculator.kt b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/BoundTypeCalculator.kt index 45bb13fb1bb..f4f111a20c6 100644 --- a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/BoundTypeCalculator.kt +++ b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/BoundTypeCalculator.kt @@ -36,37 +36,41 @@ interface BoundTypeCalculator { ): BoundType } -class BoundTypeCalculatorImpl( +open class BoundTypeCalculatorImpl( private val resolutionFacade: ResolutionFacade, private val enhancer: BoundTypeEnhancer ) : BoundTypeCalculator { private val cache = mutableMapOf() - override fun expressionsWithBoundType() = cache.toList() + final override fun expressionsWithBoundType() = cache.toList() - override fun KtExpression.boundType(inferenceContext: InferenceContext): BoundType = cache.getOrPut(this) { + final override fun KtExpression.boundType(inferenceContext: InferenceContext): BoundType = cache.getOrPut(this) { calculateBoundType(inferenceContext, this) } - private fun calculateBoundType(inferenceContext: InferenceContext, expression: KtExpression): BoundType = when { - expression.isNullExpression() -> BoundType.NULL - expression is KtParenthesizedExpression -> expression.expression?.boundType(inferenceContext) - expression is KtConstantExpression - || expression is KtStringTemplateExpression - || expression.node?.elementType == KtNodeTypes.BOOLEAN_CONSTANT - || expression is KtBinaryExpression -> - BoundType.LITERAL - expression is KtQualifiedExpression -> expression.toBoundTypeAsQualifiedExpression(inferenceContext) - expression is KtBinaryExpressionWithTypeRHS -> expression.toBoundTypeAsCastExpression(inferenceContext) - expression is KtNameReferenceExpression -> expression.toBoundTypeAsReferenceExpression(inferenceContext) - expression is KtCallExpression -> expression.toBoundTypeAsCallableExpression(null, inferenceContext) - expression is KtLambdaExpression -> expression.toBoundTypeAsLambdaExpression(inferenceContext) - expression is KtLabeledExpression -> expression.baseExpression?.boundType(inferenceContext) - expression is KtIfExpression -> expression.toBoundTypeAsIfExpression(inferenceContext) - else -> null - }?.let { boundType -> - enhancer.enhance(expression, boundType, inferenceContext) - } ?: BoundType.LITERAL + open fun interceptCalculateBoundType(inferenceContext: InferenceContext, expression: KtExpression): BoundType? = + null + + private fun calculateBoundType(inferenceContext: InferenceContext, expression: KtExpression): BoundType = + interceptCalculateBoundType(inferenceContext, expression) ?: when { + expression.isNullExpression() -> BoundType.NULL + expression is KtParenthesizedExpression -> expression.expression?.boundType(inferenceContext) + expression is KtConstantExpression + || expression is KtStringTemplateExpression + || expression.node?.elementType == KtNodeTypes.BOOLEAN_CONSTANT + || expression is KtBinaryExpression -> + BoundType.LITERAL + expression is KtQualifiedExpression -> expression.toBoundTypeAsQualifiedExpression(inferenceContext) + expression is KtBinaryExpressionWithTypeRHS -> expression.toBoundTypeAsCastExpression(inferenceContext) + expression is KtNameReferenceExpression -> expression.toBoundTypeAsReferenceExpression(inferenceContext) + expression is KtCallExpression -> expression.toBoundTypeAsCallableExpression(null, inferenceContext) + expression is KtLambdaExpression -> expression.toBoundTypeAsLambdaExpression(inferenceContext) + expression is KtLabeledExpression -> expression.baseExpression?.boundType(inferenceContext) + expression is KtIfExpression -> expression.toBoundTypeAsIfExpression(inferenceContext) + else -> null + }?.let { boundType -> + enhancer.enhance(expression, boundType, inferenceContext) + } ?: BoundType.LITERAL private fun KtIfExpression.toBoundTypeAsIfExpression(inferenceContext: InferenceContext): BoundType? { val isNullLiteralPossible = then?.isNullExpression() == true || `else`?.isNullExpression() == true @@ -166,7 +170,7 @@ class BoundTypeCalculatorImpl( return selectorExpression.toBoundTypeAsCallableExpression(receiverBoundType, inferenceContext) } - override fun KotlinType.boundType( + final override fun KotlinType.boundType( typeVariable: TypeVariable?, contextBoundType: BoundType?, call: ResolvedCall<*>?, @@ -220,8 +224,9 @@ class BoundTypeCalculatorImpl( when { containingDeclaration == call?.candidateDescriptor?.original -> { val returnTypeVariable = inferenceContext.typeElementToTypeVariable[ - call.call.typeArguments.getOrNull(target.index)?.typeReference?.typeElement ?: return null - ] ?: return null + call.call.typeArguments.getOrNull(target.index)?.typeReference?.typeElement + ?: return BoundType.STAR_PROJECTION + ] ?: return BoundType.STAR_PROJECTION BoundTypeImpl( TypeVariableLabel(returnTypeVariable), returnTypeVariable.typeParameters @@ -238,8 +243,9 @@ class BoundTypeCalculatorImpl( // `this` or `super` call case containingDeclaration == call?.candidateDescriptor.safeAs()?.constructedClass -> { val returnTypeVariable = inferenceContext.typeElementToTypeVariable[ - call?.call?.typeArguments?.getOrNull(target.index)?.typeReference?.typeElement ?: return null - ] ?: return null + call?.call?.typeArguments?.getOrNull(target.index)?.typeReference?.typeElement + ?: return BoundType.STAR_PROJECTION + ] ?: return BoundType.STAR_PROJECTION BoundTypeImpl( TypeVariableLabel(returnTypeVariable), returnTypeVariable.typeParameters diff --git a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/Constraint.kt b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/Constraint.kt index a553087fc9c..df4d4adbf74 100644 --- a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/Constraint.kt +++ b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/Constraint.kt @@ -54,28 +54,8 @@ class LiteralBound private constructor(val state: State) : ConstraintBound() { } } -val TypeVariable.constraintBound: TypeVariableBound - get() = TypeVariableBound(this) - -val State.constraintBound: LiteralBound - get() = when (this) { - State.LOWER -> LiteralBound.LOWER - State.UPPER -> LiteralBound.UPPER - State.UNKNOWN -> LiteralBound.UNKNOWN - } - -val BoundTypeLabel.constraintBound: ConstraintBound? - get() = when (this) { - is TypeVariableLabel -> typeVariable.constraintBound - is TypeParameterLabel -> null - is GenericLabel -> null - StarProjectionLabel -> null - NullLiteralLabel -> LiteralBound.UPPER - LiteralLabel -> LiteralBound.LOWER - } - -val BoundType.constraintBound: ConstraintBound? - get() = when (this) { - is BoundTypeImpl -> label.constraintBound - is WithForcedStateBoundType -> forcedState.constraintBound - } \ No newline at end of file +fun State.constraintBound(): LiteralBound = when (this) { + State.LOWER -> LiteralBound.LOWER + State.UPPER -> LiteralBound.UPPER + State.UNKNOWN -> LiteralBound.UNKNOWN +} diff --git a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/ConstraintBoundProvider.kt b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/ConstraintBoundProvider.kt new file mode 100644 index 00000000000..090729f7f2a --- /dev/null +++ b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/ConstraintBoundProvider.kt @@ -0,0 +1,22 @@ +/* + * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.nj2k.inference.common + +interface ConstraintBoundProvider { + fun TypeVariable.constraintBound(): TypeVariableBound + fun BoundType.constraintBound(): ConstraintBound? + fun BoundTypeLabel.constraintBound(): ConstraintBound? +} + +abstract class ConstraintBoundProviderImpl : ConstraintBoundProvider { + final override fun TypeVariable.constraintBound(): TypeVariableBound = + TypeVariableBound(this) + + final override fun BoundType.constraintBound(): ConstraintBound? = when (this) { + is BoundTypeImpl -> label.constraintBound() + is WithForcedStateBoundType -> forcedState.constraintBound() + } +} \ No newline at end of file diff --git a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/ConstraintBuilder.kt b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/ConstraintBuilder.kt index ba16ae896be..80d42d9f585 100644 --- a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/ConstraintBuilder.kt +++ b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/ConstraintBuilder.kt @@ -13,8 +13,9 @@ import org.jetbrains.kotlin.utils.addToStdlib.safeAs @Suppress("unused") class ConstraintBuilder( private val inferenceContext: InferenceContext, - private val boundTypeCalculator: BoundTypeCalculator -) : BoundTypeCalculator by boundTypeCalculator { + private val boundTypeCalculator: BoundTypeCalculator, + private val constraintBoundProvider: ConstraintBoundProvider +) : BoundTypeCalculator by boundTypeCalculator, ConstraintBoundProvider by constraintBoundProvider { private val constraints = mutableListOf() fun TypeVariable.isSubtypeOf(supertype: BoundType, priority: ConstraintPriority) { @@ -39,7 +40,7 @@ class ConstraintBuilder( fun KtExpression.isTheSameTypeAs(other: State, priority: ConstraintPriority) { boundType().label.safeAs()?.typeVariable?.let { typeVariable -> - constraints += EqualsConstraint(typeVariable.constraintBound, other.constraintBound, priority) + constraints += EqualsConstraint(typeVariable.constraintBound(), other.constraintBound(), priority) } } @@ -104,8 +105,8 @@ class ConstraintBuilder( if (typeVariable !in ignoreTypeVariables && other.typeVariable !in ignoreTypeVariables) { constraints += EqualsConstraint( - constraintBound ?: return, - other.constraintBound ?: return, + constraintBound() ?: return, + other.constraintBound() ?: return, priority ) } @@ -121,8 +122,8 @@ class ConstraintBuilder( } constraints += SubtypeConstraint( - constraintBound ?: return, - supertype.constraintBound ?: return, + constraintBound() ?: return, + supertype.constraintBound() ?: return, priority ) } diff --git a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/ConstraintsCollectorAggregator.kt b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/ConstraintsCollectorAggregator.kt index 765d264e86d..fd27d35b93c 100644 --- a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/ConstraintsCollectorAggregator.kt +++ b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/ConstraintsCollectorAggregator.kt @@ -14,14 +14,15 @@ import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType class ConstraintsCollectorAggregator( private val resolutionFacade: ResolutionFacade, - private val collectors: List + private val constraintBoundProvider: ConstraintBoundProvider, + val collectors: List ) { fun collectConstraints( boundTypeCalculator: BoundTypeCalculator, inferenceContext: InferenceContext, elements: List ): List { - val constraintsBuilder = ConstraintBuilder(inferenceContext, boundTypeCalculator) + val constraintsBuilder = ConstraintBuilder(inferenceContext, boundTypeCalculator, constraintBoundProvider) for (element in elements) { element.forEachDescendantOfType { innerElement -> if (innerElement.getStrictParentOfType() != null) return@forEachDescendantOfType diff --git a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/ContextCollector.kt b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/ContextCollector.kt index 13117b8fbe8..5dd85ce4708 100644 --- a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/ContextCollector.kt +++ b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/ContextCollector.kt @@ -12,6 +12,7 @@ import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptorIfAny import org.jetbrains.kotlin.idea.resolve.ResolutionFacade import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.psi.psiUtil.forEachDescendantOfType +import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.calls.callUtil.getType import org.jetbrains.kotlin.types.KotlinType @@ -29,13 +30,13 @@ abstract class ContextCollector(private val resolutionFacade: ResolutionFacade) private fun KtTypeReference.classReference(): ClassReference? = analyze()[BindingContext.TYPE, this]?.classReference() - private fun KtTypeElement.toData(): TypeElementData { - val typeReference = parent as? KtTypeReference ?: return TypeElementDataImpl(this) - val typeParameterDescriptor = analyze(resolutionFacade)[BindingContext.TYPE, typeReference] - ?.constructor - ?.declarationDescriptor - ?.safeAs() ?: return TypeElementDataImpl(this) - return TypeParameterElementData(this, typeParameterDescriptor) + private fun KtTypeElement.toData(): TypeElementData? { + val typeReference = parent as? KtTypeReference ?: return null + val type = analyze(resolutionFacade)[BindingContext.TYPE, typeReference] ?: return null + val typeParameterDescriptor = type.constructor + .declarationDescriptor + ?.safeAs() ?: return TypeElementDataImpl(this, type) + return TypeParameterElementData(this, type, typeParameterDescriptor) } fun collectTypeVariables(elements: List): InferenceContext { @@ -43,7 +44,7 @@ abstract class ContextCollector(private val resolutionFacade: ResolutionFacade) val typeElementToTypeVariable = mutableMapOf() val typeBasedTypeVariables = mutableListOf() - fun KtTypeReference.toBoundType(defaultState: State? = null): BoundType? { + fun KtTypeReference.toBoundType(owner: TypeVariableOwner, defaultState: State? = null): BoundType? { val typeElement = typeElement ?: return null val classReference = classReference() ?: NoClassReference @@ -58,9 +59,7 @@ abstract class ContextCollector(private val resolutionFacade: ResolutionFacade) classReference.descriptor.declaredTypeParameters ) { typeArgument, typeParameter -> TypeParameter( - if (typeArgument == null) { - BoundTypeImpl(StarProjectionLabel, emptyList()) - } else typeArgument.toBoundType() ?: BoundType.STAR_PROJECTION, + typeArgument?.toBoundType(owner) ?: BoundType.STAR_PROJECTION, typeParameter.variance ) } @@ -75,7 +74,8 @@ abstract class ContextCollector(private val resolutionFacade: ResolutionFacade) val typeVariable = TypeElementBasedTypeVariable( classReference, typeArguments, - typeElement.toData(), + typeElement.toData() ?: return null, + owner, state ) typeElementToTypeVariable[typeElement] = typeVariable @@ -116,6 +116,12 @@ abstract class ContextCollector(private val resolutionFacade: ResolutionFacade) val substitutors = mutableMapOf() + fun isOrAsExpression(typeReference: KtTypeReference) { + val typeElement = typeReference.typeElement ?: return + val typeVariable = typeReference.toBoundType(OtherTarget)?.typeVariable ?: return + typeElementToTypeVariable[typeElement] = typeVariable + } + for (element in elements) { element.forEachDescendantOfType { expression -> if (expression is KtCallableDeclaration @@ -124,24 +130,31 @@ abstract class ContextCollector(private val resolutionFacade: ResolutionFacade) || expression is KtNamedFunction) ) run { val typeReference = expression.typeReference ?: return@run - val typeVariable = typeReference.toBoundType()?.typeVariable ?: return@run + val typeVariable = typeReference.toBoundType( + when (expression) { + is KtParameter -> expression.getStrictParentOfType()?.let(::FunctionParameter) + is KtFunction -> FunctionReturnType(expression) + is KtProperty -> Property(expression) + else -> null + } ?: OtherTarget + )?.typeVariable ?: return@run declarationToTypeVariable[expression] = typeVariable } if (expression is KtTypeParameterListOwner) { for (typeParameter in expression.typeParameters) { - typeParameter.extendsBound?.toBoundType(defaultState = State.UPPER) + typeParameter.extendsBound?.toBoundType(OtherTarget, defaultState = State.UPPER) } for (constraint in expression.typeConstraints) { - constraint.boundTypeReference?.toBoundType(defaultState = State.UPPER) + constraint.boundTypeReference?.toBoundType(OtherTarget, defaultState = State.UPPER) } } when (expression) { - is KtClass -> { + is KtClassOrObject -> { for (entry in expression.superTypeListEntries) { for (argument in entry.typeReference?.typeElement?.typeArgumentsAsTypes ?: continue) { - argument.toBoundType() + argument.toBoundType(OtherTarget) } } val descriptor = @@ -160,7 +173,7 @@ abstract class ContextCollector(private val resolutionFacade: ResolutionFacade) } is KtCallExpression -> for (typeArgument in expression.typeArguments) { - typeArgument.typeReference?.toBoundType() + typeArgument.typeReference?.toBoundType(TypeArgument) } is KtLambdaExpression -> { val context = expression.analyze(resolutionFacade) @@ -169,10 +182,11 @@ abstract class ContextCollector(private val resolutionFacade: ResolutionFacade) declarationToTypeVariable[expression.functionLiteral] = typeVariable } is KtBinaryExpressionWithTypeRHS -> { - val typeReference = expression.right ?: return@forEachDescendantOfType - val typeElement = typeReference.typeElement ?: return@forEachDescendantOfType - val typeVariable = typeReference.toBoundType()?.typeVariable ?: return@forEachDescendantOfType - typeElementToTypeVariable[typeElement] = typeVariable + isOrAsExpression(expression.right ?: return@forEachDescendantOfType) + + } + is KtIsExpression -> { + isOrAsExpression(expression.typeReference ?: return@forEachDescendantOfType) } } } diff --git a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/DefaultStateProvider.kt b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/DefaultStateProvider.kt new file mode 100644 index 00000000000..a3973273a10 --- /dev/null +++ b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/DefaultStateProvider.kt @@ -0,0 +1,10 @@ +/* +* Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors. +* Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. +*/ + +package org.jetbrains.kotlin.nj2k.inference.common + +abstract class DefaultStateProvider { + abstract fun defaultStateFor(typeVariable: TypeVariable): State +} \ No newline at end of file diff --git a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/InferenceFacade.kt b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/InferenceFacade.kt index 3379cc6e9a9..ce99c1585b6 100644 --- a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/InferenceFacade.kt +++ b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/InferenceFacade.kt @@ -14,6 +14,7 @@ class InferenceFacade( private val constraintsCollectorAggregator: ConstraintsCollectorAggregator, private val boundTypeCalculator: BoundTypeCalculator, private val stateUpdater: StateUpdater, + private val defaultStateProvider: DefaultStateProvider, private val renderDebugTypes: Boolean = false, private val printDebugConstraints: Boolean = false ) { @@ -22,7 +23,7 @@ class InferenceFacade( val constraints = constraintsCollectorAggregator.collectConstraints(boundTypeCalculator, inferenceContext, elements) val initialConstraints = if (renderDebugTypes) constraints.map { it.copy() } else null - Solver(inferenceContext, printDebugConstraints).solveConstraints(constraints) + Solver(inferenceContext, printDebugConstraints, defaultStateProvider).solveConstraints(constraints) if (renderDebugTypes) { with(DebugPrinter(inferenceContext)) { diff --git a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/Solver.kt b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/Solver.kt index b9b603f4a74..b3009a59e24 100644 --- a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/Solver.kt +++ b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/Solver.kt @@ -5,15 +5,15 @@ package org.jetbrains.kotlin.nj2k.inference.common -import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull import org.jetbrains.kotlin.utils.addToStdlib.safeAs internal class Solver( - private val analysisContext: InferenceContext, - private val printConstraints: Boolean + private val inferenceContext: InferenceContext, + private val printConstraints: Boolean, + private val defaultStateProvider: DefaultStateProvider ) { - private val printer = DebugPrinter(analysisContext) + private val printer = DebugPrinter(inferenceContext) private fun List.printDebugInfo(step: Int) = with(printer) { @@ -24,7 +24,7 @@ internal class Solver( } println() println("type variables:") - for (typeVariable in analysisContext.typeVariables) { + for (typeVariable in inferenceContext.typeVariables) { println("${typeVariable.name} := ${typeVariable.state}") } println("---------------\n") @@ -55,9 +55,11 @@ internal class Solver( } } if (!somethingChanged) { - val typeVariable = mutableConstraints.getTypeVariableAsEqualsOrUpperBound() + val typeVariable = + mutableConstraints.getTypeVariableAsEqualsOrUpperBound() + ?: inferenceContext.typeVariables.firstOrNull { !it.isFixed } if (typeVariable != null) { - typeVariable.setStateIfNotFixed(State.LOWER) + typeVariable.setStateIfNotFixed(defaultStateProvider.defaultStateFor(typeVariable)) somethingChanged = true } } @@ -142,11 +144,11 @@ internal class Solver( val (lower, upper) = constraint if (lower is TypeVariableBound && lower.typeVariable.isFixed) { somethingChanged = true - constraint.subtype = lower.typeVariable.state.constraintBound + constraint.subtype = lower.typeVariable.state.constraintBound() } if (upper is TypeVariableBound && upper.typeVariable.isFixed) { somethingChanged = true - constraint.supertype = upper.typeVariable.state.constraintBound + constraint.supertype = upper.typeVariable.state.constraintBound() } } } @@ -166,14 +168,27 @@ internal class Solver( } - private fun List.getTypeVariableAsEqualsOrUpperBound(): TypeVariable? = - asSequence().filterIsInstance() - .map { it.supertype } - .firstIsInstanceOrNull() - ?.typeVariable - ?: asSequence().filterIsInstance() - .flatMap { sequenceOf(it.left, it.right) } - .firstIsInstanceOrNull() - ?.typeVariable + private fun List.getTypeVariableAsEqualsOrUpperBound(): TypeVariable? { + for (constraint in this) { + when (constraint) { + is SubtypeConstraint -> { + constraint.supertype.safeAs() + ?.typeVariable + ?.takeIf { defaultStateProvider.defaultStateFor(it) == State.LOWER } + ?.let { return it } + constraint.subtype.safeAs() + ?.typeVariable + ?.takeIf { defaultStateProvider.defaultStateFor(it) == State.UPPER } + ?.let { return it } + } + is EqualsConstraint -> { + (constraint.left.safeAs() + ?: constraint.right.safeAs()) + ?.let { return it.typeVariable } + } + } + } + return null + } } diff --git a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/StateUpdater.kt b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/StateUpdater.kt index 5aa0546f742..77755c99187 100644 --- a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/StateUpdater.kt +++ b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/StateUpdater.kt @@ -5,6 +5,23 @@ package org.jetbrains.kotlin.nj2k.inference.common +import org.jetbrains.kotlin.psi.psiUtil.isAncestor + abstract class StateUpdater { - abstract fun updateStates(inferenceContext: InferenceContext) + fun updateStates(inferenceContext: InferenceContext) { + if (inferenceContext.typeVariables.isEmpty()) return + + val deepComparator = Comparator { o1, o2 -> + if (o1.typeElement.typeElement.isAncestor(o2.typeElement.typeElement)) 1 else -1 + } + for (typeVariable in inferenceContext + .typeVariables + .filterIsInstance() + .sortedWith(deepComparator) + ) { + typeVariable.updateState() + } + } + + abstract fun TypeElementBasedTypeVariable.updateState() } \ No newline at end of file diff --git a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/collectors/CallExpressionConstraintCollector.kt b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/collectors/CallExpressionConstraintCollector.kt index 96e4b375f21..cabdb8cea9b 100644 --- a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/collectors/CallExpressionConstraintCollector.kt +++ b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/collectors/CallExpressionConstraintCollector.kt @@ -96,10 +96,10 @@ class CallExpressionConstraintCollector : ConstraintsCollector() { BoundTypeImpl( GenericLabel(NoClassReference),//not important as it just a primitive type emptyList() - ) else parameterBoundType.typeParameters[0].boundType + ) else parameterBoundType.typeParameters.getOrNull(0)?.boundType } else parameterBoundType - arguments.arguments.map { argument -> - parameterBoundTypeConsideringVararg to argument + arguments.arguments.mapNotNull { argument -> + parameterBoundTypeConsideringVararg?.let { it to argument } } } }.flatten() diff --git a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/typeVariables.kt b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/typeVariables.kt index b64da3f6eaa..11000630527 100644 --- a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/typeVariables.kt +++ b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/typeVariables.kt @@ -6,81 +6,61 @@ package org.jetbrains.kotlin.nj2k.inference.common import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor +import org.jetbrains.kotlin.idea.refactoring.isAbstract +import org.jetbrains.kotlin.lexer.KtTokens +import org.jetbrains.kotlin.psi.KtFunction +import org.jetbrains.kotlin.psi.KtProperty import org.jetbrains.kotlin.psi.KtTypeElement +import org.jetbrains.kotlin.psi.psiUtil.isPrivate import org.jetbrains.kotlin.types.KotlinType sealed class TypeVariable { abstract val classReference: ClassReference abstract val typeParameters: List + abstract val owner: TypeVariableOwner abstract var state: State } +sealed class TypeVariableOwner + +class FunctionParameter(val owner: KtFunction) : TypeVariableOwner() +class FunctionReturnType(val function: KtFunction) : TypeVariableOwner() +class Property(val property: KtProperty) : TypeVariableOwner() +object TypeArgument : TypeVariableOwner() +object OtherTarget : TypeVariableOwner() + + sealed class TypeElementData { abstract val typeElement: KtTypeElement + abstract val type: KotlinType } -data class TypeElementDataImpl(override val typeElement: KtTypeElement) : TypeElementData() +data class TypeElementDataImpl( + override val typeElement: KtTypeElement, + override val type: KotlinType +) : TypeElementData() + data class TypeParameterElementData( override val typeElement: KtTypeElement, + override val type: KotlinType, val typeParameterDescriptor: TypeParameterDescriptor ) : TypeElementData() -data class TypeElementBasedTypeVariable( +class TypeElementBasedTypeVariable( override val classReference: ClassReference, override val typeParameters: List, val typeElement: TypeElementData, + override val owner: TypeVariableOwner, override var state: State -) : TypeVariable() { +) : TypeVariable() - //ignore state as it is mutable - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (javaClass != other?.javaClass) return false - - other as TypeElementBasedTypeVariable - - if (classReference != other.classReference) return false - if (typeParameters != other.typeParameters) return false - if (typeElement != other.typeElement) return false - - return true - } - - override fun hashCode(): Int { - var result = classReference.hashCode() - result = 31 * result + typeParameters.hashCode() - result = 31 * result + typeElement.hashCode() - return result - } -} - -data class TypeBasedTypeVariable( +class TypeBasedTypeVariable( override val classReference: ClassReference, override val typeParameters: List, val type: KotlinType, override var state: State ) : TypeVariable() { - - //ignore state as it is mutable - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (javaClass != other?.javaClass) return false - - other as TypeBasedTypeVariable - - if (classReference != other.classReference) return false - if (typeParameters != other.typeParameters) return false - if (type != other.type) return false - - return true - } - - override fun hashCode(): Int { - var result = classReference.hashCode() - result = 31 * result + typeParameters.hashCode() - result = 31 * result + type.hashCode() - return result - } + override val owner = OtherTarget } val TypeVariable.isFixed: Boolean diff --git a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/utils.kt b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/utils.kt index 25d9d2eb1e6..e865e4c3d02 100644 --- a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/utils.kt +++ b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/common/utils.kt @@ -7,11 +7,14 @@ package org.jetbrains.kotlin.nj2k.inference.common import com.intellij.psi.PsiComment import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.nj2k.JKElementInfo -import org.jetbrains.kotlin.nj2k.JKElementInfoLabel -import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext -import org.jetbrains.kotlin.nj2k.asLabel +import org.jetbrains.kotlin.idea.refactoring.isInterfaceClass +import org.jetbrains.kotlin.lexer.KtTokens +import org.jetbrains.kotlin.nj2k.* +import org.jetbrains.kotlin.psi.KtFunction +import org.jetbrains.kotlin.psi.KtTypeElement import org.jetbrains.kotlin.psi.KtTypeProjection +import org.jetbrains.kotlin.psi.KtTypeReference +import org.jetbrains.kotlin.psi.psiUtil.containingClassOrObject import org.jetbrains.kotlin.utils.addToStdlib.safeAs fun PsiElement.getLabel(): JKElementInfoLabel? = @@ -28,3 +31,14 @@ fun PsiElement.elementInfo(converterContext: NewJ2kConverterContext): List converterContext.elementsInfoStorage.getInfoForLabel(label) } + + +private fun KtTypeReference.hasUnknownLabel(context: NewJ2kConverterContext, unknownLabel: JKElementInfo) = + getLabel()?.let { label -> + unknownLabel in context.elementsInfoStorage.getInfoForLabel(label).orEmpty() + } ?: false + +fun KtTypeElement.hasUnknownLabel(context: NewJ2kConverterContext, unknownLabel: JKElementInfo) = + parent + ?.safeAs() + ?.hasUnknownLabel(context, unknownLabel) == true diff --git a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/nullability/NullabilityConstraintBoundProvider.kt b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/nullability/NullabilityConstraintBoundProvider.kt new file mode 100644 index 00000000000..6972d0ad042 --- /dev/null +++ b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/nullability/NullabilityConstraintBoundProvider.kt @@ -0,0 +1,19 @@ +/* + * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.nj2k.inference.nullability + +import org.jetbrains.kotlin.nj2k.inference.common.* + +class NullabilityConstraintBoundProvider : ConstraintBoundProviderImpl() { + override fun BoundTypeLabel.constraintBound(): ConstraintBound? = when (this) { + is TypeVariableLabel -> typeVariable.constraintBound() + is TypeParameterLabel -> null + is GenericLabel -> null + StarProjectionLabel -> null + NullLiteralLabel -> LiteralBound.UPPER + LiteralLabel -> LiteralBound.LOWER + } +} \ No newline at end of file diff --git a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/nullability/NullabilityConstraintsCollector.kt b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/nullability/NullabilityConstraintsCollector.kt index 3876666ddd4..f8b74da320f 100644 --- a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/nullability/NullabilityConstraintsCollector.kt +++ b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/nullability/NullabilityConstraintsCollector.kt @@ -17,7 +17,7 @@ class NullabilityConstraintsCollector : ConstraintsCollector() { boundTypeCalculator: BoundTypeCalculator, inferenceContext: InferenceContext, resolutionFacade: ResolutionFacade - ) = with(boundTypeCalculator) { + ) { when { element is KtBinaryExpression && (element.left?.isNullExpression() == true @@ -50,6 +50,5 @@ class NullabilityConstraintsCollector : ConstraintsCollector() { element.right?.isTheSameTypeAs(State.LOWER, ConstraintPriority.USE_AS_RECEIVER) } } - Unit } } \ No newline at end of file diff --git a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/nullability/NullabilityContextCollector.kt b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/nullability/NullabilityContextCollector.kt index 3a28d106f3c..633b9703ef7 100644 --- a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/nullability/NullabilityContextCollector.kt +++ b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/nullability/NullabilityContextCollector.kt @@ -8,10 +8,7 @@ package org.jetbrains.kotlin.nj2k.inference.nullability import org.jetbrains.kotlin.idea.resolve.ResolutionFacade import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext import org.jetbrains.kotlin.nj2k.UnknownNullability -import org.jetbrains.kotlin.nj2k.inference.common.ClassReference -import org.jetbrains.kotlin.nj2k.inference.common.ContextCollector -import org.jetbrains.kotlin.nj2k.inference.common.State -import org.jetbrains.kotlin.nj2k.inference.common.getLabel +import org.jetbrains.kotlin.nj2k.inference.common.* import org.jetbrains.kotlin.psi.KtNullableType import org.jetbrains.kotlin.psi.KtTypeElement import org.jetbrains.kotlin.psi.KtTypeReference @@ -21,23 +18,10 @@ class NullabilityContextCollector( resolutionFacade: ResolutionFacade, private val converterContext: NewJ2kConverterContext ) : ContextCollector(resolutionFacade) { - override fun ClassReference.getState(typeElement: KtTypeElement?): State? { - val hasUndefinedNullabilityLabel = typeElement - ?.parent - ?.safeAs() - ?.hasUndefinedNullabilityLabel(converterContext) - ?: false - return when { - typeElement == null -> State.UNKNOWN - hasUndefinedNullabilityLabel -> State.UNKNOWN - typeElement is KtNullableType -> State.UPPER - else -> State.LOWER - } + override fun ClassReference.getState(typeElement: KtTypeElement?): State? = when { + typeElement == null -> State.UNKNOWN + typeElement.hasUnknownLabel(converterContext, UnknownNullability) -> State.UNKNOWN + typeElement is KtNullableType -> State.UPPER + else -> State.LOWER } - - - private fun KtTypeReference.hasUndefinedNullabilityLabel(context: NewJ2kConverterContext) = - getLabel()?.let { label -> - context.elementsInfoStorage.getInfoForLabel(label).orEmpty().contains(UnknownNullability) - } ?: false } \ No newline at end of file diff --git a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/nullability/NullabilityDefaultStateProvider.kt b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/nullability/NullabilityDefaultStateProvider.kt new file mode 100644 index 00000000000..48663337d7a --- /dev/null +++ b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/nullability/NullabilityDefaultStateProvider.kt @@ -0,0 +1,36 @@ +/* + * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.nj2k.inference.nullability + +import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor +import org.jetbrains.kotlin.idea.refactoring.isAbstract +import org.jetbrains.kotlin.lexer.KtTokens +import org.jetbrains.kotlin.nj2k.inference.common.* +import org.jetbrains.kotlin.psi.psiUtil.isPrivate + +class NullabilityDefaultStateProvider : DefaultStateProvider() { + override fun defaultStateFor(typeVariable: TypeVariable): State { + if (typeVariable is TypeElementBasedTypeVariable + && typeVariable.typeElement.type.constructor.declarationDescriptor is TypeParameterDescriptor + ) { + return State.LOWER + } + return when (val owner = typeVariable.owner) { + is FunctionParameter -> if (owner.owner.isPrivate()) State.LOWER else State.UPPER + is FunctionReturnType -> + if (owner.function.isAbstract() + || owner.function.hasModifier(KtTokens.OPEN_KEYWORD) + || owner.function.bodyExpression == null + ) State.UPPER else State.LOWER + is Property -> if (owner.property.isPrivate() + || !owner.property.isVar + || !owner.property.isLocal + ) State.LOWER else State.UPPER + is TypeArgument -> State.LOWER + OtherTarget -> State.UPPER + } + } +} \ No newline at end of file diff --git a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/nullability/NullabilityStateUpdater.kt b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/nullability/NullabilityStateUpdater.kt index e02913a234f..baa42b66b82 100644 --- a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/nullability/NullabilityStateUpdater.kt +++ b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/inference/nullability/NullabilityStateUpdater.kt @@ -12,27 +12,14 @@ import org.jetbrains.kotlin.psi.KtTypeElement import org.jetbrains.kotlin.psi.psiUtil.isAncestor class NullabilityStateUpdater : StateUpdater() { - override fun updateStates(inferenceContext: InferenceContext) { - if (inferenceContext.typeVariables.isEmpty()) return - - val deepComparator = Comparator { o1, o2 -> - if (o1.typeElement.typeElement.isAncestor(o2.typeElement.typeElement)) 1 else -1 - } - for (typeVariable in inferenceContext - .typeVariables - .filterIsInstance() - .sortedWith(deepComparator) - ) { - when (typeVariable.state) { - State.LOWER -> typeVariable.changeState(toNullable = false) - State.UPPER -> typeVariable.changeState(toNullable = true) - State.UNKNOWN -> { - if (typeVariable.typeElement is TypeParameterElementData) { - typeVariable.changeState(toNullable = false) - } else { - typeVariable.changeState(toNullable = true) - } - } + override fun TypeElementBasedTypeVariable.updateState() = when (state) { + State.LOWER -> changeState(toNullable = false) + State.UPPER -> changeState(toNullable = true) + State.UNKNOWN -> { + if (typeElement is TypeParameterElementData) { + changeState(toNullable = false) + } else { + changeState(toNullable = true) } } } diff --git a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/postProcessing/J2kPostProcessor.kt b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/postProcessing/J2kPostProcessor.kt index 3600020836d..e335b359a01 100644 --- a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/postProcessing/J2kPostProcessor.kt +++ b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/postProcessing/J2kPostProcessor.kt @@ -238,6 +238,13 @@ private val processings: List = listOf( NamedPostProcessingGroup( "Inferring declarations nullability", listOf( + InspectionLikeProcessingGroup( + processings = listOf( + VarToValProcessing(), + generalInspectionBasedProcessing(CanBeValInspection(ignoreNotUsedVals = false)) + ), + runSingleTime = true + ), nullabilityProcessing, clearUndefinedLabelsProcessing ) diff --git a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/postProcessing/processings/ConvertGettersAndSettersToPropertyProcessing.kt b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/postProcessing/processings/ConvertGettersAndSettersToPropertyProcessing.kt index 2b755ea647d..49b593aec12 100644 --- a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/postProcessing/processings/ConvertGettersAndSettersToPropertyProcessing.kt +++ b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/postProcessing/processings/ConvertGettersAndSettersToPropertyProcessing.kt @@ -23,7 +23,9 @@ import org.jetbrains.kotlin.idea.references.KtSimpleNameReference import org.jetbrains.kotlin.idea.references.mainReference import org.jetbrains.kotlin.idea.references.readWriteAccess import org.jetbrains.kotlin.idea.util.CommentSaver -import org.jetbrains.kotlin.lexer.KtModifierKeywordToken +import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers +import org.jetbrains.kotlin.j2k.getContainingClass +import org.jetbrains.kotlin.js.resolve.diagnostics.findPsi import org.jetbrains.kotlin.lexer.KtTokens import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext import org.jetbrains.kotlin.nj2k.asGetterName @@ -35,8 +37,10 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperClassNotAny import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperInterfaces import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter import org.jetbrains.kotlin.resolve.scopes.getDescriptorsFiltered +import org.jetbrains.kotlin.types.KotlinType +import org.jetbrains.kotlin.types.checker.KotlinTypeChecker +import org.jetbrains.kotlin.types.isError import org.jetbrains.kotlin.types.typeUtil.isUnit -import org.jetbrains.kotlin.types.typeUtil.makeNotNullable import org.jetbrains.kotlin.util.isJavaDescriptor import org.jetbrains.kotlin.utils.addToStdlib.cast import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull @@ -108,7 +112,6 @@ class ConvertGettersAndSettersToPropertyProcessing : ElementsBasedPostProcessing } } - private fun KtElement.forAllUsages(action: (KtElement) -> Unit) { usages().forEach { action(it.element as KtElement) } } @@ -129,13 +132,12 @@ class ConvertGettersAndSettersToPropertyProcessing : ElementsBasedPostProcessing val ktGetter = factory.createGetter(body, getter.modifiersText) ktGetter.filterModifiers() - return property.add(ktGetter).cast().let { + return property.add(ktGetter).cast().also { if (getter is RealGetter) { getter.function.forAllUsages { usage -> usage.getStrictParentOfType()!!.replace(factory.createExpression(getter.name)) } } - it } } @@ -270,9 +272,15 @@ class ConvertGettersAndSettersToPropertyProcessing : ElementsBasedPostProcessing override fun runProcessing(elements: List, converterContext: NewJ2kConverterContext) { - val classes = elements.descendantsOfType().sortedByInheritance() - for (klass in classes) { - convertClass(klass) + val classes = elements + .descendantsOfType() + .sortedByInheritance() + val collectingState = CollectingState() + val classesWithPropertiesData = classes.map { klass -> + klass to klass.collectPropertiesData(collectingState) + } + for ((klass, propertiesData) in classesWithPropertiesData) { + convertClass(klass, propertiesData) } } @@ -287,8 +295,82 @@ class ConvertGettersAndSettersToPropertyProcessing : ElementsBasedPostProcessing else -> false } - private fun KtClassOrObject.collectGettersAndSetters(factory: KtPsiFactory): List { - val classDescriptor = resolveToDescriptorIfAny() ?: return emptyList() + private fun calculatePropertyType(getterType: KotlinType?, setterType: KotlinType?): KotlinType? = when { + getterType != null && getterType.isMarkedNullable -> getterType + setterType != null && setterType.isMarkedNullable -> setterType + else -> getterType ?: setterType + } + + private fun calculatePropertyType(getter: KtNamedFunction?, setter: KtNamedFunction?): KotlinType? { + val getterType = getter?.resolveToDescriptorIfAny()?.returnType + val setterType = setter?.resolveToDescriptorIfAny()?.valueParameters?.singleOrNull()?.type + return calculatePropertyType(getterType, setterType) + } + + private fun calculatePropertyTypeBasedOnSuperDescriptors(getter: KtNamedFunction?, setter: KtNamedFunction?): KotlinType? { + val superGetterType = getter + ?.resolveToDescriptorIfAny() + ?.overriddenDescriptors + ?.firstOrNull() + ?.returnType + val superSetterType = setter + ?.resolveToDescriptorIfAny() + ?.overriddenDescriptors + ?.firstOrNull() + ?.valueParameters + ?.singleOrNull() + ?.type + return calculatePropertyType(superGetterType, superSetterType) + } + + private fun KtClassOrObject.collectPropertiesData(collectingState: CollectingState): List { + return declarations + .asSequence() + .mapNotNull { it.asPropertyAccessor() } + .groupBy { it.name.removePrefix("is").decapitalize() } + .values + .mapNotNull { group -> + val realGetter = group.firstIsInstanceOrNull() + val realSetter = group.firstIsInstanceOrNull()?.takeIf { setter -> + if (realGetter == null) return@takeIf true + val setterType = setter.function.valueParameters.first().type() + val getterType = realGetter.function.type() + if (setterType == null + || getterType == null + || !KotlinTypeChecker.DEFAULT.isSubtypeOf(getterType, setterType) + ) { + if (isInterfaceClass()) return@mapNotNull null + false + } else true + } + if (realGetter == null && realSetter == null) return@mapNotNull null + val realProperty = group.firstIsInstanceOrNull() + val name = realGetter?.name ?: realSetter?.name!! + + val superDeclarationOwner = (realGetter?.function ?: realSetter?.function) + ?.resolveToDescriptorIfAny() + ?.overriddenDescriptors + ?.firstOrNull() + ?.findPsi() + ?.safeAs() + ?.containingClassOrObject + + collectingState.propertyNameToSuperType[superDeclarationOwner to name] + val type = collectingState.propertyNameToSuperType[superDeclarationOwner to name] + ?: calculatePropertyType( + realGetter?.function, + realSetter?.function + ) ?: return@mapNotNull null + collectingState.propertyNameToSuperType[this to name] = type + PropertyData(realProperty, realGetter, realSetter, type) + } + } + + private fun List.filterGettersAndSetters( + klass: KtClassOrObject, + factory: KtPsiFactory + ): List { + val classDescriptor = klass.resolveToDescriptorIfAny() ?: return emptyList() val variablesDescriptorsMap = (listOfNotNull(classDescriptor.getSuperClassNotAny()) + classDescriptor.getSuperInterfaces()) @@ -301,153 +383,135 @@ class ConvertGettersAndSettersToPropertyProcessing : ElementsBasedPostProcessing .filterIsInstance() .associateBy { it.name.asString() } - return declarations - .asSequence() - .mapNotNull { it.asPropertyAccessor() } - .groupBy { it.name.removePrefix("is").decapitalize() } - .values - .mapNotNull { group -> - val realGetter = group.firstIsInstanceOrNull() - val realSetter = group.firstIsInstanceOrNull()?.takeIf { setter -> - if (realGetter == null) return@takeIf true - if (setter.function.valueParameters.first().type()?.makeNotNullable() != - realGetter.function.type()?.makeNotNullable() - ) { - if (isInterfaceClass()) return@mapNotNull null - false - } else true - } - val realProperty = group.firstIsInstanceOrNull() - if (realGetter == null && realSetter == null) return@mapNotNull null - val name = realGetter?.name ?: realSetter!!.name - val type = - realGetter?.function?.typeReference?.text - ?: realSetter?.function?.valueParameters?.first()?.typeReference?.text!! + return mapNotNull { (realProperty, realGetter, realSetter, type) -> + val name = realGetter?.name ?: realSetter!!.name + val typeStringified = type + .takeUnless { it.isError } + ?.let { + IdeDescriptorRenderers.SOURCE_CODE.renderType(it) + } ?: realGetter?.function?.typeReference?.text + ?: realSetter?.function?.valueParameters?.firstOrNull()?.typeReference?.text!! - if (realSetter != null - && realGetter != null - && isInterfaceClass() - && realSetter.function.hasOverrides() != realGetter.function.hasOverrides() + if (realSetter != null + && realGetter != null + && klass.isInterfaceClass() + && realSetter.function.hasOverrides() != realGetter.function.hasOverrides() + ) return@mapNotNull null + + if (realSetter != null + && realGetter != null + && realSetter.function.hasSuperFunction() != realGetter.function.hasSuperFunction() + ) return@mapNotNull null + + if (realProperty != null + && realGetter?.target != null + && realGetter.target != realProperty.property + && realProperty.property.hasInitializer() + ) return@mapNotNull null + + if (realGetter?.function?.hasInvalidSuperDescriptors() == true + || realSetter?.function?.hasInvalidSuperDescriptors() == true + ) return@mapNotNull null + + if (realProperty == null) { + if (causesNameConflictInCurrentDeclarationAndItsParents( + name, + classDescriptor.containingDeclaration + ) ) return@mapNotNull null - - if (realSetter != null - && realGetter != null - && realSetter.function.hasSuperFunction() != realGetter.function.hasSuperFunction() - ) return@mapNotNull null - - if (realProperty != null - && realGetter?.target != null - && realGetter.target != realProperty.property - && realProperty.property.hasInitializer() - ) return@mapNotNull null - - - - if (realGetter?.function?.hasInvalidSuperDescriptors() == true - || realSetter?.function?.hasInvalidSuperDescriptors() == true - ) return@mapNotNull null - - if (realProperty == null) { - if (causesNameConflictInCurrentDeclarationAndItsParents( - name, - classDescriptor.containingDeclaration - ) - ) return@mapNotNull null - } - - if (realProperty != null && (realGetter != null && realGetter.target == null || realSetter != null && realSetter.target == null)) { - if (!realProperty.property.isPrivate()) return@mapNotNull null - val hasUsages = - realProperty.property.hasUsagesOutsideOf( - containingKtFile, - listOfNotNull(realGetter?.function, realSetter?.function) - ) - if (hasUsages) return@mapNotNull null - } - - if (realSetter != null && realProperty != null) { - val assignFieldOfOtherInstance = realProperty.property.usages().any { usage -> - val element = usage.safeAs()?.element ?: return@any false - if (!element.readWriteAccess(useResolveForReadWrite = true).isWrite) return@any false - val parent = element.parent - parent is KtQualifiedExpression && !parent.receiverExpression.isReferenceToThis() - } - if (assignFieldOfOtherInstance) return@mapNotNull null - } - - - if (realGetter != null && realProperty != null) { - val getFieldOfOtherInstanceInGetter = realProperty.property.usages().any { usage -> - val element = usage.safeAs()?.element ?: return@any false - val parent = element.parent - parent is KtQualifiedExpression - && !parent.receiverExpression.isReferenceToThis() - && realGetter.function.isAncestor(element) - } - if (getFieldOfOtherInstanceInGetter) return@mapNotNull null - } - - - val getter = realGetter ?: when { - realProperty?.property?.resolveToDescriptorIfAny()?.overriddenDescriptors?.any { - it.safeAs()?.isVar == true - } == true -> FakeGetter(name, null, "") - - variablesDescriptorsMap[name]?.let { variable -> - variable.isVar && variable.containingDeclaration != classDescriptor - } == true -> - FakeGetter(name, factory.createExpression("super.$name"), "") - - else -> return@mapNotNull null - } - - val mergedProperty = - if (getter is RealGetter - && getter.target != null - && getter.target!!.name != getter.name - && (realSetter == null || realSetter.target != null) - ) { - MergedProperty(name, type, realSetter != null, getter.target!!) - } else null - - val setter = realSetter ?: when { - realProperty?.property?.isVar == true -> - FakeSetter(name, null, "") - - realProperty?.property?.resolveToDescriptorIfAny()?.overriddenDescriptors?.any { - it.safeAs()?.isVar == true - } == true - || variablesDescriptorsMap[name]?.isVar == true -> - FakeSetter( - name, - factory.createBlock("super.$name = $name"), - "" - ) - - realGetter != null - && (realProperty != null - && realProperty.property.visibilityModifierTypeOrDefault() != realGetter.function.visibilityModifierTypeOrDefault() - && realProperty.property.isVar - || mergedProperty != null - && mergedProperty.mergeTo.visibilityModifierTypeOrDefault() != realGetter.function.visibilityModifierTypeOrDefault() - && mergedProperty.mergeTo.isVar - ) -> - FakeSetter(name, null, null) - - else -> null - } - val isVar = setter != null - - val property = mergedProperty?.copy(isVar = isVar) - ?: realProperty?.copy(isVar = isVar) - ?: FakeProperty(name, type, isVar) - - PropertyWithAccessors( - property, - getter, - setter - ) } + + if (realProperty != null && (realGetter != null && realGetter.target == null || realSetter != null && realSetter.target == null)) { + if (!realProperty.property.isPrivate()) return@mapNotNull null + val hasUsages = + realProperty.property.hasUsagesOutsideOf( + klass.containingKtFile, + listOfNotNull(realGetter?.function, realSetter?.function) + ) + if (hasUsages) return@mapNotNull null + } + + if (realSetter != null && realProperty != null) { + val assignFieldOfOtherInstance = realProperty.property.usages().any { usage -> + val element = usage.safeAs()?.element ?: return@any false + if (!element.readWriteAccess(useResolveForReadWrite = true).isWrite) return@any false + val parent = element.parent + parent is KtQualifiedExpression && !parent.receiverExpression.isReferenceToThis() + } + if (assignFieldOfOtherInstance) return@mapNotNull null + } + + if (realGetter != null && realProperty != null) { + val getFieldOfOtherInstanceInGetter = realProperty.property.usages().any { usage -> + val element = usage.safeAs()?.element ?: return@any false + val parent = element.parent + parent is KtQualifiedExpression + && !parent.receiverExpression.isReferenceToThis() + && realGetter.function.isAncestor(element) + } + if (getFieldOfOtherInstanceInGetter) return@mapNotNull null + } + + + val getter = realGetter ?: when { + realProperty?.property?.resolveToDescriptorIfAny()?.overriddenDescriptors?.any { + it.safeAs()?.isVar == true + } == true -> FakeGetter(name, null, "") + + variablesDescriptorsMap[name]?.let { variable -> + variable.isVar && variable.containingDeclaration != classDescriptor + } == true -> + FakeGetter(name, factory.createExpression("super.$name"), "") + + else -> return@mapNotNull null + } + + val mergedProperty = + if (getter is RealGetter + && getter.target != null + && getter.target!!.name != getter.name + && (realSetter == null || realSetter.target != null) + ) { + MergedProperty(name, typeStringified, realSetter != null, getter.target!!) + } else null + + val setter = realSetter ?: when { + realProperty?.property?.isVar == true -> + FakeSetter(name, null, "") + + realProperty?.property?.resolveToDescriptorIfAny()?.overriddenDescriptors?.any { + it.safeAs()?.isVar == true + } == true + || variablesDescriptorsMap[name]?.isVar == true -> + FakeSetter( + name, + factory.createBlock("super.$name = $name"), + "" + ) + + realGetter != null + && (realProperty != null + && realProperty.property.visibilityModifierTypeOrDefault() != realGetter.function.visibilityModifierTypeOrDefault() + && realProperty.property.isVar + || mergedProperty != null + && mergedProperty.mergeTo.visibilityModifierTypeOrDefault() != realGetter.function.visibilityModifierTypeOrDefault() + && mergedProperty.mergeTo.isVar + ) -> + FakeSetter(name, null, null) + + else -> null + } + val isVar = setter != null + val property = mergedProperty?.copy(isVar = isVar) + ?: realProperty?.copy(isVar = isVar) + ?: FakeProperty(name, typeStringified, isVar) + + PropertyWithAccessors( + property, + getter, + setter + ) + } } private fun KtProperty.renameTo(newName: String, factory: KtPsiFactory) { @@ -466,9 +530,10 @@ class ConvertGettersAndSettersToPropertyProcessing : ElementsBasedPostProcessing setName(newName) } - private fun convertClass(klass: KtClassOrObject) { + private fun convertClass(klass: KtClassOrObject, propertiesData: List) { val factory = KtPsiFactory(klass) - val accessors = klass.collectGettersAndSetters(factory) + val accessors = propertiesData.filterGettersAndSetters(klass, factory) + for ((property, getter, setter) in accessors) { val ktProperty = when (property) { is RealProperty -> { @@ -537,6 +602,13 @@ private data class PropertyWithAccessors( val setter: Setter? ) +private data class PropertyData( + val realProperty: RealProperty?, + val realGetter: RealGetter?, + val realSetter: RealSetter?, + val type: KotlinType +) + private interface PropertyInfo { val name: String } @@ -618,6 +690,10 @@ private data class FakeSetter( get() = name.fixSetterParameterName() } +private data class CollectingState( + val propertyNameToSuperType: MutableMap, KotlinType> = mutableMapOf() +) + private fun String.fixSetterParameterName() = if (this == KtTokens.FIELD_KEYWORD.value) "value" else this diff --git a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/postProcessing/processings/ConvertToDataClassProcessing.kt b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/postProcessing/processings/ConvertToDataClassProcessing.kt index 83bb6ab578d..62f5f002583 100644 --- a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/postProcessing/processings/ConvertToDataClassProcessing.kt +++ b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/postProcessing/processings/ConvertToDataClassProcessing.kt @@ -19,6 +19,7 @@ import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.psi.psiUtil.asAssignment import org.jetbrains.kotlin.psi.psiUtil.containingClass import org.jetbrains.kotlin.psi.psiUtil.visibilityModifierTypeOrDefault +import org.jetbrains.kotlin.types.checker.KotlinTypeChecker import org.jetbrains.kotlin.utils.addToStdlib.safeAs class ConvertToDataClassProcessing : ElementsBasedPostProcessing() { @@ -64,7 +65,7 @@ class ConvertToDataClassProcessing : ElementsBasedPostProcessing() { } ?: return@map null val propertyType = property.type() ?: return@map null val parameterType = parameter.type() ?: return@map null - if (propertyType != parameterType) return@map null + if (!KotlinTypeChecker.DEFAULT.equalTypes(propertyType, parameterType)) return@map null parametersUsed += parameter ConstructorParameterInitialization(property, parameter, assignment) } diff --git a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/postProcessing/processings/inspeсtionLikeProcessings.kt b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/postProcessing/processings/inspeсtionLikeProcessings.kt index f2bb893afbe..14587686eac 100644 --- a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/postProcessing/processings/inspeсtionLikeProcessings.kt +++ b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/postProcessing/processings/inspeсtionLikeProcessings.kt @@ -40,6 +40,7 @@ import org.jetbrains.kotlin.nj2k.postProcessing.resolve import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.psi.psiUtil.* import org.jetbrains.kotlin.resolve.BindingContext +import org.jetbrains.kotlin.types.checker.KotlinTypeChecker import org.jetbrains.kotlin.types.isNullable import org.jetbrains.kotlin.utils.addToStdlib.cast import org.jetbrains.kotlin.utils.addToStdlib.safeAs @@ -55,8 +56,8 @@ class RemoveExplicitPropertyTypeProcessing : ApplicabilityBasedInspectionLikePro val initializer = element.initializer ?: return false val withoutExpectedType = initializer.analyzeInContext(initializer.getResolutionScope()).getType(initializer) ?: return false - val descriptor = element.resolveToDescriptorIfAny() as? CallableDescriptor ?: return false - return withoutExpectedType == descriptor.returnType + val typeBeDescriptor = element.resolveToDescriptorIfAny().safeAs()?.returnType ?: return false + return KotlinTypeChecker.DEFAULT.equalTypes(withoutExpectedType, typeBeDescriptor) } override fun apply(element: KtProperty) { diff --git a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/postProcessing/processings/processings.kt b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/postProcessing/processings/processings.kt index 9ae06316980..b58f3412268 100644 --- a/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/postProcessing/processings/processings.kt +++ b/nj2k/nj2k-services/src/org/jetbrains/kotlin/nj2k/postProcessing/processings/processings.kt @@ -54,6 +54,7 @@ val nullabilityProcessing = NullabilityContextCollector(resolutionFacade, converterContext), ConstraintsCollectorAggregator( resolutionFacade, + NullabilityConstraintBoundProvider(), listOf( CommonConstraintsCollector(), CallExpressionConstraintCollector(), @@ -62,7 +63,8 @@ val nullabilityProcessing = ) ), BoundTypeCalculatorImpl(resolutionFacade, NullabilityBoundTypeEnhancer(resolutionFacade)), - NullabilityStateUpdater() + NullabilityStateUpdater(), + NullabilityDefaultStateProvider() ) val elements = if (rangeMarker != null) { file.elementsInRange(rangeMarker.range ?: return@postProcessing).filterIsInstance() diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/JKElementInfoStorage.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/JKElementInfoStorage.kt index bdcba1dcb94..24710c0a60d 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/JKElementInfoStorage.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/JKElementInfoStorage.kt @@ -14,9 +14,10 @@ sealed class SuperFunctionInfo data class ExternalSuperFunctionInfo(val descriptor: FunctionDescriptor) : SuperFunctionInfo() data class InternalSuperFunctionInfo(val label: JKElementInfoLabel) : SuperFunctionInfo() -data class FunctionInfo(val originalDescriptor: FunctionDescriptor, val superFunctions: List) : JKElementInfo +data class FunctionInfo(val superFunctions: List) : JKElementInfo object UnknownNullability : JKElementInfo +object UnknownMutability : JKElementInfo inline class JKElementInfoLabel(val label: String) { fun render(): String = "/*@@$label@@*/" diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/AddElementsInfoConversion.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/AddElementsInfoConversion.kt index 1588d4ad91e..d4b60bf37d7 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/AddElementsInfoConversion.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/AddElementsInfoConversion.kt @@ -6,9 +6,14 @@ package org.jetbrains.kotlin.nj2k.conversions import com.intellij.psi.PsiMethod +import com.intellij.psi.impl.light.LightMethod +import org.jetbrains.kotlin.asJava.elements.KtLightMethod +import org.jetbrains.kotlin.descriptors.FunctionDescriptor +import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptorIfAny import org.jetbrains.kotlin.idea.caches.resolve.util.getJavaMethodDescriptor import org.jetbrains.kotlin.j2k.ast.Nullability import org.jetbrains.kotlin.js.resolve.diagnostics.findPsi +import org.jetbrains.kotlin.load.java.descriptors.JavaMethodDescriptor import org.jetbrains.kotlin.nj2k.* import org.jetbrains.kotlin.nj2k.symbols.JKUniverseMethodSymbol import org.jetbrains.kotlin.nj2k.tree.* @@ -20,7 +25,7 @@ class AddElementsInfoConversion(private val context: NewJ2kConverterContext) : R override fun applyToElement(element: JKTreeElement): JKTreeElement { when (element) { is JKTypeElement -> addInfoForTypeElement(element) - is JKKtFunction -> addInfoForFunction(element) + is JKMethod -> addInfoForFunction(element) } return recurse(element) @@ -33,24 +38,36 @@ class AddElementsInfoConversion(private val context: NewJ2kConverterContext) : R ) { context.elementsInfoStorage.addEntry(type, UnknownNullability) } + if (type.isCollectionType) { + context.elementsInfoStorage.addEntry(type, UnknownMutability) + } } } - private fun addInfoForFunction(function: JKKtFunction) { - val psiMethod = function.psi() ?: return - val descriptor = psiMethod.getJavaMethodDescriptor() ?: return - val superDescriptorsInfo = - descriptor.overriddenDescriptors.mapNotNull { superDescriptor -> - val superPsi = superDescriptor.original.findPsi() - when (val symbol = context.symbolProvider.symbolsByPsi[superPsi]) { - is JKUniverseMethodSymbol -> - InternalSuperFunctionInfo( - context.elementsInfoStorage.getOrCreateInfoForElement(symbol.target) - ) - else -> ExternalSuperFunctionInfo(superDescriptor) - } + private fun addInfoForFunction(function: JKMethod) { + val superMethods = function.superMethods() ?: return + val superDescriptorsInfo = superMethods.map { superDescriptor -> + val superPsi = superDescriptor.original.findPsi() + when (val symbol = context.symbolProvider.symbolsByPsi[superPsi]) { + is JKUniverseMethodSymbol -> + InternalSuperFunctionInfo(context.elementsInfoStorage.getOrCreateInfoForElement(symbol.target)) + else -> ExternalSuperFunctionInfo(superDescriptor) } - context.elementsInfoStorage.addEntry(function, FunctionInfo(descriptor, superDescriptorsInfo)) + } + context.elementsInfoStorage.addEntry(function, FunctionInfo(superDescriptorsInfo)) + } + + private fun JKMethod.superMethods(): Collection? { + val psiMethod = psi() ?: return null + psiMethod.getJavaMethodDescriptor()?.let { descriptor -> + return descriptor.overriddenDescriptors + } + return psiMethod.findSuperMethods().mapNotNull { superMethod -> + when (superMethod) { + is KtLightMethod -> superMethod.kotlinOrigin?.resolveToDescriptorIfAny()?.safeAs() + else -> superMethod.getJavaMethodDescriptor() + } + } } private fun JKType.forAllInnerTypes(action: (JKType) -> Unit) { diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/StaticMemberAccessConversion.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/StaticMemberAccessConversion.kt index fb419271f58..6e5570f9900 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/StaticMemberAccessConversion.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/StaticMemberAccessConversion.kt @@ -23,6 +23,7 @@ import org.jetbrains.kotlin.psi.KtClassOrObject import org.jetbrains.kotlin.psi.KtElement import org.jetbrains.kotlin.psi.KtObjectDeclaration import org.jetbrains.kotlin.psi.psiUtil.containingClass +import org.jetbrains.kotlin.psi.psiUtil.getParentOfType import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType import org.jetbrains.kotlin.utils.addToStdlib.safeAs @@ -47,14 +48,13 @@ class StaticMemberAccessConversion(private val context: NewJ2kConverterContext) ) } return recurse(element) - } private fun JKSymbol.isStaticMember(): Boolean { val target = target return when (target) { is PsiModifierListOwner -> target.hasModifier(JvmModifier.STATIC) - is KtElement -> target.parentOfType() + is KtElement -> target.getStrictParentOfType() ?.safeAs() ?.isCompanion() == true is JKTreeElement -> diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/TypeMappingConversion.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/TypeMappingConversion.kt index b1620ac35b9..35b5cf7c5ab 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/TypeMappingConversion.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/TypeMappingConversion.kt @@ -22,17 +22,6 @@ import org.jetbrains.kotlin.nj2k.tree.* import org.jetbrains.kotlin.nj2k.tree.impl.* class TypeMappingConversion(val context: NewJ2kConverterContext) : RecursiveApplicableConversionBase() { - private val typeFlavorCalculator = TypeFlavorCalculator(object : TypeFlavorConverterFacade { - override val referenceSearcher: ReferenceSearcher - get() = context.converter.converterServices.oldServices.referenceSearcher - override val javaDataFlowAnalyzerFacade: JavaDataFlowAnalyzerFacade - get() = context.converter.converterServices.oldServices.javaDataFlowAnalyzerFacade - override val resolverForConverter: ResolverForConverter - get() = context.converter.converterServices.oldServices.resolverForConverter - - override fun inConversionScope(element: PsiElement): Boolean = context.inConversionContext(element) - }) - override fun applyToElement(element: JKTreeElement): JKTreeElement { return when (element) { is JKTypeElement -> { @@ -62,8 +51,7 @@ class TypeMappingConversion(val context: NewJ2kConverterContext) : RecursiveAppl } ) } - val typeParametersCount = classSymbol.expectedTypeParametersCount() - return when (typeParametersCount) { + return when (val typeParametersCount = classSymbol.expectedTypeParametersCount()) { 0 -> this else -> JKTypeArgumentListImpl(List(typeParametersCount) { JKTypeElementImpl( @@ -124,7 +112,7 @@ class TypeMappingConversion(val context: NewJ2kConverterContext) : RecursiveAppl private fun JKClassSymbol.mapClassSymbol(typeElement: JKTypeElement?): JKClassSymbol { if (this is JKUniverseClassSymbol) return this - val newFqName = typeElement?.let { kotlinCollectionClassName(it) } + val newFqName = kotlinCollectionClassName() ?: kotlinStandardType() ?: fqName return context.symbolProvider.provideClassSymbol(newFqName) @@ -137,12 +125,8 @@ class TypeMappingConversion(val context: NewJ2kConverterContext) : RecursiveAppl nullability ) - - private fun JKClassSymbol.kotlinCollectionClassName(typeElement: JKTypeElement?): String? { - val isStructureMutable = calculateStructureMutability(typeElement) - return if (isStructureMutable) toKotlinMutableTypesMap[fqName] - else toKotlinTypesMap[fqName] - } + private fun JKClassSymbol.kotlinCollectionClassName(): String? = + toKotlinMutableTypesMap[fqName] private fun JKClassSymbol.kotlinStandardType(): String? { if (isKtFunction(fqName)) return fqName @@ -157,16 +141,6 @@ class TypeMappingConversion(val context: NewJ2kConverterContext) : RecursiveAppl ) } - private fun calculateStructureMutability(typeElement: JKTypeElement?): Boolean { - val parent = typeElement?.parent ?: return false - val psi = parent.psi ?: return false - return when (parent) { - is JKVariable -> typeFlavorCalculator.variableMutability(psi as PsiVariable) == Mutability.Mutable - is JKMethod -> typeFlavorCalculator.methodMutability(psi as PsiMethod) == Mutability.Mutable - else -> false - } - } - companion object { private val ktFunctionRegex = "kotlin\\.jvm\\.functions\\.Function\\d+".toRegex() private fun isKtFunction(fqName: String) = diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/typesUtils.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/typesUtils.kt index fde74d94d82..f0e4c99001d 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/typesUtils.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/typesUtils.kt @@ -357,11 +357,12 @@ fun JKType.arrayFqName(): String = else KotlinBuiltIns.FQ_NAMES.array.asString() fun JKClassSymbol.isArrayType(): Boolean = - fqName in - JKJavaPrimitiveTypeImpl.KEYWORD_TO_INSTANCE.values - .filterIsInstance() - .map { PrimitiveType.valueOf(it.jvmPrimitiveType.name).arrayTypeFqName.asString() } + - KotlinBuiltIns.FQ_NAMES.array.asString() + fqName in arrayFqNames + +private val arrayFqNames = JKJavaPrimitiveTypeImpl.KEYWORD_TO_INSTANCE.values + .filterIsInstance() + .map { PrimitiveType.valueOf(it.jvmPrimitiveType.name).arrayTypeFqName.asString() } + + KotlinBuiltIns.FQ_NAMES.array.asString() fun JKType.isArrayType() = when (this) { @@ -370,6 +371,18 @@ fun JKType.isArrayType() = else -> false } +val JKType.isCollectionType: Boolean + get() = safeAs()?.classReference?.fqName in collectionFqNames + +private val collectionFqNames = setOf( + KotlinBuiltIns.FQ_NAMES.mutableIterator.asString(), + KotlinBuiltIns.FQ_NAMES.mutableList.asString(), + KotlinBuiltIns.FQ_NAMES.mutableCollection.asString(), + KotlinBuiltIns.FQ_NAMES.mutableSet.asString(), + KotlinBuiltIns.FQ_NAMES.mutableMap.asString(), + KotlinBuiltIns.FQ_NAMES.mutableMapEntry.asString(), + KotlinBuiltIns.FQ_NAMES.mutableListIterator.asString() +) fun JKType.arrayInnerType(): JKType? = when (this) { diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/utils.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/utils.kt index c85e5307d6f..2e9571b4214 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/utils.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/utils.kt @@ -32,6 +32,10 @@ fun String.asSetterName() = ?.decapitalize() ?.escaped() +fun String.isPossiblyGetterOrSetterName() = + asGetterName() != null || asSetterName() != null + + private val KEYWORDS = KtTokens.KEYWORDS.types.map { (it as KtKeywordToken).value }.toSet() fun String.escaped() = diff --git a/nj2k/testData/inference/nullability/arrayOfArraysOfNull.kt b/nj2k/testData/inference/nullability/arrayOfArraysOfNull.kt index aeafeb6499d..5c973579def 100644 --- a/nj2k/testData/inference/nullability/arrayOfArraysOfNull.kt +++ b/nj2k/testData/inference/nullability/arrayOfArraysOfNull.kt @@ -1,6 +1,6 @@ class Test { fun foo() { - val ss = Array>(5/*LIT*/, { arrayOfNulls(5/*LIT*/)/*Array!!L*/ }/*Function0>!!L*/) + val ss = Array>(5/*LIT*/, { arrayOfNulls(5/*LIT*/)/*Array!!L*/ }/*Function0>!!L*/) } } diff --git a/nj2k/testData/inference/nullability/arrayOfNulls.kt b/nj2k/testData/inference/nullability/arrayOfNulls.kt index 6cdaa3c406d..c0bb60408cb 100644 --- a/nj2k/testData/inference/nullability/arrayOfNulls.kt +++ b/nj2k/testData/inference/nullability/arrayOfNulls.kt @@ -1,5 +1,5 @@ fun test() { - val x: /*T2@*/Array = arrayOfNulls(10/*LIT*/)/*Array!!L*/ + val x: /*T2@*/Array = arrayOfNulls(10/*LIT*/)/*Array!!L*/ } //T1 := UPPER due to 'INITIALIZER' diff --git a/nj2k/testData/inference/nullability/classTypeParameters.kt b/nj2k/testData/inference/nullability/classTypeParameters.kt index 831d5abfaba..cef214684b5 100644 --- a/nj2k/testData/inference/nullability/classTypeParameters.kt +++ b/nj2k/testData/inference/nullability/classTypeParameters.kt @@ -1,5 +1,5 @@ open class A { - open fun foo(): /*T3@*/Map>? { + open fun foo(): /*T3@*/Map?>? { TODO() } @@ -9,7 +9,7 @@ open class A { } class B : A() { - override fun foo(): /*T8@*/Map>? { + override fun foo(): /*T8@*/Map?>? { return null/*NULL!!U*/ } override fun bar(): /*T9@*/Int { diff --git a/nj2k/testData/inference/nullability/forcedNullability.kt b/nj2k/testData/inference/nullability/forcedNullability.kt index 4cd230b1111..a5ae26dcdc2 100644 --- a/nj2k/testData/inference/nullability/forcedNullability.kt +++ b/nj2k/testData/inference/nullability/forcedNullability.kt @@ -1,4 +1,4 @@ -fun b(m: /*T2@*/Map): /*T3@*/String? { +fun b(m: /*T2@*/Map): /*T3@*/String? { return m/*T2@Map*/.get(42/*LIT*/)/*T1@String!!U*/ } diff --git a/nj2k/testData/inference/nullability/functionTypeParameterNullability.kt b/nj2k/testData/inference/nullability/functionTypeParameterNullability.kt index 159dde46e1d..ea82d1e54a0 100644 --- a/nj2k/testData/inference/nullability/functionTypeParameterNullability.kt +++ b/nj2k/testData/inference/nullability/functionTypeParameterNullability.kt @@ -1,4 +1,4 @@ -fun foo(x: /*T0@*/T, y: /*T2@*/List, z: /*T4@*/List, a: /*T5@*/S) {} +fun foo(x: /*T0@*/T, y: /*T2@*/List?, z: /*T4@*/List?, a: /*T5@*/S) {} fun bar() { val lst: /*T8@*/List = listOf(null/*NULL!!U*/)/*List!!L*/ diff --git a/nj2k/testData/inference/nullability/functions.kt b/nj2k/testData/inference/nullability/functions.kt index f1735e78c4e..667f7a15a2e 100644 --- a/nj2k/testData/inference/nullability/functions.kt +++ b/nj2k/testData/inference/nullability/functions.kt @@ -1,6 +1,6 @@ -fun notNullParameters(f: /*T3@*/Function2) {} -fun nullableParameter(f: /*T7@*/Function2) {} -fun nullableReturnType(f: /*T11@*/Function2) {} +fun notNullParameters(f: /*T3@*/Function2?) {} +fun nullableParameter(f: /*T7@*/Function2?) {} +fun nullableReturnType(f: /*T11@*/Function2?) {} fun test() { @@ -8,11 +8,11 @@ fun test() { if (i/*T12@Int*/ < 10/*LIT*//*LIT*/ && j/*T13@Int*/ > 0/*LIT*//*LIT*//*LIT*/) ""/*LIT*/ else ""/*LIT*/ }/*Function2!!L*/) - nullableParameter({ i: /*T14@*/Int?, j: /*T15@*/Int -> + nullableParameter({ i: /*T14@*/Int?, j: /*T15@*/Int? -> if (i/*T14@Int*/ == null/*LIT*/) ""/*LIT*/ else ""/*LIT*/ }/*Function2!!L*/) - nullableReturnType({ i: /*T16@*/Int, j: /*T17@*/Int -> + nullableReturnType({ i: /*T16@*/Int, j: /*T17@*/Int? -> if (i/*T16@Int*/ < 10/*LIT*//*LIT*/) return@nullableReturnType null/*NULL!!U*/ return@nullableReturnType "nya"/*LIT*/ }/*Function2!!L*/) diff --git a/nj2k/testData/inference/nullability/javaStream.kt b/nj2k/testData/inference/nullability/javaStream.kt index c4cacc4ccdc..ce251548442 100644 --- a/nj2k/testData/inference/nullability/javaStream.kt +++ b/nj2k/testData/inference/nullability/javaStream.kt @@ -7,7 +7,7 @@ import java.util.stream.Stream fun test(list: /*T1@*/List) { val x: /*T9@*/List = list/*T1@List*/.stream()/*Stream!!L*/ .map({ x: /*T2@*/String -> x/*T2@String*/ + ""/*LIT*//*LIT*/ }/*Function1!!L*/)/*Stream*/ - .collect, /*T7@*/Any?>(Collectors/*LIT*/.toList()/*Collector>*/)/*T6@List*/ + .collect, /*T7@*/Any>(Collectors/*LIT*/.toList()/*Collector>*/)/*T6@List*/ } diff --git a/nj2k/testData/inference/nullability/lambdaReturnNull.kt b/nj2k/testData/inference/nullability/lambdaReturnNull.kt index 1266ee5a484..901cd74d6e0 100644 --- a/nj2k/testData/inference/nullability/lambdaReturnNull.kt +++ b/nj2k/testData/inference/nullability/lambdaReturnNull.kt @@ -1,7 +1,7 @@ class Test { - fun foo1(r: /*T2@*/Function1) {} + fun foo1(r: /*T2@*/Function1?) {} fun foo() { - foo1({ x: /*T3@*/Int -> ""/*LIT*/ }/*Function1!!L*/) + foo1({ x: /*T3@*/Int? -> ""/*LIT*/ }/*Function1!!L*/) foo1({ i: /*T4@*/Int -> if (i/*T4@Int*/ > 1/*LIT*//*LIT*/) { return@foo1 null/*NULL!!U*/ diff --git a/nj2k/testData/inference/nullability/loopIterator.kt b/nj2k/testData/inference/nullability/loopIterator.kt index 5d9e0d7d0c1..b205d62cae1 100644 --- a/nj2k/testData/inference/nullability/loopIterator.kt +++ b/nj2k/testData/inference/nullability/loopIterator.kt @@ -1,5 +1,5 @@ -fun test(a: /*T1@*/List) { - for (i: /*T2@*/Int in a/*T1@List*/) { +fun test(a: /*T1@*/List) { + for (i: /*T2@*/Int? in a/*T1@List*/) { } } diff --git a/nj2k/testData/inference/nullability/loops.kt b/nj2k/testData/inference/nullability/loops.kt index bd5b7f83511..661c1bc2a6e 100644 --- a/nj2k/testData/inference/nullability/loops.kt +++ b/nj2k/testData/inference/nullability/loops.kt @@ -1,4 +1,4 @@ -fun bar(map: /*T2@*/HashMap, list1: /*T4@*/List, list2: /*T6@*/List) { +fun bar(map: /*T2@*/HashMap, list1: /*T4@*/List, list2: /*T6@*/List) { for (entry: /*T9@*/MutableMap.MutableEntry in map/*T2@HashMap*/.entries/*MutableSet>*/) { val value: /*T10@*/Int = entry/*T9@MutableEntry*/.value/*T8@Int*/ if (entry/*T9@MutableEntry*/.key/*T7@String*/ == null/*LIT*/) { diff --git a/nj2k/testData/inference/nullability/sequenceOfCallsWIthLambda.kt b/nj2k/testData/inference/nullability/sequenceOfCallsWIthLambda.kt index fdb89826498..292b29206ab 100644 --- a/nj2k/testData/inference/nullability/sequenceOfCallsWIthLambda.kt +++ b/nj2k/testData/inference/nullability/sequenceOfCallsWIthLambda.kt @@ -1,7 +1,7 @@ fun a(lst: /*T1@*/List) { val newList: /*T8@*/List = lst/*T1@List*/ .asSequence()/*Sequence!!L*/ - .map({ x: /*T3@*/String -> 1/*LIT*/ }/*Function1!!L*/)/*Sequence!!L*/ + .map({ x: /*T3@*/String? -> 1/*LIT*/ }/*Function1!!L*/)/*Sequence!!L*/ .toList()/*List!!L*/ } diff --git a/nj2k/testData/inference/nullability/typeParametersReturnType.kt b/nj2k/testData/inference/nullability/typeParametersReturnType.kt index 692c9878cee..8cd896a1d8d 100644 --- a/nj2k/testData/inference/nullability/typeParametersReturnType.kt +++ b/nj2k/testData/inference/nullability/typeParametersReturnType.kt @@ -1,5 +1,5 @@ open class A { - open fun foo(): /*T3@*/Map> { + open fun foo(): /*T3@*/Map?>? { TODO() } @@ -9,7 +9,7 @@ open class A { } class B : A() { - override fun foo(): /*T8@*/Map> { + override fun foo(): /*T8@*/Map?>? { TODO() } } diff --git a/nj2k/testData/inference/nullability/typeParametersValueParams.kt b/nj2k/testData/inference/nullability/typeParametersValueParams.kt index e548d8b5fc4..baad1816a0d 100644 --- a/nj2k/testData/inference/nullability/typeParametersValueParams.kt +++ b/nj2k/testData/inference/nullability/typeParametersValueParams.kt @@ -1,11 +1,11 @@ open class A { - open fun foo(x: /*T1@*/List, y: /*T2@*/Boolean, z: /*T3@*/T) { + open fun foo(x: /*T1@*/List?, y: /*T2@*/Boolean?, z: /*T3@*/T) { TODO() } } -class B : A() { - override fun foo(x: /*T5@*/List, y: /*T6@*/Boolean, z: /*T7@*/Int) { +class B : A() { + override fun foo(x: /*T5@*/List?, y: /*T6@*/Boolean?, z: /*T7@*/Int?) { TODO() } } diff --git a/nj2k/testData/newJ2k/anonymousClass/kt-13146.kt b/nj2k/testData/newJ2k/anonymousClass/kt-13146.kt index d6c30503f90..5004f2bbd44 100644 --- a/nj2k/testData/newJ2k/anonymousClass/kt-13146.kt +++ b/nj2k/testData/newJ2k/anonymousClass/kt-13146.kt @@ -15,7 +15,7 @@ class Test2 { } class Handler { - fun postDelayed(r: Runnable, time: Long) {} + fun postDelayed(r: Runnable?, time: Long) {} } class Test3 { diff --git a/nj2k/testData/newJ2k/arrayInitializerExpression/objectArrayWithLength.kt b/nj2k/testData/newJ2k/arrayInitializerExpression/objectArrayWithLength.kt index fa6abe5123e..91ced175767 100644 --- a/nj2k/testData/newJ2k/arrayInitializerExpression/objectArrayWithLength.kt +++ b/nj2k/testData/newJ2k/arrayInitializerExpression/objectArrayWithLength.kt @@ -1 +1 @@ -val a = arrayOfNulls(10) \ No newline at end of file +val a = arrayOfNulls(10) \ No newline at end of file diff --git a/nj2k/testData/newJ2k/arrayType/arrayInitializationStatementWithDimension.kt b/nj2k/testData/newJ2k/arrayType/arrayInitializationStatementWithDimension.kt index 239e170a566..1462d0c46d1 100644 --- a/nj2k/testData/newJ2k/arrayType/arrayInitializationStatementWithDimension.kt +++ b/nj2k/testData/newJ2k/arrayType/arrayInitializationStatementWithDimension.kt @@ -1 +1 @@ -val d2 = arrayOfNulls(5) \ No newline at end of file +val d2 = arrayOfNulls(5) \ No newline at end of file diff --git a/nj2k/testData/newJ2k/arrayType/arrayInitializationStatementWithDimension3d.kt b/nj2k/testData/newJ2k/arrayType/arrayInitializationStatementWithDimension3d.kt index d8bb9a288d4..093ca6d2767 100644 --- a/nj2k/testData/newJ2k/arrayType/arrayInitializationStatementWithDimension3d.kt +++ b/nj2k/testData/newJ2k/arrayType/arrayInitializationStatementWithDimension3d.kt @@ -1 +1 @@ -val d3 = Array(5) { arrayOfNulls(5) } \ No newline at end of file +val d3 = Array(5) { arrayOfNulls(5) } \ No newline at end of file diff --git a/nj2k/testData/newJ2k/arrayType/d2StringEmptyArray.kt b/nj2k/testData/newJ2k/arrayType/d2StringEmptyArray.kt index 71e6c99097d..2e6c644d5eb 100644 --- a/nj2k/testData/newJ2k/arrayType/d2StringEmptyArray.kt +++ b/nj2k/testData/newJ2k/arrayType/d2StringEmptyArray.kt @@ -1 +1 @@ -val ss = Array(5) { arrayOfNulls(5) } \ No newline at end of file +val ss = Array(5) { arrayOfNulls(5) } \ No newline at end of file diff --git a/nj2k/testData/newJ2k/arrayType/d3StringEmptyArray.kt b/nj2k/testData/newJ2k/arrayType/d3StringEmptyArray.kt index d563126920f..a465fbe3c1b 100644 --- a/nj2k/testData/newJ2k/arrayType/d3StringEmptyArray.kt +++ b/nj2k/testData/newJ2k/arrayType/d3StringEmptyArray.kt @@ -1 +1 @@ -val sss = Array(5) { Array(5) { arrayOfNulls(5) } } \ No newline at end of file +val sss = Array(5) { Array(5) { arrayOfNulls(5) } } \ No newline at end of file diff --git a/nj2k/testData/newJ2k/boxedType/kt-671.kt b/nj2k/testData/newJ2k/boxedType/kt-671.kt index d3ab3327326..c6936f66b6a 100644 --- a/nj2k/testData/newJ2k/boxedType/kt-671.kt +++ b/nj2k/testData/newJ2k/boxedType/kt-671.kt @@ -1,6 +1,6 @@ internal class Test { fun test() { - val i: Int? = Integer.valueOf(100) + val i = Integer.valueOf(100) val s: Short = 3 val ss = s } diff --git a/nj2k/testData/newJ2k/class/ClassShadowing.kt b/nj2k/testData/newJ2k/class/ClassShadowing.kt index 3a73aeb2f92..deba2914b12 100644 --- a/nj2k/testData/newJ2k/class/ClassShadowing.kt +++ b/nj2k/testData/newJ2k/class/ClassShadowing.kt @@ -1,8 +1,8 @@ package test -class Integer(s: String) { +class Integer(s: String?) { companion object { - fun valueOf(value: String): Integer { + fun valueOf(value: String?): Integer { return Integer(value) } } diff --git a/nj2k/testData/newJ2k/class/classWithEmptyMethods.kt b/nj2k/testData/newJ2k/class/classWithEmptyMethods.kt index 253df7668b5..59aaee9cf53 100644 --- a/nj2k/testData/newJ2k/class/classWithEmptyMethods.kt +++ b/nj2k/testData/newJ2k/class/classWithEmptyMethods.kt @@ -1,5 +1,5 @@ internal class T { fun main() {} fun i(): Int {} - fun s(): String? {} + fun s(): String {} } \ No newline at end of file diff --git a/nj2k/testData/newJ2k/class/kt-639.kt b/nj2k/testData/newJ2k/class/kt-639.kt index 44f7056b18c..f8928cdfd62 100644 --- a/nj2k/testData/newJ2k/class/kt-639.kt +++ b/nj2k/testData/newJ2k/class/kt-639.kt @@ -4,7 +4,7 @@ import java.util.HashMap internal class Test { constructor() {} - constructor(s: String) {} + constructor(s: String?) {} } internal class User { diff --git a/nj2k/testData/newJ2k/constructors/fieldsInitializedFromParams8.kt b/nj2k/testData/newJ2k/constructors/fieldsInitializedFromParams8.kt index 8fcb8ff6322..f10e368f5dc 100644 --- a/nj2k/testData/newJ2k/constructors/fieldsInitializedFromParams8.kt +++ b/nj2k/testData/newJ2k/constructors/fieldsInitializedFromParams8.kt @@ -1,2 +1,2 @@ -internal open class Base(o: Any, l: Int) +internal open class Base(o: Any?, l: Int) internal class C(private val string: String) : Base(string, string.length) \ No newline at end of file diff --git a/nj2k/testData/newJ2k/constructors/nestedClassNameInParameterDefaults.kt b/nj2k/testData/newJ2k/constructors/nestedClassNameInParameterDefaults.kt index a559029bb51..3abf416f367 100644 --- a/nj2k/testData/newJ2k/constructors/nestedClassNameInParameterDefaults.kt +++ b/nj2k/testData/newJ2k/constructors/nestedClassNameInParameterDefaults.kt @@ -1,8 +1,6 @@ -internal class A @JvmOverloads constructor(nested: Nested = Nested(Nested.FIELD)) { - +internal class A @JvmOverloads constructor(nested: Nested? = Nested(Nested.FIELD)) { internal class Nested(p: Int) { companion object { - const val FIELD = 0 } } diff --git a/nj2k/testData/newJ2k/constructors/nestedClassNameInParameterDefaults2.kt b/nj2k/testData/newJ2k/constructors/nestedClassNameInParameterDefaults2.kt index 5d9d368d9ec..fd08f307eea 100644 --- a/nj2k/testData/newJ2k/constructors/nestedClassNameInParameterDefaults2.kt +++ b/nj2k/testData/newJ2k/constructors/nestedClassNameInParameterDefaults2.kt @@ -1,6 +1,6 @@ import A.Nested -internal class A @JvmOverloads constructor(nested: Nested = Nested(Nested.FIELD)) { +internal class A @JvmOverloads constructor(nested: Nested? = Nested(Nested.FIELD)) { internal class Nested(p: Int) { companion object { const val FIELD = 0 diff --git a/nj2k/testData/newJ2k/constructors/nestedClassNameInParameterDefaults3.kt b/nj2k/testData/newJ2k/constructors/nestedClassNameInParameterDefaults3.kt index d6f8f39dfbb..4cd1863bb14 100644 --- a/nj2k/testData/newJ2k/constructors/nestedClassNameInParameterDefaults3.kt +++ b/nj2k/testData/newJ2k/constructors/nestedClassNameInParameterDefaults3.kt @@ -2,7 +2,7 @@ package pack import pack.A.Nested -internal class A @JvmOverloads constructor(nested: Nested = Nested(Nested.FIELD)) { +internal class A @JvmOverloads constructor(nested: Nested? = Nested(Nested.FIELD)) { internal class Nested(p: Int) { companion object { const val FIELD = 0 diff --git a/nj2k/testData/newJ2k/constructors/nestedClassNameInParameterDefaults4.kt b/nj2k/testData/newJ2k/constructors/nestedClassNameInParameterDefaults4.kt index d6f8f39dfbb..4cd1863bb14 100644 --- a/nj2k/testData/newJ2k/constructors/nestedClassNameInParameterDefaults4.kt +++ b/nj2k/testData/newJ2k/constructors/nestedClassNameInParameterDefaults4.kt @@ -2,7 +2,7 @@ package pack import pack.A.Nested -internal class A @JvmOverloads constructor(nested: Nested = Nested(Nested.FIELD)) { +internal class A @JvmOverloads constructor(nested: Nested? = Nested(Nested.FIELD)) { internal class Nested(p: Int) { companion object { const val FIELD = 0 diff --git a/nj2k/testData/newJ2k/constructors/nestedClassNameInSuperParameters.kt b/nj2k/testData/newJ2k/constructors/nestedClassNameInSuperParameters.kt index 3f6f4d3ca39..d8143794497 100644 --- a/nj2k/testData/newJ2k/constructors/nestedClassNameInSuperParameters.kt +++ b/nj2k/testData/newJ2k/constructors/nestedClassNameInSuperParameters.kt @@ -1,4 +1,4 @@ -internal open class Base(nested: Nested) { +internal open class Base(nested: Nested?) { internal class Nested(p: Int) { companion object { const val FIELD = 0 diff --git a/nj2k/testData/newJ2k/constructors/withManyDefaultParams.kt b/nj2k/testData/newJ2k/constructors/withManyDefaultParams.kt index 06bd6dcb715..1dfe08d907c 100644 --- a/nj2k/testData/newJ2k/constructors/withManyDefaultParams.kt +++ b/nj2k/testData/newJ2k/constructors/withManyDefaultParams.kt @@ -10,14 +10,12 @@ class Test { protected var g = 0.toChar() constructor() {} - - constructor(name: String) { + constructor(name: String?) { myName = foo(name) } companion object { - - internal fun foo(n: String): String { + internal fun foo(n: String?): String { return "" } } diff --git a/nj2k/testData/newJ2k/equals/Equals3.kt b/nj2k/testData/newJ2k/equals/Equals3.kt index dcf03ae53a1..23a0448b0d2 100644 --- a/nj2k/testData/newJ2k/equals/Equals3.kt +++ b/nj2k/testData/newJ2k/equals/Equals3.kt @@ -1,9 +1,9 @@ internal class C { - fun equals(c: C): Boolean { + fun equals(c: C?): Boolean { return false } - fun foo(c1: C, c2: C): Boolean { + fun foo(c1: C, c2: C?): Boolean { return c1.equals(c2) } } \ No newline at end of file diff --git a/nj2k/testData/newJ2k/for/forThroughListIndices.kt b/nj2k/testData/newJ2k/for/forThroughListIndices.kt index 45bd0422a63..951a236e2ed 100644 --- a/nj2k/testData/newJ2k/for/forThroughListIndices.kt +++ b/nj2k/testData/newJ2k/for/forThroughListIndices.kt @@ -1,13 +1,13 @@ import java.util.ArrayList internal class C { - fun foo1(list: MutableList) { + fun foo1(list: MutableList) { for (i in list.indices) { list[i] = "a" } } - fun foo2(list: ArrayList) { + fun foo2(list: ArrayList) { for (i in list.indices) { list[i] = "a" } diff --git a/nj2k/testData/newJ2k/for/forThroughListIndicesNE.kt b/nj2k/testData/newJ2k/for/forThroughListIndicesNE.kt index c2deef97320..2a685dcf00a 100644 --- a/nj2k/testData/newJ2k/for/forThroughListIndicesNE.kt +++ b/nj2k/testData/newJ2k/for/forThroughListIndicesNE.kt @@ -1,5 +1,5 @@ internal class C { - fun foo(list: MutableList) { + fun foo(list: MutableList) { for (i in list.indices) { list[i] = "a" } diff --git a/nj2k/testData/newJ2k/foreachStatement/nullableIterable.kt b/nj2k/testData/newJ2k/foreachStatement/nullableIterable.kt index d4d67bf62bd..b581811b0a1 100644 --- a/nj2k/testData/newJ2k/foreachStatement/nullableIterable.kt +++ b/nj2k/testData/newJ2k/foreachStatement/nullableIterable.kt @@ -1,5 +1,5 @@ internal class A { - var list: List? = null + var list: List? = null fun foo() { for (e in list!!) { println(e) diff --git a/nj2k/testData/newJ2k/function/classGenericParam.kt b/nj2k/testData/newJ2k/function/classGenericParam.kt index 5c47fe00f30..dd57294db6b 100644 --- a/nj2k/testData/newJ2k/function/classGenericParam.kt +++ b/nj2k/testData/newJ2k/function/classGenericParam.kt @@ -1,2 +1,2 @@ -val t: T? +val t: T get() {} \ No newline at end of file diff --git a/nj2k/testData/newJ2k/function/externalKtFunctionalInterface.kt b/nj2k/testData/newJ2k/function/externalKtFunctionalInterface.kt index d8b53b259eb..b62cc818d64 100644 --- a/nj2k/testData/newJ2k/function/externalKtFunctionalInterface.kt +++ b/nj2k/testData/newJ2k/function/externalKtFunctionalInterface.kt @@ -11,6 +11,6 @@ internal class Test { fun nya(): Double { //TODO explicitlly call apply here - return foo(1, FunctionalI { x: Int -> this.toDouble(x) }) + return foo(1, FunctionalI { x: Int -> this.toDouble(x) }) } } \ No newline at end of file diff --git a/nj2k/testData/newJ2k/function/internalFunctionalInterface.kt b/nj2k/testData/newJ2k/function/internalFunctionalInterface.kt index e084777bac0..ed4c3c606dc 100644 --- a/nj2k/testData/newJ2k/function/internalFunctionalInterface.kt +++ b/nj2k/testData/newJ2k/function/internalFunctionalInterface.kt @@ -14,6 +14,6 @@ internal class Test { } fun nya(): Double { - return foo(1, FunctionalI { x: A -> this.toDouble(x) }) + return foo(1, FunctionalI { x: A -> this.toDouble(x) }) } } \ No newline at end of file diff --git a/nj2k/testData/newJ2k/function/java8Lambdas.kt b/nj2k/testData/newJ2k/function/java8Lambdas.kt index 34120b0b315..23ca53ab2f4 100644 --- a/nj2k/testData/newJ2k/function/java8Lambdas.kt +++ b/nj2k/testData/newJ2k/function/java8Lambdas.kt @@ -1,7 +1,7 @@ class Java8Class { - fun foo0(r: Function0) {} - fun foo1(r: Function1) {} - fun foo2(r: Function2) {} + fun foo0(r: Function0?) {} + fun foo1(r: Function1?) {} + fun foo2(r: Function2?) {} fun helper() {} fun foo() { foo0 { "42" } @@ -10,8 +10,8 @@ class Java8Class { helper() "42" } - foo1 { i: Int -> "42" } - foo1 { i: Int -> "42" } + foo1 { i: Int? -> "42" } + foo1 { i: Int? -> "42" } foo1 { i: Int -> helper() if (i > 1) { @@ -19,12 +19,12 @@ class Java8Class { } "43" } - foo2 { i: Int, j: Int -> "42" } - foo2 { i: Int, j: Int -> + foo2 { i: Int?, j: Int? -> "42" } + foo2 { i: Int?, j: Int? -> helper() "42" } - val f = label@{ i: Int, k: Int -> + val f: Function2 = label@{ i: Int, k: Int? -> helper() if (i > 1) { return@label "42" @@ -32,7 +32,7 @@ class Java8Class { "43" } val f1 = label@{ i1: Int, k1: Int -> - val f2 = label@{ i2: Int, k2: Int -> + val f2: Function2 = label@{ i2: Int, k2: Int? -> helper() if (i2 > 1) { return@label "42" diff --git a/nj2k/testData/newJ2k/function/methodClassType.kt b/nj2k/testData/newJ2k/function/methodClassType.kt index 30d4d3d51c1..137639e0856 100644 --- a/nj2k/testData/newJ2k/function/methodClassType.kt +++ b/nj2k/testData/newJ2k/function/methodClassType.kt @@ -1 +1 @@ -fun main(): String? {} \ No newline at end of file +fun main(): String {} \ No newline at end of file diff --git a/nj2k/testData/newJ2k/function/referenceToConstructor.kt b/nj2k/testData/newJ2k/function/referenceToConstructor.kt index d933bb19204..60a5d8464f0 100644 --- a/nj2k/testData/newJ2k/function/referenceToConstructor.kt +++ b/nj2k/testData/newJ2k/function/referenceToConstructor.kt @@ -4,7 +4,7 @@ import java.util.stream.Collectors object TestLambda { @JvmStatic fun main(args: Array) { - val names: List = Arrays.asList("A", "B") - val people: List = names.stream().map { name: String -> Person(name) }.collect(Collectors.toList()) + val names = Arrays.asList("A", "B") + val people = names.stream().map { name: String? -> Person(name) }.collect(Collectors.toList()) } -} +} \ No newline at end of file diff --git a/nj2k/testData/newJ2k/function/varVararg.kt b/nj2k/testData/newJ2k/function/varVararg.kt index 4a87cdc05e2..2ce5fee357d 100644 --- a/nj2k/testData/newJ2k/function/varVararg.kt +++ b/nj2k/testData/newJ2k/function/varVararg.kt @@ -1,8 +1,8 @@ package demo internal class Test { - fun test(vararg args: Any) { + fun test(vararg args: Any?) { var args = args - args = arrayOf(1, 2, 3) + args = arrayOf(1, 2, 3) } } \ No newline at end of file diff --git a/nj2k/testData/newJ2k/inheritance/classOneExtendsBaseWithOneParam.kt b/nj2k/testData/newJ2k/inheritance/classOneExtendsBaseWithOneParam.kt index c64c1b12506..85de9e0b9fc 100644 --- a/nj2k/testData/newJ2k/inheritance/classOneExtendsBaseWithOneParam.kt +++ b/nj2k/testData/newJ2k/inheritance/classOneExtendsBaseWithOneParam.kt @@ -1,2 +1,2 @@ -internal open class Base(name: String) -internal class One(name: String, second: String?) : Base(name) \ No newline at end of file +internal open class Base(name: String?) +internal class One(name: String?, second: String?) : Base(name) \ No newline at end of file diff --git a/nj2k/testData/newJ2k/inheritance/classOneExtendsBaseWithZeroParamsNonEmptyConstructor.kt b/nj2k/testData/newJ2k/inheritance/classOneExtendsBaseWithZeroParamsNonEmptyConstructor.kt index ba9d813490b..858fddc4731 100644 --- a/nj2k/testData/newJ2k/inheritance/classOneExtendsBaseWithZeroParamsNonEmptyConstructor.kt +++ b/nj2k/testData/newJ2k/inheritance/classOneExtendsBaseWithZeroParamsNonEmptyConstructor.kt @@ -1,2 +1,2 @@ -internal open class Base(name: String) -internal class One(name: String, private val mySecond: String) : Base(name) \ No newline at end of file +internal open class Base(name: String?) +internal class One(name: String?, private val mySecond: String) : Base(name) \ No newline at end of file diff --git a/nj2k/testData/newJ2k/issues/kt-19336.kt b/nj2k/testData/newJ2k/issues/kt-19336.kt index 99323f59e87..1c30926646e 100644 --- a/nj2k/testData/newJ2k/issues/kt-19336.kt +++ b/nj2k/testData/newJ2k/issues/kt-19336.kt @@ -1,6 +1,6 @@ class TestReturnsArray { fun strings(n: Int): Array { - val result = arrayOfNulls(n) + val result = arrayOfNulls(n) for (i in 0 until n) { result[i] = Integer.toString(i) } diff --git a/nj2k/testData/newJ2k/issues/kt-19348.kt b/nj2k/testData/newJ2k/issues/kt-19348.kt index 92f0461e53b..a61957231ea 100644 --- a/nj2k/testData/newJ2k/issues/kt-19348.kt +++ b/nj2k/testData/newJ2k/issues/kt-19348.kt @@ -2,7 +2,7 @@ class TestMutltipleCtorsWithJavadoc /** * Javadoc for 1st ctor * @param x - */(private val x: String) { + */(private val x: String?) { private var y: String? = null // --- @@ -14,7 +14,7 @@ class TestMutltipleCtorsWithJavadoc * @param x * @param y */ - constructor(x: String, y: String?) : this(x) { + constructor(x: String?, y: String?) : this(x) { this.y = y } diff --git a/nj2k/testData/newJ2k/issues/kt-19382.kt b/nj2k/testData/newJ2k/issues/kt-19382.kt index 3cadb176f1f..8e500166174 100644 --- a/nj2k/testData/newJ2k/issues/kt-19382.kt +++ b/nj2k/testData/newJ2k/issues/kt-19382.kt @@ -3,7 +3,7 @@ package test import java.util.HashMap class TestPrimitiveFromMap { - fun foo(map: HashMap): Int { + fun foo(map: HashMap): Int { return map["zzz"]!! } } \ No newline at end of file diff --git a/nj2k/testData/newJ2k/issues/kt-19383.kt b/nj2k/testData/newJ2k/issues/kt-19383.kt index c2bf1ecada5..d4d12b5b27e 100644 --- a/nj2k/testData/newJ2k/issues/kt-19383.kt +++ b/nj2k/testData/newJ2k/issues/kt-19383.kt @@ -1,7 +1,7 @@ package test class TestMapGetAsReceiver { - fun foo(map: Map): Int { + fun foo(map: Map): Int { return map["zzz"]!!.length } } \ No newline at end of file diff --git a/nj2k/testData/newJ2k/issues/kt-19396.kt b/nj2k/testData/newJ2k/issues/kt-19396.kt index a92ef992b37..52864247652 100644 --- a/nj2k/testData/newJ2k/issues/kt-19396.kt +++ b/nj2k/testData/newJ2k/issues/kt-19396.kt @@ -1,9 +1,9 @@ package test -class TestValReassign(private val s1: String) { +class TestValReassign(private val s1: String?) { private var s2: String? = null - constructor(s1: String, s2: String?) : this(s1) { + constructor(s1: String?, s2: String?) : this(s1) { this.s2 = s2 } diff --git a/nj2k/testData/newJ2k/issues/kt-19550.kt b/nj2k/testData/newJ2k/issues/kt-19550.kt index 96bf5371d57..c6cef5aeacd 100644 --- a/nj2k/testData/newJ2k/issues/kt-19550.kt +++ b/nj2k/testData/newJ2k/issues/kt-19550.kt @@ -3,13 +3,13 @@ class TestToStringReturnsNullable { var string: String? = null } - open class Ctor(string: String) : Base() { + open class Ctor(string: String?) : Base() { init { this.string = string } } - class Derived(string: String) : Ctor(string) { + class Derived(string: String?) : Ctor(string) { override fun toString(): String { return string!! } diff --git a/nj2k/testData/newJ2k/issues/kt-19639.kt b/nj2k/testData/newJ2k/issues/kt-19639.kt index 1f0db751a83..03e398fea3e 100644 --- a/nj2k/testData/newJ2k/issues/kt-19639.kt +++ b/nj2k/testData/newJ2k/issues/kt-19639.kt @@ -6,7 +6,7 @@ class TestJavaExpectedTypeInference { fun test(node: DefaultMutableTreeNode) { val e: Enumeration = node.children() while (e.hasMoreElements()) { - val child: DefaultMutableTreeNode = e.nextElement() + val child = e.nextElement() val name = child.userObject as String println(name) } diff --git a/nj2k/testData/newJ2k/issues/kt-24677.kt b/nj2k/testData/newJ2k/issues/kt-24677.kt index 7648ba14608..6b57798e775 100644 --- a/nj2k/testData/newJ2k/issues/kt-24677.kt +++ b/nj2k/testData/newJ2k/issues/kt-24677.kt @@ -1,11 +1,11 @@ import java.util.ArrayList internal interface FooInterface { - fun foo(): ArrayList? + fun foo(): ArrayList? } class Foo : FooInterface { - override fun foo(): ArrayList? { + override fun foo(): ArrayList? { return null } diff --git a/nj2k/testData/newJ2k/issues/kt-32702.kt b/nj2k/testData/newJ2k/issues/kt-32702.kt index 3a3f935380d..f510cf598e0 100644 --- a/nj2k/testData/newJ2k/issues/kt-32702.kt +++ b/nj2k/testData/newJ2k/issues/kt-32702.kt @@ -5,6 +5,6 @@ internal class Test { fun context() { val items: MutableList = ArrayList() items.add(1.0) - items.forEach(Consumer { o: Double -> println(o) }) + items.forEach(Consumer { o: Double? -> println(o) }) } } \ No newline at end of file diff --git a/nj2k/testData/newJ2k/issues/kt-5294.kt b/nj2k/testData/newJ2k/issues/kt-5294.kt index 735489c3efe..be64ffaa7cb 100644 --- a/nj2k/testData/newJ2k/issues/kt-5294.kt +++ b/nj2k/testData/newJ2k/issues/kt-5294.kt @@ -1,4 +1,4 @@ -internal class X(private val list: List) { +internal class X(private val list: MutableList) { internal inner class Y } \ No newline at end of file diff --git a/nj2k/testData/newJ2k/issues/kt-543-boxed.kt b/nj2k/testData/newJ2k/issues/kt-543-boxed.kt index ad9cd2223d4..6f2eb0f3684 100644 --- a/nj2k/testData/newJ2k/issues/kt-543-boxed.kt +++ b/nj2k/testData/newJ2k/issues/kt-543-boxed.kt @@ -1,12 +1,10 @@ package demo internal class Test { - fun putInt(i: Int) {} - + fun putInt(i: Int?) {} fun test() { val b: Byte = 10 putInt(b.toInt()) - val b2: Byte = 10 putInt(b2.toInt()) } diff --git a/nj2k/testData/newJ2k/issues/kt-543-mixed.kt b/nj2k/testData/newJ2k/issues/kt-543-mixed.kt index cb70bc4cf3a..5f9fb471f51 100644 --- a/nj2k/testData/newJ2k/issues/kt-543-mixed.kt +++ b/nj2k/testData/newJ2k/issues/kt-543-mixed.kt @@ -1,8 +1,7 @@ package demo internal class Test { - fun putInt(i: Int) {} - + fun putInt(i: Int?) {} fun test() { val i = 10 putInt(i) diff --git a/nj2k/testData/newJ2k/issues/kt-792-mixed.kt b/nj2k/testData/newJ2k/issues/kt-792-mixed.kt index 8ca7aaaa333..d4cf8d3073a 100644 --- a/nj2k/testData/newJ2k/issues/kt-792-mixed.kt +++ b/nj2k/testData/newJ2k/issues/kt-792-mixed.kt @@ -1,6 +1,6 @@ package demo -internal class Test(i: Int) { +internal class Test(i: Int?) { fun test() { val i = 10 Test(i) diff --git a/nj2k/testData/newJ2k/issues/kt-807.kt b/nj2k/testData/newJ2k/issues/kt-807.kt index bc27457fa35..f4407133b15 100644 --- a/nj2k/testData/newJ2k/issues/kt-807.kt +++ b/nj2k/testData/newJ2k/issues/kt-807.kt @@ -13,7 +13,7 @@ internal object FileRead { val fstream = FileInputStream(File("file.txt")) val `in` = DataInputStream(fstream) val br = BufferedReader(InputStreamReader(`in`)) - var strLine: String + var strLine: String? while (br.readLine().also { strLine = it } != null) { println(strLine) } diff --git a/nj2k/testData/newJ2k/issues/kt-809-string.kt b/nj2k/testData/newJ2k/issues/kt-809-string.kt index afa3bbcb248..c4c72856a5e 100644 --- a/nj2k/testData/newJ2k/issues/kt-809-string.kt +++ b/nj2k/testData/newJ2k/issues/kt-809-string.kt @@ -8,9 +8,9 @@ internal object One { var myContainer = Container() } -internal class StringContainer(s: String) +internal class StringContainer(s: String?) internal class Test { - fun putString(s: String) {} + fun putString(s: String?) {} fun test() { putString(One.myContainer.myString) StringContainer(One.myContainer.myString) diff --git a/nj2k/testData/newJ2k/issues/kt-8170.kt b/nj2k/testData/newJ2k/issues/kt-8170.kt index af2dc349d8a..3f8297676be 100644 --- a/nj2k/testData/newJ2k/issues/kt-8170.kt +++ b/nj2k/testData/newJ2k/issues/kt-8170.kt @@ -2,12 +2,12 @@ object ArrayNullable { @JvmStatic fun main(args: Array) { val notNull = 0 - val a1 = arrayOfNulls(2) + val a1 = arrayOfNulls(2) a1[0] = null a1[1] = notNull println(a1[0]) println(a1[1]) - val a2 = arrayOfNulls(2) + val a2 = arrayOfNulls(2) a2[0] = nullable() a2[1] = notNull println(a2[0]) @@ -21,4 +21,4 @@ object ArrayNullable { fun nullable(): Int? { return if (System.getProperty("user.home").length > 20) null else 1 } -} +} \ No newline at end of file diff --git a/nj2k/testData/newJ2k/javaStreamsApi/collectStream.kt b/nj2k/testData/newJ2k/javaStreamsApi/collectStream.kt index 85c2b60fa95..e6e1911fe0a 100644 --- a/nj2k/testData/newJ2k/javaStreamsApi/collectStream.kt +++ b/nj2k/testData/newJ2k/javaStreamsApi/collectStream.kt @@ -2,12 +2,12 @@ import java.util.stream.Collectors internal class Test { fun main(lst: List) { - val toList: List = lst.stream().collect(Collectors.toList()) - val toSet: Set = lst.stream().collect(Collectors.toSet()) + val toList = lst.stream().collect(Collectors.toList()) + val toSet = lst.stream().collect(Collectors.toSet()) val count = lst.stream().count() val anyMatch = lst.stream().anyMatch { v: String -> v.isEmpty() } val allMatch = lst.stream().allMatch { v: String -> v.isEmpty() } val noneMatch = lst.stream().noneMatch { v: String -> v.isEmpty() } - lst.stream().forEach { v: String -> println(v) } + lst.stream().forEach { v: String? -> println(v) } } } \ No newline at end of file diff --git a/nj2k/testData/newJ2k/javaStreamsApi/createStream.kt b/nj2k/testData/newJ2k/javaStreamsApi/createStream.kt index a464b4e55f6..cddd599337a 100644 --- a/nj2k/testData/newJ2k/javaStreamsApi/createStream.kt +++ b/nj2k/testData/newJ2k/javaStreamsApi/createStream.kt @@ -4,23 +4,23 @@ import java.util.stream.Stream internal class Test { fun main(lst: List) { - val streamOfList: List = lst.stream() + val streamOfList = lst.stream() .map { x: String -> x + "e" } .collect(Collectors.toList()) - val streamOfElements: List = Stream.of(1, 2, 3) + val streamOfElements = Stream.of(1, 2, 3) .map { x: Int -> x + 1 } .collect(Collectors.toList()) val array = arrayOf(1, 2, 3) - val streamOfArray: List = Arrays.stream(array) + val streamOfArray = Arrays.stream(array) .map { x: Int -> x + 1 } .collect(Collectors.toList()) - val streamOfArray2: List = Stream.of(*array) + val streamOfArray2 = Stream.of(*array) .map { x: Int -> x + 1 } .collect(Collectors.toList()) - val streamIterate: List = Stream.iterate(2, { v: Int -> v * 2 }) + val streamIterate = Stream.iterate(2, { v: Int -> v * 2 }) .map { x: Int -> x + 1 } .collect(Collectors.toList()) - val streamGenerate: List = Stream.generate { 42 } + val streamGenerate = Stream.generate { 42 } .map { x: Int -> x + 1 } .collect(Collectors.toList()) } diff --git a/nj2k/testData/newJ2k/javaStreamsApi/dontCollectOnExistingStreams.kt b/nj2k/testData/newJ2k/javaStreamsApi/dontCollectOnExistingStreams.kt index 9ad1baf6050..89a55a809d8 100644 --- a/nj2k/testData/newJ2k/javaStreamsApi/dontCollectOnExistingStreams.kt +++ b/nj2k/testData/newJ2k/javaStreamsApi/dontCollectOnExistingStreams.kt @@ -3,7 +3,7 @@ import java.util.stream.Stream internal class Test { fun main(lst: List?) { - val stream: Stream = Stream.of(1) - val list: List = stream.collect(Collectors.toList()) + val stream = Stream.of(1) + val list = stream.collect(Collectors.toList()) } } \ No newline at end of file diff --git a/nj2k/testData/newJ2k/javaStreamsApi/formatting.kt b/nj2k/testData/newJ2k/javaStreamsApi/formatting.kt index da10b78bb70..a8d1cdcb438 100644 --- a/nj2k/testData/newJ2k/javaStreamsApi/formatting.kt +++ b/nj2k/testData/newJ2k/javaStreamsApi/formatting.kt @@ -3,11 +3,11 @@ import java.util.stream.Collectors internal class Test { fun main(lst: List) { - val newLst: List = /*before list*/lst/*after list*/.stream/*before stream*/()/* after stream*/ + val newLst = /*before list*/lst/*after list*/.stream/*before stream*/()/* after stream*/ .filter { x: Int -> x > 10 } .map { x: Int -> x + 2 }/*some comment*/.distinct/*another comment*/()/* one more comment */.sorted()/*another one comment*/ .sorted(Comparator.naturalOrder()) - .peek { x: Int -> println(x) }.limit(1) + .peek { x: Int? -> println(x) }.limit(1) .skip(42)/*skipped*/ /*collecting one*/.collect/*collecting two */(Collectors.toList())/* cool */ } diff --git a/nj2k/testData/newJ2k/javaStreamsApi/kt-21467.kt b/nj2k/testData/newJ2k/javaStreamsApi/kt-21467.kt index 9a5b2caba74..4b8626e0ff2 100644 --- a/nj2k/testData/newJ2k/javaStreamsApi/kt-21467.kt +++ b/nj2k/testData/newJ2k/javaStreamsApi/kt-21467.kt @@ -3,14 +3,14 @@ import java.util.stream.Stream internal class Test { fun main() { - val activities: List = Stream.of("12") + val activities = Stream.of("12") .map { v: String -> v + "nya" } .filter { v: String? -> v != null } .flatMap { v: String -> Stream.of(v) .flatMap { s: String -> Stream.of(s) } }.filter { v: String -> - val name: String = v.javaClass.name + val name = v.javaClass.name if (name == "name") { return@filter false } diff --git a/nj2k/testData/newJ2k/javaStreamsApi/streamOperations.kt b/nj2k/testData/newJ2k/javaStreamsApi/streamOperations.kt index ed970e78156..24f235a60c7 100644 --- a/nj2k/testData/newJ2k/javaStreamsApi/streamOperations.kt +++ b/nj2k/testData/newJ2k/javaStreamsApi/streamOperations.kt @@ -3,13 +3,13 @@ import java.util.stream.Collectors internal class Test { fun main(lst: List) { - val newLst: List = lst.stream() + val newLst = lst.stream() .filter { x: Int -> x > 10 } .map { x: Int -> x + 2 } .distinct() .sorted() .sorted(Comparator.naturalOrder()) - .peek { x: Int -> println(x) } + .peek { x: Int? -> println(x) } .limit(1) .skip(42) .collect(Collectors.toList()) diff --git a/nj2k/testData/newJ2k/list/ForEach.kt b/nj2k/testData/newJ2k/list/ForEach.kt index faf8b72d496..f5f440b62f8 100644 --- a/nj2k/testData/newJ2k/list/ForEach.kt +++ b/nj2k/testData/newJ2k/list/ForEach.kt @@ -4,7 +4,7 @@ import java.util.ArrayList class ForEach { fun test() { val xs = ArrayList() - val ys: MutableList = LinkedList() + val ys: MutableList = LinkedList() for (x in xs) { ys.add(x) } diff --git a/nj2k/testData/newJ2k/list/Lists.kt b/nj2k/testData/newJ2k/list/Lists.kt index 3529329f0b7..d11b79c3f35 100644 --- a/nj2k/testData/newJ2k/list/Lists.kt +++ b/nj2k/testData/newJ2k/list/Lists.kt @@ -4,7 +4,7 @@ import java.util.ArrayList class Lists { fun test() { val xs: MutableList = ArrayList() - val ys: MutableList = LinkedList() + val ys: MutableList = LinkedList() val zs = ArrayList() xs.add(null) ys.add(null) diff --git a/nj2k/testData/newJ2k/literalExpression/double.kt b/nj2k/testData/newJ2k/literalExpression/double.kt index 9f88435b34d..a3495d6deac 100644 --- a/nj2k/testData/newJ2k/literalExpression/double.kt +++ b/nj2k/testData/newJ2k/literalExpression/double.kt @@ -9,10 +9,8 @@ internal class A { private val d8 = 1.0 private val d9 = 1.0 private val x = 1 / (1.0 + 0) - fun foo1(d: Double) {} - fun foo2(d: Double) {} - + fun foo2(d: Double?) {} fun bar() { foo1(1.0) foo1(1.0) diff --git a/nj2k/testData/newJ2k/literalExpression/float.kt b/nj2k/testData/newJ2k/literalExpression/float.kt index c478a3a259c..b3ec740d481 100644 --- a/nj2k/testData/newJ2k/literalExpression/float.kt +++ b/nj2k/testData/newJ2k/literalExpression/float.kt @@ -9,10 +9,8 @@ internal class A { private val f8 = +1f private val f9 = 1f private val f10 = 1f - fun foo1(f: Float) {} - fun foo2(f: Float) {} - + fun foo2(f: Float?) {} fun bar() { foo1(1f) foo2(1f) diff --git a/nj2k/testData/newJ2k/literalExpression/long.kt b/nj2k/testData/newJ2k/literalExpression/long.kt index 41f07d4a824..203a841a862 100644 --- a/nj2k/testData/newJ2k/literalExpression/long.kt +++ b/nj2k/testData/newJ2k/literalExpression/long.kt @@ -7,10 +7,8 @@ internal class A { private val l6 = -123456789101112 private val l7: Long = +1 private val l8 = +1L - fun foo1(l: Long) {} - fun foo2(l: Long) {} - + fun foo2(l: Long?) {} fun bar() { foo1(1) foo1(1L) diff --git a/nj2k/testData/newJ2k/methodCallExpression/specialBuiltinMembers.kt b/nj2k/testData/newJ2k/methodCallExpression/specialBuiltinMembers.kt index 83dcf8574cb..d65726ef927 100644 --- a/nj2k/testData/newJ2k/methodCallExpression/specialBuiltinMembers.kt +++ b/nj2k/testData/newJ2k/methodCallExpression/specialBuiltinMembers.kt @@ -1,8 +1,9 @@ +// ERROR: Operator call corresponds to a dot-qualified call 'value.plus(1)' which is not allowed on a nullable receiver 'value'. import java.util.HashMap internal enum class E { A, B, C } internal class A { - fun foo(list: List, collection: Collection, map: Map) { + fun foo(list: List, collection: Collection, map: Map) { val a = "".length val b = E.A.name val c = E.A.ordinal @@ -14,7 +15,7 @@ internal class A { val i = map.entries.iterator().next().key + 1 } - fun bar(list: MutableList, map: HashMap) { + fun bar(list: MutableList, map: HashMap) { val c = "a"[0] val b = 10.toByte() val i = 10.1.toInt() @@ -34,7 +35,7 @@ internal class A { entry.setValue(value + 1) } } - + fun kt21504() { val b = "1".toByte() val s = "1".toShort() @@ -42,7 +43,6 @@ internal class A { val l = "1".toLong() val f = "1".toFloat() val d = "1".toDouble() - val b2 = "1".toByte(10) val s2 = "1".toShort(10) val i2 = "1".toInt(10) diff --git a/nj2k/testData/newJ2k/methodCallExpression/stringMethods.kt b/nj2k/testData/newJ2k/methodCallExpression/stringMethods.kt index 68c60845be8..aeb07a63590 100644 --- a/nj2k/testData/newJ2k/methodCallExpression/stringMethods.kt +++ b/nj2k/testData/newJ2k/methodCallExpression/stringMethods.kt @@ -1,7 +1,6 @@ // ERROR: Type mismatch: inferred type is String but Charset was expected // ERROR: Type mismatch: inferred type is String but Charset was expected import java.nio.charset.Charset -import java.util.Comparator import java.util.Locale internal class A { @@ -9,19 +8,19 @@ internal class A { fun constructors() { String() // TODO: new String("original"); + + String(charArrayOf('a', 'b', 'c')) String(charArrayOf('b', 'd'), 1, 1) String(intArrayOf(32, 65, 127), 0, 3) - val bytes = byteArrayOf(32, 65, 100, 81) - val charset: Charset = Charset.forName("utf-8") + val charset = Charset.forName("utf-8") String(bytes) String(bytes, charset) String(bytes, 0, 2) String(bytes, "utf-8") String(bytes, 0, 2, "utf-8") String(bytes, 0, 2, charset) - String(StringBuilder("content")) String(StringBuffer("content")) } @@ -92,11 +91,9 @@ internal class A { */ s.trim { it <= ' ' } "$s another" - s.toByteArray() s.toByteArray(Charset.forName("utf-8")) s.toByteArray(charset("utf-8")) - val chars = CharArray(10) s.toCharArray(chars, 0, 1, 11) } @@ -109,20 +106,18 @@ internal class A { 1.11f.toString() 3.14.toString() Any().toString() - String.format( Locale.FRENCH, "Je ne mange pas %d jours", 6 ) String.format("Operation completed with %s", "success") - val chars = charArrayOf('a', 'b', 'c') String(chars) String(chars, 1, 2) String(chars) String(chars, 1, 2) - val order: Comparator? = java.lang.String.CASE_INSENSITIVE_ORDER + val order = java.lang.String.CASE_INSENSITIVE_ORDER } fun unsupportedMethods() { diff --git a/nj2k/testData/newJ2k/mutableCollections/FunctionParameters.kt b/nj2k/testData/newJ2k/mutableCollections/FunctionParameters.kt index 82533f68e54..2dcc227b239 100644 --- a/nj2k/testData/newJ2k/mutableCollections/FunctionParameters.kt +++ b/nj2k/testData/newJ2k/mutableCollections/FunctionParameters.kt @@ -1,8 +1,8 @@ internal class A { - fun foo(nonMutableCollection: Collection?, - mutableCollection: MutableCollection, + fun foo(nonMutableCollection: Collection?, + mutableCollection: MutableCollection, mutableSet: MutableSet, - mutableMap: MutableMap) { + mutableMap: MutableMap) { mutableCollection.addAll(nonMutableCollection!!) mutableSet.add(mutableMap.remove("a")) } diff --git a/nj2k/testData/newJ2k/mutableCollections/FunctionParameters2.kt b/nj2k/testData/newJ2k/mutableCollections/FunctionParameters2.kt index 191e21328e2..6ee43972046 100644 --- a/nj2k/testData/newJ2k/mutableCollections/FunctionParameters2.kt +++ b/nj2k/testData/newJ2k/mutableCollections/FunctionParameters2.kt @@ -1,9 +1,9 @@ internal class A { - fun foo(set: MutableSet) { + fun foo(set: MutableSet) { bar(set) } - fun bar(collection: MutableCollection) { + fun bar(collection: MutableCollection) { collection.add("a") } -} +} \ No newline at end of file diff --git a/nj2k/testData/newJ2k/mutableCollections/Iterator.kt b/nj2k/testData/newJ2k/mutableCollections/Iterator.kt index dbc2e2bfe9d..2659826b9a4 100644 --- a/nj2k/testData/newJ2k/mutableCollections/Iterator.kt +++ b/nj2k/testData/newJ2k/mutableCollections/Iterator.kt @@ -8,7 +8,7 @@ internal class IteratorTest { mutableMap2.entries.iterator().remove() } - fun testFunctionParameters(immutableCollection: Collection, mutableList: MutableList) { + fun testFunctionParameters(immutableCollection: Collection, mutableList: MutableList) { val it = immutableCollection.iterator() while (it.hasNext()) { it.next() diff --git a/nj2k/testData/newJ2k/mutableCollections/Recursion.kt b/nj2k/testData/newJ2k/mutableCollections/Recursion.kt index c03aaf12851..a8c8e610af3 100644 --- a/nj2k/testData/newJ2k/mutableCollections/Recursion.kt +++ b/nj2k/testData/newJ2k/mutableCollections/Recursion.kt @@ -1,9 +1,9 @@ internal class A { - fun foo(collection: MutableCollection) { + fun foo(collection: MutableCollection) { bar(collection) } - fun bar(collection: MutableCollection) { + fun bar(collection: MutableCollection) { if (collection.size < 5) { foo(collection) } else { diff --git a/nj2k/testData/newJ2k/nullability/Overrides.kt b/nj2k/testData/newJ2k/nullability/Overrides.kt index ccff331dc4d..d2c70e63a2a 100644 --- a/nj2k/testData/newJ2k/nullability/Overrides.kt +++ b/nj2k/testData/newJ2k/nullability/Overrides.kt @@ -11,14 +11,14 @@ internal open class Base { return "" } - open fun nya(s: String): String { + open fun nya(s: String?): String? { return s } } internal interface I { fun zoo(o: Any?): String? - fun nya(s: String): String { + fun nya(s: String?): String? { return "" } } @@ -36,7 +36,7 @@ internal class C : Base(), I { return "" } - override fun nya(s: String): String { + override fun nya(s: String?): String? { return "" } -} +} \ No newline at end of file diff --git a/nj2k/testData/newJ2k/nullability/kt-12050.kt b/nj2k/testData/newJ2k/nullability/kt-12050.kt index 2773fd39f6d..25adb4aa436 100644 --- a/nj2k/testData/newJ2k/nullability/kt-12050.kt +++ b/nj2k/testData/newJ2k/nullability/kt-12050.kt @@ -1,6 +1,6 @@ class NullableArray { fun createArrayFailure(size: Int): Array { - return arrayOfNulls(size) + return arrayOfNulls(size) } fun createArraySuccess(size: Int): Array { diff --git a/nj2k/testData/newJ2k/postProcessing/GetOperator.kt b/nj2k/testData/newJ2k/postProcessing/GetOperator.kt index 8058ae29076..aea545b798a 100644 --- a/nj2k/testData/newJ2k/postProcessing/GetOperator.kt +++ b/nj2k/testData/newJ2k/postProcessing/GetOperator.kt @@ -9,7 +9,7 @@ internal class X { } internal class C { - fun foo(map: HashMap): String? { + fun foo(map: HashMap): String? { return map["a"] } diff --git a/nj2k/testData/newJ2k/postProcessing/MapGetOrDefault.java b/nj2k/testData/newJ2k/postProcessing/MapGetOrDefault.java index b86251a931b..e75ada66c5e 100644 --- a/nj2k/testData/newJ2k/postProcessing/MapGetOrDefault.java +++ b/nj2k/testData/newJ2k/postProcessing/MapGetOrDefault.java @@ -1,8 +1,9 @@ // RUNTIME_WITH_FULL_JDK + import java.util.Map; class C { - String foo(Map map) { + private String foo(Map map) { return map.getOrDefault(1, "bar"); } } \ No newline at end of file diff --git a/nj2k/testData/newJ2k/postProcessing/MapGetOrDefault.kt b/nj2k/testData/newJ2k/postProcessing/MapGetOrDefault.kt index 587f0164258..0fe19f7ce37 100644 --- a/nj2k/testData/newJ2k/postProcessing/MapGetOrDefault.kt +++ b/nj2k/testData/newJ2k/postProcessing/MapGetOrDefault.kt @@ -1,5 +1,5 @@ internal class C { - fun foo(map: Map): String { + private fun foo(map: Map): String { return map[1] ?: "bar" } } \ No newline at end of file diff --git a/nj2k/testData/newJ2k/postProcessing/RedunduntTypeCastAndProhibitedInline.kt b/nj2k/testData/newJ2k/postProcessing/RedunduntTypeCastAndProhibitedInline.kt index c7e80a46cdc..75ed155c30f 100644 --- a/nj2k/testData/newJ2k/postProcessing/RedunduntTypeCastAndProhibitedInline.kt +++ b/nj2k/testData/newJ2k/postProcessing/RedunduntTypeCastAndProhibitedInline.kt @@ -1,7 +1,7 @@ object C { - fun consume1(c: C) {} - fun consume2(c: C) {} - fun foo(cList: List) { + fun consume1(c: C?) {} + fun consume2(c: C?) {} + fun foo(cList: List) { val iter: Iterator<*> = cList.iterator() while (iter.hasNext()) { val c = iter.next() as C diff --git a/nj2k/testData/newJ2k/postProcessing/java8MapForEachWithFullJdk.kt b/nj2k/testData/newJ2k/postProcessing/java8MapForEachWithFullJdk.kt index ccf81d1ae6e..f991570bc87 100644 --- a/nj2k/testData/newJ2k/postProcessing/java8MapForEachWithFullJdk.kt +++ b/nj2k/testData/newJ2k/postProcessing/java8MapForEachWithFullJdk.kt @@ -1,9 +1,9 @@ import java.util.HashMap internal class Test { - fun test(map: HashMap) { - map.forEach { (key: String, value: String) -> foo(key, value) } + fun test(map: HashMap) { + map.forEach { (key: String?, value: String?) -> foo(key, value) } } - fun foo(key: String, value: String) {} + fun foo(key: String?, value: String?) {} } \ No newline at end of file diff --git a/nj2k/testData/newJ2k/rawGenerics/kt-540-map.kt b/nj2k/testData/newJ2k/rawGenerics/kt-540-map.kt index b10a19ddbf4..205ecc380a8 100644 --- a/nj2k/testData/newJ2k/rawGenerics/kt-540-map.kt +++ b/nj2k/testData/newJ2k/rawGenerics/kt-540-map.kt @@ -5,7 +5,7 @@ import java.util.HashMap internal class Test { fun main() { val commonMap = HashMap() - val rawMap: HashMap<*, *> = HashMap() + val rawMap: HashMap<*, *> = HashMap() val superRawMap: HashMap<*, *> = HashMap() } } \ No newline at end of file diff --git a/nj2k/testData/newJ2k/rawGenerics/kt-540.kt b/nj2k/testData/newJ2k/rawGenerics/kt-540.kt index fc32320fbc0..e3981b0891c 100644 --- a/nj2k/testData/newJ2k/rawGenerics/kt-540.kt +++ b/nj2k/testData/newJ2k/rawGenerics/kt-540.kt @@ -5,7 +5,7 @@ import java.util.ArrayList internal class Test { fun main() { val common: List = ArrayList() - val raw: List<*> = ArrayList() + val raw: List<*> = ArrayList() val superRaw: List<*> = ArrayList() } } \ No newline at end of file diff --git a/nj2k/testData/newJ2k/rawGenerics/rawGenericMethod.kt b/nj2k/testData/newJ2k/rawGenerics/rawGenericMethod.kt index 0e0d7378861..6be2c6454ee 100644 --- a/nj2k/testData/newJ2k/rawGenerics/rawGenericMethod.kt +++ b/nj2k/testData/newJ2k/rawGenerics/rawGenericMethod.kt @@ -7,8 +7,8 @@ internal class TestT { internal class U { fun main() { val t = TestT() - t.getT() - t.getT() - t.getT() + t.getT() + t.getT() + t.getT() } } \ No newline at end of file diff --git a/nj2k/testData/newJ2k/returnStatement/currentMethodBug.kt b/nj2k/testData/newJ2k/returnStatement/currentMethodBug.kt index e900f08948d..db3f8b48e0b 100644 --- a/nj2k/testData/newJ2k/returnStatement/currentMethodBug.kt +++ b/nj2k/testData/newJ2k/returnStatement/currentMethodBug.kt @@ -12,6 +12,6 @@ internal class C { return string } - fun foo(i: I) {} + fun foo(i: I?) {} var string: String? = null } \ No newline at end of file diff --git a/nj2k/testData/newJ2k/settings/specifyLocalVariableTypeByDefaultInFor.kt b/nj2k/testData/newJ2k/settings/specifyLocalVariableTypeByDefaultInFor.kt index 4b9bc5a2530..4f6be3f75b1 100644 --- a/nj2k/testData/newJ2k/settings/specifyLocalVariableTypeByDefaultInFor.kt +++ b/nj2k/testData/newJ2k/settings/specifyLocalVariableTypeByDefaultInFor.kt @@ -1,9 +1,9 @@ // !specifyLocalVariableTypeByDefault: true -fun foo(list: List) { +fun foo(list: List) { val array: IntArray = IntArray(10) for (i: Int in 0..9) { array[i] = i } - for (s: String in list) print(s) + for (s: String? in list) print(s) } \ No newline at end of file diff --git a/nj2k/testData/newJ2k/switch/comlicatedFallDown.kt b/nj2k/testData/newJ2k/switch/comlicatedFallDown.kt index 7078133583e..1218c75d72e 100644 --- a/nj2k/testData/newJ2k/switch/comlicatedFallDown.kt +++ b/nj2k/testData/newJ2k/switch/comlicatedFallDown.kt @@ -1,7 +1,7 @@ package demo object SwitchDemo { - fun print(o: Any) { + fun print(o: Any?) { println(o) } @@ -78,7 +78,6 @@ object SwitchDemo { @JvmStatic fun main(args: Array) { - for (i in 1..12) - test(i) + for (i in 1..12) test(i) } } \ No newline at end of file diff --git a/nj2k/testData/newJ2k/toArray/toArray.kt b/nj2k/testData/newJ2k/toArray/toArray.kt index 23ae7934308..9759ed5761d 100644 --- a/nj2k/testData/newJ2k/toArray/toArray.kt +++ b/nj2k/testData/newJ2k/toArray/toArray.kt @@ -5,8 +5,8 @@ import java.util.Arrays class Foo { fun test() { - val list: List = Arrays.asList("a", "b") - val array1: Array = list.toTypedArray() + val list = Arrays.asList("a", "b") + val array1: Array = list.toTypedArray() val array2: Array = list.toTypedArray() } } \ No newline at end of file diff --git a/nj2k/testData/newJ2k/toKotlinClasses/LibraryFunctions.kt b/nj2k/testData/newJ2k/toKotlinClasses/LibraryFunctions.kt index 6d11f2c0c8c..7fbdf093dd2 100644 --- a/nj2k/testData/newJ2k/toKotlinClasses/LibraryFunctions.kt +++ b/nj2k/testData/newJ2k/toKotlinClasses/LibraryFunctions.kt @@ -3,7 +3,7 @@ package demo import java.util.ArrayList class TestJava { - fun f(result: Function1) { + fun f(result: Function1) { result.invoke("a") } diff --git a/nj2k/testData/newJ2k/toKotlinClasses/iterableAndIterator.kt b/nj2k/testData/newJ2k/toKotlinClasses/iterableAndIterator.kt index d1b048fc229..55e54ae28b2 100644 --- a/nj2k/testData/newJ2k/toKotlinClasses/iterableAndIterator.kt +++ b/nj2k/testData/newJ2k/toKotlinClasses/iterableAndIterator.kt @@ -1,9 +1,9 @@ -// ERROR: Null can not be a value of a non-null type Iterator -// ERROR: Null can not be a value of a non-null type Iterator +// ERROR: Null can not be a value of a non-null type Iterator +// ERROR: Null can not be a value of a non-null type Iterator package demo internal class Test : Iterable { - override fun iterator(): Iterator { + override fun iterator(): Iterator { return null } @@ -13,7 +13,7 @@ internal class Test : Iterable { } internal class FullTest : Iterable { - override fun iterator(): Iterator { + override fun iterator(): Iterator { return null } diff --git a/nj2k/testData/newJ2k/toKotlinClasses/iterableAndIterator2.kt b/nj2k/testData/newJ2k/toKotlinClasses/iterableAndIterator2.kt index d1b048fc229..55e54ae28b2 100644 --- a/nj2k/testData/newJ2k/toKotlinClasses/iterableAndIterator2.kt +++ b/nj2k/testData/newJ2k/toKotlinClasses/iterableAndIterator2.kt @@ -1,9 +1,9 @@ -// ERROR: Null can not be a value of a non-null type Iterator -// ERROR: Null can not be a value of a non-null type Iterator +// ERROR: Null can not be a value of a non-null type Iterator +// ERROR: Null can not be a value of a non-null type Iterator package demo internal class Test : Iterable { - override fun iterator(): Iterator { + override fun iterator(): Iterator { return null } @@ -13,7 +13,7 @@ internal class Test : Iterable { } internal class FullTest : Iterable { - override fun iterator(): Iterator { + override fun iterator(): Iterator { return null } diff --git a/nj2k/testData/newJ2k/toKotlinClasses/iterableAndIterator3.kt b/nj2k/testData/newJ2k/toKotlinClasses/iterableAndIterator3.kt index 589d2e0cdb2..32d8dd7cd24 100644 --- a/nj2k/testData/newJ2k/toKotlinClasses/iterableAndIterator3.kt +++ b/nj2k/testData/newJ2k/toKotlinClasses/iterableAndIterator3.kt @@ -1,8 +1,8 @@ -// ERROR: Null can not be a value of a non-null type Iterator +// ERROR: Null can not be a value of a non-null type Iterator package demo internal class Test : Iterable { - override fun iterator(): Iterator { + override fun iterator(): Iterator { return null } diff --git a/nj2k/testData/newJ2k/types/capturedTypeInStreamsLambda.kt b/nj2k/testData/newJ2k/types/capturedTypeInStreamsLambda.kt index 33daaa5e0f1..bdf49050b7f 100644 --- a/nj2k/testData/newJ2k/types/capturedTypeInStreamsLambda.kt +++ b/nj2k/testData/newJ2k/types/capturedTypeInStreamsLambda.kt @@ -2,8 +2,8 @@ import java.util.stream.Collectors class Test { private fun addPackages(packages: Collection) { - val sorted: List = packages.stream() - .filter { repoPackage: Number? -> repoPackage != null } - .collect(Collectors.toList()) + val sorted = packages.stream() + .filter { repoPackage: Number? -> repoPackage != null } + .collect(Collectors.toList()) } } diff --git a/nj2k/tests/org/jetbrains/kotlin/nj2k/inference/AbstractConstraintCollectorTest.kt b/nj2k/tests/org/jetbrains/kotlin/nj2k/inference/AbstractConstraintCollectorTest.kt index bd08f26c96b..a423f9cc976 100644 --- a/nj2k/tests/org/jetbrains/kotlin/nj2k/inference/AbstractConstraintCollectorTest.kt +++ b/nj2k/tests/org/jetbrains/kotlin/nj2k/inference/AbstractConstraintCollectorTest.kt @@ -30,6 +30,7 @@ abstract class AbstractConstraintCollectorTest : KotlinLightCodeInsightFixtureTe CommandProcessor.getInstance().runUndoTransparentAction { ktFile.prepareFile() createInferenceFacade(resolutionFacade).runOn(listOf(ktFile)) + ktFile.afterInference() } KotlinTestUtils.assertEqualsToFile(file, ktFile.text) } @@ -38,6 +39,8 @@ abstract class AbstractConstraintCollectorTest : KotlinLightCodeInsightFixtureTe deleteComments() } + open fun KtFile.afterInference() = Unit + fun KtFile.deleteComments() { for (comment in collectDescendantsOfType()) { if (!comment.text.startsWith("// RUNTIME_WITH_FULL_JDK")) { diff --git a/nj2k/tests/org/jetbrains/kotlin/nj2k/inference/common/AbstractCommonConstraintCollectorTest.kt b/nj2k/tests/org/jetbrains/kotlin/nj2k/inference/common/AbstractCommonConstraintCollectorTest.kt index 8e1f07f3e84..7f3e92b1511 100644 --- a/nj2k/tests/org/jetbrains/kotlin/nj2k/inference/common/AbstractCommonConstraintCollectorTest.kt +++ b/nj2k/tests/org/jetbrains/kotlin/nj2k/inference/common/AbstractCommonConstraintCollectorTest.kt @@ -10,6 +10,7 @@ import org.jetbrains.kotlin.nj2k.inference.AbstractConstraintCollectorTest import org.jetbrains.kotlin.nj2k.inference.common.collectors.CallExpressionConstraintCollector import org.jetbrains.kotlin.nj2k.inference.common.collectors.CommonConstraintsCollector import org.jetbrains.kotlin.nj2k.inference.common.collectors.FunctionConstraintsCollector +import org.jetbrains.kotlin.nj2k.inference.nullability.NullabilityConstraintBoundProvider import org.jetbrains.kotlin.psi.KtTypeElement abstract class AbstractCommonConstraintCollectorTest : AbstractConstraintCollectorTest() { @@ -21,6 +22,7 @@ abstract class AbstractCommonConstraintCollectorTest : AbstractConstraintCollect }, ConstraintsCollectorAggregator( resolutionFacade, + NullabilityConstraintBoundProvider(), listOf( CommonConstraintsCollector(), CallExpressionConstraintCollector(), @@ -29,7 +31,10 @@ abstract class AbstractCommonConstraintCollectorTest : AbstractConstraintCollect ), BoundTypeCalculatorImpl(resolutionFacade, BoundTypeEnhancer.ID), object : StateUpdater() { - override fun updateStates(inferenceContext: InferenceContext) {} + override fun TypeElementBasedTypeVariable.updateState() = Unit + }, + object : DefaultStateProvider() { + override fun defaultStateFor(typeVariable: TypeVariable): State = State.LOWER }, renderDebugTypes = true ) diff --git a/nj2k/tests/org/jetbrains/kotlin/nj2k/inference/nullability/AbstractNullabilityInferenceTest.kt b/nj2k/tests/org/jetbrains/kotlin/nj2k/inference/nullability/AbstractNullabilityInferenceTest.kt index e19ce1e4c60..cf5a2eabbb5 100644 --- a/nj2k/tests/org/jetbrains/kotlin/nj2k/inference/nullability/AbstractNullabilityInferenceTest.kt +++ b/nj2k/tests/org/jetbrains/kotlin/nj2k/inference/nullability/AbstractNullabilityInferenceTest.kt @@ -31,6 +31,7 @@ abstract class AbstractNullabilityInferenceTest : AbstractConstraintCollectorTes }, ConstraintsCollectorAggregator( resolutionFacade, + NullabilityConstraintBoundProvider(), listOf( CommonConstraintsCollector(), CallExpressionConstraintCollector(), @@ -40,6 +41,7 @@ abstract class AbstractNullabilityInferenceTest : AbstractConstraintCollectorTes ), BoundTypeCalculatorImpl(resolutionFacade, typeEnhancer), NullabilityStateUpdater(), + NullabilityDefaultStateProvider(), renderDebugTypes = true ) } @@ -69,4 +71,5 @@ abstract class AbstractNullabilityInferenceTest : AbstractConstraintCollectorTes } override fun getProjectDescriptor() = - descriptorByFileDirective(File(testDataPath, fileName()), isAllFilesPresentInTest())} \ No newline at end of file + descriptorByFileDirective(File(testDataPath, fileName()), isAllFilesPresentInTest()) +} \ No newline at end of file