Use switch expressions

src/Workspaces/Core/Portable/CodeGeneration/AbstractCodeGenerationService.cs

@@ -290,22 +290,17 @@ protected static T Cast<T>(object value)
             return currentDestination;
         }
 
-        private SyntaxNode GetNewMember(
-            CodeGenerationOptions options, CodeGenerationDestination codeGenerationDestination,
-            ISymbol member, CancellationToken cancellationToken)
-        {
-            switch (member)
+        private SyntaxNode GetNewMember(CodeGenerationOptions options, CodeGenerationDestination codeGenerationDestination, ISymbol member, CancellationToken cancellationToken)
+            => member switch
             {
-                case IEventSymbol @event: return this.CreateEventDeclaration(@event, codeGenerationDestination, options);
-                case IFieldSymbol field: return this.CreateFieldDeclaration(field, codeGenerationDestination, options);
-                case IPropertySymbol property: return this.CreatePropertyDeclaration(property, codeGenerationDestination, options);
-                case IMethodSymbol method: return this.CreateMethodDeclaration(method, codeGenerationDestination, options);
-                case INamedTypeSymbol namedType: return this.CreateNamedTypeDeclaration(namedType, codeGenerationDestination, options, cancellationToken);
-                case INamespaceSymbol @namespace: return this.CreateNamespaceDeclaration(@namespace, codeGenerationDestination, options, cancellationToken);
-            }
-
-            return null;
-        }
+                IEventSymbol @event => this.CreateEventDeclaration(@event, codeGenerationDestination, options),
+                IFieldSymbol field => this.CreateFieldDeclaration(field, codeGenerationDestination, options),
+                IPropertySymbol property => this.CreatePropertyDeclaration(property, codeGenerationDestination, options),
+                IMethodSymbol method => this.CreateMethodDeclaration(method, codeGenerationDestination, options),
+                INamedTypeSymbol namedType => this.CreateNamedTypeDeclaration(namedType, codeGenerationDestination, options, cancellationToken),
+                INamespaceSymbol @namespace => this.CreateNamespaceDeclaration(@namespace, codeGenerationDestination, options, cancellationToken),
+                _ => null,
+            };
 
         private TDeclarationNode UpdateDestination<TDeclarationNode>(
             IList<bool> availableIndices,
@@ -314,17 +309,16 @@ protected static T Cast<T>(object value)
             ISymbol member,
             CancellationToken cancellationToken) where TDeclarationNode : SyntaxNode
         {
-            switch (member)
+            return member switch
             {
-                case IEventSymbol @event: return this.AddEvent(currentDestination, @event, options, availableIndices);
-                case IFieldSymbol field: return this.AddField(currentDestination, field, options, availableIndices);
-                case IPropertySymbol property: return this.AddProperty(currentDestination, property, options, availableIndices);
-                case IMethodSymbol method: return this.AddMethod(currentDestination, method, options, availableIndices);
-                case INamedTypeSymbol namedType: return this.AddNamedType(currentDestination, namedType, options, availableIndices, cancellationToken);
-                case INamespaceSymbol @namespace: return this.AddNamespace(currentDestination, @namespace, options, availableIndices, cancellationToken);
-            }
-
-            return currentDestination;
+                IEventSymbol @event => this.AddEvent(currentDestination, @event, options, availableIndices),
+                IFieldSymbol field => this.AddField(currentDestination, field, options, availableIndices),
+                IPropertySymbol property => this.AddProperty(currentDestination, property, options, availableIndices),
+                IMethodSymbol method => this.AddMethod(currentDestination, method, options, availableIndices),
+                INamedTypeSymbol namedType => this.AddNamedType(currentDestination, namedType, options, availableIndices, cancellationToken),
+                INamespaceSymbol @namespace => this.AddNamespace(currentDestination, @namespace, options, availableIndices, cancellationToken),
+                _ => currentDestination,
+            };
         }
 
         private bool GeneratingEnum(IEnumerable<ISymbol> members)

src/Workspaces/Core/Portable/CodeGeneration/Symbols/CodeGenerationOperatorSymbol.cs

@@ -75,40 +75,37 @@ public static int GetParameterCount(CodeGenerationOperatorKind operatorKind)
         }
 
         private static string GetMetadataName(CodeGenerationOperatorKind operatorKind)
