Simplify code using SyntaxFactory.

src/Analyzers/CSharp/Analyzers/UseCollectionExpression/CSharpUseCollectionExpressionForFluentDiagnosticAnalyzer.cs

@@ -21,6 +21,7 @@
 namespace Microsoft.CodeAnalysis.CSharp.UseCollectionExpression;
 
 using static UseCollectionExpressionHelpers;
+using static SyntaxFactory;
 using FluentState = UpdateExpressionState<ExpressionSyntax, StatementSyntax>;
 
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
@@ -42,7 +43,7 @@ internal sealed partial class CSharpUseCollectionExpressionForFluentDiagnosticAn
         nameof(Array),
         nameof(Span<int>),
         nameof(ReadOnlySpan<int>),
-        nameof(List<int>),
+        nameof(System.Collections.Generic.List<int>),
         nameof(HashSet<int>),
         nameof(LinkedList<int>),
         nameof(Queue<int>),
@@ -293,7 +294,7 @@ void AddFinalMatch(ExpressionSyntax expression)
             {
                 // Remove any whitespace around the `.`, making the singly-wrapped fluent expression into a single line.
                 matchesInReverse.Add(new CollectionExpressionMatch<ArgumentSyntax>(
-                    SyntaxFactory.Argument(innerInvocation.WithExpression(
+                    Argument(innerInvocation.WithExpression(
                         memberAccess.Update(
                             memberAccess.Expression.WithoutTrailingTrivia(),
                             memberAccess.OperatorToken.WithoutTrivia(),
@@ -302,7 +303,7 @@ void AddFinalMatch(ExpressionSyntax expression)
                 return;
             }
 
-            matchesInReverse.Add(new CollectionExpressionMatch<ArgumentSyntax>(SyntaxFactory.Argument(expression), UseSpread: true));
+            matchesInReverse.Add(new CollectionExpressionMatch<ArgumentSyntax>(Argument(expression), UseSpread: true));
         }
 
         // We only want to offer this feature when the original collection was list-like (as opposed to being something

src/Analyzers/CSharp/Analyzers/UseCollectionInitializer/CSharpUpdateExpressionSyntaxHelper.cs

@@ -5,7 +5,6 @@
 using System.Collections.Generic;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.UseCollectionInitializer;
-using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.UseCollectionInitializer;
 
@@ -40,5 +39,5 @@ public void GetPartsOfIfStatement(
     }
 
     private static IEnumerable<StatementSyntax> ExtractEmbeddedStatements(StatementSyntax embeddedStatement)
-        => embeddedStatement is BlockSyntax block ? block.Statements : SpecializedCollections.SingletonEnumerable(embeddedStatement);
+        => embeddedStatement is BlockSyntax block ? [.. block.Statements] : [embeddedStatement];
 }

src/Analyzers/CSharp/Analyzers/UseExpressionBody/Helpers/UseExpressionBodyHelper`1.cs

@@ -8,7 +8,6 @@
 using System.Linq;
 using System.Threading;
 using Microsoft.CodeAnalysis.CodeStyle;
-using Microsoft.CodeAnalysis.CSharp.CodeGeneration;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
@@ -17,6 +16,8 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UseExpressionBody;
 
+using static SyntaxFactory;
+
 /// <summary>
 /// Helper class that allows us to share lots of logic between the diagnostic analyzer and the
 /// code refactoring provider.  Those can't share a common base class due to their own inheritance
@@ -160,7 +161,7 @@ protected bool TryConvertToExpressionBodyForBaseProperty(
         if (getAccessor?.ExpressionBody != null &&
             BlockSyntaxExtensions.MatchesPreference(getAccessor.ExpressionBody.Expression, conversionPreference))
         {
-            arrowExpression = SyntaxFactory.ArrowExpressionClause(getAccessor.ExpressionBody.Expression);
+            arrowExpression = ArrowExpressionClause(getAccessor.ExpressionBody.Expression);
             semicolonToken = getAccessor.SemicolonToken;
             return true;
         }
@@ -180,7 +181,7 @@ public bool CanOfferUseBlockBody(
 
         expressionBody = GetExpressionBody(declaration);
         if (expressionBody?.TryConvertToBlock(
-            SyntaxFactory.Token(SyntaxKind.SemicolonToken), false, block: out _) != true)
+            Token(SyntaxKind.SemicolonToken), false, block: out _) != true)
         {
             fixesError = false;
             return false;
@@ -296,13 +297,13 @@ protected TDeclaration WithAccessorList(SemanticModel semanticModel, TDeclaratio
             CreateReturnStatementForExpression(semanticModel, declaration),
             out var block);
 
-        var accessor = SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration);
+        var accessor = AccessorDeclaration(SyntaxKind.GetAccessorDeclaration);
         accessor = block != null
             ? accessor.WithBody(block)
             : accessor.WithExpressionBody(expressionBody)
                       .WithSemicolonToken(semicolonToken);
 
-        return WithAccessorList(declaration, SyntaxFactory.AccessorList([accessor]));
+        return WithAccessorList(declaration, AccessorList([accessor]));
     }
 
     protected virtual TDeclaration WithAccessorList(TDeclaration declaration, AccessorListSyntax accessorListSyntax)

src/Analyzers/CSharp/Analyzers/UsePatternCombinators/AnalyzedPattern.cs

@@ -9,6 +9,8 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.UsePatternCombinators;
 
+using static SyntaxFactory;
+
 /// <summary>
 /// Base class to represent a pattern constructed from various checks
 /// </summary>
@@ -48,12 +50,12 @@ internal sealed class Type : AnalyzedPattern
             // semantics, and for 'C.X' could be a compile error.
             //
             // So lets create a pattern syntax and make sure the result is the same
-            var dummyStatement = SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(
+            var dummyStatement = ExpressionStatement(AssignmentExpression(
                 SyntaxKind.SimpleAssignmentExpression,
-                SyntaxFactory.IdentifierName("_"),
-                SyntaxFactory.IsPatternExpression(
+                IdentifierName("_"),
+                IsPatternExpression(
                     binaryExpression.Left,
-                    SyntaxFactory.ConstantPattern(SyntaxFactory.ParenthesizedExpression(binaryExpression.Right.WithAdditionalAnnotations(s_annotation)))
+                    ConstantPattern(ParenthesizedExpression(binaryExpression.Right.WithAdditionalAnnotations(s_annotation)))
                 )
             ));
 
@@ -149,7 +151,7 @@ private Binary(AnalyzedPattern leftPattern, AnalyzedPattern rightPattern, bool i
                 return null;
 
             var compareTarget = target == leftTarget ? rightTarget : leftTarget;
-            if (!SyntaxFactory.AreEquivalent(target.Syntax, compareTarget.Syntax))
+            if (!AreEquivalent(target.Syntax, compareTarget.Syntax))
                 return null;
 
             return new Binary(leftPattern, rightPattern, isDisjunctive, token, target);

src/Analyzers/CSharp/CodeFixes/ConvertNamespace/ConvertNamespaceTransform.cs

@@ -18,6 +18,8 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.ConvertNamespace;
 
+using static SyntaxFactory;
+
 internal static class ConvertNamespaceTransform
 {
     public static Task<Document> ConvertAsync(Document document, BaseNamespaceDeclarationSyntax baseNamespace, CSharpSyntaxFormattingOptions options, CancellationToken cancellationToken)
@@ -271,7 +273,7 @@ private static SyntaxNode ReplaceWithBlockScopedNamespace(
         if (triviaBeforeSplit.Length > 0)
         {
             if (needsAdditionalLineEnding)
-                triviaBeforeSplit = triviaBeforeSplit.Append(SyntaxFactory.EndOfLine(lineEnding));
+                triviaBeforeSplit = triviaBeforeSplit.Append(EndOfLine(lineEnding));
 
             converted = converted.WithCloseBraceToken(converted.CloseBraceToken.WithPrependedLeadingTrivia(triviaBeforeSplit));
         }
@@ -320,7 +322,7 @@ private static bool HasLeadingBlankLine(
     private static FileScopedNamespaceDeclarationSyntax ConvertNamespaceDeclaration(NamespaceDeclarationSyntax namespaceDeclaration)
     {
         // If the open-brace token has any special trivia, then move them to after the semicolon.
-        var semiColon = SyntaxFactory.Token(SyntaxKind.SemicolonToken)
+        var semiColon = Token(SyntaxKind.SemicolonToken)
             .WithoutTrivia()
             .WithTrailingTrivia(namespaceDeclaration.Name.GetTrailingTrivia())
             .WithAppendedTrailingTrivia(namespaceDeclaration.OpenBraceToken.LeadingTrivia);
@@ -329,7 +331,7 @@ private static FileScopedNamespaceDeclarationSyntax ConvertNamespaceDeclaration(
             semiColon = semiColon.WithAppendedTrailingTrivia(namespaceDeclaration.OpenBraceToken.TrailingTrivia);
 
         // Move trivia after the original name token to now be after the new semicolon token.
-        var fileScopedNamespace = SyntaxFactory.FileScopedNamespaceDeclaration(
+        var fileScopedNamespace = FileScopedNamespaceDeclaration(
             namespaceDeclaration.AttributeLists,
             namespaceDeclaration.Modifiers,
             namespaceDeclaration.NamespaceKeyword,
@@ -379,16 +381,16 @@ private static FileScopedNamespaceDeclarationSyntax ConvertNamespaceDeclaration(
     private static NamespaceDeclarationSyntax ConvertFileScopedNamespace(ParsedDocument document, FileScopedNamespaceDeclarationSyntax fileScopedNamespace, string lineEnding, NewLinePlacement newLinePlacement)
     {
         var nameSyntax = fileScopedNamespace.Name.WithAppendedTrailingTrivia(fileScopedNamespace.SemicolonToken.LeadingTrivia)
-            .WithAppendedTrailingTrivia(newLinePlacement.HasFlag(NewLinePlacement.BeforeOpenBraceInTypes) ? SyntaxFactory.EndOfLine(lineEnding) : SyntaxFactory.Space);
-        var openBraceToken = SyntaxFactory.Token(SyntaxKind.OpenBraceToken).WithoutLeadingTrivia().WithTrailingTrivia(fileScopedNamespace.SemicolonToken.TrailingTrivia);
+            .WithAppendedTrailingTrivia(newLinePlacement.HasFlag(NewLinePlacement.BeforeOpenBraceInTypes) ? EndOfLine(lineEnding) : Space);
+        var openBraceToken = Token(SyntaxKind.OpenBraceToken).WithoutLeadingTrivia().WithTrailingTrivia(fileScopedNamespace.SemicolonToken.TrailingTrivia);
 
         if (openBraceToken.TrailingTrivia is not [.., SyntaxTrivia(SyntaxKind.EndOfLineTrivia)])
         {
-            openBraceToken = openBraceToken.WithAppendedTrailingTrivia(SyntaxFactory.EndOfLine(lineEnding));
+            openBraceToken = openBraceToken.WithAppendedTrailingTrivia(EndOfLine(lineEnding));
         }
 
         FileScopedNamespaceDeclarationSyntax adjustedFileScopedNamespace;
-        var closeBraceToken = SyntaxFactory.Token(SyntaxKind.CloseBraceToken).WithoutLeadingTrivia().WithoutTrailingTrivia();
+        var closeBraceToken = Token(SyntaxKind.CloseBraceToken).WithoutLeadingTrivia().WithoutTrailingTrivia();
 
         // Normally the block scoped namespace will have a newline after the closing brace. The only exception to
         // this occurs when there are no tokens after the closing brace and the document with a file scoped
@@ -397,28 +399,28 @@ private static NamespaceDeclarationSyntax ConvertFileScopedNamespace(ParsedDocum
         if (!fileScopedNamespace.GetLastToken().GetNextTokenOrEndOfFile().IsKind(SyntaxKind.EndOfFileToken)
             || document.Text.Lines.GetLinePosition(document.Text.Length).Character == 0)
         {
-            closeBraceToken = closeBraceToken.WithAppendedTrailingTrivia(SyntaxFactory.EndOfLine(lineEnding));
+            closeBraceToken = closeBraceToken.WithAppendedTrailingTrivia(EndOfLine(lineEnding));
             adjustedFileScopedNamespace = fileScopedNamespace;
         }
         else
         {
             // Make sure the body of the file scoped namespace ends with a trailing new line (so the closing brace
             // of the converted block-body namespace appears on its own line), but don't add a new line after the
             // closing brace.
-            adjustedFileScopedNamespace = fileScopedNamespace.WithAppendedTrailingTrivia(SyntaxFactory.EndOfLine(lineEnding));
+            adjustedFileScopedNamespace = fileScopedNamespace.WithAppendedTrailingTrivia(EndOfLine(lineEnding));
         }
 
         // If the file scoped namespace is indented, also indent the newly added braces to match
         var outerIndentation = document.Text.GetLeadingWhitespaceOfLineAtPosition(fileScopedNamespace.SpanStart);
         if (outerIndentation.Length > 0)
         {
             if (newLinePlacement.HasFlag(NewLinePlacement.BeforeOpenBraceInTypes))
-                openBraceToken = openBraceToken.WithLeadingTrivia(openBraceToken.LeadingTrivia.Add(SyntaxFactory.Whitespace(outerIndentation)));
+                openBraceToken = openBraceToken.WithLeadingTrivia(openBraceToken.LeadingTrivia.Add(Whitespace(outerIndentation)));
 
-            closeBraceToken = closeBraceToken.WithLeadingTrivia(closeBraceToken.LeadingTrivia.Add(SyntaxFactory.Whitespace(outerIndentation)));
+            closeBraceToken = closeBraceToken.WithLeadingTrivia(closeBraceToken.LeadingTrivia.Add(Whitespace(outerIndentation)));
         }
 
-        var namespaceDeclaration = SyntaxFactory.NamespaceDeclaration(
+        var namespaceDeclaration = NamespaceDeclaration(
             adjustedFileScopedNamespace.AttributeLists,
             adjustedFileScopedNamespace.Modifiers,
             adjustedFileScopedNamespace.NamespaceKeyword,