Store nested conversion in the target-typed switch expression conversion

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

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Linq;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
@@ -104,7 +105,7 @@ protected BoundExpression CreateConversion(
 
             if (conversion.Kind == ConversionKind.SwitchExpression)
             {
-                return ConvertSwitchExpression((BoundUnconvertedSwitchExpression)source, destination, targetTyped: true, diagnostics);
+                return ConvertSwitchExpression((BoundUnconvertedSwitchExpression)source, destination, conversionIfTargetTyped: conversion, diagnostics);
             }
 
             if (source.Kind == BoundKind.UnconvertedSwitchExpression)
@@ -117,7 +118,7 @@ protected BoundExpression CreateConversion(
                     hasErrors = true;
                 }
 
-                source = ConvertSwitchExpression((BoundUnconvertedSwitchExpression)source, type, targetTyped: false, diagnostics, hasErrors);
+                source = ConvertSwitchExpression((BoundUnconvertedSwitchExpression)source, type, conversionIfTargetTyped: null, diagnostics, hasErrors);
                 if (destination.Equals(type, TypeCompareKind.ConsiderEverything) && wasCompilerGenerated)
                 {
                     return source;
@@ -151,17 +152,24 @@ protected BoundExpression CreateConversion(
             { WasCompilerGenerated = wasCompilerGenerated };
         }
 
+#nullable enable
         /// <summary>
         /// Rewrite the expressions in the switch expression arms to add a conversion to the destination type.
         /// </summary>
-        private BoundExpression ConvertSwitchExpression(BoundUnconvertedSwitchExpression source, TypeSymbol destination, bool targetTyped, DiagnosticBag diagnostics, bool hasErrors = false)
+        private BoundExpression ConvertSwitchExpression(BoundUnconvertedSwitchExpression source, TypeSymbol destination, Conversion? conversionIfTargetTyped, DiagnosticBag diagnostics, bool hasErrors = false)
         {
+            bool targetTyped = conversionIfTargetTyped != null;
             Debug.Assert(targetTyped || destination.IsErrorType() || destination.Equals(source.Type, TypeCompareKind.ConsiderEverything));
+            ImmutableArray<Conversion> underlyingConversions = conversionIfTargetTyped.GetValueOrDefault().UnderlyingConversions;
             var builder = ArrayBuilder<BoundSwitchExpressionArm>.GetInstance(source.SwitchArms.Length);
-            foreach (var oldCase in source.SwitchArms)
+            for (int i = 0, n = source.SwitchArms.Length; i < n; i++)
             {
+                var oldCase = source.SwitchArms[i];
                 var oldValue = oldCase.Value;
-                var newValue = GenerateConversionForAssignment(destination, oldValue, diagnostics);
+                var newValue =
+                    targetTyped
+                    ? 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);
                 builder.Add(newCase);
@@ -172,6 +180,7 @@ private BoundExpression ConvertSwitchExpression(BoundUnconvertedSwitchExpression
                 source.Syntax, source.Type, targetTyped, source.Expression, newSwitchArms, source.DecisionDag,
                 source.DefaultLabel, source.ReportedNotExhaustive, destination, hasErrors || source.HasErrors);
         }
+#nullable restore
 
         private BoundExpression CreateUserDefinedConversion(
             SyntaxNode syntax,

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

@@ -270,7 +270,7 @@ internal BoundExpression BindToNaturalType(BoundExpression expression, Diagnosti
                             commonType = CreateErrorType();
                             hasErrors = true;
                         }
-                        result = ConvertSwitchExpression(expr, commonType, targetTyped: false, diagnostics, hasErrors);
+                        result = ConvertSwitchExpression(expr, commonType, conversionIfTargetTyped: null, diagnostics, hasErrors);
                     }
                     break;
                 case BoundTupleLiteral sourceTuple:

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

@@ -961,7 +961,7 @@ private BoundCall BindInvocationExpressionContinued(
                                 _ = BindToNaturalType(argument, diagnostics);
                                 break;
                             case BoundUnconvertedSwitchExpression { Type: { } naturalType } switchExpr:
-                                _ = ConvertSwitchExpression(switchExpr, naturalType ?? CreateErrorType(), targetTyped: false, diagnostics);
+                                _ = ConvertSwitchExpression(switchExpr, naturalType ?? CreateErrorType(), conversionIfTargetTyped: null, diagnostics);
                                 break;
                         }
                     }

src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/Conversion.cs

@@ -238,7 +238,6 @@ internal static Conversion GetTrivialConversion(ConversionKind kind)
         internal static Conversion ImplicitDynamic => new Conversion(ConversionKind.ImplicitDynamic);
         internal static Conversion ExplicitDynamic => new Conversion(ConversionKind.ExplicitDynamic);
         internal static Conversion InterpolatedString => new Conversion(ConversionKind.InterpolatedString);
-        internal static Conversion SwitchExpression => new Conversion(ConversionKind.SwitchExpression);
         internal static Conversion Deconstruction => new Conversion(ConversionKind.Deconstruction);
         internal static Conversion PinnedObjectToPointer => new Conversion(ConversionKind.PinnedObjectToPointer);
 
@@ -306,6 +305,11 @@ internal static Conversion MakeNullableConversion(ConversionKind kind, Conversio
             return new Conversion(kind, nested);
         }
 
+        internal static Conversion MakeSwitchExpression(ImmutableArray<Conversion> innerConversions)
+        {
+            return new Conversion(ConversionKind.SwitchExpression, innerConversions);
+        }
+
         internal ConversionKind Kind
         {
             get

src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionsBase.cs

@@ -935,15 +935,20 @@ private Conversion GetSwitchExpressionConversion(BoundExpression source, TypeSym
                     // It has already been subjected to a switch expression conversion.
                     return Conversion.NoConversion;
                 case BoundUnconvertedSwitchExpression switchExpression:
+                    var innerConversions = ArrayBuilder<Conversion>.GetInstance(switchExpression.SwitchArms.Length);
                     foreach (var arm in switchExpression.SwitchArms)
                     {
-                        if (!this.ClassifyConversionFromExpression(arm.Value, destination, ref useSiteDiagnostics).IsImplicit)
+                        var nestedConversion = this.ClassifyImplicitConversionFromExpression(arm.Value, destination, ref useSiteDiagnostics);
+                        if (!nestedConversion.Exists)
                         {
+                            innerConversions.Free();
                             return Conversion.NoConversion;
                         }
+
+                        innerConversions.Add(nestedConversion);
                     }
 
-                    return Conversion.SwitchExpression;
+                    return Conversion.MakeSwitchExpression(innerConversions.ToImmutableAndFree());
                 default:
                     return Conversion.NoConversion;
             }

src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml

@@ -1267,7 +1267,7 @@
     <!-- Converted switch expression must have a type, even if that's `void` for a statement. -->
     <Field Name="Type" Type="TypeSymbol" Override="true" Null="disallow"/>
     <!-- Natural type is preserved for the purpose of semantic model. Can be `null`. -->
-    <Field Name="NaturalTypeOpt" Type="TypeSymbol" Null="allow"/>
+    <Field Name="NaturalTypeOpt" Type="TypeSymbol?" Null="allow"/>
     <Field Name="WasTargetTyped" Type="bool" />
   </Node>