-        {
-            switch (operatorKind)
+            => operatorKind switch
             {
-                case CodeGenerationOperatorKind.Addition: return WellKnownMemberNames.AdditionOperatorName;
-                case CodeGenerationOperatorKind.BitwiseAnd: return WellKnownMemberNames.BitwiseAndOperatorName;
-                case CodeGenerationOperatorKind.BitwiseOr: return WellKnownMemberNames.BitwiseOrOperatorName;
-                case CodeGenerationOperatorKind.Concatenate: return WellKnownMemberNames.ConcatenateOperatorName;
-                case CodeGenerationOperatorKind.Decrement: return WellKnownMemberNames.DecrementOperatorName;
-                case CodeGenerationOperatorKind.Division: return WellKnownMemberNames.DivisionOperatorName;
-                case CodeGenerationOperatorKind.Equality: return WellKnownMemberNames.EqualityOperatorName;
-                case CodeGenerationOperatorKind.ExclusiveOr: return WellKnownMemberNames.ExclusiveOrOperatorName;
-                case CodeGenerationOperatorKind.Exponent: return WellKnownMemberNames.ExponentOperatorName;
-                case CodeGenerationOperatorKind.False: return WellKnownMemberNames.FalseOperatorName;
-                case CodeGenerationOperatorKind.GreaterThan: return WellKnownMemberNames.GreaterThanOperatorName;
-                case CodeGenerationOperatorKind.GreaterThanOrEqual: return WellKnownMemberNames.GreaterThanOrEqualOperatorName;
-                case CodeGenerationOperatorKind.Increment: return WellKnownMemberNames.IncrementOperatorName;
-                case CodeGenerationOperatorKind.Inequality: return WellKnownMemberNames.InequalityOperatorName;
-                case CodeGenerationOperatorKind.IntegerDivision: return WellKnownMemberNames.IntegerDivisionOperatorName;
-                case CodeGenerationOperatorKind.LeftShift: return WellKnownMemberNames.LeftShiftOperatorName;
-                case CodeGenerationOperatorKind.LessThan: return WellKnownMemberNames.LessThanOperatorName;
-                case CodeGenerationOperatorKind.LessThanOrEqual: return WellKnownMemberNames.LessThanOrEqualOperatorName;
-                case CodeGenerationOperatorKind.Like: return WellKnownMemberNames.LikeOperatorName;
-                case CodeGenerationOperatorKind.LogicalNot: return WellKnownMemberNames.LogicalNotOperatorName;
-                case CodeGenerationOperatorKind.Modulus: return WellKnownMemberNames.ModulusOperatorName;
-                case CodeGenerationOperatorKind.Multiplication: return WellKnownMemberNames.MultiplyOperatorName;
-                case CodeGenerationOperatorKind.OnesComplement: return WellKnownMemberNames.OnesComplementOperatorName;
-                case CodeGenerationOperatorKind.RightShift: return WellKnownMemberNames.RightShiftOperatorName;
-                case CodeGenerationOperatorKind.Subtraction: return WellKnownMemberNames.SubtractionOperatorName;
-                case CodeGenerationOperatorKind.True: return WellKnownMemberNames.TrueOperatorName;
-                case CodeGenerationOperatorKind.UnaryPlus: return WellKnownMemberNames.UnaryPlusOperatorName;
-                case CodeGenerationOperatorKind.UnaryNegation: return WellKnownMemberNames.UnaryNegationOperatorName;
-                default:
-                    throw ExceptionUtilities.UnexpectedValue(operatorKind);
-            }
-        }
+                CodeGenerationOperatorKind.Addition => WellKnownMemberNames.AdditionOperatorName,
+                CodeGenerationOperatorKind.BitwiseAnd => WellKnownMemberNames.BitwiseAndOperatorName,
+                CodeGenerationOperatorKind.BitwiseOr => WellKnownMemberNames.BitwiseOrOperatorName,
+                CodeGenerationOperatorKind.Concatenate => WellKnownMemberNames.ConcatenateOperatorName,
+                CodeGenerationOperatorKind.Decrement => WellKnownMemberNames.DecrementOperatorName,
+                CodeGenerationOperatorKind.Division => WellKnownMemberNames.DivisionOperatorName,
+                CodeGenerationOperatorKind.Equality => WellKnownMemberNames.EqualityOperatorName,
+                CodeGenerationOperatorKind.ExclusiveOr => WellKnownMemberNames.ExclusiveOrOperatorName,
+                CodeGenerationOperatorKind.Exponent => WellKnownMemberNames.ExponentOperatorName,
+                CodeGenerationOperatorKind.False => WellKnownMemberNames.FalseOperatorName,
+                CodeGenerationOperatorKind.GreaterThan => WellKnownMemberNames.GreaterThanOperatorName,
+                CodeGenerationOperatorKind.GreaterThanOrEqual => WellKnownMemberNames.GreaterThanOrEqualOperatorName,
+                CodeGenerationOperatorKind.Increment => WellKnownMemberNames.IncrementOperatorName,
+                CodeGenerationOperatorKind.Inequality => WellKnownMemberNames.InequalityOperatorName,
+                CodeGenerationOperatorKind.IntegerDivision => WellKnownMemberNames.IntegerDivisionOperatorName,
+                CodeGenerationOperatorKind.LeftShift => WellKnownMemberNames.LeftShiftOperatorName,
+                CodeGenerationOperatorKind.LessThan => WellKnownMemberNames.LessThanOperatorName,
+                CodeGenerationOperatorKind.LessThanOrEqual => WellKnownMemberNames.LessThanOrEqualOperatorName,
+                CodeGenerationOperatorKind.Like => WellKnownMemberNames.LikeOperatorName,
+                CodeGenerationOperatorKind.LogicalNot => WellKnownMemberNames.LogicalNotOperatorName,
+                CodeGenerationOperatorKind.Modulus => WellKnownMemberNames.ModulusOperatorName,
+                CodeGenerationOperatorKind.Multiplication => WellKnownMemberNames.MultiplyOperatorName,
+                CodeGenerationOperatorKind.OnesComplement => WellKnownMemberNames.OnesComplementOperatorName,
+                CodeGenerationOperatorKind.RightShift => WellKnownMemberNames.RightShiftOperatorName,
+                CodeGenerationOperatorKind.Subtraction => WellKnownMemberNames.SubtractionOperatorName,
+                CodeGenerationOperatorKind.True => WellKnownMemberNames.TrueOperatorName,
+                CodeGenerationOperatorKind.UnaryPlus => WellKnownMemberNames.UnaryPlusOperatorName,
+                CodeGenerationOperatorKind.UnaryNegation => WellKnownMemberNames.UnaryNegationOperatorName,
+                _ => throw ExceptionUtilities.UnexpectedValue(operatorKind),
+            };
     }
 }

