New J2K: do not add extra !! in ImplicitCastsConversion because it would be added later in post-processing

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/ImplicitCastsConversion.kt

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.nj2k.conversions
 
-import org.jetbrains.kotlin.j2k.ast.Nullability
 import org.jetbrains.kotlin.nj2k.*
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.*
@@ -16,7 +15,6 @@ class ImplicitCastsConversion(private val context: NewJ2kConverterContext) : Rec
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         when (element) {
             is JKVariable -> convertVariable(element)
-            is JKForInStatement -> convertForInStatement(element)
             is JKMethodCallExpression -> convertMethodCallExpression(element)
             is JKBinaryExpression -> return recurse(convertBinaryExpression(element))
             is JKKtAssignmentStatement -> convertAssignmentStatement(element)
@@ -26,26 +24,6 @@ class ImplicitCastsConversion(private val context: NewJ2kConverterContext) : Rec
 
 
     private fun convertBinaryExpression(binaryExpression: JKBinaryExpression): JKExpression {
-        fun JKBinaryExpression.addBangBang(): JKBinaryExpression {
-            fun JKType.isAcceptable() = asPrimitiveType() != null
-
-            if (operator.isEquals()) return this
-
-            val leftType = left.type(context.symbolProvider) ?: return this
-            val rightType = right.type(context.symbolProvider) ?: return this
-            return if (leftType.isAcceptable()
-                && rightType.isAcceptable()
-                && (leftType.isNullable() || rightType.isNullable())
-                && (operator.isArithmetic() || operator.isLessOrGreater())
-            ) {
-                JKBinaryExpressionImpl(
-                    ::left.detached().bangedBangedExpr(context.symbolProvider),
-                    ::right.detached().bangedBangedExpr(context.symbolProvider),
-                    operator
-                )
-            } else this
-        }
-
         fun JKBinaryExpression.convertBinaryOperationWithChar(): JKBinaryExpression {
             val leftType = left.type(context.symbolProvider)?.asPrimitiveType() ?: return this
             val rightType = right.type(context.symbolProvider)?.asPrimitiveType() ?: return this
@@ -78,7 +56,7 @@ class ImplicitCastsConversion(private val context: NewJ2kConverterContext) : Rec
             }
         }
 
-        return binaryExpression.convertBinaryOperationWithChar().addBangBang()
+        return binaryExpression.convertBinaryOperationWithChar()
     }
 
     private fun convertVariable(variable: JKVariable) {
@@ -88,13 +66,6 @@ class ImplicitCastsConversion(private val context: NewJ2kConverterContext) : Rec
         }
     }
 
-    private fun convertForInStatement(forInStatement: JKForInStatement) {
-        val notNullType = forInStatement.iterationExpression.type(context.symbolProvider)?.updateNullability(Nullability.NotNull) ?: return
-        forInStatement.iterationExpression.addBangBang(notNullType)?.also {
-            forInStatement.iterationExpression = it
-        }
-    }
-
     private fun convertAssignmentStatement(statement: JKKtAssignmentStatement) {
         val expressionType = statement.field.type(context.symbolProvider) ?: return
         statement.expression.castTo(expressionType)?.also {
@@ -122,18 +93,6 @@ class ImplicitCastsConversion(private val context: NewJ2kConverterContext) : Rec
     }
 
 
-    private fun JKExpression.addBangBang(toType: JKType): JKExpression? {
-        if (this is JKJavaNewExpression) return null
-        val expressionType = type(context.symbolProvider) as? JKClassType ?: return null
-        if (toType !is JKClassType) return null
-        if (expressionType.classReference == toType.classReference
-            && expressionType.isNullable() && !toType.isNullable()
-        ) {
-            return this.copyTreeAndDetach().bangedBangedExpr(context.symbolProvider)
-        }
-        return null
-    }
-
     private fun JKExpression.castStringToRegex(toType: JKType): JKExpression? {
         if (toType.safeAs<JKClassType>()?.classReference?.fqName != "java.util.regex.Pattern") return null
         val expressionType = type(context.symbolProvider) ?: return null
@@ -196,6 +155,6 @@ class ImplicitCastsConversion(private val context: NewJ2kConverterContext) : Rec
         if (expressionType == toType) return null
         castToAsPrimitiveTypes(toType, strict)?.also { return it }
         castStringToRegex(toType)?.also { return it }
-        return addBangBang(toType)
+        return null
     }
 }