Fix context type for == and != patterns.

According to the patterns spec
(https://github.com/dart-lang/language/blob/main/accepted/3.0/patterns/feature-specification.md),
if `A` is the type of the formal parameter of the operator
declaration, then operand should be type checked with context type
`A?` when op is `==` or `!=`, and with context type `A` otherwise.

Prior to this commit, context type `A` was always used.

There should be no observable behavior difference, because the operand
of a relational operator is required to be a constant expression, and
there is no constant expression that behaves differently when its
context is `A?` vs `A`.

However, we are contemplating some possible future language changes
that *would* make the difference observable (e.g.,
dart-lang/language#3471), so it seems
prudent to fix the behavior to match the spec.

Change-Id: Ib3a1c82de45c65a851cbd613899ba1f72c215fbe
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/346420
Commit-Queue: Paul Berry <[email protected]>
Reviewed-by: Konstantin Shcheglov <[email protected]>

Author: stereotype441

pkg/_fe_analyzer_shared/lib/src/type_inference/type_analyzer.dart

@@ -1608,33 +1608,26 @@ mixin TypeAnalyzer<
     RelationalOperatorResolution<Type>? operator =
         resolveRelationalPatternOperator(node, matchedValueType);
     Type operandContext = operator?.parameterType ?? operations.unknownType;
+    bool isEquality = switch (operator?.kind) {
+      RelationalOperatorKind.equals => true,
+      RelationalOperatorKind.notEquals => true,
+      _ => false
+    };
+    if (isEquality) {
+      operandContext = operations.makeNullable(operandContext);
+    }
     Type operandType = analyzeExpression(operand, operandContext);
-    bool isEquality;
-    switch (operator?.kind) {
-      case RelationalOperatorKind.equals:
-        isEquality = true;
-        flow.equalityRelationalPattern_end(operand, operandType,
-            notEqual: false);
-        break;
-      case RelationalOperatorKind.notEquals:
-        isEquality = true;
-        flow.equalityRelationalPattern_end(operand, operandType,
-            notEqual: true);
-        break;
-      default:
-        isEquality = false;
-        flow.nonEqualityRelationalPattern_end();
-        break;
+    if (isEquality) {
+      flow.equalityRelationalPattern_end(operand, operandType,
+          notEqual: operator?.kind == RelationalOperatorKind.notEquals);
+    } else {
+      flow.nonEqualityRelationalPattern_end();
     }
     // Stack: (Expression)
     Error? argumentTypeNotAssignableError;
     Error? operatorReturnTypeNotAssignableToBoolError;
     if (operator != null) {
-      Type parameterType = operator.parameterType;
-      if (isEquality) {
-        parameterType = operations.makeNullable(parameterType);
-      }
-      if (!operations.isAssignableTo(operandType, parameterType)) {
+      if (!operations.isAssignableTo(operandType, operandContext)) {
         argumentTypeNotAssignableError =
             errors.relationalPatternOperandTypeNotAssignable(
           pattern: node,

pkg/_fe_analyzer_shared/test/type_inference/type_inference_test.dart

@@ -3571,7 +3571,7 @@ main() {
           h.run([
             ifCase(
               expr('Object').checkContext('?'),
-              relationalPattern('==', expr('int?').checkContext('Object')),
+              relationalPattern('==', expr('int?').checkContext('Object?')),
               [],
             ).checkIR('ifCase(expr(Object), ==(expr(int?), '
                 'matchedType: Object), variables(), true, block(), noop)')
@@ -3581,7 +3581,7 @@ main() {
           h.run([
             ifCase(
               expr('Object').checkContext('?'),
-              relationalPattern('!=', expr('int?').checkContext('Object')),
+              relationalPattern('!=', expr('int?').checkContext('Object?')),
               [],
             ).checkIR('ifCase(expr(Object), !=(expr(int?), '
                 'matchedType: Object), variables(), true, block(), noop)')