src/Workspaces/Core/Portable/Shared/Extensions/ITypeSymbolExtensions.cs

@@ -155,20 +155,14 @@ internal static partial class ITypeSymbolExtensions
         }
 
 
-        public static ISymbol? FindImplementations(
-            this ITypeSymbol typeSymbol,
-            ISymbol constructedInterfaceMember,
-            Workspace workspace)
-        {
-            switch (constructedInterfaceMember)
+        public static ISymbol? FindImplementations(this ITypeSymbol typeSymbol, ISymbol constructedInterfaceMember, Workspace workspace)
+            => constructedInterfaceMember switch
             {
-                case IEventSymbol eventSymbol: return typeSymbol.FindImplementations(eventSymbol, workspace);
-                case IMethodSymbol methodSymbol: return typeSymbol.FindImplementations(methodSymbol, workspace);
-                case IPropertySymbol propertySymbol: return typeSymbol.FindImplementations(propertySymbol, workspace);
-            }
-
-            return null;
-        }
+                IEventSymbol eventSymbol => typeSymbol.FindImplementations(eventSymbol, workspace),
+                IMethodSymbol methodSymbol => typeSymbol.FindImplementations(methodSymbol, workspace),
+                IPropertySymbol propertySymbol => typeSymbol.FindImplementations(propertySymbol, workspace),
+                _ => null,
+            };
 
         private static ISymbol? FindImplementations<TSymbol>(
             this ITypeSymbol typeSymbol,

src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/INamedTypeSymbolExtensions.cs

@@ -77,16 +77,13 @@ public static bool IsContainedWithin([NotNullWhen(returnValue: true)] this IName
         }
 
         internal static ISymbol? GetOverriddenMember(this ISymbol? symbol)
-        {
-            switch (symbol)
+            => symbol switch
             {
-                case IMethodSymbol method: return method.OverriddenMethod;
-                case IPropertySymbol property: return property.OverriddenProperty;
-                case IEventSymbol @event: return @event.OverriddenEvent;
-            }
-
-            return null;
-        }
+                IMethodSymbol method => method.OverriddenMethod,
+                IPropertySymbol property => property.OverriddenProperty,
+                IEventSymbol @event => @event.OverriddenEvent,
+                _ => null,
+            };
 
         private static bool ImplementationExists(INamedTypeSymbol classOrStructType, ISymbol member)
         {
@@ -179,13 +176,13 @@ private static bool IsAbstractPropertyImplemented(INamedTypeSymbol classOrStruct
                 return true;
             }
 
-            switch (implementation)
+            return implementation switch
             {
-                case IEventSymbol @event: return @event.ExplicitInterfaceImplementations.Length > 0;
-                case IMethodSymbol method: return method.ExplicitInterfaceImplementations.Length > 0;
-                case IPropertySymbol property: return property.ExplicitInterfaceImplementations.Length > 0;
-                default: return false;
-            }
+                IEventSymbol @event => @event.ExplicitInterfaceImplementations.Length > 0,
+                IMethodSymbol method => method.ExplicitInterfaceImplementations.Length > 0,
+                IPropertySymbol property => property.ExplicitInterfaceImplementations.Length > 0,
+                _ => false,
+            };
         }
 
         public static ImmutableArray<(INamedTypeSymbol type, ImmutableArray<ISymbol> members)> GetAllUnimplementedMembers(

src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/ISymbolExtensions.cs

@@ -79,21 +79,13 @@ public static SymbolVisibility GetResultantVisibility(this ISymbol symbol)
         }
 
         public static ISymbol? OverriddenMember(this ISymbol symbol)
