Use nullable context type for operand of null-check operator. (2)

Initial: https://dart-review.googlesource.com/c/sdk/+/131343
Reverted: https://dart-review.googlesource.com/c/sdk/+/131461

Bug: dart-lang/sdk#39694
Change-Id: I6287338ce347ddc45d6cc1f3cb16fdccbc75c891
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/132200
Reviewed-by: Brian Wilkerson <brianwilkerson@google.com>
Commit-Queue: Konstantin Shcheglov <scheglov@google.com>

pkg/analyzer/lib/src/dart/resolver/postfix_expression_resolver.dart

@@ -51,18 +51,18 @@ class PostfixExpressionResolver {
   TypeSystemImpl get _typeSystem => _resolver.typeSystem;
 
   void resolve(PostfixExpressionImpl node) {
+    if (node.operator.type == TokenType.BANG) {
+      _resolveNullCheck(node);
+      return;
+    }
+
     node.operand.accept(_resolver);
 
     var receiverType = getReadType(
       node.operand,
       elementTypeProvider: _elementTypeProvider,
     );
 
-    if (node.operator.type == TokenType.BANG) {
-      _resolveNullCheck(node, receiverType);
-      return;
-    }
-
     _assignmentShared.checkLateFinalAlreadyAssigned(node.operand);
 
     _resolve1(node, receiverType);
@@ -197,11 +197,29 @@ class PostfixExpressionResolver {
     _inferenceHelper.recordStaticType(node, receiverType);
   }
 
-  void _resolveNullCheck(PostfixExpressionImpl node, DartType operandType) {
+  void _resolveNullCheck(PostfixExpressionImpl node) {
+    var operand = node.operand;
+
+    var contextType = InferenceContext.getContext(node);
+    if (contextType != null) {
+      if (_isNonNullableByDefault) {
+        contextType = _typeSystem.makeNullable(contextType);
+      }
+      InferenceContext.setType(operand, contextType);
+    }
+
+    operand.accept(_resolver);
+    operand = node.operand;
+
+    var operandType = getReadType(
+      operand,
+      elementTypeProvider: _elementTypeProvider,
+    );
+
     var type = _typeSystem.promoteToNonNull(operandType);
     _inferenceHelper.recordStaticType(node, type);
 
-    _flowAnalysis?.flow?.nonNullAssert_end(node.operand);
+    _flowAnalysis?.flow?.nonNullAssert_end(operand);
   }
 
   /// Return `true` if we should report an error for the lookup [result] on

pkg/analyzer/test/src/dart/resolution/postfix_expression_test.dart

@@ -119,6 +119,14 @@ f(int? x) {
     );
   }
 
+  test_nullCheck_functionExpressionInvocation_rewrite() async {
+    await assertNoErrorsInCode(r'''
+main(Function f2) {
+  f2(42)!;
+}
+''');
+  }
+
   test_nullCheck_null() async {
     await assertNoErrorsInCode('''
 main(Null x) {
@@ -129,6 +137,28 @@ main(Null x) {
     assertType(findNode.postfix('x!'), 'Never');
   }
 
+  test_nullCheck_nullableContext() async {
+    await assertNoErrorsInCode(r'''
+T f<T>(T t) => t;
+
+int g() => f(null)!;
+''');
+
+    assertMethodInvocation2(
+      findNode.methodInvocation('f(null)'),
+      element: findElement.topFunction('f'),
+      typeArgumentTypes: ['int?'],
+      invokeType: 'int? Function(int?)',
+      type: 'int?',
+    );
+
+    assertPostfixExpression(
+      findNode.postfix('f(null)!'),
+      element: null,
+      type: 'int',
+    );
+  }
+
   test_nullCheck_typeParameter() async {
     await assertNoErrorsInCode(r'''
 f<T>(T? x) {