Merge pull request #48099 from CyrusNajmabadi/useSwitchExprs

Use switch expressions.

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

@@ -1191,18 +1191,14 @@ private SyntaxNode InsertNamespaceImportsInternal(SyntaxNode declaration, int in
         }
 
         public override IReadOnlyList<SyntaxNode> GetMembers(SyntaxNode declaration)
-        {
-            return Flatten(declaration.Kind() switch
+            => Flatten(declaration switch
             {
-                SyntaxKind.ClassDeclaration => ((ClassDeclarationSyntax)declaration).Members,
-                SyntaxKind.StructDeclaration => ((StructDeclarationSyntax)declaration).Members,
-                SyntaxKind.InterfaceDeclaration => ((InterfaceDeclarationSyntax)declaration).Members,
-                SyntaxKind.EnumDeclaration => ((EnumDeclarationSyntax)declaration).Members,
-                SyntaxKind.NamespaceDeclaration => ((NamespaceDeclarationSyntax)declaration).Members,
-                SyntaxKind.CompilationUnit => ((CompilationUnitSyntax)declaration).Members,
+                TypeDeclarationSyntax type => type.Members,
+                EnumDeclarationSyntax @enum => @enum.Members,
+                NamespaceDeclarationSyntax @namespace => @namespace.Members,
+                CompilationUnitSyntax compilationUnit => compilationUnit.Members,
                 _ => SpecializedCollections.EmptyReadOnlyList<SyntaxNode>(),
             });
-        }
 
         private static ImmutableArray<SyntaxNode> Flatten(IEnumerable<SyntaxNode> declarations)
         {
@@ -1287,29 +1283,14 @@ public override SyntaxNode InsertMembers(SyntaxNode declaration, int index, IEnu
             }
             else
             {
-                switch (declaration.Kind())
+                return declaration switch
                 {
-                    case SyntaxKind.ClassDeclaration:
-                        var cd = (ClassDeclarationSyntax)declaration;
-                        return cd.WithMembers(cd.Members.AddRange(newMembers));
-                    case SyntaxKind.StructDeclaration:
-                        var sd = (StructDeclarationSyntax)declaration;
-                        return sd.WithMembers(sd.Members.AddRange(newMembers));
-                    case SyntaxKind.InterfaceDeclaration:
-                        var id = (InterfaceDeclarationSyntax)declaration;
-                        return id.WithMembers(id.Members.AddRange(newMembers));
-                    case SyntaxKind.EnumDeclaration:
-                        var ed = (EnumDeclarationSyntax)declaration;
-                        return ed.WithMembers(ed.Members.AddRange(newMembers.OfType<EnumMemberDeclarationSyntax>()));
-                    case SyntaxKind.NamespaceDeclaration:
-                        var nd = (NamespaceDeclarationSyntax)declaration;
-                        return nd.WithMembers(nd.Members.AddRange(newMembers));
-                    case SyntaxKind.CompilationUnit:
-                        var cu = (CompilationUnitSyntax)declaration;
-                        return cu.WithMembers(cu.Members.AddRange(newMembers));
-                    default:
-                        return declaration;
-                }
+                    TypeDeclarationSyntax type => type.WithMembers(type.Members.AddRange(newMembers)),
+                    EnumDeclarationSyntax @enum => @enum.WithMembers(@enum.Members.AddRange(newMembers.OfType<EnumMemberDeclarationSyntax>())),
+                    NamespaceDeclarationSyntax @namespace => @namespace.WithMembers(@namespace.Members.AddRange(newMembers)),
+                    CompilationUnitSyntax compilationUnit => compilationUnit.WithMembers(compilationUnit.Members.AddRange(newMembers)),
+                    _ => declaration,
+                };
             }
         }
 
