Use switch expression

src/Features/CSharp/Portable/ExtractMethod/CSharpSelectionResult.StatementResult.cs

@@ -30,17 +30,16 @@ private class StatementResult : CSharpSelectionResult
             public override bool ContainingScopeHasAsyncKeyword()
             {
                 var node = this.GetContainingScope();
-                var semanticModel = this.SemanticDocument.SemanticModel;
 
-                switch (node)
+                return node switch
                 {
-                    case AccessorDeclarationSyntax access: return false;
-                    case MethodDeclarationSyntax method: return method.Modifiers.Any(SyntaxKind.AsyncKeyword);
-                    case ParenthesizedLambdaExpressionSyntax lambda: return lambda.AsyncKeyword.Kind() == SyntaxKind.AsyncKeyword;
-                    case SimpleLambdaExpressionSyntax lambda: return lambda.AsyncKeyword.Kind() == SyntaxKind.AsyncKeyword;
-                    case AnonymousMethodExpressionSyntax anonymous: return anonymous.AsyncKeyword.Kind() == SyntaxKind.AsyncKeyword;
-                    default: return false;
-                }
+                    AccessorDeclarationSyntax access => false,
+                    MethodDeclarationSyntax method => method.Modifiers.Any(SyntaxKind.AsyncKeyword),
+                    ParenthesizedLambdaExpressionSyntax lambda => lambda.AsyncKeyword.Kind() == SyntaxKind.AsyncKeyword,
+                    SimpleLambdaExpressionSyntax lambda => lambda.AsyncKeyword.Kind() == SyntaxKind.AsyncKeyword,
+                    AnonymousMethodExpressionSyntax anonymous => anonymous.AsyncKeyword.Kind() == SyntaxKind.AsyncKeyword,
+                    _ => false,
+                };
             }
 
             public override SyntaxNode GetContainingScope()

src/VisualStudio/Core/Impl/CodeModel/MethodXml/AbstractMethodXmlBuilder.cs

@@ -221,17 +221,12 @@ private AttributeInfo RankAttribute(int rank)
         }
 
         private AttributeInfo SpecialCastKindAttribute(SpecialCastKind? specialCastKind = null)
-        {
-            switch (specialCastKind)
+            => specialCastKind switch
             {
-                case SpecialCastKind.DirectCast:
-                    return new AttributeInfo(DirectCastAttributeName, "yes");
-                case SpecialCastKind.TryCast:
-                    return new AttributeInfo(TryCastAttributeName, "yes");
-                default:
-                    return AttributeInfo.Empty;
-            }
-        }
+                SpecialCastKind.DirectCast => new AttributeInfo(DirectCastAttributeName, "yes"),
+                SpecialCastKind.TryCast => new AttributeInfo(TryCastAttributeName, "yes"),
+                _ => AttributeInfo.Empty,
+            };
 
         private AttributeInfo TypeAttribute(string typeName)
         {

src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs

@@ -3741,43 +3741,25 @@ public override SyntaxNode TypeExpression(ITypeSymbol typeSymbol)
         }
 
         public override SyntaxNode TypeExpression(SpecialType specialType)