-        {
-            switch (symbol.Kind)
+            => symbol.Kind switch
             {
-                case SymbolKind.Event:
-                    return ((IEventSymbol)symbol).OverriddenEvent;
-
-                case SymbolKind.Method:
-                    return ((IMethodSymbol)symbol).OverriddenMethod;
-
-                case SymbolKind.Property:
-                    return ((IPropertySymbol)symbol).OverriddenProperty;
-            }
-
-            return null;
-        }
+                SymbolKind.Event => ((IEventSymbol)symbol).OverriddenEvent,
+                SymbolKind.Method => ((IMethodSymbol)symbol).OverriddenMethod,
+                SymbolKind.Property => ((IPropertySymbol)symbol).OverriddenProperty,
+                _ => null,
+            };
 
         public static ImmutableArray<ISymbol> ExplicitInterfaceImplementations(this ISymbol symbol)
             => symbol switch
@@ -330,47 +322,30 @@ public static bool IsIndexer([NotNullWhen(returnValue: true)] this ISymbol? symb
         }
 
         public static bool IsWriteableFieldOrProperty([NotNullWhen(returnValue: true)] this ISymbol? symbol)
-        {
-            switch (symbol)
+            => symbol switch
             {
-                case IFieldSymbol fieldSymbol:
-                    return !fieldSymbol.IsReadOnly && !fieldSymbol.IsConst;
-                case IPropertySymbol propertySymbol:
-                    return !propertySymbol.IsReadOnly;
-            }
-
-            return false;
-        }
+                IFieldSymbol fieldSymbol => !fieldSymbol.IsReadOnly && !fieldSymbol.IsConst,
+                IPropertySymbol propertySymbol => !propertySymbol.IsReadOnly,
+                _ => false,
+            };
 
         public static ITypeSymbol? GetMemberType(this ISymbol symbol)
-        {
-            switch (symbol)
+            => symbol switch
             {
-                case IFieldSymbol fieldSymbol:
-                    return fieldSymbol.Type;
-                case IPropertySymbol propertySymbol:
-                    return propertySymbol.Type;
-                case IMethodSymbol methodSymbol:
-                    return methodSymbol.ReturnType;
-                case IEventSymbol eventSymbol:
-                    return eventSymbol.Type;
-            }
-
-            return null;
-        }
+                IFieldSymbol fieldSymbol => fieldSymbol.Type,
+                IPropertySymbol propertySymbol => propertySymbol.Type,
+                IMethodSymbol methodSymbol => methodSymbol.ReturnType,
+                IEventSymbol eventSymbol => eventSymbol.Type,
+                _ => null,
+            };
 
         public static int GetArity(this ISymbol symbol)
