Issue 46839. Stop using UNCHECKED_USE_OF_NULLABLE_VALUE.

Bug: #46839
Change-Id: Ia6a71438c265e54e83b148689e68e1e409d34cee
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/209500
Reviewed-by: Samuel Rawlins <[email protected]>
Reviewed-by: Brian Wilkerson <[email protected]>
Commit-Queue: Konstantin Shcheglov <[email protected]>

Author: scheglov

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

@@ -114,9 +114,10 @@ class ForResolver {
     iterable.accept(_resolver);
     iterable = forEachParts.iterable;
 
-    _resolver.nullableDereferenceVerifier.expression(iterable,
-        errorCode:
-            CompileTimeErrorCode.UNCHECKED_USE_OF_NULLABLE_VALUE_AS_ITERATOR);
+    _resolver.nullableDereferenceVerifier.expression(
+      CompileTimeErrorCode.UNCHECKED_USE_OF_NULLABLE_VALUE_AS_ITERATOR,
+      iterable,
+    );
 
     loopVariable?.accept(_resolver);
     var elementType = _computeForEachElementType(iterable, isAsync);

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

@@ -24,7 +24,7 @@ class FunctionExpressionInvocationResolver {
 
   FunctionExpressionInvocationResolver({
     required ResolverVisitor resolver,
-  })   : _resolver = resolver,
+  })  : _resolver = resolver,
         _typePropertyResolver = resolver.typePropertyResolver,
         _inferenceHelper = resolver.inferenceHelper;
 
@@ -60,8 +60,10 @@ class FunctionExpressionInvocationResolver {
       return;
     }
 
-    _nullableDereferenceVerifier.expression(function,
-        errorCode: CompileTimeErrorCode.UNCHECKED_INVOCATION_OF_NULLABLE_VALUE);
+    _nullableDereferenceVerifier.expression(
+      CompileTimeErrorCode.UNCHECKED_INVOCATION_OF_NULLABLE_VALUE,
+      function,
+    );
 
     if (receiverType is FunctionType) {
       _resolve(node, receiverType, whyNotPromotedList);

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

@@ -495,9 +495,11 @@ class MethodInvocationResolver {
         );
       } else {
         _setDynamicResolution(node, whyNotPromotedList: whyNotPromotedList);
-        _resolver.nullableDereferenceVerifier.report(methodName, receiverType,
-            errorCode: CompileTimeErrorCode
-                .UNCHECKED_METHOD_INVOCATION_OF_NULLABLE_VALUE);
+        _resolver.nullableDereferenceVerifier.report(
+          CompileTimeErrorCode.UNCHECKED_METHOD_INVOCATION_OF_NULLABLE_VALUE,
+          methodName,
+          receiverType,
+        );
       }
       return;
     }

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

@@ -143,8 +143,8 @@ class TypePropertyResolver {
         }
       }
       _resolver.nullableDereferenceVerifier.report(
-          propertyErrorEntity, receiverType,
-          errorCode: errorCode, arguments: [name], messages: messages);
+          errorCode, propertyErrorEntity, receiverType,
+          arguments: [name], messages: messages);
       _reportedGetterError = true;
       _reportedSetterError = true;
 

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

@@ -126,9 +126,10 @@ class YieldStatementResolver {
     node.expression.accept(_resolver);
 
     if (node.star != null) {
-      _resolver.nullableDereferenceVerifier.expression(node.expression,
-          errorCode: CompileTimeErrorCode
-              .UNCHECKED_USE_OF_NULLABLE_VALUE_IN_YIELD_EACH);
+      _resolver.nullableDereferenceVerifier.expression(
+        CompileTimeErrorCode.UNCHECKED_USE_OF_NULLABLE_VALUE_IN_YIELD_EACH,
+        node.expression,
+      );
     }
 
     bodyContext.addYield(node);

pkg/analyzer/lib/src/error/bool_expression_verifier.dart

@@ -25,7 +25,7 @@ class BoolExpressionVerifier {
     required ResolverVisitor resolver,
     required ErrorReporter errorReporter,
     required NullableDereferenceVerifier nullableDereferenceVerifier,
-  })   : _resolver = resolver,
+  })  : _resolver = resolver,
         _errorReporter = errorReporter,
         _nullableDereferenceVerifier = nullableDereferenceVerifier,
         _boolType = resolver.typeSystem.typeProvider.boolType;