-        {
-            switch (specialType)
-            {
-                case SpecialType.System_Boolean:
-                    return SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.BoolKeyword));
-                case SpecialType.System_Byte:
-                    return SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.ByteKeyword));
-                case SpecialType.System_Char:
-                    return SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.CharKeyword));
-                case SpecialType.System_Decimal:
-                    return SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.DecimalKeyword));
-                case SpecialType.System_Double:
-                    return SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.DoubleKeyword));
-                case SpecialType.System_Int16:
-                    return SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.ShortKeyword));
-                case SpecialType.System_Int32:
-                    return SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword));
-                case SpecialType.System_Int64:
-                    return SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.LongKeyword));
-                case SpecialType.System_Object:
-                    return SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.ObjectKeyword));
-                case SpecialType.System_SByte:
-                    return SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.SByteKeyword));
-                case SpecialType.System_Single:
-                    return SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.FloatKeyword));
-                case SpecialType.System_String:
-                    return SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.StringKeyword));
-                case SpecialType.System_UInt16:
-                    return SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.UShortKeyword));
-                case SpecialType.System_UInt32:
-                    return SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.UIntKeyword));
-                case SpecialType.System_UInt64:
-                    return SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.ULongKeyword));
-                default:
-                    throw new NotSupportedException("Unsupported SpecialType");
-            }
-        }
+            => specialType switch
+            {
+                SpecialType.System_Boolean => SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.BoolKeyword)),
+                SpecialType.System_Byte => SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.ByteKeyword)),
+                SpecialType.System_Char => SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.CharKeyword)),
+                SpecialType.System_Decimal => SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.DecimalKeyword)),
+                SpecialType.System_Double => SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.DoubleKeyword)),
+                SpecialType.System_Int16 => SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.ShortKeyword)),
+                SpecialType.System_Int32 => SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)),
+                SpecialType.System_Int64 => SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.LongKeyword)),
+                SpecialType.System_Object => SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.ObjectKeyword)),
+                SpecialType.System_SByte => SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.SByteKeyword)),
+                SpecialType.System_Single => SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.FloatKeyword)),
+                SpecialType.System_String => SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.StringKeyword)),
+                SpecialType.System_UInt16 => SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.UShortKeyword)),
+                SpecialType.System_UInt32 => SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.UIntKeyword)),
+                SpecialType.System_UInt64 => SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.ULongKeyword)),
+                _ => throw new NotSupportedException("Unsupported SpecialType"),
+            };
 
         public override SyntaxNode ArrayTypeExpression(SyntaxNode type)
         {

src/Workspaces/CSharp/Portable/Indentation/CSharpIndentationService.Indenter.cs

@@ -265,26 +265,17 @@ private IndentationResult GetIndentationBasedOnToken(SyntaxToken token)
             }
 
             private IndentationResult GetIndentationFromCommaSeparatedList(SyntaxToken token)
-            {
-                var node = token.Parent;
-                switch (node)
+                => token.Parent switch
                 {
-                    case BaseArgumentListSyntax argument:
-                        return GetIndentationFromCommaSeparatedList(argument.Arguments, token);
-                    case BaseParameterListSyntax parameter:
-                        return GetIndentationFromCommaSeparatedList(parameter.Parameters, token);
-                    case TypeArgumentListSyntax typeArgument:
-                        return GetIndentationFromCommaSeparatedList(typeArgument.Arguments, token);
-                    case TypeParameterListSyntax typeParameter:
-                        return GetIndentationFromCommaSeparatedList(typeParameter.Parameters, token);
-                    case EnumDeclarationSyntax enumDeclaration:
-                        return GetIndentationFromCommaSeparatedList(enumDeclaration.Members, token);
-                    case InitializerExpressionSyntax initializerSyntax:
-                        return GetIndentationFromCommaSeparatedList(initializerSyntax.Expressions, token);
-                }
-
-                return GetDefaultIndentationFromToken(token);
-            }
+                    BaseArgumentListSyntax argument => GetIndentationFromCommaSeparatedList(argument.Arguments, token),
+                    BaseParameterListSyntax parameter => GetIndentationFromCommaSeparatedList(parameter.Parameters, token),
+                    TypeArgumentListSyntax typeArgument => GetIndentationFromCommaSeparatedList(typeArgument.Arguments, token),
+                    TypeParameterListSyntax typeParameter => GetIndentationFromCommaSeparatedList(typeParameter.Parameters, token),
+                    EnumDeclarationSyntax enumDeclaration => GetIndentationFromCommaSeparatedList(enumDeclaration.Members, token),
+                    InitializerExpressionSyntax initializerSyntax => GetIndentationFromCommaSeparatedList(initializerSyntax.Expressions, token),
+
+                    _ => GetDefaultIndentationFromToken(token),
+                };
 
             private IndentationResult GetIndentationFromCommaSeparatedList<T>(SeparatedSyntaxList<T> list, SyntaxToken token) where T : SyntaxNode
             {