@@ -1658,13 +1639,11 @@ public override SyntaxNode WithTypeParameters(SyntaxNode declaration, IEnumerabl
         {
             var typeParameters = AsTypeParameterList(typeParameterNames);
 
-            return declaration.Kind() switch
+            return declaration switch
             {
-                SyntaxKind.MethodDeclaration => ((MethodDeclarationSyntax)declaration).WithTypeParameterList(typeParameters),
-                SyntaxKind.ClassDeclaration => ((ClassDeclarationSyntax)declaration).WithTypeParameterList(typeParameters),
-                SyntaxKind.StructDeclaration => ((StructDeclarationSyntax)declaration).WithTypeParameterList(typeParameters),
-                SyntaxKind.InterfaceDeclaration => ((InterfaceDeclarationSyntax)declaration).WithTypeParameterList(typeParameters),
-                SyntaxKind.DelegateDeclaration => ((DelegateDeclarationSyntax)declaration).WithTypeParameterList(typeParameters),
+                MethodDeclarationSyntax method => method.WithTypeParameterList(typeParameters),
+                TypeDeclarationSyntax type => type.WithTypeParameterList(typeParameters),
+                DelegateDeclarationSyntax @delegate => @delegate.WithTypeParameterList(typeParameters),
                 _ => declaration,
             };
         }
@@ -1682,32 +1661,13 @@ private static ExplicitInterfaceSpecifierSyntax CreateExplicitInterfaceSpecifier
             => SyntaxFactory.ExplicitInterfaceSpecifier(explicitInterfaceImplementations[0].ContainingType.GenerateNameSyntax());
 
         public override SyntaxNode WithTypeConstraint(SyntaxNode declaration, string typeParameterName, SpecialTypeConstraintKind kinds, IEnumerable<SyntaxNode> types)
-        {
-            switch (declaration.Kind())
+            => declaration switch
             {
-                case SyntaxKind.MethodDeclaration:
-                    var method = (MethodDeclarationSyntax)declaration;
-                    return method.WithConstraintClauses(WithTypeConstraints(method.ConstraintClauses, typeParameterName, kinds, types));
-
-                case SyntaxKind.ClassDeclaration:
-                    var cls = (ClassDeclarationSyntax)declaration;
-                    return cls.WithConstraintClauses(WithTypeConstraints(cls.ConstraintClauses, typeParameterName, kinds, types));
-
-                case SyntaxKind.StructDeclaration:
-                    var str = (StructDeclarationSyntax)declaration;
-                    return str.WithConstraintClauses(WithTypeConstraints(str.ConstraintClauses, typeParameterName, kinds, types));
-
-                case SyntaxKind.InterfaceDeclaration:
-                    var iface = (InterfaceDeclarationSyntax)declaration;
-                    return iface.WithConstraintClauses(WithTypeConstraints(iface.ConstraintClauses, typeParameterName, kinds, types));
-
-                case SyntaxKind.DelegateDeclaration:
-                    var del = (DelegateDeclarationSyntax)declaration;
-                    return del.WithConstraintClauses(WithTypeConstraints(del.ConstraintClauses, typeParameterName, kinds, types));
-                default:
-                    return declaration;
-            }
-        }
+                MethodDeclarationSyntax method => method.WithConstraintClauses(WithTypeConstraints(method.ConstraintClauses, typeParameterName, kinds, types)),
+                TypeDeclarationSyntax type => type.WithConstraintClauses(WithTypeConstraints(type.ConstraintClauses, typeParameterName, kinds, types)),
+                DelegateDeclarationSyntax @delegate => @delegate.WithConstraintClauses(WithTypeConstraints(@delegate.ConstraintClauses, typeParameterName, kinds, types)),
+                _ => declaration,
+            };
 
         private static SyntaxList<TypeParameterConstraintClauseSyntax> WithTypeConstraints(
             SyntaxList<TypeParameterConstraintClauseSyntax> clauses, string typeParameterName, SpecialTypeConstraintKind kinds, IEnumerable<SyntaxNode> types)
@@ -2648,22 +2608,14 @@ private static SyntaxNode AddBaseList(SyntaxNode declaration, BaseListSyntax bas
         }
 
         private static BaseListSyntax GetBaseList(SyntaxNode declaration)
-            => declaration.Kind() switch
-            {
-                SyntaxKind.ClassDeclaration => ((ClassDeclarationSyntax)declaration).BaseList,
-                SyntaxKind.StructDeclaration => ((StructDeclarationSyntax)declaration).BaseList,
-                SyntaxKind.InterfaceDeclaration => ((InterfaceDeclarationSyntax)declaration).BaseList,
-                _ => null,
-            };
+            => declaration is TypeDeclarationSyntax typeDeclaration
+                ? typeDeclaration.BaseList
+                : null;
 
         private static SyntaxNode WithBaseList(SyntaxNode declaration, BaseListSyntax baseList)
-            => declaration.Kind() switch
-            {
-                SyntaxKind.ClassDeclaration => ((ClassDeclarationSyntax)declaration).WithBaseList(baseList),
-                SyntaxKind.StructDeclaration => ((StructDeclarationSyntax)declaration).WithBaseList(baseList),
-                SyntaxKind.InterfaceDeclaration => ((InterfaceDeclarationSyntax)declaration).WithBaseList(baseList),
-                _ => declaration,
-            };
+            => declaration is TypeDeclarationSyntax typeDeclaration
+                ? typeDeclaration.WithBaseList(baseList)
+                : declaration;
 
         #endregion