-        {
-            switch (symbol.Kind)
+            => symbol.Kind switch
             {
-                case SymbolKind.NamedType:
-                    return ((INamedTypeSymbol)symbol).Arity;
-                case SymbolKind.Method:
-                    return ((IMethodSymbol)symbol).Arity;
-                default:
-                    return 0;
-            }
-        }
+                SymbolKind.NamedType => ((INamedTypeSymbol)symbol).Arity,
+                SymbolKind.Method => ((IMethodSymbol)symbol).Arity,
+                _ => 0,
+            };
 
         [return: NotNullIfNotNull(parameterName: "symbol")]
         public static ISymbol? GetOriginalUnreducedDefinition(this ISymbol? symbol)
@@ -442,24 +417,20 @@ public static bool IsParams([NotNullWhen(returnValue: true)] this ISymbol? symbo
         }
 
         public static ImmutableArray<IParameterSymbol> GetParameters(this ISymbol? symbol)
-        {
-            switch (symbol)
+            => symbol switch
             {
-                case IMethodSymbol m: return m.Parameters;
-                case IPropertySymbol nt: return nt.Parameters;
-                default: return ImmutableArray<IParameterSymbol>.Empty;
-            }
-        }
+                IMethodSymbol m => m.Parameters,
+                IPropertySymbol nt => nt.Parameters,
+                _ => ImmutableArray<IParameterSymbol>.Empty,
+            };
 
         public static ImmutableArray<ITypeParameterSymbol> GetTypeParameters(this ISymbol? symbol)
-        {
-            switch (symbol)
+            => symbol switch
             {
-                case IMethodSymbol m: return m.TypeParameters;
-                case INamedTypeSymbol nt: return nt.TypeParameters;
-                default: return ImmutableArray<ITypeParameterSymbol>.Empty;
-            }
-        }
+                IMethodSymbol m => m.TypeParameters,
+                INamedTypeSymbol nt => nt.TypeParameters,
+                _ => ImmutableArray<ITypeParameterSymbol>.Empty,
+            };
 
         public static ImmutableArray<ITypeParameterSymbol> GetAllTypeParameters(this ISymbol? symbol)
         {
@@ -475,14 +446,12 @@ public static ImmutableArray<ITypeParameterSymbol> GetAllTypeParameters(this ISy
         }
 
         public static ImmutableArray<ITypeSymbol> GetTypeArguments(this ISymbol? symbol)
-        {
-            switch (symbol)
+            => symbol switch
             {
-                case IMethodSymbol m: return m.TypeArguments;
-                case INamedTypeSymbol nt: return nt.TypeArguments;
-                default: return ImmutableArray.Create<ITypeSymbol>();
-            }
-        }
+                IMethodSymbol m => m.TypeArguments,
+                INamedTypeSymbol nt => nt.TypeArguments,
+                _ => ImmutableArray.Create<ITypeSymbol>(),
+            };
 
         public static ImmutableArray<ITypeSymbol> GetAllTypeArguments(this ISymbol symbol)
         {
@@ -665,23 +634,15 @@ public static bool IsNonImplicitAndFromSource(this ISymbol symbol)
             => !symbol.IsImplicitlyDeclared && symbol.IsFromSource();
 
         public static ITypeSymbol? GetSymbolType(this ISymbol? symbol)
-        {
-            switch (symbol)
-            {
-                case ILocalSymbol localSymbol:
-                    return localSymbol.Type;
-                case IFieldSymbol fieldSymbol:
-                    return fieldSymbol.Type;
-                case IPropertySymbol propertySymbol:
-                    return propertySymbol.Type;
-                case IParameterSymbol parameterSymbol:
-                    return parameterSymbol.Type;
-                case IAliasSymbol aliasSymbol:
-                    return aliasSymbol.Target as ITypeSymbol;
-            }
-
-            return symbol as ITypeSymbol;
-        }
+            => symbol switch
+            {
+                ILocalSymbol localSymbol => localSymbol.Type,
+                IFieldSymbol fieldSymbol => fieldSymbol.Type,
+                IPropertySymbol propertySymbol => propertySymbol.Type,
+                IParameterSymbol parameterSymbol => parameterSymbol.Type,
+                IAliasSymbol aliasSymbol => aliasSymbol.Target as ITypeSymbol,
+                _ => symbol as ITypeSymbol,
+            };
 
         /// <summary>
         /// If the <paramref name="symbol"/> is a method symbol, returns <see langword="true"/> if the method's return type is "awaitable", but not if it's <see langword="dynamic"/>.