[FE 1.0] Report INTEGER_OPERATOR_RESOLVE_WILL_CHANGE in missing cases

Covered places:
- local properties
- vars
- return positions of functions and lambdas

^KT-45970 Fixed
^KT-55358 Fixed

compiler/frontend/src/org/jetbrains/kotlin/resolve/VariableTypeAndInitializerResolver.kt

@@ -14,7 +14,6 @@ import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.psi.KtProperty
 import org.jetbrains.kotlin.psi.KtVariableDeclaration
 import org.jetbrains.kotlin.resolve.DescriptorResolver.transformAnonymousTypeIfNeeded
-import org.jetbrains.kotlin.resolve.calls.checkers.NewSchemeOfIntegerOperatorResolutionChecker
 import org.jetbrains.kotlin.resolve.calls.components.InferenceSession
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
 import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator
@@ -128,12 +127,6 @@ class VariableTypeAndInitializerResolver(
                     val initializer = variable.initializer
                     val initializerType =
                         expressionTypingServices.safeGetType(scope, initializer!!, variableType, dataFlowInfo, inferenceSession, trace)
-                    NewSchemeOfIntegerOperatorResolutionChecker.checkArgument(
-                        variableType,
-                        initializer,
-                        trace,
-                        constantExpressionEvaluator.module
-                    )
                     val constant = constantExpressionEvaluator.evaluateExpression(initializer, trace, initializerType)
                         ?: return@computeInitializer null
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/NewSchemeOfIntegerOperatorResolutionChecker.kt

@@ -36,7 +36,7 @@ object NewSchemeOfIntegerOperatorResolutionChecker : CallChecker {
             } else {
                 valueParameter.type
             }.unwrap().lowerIfFlexible()
-            if (!expectedType.isPrimitiveNumberOrNullableType()) {
+            if (!needToCheck(expectedType)) {
                 continue
             }
             for (argument in arguments.arguments) {
@@ -53,12 +53,16 @@ object NewSchemeOfIntegerOperatorResolutionChecker : CallChecker {
         trace: BindingTrace,
         moduleDescriptor: ModuleDescriptor
     ) {
-        val type = expectedType.lowerIfFlexible()
-        if (type.isPrimitiveNumberOrNullableType()) {
-            checkArgumentImpl(type, KtPsiUtil.deparenthesize(argument)!!, trace, moduleDescriptor)
+        if (needToCheck(expectedType)) {
+            checkArgumentImpl(expectedType.lowerIfFlexible(), KtPsiUtil.deparenthesize(argument)!!, trace, moduleDescriptor)
         }
     }
 
+    fun needToCheck(expectedType: KotlinType): Boolean {
+        if (TypeUtils.noExpectedType(expectedType)) return false
+        return expectedType.lowerIfFlexible().isPrimitiveNumberOrNullableType()
+    }
+
     private fun checkArgumentImpl(
         expectedType: SimpleType,
         argumentExpression: KtExpression,

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tower/ResolvedAtomCompleter.kt

@@ -19,6 +19,7 @@ import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver
 import org.jetbrains.kotlin.resolve.calls.NewCommonSuperTypeCalculator
 import org.jetbrains.kotlin.resolve.calls.checkers.CallCheckerContext
+import org.jetbrains.kotlin.resolve.calls.checkers.NewSchemeOfIntegerOperatorResolutionChecker
 import org.jetbrains.kotlin.resolve.calls.commonSuperType
 import org.jetbrains.kotlin.resolve.calls.components.*
 import org.jetbrains.kotlin.resolve.calls.components.candidate.CallableReferenceResolutionCandidate
@@ -365,13 +366,17 @@ class ResolvedAtomCompleter(
                 .replaceBindingTrace(topLevelTrace)
             val argumentExpression = resultValueArgument.valueArgument.getArgumentExpression() ?: continue
 
-            kotlinToResolvedCallTransformer.updateRecordedType(
+            val updatedType = kotlinToResolvedCallTransformer.updateRecordedType(
                 argumentExpression,
                 parameter = null,
                 context = newContext,
                 reportErrorForTypeMismatch = true,
                 convertedArgumentType = null
             )
+
+            if (updatedType != null) {
+                NewSchemeOfIntegerOperatorResolutionChecker.checkArgument(updatedType, argumentExpression, topLevelTrace, moduleDescriptor)
+            }
         }
     }
 

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DataFlowAnalyzer.java

@@ -34,6 +34,7 @@ import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.BindingTrace;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.calls.checkers.AdditionalTypeChecker;
+import org.jetbrains.kotlin.resolve.calls.checkers.NewSchemeOfIntegerOperatorResolutionChecker;
 import org.jetbrains.kotlin.resolve.calls.context.ResolutionContext;
 import org.jetbrains.kotlin.resolve.calls.inference.BuilderInferenceSession;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.*;
@@ -447,6 +448,8 @@ public class DataFlowAnalyzer {
             expressionType = ((TypedCompileTimeConstant<?>) value).getType();
         }
 
+        NewSchemeOfIntegerOperatorResolutionChecker.checkArgument(context.expectedType, expression, context.trace, module);
+
         return createCheckedTypeInfo(expressionType, context, expression);
     }
 }