Add initial support for Union matching (#81188)

Relates to test plan #81074

Author: AlekseyTs

src/Compilers/CSharp/Portable/Binder/Binder_Conversions.cs

@@ -1978,7 +1978,7 @@ private BoundExpression ConvertSwitchExpression(BoundUnconvertedSwitchExpression
                     ? CreateConversion(oldValue.Syntax, oldValue, underlyingConversions[i], isCast: false, conversionGroupOpt: null, destination, diagnostics)
                     : GenerateConversionForAssignment(destination, oldValue, diagnostics);
                 var newCase = (oldValue == newValue) ? oldCase :
-                    new BoundSwitchExpressionArm(oldCase.Syntax, oldCase.Locals, oldCase.Pattern, oldCase.WhenClause, newValue, oldCase.Label, oldCase.HasErrors);
+                    new BoundSwitchExpressionArm(oldCase.Syntax, oldCase.Locals, oldCase.Pattern, oldCase.HasUnionMatching, oldCase.WhenClause, newValue, oldCase.Label, oldCase.HasErrors);
                 builder.Add(newCase);
             }
             conversion.MarkUnderlyingConversionsChecked();

src/Compilers/CSharp/Portable/Binder/Binder_Operators.cs

@@ -4865,19 +4865,23 @@ private BoundExpression BindIsOperator(BinaryExpressionSyntax node, BindingDiagn
                     operand = ToBadExpression(operand);
                 }
 
+                TypeSymbol inputType = operand.Type;
+                NamedTypeSymbol unionType = PrepareForUnionMatchingIfAppropriateAndReturnUnionType(node, ref inputType, isPatternDiagnostics);
+
                 bool hasErrors = node.Right.HasErrors;
-                var convertedExpression = BindExpressionForPattern(operand.Type, node.Right, ref hasErrors, isPatternDiagnostics, out var constantValueOpt, out var wasExpression, out _);
+                var convertedExpression = BindExpressionForPattern(inputType, node.Right, ref hasErrors, isPatternDiagnostics, out var constantValueOpt, out var wasExpression, out _);
                 if (wasExpression)
                 {
                     hasErrors |= constantValueOpt is null;
                     isTypeDiagnostics.Free();
                     diagnostics.AddRangeAndFree(isPatternDiagnostics);
+
                     var boundConstantPattern = new BoundConstantPattern(
-                        node.Right, convertedExpression, constantValueOpt ?? ConstantValue.Bad, operand.Type, convertedExpression.Type ?? operand.Type, hasErrors)
+                        node.Right, convertedExpression, constantValueOpt ?? ConstantValue.Bad, isUnionMatching: unionType is not null, inputType: unionType ?? inputType, convertedExpression.Type ?? inputType, hasErrors)
 #pragma warning disable format
                         { WasCompilerGenerated = true };
 #pragma warning restore format
-                    return MakeIsPatternExpression(node, operand, boundConstantPattern, resultType, operandHasErrors, diagnostics);
+                    return MakeIsPatternExpression(node, operand, boundConstantPattern, boundConstantPattern.IsUnionMatching, resultType, operandHasErrors, diagnostics);
                 }
 
                 isPatternDiagnostics.Free();

src/Compilers/CSharp/Portable/Binder/Binder_Patterns.cs

@@ -115,25 +115,27 @@ public static BoundDecisionDag CreateDecisionDagForIsPattern(
             SyntaxNode syntax,
             BoundExpression inputExpression,
             BoundPattern pattern,
+            bool hasUnionMatching,
             LabelSymbol whenTrueLabel,
             LabelSymbol whenFalseLabel,
             BindingDiagnosticBag diagnostics,
             bool forLowering = false)
         {
             var builder = new DecisionDagBuilder(compilation, defaultLabel: whenFalseLabel, forLowering, diagnostics);
-            return builder.CreateDecisionDagForIsPattern(syntax, inputExpression, pattern, whenTrueLabel);
+            return builder.CreateDecisionDagForIsPattern(syntax, inputExpression, pattern, hasUnionMatching, whenTrueLabel);
         }
 
         private BoundDecisionDag CreateDecisionDagForIsPattern(
             SyntaxNode syntax,
             BoundExpression inputExpression,
             BoundPattern pattern,
+            bool hasUnionMatching,
             LabelSymbol whenTrueLabel)
         {
             var rootIdentifier = BoundDagTemp.ForOriginalInput(inputExpression);
 
             using var builder = TemporaryArray<StateForCase>.Empty;
-            builder.Add(MakeTestsForPattern(index: 1, pattern.Syntax, rootIdentifier, pattern, whenClause: null, whenTrueLabel));
+            builder.Add(MakeTestsForPattern(index: 1, pattern.Syntax, rootIdentifier, pattern, hasUnionMatching, whenClause: null, whenTrueLabel));
 
             return MakeBoundDecisionDag(syntax, ref builder.AsRef());
         }
@@ -152,7 +154,7 @@ private BoundDecisionDag CreateDecisionDagForSwitchStatement(
                 {
                     if (label.Syntax.Kind() != SyntaxKind.DefaultSwitchLabel)
                     {
-                        builder.Add(MakeTestsForPattern(++i, label.Syntax, rootIdentifier, label.Pattern, label.WhenClause, label.Label));
+                        builder.Add(MakeTestsForPattern(++i, label.Syntax, rootIdentifier, label.Pattern, label.HasUnionMatching, label.WhenClause, label.Label));
                     }
                 }
             }
@@ -172,7 +174,7 @@ private BoundDecisionDag CreateDecisionDagForSwitchExpression(
             int i = 0;
             using var builder = TemporaryArray<StateForCase>.GetInstance(switchArms.Length);
             foreach (BoundSwitchExpressionArm arm in switchArms)
-                builder.Add(MakeTestsForPattern(++i, arm.Syntax, rootIdentifier, arm.Pattern, arm.WhenClause, arm.Label));
+                builder.Add(MakeTestsForPattern(++i, arm.Syntax, rootIdentifier, arm.Pattern, arm.HasUnionMatching, arm.WhenClause, arm.Label));
 
             return MakeBoundDecisionDag(syntax, ref builder.AsRef());
         }
@@ -185,9 +187,15 @@ private StateForCase MakeTestsForPattern(
             SyntaxNode syntax,
             BoundDagTemp input,
             BoundPattern pattern,
+            bool hasUnionMatching,
             BoundExpression? whenClause,
             LabelSymbol label)
         {
+            if (hasUnionMatching)
+            {
+                pattern = UnionMatchingRewriter.Rewrite(_compilation, pattern);
+            }
+
             Tests tests = MakeAndSimplifyTestsAndBindings(input, pattern, out ImmutableArray<BoundPatternBinding> bindings);
             return new StateForCase(index, syntax, tests, bindings, whenClause, label);
         }
@@ -330,6 +338,7 @@ private Tests MakeTestsAndBindings(
             out BoundDagTemp output,
             ArrayBuilder<BoundPatternBinding> bindings)
         {
+            Debug.Assert(!pattern.IsUnionMatching);
             Debug.Assert(pattern.HasErrors || pattern.InputType.Equals(input.Type, TypeCompareKind.AllIgnoreOptions) || pattern.InputType.IsErrorType());
             switch (pattern)
             {