[NI] Don't use only platform specific checks for FIC in inference

compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/JvmSamConversionTransformer.kt

@@ -8,12 +8,15 @@ package org.jetbrains.kotlin.load.java.sam
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.impl.TypeAliasConstructorDescriptor
 import org.jetbrains.kotlin.resolve.sam.SamConversionResolver
 import org.jetbrains.kotlin.load.java.descriptors.JavaClassConstructorDescriptor
+import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor
 import org.jetbrains.kotlin.resolve.calls.components.SamConversionTransformer
 import org.jetbrains.kotlin.synthetic.hasJavaOriginInHierarchy
+import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.UnwrappedType
 
 class JvmSamConversionTransformer(
@@ -33,4 +36,9 @@ class JvmSamConversionTransformer(
 
         return functionDescriptor.hasJavaOriginInHierarchy()
     }
+
+    override fun isPossibleSamType(samType: KotlinType): Boolean {
+        val descriptor = samType.constructor.declarationDescriptor
+        return descriptor is ClassDescriptor && (descriptor.isFun || descriptor is JavaClassDescriptor)
+    }
 }

compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SingleAbstractMethodUtils.java

@@ -38,6 +38,7 @@ import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 
+import static org.jetbrains.kotlin.resolve.sam.SamConversionResolverImplKt.nonProjectionParametrization;
 import static org.jetbrains.kotlin.types.Variance.IN_VARIANCE;
 
 public class SingleAbstractMethodUtils {
@@ -73,7 +74,7 @@ public class SingleAbstractMethodUtils {
             SimpleType functionTypeDefault = samResolver.resolveFunctionTypeIfSamInterface(descriptor);
 
             if (functionTypeDefault != null) {
-                SimpleType noProjectionsSamType = SingleAbstractMethodUtilsKt.nonProjectionParametrization(samType);
+                SimpleType noProjectionsSamType = nonProjectionParametrization(samType);
                 if (noProjectionsSamType == null) return null;
 
                 // Function2<String, String, Int>?

compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SingleAbstractMethodUtils.kt

@@ -1,52 +0,0 @@
-/*
- * Copyright 2010-2016 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.load.java.sam
-
-import org.jetbrains.kotlin.types.SimpleType
-import org.jetbrains.kotlin.types.Variance
-import org.jetbrains.kotlin.types.replace
-import org.jetbrains.kotlin.types.typeUtil.asTypeProjection
-import org.jetbrains.kotlin.types.typeUtil.contains
-
-// If type 'samType' contains no projection, then it's non-projection parametrization is 'samType' itself
-// Else each projection type argument 'out/in A_i' (but star projections) is replaced with it's bound 'A_i'
-// Star projections are treated specially:
-// - If first upper bound of corresponding type parameter does not contain any type parameter of 'samType' class,
-//   then use this upper bound instead of star projection
-// - Otherwise no non-projection parametrization exists for such 'samType'
-//
-// See Non-wildcard parametrization in JLS 8 p.9.9 for clarification
-internal fun nonProjectionParametrization(samType: SimpleType): SimpleType? {
-    if (samType.arguments.none { it.projectionKind != Variance.INVARIANT }) return samType
-    val parameters = samType.constructor.parameters
-    val parametersSet = parameters.toSet()
-
-    return samType.replace(
-            newArguments = samType.arguments.zip(parameters).map {
-                val (projection, parameter) = it
-                when {
-                    projection.projectionKind == Variance.INVARIANT -> projection
-
-                    projection.isStarProjection ->
-                        parameter.upperBounds.first().takeUnless {
-                            t -> t.contains { it.constructor.declarationDescriptor in parametersSet }
-                        }?.asTypeProjection() ?: return@nonProjectionParametrization null
-
-                    else -> projection.type.asTypeProjection()
-                }
-            })
-}