@@ -53,9 +53,10 @@ class BoolExpressionVerifier {
     if (!_checkForUseOfVoidResult(expression) &&
         !_resolver.typeSystem.isAssignableTo(type, _boolType)) {
       if (type.isDartCoreBool) {
-        _nullableDereferenceVerifier.report(expression, type,
-            errorCode: CompileTimeErrorCode
-                .UNCHECKED_USE_OF_NULLABLE_VALUE_AS_CONDITION,
+        _nullableDereferenceVerifier.report(
+            CompileTimeErrorCode.UNCHECKED_USE_OF_NULLABLE_VALUE_AS_CONDITION,
+            expression,
+            type,
             messages: _resolver.computeWhyNotPromotedMessages(
                 expression, whyNotPromoted?.call()));
       } else {

pkg/analyzer/lib/src/error/nullable_dereference_verifier.dart

@@ -27,28 +27,26 @@ class NullableDereferenceVerifier {
     required TypeSystemImpl typeSystem,
     required ErrorReporter errorReporter,
     required ResolverVisitor resolver,
-  })   : _typeSystem = typeSystem,
+  })  : _typeSystem = typeSystem,
         _errorReporter = errorReporter,
         _resolver = resolver;
 
-  bool expression(Expression expression,
-      {DartType? type, ErrorCode? errorCode}) {
+  bool expression(ErrorCode errorCode, Expression expression,
+      {DartType? type}) {
     if (!_typeSystem.isNonNullableByDefault) {
       return false;
     }
 
     type ??= expression.typeOrThrow;
-    return _check(expression, type, errorCode: errorCode);
+    return _check(errorCode, expression, type);
   }
 
-  void report(SyntacticEntity errorEntity, DartType receiverType,
-      {ErrorCode? errorCode,
-      List<String> arguments = const <String>[],
+  void report(
+      ErrorCode errorCode, SyntacticEntity errorEntity, DartType receiverType,
+      {List<String> arguments = const <String>[],
       List<DiagnosticMessage>? messages}) {
     if (receiverType == _typeSystem.typeProvider.nullType) {
       errorCode = CompileTimeErrorCode.INVALID_USE_OF_NULL_VALUE;
-    } else {
-      errorCode ??= CompileTimeErrorCode.UNCHECKED_USE_OF_NULLABLE_VALUE;
     }
     if (errorEntity is AstNode) {
       _errorReporter.reportErrorForNode(
@@ -67,8 +65,11 @@ class NullableDereferenceVerifier {
   /// receiver is the implicit `this`, the name of the invocation.
   ///
   /// Returns whether [receiverType] was reported.
-  bool _check(AstNode errorNode, DartType receiverType,
-      {ErrorCode? errorCode}) {
+  bool _check(
+    ErrorCode errorCode,
+    AstNode errorNode,
+    DartType receiverType,
+  ) {
     if (identical(receiverType, DynamicTypeImpl.instance) ||
         !_typeSystem.isPotentiallyNullable(receiverType)) {
       return false;
@@ -79,7 +80,7 @@ class NullableDereferenceVerifier {
       messages = _resolver.computeWhyNotPromotedMessages(
           errorNode, _resolver.flowAnalysis?.flow?.whyNotPromoted(errorNode)());
     }
-    report(errorNode, receiverType, errorCode: errorCode, messages: messages);
+    report(errorCode, errorNode, receiverType, messages: messages);
     return true;
   }
 }

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

@@ -1896,9 +1896,10 @@ class ResolverVisitor extends ScopedVisitor with ErrorDetectionHelpers {
     super.visitSpreadElement(node);
 
     if (!node.isNullAware) {
-      nullableDereferenceVerifier.expression(node.expression,
-          errorCode:
-              CompileTimeErrorCode.UNCHECKED_USE_OF_NULLABLE_VALUE_IN_SPREAD);
+      nullableDereferenceVerifier.expression(
+        CompileTimeErrorCode.UNCHECKED_USE_OF_NULLABLE_VALUE_IN_SPREAD,
+        node.expression,
+      );
     }
   }