30private static readonly SyntaxTree s_implicitUsingsSyntaxTree = SyntaxFactory.ParseSyntaxTree(SourceText.From( 1561var sourceSyntaxTree = SyntaxFactory.ParseSyntaxTree(SourceText.From(sourceText));

157var todoComment = SyntaxFactory.Comment("// TODO(unsafe): Baselining unsafe usage"); 158var newLine = SyntaxFactory.ElasticCarriageReturnLineFeed; 185typeSyntax = SyntaxFactory.ParseTypeName(typeInfo.Type.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat)) 186.WithTrailingTrivia(SyntaxFactory.Space); 198var forwardDeclVariable = SyntaxFactory.VariableDeclarator(variable.Identifier); 199var forwardDeclDeclaration = SyntaxFactory.VariableDeclaration(typeSyntax) 201forwardDecl = SyntaxFactory.LocalDeclarationStatement(forwardDeclDeclaration) 203.WithTrailingTrivia(SyntaxFactory.TriviaList(SyntaxFactory.ElasticCarriageReturnLineFeed)); 206var assignment = SyntaxFactory.AssignmentExpression( 208SyntaxFactory.IdentifierName(variable.Identifier), 210statementToWrap = SyntaxFactory.ExpressionStatement(assignment) 211.WithTrailingTrivia(SyntaxFactory.TriviaList(SyntaxFactory.ElasticCarriageReturnLineFeed)); 289.WithTrailingTrivia(SyntaxFactory.TriviaList(SyntaxFactory.ElasticCarriageReturnLineFeed))); 290var unsafeBlock = SyntaxFactory.UnsafeStatement( 291SyntaxFactory.Block(wrappedStatements)) 293? SyntaxFactory.TriviaList(todoComment, newLine) 321var newBlock = parentBlock.WithStatements(SyntaxFactory.List(newStatements)); 336var todoComment = SyntaxFactory.Comment("// TODO(unsafe): Baselining unsafe usage"); 337var newLine = SyntaxFactory.CarriageReturnLineFeed; 340var unsafeBlock = SyntaxFactory.UnsafeStatement( 341SyntaxFactory.Block(triggerStatement.WithoutTrivia())) 359var todoComment = SyntaxFactory.Comment("// TODO(unsafe): Baselining unsafe usage"); 360var newLine = SyntaxFactory.CarriageReturnLineFeed; 363var unsafeBlock = SyntaxFactory.UnsafeStatement( 364SyntaxFactory.Block(embeddedStatement.WithoutTrivia())) 368var wrappingBlock = SyntaxFactory.Block(unsafeBlock) 385var todoComment = SyntaxFactory.Comment("// TODO(unsafe): Baselining unsafe usage"); 386var newLine = SyntaxFactory.CarriageReturnLineFeed; 411? SyntaxFactory.ExpressionStatement(arrowExpr.Expression.WithoutTrivia()) 412: SyntaxFactory.ReturnStatement(arrowExpr.Expression.WithoutTrivia()); 415var unsafeBlock = SyntaxFactory.UnsafeStatement( 416SyntaxFactory.Block(innerStatement)) 420var blockBody = SyntaxFactory.Block(unsafeBlock); 450var getter = SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) 451.WithBody(SyntaxFactory.Block(unsafeBlock)); 452var accessorList = SyntaxFactory.AccessorList(SyntaxFactory.SingletonList(getter)); 464.WithBody(SyntaxFactory.Block(unsafeBlock)); 469var indexerGetter = SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) 470.WithBody(SyntaxFactory.Block(unsafeBlock)); 471var indexerAccessorList = SyntaxFactory.AccessorList(SyntaxFactory.SingletonList(indexerGetter));

376loggerParam = parameterSyntax.WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.ThisKeyword))); 603var line = SyntaxFactory.ParseLeadingTrivia($@"

21var node = SyntaxFactory.VariableDeclarator("v"); 47SyntaxTree tree = SyntaxFactory.ParseSyntaxTree(codeStr); 79SyntaxTree tree = SyntaxFactory.ParseSyntaxTree(codeStr); 99var node = SyntaxFactory.VariableDeclarator("v"); 107var node = SyntaxFactory.InvocationExpression(SyntaxFactory.IdentifierName("CheckGetFirstAncestorOfSyntaxKindReturnsNullWhenNodeIsNotfound")); 117var node = SyntaxFactory.IdentifierName("expectedName"); 142SyntaxTree tree = SyntaxFactory.ParseSyntaxTree(codeStr); 173SyntaxTree tree = SyntaxFactory.ParseSyntaxTree(codeStr); 186var console = SyntaxFactory.IdentifierName("Console"); 187var writeline = SyntaxFactory.IdentifierName("WriteLine"); 188var memberaccess = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, console, writeline); 189var expression = SyntaxFactory.InvocationExpression(memberaccess, SyntaxFactory.ArgumentList()); 197var b = SyntaxFactory.IdentifierName("b"); 198var memberbind = SyntaxFactory.MemberBindingExpression(SyntaxFactory.ParseToken("."), b); 199var expression = SyntaxFactory.InvocationExpression(memberbind);

81SyntaxFactory.Identifier("AddAuthorizationBuilder")); 83invocation = SyntaxFactory.InvocationExpression(addAuthorizationBuilderMethod); 92SyntaxFactory.ArgumentList( 93SyntaxFactory.SeparatedList(configureArguments))); 101SyntaxFactory.ArgumentList( 102SyntaxFactory.SingletonSeparatedList( 103SyntaxFactory.Argument(assignmentExpression)))); 122SyntaxFactory.EndOfLine(Environment.NewLine), 123SyntaxFactory.Tab) 126return SyntaxFactory.InvocationExpression( 127SyntaxFactory.MemberAccessExpression( 130SyntaxFactory.IdentifierName(invokedMemberName)),

48var newParam = parameterSyntax.WithType(SyntaxFactory.NullableType(parameterType));

91invocation = invocationExpression.ReplaceToken(identifierToken, SyntaxFactory.Identifier("Append")); 124SyntaxFactory.AssignmentExpression( 126SyntaxFactory.ElementAccessExpression( 128SyntaxFactory.BracketedArgumentList( 129SyntaxFactory.SeparatedList(new[] { arguments[0] }))),

59var newExpression = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, expression, SyntaxFactory.IdentifierName(resolvedPropertyName));

67.WithExpression(SyntaxFactory.ParseExpression($"{instanceVariableInvoked.ToString()}.ListenAnyIP"))

22private static readonly TypeSyntax DefaultType = SyntaxFactory.ParseTypeName("string"); 84resolvedType = SyntaxFactory.NullableType(resolvedType); 89var newParameter = SyntaxFactory.Parameter(SyntaxFactory.Identifier(routeParameterName!)).WithType(type); 160return resolvedName != null ? SyntaxFactory.ParseTypeName(resolvedName) : DefaultType;

62if (!CanFixWebApplicationBuilder(diagnostic, SyntaxFactory.IdentifierName(identifierMethod), root, out var invocation))

83var publicModifier = SyntaxFactory.Token(SyntaxKind.PublicKeyword);

83var publicModifier = SyntaxFactory.Token(SyntaxKind.PublicKeyword);

120root = compilationUnit.AddUsings(SyntaxFactory.UsingDirective(SyntaxFactory.ParseName(@namespace))); 206return SyntaxFactory.Attribute( 207SyntaxFactory.ParseName(ApiSymbolNames.ProducesResponseTypeAttribute) 209SyntaxFactory.AttributeArgumentList().AddArguments( 211SyntaxFactory.AttributeArgument(statusCodeSyntax))); 218var responseTypeAttribute = SyntaxFactory.TypeOfExpression( 219SyntaxFactory.ParseTypeName(typeSymbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)) 222return SyntaxFactory.Attribute( 223SyntaxFactory.ParseName(ApiSymbolNames.ProducesResponseTypeAttribute) 225SyntaxFactory.AttributeArgumentList().AddArguments( 226SyntaxFactory.AttributeArgument(responseTypeAttribute), 227SyntaxFactory.AttributeArgument(statusCodeSyntax))); 235return SyntaxFactory.MemberAccessExpression( 237SyntaxFactory.ParseTypeName(ApiSymbolNames.HttpStatusCodes) 239SyntaxFactory.IdentifierName(constantName)); 243return SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(statusCode)); 248return SyntaxFactory.Attribute( 249SyntaxFactory.ParseName(ApiSymbolNames.ProducesDefaultResponseTypeAttribute)

2286=> SyntaxFactory.QualifiedName(left, SyntaxFactory.Token(SyntaxKind.DotToken), right); 2298=> SyntaxFactory.GenericName(identifier, SyntaxFactory.TypeArgumentList()); 2302=> SyntaxFactory.GenericName(SyntaxFactory.Identifier(identifier), SyntaxFactory.TypeArgumentList()); 2314=> SyntaxFactory.TypeArgumentList(SyntaxFactory.Token(SyntaxKind.LessThanToken), arguments, SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); 2327=> SyntaxFactory.AliasQualifiedName(alias, SyntaxFactory.Token(SyntaxKind.ColonColonToken), name); 2331=> SyntaxFactory.AliasQualifiedName(SyntaxFactory.IdentifierName(alias), SyntaxFactory.Token(SyntaxKind.ColonColonToken), name); 2368=> SyntaxFactory.ArrayType(elementType, default); 2380=> SyntaxFactory.ArrayRankSpecifier(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), sizes, SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); 2392=> SyntaxFactory.PointerType(elementType, SyntaxFactory.Token(SyntaxKind.AsteriskToken)); 2405=> SyntaxFactory.FunctionPointerType(SyntaxFactory.Token(SyntaxKind.DelegateKeyword), SyntaxFactory.Token(SyntaxKind.AsteriskToken), callingConvention, parameterList); 2409=> SyntaxFactory.FunctionPointerType(SyntaxFactory.Token(SyntaxKind.DelegateKeyword), SyntaxFactory.Token(SyntaxKind.AsteriskToken), default, SyntaxFactory.FunctionPointerParameterList()); 2421=> SyntaxFactory.FunctionPointerParameterList(SyntaxFactory.Token(SyntaxKind.LessThanToken), parameters, SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); 2437=> SyntaxFactory.FunctionPointerCallingConvention(managedOrUnmanagedKeyword, default); 2449=> SyntaxFactory.FunctionPointerUnmanagedCallingConventionList(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), callingConventions, SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); 2468=> SyntaxFactory.NullableType(elementType, SyntaxFactory.Token(SyntaxKind.QuestionToken)); 2480=> SyntaxFactory.TupleType(SyntaxFactory.Token(SyntaxKind.OpenParenToken), elements, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 2497=> SyntaxFactory.TupleElement(type, default); 2508=> SyntaxFactory.OmittedTypeArgument(SyntaxFactory.Token(SyntaxKind.OmittedTypeArgumentToken)); 2526=> SyntaxFactory.RefType(SyntaxFactory.Token(SyntaxKind.RefKeyword), default, type); 2538=> SyntaxFactory.ScopedType(SyntaxFactory.Token(SyntaxKind.ScopedKeyword), type); 2551=> SyntaxFactory.ParenthesizedExpression(SyntaxFactory.Token(SyntaxKind.OpenParenToken), expression, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 2563=> SyntaxFactory.TupleExpression(SyntaxFactory.Token(SyntaxKind.OpenParenToken), arguments, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 2600=> SyntaxFactory.PrefixUnaryExpression(kind, SyntaxFactory.Token(GetPrefixUnaryExpressionOperatorTokenKind(kind)), operand); 2627=> SyntaxFactory.AwaitExpression(SyntaxFactory.Token(SyntaxKind.AwaitKeyword), expression); 2652=> SyntaxFactory.PostfixUnaryExpression(kind, operand, SyntaxFactory.Token(GetPostfixUnaryExpressionOperatorTokenKind(kind))); 2685=> SyntaxFactory.MemberAccessExpression(kind, expression, SyntaxFactory.Token(GetMemberAccessExpressionOperatorTokenKind(kind)), name); 2706=> SyntaxFactory.ConditionalAccessExpression(expression, SyntaxFactory.Token(SyntaxKind.QuestionToken), whenNotNull); 2718=> SyntaxFactory.MemberBindingExpression(SyntaxFactory.Token(SyntaxKind.DotToken), name); 2729=> SyntaxFactory.ElementBindingExpression(SyntaxFactory.BracketedArgumentList()); 2740=> SyntaxFactory.RangeExpression(leftOperand, SyntaxFactory.Token(SyntaxKind.DotDotToken), rightOperand); 2744=> SyntaxFactory.RangeExpression(default, SyntaxFactory.Token(SyntaxKind.DotDotToken), default); 2755=> SyntaxFactory.ImplicitElementAccess(SyntaxFactory.BracketedArgumentList()); 2819=> SyntaxFactory.BinaryExpression(kind, left, SyntaxFactory.Token(GetBinaryExpressionOperatorTokenKind(kind)), right); 2893=> SyntaxFactory.AssignmentExpression(kind, left, SyntaxFactory.Token(GetAssignmentExpressionOperatorTokenKind(kind)), right); 2927=> SyntaxFactory.ConditionalExpression(condition, SyntaxFactory.Token(SyntaxKind.QuestionToken), whenTrue, SyntaxFactory.Token(SyntaxKind.ColonToken), whenFalse); 2938=> SyntaxFactory.ThisExpression(SyntaxFactory.Token(SyntaxKind.ThisKeyword)); 2949=> SyntaxFactory.BaseExpression(SyntaxFactory.Token(SyntaxKind.BaseKeyword)); 2996=> SyntaxFactory.FieldExpression(SyntaxFactory.Token(SyntaxKind.FieldKeyword)); 3010=> SyntaxFactory.MakeRefExpression(SyntaxFactory.Token(SyntaxKind.MakeRefKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), expression, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 3024=> SyntaxFactory.RefTypeExpression(SyntaxFactory.Token(SyntaxKind.RefTypeKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), expression, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 3040=> SyntaxFactory.RefValueExpression(SyntaxFactory.Token(SyntaxKind.RefValueKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), expression, SyntaxFactory.Token(SyntaxKind.CommaToken), type, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 3065=> SyntaxFactory.CheckedExpression(kind, SyntaxFactory.Token(GetCheckedExpressionKeywordKind(kind)), SyntaxFactory.Token(SyntaxKind.OpenParenToken), expression, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 3087=> SyntaxFactory.DefaultExpression(SyntaxFactory.Token(SyntaxKind.DefaultKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), type, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 3101=> SyntaxFactory.TypeOfExpression(SyntaxFactory.Token(SyntaxKind.TypeOfKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), type, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 3115=> SyntaxFactory.SizeOfExpression(SyntaxFactory.Token(SyntaxKind.SizeOfKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), type, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 3127=> SyntaxFactory.InvocationExpression(expression, SyntaxFactory.ArgumentList()); 3139=> SyntaxFactory.ElementAccessExpression(expression, SyntaxFactory.BracketedArgumentList()); 3151=> SyntaxFactory.ArgumentList(SyntaxFactory.Token(SyntaxKind.OpenParenToken), arguments, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 3163=> SyntaxFactory.BracketedArgumentList(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), arguments, SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); 3182=> SyntaxFactory.Argument(default, default, expression); 3220=> SyntaxFactory.CastExpression(SyntaxFactory.Token(SyntaxKind.OpenParenToken), type, SyntaxFactory.Token(SyntaxKind.CloseParenToken), expression); 3248=> SyntaxFactory.RefExpression(SyntaxFactory.Token(SyntaxKind.RefKeyword), expression); 3260=> SyntaxFactory.ParenthesizedLambdaExpression(attributeLists, modifiers, returnType, parameterList, SyntaxFactory.Token(SyntaxKind.EqualsGreaterThanToken), block, expressionBody); 3264=> SyntaxFactory.ParenthesizedLambdaExpression(default, default(SyntaxTokenList), default, SyntaxFactory.ParameterList(), SyntaxFactory.Token(SyntaxKind.EqualsGreaterThanToken), default, default); 3285=> SyntaxFactory.InitializerExpression(kind, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), expressions, SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 3297=> SyntaxFactory.ImplicitObjectCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), argumentList, initializer); 3301=> SyntaxFactory.ImplicitObjectCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), SyntaxFactory.ArgumentList(), default); 3313=> SyntaxFactory.ObjectCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), type, argumentList, initializer); 3317=> SyntaxFactory.ObjectCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), type, default, default); 3330=> SyntaxFactory.WithExpression(expression, SyntaxFactory.Token(SyntaxKind.WithKeyword), initializer); 3341=> SyntaxFactory.AnonymousObjectMemberDeclarator(default, expression); 3354=> SyntaxFactory.AnonymousObjectCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), SyntaxFactory.Token(SyntaxKind.OpenBraceToken), initializers, SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 3366=> SyntaxFactory.ArrayCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), type, initializer); 3370=> SyntaxFactory.ArrayCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), type, default); 3384=> SyntaxFactory.ImplicitArrayCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), SyntaxFactory.Token(SyntaxKind.OpenBracketToken), commas, SyntaxFactory.Token(SyntaxKind.CloseBracketToken), initializer); 3388=> SyntaxFactory.ImplicitArrayCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), SyntaxFactory.Token(SyntaxKind.OpenBracketToken), default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.CloseBracketToken), initializer); 3400=> SyntaxFactory.StackAllocArrayCreationExpression(SyntaxFactory.Token(SyntaxKind.StackAllocKeyword), type, initializer); 3404=> SyntaxFactory.StackAllocArrayCreationExpression(SyntaxFactory.Token(SyntaxKind.StackAllocKeyword), type, default); 3418=> SyntaxFactory.ImplicitStackAllocArrayCreationExpression(SyntaxFactory.Token(SyntaxKind.StackAllocKeyword), SyntaxFactory.Token(SyntaxKind.OpenBracketToken), SyntaxFactory.Token(SyntaxKind.CloseBracketToken), initializer); 3430=> SyntaxFactory.CollectionExpression(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), elements, SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); 3449=> SyntaxFactory.SpreadElement(SyntaxFactory.Token(SyntaxKind.DotDotToken), expression); 3463=> SyntaxFactory.WithElement(SyntaxFactory.Token(SyntaxKind.WithKeyword), argumentList ?? SyntaxFactory.ArgumentList()); 3482=> SyntaxFactory.QueryBody(default, selectOrGroup, default); 3496=> SyntaxFactory.FromClause(SyntaxFactory.Token(SyntaxKind.FromKeyword), type, identifier, SyntaxFactory.Token(SyntaxKind.InKeyword), expression); 3500=> SyntaxFactory.FromClause(SyntaxFactory.Token(SyntaxKind.FromKeyword), default, identifier, SyntaxFactory.Token(SyntaxKind.InKeyword), expression); 3504=> SyntaxFactory.FromClause(SyntaxFactory.Token(SyntaxKind.FromKeyword), default, SyntaxFactory.Identifier(identifier), SyntaxFactory.Token(SyntaxKind.InKeyword), expression); 3518=> SyntaxFactory.LetClause(SyntaxFactory.Token(SyntaxKind.LetKeyword), identifier, SyntaxFactory.Token(SyntaxKind.EqualsToken), expression); 3522=> SyntaxFactory.LetClause(SyntaxFactory.Token(SyntaxKind.LetKeyword), SyntaxFactory.Identifier(identifier), SyntaxFactory.Token(SyntaxKind.EqualsToken), expression); 3540=> SyntaxFactory.JoinClause(SyntaxFactory.Token(SyntaxKind.JoinKeyword), type, identifier, SyntaxFactory.Token(SyntaxKind.InKeyword), inExpression, SyntaxFactory.Token(SyntaxKind.OnKeyword), leftExpression, SyntaxFactory.Token(SyntaxKind.EqualsKeyword), rightExpression, into); 3544=> SyntaxFactory.JoinClause(SyntaxFactory.Token(SyntaxKind.JoinKeyword), default, identifier, SyntaxFactory.Token(SyntaxKind.InKeyword), inExpression, SyntaxFactory.Token(SyntaxKind.OnKeyword), leftExpression, SyntaxFactory.Token(SyntaxKind.EqualsKeyword), rightExpression, default); 3548=> SyntaxFactory.JoinClause(SyntaxFactory.Token(SyntaxKind.JoinKeyword), default, SyntaxFactory.Identifier(identifier), SyntaxFactory.Token(SyntaxKind.InKeyword), inExpression, SyntaxFactory.Token(SyntaxKind.OnKeyword), leftExpression, SyntaxFactory.Token(SyntaxKind.EqualsKeyword), rightExpression, default); 3560=> SyntaxFactory.JoinIntoClause(SyntaxFactory.Token(SyntaxKind.IntoKeyword), identifier); 3564=> SyntaxFactory.JoinIntoClause(SyntaxFactory.Token(SyntaxKind.IntoKeyword), SyntaxFactory.Identifier(identifier)); 3576=> SyntaxFactory.WhereClause(SyntaxFactory.Token(SyntaxKind.WhereKeyword), condition); 3587=> SyntaxFactory.OrderByClause(SyntaxFactory.Token(SyntaxKind.OrderByKeyword), orderings); 3611=> SyntaxFactory.Ordering(kind, expression, default); 3631=> SyntaxFactory.SelectClause(SyntaxFactory.Token(SyntaxKind.SelectKeyword), expression); 3645=> SyntaxFactory.GroupClause(SyntaxFactory.Token(SyntaxKind.GroupKeyword), groupExpression, SyntaxFactory.Token(SyntaxKind.ByKeyword), byExpression); 3658=> SyntaxFactory.QueryContinuation(SyntaxFactory.Token(SyntaxKind.IntoKeyword), identifier, body); 3662=> SyntaxFactory.QueryContinuation(SyntaxFactory.Token(SyntaxKind.IntoKeyword), SyntaxFactory.Identifier(identifier), body); 3673=> SyntaxFactory.OmittedArraySizeExpression(SyntaxFactory.Token(SyntaxKind.OmittedArraySizeExpressionToken)); 3697=> SyntaxFactory.InterpolatedStringExpression(stringStartToken, default, stringEndToken); 3710=> SyntaxFactory.IsPatternExpression(expression, SyntaxFactory.Token(SyntaxKind.IsKeyword), pattern); 3722=> SyntaxFactory.ThrowExpression(SyntaxFactory.Token(SyntaxKind.ThrowKeyword), expression); 3734=> SyntaxFactory.WhenClause(SyntaxFactory.Token(SyntaxKind.WhenKeyword), condition); 3745=> SyntaxFactory.DiscardPattern(SyntaxFactory.Token(SyntaxKind.UnderscoreToken)); 3765=> SyntaxFactory.VarPattern(SyntaxFactory.Token(SyntaxKind.VarKeyword), designation); 3775=> SyntaxFactory.RecursivePattern(default, default, default, default); 3787=> SyntaxFactory.PositionalPatternClause(SyntaxFactory.Token(SyntaxKind.OpenParenToken), subpatterns, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 3799=> SyntaxFactory.PropertyPatternClause(SyntaxFactory.Token(SyntaxKind.OpenBraceToken), subpatterns, SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 3810=> SyntaxFactory.Subpattern(default, pattern); 3830=> SyntaxFactory.ParenthesizedPattern(SyntaxFactory.Token(SyntaxKind.OpenParenToken), pattern, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 3878=> SyntaxFactory.BinaryPattern(kind, left, SyntaxFactory.Token(GetBinaryPatternOperatorTokenKind(kind)), right); 3898=> SyntaxFactory.UnaryPattern(SyntaxFactory.Token(SyntaxKind.NotKeyword), pattern); 3910=> SyntaxFactory.ListPattern(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), patterns, SyntaxFactory.Token(SyntaxKind.CloseBracketToken), designation); 3914=> SyntaxFactory.ListPattern(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), patterns, SyntaxFactory.Token(SyntaxKind.CloseBracketToken), default); 3925=> SyntaxFactory.SlicePattern(SyntaxFactory.Token(SyntaxKind.DotDotToken), pattern); 3936=> SyntaxFactory.InterpolatedStringText(SyntaxFactory.Token(SyntaxKind.InterpolatedStringTextToken)); 3949=> SyntaxFactory.Interpolation(SyntaxFactory.Token(SyntaxKind.OpenBraceToken), expression, alignmentClause, formatClause, SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 3953=> SyntaxFactory.Interpolation(SyntaxFactory.Token(SyntaxKind.OpenBraceToken), expression, default, default, SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 3971=> SyntaxFactory.InterpolationFormatClause(colonToken, SyntaxFactory.Token(SyntaxKind.InterpolatedStringTextToken)); 3982=> SyntaxFactory.GlobalStatement(default, default(SyntaxTokenList), statement); 3994=> SyntaxFactory.Block(attributeLists, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), statements, SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 3999=> SyntaxFactory.Block(default, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), statements, SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 4019=> SyntaxFactory.LocalFunctionStatement(attributeLists, modifiers, returnType, identifier, typeParameterList, parameterList, constraintClauses, body, expressionBody, default); 4023=> SyntaxFactory.LocalFunctionStatement(default, default(SyntaxTokenList), returnType, identifier, default, SyntaxFactory.ParameterList(), default, default, default, default); 4027=> SyntaxFactory.LocalFunctionStatement(default, default(SyntaxTokenList), returnType, SyntaxFactory.Identifier(identifier), default, SyntaxFactory.ParameterList(), default, default, default, default); 4051=> SyntaxFactory.LocalDeclarationStatement(attributeLists, default, default, modifiers, declaration, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4055=> SyntaxFactory.LocalDeclarationStatement(default, default, default, default(SyntaxTokenList), declaration, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4066=> SyntaxFactory.VariableDeclaration(type, default); 4077=> SyntaxFactory.VariableDeclarator(identifier, default, default); 4081=> SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(identifier), default, default); 4093=> SyntaxFactory.EqualsValueClause(SyntaxFactory.Token(SyntaxKind.EqualsToken), value); 4111=> SyntaxFactory.DiscardDesignation(SyntaxFactory.Token(SyntaxKind.UnderscoreToken)); 4123=> SyntaxFactory.ParenthesizedVariableDesignation(SyntaxFactory.Token(SyntaxKind.OpenParenToken), variables, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 4135=> SyntaxFactory.ExpressionStatement(attributeLists, expression, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4139=> SyntaxFactory.ExpressionStatement(default, expression, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4150=> SyntaxFactory.EmptyStatement(attributeLists, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4154=> SyntaxFactory.EmptyStatement(default, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4167=> SyntaxFactory.LabeledStatement(attributeLists, identifier, SyntaxFactory.Token(SyntaxKind.ColonToken), statement); 4171=> SyntaxFactory.LabeledStatement(default, identifier, SyntaxFactory.Token(SyntaxKind.ColonToken), statement); 4175=> SyntaxFactory.LabeledStatement(default, SyntaxFactory.Identifier(identifier), SyntaxFactory.Token(SyntaxKind.ColonToken), statement); 4201=> SyntaxFactory.GotoStatement(kind, attributeLists, SyntaxFactory.Token(SyntaxKind.GotoKeyword), caseOrDefaultKeyword, expression, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4206=> SyntaxFactory.GotoStatement(kind, default, SyntaxFactory.Token(SyntaxKind.GotoKeyword), default, expression, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4219=> SyntaxFactory.BreakStatement(attributeLists, SyntaxFactory.Token(SyntaxKind.BreakKeyword), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4223=> SyntaxFactory.BreakStatement(default, SyntaxFactory.Token(SyntaxKind.BreakKeyword), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4235=> SyntaxFactory.ContinueStatement(attributeLists, SyntaxFactory.Token(SyntaxKind.ContinueKeyword), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4239=> SyntaxFactory.ContinueStatement(default, SyntaxFactory.Token(SyntaxKind.ContinueKeyword), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4251=> SyntaxFactory.ReturnStatement(attributeLists, SyntaxFactory.Token(SyntaxKind.ReturnKeyword), expression, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4256=> SyntaxFactory.ReturnStatement(default, SyntaxFactory.Token(SyntaxKind.ReturnKeyword), expression, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4269=> SyntaxFactory.ThrowStatement(attributeLists, SyntaxFactory.Token(SyntaxKind.ThrowKeyword), expression, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4274=> SyntaxFactory.ThrowStatement(default, SyntaxFactory.Token(SyntaxKind.ThrowKeyword), expression, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4299=> SyntaxFactory.YieldStatement(kind, attributeLists, SyntaxFactory.Token(SyntaxKind.YieldKeyword), SyntaxFactory.Token(GetYieldStatementReturnOrBreakKeywordKind(kind)), expression, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4304=> SyntaxFactory.YieldStatement(kind, default, SyntaxFactory.Token(SyntaxKind.YieldKeyword), SyntaxFactory.Token(GetYieldStatementReturnOrBreakKeywordKind(kind)), expression, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4328=> SyntaxFactory.WhileStatement(attributeLists, SyntaxFactory.Token(SyntaxKind.WhileKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), condition, SyntaxFactory.Token(SyntaxKind.CloseParenToken), statement); 4332=> SyntaxFactory.WhileStatement(default, SyntaxFactory.Token(SyntaxKind.WhileKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), condition, SyntaxFactory.Token(SyntaxKind.CloseParenToken), statement); 4349=> SyntaxFactory.DoStatement(attributeLists, SyntaxFactory.Token(SyntaxKind.DoKeyword), statement, SyntaxFactory.Token(SyntaxKind.WhileKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), condition, SyntaxFactory.Token(SyntaxKind.CloseParenToken), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4353=> SyntaxFactory.DoStatement(default, SyntaxFactory.Token(SyntaxKind.DoKeyword), statement, SyntaxFactory.Token(SyntaxKind.WhileKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), condition, SyntaxFactory.Token(SyntaxKind.CloseParenToken), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4369=> SyntaxFactory.ForStatement(attributeLists, SyntaxFactory.Token(SyntaxKind.ForKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), declaration, initializers, SyntaxFactory.Token(SyntaxKind.SemicolonToken), condition, SyntaxFactory.Token(SyntaxKind.SemicolonToken), incrementors, SyntaxFactory.Token(SyntaxKind.CloseParenToken), statement); 4373=> SyntaxFactory.ForStatement(default, SyntaxFactory.Token(SyntaxKind.ForKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), default, default, SyntaxFactory.Token(SyntaxKind.SemicolonToken), default, SyntaxFactory.Token(SyntaxKind.SemicolonToken), default, SyntaxFactory.Token(SyntaxKind.CloseParenToken), statement); 4397=> SyntaxFactory.ForEachStatement(attributeLists, default, SyntaxFactory.Token(SyntaxKind.ForEachKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), type, identifier, SyntaxFactory.Token(SyntaxKind.InKeyword), expression, SyntaxFactory.Token(SyntaxKind.CloseParenToken), statement); 4401=> SyntaxFactory.ForEachStatement(default, default, SyntaxFactory.Token(SyntaxKind.ForEachKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), type, identifier, SyntaxFactory.Token(SyntaxKind.InKeyword), expression, SyntaxFactory.Token(SyntaxKind.CloseParenToken), statement); 4405=> SyntaxFactory.ForEachStatement(default, default, SyntaxFactory.Token(SyntaxKind.ForEachKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), type, SyntaxFactory.Identifier(identifier), SyntaxFactory.Token(SyntaxKind.InKeyword), expression, SyntaxFactory.Token(SyntaxKind.CloseParenToken), statement); 4428=> SyntaxFactory.ForEachVariableStatement(attributeLists, default, SyntaxFactory.Token(SyntaxKind.ForEachKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), variable, SyntaxFactory.Token(SyntaxKind.InKeyword), expression, SyntaxFactory.Token(SyntaxKind.CloseParenToken), statement); 4432=> SyntaxFactory.ForEachVariableStatement(default, default, SyntaxFactory.Token(SyntaxKind.ForEachKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), variable, SyntaxFactory.Token(SyntaxKind.InKeyword), expression, SyntaxFactory.Token(SyntaxKind.CloseParenToken), statement); 4452=> SyntaxFactory.UsingStatement(attributeLists, default, SyntaxFactory.Token(SyntaxKind.UsingKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), declaration, expression, SyntaxFactory.Token(SyntaxKind.CloseParenToken), statement); 4456=> SyntaxFactory.UsingStatement(default, default, SyntaxFactory.Token(SyntaxKind.UsingKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), default, default, SyntaxFactory.Token(SyntaxKind.CloseParenToken), statement); 4471=> SyntaxFactory.FixedStatement(attributeLists, SyntaxFactory.Token(SyntaxKind.FixedKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), declaration, SyntaxFactory.Token(SyntaxKind.CloseParenToken), statement); 4475=> SyntaxFactory.FixedStatement(default, SyntaxFactory.Token(SyntaxKind.FixedKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), declaration, SyntaxFactory.Token(SyntaxKind.CloseParenToken), statement); 4498=> SyntaxFactory.CheckedStatement(kind, attributeLists, SyntaxFactory.Token(GetCheckedStatementKeywordKind(kind)), block); 4503=> SyntaxFactory.CheckedStatement(kind, default, SyntaxFactory.Token(GetCheckedStatementKeywordKind(kind)), block ?? SyntaxFactory.Block()); 4524=> SyntaxFactory.UnsafeStatement(attributeLists, SyntaxFactory.Token(SyntaxKind.UnsafeKeyword), block); 4529=> SyntaxFactory.UnsafeStatement(default, SyntaxFactory.Token(SyntaxKind.UnsafeKeyword), block ?? SyntaxFactory.Block()); 4545=> SyntaxFactory.LockStatement(attributeLists, SyntaxFactory.Token(SyntaxKind.LockKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), expression, SyntaxFactory.Token(SyntaxKind.CloseParenToken), statement); 4549=> SyntaxFactory.LockStatement(default, SyntaxFactory.Token(SyntaxKind.LockKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), expression, SyntaxFactory.Token(SyntaxKind.CloseParenToken), statement); 4564=> SyntaxFactory.IfStatement(attributeLists, SyntaxFactory.Token(SyntaxKind.IfKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), condition, SyntaxFactory.Token(SyntaxKind.CloseParenToken), statement, @else); 4568=> SyntaxFactory.IfStatement(default, SyntaxFactory.Token(SyntaxKind.IfKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), condition, SyntaxFactory.Token(SyntaxKind.CloseParenToken), statement, default); 4580=> SyntaxFactory.ElseClause(SyntaxFactory.Token(SyntaxKind.ElseKeyword), statement); 4612=> SyntaxFactory.SwitchSection(default, default); 4625=> SyntaxFactory.CasePatternSwitchLabel(SyntaxFactory.Token(SyntaxKind.CaseKeyword), pattern, whenClause, colonToken); 4629=> SyntaxFactory.CasePatternSwitchLabel(SyntaxFactory.Token(SyntaxKind.CaseKeyword), pattern, default, colonToken); 4642=> SyntaxFactory.CaseSwitchLabel(SyntaxFactory.Token(SyntaxKind.CaseKeyword), value, colonToken); 4654=> SyntaxFactory.DefaultSwitchLabel(SyntaxFactory.Token(SyntaxKind.DefaultKeyword), colonToken); 4668=> SyntaxFactory.SwitchExpression(governingExpression, SyntaxFactory.Token(SyntaxKind.SwitchKeyword), SyntaxFactory.Token(SyntaxKind.OpenBraceToken), arms, SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 4672=> SyntaxFactory.SwitchExpression(governingExpression, SyntaxFactory.Token(SyntaxKind.SwitchKeyword), SyntaxFactory.Token(SyntaxKind.OpenBraceToken), default, SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 4685=> SyntaxFactory.SwitchExpressionArm(pattern, whenClause, SyntaxFactory.Token(SyntaxKind.EqualsGreaterThanToken), expression); 4689=> SyntaxFactory.SwitchExpressionArm(pattern, default, SyntaxFactory.Token(SyntaxKind.EqualsGreaterThanToken), expression); 4701=> SyntaxFactory.TryStatement(attributeLists, SyntaxFactory.Token(SyntaxKind.TryKeyword), block, catches, @finally); 4706=> SyntaxFactory.TryStatement(default, SyntaxFactory.Token(SyntaxKind.TryKeyword), SyntaxFactory.Block(), catches, default); 4719=> SyntaxFactory.CatchClause(SyntaxFactory.Token(SyntaxKind.CatchKeyword), declaration, filter, block); 4723=> SyntaxFactory.CatchClause(SyntaxFactory.Token(SyntaxKind.CatchKeyword), default, default, SyntaxFactory.Block()); 4742=> SyntaxFactory.CatchDeclaration(SyntaxFactory.Token(SyntaxKind.OpenParenToken), type, identifier, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 4746=> SyntaxFactory.CatchDeclaration(SyntaxFactory.Token(SyntaxKind.OpenParenToken), type, default, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 4760=> SyntaxFactory.CatchFilterClause(SyntaxFactory.Token(SyntaxKind.WhenKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), filterExpression, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 4772=> SyntaxFactory.FinallyClause(SyntaxFactory.Token(SyntaxKind.FinallyKeyword), block ?? SyntaxFactory.Block()); 4783=> SyntaxFactory.CompilationUnit(externs, usings, attributeLists, members, SyntaxFactory.Token(SyntaxKind.EndOfFileToken)); 4787=> SyntaxFactory.CompilationUnit(default, default, default, default, SyntaxFactory.Token(SyntaxKind.EndOfFileToken)); 4801=> SyntaxFactory.ExternAliasDirective(SyntaxFactory.Token(SyntaxKind.ExternKeyword), SyntaxFactory.Token(SyntaxKind.AliasKeyword), identifier, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4805=> SyntaxFactory.ExternAliasDirective(SyntaxFactory.Token(SyntaxKind.ExternKeyword), SyntaxFactory.Token(SyntaxKind.AliasKeyword), SyntaxFactory.Identifier(identifier), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4836=> SyntaxFactory.UsingDirective(default, SyntaxFactory.Token(SyntaxKind.UsingKeyword), default, default, alias, namespaceOrType, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4840=> SyntaxFactory.UsingDirective(default, SyntaxFactory.Token(SyntaxKind.UsingKeyword), default, default, default, namespaceOrType, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4860=> SyntaxFactory.NamespaceDeclaration(attributeLists, modifiers, SyntaxFactory.Token(SyntaxKind.NamespaceKeyword), name, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), externs, usings, members, SyntaxFactory.Token(SyntaxKind.CloseBraceToken), default); 4864=> SyntaxFactory.NamespaceDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.NamespaceKeyword), name, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), default, default, default, SyntaxFactory.Token(SyntaxKind.CloseBraceToken), default); 4877=> SyntaxFactory.FileScopedNamespaceDeclaration(attributeLists, modifiers, SyntaxFactory.Token(SyntaxKind.NamespaceKeyword), name, SyntaxFactory.Token(SyntaxKind.SemicolonToken), externs, usings, members); 4881=> SyntaxFactory.FileScopedNamespaceDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.NamespaceKeyword), name, SyntaxFactory.Token(SyntaxKind.SemicolonToken), default, default, default); 4893=> SyntaxFactory.AttributeList(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), target, attributes, SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); 4897=> SyntaxFactory.AttributeList(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), default, attributes, SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); 4908=> SyntaxFactory.AttributeTargetSpecifier(identifier, SyntaxFactory.Token(SyntaxKind.ColonToken)); 4919=> SyntaxFactory.Attribute(name, default); 4931=> SyntaxFactory.AttributeArgumentList(SyntaxFactory.Token(SyntaxKind.OpenParenToken), arguments, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 4942=> SyntaxFactory.AttributeArgument(default, default, expression); 4954=> SyntaxFactory.NameEquals(name, SyntaxFactory.Token(SyntaxKind.EqualsToken)); 4958=> SyntaxFactory.NameEquals(SyntaxFactory.IdentifierName(name), SyntaxFactory.Token(SyntaxKind.EqualsToken)); 4970=> SyntaxFactory.TypeParameterList(SyntaxFactory.Token(SyntaxKind.LessThanToken), parameters, SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); 4988=> SyntaxFactory.TypeParameter(default, default, identifier); 4992=> SyntaxFactory.TypeParameter(default, default, SyntaxFactory.Identifier(identifier)); 5132=> SyntaxFactory.RecordDeclaration(kind, attributeLists, modifiers, keyword, default, identifier, typeParameterList, parameterList, baseList, constraintClauses, default, members, default, default); 5136=> SyntaxFactory.RecordDeclaration(kind, default, default(SyntaxTokenList), keyword, default, identifier, default, default, default, default, default, default, default, default); 5140=> SyntaxFactory.RecordDeclaration(kind, default, default(SyntaxTokenList), keyword, default, SyntaxFactory.Identifier(identifier), default, default, default, default, default, default, default, default); 5189=> SyntaxFactory.DelegateDeclaration(attributeLists, modifiers, SyntaxFactory.Token(SyntaxKind.DelegateKeyword), returnType, identifier, typeParameterList, parameterList, constraintClauses, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 5193=> SyntaxFactory.DelegateDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.DelegateKeyword), returnType, identifier, default, SyntaxFactory.ParameterList(), default, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 5197=> SyntaxFactory.DelegateDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.DelegateKeyword), returnType, SyntaxFactory.Identifier(identifier), default, SyntaxFactory.ParameterList(), default, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 5208=> SyntaxFactory.EnumMemberDeclaration(default, default(SyntaxTokenList), identifier, default); 5212=> SyntaxFactory.EnumMemberDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Identifier(identifier), default); 5241=> SyntaxFactory.ExtensionBlockDeclaration(attributeLists, modifiers, SyntaxFactory.Token(SyntaxKind.ExtensionKeyword), typeParameterList, parameterList, constraintClauses, default, members, default, default); 5245=> SyntaxFactory.ExtensionBlockDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.ExtensionKeyword), default, default, default, default, default, default, default); 5256=> SyntaxFactory.BaseList(SyntaxFactory.Token(SyntaxKind.ColonToken), types); 5275=> SyntaxFactory.PrimaryConstructorBaseType(type, SyntaxFactory.ArgumentList()); 5288=> SyntaxFactory.TypeParameterConstraintClause(SyntaxFactory.Token(SyntaxKind.WhereKeyword), name, SyntaxFactory.Token(SyntaxKind.ColonToken), constraints); 5292=> SyntaxFactory.TypeParameterConstraintClause(SyntaxFactory.Token(SyntaxKind.WhereKeyword), name, SyntaxFactory.Token(SyntaxKind.ColonToken), default); 5296=> SyntaxFactory.TypeParameterConstraintClause(SyntaxFactory.Token(SyntaxKind.WhereKeyword), SyntaxFactory.IdentifierName(name), SyntaxFactory.Token(SyntaxKind.ColonToken), default); 5309=> SyntaxFactory.ConstructorConstraint(SyntaxFactory.Token(SyntaxKind.NewKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 5337=> SyntaxFactory.ClassOrStructConstraint(kind, SyntaxFactory.Token(GetClassOrStructConstraintClassOrStructKeywordKind(kind)), default); 5363=> SyntaxFactory.DefaultConstraint(SyntaxFactory.Token(SyntaxKind.DefaultKeyword)); 5374=> SyntaxFactory.AllowsConstraintClause(SyntaxFactory.Token(SyntaxKind.AllowsKeyword), constraints); 5386=> SyntaxFactory.RefStructConstraint(SyntaxFactory.Token(SyntaxKind.RefKeyword), SyntaxFactory.Token(SyntaxKind.StructKeyword)); 5398=> SyntaxFactory.FieldDeclaration(attributeLists, modifiers, declaration, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 5402=> SyntaxFactory.FieldDeclaration(default, default(SyntaxTokenList), declaration, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 5415=> SyntaxFactory.EventFieldDeclaration(attributeLists, modifiers, SyntaxFactory.Token(SyntaxKind.EventKeyword), declaration, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 5419=> SyntaxFactory.EventFieldDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.EventKeyword), declaration, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 5431=> SyntaxFactory.ExplicitInterfaceSpecifier(name, SyntaxFactory.Token(SyntaxKind.DotToken)); 5450=> SyntaxFactory.MethodDeclaration(attributeLists, modifiers, returnType, explicitInterfaceSpecifier, identifier, typeParameterList, parameterList, constraintClauses, body, expressionBody, default); 5454=> SyntaxFactory.MethodDeclaration(default, default(SyntaxTokenList), returnType, default, identifier, default, SyntaxFactory.ParameterList(), default, default, default, default); 5458=> SyntaxFactory.MethodDeclaration(default, default(SyntaxTokenList), returnType, default, SyntaxFactory.Identifier(identifier), default, SyntaxFactory.ParameterList(), default, default, default, default); 5522=> SyntaxFactory.OperatorDeclaration(attributeLists, modifiers, returnType, explicitInterfaceSpecifier, SyntaxFactory.Token(SyntaxKind.OperatorKeyword), default, operatorToken, parameterList, body, expressionBody, default); 5526=> SyntaxFactory.OperatorDeclaration(default, default(SyntaxTokenList), returnType, default, SyntaxFactory.Token(SyntaxKind.OperatorKeyword), default, operatorToken, SyntaxFactory.ParameterList(), default, default, default); 5557=> SyntaxFactory.ConversionOperatorDeclaration(attributeLists, modifiers, implicitOrExplicitKeyword, explicitInterfaceSpecifier, SyntaxFactory.Token(SyntaxKind.OperatorKeyword), default, type, parameterList, body, expressionBody, default); 5561=> SyntaxFactory.ConversionOperatorDeclaration(default, default(SyntaxTokenList), implicitOrExplicitKeyword, default, SyntaxFactory.Token(SyntaxKind.OperatorKeyword), default, type, SyntaxFactory.ParameterList(), default, default, default); 5579=> SyntaxFactory.ConstructorDeclaration(attributeLists, modifiers, identifier, parameterList, initializer, body, expressionBody, default); 5583=> SyntaxFactory.ConstructorDeclaration(default, default(SyntaxTokenList), identifier, SyntaxFactory.ParameterList(), default, default, default, default); 5587=> SyntaxFactory.ConstructorDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Identifier(identifier), SyntaxFactory.ParameterList(), default, default, default, default); 5611=> SyntaxFactory.ConstructorInitializer(kind, SyntaxFactory.Token(SyntaxKind.ColonToken), SyntaxFactory.Token(GetConstructorInitializerThisOrBaseKeywordKind(kind)), argumentList ?? SyntaxFactory.ArgumentList()); 5638=> SyntaxFactory.DestructorDeclaration(attributeLists, modifiers, SyntaxFactory.Token(SyntaxKind.TildeToken), identifier, parameterList, body, expressionBody, default); 5642=> SyntaxFactory.DestructorDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.TildeToken), identifier, SyntaxFactory.ParameterList(), default, default, default); 5646=> SyntaxFactory.DestructorDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.TildeToken), SyntaxFactory.Identifier(identifier), SyntaxFactory.ParameterList(), default, default, default); 5664=> SyntaxFactory.PropertyDeclaration(attributeLists, modifiers, type, explicitInterfaceSpecifier, identifier, accessorList, expressionBody, initializer, default); 5668=> SyntaxFactory.PropertyDeclaration(default, default(SyntaxTokenList), type, default, identifier, default, default, default, default); 5672=> SyntaxFactory.PropertyDeclaration(default, default(SyntaxTokenList), type, default, SyntaxFactory.Identifier(identifier), default, default, default, default); 5684=> SyntaxFactory.ArrowExpressionClause(SyntaxFactory.Token(SyntaxKind.EqualsGreaterThanToken), expression); 5703=> SyntaxFactory.EventDeclaration(attributeLists, modifiers, SyntaxFactory.Token(SyntaxKind.EventKeyword), type, explicitInterfaceSpecifier, identifier, accessorList, default); 5707=> SyntaxFactory.EventDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.EventKeyword), type, default, identifier, default, default); 5711=> SyntaxFactory.EventDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.EventKeyword), type, default, SyntaxFactory.Identifier(identifier), default, default); 5730=> SyntaxFactory.IndexerDeclaration(attributeLists, modifiers, type, explicitInterfaceSpecifier, SyntaxFactory.Token(SyntaxKind.ThisKeyword), parameterList, accessorList, expressionBody, default); 5734=> SyntaxFactory.IndexerDeclaration(default, default(SyntaxTokenList), type, default, SyntaxFactory.Token(SyntaxKind.ThisKeyword), SyntaxFactory.BracketedParameterList(), default, default, default); 5746=> SyntaxFactory.AccessorList(SyntaxFactory.Token(SyntaxKind.OpenBraceToken), accessors, SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 5782=> SyntaxFactory.AccessorDeclaration(kind, attributeLists, modifiers, SyntaxFactory.Token(GetAccessorDeclarationKeywordKind(kind)), body, expressionBody, default); 5786=> SyntaxFactory.AccessorDeclaration(kind, default, default(SyntaxTokenList), SyntaxFactory.Token(GetAccessorDeclarationKeywordKind(kind)), default, default, default); 5810=> SyntaxFactory.ParameterList(SyntaxFactory.Token(SyntaxKind.OpenParenToken), parameters, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 5822=> SyntaxFactory.BracketedParameterList(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), parameters, SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); 5846=> SyntaxFactory.FunctionPointerParameter(default, default(SyntaxTokenList), type); 5857=> SyntaxFactory.IncompleteMember(default, default(SyntaxTokenList), type); 5868=> SyntaxFactory.SkippedTokensTrivia(default(SyntaxTokenList)); 5885=> SyntaxFactory.DocumentationCommentTrivia(kind, content, SyntaxFactory.Token(SyntaxKind.EndOfDocumentationCommentToken)); 5905=> SyntaxFactory.QualifiedCref(container, SyntaxFactory.Token(SyntaxKind.DotToken), member); 5916=> SyntaxFactory.NameMemberCref(name, default); 5930=> SyntaxFactory.ExtensionMemberCref(SyntaxFactory.Token(SyntaxKind.ExtensionKeyword), typeArgumentList, parameters, SyntaxFactory.Token(SyntaxKind.DotToken), member); 5934=> SyntaxFactory.ExtensionMemberCref(SyntaxFactory.Token(SyntaxKind.ExtensionKeyword), default, SyntaxFactory.CrefParameterList(), SyntaxFactory.Token(SyntaxKind.DotToken), member); 5945=> SyntaxFactory.IndexerMemberCref(SyntaxFactory.Token(SyntaxKind.ThisKeyword), parameters); 6000=> SyntaxFactory.OperatorMemberCref(SyntaxFactory.Token(SyntaxKind.OperatorKeyword), default, operatorToken, parameters); 6004=> SyntaxFactory.OperatorMemberCref(SyntaxFactory.Token(SyntaxKind.OperatorKeyword), default, operatorToken, default); 6028=> SyntaxFactory.ConversionOperatorMemberCref(implicitOrExplicitKeyword, SyntaxFactory.Token(SyntaxKind.OperatorKeyword), default, type, parameters); 6032=> SyntaxFactory.ConversionOperatorMemberCref(implicitOrExplicitKeyword, SyntaxFactory.Token(SyntaxKind.OperatorKeyword), default, type, default); 6044=> SyntaxFactory.CrefParameterList(SyntaxFactory.Token(SyntaxKind.OpenParenToken), parameters, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 6056=> SyntaxFactory.CrefBracketedParameterList(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), parameters, SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); 6081=> SyntaxFactory.CrefParameter(refKindKeyword, default, type); 6085=> SyntaxFactory.CrefParameter(default, default, type); 6097=> SyntaxFactory.XmlElement(startTag, default, endTag); 6110=> SyntaxFactory.XmlElementStartTag(SyntaxFactory.Token(SyntaxKind.LessThanToken), name, attributes, SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); 6114=> SyntaxFactory.XmlElementStartTag(SyntaxFactory.Token(SyntaxKind.LessThanToken), name, default, SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); 6127=> SyntaxFactory.XmlElementEndTag(SyntaxFactory.Token(SyntaxKind.LessThanSlashToken), name, SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); 6140=> SyntaxFactory.XmlEmptyElement(SyntaxFactory.Token(SyntaxKind.LessThanToken), name, attributes, SyntaxFactory.Token(SyntaxKind.SlashGreaterThanToken)); 6144=> SyntaxFactory.XmlEmptyElement(SyntaxFactory.Token(SyntaxKind.LessThanToken), name, default, SyntaxFactory.Token(SyntaxKind.SlashGreaterThanToken)); 6155=> SyntaxFactory.XmlName(default, localName); 6159=> SyntaxFactory.XmlName(default, SyntaxFactory.Identifier(localName)); 6171=> SyntaxFactory.XmlPrefix(prefix, SyntaxFactory.Token(SyntaxKind.ColonToken)); 6175=> SyntaxFactory.XmlPrefix(SyntaxFactory.Identifier(prefix), SyntaxFactory.Token(SyntaxKind.ColonToken)); 6199=> SyntaxFactory.XmlTextAttribute(name, SyntaxFactory.Token(SyntaxKind.EqualsToken), startQuoteToken, textTokens, endQuoteToken); 6203=> SyntaxFactory.XmlTextAttribute(name, SyntaxFactory.Token(SyntaxKind.EqualsToken), startQuoteToken, default(SyntaxTokenList), endQuoteToken); 6228=> SyntaxFactory.XmlCrefAttribute(name, SyntaxFactory.Token(SyntaxKind.EqualsToken), startQuoteToken, cref, endQuoteToken); 6253=> SyntaxFactory.XmlNameAttribute(name, SyntaxFactory.Token(SyntaxKind.EqualsToken), startQuoteToken, identifier, endQuoteToken); 6257=> SyntaxFactory.XmlNameAttribute(name, SyntaxFactory.Token(SyntaxKind.EqualsToken), startQuoteToken, SyntaxFactory.IdentifierName(identifier), endQuoteToken); 6267=> SyntaxFactory.XmlText(default(SyntaxTokenList)); 6279=> SyntaxFactory.XmlCDataSection(SyntaxFactory.Token(SyntaxKind.XmlCDataStartToken), textTokens, SyntaxFactory.Token(SyntaxKind.XmlCDataEndToken)); 6292=> SyntaxFactory.XmlProcessingInstruction(SyntaxFactory.Token(SyntaxKind.XmlProcessingInstructionStartToken), name, textTokens, SyntaxFactory.Token(SyntaxKind.XmlProcessingInstructionEndToken)); 6296=> SyntaxFactory.XmlProcessingInstruction(SyntaxFactory.Token(SyntaxKind.XmlProcessingInstructionStartToken), name, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.XmlProcessingInstructionEndToken)); 6308=> SyntaxFactory.XmlComment(SyntaxFactory.Token(SyntaxKind.XmlCommentStartToken), textTokens, SyntaxFactory.Token(SyntaxKind.XmlCommentEndToken)); 6322=> SyntaxFactory.IfDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.IfKeyword), condition, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive, branchTaken, conditionValue); 6336=> SyntaxFactory.ElifDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ElifKeyword), condition, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive, branchTaken, conditionValue); 6349=> SyntaxFactory.ElseDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ElseKeyword), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive, branchTaken); 6362=> SyntaxFactory.EndIfDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.EndIfKeyword), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6375=> SyntaxFactory.RegionDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.RegionKeyword), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6388=> SyntaxFactory.EndRegionDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.EndRegionKeyword), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6401=> SyntaxFactory.ErrorDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ErrorKeyword), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6414=> SyntaxFactory.WarningDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.WarningKeyword), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6426=> SyntaxFactory.BadDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), identifier, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6440=> SyntaxFactory.DefineDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.DefineKeyword), name, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6444=> SyntaxFactory.DefineDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.DefineKeyword), SyntaxFactory.Identifier(name), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6458=> SyntaxFactory.UndefDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.UndefKeyword), name, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6462=> SyntaxFactory.UndefDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.UndefKeyword), SyntaxFactory.Identifier(name), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6488=> SyntaxFactory.LineDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.LineKeyword), line, file, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6492=> SyntaxFactory.LineDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.LineKeyword), line, default, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6507=> SyntaxFactory.LineDirectivePosition(SyntaxFactory.Token(SyntaxKind.OpenParenToken), line, SyntaxFactory.Token(SyntaxKind.CommaToken), character, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 6530=> SyntaxFactory.LineSpanDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.LineKeyword), start, SyntaxFactory.Token(SyntaxKind.MinusToken), end, characterOffset, file, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6534=> SyntaxFactory.LineSpanDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.LineKeyword), start, SyntaxFactory.Token(SyntaxKind.MinusToken), end, default, file, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6554=> SyntaxFactory.PragmaWarningDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.PragmaKeyword), SyntaxFactory.Token(SyntaxKind.WarningKeyword), disableOrRestoreKeyword, errorCodes, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6558=> SyntaxFactory.PragmaWarningDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.PragmaKeyword), SyntaxFactory.Token(SyntaxKind.WarningKeyword), disableOrRestoreKeyword, default, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6575=> SyntaxFactory.PragmaChecksumDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.PragmaKeyword), SyntaxFactory.Token(SyntaxKind.ChecksumKeyword), file, guid, bytes, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6589=> SyntaxFactory.ReferenceDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ReferenceKeyword), file, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6603=> SyntaxFactory.LoadDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.LoadKeyword), file, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6616=> SyntaxFactory.ShebangDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ExclamationToken), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6635=> SyntaxFactory.IgnoredDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ColonToken), content, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6639=> SyntaxFactory.IgnoredDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ColonToken), default, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6666=> SyntaxFactory.NullableDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.NullableKeyword), settingToken, targetToken, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6670=> SyntaxFactory.NullableDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.NullableKeyword), settingToken, default, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive);

66var newNode = SyntaxFactory.IdentifierName(identifier); 127var newNode = SyntaxFactory.QualifiedName(left, dotToken, right); 173var newNode = SyntaxFactory.GenericName(identifier, typeArgumentList); 231var newNode = SyntaxFactory.TypeArgumentList(lessThanToken, arguments, greaterThanToken); 295var newNode = SyntaxFactory.AliasQualifiedName(alias, colonColonToken, name); 346var newNode = SyntaxFactory.PredefinedType(keyword); 403var newNode = SyntaxFactory.ArrayType(elementType, rankSpecifiers); 456var newNode = SyntaxFactory.ArrayRankSpecifier(openBracketToken, sizes, closeBracketToken); 504var newNode = SyntaxFactory.PointerType(elementType, asteriskToken); 567var newNode = SyntaxFactory.FunctionPointerType(delegateKeyword, asteriskToken, callingConvention, parameterList); 626var newNode = SyntaxFactory.FunctionPointerParameterList(lessThanToken, parameters, greaterThanToken); 674var newNode = SyntaxFactory.FunctionPointerCallingConvention(managedOrUnmanagedKeyword, unmanagedCallingConventionList); 687var unmanagedCallingConventionList = this.UnmanagedCallingConventionList ?? SyntaxFactory.FunctionPointerUnmanagedCallingConventionList(); 735var newNode = SyntaxFactory.FunctionPointerUnmanagedCallingConventionList(openBracketToken, callingConventions, closeBracketToken); 779var newNode = SyntaxFactory.FunctionPointerUnmanagedCallingConvention(name); 823var newNode = SyntaxFactory.NullableType(elementType, questionToken); 877var newNode = SyntaxFactory.TupleType(openParenToken, elements, closeParenToken); 932var newNode = SyntaxFactory.TupleElement(type, identifier); 973var newNode = SyntaxFactory.OmittedTypeArgument(omittedTypeArgumentToken); 1025var newNode = SyntaxFactory.RefType(refKeyword, readOnlyKeyword, type); 1069var newNode = SyntaxFactory.ScopedType(scopedKeyword, type); 1134var newNode = SyntaxFactory.ParenthesizedExpression(openParenToken, expression, closeParenToken); 1190var newNode = SyntaxFactory.TupleExpression(openParenToken, arguments, closeParenToken); 1246var newNode = SyntaxFactory.PrefixUnaryExpression(this.Kind(), operatorToken, operand); 1291var newNode = SyntaxFactory.AwaitExpression(awaitKeyword, expression); 1338var newNode = SyntaxFactory.PostfixUnaryExpression(this.Kind(), operand, operatorToken); 1400var newNode = SyntaxFactory.MemberAccessExpression(this.Kind(), expression, operatorToken, name); 1462var newNode = SyntaxFactory.ConditionalAccessExpression(expression, operatorToken, whenNotNull); 1508var newNode = SyntaxFactory.MemberBindingExpression(operatorToken, name); 1550var newNode = SyntaxFactory.ElementBindingExpression(argumentList); 1612var newNode = SyntaxFactory.RangeExpression(leftOperand, operatorToken, rightOperand); 1655var newNode = SyntaxFactory.ImplicitElementAccess(argumentList); 1738var newNode = SyntaxFactory.BinaryExpression(this.Kind(), left, operatorToken, right); 1812var newNode = SyntaxFactory.AssignmentExpression(this.Kind(), left, operatorToken, right); 1883var newNode = SyntaxFactory.ConditionalExpression(condition, questionToken, whenTrue, colonToken, whenFalse); 1936var newNode = SyntaxFactory.ThisExpression(token); 1976var newNode = SyntaxFactory.BaseExpression(token); 2024var newNode = SyntaxFactory.LiteralExpression(this.Kind(), token); 2064var newNode = SyntaxFactory.FieldExpression(token); 2114var newNode = SyntaxFactory.MakeRefExpression(keyword, openParenToken, expression, closeParenToken); 2167var newNode = SyntaxFactory.RefTypeExpression(keyword, openParenToken, expression, closeParenToken); 2239var newNode = SyntaxFactory.RefValueExpression(keyword, openParenToken, expression, comma, type, closeParenToken); 2295var newNode = SyntaxFactory.CheckedExpression(this.Kind(), keyword, openParenToken, expression, closeParenToken); 2348var newNode = SyntaxFactory.DefaultExpression(keyword, openParenToken, type, closeParenToken); 2401var newNode = SyntaxFactory.TypeOfExpression(keyword, openParenToken, type, closeParenToken); 2454var newNode = SyntaxFactory.SizeOfExpression(keyword, openParenToken, type, closeParenToken); 2514var newNode = SyntaxFactory.InvocationExpression(expression, argumentList); 2574var newNode = SyntaxFactory.ElementAccessExpression(expression, argumentList); 2648var newNode = SyntaxFactory.ArgumentList(openParenToken, arguments, closeParenToken); 2708var newNode = SyntaxFactory.BracketedArgumentList(openBracketToken, arguments, closeBracketToken); 2781var newNode = SyntaxFactory.Argument(nameColon, refKindKeyword, expression); 2840var newNode = SyntaxFactory.ExpressionColon(expression, colonToken); 2887var newNode = SyntaxFactory.NameColon(name, colonToken); 2945var newNode = SyntaxFactory.DeclarationExpression(type, designation); 3009var newNode = SyntaxFactory.CastExpression(openParenToken, type, closeParenToken, expression); 3131var newNode = SyntaxFactory.AnonymousMethodExpression(modifiers, delegateKeyword, parameterList, block, expressionBody); 3152var parameterList = this.ParameterList ?? SyntaxFactory.ParameterList(); 3267var newNode = SyntaxFactory.SimpleLambdaExpression(attributeLists, modifiers, parameter, arrowToken, block, expressionBody); 3296var block = this.Block ?? SyntaxFactory.Block(); 3302var block = this.Block ?? SyntaxFactory.Block(); 3337var newNode = SyntaxFactory.RefExpression(refKeyword, expression); 3429var newNode = SyntaxFactory.ParenthesizedLambdaExpression(attributeLists, modifiers, returnType, parameterList, arrowToken, block, expressionBody); 3458var block = this.Block ?? SyntaxFactory.Block(); 3464var block = this.Block ?? SyntaxFactory.Block(); 3516var newNode = SyntaxFactory.InitializerExpression(this.Kind(), openBraceToken, expressions, closeBraceToken); 3606var newNode = SyntaxFactory.ImplicitObjectCreationExpression(newKeyword, argumentList, initializer); 3680var newNode = SyntaxFactory.ObjectCreationExpression(newKeyword, type, argumentList, initializer); 3699var argumentList = this.ArgumentList ?? SyntaxFactory.ArgumentList(); 3750var newNode = SyntaxFactory.WithExpression(expression, withKeyword, initializer); 3810var newNode = SyntaxFactory.AnonymousObjectMemberDeclarator(nameEquals, expression); 3868var newNode = SyntaxFactory.AnonymousObjectCreationExpression(newKeyword, openBraceToken, initializers, closeBraceToken); 3933var newNode = SyntaxFactory.ArrayCreationExpression(newKeyword, type, initializer); 3997var newNode = SyntaxFactory.ImplicitArrayCreationExpression(newKeyword, openBracketToken, commas, closeBracketToken, initializer); 4064var newNode = SyntaxFactory.StackAllocArrayCreationExpression(stackAllocKeyword, type, initializer); 4116var newNode = SyntaxFactory.ImplicitStackAllocArrayCreationExpression(stackAllocKeyword, openBracketToken, closeBracketToken, initializer); 4172var newNode = SyntaxFactory.CollectionExpression(openBracketToken, elements, closeBracketToken); 4223var newNode = SyntaxFactory.ExpressionElement(expression); 4264var newNode = SyntaxFactory.SpreadElement(operatorToken, expression); 4308var newNode = SyntaxFactory.WithElement(withKeyword, argumentList); 4381var newNode = SyntaxFactory.QueryExpression(fromClause, body); 4443var newNode = SyntaxFactory.QueryBody(clauses, selectOrGroup, continuation); 4508var newNode = SyntaxFactory.FromClause(fromKeyword, type, identifier, inKeyword, expression); 4558var newNode = SyntaxFactory.LetClause(letKeyword, identifier, equalsToken, expression); 4641var newNode = SyntaxFactory.JoinClause(joinKeyword, type, identifier, inKeyword, inExpression, onKeyword, leftExpression, equalsKeyword, rightExpression, into); 4691var newNode = SyntaxFactory.JoinIntoClause(intoKeyword, identifier); 4733var newNode = SyntaxFactory.WhereClause(whereKeyword, condition); 4782var newNode = SyntaxFactory.OrderByClause(orderByKeyword, orderings); 4834var newNode = SyntaxFactory.Ordering(this.Kind(), expression, ascendingOrDescendingKeyword); 4876var newNode = SyntaxFactory.SelectClause(selectKeyword, expression); 4935var newNode = SyntaxFactory.GroupClause(groupKeyword, groupExpression, byKeyword, byExpression); 4982var newNode = SyntaxFactory.QueryContinuation(intoKeyword, identifier, body); 5026var newNode = SyntaxFactory.OmittedArraySizeExpression(omittedArraySizeExpressionToken); 5072var newNode = SyntaxFactory.InterpolatedStringExpression(stringStartToken, contents, stringEndToken); 5135var newNode = SyntaxFactory.IsPatternExpression(expression, isKeyword, pattern); 5178var newNode = SyntaxFactory.ThrowExpression(throwKeyword, expression); 5220var newNode = SyntaxFactory.WhenClause(whenKeyword, condition); 5267var newNode = SyntaxFactory.DiscardPattern(underscoreToken); 5321var newNode = SyntaxFactory.DeclarationPattern(type, designation); 5363var newNode = SyntaxFactory.VarPattern(varKeyword, designation); 5428var newNode = SyntaxFactory.RecursivePattern(type, positionalPatternClause, propertyPatternClause, designation); 5443var positionalPatternClause = this.PositionalPatternClause ?? SyntaxFactory.PositionalPatternClause(); 5448var propertyPatternClause = this.PropertyPatternClause ?? SyntaxFactory.PropertyPatternClause(); 5492var newNode = SyntaxFactory.PositionalPatternClause(openParenToken, subpatterns, closeParenToken); 5546var newNode = SyntaxFactory.PropertyPatternClause(openBraceToken, subpatterns, closeBraceToken); 5604var newNode = SyntaxFactory.Subpattern(expressionColon, pattern); 5645var newNode = SyntaxFactory.ConstantPattern(expression); 5688var newNode = SyntaxFactory.ParenthesizedPattern(openParenToken, pattern, closeParenToken); 5732var newNode = SyntaxFactory.RelationalPattern(operatorToken, expression); 5773var newNode = SyntaxFactory.TypePattern(type); 5830var newNode = SyntaxFactory.BinaryPattern(this.Kind(), left, operatorToken, right); 5873var newNode = SyntaxFactory.UnaryPattern(operatorToken, pattern); 5939var newNode = SyntaxFactory.ListPattern(openBracketToken, patterns, closeBracketToken, designation); 5985var newNode = SyntaxFactory.SlicePattern(dotDotToken, pattern); 6033var newNode = SyntaxFactory.InterpolatedStringText(textToken); 6100var newNode = SyntaxFactory.Interpolation(openBraceToken, expression, alignmentClause, formatClause, closeBraceToken); 6145var newNode = SyntaxFactory.InterpolationAlignmentClause(commaToken, value); 6187var newNode = SyntaxFactory.InterpolationFormatClause(colonToken, formatStringToken); 6252var newNode = SyntaxFactory.GlobalStatement(attributeLists, modifiers, statement); 6335var newNode = SyntaxFactory.Block(attributeLists, openBraceToken, statements, closeBraceToken); 6444var newNode = SyntaxFactory.LocalFunctionStatement(attributeLists, modifiers, returnType, identifier, typeParameterList, parameterList, constraintClauses, body, expressionBody, semicolonToken); 6469var typeParameterList = this.TypeParameterList ?? SyntaxFactory.TypeParameterList(); 6476var body = this.Body ?? SyntaxFactory.Block(); 6481var body = this.Body ?? SyntaxFactory.Block(); 6559var newNode = SyntaxFactory.LocalDeclarationStatement(attributeLists, awaitKeyword, usingKeyword, modifiers, declaration, semicolonToken); 6631var newNode = SyntaxFactory.VariableDeclaration(type, variables); 6691var newNode = SyntaxFactory.VariableDeclarator(identifier, argumentList, initializer); 6705var argumentList = this.ArgumentList ?? SyntaxFactory.BracketedArgumentList(); 6740var newNode = SyntaxFactory.EqualsValueClause(equalsToken, value); 6787var newNode = SyntaxFactory.SingleVariableDesignation(identifier); 6825var newNode = SyntaxFactory.DiscardDesignation(underscoreToken); 6875var newNode = SyntaxFactory.ParenthesizedVariableDesignation(openParenToken, variables, closeParenToken); 6935var newNode = SyntaxFactory.ExpressionStatement(attributeLists, expression, semicolonToken); 6982var newNode = SyntaxFactory.EmptyStatement(attributeLists, semicolonToken); 7048var newNode = SyntaxFactory.LabeledStatement(attributeLists, identifier, colonToken, statement); 7139var newNode = SyntaxFactory.GotoStatement(this.Kind(), attributeLists, gotoKeyword, caseOrDefaultKeyword, expression, semicolonToken); 7190var newNode = SyntaxFactory.BreakStatement(attributeLists, breakKeyword, semicolonToken); 7239var newNode = SyntaxFactory.ContinueStatement(attributeLists, continueKeyword, semicolonToken); 7303var newNode = SyntaxFactory.ReturnStatement(attributeLists, returnKeyword, expression, semicolonToken); 7368var newNode = SyntaxFactory.ThrowStatement(attributeLists, throwKeyword, expression, semicolonToken); 7436var newNode = SyntaxFactory.YieldStatement(this.Kind(), attributeLists, yieldKeyword, returnOrBreakKeyword, expression, semicolonToken); 7509var newNode = SyntaxFactory.WhileStatement(attributeLists, whileKeyword, openParenToken, condition, closeParenToken, statement); 7587var newNode = SyntaxFactory.DoStatement(attributeLists, doKeyword, statement, whileKeyword, openParenToken, condition, closeParenToken, semicolonToken); 7696var newNode = SyntaxFactory.ForStatement(attributeLists, forKeyword, openParenToken, declaration, initializers, firstSemicolonToken, condition, secondSemicolonToken, incrementors, closeParenToken, statement); 7836var newNode = SyntaxFactory.ForEachStatement(attributeLists, awaitKeyword, forEachKeyword, openParenToken, type, identifier, inKeyword, expression, closeParenToken, statement); 7943var newNode = SyntaxFactory.ForEachVariableStatement(attributeLists, awaitKeyword, forEachKeyword, openParenToken, variable, inKeyword, expression, closeParenToken, statement); 8041var newNode = SyntaxFactory.UsingStatement(attributeLists, awaitKeyword, usingKeyword, openParenToken, declaration, expression, closeParenToken, statement); 8117var newNode = SyntaxFactory.FixedStatement(attributeLists, fixedKeyword, openParenToken, declaration, closeParenToken, statement); 8184var newNode = SyntaxFactory.CheckedStatement(this.Kind(), attributeLists, keyword, block); 8248var newNode = SyntaxFactory.UnsafeStatement(attributeLists, unsafeKeyword, block); 8321var newNode = SyntaxFactory.LockStatement(attributeLists, lockKeyword, openParenToken, expression, closeParenToken, statement); 8421var newNode = SyntaxFactory.IfStatement(attributeLists, ifKeyword, openParenToken, condition, closeParenToken, statement, @else); 8476var newNode = SyntaxFactory.ElseClause(elseKeyword, statement); 8582var newNode = SyntaxFactory.SwitchStatement(attributeLists, switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, sections, closeBraceToken); 8655var newNode = SyntaxFactory.SwitchSection(labels, statements); 8745var newNode = SyntaxFactory.CasePatternSwitchLabel(keyword, pattern, whenClause, colonToken); 8798var newNode = SyntaxFactory.CaseSwitchLabel(keyword, value, colonToken); 8844var newNode = SyntaxFactory.DefaultSwitchLabel(keyword, colonToken); 8914var newNode = SyntaxFactory.SwitchExpression(governingExpression, switchKeyword, openBraceToken, arms, closeBraceToken); 8981var newNode = SyntaxFactory.SwitchExpressionArm(pattern, whenClause, equalsGreaterThanToken, expression); 9050var newNode = SyntaxFactory.TryStatement(attributeLists, tryKeyword, block, catches, @finally); 9122var newNode = SyntaxFactory.CatchClause(catchKeyword, declaration, filter, block); 9180var newNode = SyntaxFactory.CatchDeclaration(openParenToken, type, identifier, closeParenToken); 9228var newNode = SyntaxFactory.CatchFilterClause(whenKeyword, openParenToken, filterExpression, closeParenToken); 9272var newNode = SyntaxFactory.FinallyClause(finallyKeyword, block); 9343var newNode = SyntaxFactory.CompilationUnit(externs, usings, attributeLists, members, endOfFileToken); 9403var newNode = SyntaxFactory.ExternAliasDirective(externKeyword, aliasKeyword, identifier, semicolonToken); 9491var newNode = SyntaxFactory.UsingDirective(globalKeyword, usingKeyword, staticKeyword, unsafeKeyword, alias, namespaceOrType, semicolonToken); 9660var newNode = SyntaxFactory.NamespaceDeclaration(attributeLists, modifiers, namespaceKeyword, name, openBraceToken, externs, usings, members, closeBraceToken, semicolonToken); 9769var newNode = SyntaxFactory.FileScopedNamespaceDeclaration(attributeLists, modifiers, namespaceKeyword, name, semicolonToken, externs, usings, members); 9864var newNode = SyntaxFactory.AttributeList(openBracketToken, target, attributes, closeBracketToken); 9912var newNode = SyntaxFactory.AttributeTargetSpecifier(identifier, colonToken); 9969var newNode = SyntaxFactory.Attribute(name, argumentList); 9982var argumentList = this.ArgumentList ?? SyntaxFactory.AttributeArgumentList(); 10030var newNode = SyntaxFactory.AttributeArgumentList(openParenToken, arguments, closeParenToken); 10095var newNode = SyntaxFactory.AttributeArgument(nameEquals, nameColon, expression); 10140var newNode = SyntaxFactory.NameEquals(name, equalsToken); 10195var newNode = SyntaxFactory.TypeParameterList(lessThanToken, parameters, greaterThanToken); 10252var newNode = SyntaxFactory.TypeParameter(attributeLists, varianceKeyword, identifier); 10468var newNode = SyntaxFactory.ClassDeclaration(attributeLists, modifiers, keyword, identifier, typeParameterList, parameterList, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken); 10508var typeParameterList = this.TypeParameterList ?? SyntaxFactory.TypeParameterList(); 10514var parameterList = this.ParameterList ?? SyntaxFactory.ParameterList(); 10520var baseList = this.BaseList ?? SyntaxFactory.BaseList(); 10635var newNode = SyntaxFactory.StructDeclaration(this.Kind(), attributeLists, modifiers, keyword, identifier, typeParameterList, parameterList, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken); 10675var typeParameterList = this.TypeParameterList ?? SyntaxFactory.TypeParameterList(); 10681var parameterList = this.ParameterList ?? SyntaxFactory.ParameterList(); 10687var baseList = this.BaseList ?? SyntaxFactory.BaseList(); 10801var newNode = SyntaxFactory.InterfaceDeclaration(attributeLists, modifiers, keyword, identifier, typeParameterList, parameterList, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken); 10841var typeParameterList = this.TypeParameterList ?? SyntaxFactory.TypeParameterList(); 10847var parameterList = this.ParameterList ?? SyntaxFactory.ParameterList(); 10853var baseList = this.BaseList ?? SyntaxFactory.BaseList(); 10975var newNode = SyntaxFactory.RecordDeclaration(this.Kind(), attributeLists, modifiers, keyword, classOrStructKeyword, identifier, typeParameterList, parameterList, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken); 11016var typeParameterList = this.TypeParameterList ?? SyntaxFactory.TypeParameterList(); 11022var parameterList = this.ParameterList ?? SyntaxFactory.ParameterList(); 11028var baseList = this.BaseList ?? SyntaxFactory.BaseList(); 11136var newNode = SyntaxFactory.EnumDeclaration(attributeLists, modifiers, enumKeyword, identifier, baseList, openBraceToken, members, closeBraceToken, semicolonToken); 11168var baseList = this.BaseList ?? SyntaxFactory.BaseList(); 11254var newNode = SyntaxFactory.DelegateDeclaration(attributeLists, modifiers, delegateKeyword, returnType, identifier, typeParameterList, parameterList, constraintClauses, semicolonToken); 11280var typeParameterList = this.TypeParameterList ?? SyntaxFactory.TypeParameterList(); 11342var newNode = SyntaxFactory.EnumMemberDeclaration(attributeLists, modifiers, identifier, equalsValue); 11460var newNode = SyntaxFactory.ExtensionBlockDeclaration(attributeLists, modifiers, keyword, typeParameterList, parameterList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken); 11496var typeParameterList = this.TypeParameterList ?? SyntaxFactory.TypeParameterList(); 11502var parameterList = this.ParameterList ?? SyntaxFactory.ParameterList(); 11551var newNode = SyntaxFactory.BaseList(colonToken, types); 11606var newNode = SyntaxFactory.SimpleBaseType(type); 11661var newNode = SyntaxFactory.PrimaryConstructorBaseType(type, argumentList); 11734var newNode = SyntaxFactory.TypeParameterConstraintClause(whereKeyword, name, colonToken, constraints); 11794var newNode = SyntaxFactory.ConstructorConstraint(newKeyword, openParenToken, closeParenToken); 11847var newNode = SyntaxFactory.ClassOrStructConstraint(this.Kind(), classOrStructKeyword, questionToken); 11889var newNode = SyntaxFactory.TypeConstraint(type); 11929var newNode = SyntaxFactory.DefaultConstraint(defaultKeyword); 11979var newNode = SyntaxFactory.AllowsConstraintClause(allowsKeyword, constraints); 12034var newNode = SyntaxFactory.RefStructConstraint(refKeyword, structKeyword); 12126var newNode = SyntaxFactory.FieldDeclaration(attributeLists, modifiers, declaration, semicolonToken); 12207var newNode = SyntaxFactory.EventFieldDeclaration(attributeLists, modifiers, eventKeyword, declaration, semicolonToken); 12263var newNode = SyntaxFactory.ExplicitInterfaceSpecifier(name, dotToken); 12416var newNode = SyntaxFactory.MethodDeclaration(attributeLists, modifiers, returnType, explicitInterfaceSpecifier, identifier, typeParameterList, parameterList, constraintClauses, body, expressionBody, semicolonToken); 12448var typeParameterList = this.TypeParameterList ?? SyntaxFactory.TypeParameterList(); 12457var body = this.Body ?? SyntaxFactory.Block(); 12463var body = this.Body ?? SyntaxFactory.Block(); 12568var newNode = SyntaxFactory.OperatorDeclaration(attributeLists, modifiers, returnType, explicitInterfaceSpecifier, operatorKeyword, checkedKeyword, operatorToken, parameterList, body, expressionBody, semicolonToken); 12603var body = this.Body ?? SyntaxFactory.Block(); 12609var body = this.Body ?? SyntaxFactory.Block(); 12714var newNode = SyntaxFactory.ConversionOperatorDeclaration(attributeLists, modifiers, implicitOrExplicitKeyword, explicitInterfaceSpecifier, operatorKeyword, checkedKeyword, type, parameterList, body, expressionBody, semicolonToken); 12749var body = this.Body ?? SyntaxFactory.Block(); 12755var body = this.Body ?? SyntaxFactory.Block(); 12841var newNode = SyntaxFactory.ConstructorDeclaration(attributeLists, modifiers, identifier, parameterList, initializer, body, expressionBody, semicolonToken); 12873var body = this.Body ?? SyntaxFactory.Block(); 12879var body = this.Body ?? SyntaxFactory.Block(); 12920var newNode = SyntaxFactory.ConstructorInitializer(this.Kind(), colonToken, thisOrBaseKeyword, argumentList); 13014var newNode = SyntaxFactory.DestructorDeclaration(attributeLists, modifiers, tildeToken, identifier, parameterList, body, expressionBody, semicolonToken); 13046var body = this.Body ?? SyntaxFactory.Block(); 13052var body = this.Body ?? SyntaxFactory.Block(); 13174var newNode = SyntaxFactory.PropertyDeclaration(attributeLists, modifiers, type, explicitInterfaceSpecifier, identifier, accessorList, expressionBody, initializer, semicolonToken); 13204var accessorList = this.AccessorList ?? SyntaxFactory.AccessorList(); 13240var newNode = SyntaxFactory.ArrowExpressionClause(arrowToken, expression); 13328var newNode = SyntaxFactory.EventDeclaration(attributeLists, modifiers, eventKeyword, type, explicitInterfaceSpecifier, identifier, accessorList, semicolonToken); 13357var accessorList = this.AccessorList ?? SyntaxFactory.AccessorList(); 13446var newNode = SyntaxFactory.IndexerDeclaration(attributeLists, modifiers, type, explicitInterfaceSpecifier, thisKeyword, parameterList, accessorList, expressionBody, semicolonToken); 13477var accessorList = this.AccessorList ?? SyntaxFactory.AccessorList(); 13514var newNode = SyntaxFactory.AccessorList(openBraceToken, accessors, closeBraceToken); 13608var newNode = SyntaxFactory.AccessorDeclaration(this.Kind(), attributeLists, modifiers, keyword, body, expressionBody, semicolonToken); 13627var body = this.Body ?? SyntaxFactory.Block(); 13632var body = this.Body ?? SyntaxFactory.Block(); 13696var newNode = SyntaxFactory.ParameterList(openParenToken, parameters, closeParenToken); 13755var newNode = SyntaxFactory.BracketedParameterList(openBracketToken, parameters, closeBracketToken); 13874var newNode = SyntaxFactory.Parameter(attributeLists, modifiers, type, identifier, @default); 13952var newNode = SyntaxFactory.FunctionPointerParameter(attributeLists, modifiers, type); 14025var newNode = SyntaxFactory.IncompleteMember(attributeLists, modifiers, type); 14079var newNode = SyntaxFactory.SkippedTokensTrivia(tokens); 14123var newNode = SyntaxFactory.DocumentationCommentTrivia(this.Kind(), content, endOfComment); 14184var newNode = SyntaxFactory.TypeCref(type); 14247var newNode = SyntaxFactory.QualifiedCref(container, dotToken, member); 14324var newNode = SyntaxFactory.NameMemberCref(name, parameters); 14337var parameters = this.Parameters ?? SyntaxFactory.CrefParameterList(); 14394var newNode = SyntaxFactory.ExtensionMemberCref(extensionKeyword, typeArgumentList, parameters, dotToken, member); 14410var typeArgumentList = this.TypeArgumentList ?? SyntaxFactory.TypeArgumentList(); 14450var newNode = SyntaxFactory.IndexerMemberCref(thisKeyword, parameters); 14463var parameters = this.Parameters ?? SyntaxFactory.CrefBracketedParameterList(); 14515var newNode = SyntaxFactory.OperatorMemberCref(operatorKeyword, checkedKeyword, operatorToken, parameters); 14530var parameters = this.Parameters ?? SyntaxFactory.CrefParameterList(); 14595var newNode = SyntaxFactory.ConversionOperatorMemberCref(implicitOrExplicitKeyword, operatorKeyword, checkedKeyword, type, parameters); 14611var parameters = this.Parameters ?? SyntaxFactory.CrefParameterList(); 14680var newNode = SyntaxFactory.CrefParameterList(openParenToken, parameters, closeParenToken); 14741var newNode = SyntaxFactory.CrefBracketedParameterList(openBracketToken, parameters, closeBracketToken); 14810var newNode = SyntaxFactory.CrefParameter(refKindKeyword, readOnlyKeyword, type); 14879var newNode = SyntaxFactory.XmlElement(startTag, content, endTag); 14942var newNode = SyntaxFactory.XmlElementStartTag(lessThanToken, name, attributes, greaterThanToken); 14990var newNode = SyntaxFactory.XmlElementEndTag(lessThanSlashToken, name, greaterThanToken); 15050var newNode = SyntaxFactory.XmlEmptyElement(lessThanToken, name, attributes, slashGreaterThanToken); 15096var newNode = SyntaxFactory.XmlName(prefix, localName); 15137var newNode = SyntaxFactory.XmlPrefix(prefix, colonToken); 15216var newNode = SyntaxFactory.XmlTextAttribute(name, equalsToken, startQuoteToken, textTokens, endQuoteToken); 15286var newNode = SyntaxFactory.XmlCrefAttribute(name, equalsToken, startQuoteToken, cref, endQuoteToken); 15354var newNode = SyntaxFactory.XmlNameAttribute(name, equalsToken, startQuoteToken, identifier, endQuoteToken); 15407var newNode = SyntaxFactory.XmlText(textTokens); 15458var newNode = SyntaxFactory.XmlCDataSection(startCDataToken, textTokens, endCDataToken); 15514var newNode = SyntaxFactory.XmlProcessingInstruction(startProcessingInstructionToken, name, textTokens, endProcessingInstructionToken); 15568var newNode = SyntaxFactory.XmlComment(lessThanExclamationMinusMinusToken, textTokens, minusMinusGreaterThanToken); 15668var newNode = SyntaxFactory.IfDirectiveTrivia(hashToken, ifKeyword, condition, endOfDirectiveToken, isActive, branchTaken, conditionValue); 15728var newNode = SyntaxFactory.ElifDirectiveTrivia(hashToken, elifKeyword, condition, endOfDirectiveToken, isActive, branchTaken, conditionValue); 15783var newNode = SyntaxFactory.ElseDirectiveTrivia(hashToken, elseKeyword, endOfDirectiveToken, isActive, branchTaken); 15833var newNode = SyntaxFactory.EndIfDirectiveTrivia(hashToken, endIfKeyword, endOfDirectiveToken, isActive); 15882var newNode = SyntaxFactory.RegionDirectiveTrivia(hashToken, regionKeyword, endOfDirectiveToken, isActive); 15931var newNode = SyntaxFactory.EndRegionDirectiveTrivia(hashToken, endRegionKeyword, endOfDirectiveToken, isActive); 15980var newNode = SyntaxFactory.ErrorDirectiveTrivia(hashToken, errorKeyword, endOfDirectiveToken, isActive); 16029var newNode = SyntaxFactory.WarningDirectiveTrivia(hashToken, warningKeyword, endOfDirectiveToken, isActive); 16078var newNode = SyntaxFactory.BadDirectiveTrivia(hashToken, identifier, endOfDirectiveToken, isActive); 16129var newNode = SyntaxFactory.DefineDirectiveTrivia(hashToken, defineKeyword, name, endOfDirectiveToken, isActive); 16181var newNode = SyntaxFactory.UndefDirectiveTrivia(hashToken, undefKeyword, name, endOfDirectiveToken, isActive); 16261var newNode = SyntaxFactory.LineDirectiveTrivia(hashToken, lineKeyword, line, file, endOfDirectiveToken, isActive); 16316var newNode = SyntaxFactory.LineDirectivePosition(openParenToken, line, commaToken, character, closeParenToken); 16395var newNode = SyntaxFactory.LineSpanDirectiveTrivia(hashToken, lineKeyword, start, minusToken, end, characterOffset, file, endOfDirectiveToken, isActive); 16465var newNode = SyntaxFactory.PragmaWarningDirectiveTrivia(hashToken, pragmaKeyword, warningKeyword, disableOrRestoreKeyword, errorCodes, endOfDirectiveToken, isActive); 16527var newNode = SyntaxFactory.PragmaChecksumDirectiveTrivia(hashToken, pragmaKeyword, checksumKeyword, file, guid, bytes, endOfDirectiveToken, isActive); 16582var newNode = SyntaxFactory.ReferenceDirectiveTrivia(hashToken, referenceKeyword, file, endOfDirectiveToken, isActive); 16634var newNode = SyntaxFactory.LoadDirectiveTrivia(hashToken, loadKeyword, file, endOfDirectiveToken, isActive); 16684var newNode = SyntaxFactory.ShebangDirectiveTrivia(hashToken, exclamationToken, endOfDirectiveToken, isActive); 16742var newNode = SyntaxFactory.IgnoredDirectiveTrivia(hashToken, colonToken, content, endOfDirectiveToken, isActive); 16803var newNode = SyntaxFactory.NullableDirectiveTrivia(hashToken, nullableKeyword, settingToken, targetToken, endOfDirectiveToken, isActive);

11788var conditionalAccessNode = SyntaxFactory.FindConditionalAccessNodeForBinding(binding);

207var tree = SyntaxFactory.ParseSyntaxTree(

49NameSyntax qualifiedName = SyntaxFactory.IdentifierName(identifiers[0]); 53qualifiedName = SyntaxFactory.QualifiedName(left: qualifiedName, right: SyntaxFactory.IdentifierName(identifiers[j]));

290expression = SyntaxFactory.GetStandaloneExpression(expression); 308var crefWrapper = SyntaxFactory.QualifiedCref(qualified.Left, SyntaxFactory.NameMemberCref(qualified.Right)); 314(CrefSyntax)SyntaxFactory.TypeCref(typeSyntax) : 315SyntaxFactory.NameMemberCref(typeSyntax);

172var expression = SyntaxFactory.GetStandaloneExpression(type); 203expression = SyntaxFactory.GetStandaloneExpression(expression); 2258var tmp = SyntaxFactory.GetStandaloneNode(node); 2366bindableParent = SyntaxFactory.GetStandaloneExpression(arrayType);

241var loadedTree = SyntaxFactory.ParseSyntaxTree(

207node = SyntaxFactory.GetStandaloneNode(node); 308node = SyntaxFactory.GetStandaloneNode(node); 400node = SyntaxFactory.GetStandaloneNode(node); 409node = SyntaxFactory.GetStandaloneNode(node); 418node = SyntaxFactory.GetStandaloneNode(node);

498CrefSyntax crefSyntax = SyntaxFactory.ParseCref(attributeValue); 621SyntaxTriviaList leadingTrivia = SyntaxFactory.ParseLeadingTrivia(commentText, CSharpParseOptions.Default.WithDocumentationMode(DocumentationMode.Diagnose));

275return SyntaxFactory.TokenList(items);

255var identifierName = SyntaxFactory.IdentifierName(symbol.Name); 294var token = SyntaxFactory.ParseToken(nameWithoutAttributeSuffix);

515return SyntaxFactory.AreEquivalent(this, (CSharpSyntaxNode)node, topLevel);

127return SyntaxFactory.Trivia(newStructure);

127return SyntaxFactory.AreEquivalent(this, tree, topLevel);

25_node = this.CloneNodeAsRoot(SyntaxFactory.ParseCompilationUnit(string.Empty));

70var tree = SyntaxFactory.ParseSyntaxTree(_text, _options, _path, cancellationToken);

46SyntaxFactory.Token(SyntaxKind.TildeToken), 80SyntaxFactory.Token(SyntaxKind.TildeToken),

44return SyntaxFactory.IndexerDeclaration(

243return CSharp.SyntaxFactory.Token(SyntaxKind.CommaToken);

245if (!SyntaxFactory.AreEquivalent(sourceIdentifier, selectorIdentifier)) 363=> DescendantTokensIgnoringLambdaBodies(oldNode).SequenceEqual(DescendantTokensIgnoringLambdaBodies(newNode), SyntaxFactory.AreEquivalent);

14=> SyntaxFactory.LiteralExpression(kind, SyntaxFactory.Token(GetLiteralExpressionTokenKind(kind)));

39return SyntaxFactory.MethodDeclaration(

17return SyntaxFactory.ExpressionColon(expression, this.ColonToken);

13=> SyntaxFactory.Parameter(default, default(SyntaxTokenList), null, identifier, null);

52=> SyntaxFactory.ParenthesizedLambdaExpression(attributeLists: default, modifiers, returnType: null, parameterList, arrowToken, block, expressionBody); 55=> SyntaxFactory.ParenthesizedLambdaExpression(attributeLists: default, modifiers, parameterList, block, expressionBody); 58=> SyntaxFactory.ParenthesizedLambdaExpression(attributeLists, modifiers, returnType: null, parameterList, block, expressionBody);

46return SyntaxFactory.AccessorDeclaration(kind, default(SyntaxList<AttributeListSyntax>), default(SyntaxTokenList), SyntaxFactory.Token(GetAccessorDeclarationKeywordKind(kind)), body, expressionBody: null, default(SyntaxToken));

44=> SyntaxFactory.SimpleLambdaExpression(attributeLists, modifiers, parameter, SyntaxFactory.Token(SyntaxKind.EqualsGreaterThanToken), block, expressionBody); 48=> SyntaxFactory.SimpleLambdaExpression(default, default(SyntaxTokenList), parameter, SyntaxFactory.Token(SyntaxKind.EqualsGreaterThanToken), null, null);

128return SyntaxFactory.TriviaList(sequence);

2143return SyntaxFactory.GetStandaloneNode(expression) as ExpressionSyntax ?? expression; 2335return SyntaxFactory.BinaryExpression(expression.Kind(), max.Expression, max.OperatorToken, SyntaxFactory.IdentifierName(gn.Identifier)); 2343return SyntaxFactory.QualifiedName(qn.Left, qn.DotToken, SyntaxFactory.IdentifierName(gn.Identifier)); 2351return SyntaxFactory.AliasQualifiedName(an.Alias, an.ColonColonToken, SyntaxFactory.IdentifierName(gn.Identifier)); 2477return SyntaxFactory.CaseSwitchLabel(SyntaxFactory.Token(SyntaxKind.CaseKeyword), value, SyntaxFactory.Token(SyntaxKind.ColonToken)); 2483return SyntaxFactory.DefaultSwitchLabel(SyntaxFactory.Token(SyntaxKind.DefaultKeyword), SyntaxFactory.Token(SyntaxKind.ColonToken)); 2506return SyntaxFactory.PropertyDeclaration( 2527return SyntaxFactory.ConversionOperatorDeclaration( 2549return SyntaxFactory.ConversionOperatorDeclaration( 2571return SyntaxFactory.ConversionOperatorDeclaration( 2595return SyntaxFactory.ConversionOperatorDeclaration( 2620return SyntaxFactory.OperatorDeclaration( 2644return SyntaxFactory.OperatorDeclaration( 2667return SyntaxFactory.OperatorDeclaration( 2691return SyntaxFactory.OperatorDeclaration( 2736=> SyntaxFactory.AccessorDeclaration(kind, attributeLists, modifiers, body, expressionBody: null); 2738=> SyntaxFactory.AccessorDeclaration(kind, attributeLists, modifiers, keyword, body, expressionBody: null, semicolonToken); 2740=> SyntaxFactory.AccessorDeclaration(kind, attributeLists, modifiers, body: null, expressionBody); 2742=> SyntaxFactory.AccessorDeclaration(kind, attributeLists, modifiers, keyword, body: null, expressionBody, semicolonToken); 2772var openParen = needsParens ? SyntaxFactory.Token(SyntaxKind.OpenParenToken) : default; 2773var closeParen = needsParens ? SyntaxFactory.Token(SyntaxKind.CloseParenToken) : default; 2774return SyntaxFactory.SwitchStatement( 2776SyntaxFactory.Token(SyntaxKind.SwitchKeyword), 2780SyntaxFactory.Token(SyntaxKind.OpenBraceToken), 2782SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 2788return SyntaxFactory.SwitchStatement(expression, default(SyntaxList<SwitchSectionSyntax>)); 2819? AnonymousMethodExpression(default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.DelegateKeyword), parameterList, block, null) 2886return SyntaxFactory.OperatorMemberCref( 2896return SyntaxFactory.ConversionOperatorMemberCref( 2907return SyntaxFactory.ClassDeclaration( 2916return SyntaxFactory.ClassDeclaration(attributeLists, modifiers, identifier, typeParameterList, parameterList: null, baseList, constraintClauses, members); 2921=> SyntaxFactory.ClassDeclaration(attributeLists, modifiers, SyntaxFactory.Token(SyntaxKind.ClassKeyword), identifier, typeParameterList, parameterList, baseList, constraintClauses, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), members, SyntaxFactory.Token(SyntaxKind.CloseBraceToken), default); 2925=> SyntaxFactory.ClassDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.ClassKeyword), identifier, null, null, null, default, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), default, SyntaxFactory.Token(SyntaxKind.CloseBraceToken), default); 2929=> SyntaxFactory.ClassDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.ClassKeyword), SyntaxFactory.Identifier(identifier), null, null, null, default, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), default, SyntaxFactory.Token(SyntaxKind.CloseBraceToken), default); 2934return SyntaxFactory.StructDeclaration( 2943return SyntaxFactory.StructDeclaration(attributeLists, modifiers, identifier, typeParameterList, parameterList: null, baseList, constraintClauses, members); 2948=> SyntaxFactory.StructDeclaration(attributeLists, modifiers, SyntaxFactory.Token(SyntaxKind.StructKeyword), identifier, typeParameterList, parameterList, baseList, constraintClauses, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), members, SyntaxFactory.Token(SyntaxKind.CloseBraceToken), default); 2952=> SyntaxFactory.StructDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.StructKeyword), identifier, null, null, null, default, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), default, SyntaxFactory.Token(SyntaxKind.CloseBraceToken), default); 2956=> SyntaxFactory.StructDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.StructKeyword), SyntaxFactory.Identifier(identifier), null, null, null, default, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), default, SyntaxFactory.Token(SyntaxKind.CloseBraceToken), default); 2966=> SyntaxFactory.InterfaceDeclaration(attributeLists, modifiers, SyntaxFactory.Token(SyntaxKind.InterfaceKeyword), identifier, typeParameterList, baseList, constraintClauses, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), members, SyntaxFactory.Token(SyntaxKind.CloseBraceToken), default); 2970=> SyntaxFactory.InterfaceDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.InterfaceKeyword), identifier, null, null, default, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), default, SyntaxFactory.Token(SyntaxKind.CloseBraceToken), default); 2974=> SyntaxFactory.InterfaceDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.InterfaceKeyword), SyntaxFactory.Identifier(identifier), null, null, default, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), default, SyntaxFactory.Token(SyntaxKind.CloseBraceToken), default); 2978=> SyntaxFactory.EnumDeclaration(attributeLists, modifiers, SyntaxFactory.Token(SyntaxKind.EnumKeyword), identifier, baseList, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), members, SyntaxFactory.Token(SyntaxKind.CloseBraceToken), default); 2982=> SyntaxFactory.EnumDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.EnumKeyword), identifier, null, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), default, SyntaxFactory.Token(SyntaxKind.CloseBraceToken), default); 2986=> SyntaxFactory.EnumDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.EnumKeyword), SyntaxFactory.Identifier(identifier), null, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), default, SyntaxFactory.Token(SyntaxKind.CloseBraceToken), default);

56node = (ExpressionSyntax)SyntaxFactory.GetStandaloneExpression(node); 66node = (ExpressionSyntax)SyntaxFactory.GetStandaloneExpression(node); 84node = SyntaxFactory.GetStandaloneExpression(node); 244node = SyntaxFactory.GetStandaloneExpression(node);

102this.AddEndOfLine(GetEndOfLine(trivia) ?? SyntaxFactory.CarriageReturnLineFeed); 320this.AddResidualTrivia(SyntaxFactory.TriviaList(SyntaxFactory.ElasticMarker)); 360this.AddResidualTrivia(SyntaxFactory.TriviaList(SyntaxFactory.ElasticMarker)); 400this.AddResidualTrivia(SyntaxFactory.TriviaList(SyntaxFactory.ElasticMarker)); 475AddResidualTrivia(SyntaxFactory.TriviaList(indentationTrivia, parentTrivia), requiresNewLine: true); 479AddResidualTrivia(SyntaxFactory.TriviaList(parentTrivia), requiresNewLine: true);

41_eolTrivia = useElasticTrivia ? SyntaxFactory.ElasticEndOfLine(eolWhitespace) : SyntaxFactory.EndOfLine(eolWhitespace); 182_indentations.Add(_useElasticTrivia ? SyntaxFactory.ElasticWhitespace(text) : SyntaxFactory.Whitespace(text)); 1143return SyntaxFactory.TriviaList(currentTriviaList.First()); 1147return SyntaxFactory.TriviaList(currentTriviaList); 1156private static readonly SyntaxTrivia s_trimmedDocCommentExterior = SyntaxFactory.DocumentationCommentExterior("///"); 1160return _useElasticTrivia ? SyntaxFactory.ElasticSpace : SyntaxFactory.Space;

95SyntaxFactory.Token(GetTypeDeclarationKeywordKind(kind)), 100SyntaxFactory.Token(SyntaxKind.OpenBraceToken), 102SyntaxFactory.Token(SyntaxKind.CloseBraceToken), 108return SyntaxFactory.TypeDeclaration(kind, SyntaxFactory.Identifier(identifier)); 128return SyntaxFactory.ClassDeclaration(attributes, modifiers, keyword, identifier, typeParameterList, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken); 130return SyntaxFactory.StructDeclaration(SyntaxKind.StructDeclaration, attributes, modifiers, keyword, identifier, typeParameterList, parameterList: null, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken); 132return SyntaxFactory.StructDeclaration(SyntaxKind.UnionDeclaration, attributes, modifiers, keyword, identifier, typeParameterList, parameterList: null, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken); 134return SyntaxFactory.InterfaceDeclaration(attributes, modifiers, keyword, identifier, typeParameterList, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken); 136return SyntaxFactory.RecordDeclaration(SyntaxKind.RecordDeclaration, attributes, modifiers, keyword, classOrStructKeyword: default, identifier, typeParameterList, parameterList: null, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken); 138return SyntaxFactory.RecordDeclaration(SyntaxKind.RecordStructDeclaration, attributes, modifiers, keyword, classOrStructKeyword: SyntaxFactory.Token(SyntaxKind.StructKeyword), identifier, typeParameterList, parameterList: null, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken);

20return SyntaxFactory.ParseExpression(expression).WithAdditionalAnnotations(Simplifier.Annotation);

20=> SyntaxFactory.ConditionalAccessExpression((ExpressionSyntax)expression, (ExpressionSyntax)whenNotNull);

48newInvocation = SyntaxFactory.InvocationExpression( 49SyntaxFactory.MemberAccessExpression( 52SyntaxFactory.IdentifierName(SyntaxFactory.Identifier("IsKind")))); 66.AddArgumentListArguments(SyntaxFactory.Argument(binaryExpression.Right.WithoutTrailingTrivia())) 71return SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression, newInvocation.WithoutLeadingTrivia()).WithLeadingTrivia(newInvocation.GetLeadingTrivia()); 84return memberAccessExpression.WithName(SyntaxFactory.IdentifierName(SyntaxFactory.Identifier("IsKind")));

255if (!SyntaxFactory.AreEquivalent(node.Left, _assignmentTargetOpt))

148if (SyntaxFactory.AreEquivalent(expression, invocationExpression.Expression, topLevel: false)) 153SyntaxFactory.AreEquivalent(expression, memberAccessExpression.Expression, topLevel: false))

23using static SyntaxFactory;

27using static SyntaxFactory;

22using static SyntaxFactory;

16using static SyntaxFactory;

21using static SyntaxFactory;

19using static SyntaxFactory;

12using static SyntaxFactory;

200if (!SyntaxFactory.AreEquivalent(isExpression.Left.WalkDownParentheses(), castExpression.Expression.WalkDownParentheses(), topLevel: false) || 201!SyntaxFactory.AreEquivalent(isExpression.Right.WalkDownParentheses(), castExpression.Type, topLevel: false))

7using static SyntaxFactory;

18return [SyntaxFactory.Token(argument.RefKindKeyword.Kind())];

27block = SyntaxFactory.Block(statement);

117var parsed = SyntaxFactory.ParseStatement(nextTrivia.ToFullString()); 153arrowExpression = SyntaxFactory.ArrowExpressionClause(expression); 228expression = SyntaxFactory.ThrowExpression(throwStatement.ThrowKeyword, throwStatement.Expression);

16SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression);

876return SyntaxFactory.ThrowStatement(throwExpression.ThrowKeyword, throwExpression.Expression, semicolonToken); 882return SyntaxFactory.ReturnStatement(expression.WithLeadingTrivia(SyntaxFactory.ElasticSpace)) 885.WithPrependedLeadingTrivia(SyntaxFactory.ElasticMarker); 889return SyntaxFactory.ReturnStatement(expression) 895return SyntaxFactory.ExpressionStatement(expression)

107var expr = SyntaxFactory.GetStandaloneExpression(expression);

34token = token.WithLeadingTrivia(SyntaxFactory.ElasticSpace); 38token = token.WithLeadingTrivia(SyntaxFactory.Space); 46token = token.WithTrailingTrivia(SyntaxFactory.ElasticSpace); 50token = token.WithTrailingTrivia(SyntaxFactory.Space); 65token = SyntaxFactory.Token(

247var name = SyntaxFactory.ParseName(syntaxTree.GetText(cancellationToken).ToString(TextSpan.FromBounds(genericIdentifier.SpanStart, lastToken.Span.End)));

142=> SyntaxFactory.ParseLeadingTrivia(s ?? string.Empty); 185yield return SyntaxFactory.ElasticMarker;

49=> SyntaxFactory.Whitespace(text); 55_newLine = SyntaxFactory.EndOfLine(Context.Options.NewLine); 234var multilineCommentTrivia = SyntaxFactory.ParseLeadingTrivia(multiLineComment); 348var formattedTrivia = SyntaxFactory.Trivia((StructuredTriviaSyntax)result.GetFormattedRoot(cancellationToken)); 382var formattedTrivia = SyntaxFactory.Trivia((StructuredTriviaSyntax)result.GetFormattedRoot(cancellationToken));

56var parsedNewTrivia = SyntaxFactory.DocumentationCommentExterior(newTriviaText);

90var trailingTrivia = SyntaxFactory.ParseTrailingTrivia(text); 93var leadingTrivia = SyntaxFactory.ParseLeadingTrivia(text[width..]); 146return SyntaxFactory.ParseLeadingTrivia(text);

23? SyntaxFactory.Comment(text)

39=> SyntaxFactory.ElasticMarker; 42=> SyntaxFactory.ElasticCarriageReturnLineFeed; 88=> SyntaxFactory.ParseToken(text); 91=> SyntaxFactory.ParseLeadingTrivia(text); 183=> node is ExpressionSyntax expression ? SyntaxFactory.GetStandaloneExpression(expression) : node; 459var token = SyntaxFactory.ParseToken(identifier); 465var token = SyntaxFactory.ParseToken(identifier); 1257=> SyntaxFactory.AreEquivalent(token1, token2); 1260=> SyntaxFactory.AreEquivalent(node1, node2);

97var candidateReplacementNode = SyntaxFactory.IdentifierName("var"); 177SyntaxFactory.IdentifierName("var").WithTriviaFrom(declarationTypeNode).WithAdditionalAnnotations(annotation));

39SyntaxFactory.NameEquals( 40SyntaxFactory.IdentifierName(name)));

46return embeddedStatement is null ? currentStatement : currentStatement.ReplaceNode(embeddedStatement, SyntaxFactory.Block(embeddedStatement));

22using static SyntaxFactory;

59var newBody = SyntaxFactory.Block(statements.Add(exprOrStatement).Cast<StatementSyntax>()); 79var newBody = SyntaxFactory.Block(statements.Add(generator.ReturnStatement(exprOrStatement)).Cast<StatementSyntax>());

22using static SyntaxFactory;

18using static SyntaxFactory;

98SyntaxFactory.ParseTypeName("Task")

24using static SyntaxFactory;

412return SyntaxFactory.LiteralExpression(

25using static SyntaxFactory;

75var newDocCommentNode = SyntaxFactory.DocumentationComment(SyntaxFactory.XmlParamElement(parameterName)); 81return elementNode.WithTrailingTrivia(SyntaxFactory.ParseTrailingTrivia(Environment.NewLine)); 85SyntaxFactory.ParseLeadingTrivia(Environment.NewLine)

41=> SyntaxFactory.ParseLeadingTrivia(docCommentText);

103clause.Constraints.Insert(0, SyntaxFactory.ClassOrStructConstraint(

64identifierToken = SyntaxFactory.Token( 90identifierToken = SyntaxFactory.Token(

46var typeToInsert = SyntaxFactory.ParseTypeName(diagnostic.Properties[CSharpHiddenExplicitCastDiagnosticAnalyzer.Type]!);

112var methodDecl = SyntaxFactory.DestructorDeclaration(classType.Name).AddBodyStatements(disposeStatement);

29using static SyntaxFactory;

24using static SyntaxFactory;

75var yieldStatement = SyntaxFactory.YieldStatement(

22using static SyntaxFactory;

23using static SyntaxFactory;

64newReturnType = SyntaxFactory.PredefinedType(VoidKeyword).WithTriviaFrom(returnTypeSyntax);

31using static SyntaxFactory; 379var newFirstMember = firstMember.WithLeadingTrivia(firstMemberTrivia.Insert(0, SyntaxFactory.CarriageReturnLineFeed));

77.WithTrailingTrivia(SyntaxFactory.Space); 96replacementMap[colonToken] = colonToken.WithLeadingTrivia(thisBaseKeyword.LeadingTrivia).WithTrailingTrivia(SyntaxFactory.Space);

23using static SyntaxFactory;

105var fixedDeclaration = SyntaxFactory.NullableType(declarationTypeToFix.WithoutTrivia()).WithTriviaFrom(declarationTypeToFix);

16using static SyntaxFactory;

38var block = SyntaxFactory.Block(statement);

52return SyntaxFactory.BinaryExpression( 65SyntaxFactory.TypePattern(((DeclarationPatternSyntax)current).Type)

85editor.ReplaceNode(statement, SyntaxFactory.Block());

21using static SyntaxFactory;

19using static SyntaxFactory;

22using static SyntaxFactory;

59var remainingLeadingTrivia = SyntaxFactory.TriviaList(leadingTrivia.Skip(skippedTriviaIndex + 1)); 65.WithLeadingTrivia(SyntaxFactory.TriviaList(remainingLeadingTrivia.Skip(trailingTriviaTakeUntil))) 69.WithTrailingTrivia(SyntaxFactory.TriviaList(remainingLeadingTrivia.Take(trailingTriviaTakeUntil)));

28using static SyntaxFactory;

10using static SyntaxFactory;

27using static SyntaxFactory;

25using static SyntaxFactory;

22using static SyntaxFactory;

19using static SyntaxFactory;

31using static SyntaxFactory;

22using static SyntaxFactory;

20using static SyntaxFactory;

23=> SyntaxFactory.Token(kind); 28return SyntaxFactory.AssignmentExpression(assignmentOpKind, left, syntaxToken, right); 42=> SyntaxFactory.PostfixUnaryExpression(kind, operand); 45=> SyntaxFactory.PrefixUnaryExpression(kind, operand);

24using static SyntaxFactory;

35=> variable.WithInitializer(SyntaxFactory.EqualsValueClause(value));

22return SyntaxFactory.ThrowExpression(throwStatement.ThrowKeyword, throwStatement.Expression); 38.WithWhenTrue(conditional.WhenTrue.WithAppendedTrailingTrivia(SyntaxFactory.ElasticCarriageReturnLineFeed));

21using static SyntaxFactory;

59SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression).WithTriviaFrom(defaultExpression)),

21using static SyntaxFactory;

18using static SyntaxFactory;

25using static SyntaxFactory;

27using static SyntaxFactory;

55var implicitType = SyntaxFactory.IdentifierName("var")

29using static SyntaxFactory;

16=> SyntaxFactory.PrefixUnaryExpression(

54var newStartToken = SyntaxFactory.Token(oldStartToken.LeadingTrivia, SyntaxKind.InterpolatedVerbatimStringStartToken,

22using static SyntaxFactory;

15using static SyntaxFactory;

17using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

32using static SyntaxFactory;

54=> SyntaxFactory.ElementBindingExpression(argumentList);

21using static SyntaxFactory; 47=> SyntaxFactory.Whitespace(text);

12using static SyntaxFactory;

26using static SyntaxFactory;

23using static SyntaxFactory;

23using static SyntaxFactory;

58var updatedCondition = SyntaxFactory.IsPatternExpression( 59isExpression.Left, SyntaxFactory.DeclarationPattern( 61SyntaxFactory.SingleVariableDesignation( 66.SelectMany(t => ImmutableArray.Create(SyntaxFactory.Space, t, SyntaxFactory.ElasticCarriageReturnLineFeed))

33using static SyntaxFactory;

24using static SyntaxFactory;

27using static SyntaxFactory;

20using static SyntaxFactory;

21using static SyntaxFactory;

23using static SyntaxFactory;

17return SyntaxFactory.Argument(expression); 24=> SyntaxFactory.ArgumentList([.. arguments.Select(GenerateArgument)]); 27=> SyntaxFactory.BracketedArgumentList([.. arguments.Select(GenerateArgument)]);

16using static SyntaxFactory;

19using static SyntaxFactory;

18using static SyntaxFactory;

23using static SyntaxFactory;

26using static SyntaxFactory;

17using static SyntaxFactory;

19using static SyntaxFactory;

20using static SyntaxFactory;

20using static SyntaxFactory;

19using static SyntaxFactory;

22using static SyntaxFactory;

20using static SyntaxFactory;

20using static SyntaxFactory;

19using static SyntaxFactory;

15using static SyntaxFactory;

22using static SyntaxFactory;

19return SyntaxFactory.Block(

14using static SyntaxFactory;

14using static SyntaxFactory;

14using static SyntaxFactory;

20using static SyntaxFactory;

12using static SyntaxFactory;

18using static SyntaxFactory;

33var clauses = SyntaxFactory.List(allClauses.Take(allClauses.Count() - 1).Cast<QueryClauseSyntax>());

28: SyntaxFactory.SeparatedList<T>(newList.GetWithSeparators().Add(SyntaxFactory.Token(separator)));

39return SyntaxFactory.Identifier(escaped); 46var token = SyntaxFactory.Identifier( 58=> SyntaxFactory.IdentifierName(identifier.ToIdentifierToken());

101var leadingTrivia = prependNewLineIfMissing ? token.LeadingTrivia.Insert(0, SyntaxFactory.ElasticCarriageReturnLineFeed) : token.LeadingTrivia; 102var trailingTrivia = appendNewLineIfMissing ? token.TrailingTrivia.Insert(0, SyntaxFactory.ElasticCarriageReturnLineFeed) : token.TrailingTrivia; 103return SyntaxFactory.Token(leadingTrivia, kind, trailingTrivia).WithAdditionalAnnotations(Formatter.Annotation);

103=> SyntaxFactory.AreEquivalent(a, b, kind => kind == SyntaxKind.NullableDirectiveTrivia);

23using static SyntaxFactory;

35=> SyntaxFactory.CarriageReturnLineFeed; 38=> SyntaxFactory.ElasticCarriageReturnLineFeed; 47=> SyntaxFactory.EndOfLine(text); 50=> SyntaxFactory.Comment("//" + text); 54return SyntaxFactory.LocalDeclarationStatement( 67.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 74=> SyntaxFactory.EqualsValueClause(operatorToken, (ExpressionSyntax)value); 78return SyntaxFactory.VariableDeclaration( 79type == null ? SyntaxFactory.IdentifierName("var") : (TypeSyntax)type, 80[SyntaxFactory.VariableDeclarator( 82expression == null ? null : SyntaxFactory.EqualsValueClause((ExpressionSyntax)expression))]); 86=> SyntaxFactory.Identifier(identifier); 89=> SyntaxFactory.ConditionalAccessExpression((ExpressionSyntax)expression, (ExpressionSyntax)whenNotNull); 92=> SyntaxFactory.MemberBindingExpression((SimpleNameSyntax)name); 95=> SyntaxFactory.RefExpression((ExpressionSyntax)expression); 109=> SyntaxFactory.YieldStatement(SyntaxKind.YieldReturnStatement, (ExpressionSyntax)expression); 118=> SyntaxFactory.InterpolatedStringExpression(startToken, [.. content.Cast<InterpolatedStringContentSyntax>()], endToken); 121=> SyntaxFactory.InterpolatedStringText(textToken); 124=> SyntaxFactory.Token( 131=> SyntaxFactory.Interpolation((ExpressionSyntax)syntaxNode); 134=> SyntaxFactory.InterpolationAlignmentClause(CommaToken, (ExpressionSyntax)alignment); 137=> SyntaxFactory.InterpolationFormatClause( 139SyntaxFactory.Token(default, SyntaxKind.InterpolatedStringTextToken, format, format, default)); 142=> SyntaxFactory.TypeParameterList([.. typeParameterNames.Select(SyntaxFactory.TypeParameter)]); 187return SyntaxFactory.TokenList(result); 210=> SyntaxFactory.IsPatternExpression( 216=> SyntaxFactory.BinaryPattern(SyntaxKind.AndPattern, (PatternSyntax)ParenthesizeNonSimple(left), (PatternSyntax)ParenthesizeNonSimple(right)); 219=> SyntaxFactory.ConstantPattern((ExpressionSyntax)expression); 222=> SyntaxFactory.DeclarationPattern( 224SyntaxFactory.SingleVariableDesignation(name.ToIdentifierToken())); 227=> SyntaxFactory.RelationalPattern(LessThanToken, (ExpressionSyntax)expression); 230=> SyntaxFactory.RelationalPattern(LessThanEqualsToken, (ExpressionSyntax)expression); 233=> SyntaxFactory.RelationalPattern(GreaterThanToken, (ExpressionSyntax)expression); 236=> SyntaxFactory.RelationalPattern(GreaterThanEqualsToken, (ExpressionSyntax)expression); 239=> SyntaxFactory.UnaryPattern(NotKeyword, (PatternSyntax)ParenthesizeNonSimple(pattern)); 242=> SyntaxFactory.BinaryPattern(SyntaxKind.OrPattern, (PatternSyntax)ParenthesizeNonSimple(left), (PatternSyntax)ParenthesizeNonSimple(right)); 248=> SyntaxFactory.TypePattern((TypeSyntax)type); 251=> SyntaxFactory.UnaryPattern(operatorToken, (PatternSyntax)ParenthesizeNonSimple(pattern)); 256=> SyntaxFactory.CastExpression((TypeSyntax)type, (ExpressionSyntax)ParenthesizeNonSimple(expression)).WithAdditionalAnnotations(Simplifier.Annotation); 259=> SyntaxFactory.DefaultExpression((TypeSyntax)type).WithAdditionalAnnotations(Simplifier.Annotation); 270return SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression); 276return SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression); 288return SyntaxFactory.LiteralExpression( 289SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal("0", 0)); 301RefKind.Ref => SyntaxFactory.RefType(type), 302RefKind.RefReadOnly => SyntaxFactory.RefType(RefKeyword, ReadOnlyKeyword, type), 312return SyntaxFactory.MemberAccessExpression( 343=> SyntaxFactory.BinaryExpression(syntaxKind, (ExpressionSyntax)ParenthesizeNonSimple(left), (ExpressionSyntax)ParenthesizeNonSimple(right)); 349=> SyntaxFactory.CastExpression((TypeSyntax)type, (ExpressionSyntax)ParenthesizeNonSimple(expression)).WithAdditionalAnnotations(Simplifier.Annotation);

26using static SyntaxFactory; 275.AddAccessorListAccessors(SyntaxFactory

49SyntaxFactory.VerbatimIdentifier( 85tokenWithLeadingWhitespace = token.WithLeadingTrivia(SyntaxFactory.ElasticMarker).WithAdditionalAnnotations(Formatter.Annotation);

31using static SyntaxFactory;

119var annotatedNewline = SyntaxFactory.EndOfLine(options.FormattingOptions.NewLine).WithAdditionalAnnotations(s_closingBraceNewlineAnnotation);

29using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

54? Create(argument.WithNameColon(SyntaxFactory.NameColon(SyntaxFactory.IdentifierName(name)))) 55: Create(((AttributeArgumentSyntax)_argument).WithNameColon(SyntaxFactory.NameColon(SyntaxFactory.IdentifierName(name))));

26using static SyntaxFactory;

301return SyntaxFactory.Parameter(name.ToIdentifierToken())

164var newLine = SyntaxFactory.EndOfLine(options.NewLine); 169var nullableDisableTrivia = SyntaxFactory.Trivia(SyntaxFactory.NullableDirectiveTrivia(DisableKeyword.WithPrependedLeadingTrivia(SyntaxFactory.ElasticSpace), isActive: true)); 180return root.ReplaceTrivia(leadingDirective.ParentTrivia, SyntaxFactory.ElasticMarker);

28using static SyntaxFactory; 417var newLabeledStatement = labeledStatement.ReplaceNode(newLocalDeclaration, SyntaxFactory.ParseStatement("")); 460return SyntaxFactory.ObjectCreationExpression(implicitCreation.NewKeyword, type, implicitCreation.ArgumentList, implicitCreation.Initializer); 478return SyntaxFactory.ArrayCreationExpression(arrayType, arrayInitializer);

29using static SyntaxFactory;

29using static SyntaxFactory; 389return SyntaxFactory.Subpattern(ExpressionColon(expression, Token(ColonToken)), pattern); 401=> SyntaxFactory.Subpattern(NameColon(name), pattern); 404=> SyntaxFactory.RecursivePattern(type: null, positionalPatternClause: null, PropertyPatternClause([.. subpatterns]), designation: null); 407=> SyntaxFactory.RecursivePattern(type, positionalPatternClause: null, PropertyPatternClause([subpattern]), designation);

192var type = SyntaxFactory.ParseTypeName(sourceText.ToString(subSpan));

14using static SyntaxFactory;

37return SyntaxFactory.ObjectCreationExpression( 42=> SyntaxFactory.ArgumentList( 48=> SyntaxFactory.SeparatedList<ArgumentSyntax>(CreateArguments(OmitTrailingComma(initializers.GetWithSeparators()))); 77=> SyntaxFactory.Argument(decl.Expression);

18using static SyntaxFactory;

28using static SyntaxFactory;

68var newStartToken = SyntaxFactory.Token( 80=> SyntaxFactory.Token(

58=> SyntaxFactory.Token(

17using static SyntaxFactory;

11using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

20using static SyntaxFactory;

121return SyntaxFactory.ForEachStatement(

18using static SyntaxFactory;

22using static SyntaxFactory;

180=> SyntaxFactory.InvocationExpression( 181SyntaxFactory.MemberAccessExpression( 184SyntaxFactory.IdentifierName(MethodName))).WithAdditionalAnnotations(Formatter.Annotation);

234selectExpression: SyntaxFactory.IdentifierName(forEachInfo.ForEachStatement.Identifier), 343return compilationUnit.AddUsings(SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("System.Linq")));

16using static SyntaxFactory;

42=> SyntaxFactory.ExpressionStatement( 43SyntaxFactory.AssignmentExpression(

47=> SyntaxFactory.ExpressionStatement( 48SyntaxFactory.InvocationExpression( 49SyntaxFactory.MemberAccessExpression( 52SyntaxFactory.IdentifierName(nameof(List<>.AddRange))), 53SyntaxFactory.ArgumentList([SyntaxFactory.Argument(queryOrLinqInvocationExpression)])));

38SyntaxFactory.ReturnStatement(queryOrLinqInvocationExpression).WithAdditionalAnnotations(Formatter.Annotation));

28using static SyntaxFactory;

34using static SyntaxFactory;

15using static SyntaxFactory;

22using static SyntaxFactory;

26using static SyntaxFactory;

29using static SyntaxFactory;

27=> SyntaxFactory.ParseExpression(text);

26using static SyntaxFactory;

19using static SyntaxFactory;

45var newName = SyntaxFactory.IdentifierName(name).WithTriviaFrom(nameColon.Name);

106var memberDeclaration = SyntaxFactory.ParseMemberDeclaration(fix, options: method.SyntaxTree.Options);

141var comment = SyntaxFactory.TriviaList( 142SyntaxFactory.Comment($"/* {errorMessage} */"), 143SyntaxFactory.CarriageReturnLineFeed);

50var name = SyntaxFactory.ParseName(text, consumeFullText: false); 52var parameterList = SyntaxFactory.ParseParameterList(text, lengthOfParsedText, consumeFullText: false); 72var token = SyntaxFactory.ParseToken(text, lengthOfParsedText);

55var expression = SyntaxFactory.ParseExpression(expressionValue);

76var regionTrivia = SyntaxFactory.RegionDirectiveTrivia(true) 77.WithTrailingTrivia(new[] { SyntaxFactory.Space, SyntaxFactory.PreprocessingMessage(assemblyInfo) }); 84SyntaxFactory.Trivia(regionTrivia), 85SyntaxFactory.CarriageReturnLineFeed, 86SyntaxFactory.Comment("// " + assemblyPath), 87SyntaxFactory.CarriageReturnLineFeed, 88SyntaxFactory.Comment($"// Decompiled with ICSharpCode.Decompiler {decompilerVersion.FileVersion}"), 89SyntaxFactory.CarriageReturnLineFeed, 90SyntaxFactory.Trivia(SyntaxFactory.EndRegionDirectiveTrivia(true)), 91SyntaxFactory.CarriageReturnLineFeed, 92SyntaxFactory.CarriageReturnLineFeed

212if (SyntaxFactory.AreEquivalent(exceptionType, catchClause.Declaration.Type.ConvertToSingleLine()))

61newLeadingTrivia.Add(SyntaxFactory.Comment("//")); 62newLeadingTrivia.Add(SyntaxFactory.ElasticCarriageReturnLineFeed); 91yield return SyntaxFactory.Comment("// " + line); 95yield return SyntaxFactory.Comment("//"); 98yield return SyntaxFactory.ElasticCarriageReturnLineFeed;

354if (SyntaxFactory.AreEquivalent(left, right)) 567=> SyntaxFactory.CompilationUnit(); 904=> SyntaxFactory.AreEquivalent(oldToken, newToken); 1460=> SyntaxFactory.AreEquivalent; 2662return SyntaxFactory.AreEquivalent(oldTryStatement.Finally, newTryStatement.Finally) 2663&& SyntaxFactory.AreEquivalent(oldTryStatement.Catches, newTryStatement.Catches); 2667return SyntaxFactory.AreEquivalent(oldNode, newNode); 2738if (!SyntaxFactory.AreEquivalent(oldContainingStatementPart, newContainingStatementPart) && 2921return SyntaxFactory.AreEquivalent(oldCasePatternLabel.Pattern, newCasePatternLabel.Pattern) && 2926return SyntaxFactory.AreEquivalent(oldLabel, newLabel); 3084if (!SyntaxFactory.AreEquivalent(oldVariables[i], newVariables[i]))

65=> SyntaxFactory.AreEquivalent(node, ((CSharpLambdaBody)other).Node);

733if (!SyntaxFactory.AreEquivalent(leftBody, rightBody, null)) 761return SyntaxFactory.AreEquivalent(left, right, ignoreChildFunction); 766return SyntaxFactory.AreEquivalent(left.Labels, right.Labels, null) 767&& SyntaxFactory.AreEquivalent(left.Statements, right.Statements, ignoreChildNode: HasLabel); 1529if (weightedDistance == ExactMatchDist && !SyntaxFactory.AreEquivalent(oldNode, newNode)) 1542if (SyntaxFactory.AreEquivalent(oldNode, newNode)) 1565Debug.Assert(!SyntaxFactory.AreEquivalent(leftToken, rightToken) || distance == ExactMatchDist); 1573Debug.Assert(!SyntaxFactory.AreEquivalent(leftNode, rightNode) || distance == ExactMatchDist); 1671=> SyntaxFactory.AreEquivalent(oldElement, newElement); 1679=> SyntaxFactory.AreEquivalent(oldElement, newElement);

14var triviaList = SyntaxFactory.TriviaList( 15SyntaxFactory.Comment($"/*{commentContents}*/"), 16SyntaxFactory.ElasticSpace);

29using static SyntaxFactory;

28var info = this.SemanticModel.GetSpeculativeTypeInfo(SelectionResult.FinalSpan.Start, SyntaxFactory.ParseName(symbol.Name), SpeculativeBindingOption.BindAsExpression);

176=> SyntaxFactory.ParseTypeName(name); 191methodDefinition = methodDefinition.WithPrependedLeadingTrivia(SyntaxFactory.EndOfLine(newLine)); 196methodDefinition = methodDefinition.WithPrependedLeadingTrivia(SyntaxFactory.EndOfLine(newLine));

100return SyntaxFactory.EmptyStatement(SyntaxFactory.Token([.. triviaList], SyntaxKind.SemicolonToken, [SyntaxFactory.ElasticMarker])); 114SyntaxFactory.LocalDeclarationStatement( 116SyntaxFactory.VariableDeclaration( 287return SyntaxFactory.Block(statements); 337_statementsOrMemberOrAccessorToInsert.Select(s => global ? SyntaxFactory.GlobalStatement((StatementSyntax)s) : (MemberDeclarationSyntax)s));

33using static SyntaxFactory; 279=> useBlock ? SyntaxFactory.Block(statement) : statement; 320return [.. AnalyzerResult.MethodTypeParametersInDeclaration.Select(m => SyntaxFactory.ParseTypeName(m.Name))];

40return SyntaxFactory.Identifier(nameGenerator.CreateUniqueMethodName(containingScope, methodName)); 96? SyntaxFactory.ArrayCreationExpression((ArrayTypeSyntax)returnType.GenerateTypeSyntax(), initializerExpression) 100? [SyntaxFactory.ReturnStatement(WrapInCheckedExpressionIfNeeded(expression))] 101: [SyntaxFactory.ExpressionStatement(WrapInCheckedExpressionIfNeeded(expression))]; 112return SyntaxFactory.CheckedExpression(kind, expression);

17using static SyntaxFactory;

91return location == TriviaLocation.AfterBeginningOfSpan ? [SyntaxFactory.ElasticMarker] : []; 99return location == TriviaLocation.AfterBeginningOfSpan ? [SyntaxFactory.ElasticMarker] : [];

48var qualifiedName = SyntaxFactory.QualifiedName(SyntaxFactory.ParseName(containerName), newName)

27wrappedStatements = [SyntaxFactory.CheckedStatement(SyntaxKind.UncheckedStatement, 28SyntaxFactory.Block(statements.OfType<StatementSyntax>()))];

21using static SyntaxFactory;

733var usingDirective = SyntaxFactory.UsingDirective(SyntaxFactory.ParseName(includeUsingsOrImports));

16using static SyntaxFactory;

31using static SyntaxFactory;

17using static SyntaxFactory;

25using static SyntaxFactory;

12using static SyntaxFactory;

21using static SyntaxFactory;

25using static SyntaxFactory;

33var newLocalName = SyntaxFactory.IdentifierName(newLocalNameToken); 35var letClause = SyntaxFactory.LetClause(

22using static SyntaxFactory;

26using static SyntaxFactory;

27=> argument.WithNameColon(SyntaxFactory.NameColon(argumentName.ToIdentifierName()));

33=> SyntaxFactory.ParseExpression(text);

25using static SyntaxFactory;

22=> name.ReplaceToken(name.LocalName, SyntaxFactory.Identifier("param")); 30.AddAttributes(SyntaxFactory.XmlNameAttribute("value"));

22=> name.ReplaceToken(name.LocalName, SyntaxFactory.Identifier("returns"));

27using static SyntaxFactory;

23using static SyntaxFactory;

26using static SyntaxFactory;

66return SyntaxFactory.PropertyDeclaration( 72accessorList: SyntaxFactory.AccessorList([.. (IEnumerable<AccessorDeclarationSyntax>)accessors.Where(a => a is not null)]));

29using static SyntaxFactory;

106typeDeclaration.CloseBraceToken.WithPrependedLeadingTrivia(SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, indentationString)));

43=> SyntaxFactory.ClassDeclaration(name);

37return SyntaxFactory.DoStatement( 38SyntaxFactory.Block(),

59var elseClause = SyntaxFactory.ElseClause(SyntaxFactory.Block());

39=> SyntaxFactory.EnumDeclaration(name);

28using static SyntaxFactory;

38=> SyntaxFactory.InterfaceDeclaration(name);

60var updatedReturnStatement = returnStatement.WithPrependedLeadingTrivia(SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, indentationString));

29=> SyntaxFactory.AccessorDeclaration(SyntaxKind.InitAccessorDeclaration).WithSemicolonToken(SemicolonToken);

62return SyntaxFactory.AccessorDeclaration(SyntaxKind.InitAccessorDeclaration).WithSemicolonToken(SemicolonToken);

55var updatedBlock = block.WithCloseBraceToken(block.CloseBraceToken.WithPrependedLeadingTrivia(SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, indentationString)));

40=> SyntaxFactory.StructDeclaration(name);

27=> Task.FromResult(new TextChange(TextSpan.FromBounds(position, position), SyntaxFactory.UnsafeStatement().ToFullString()));

31=> SyntaxFactory.PredefinedType(VoidKeyword);

69=> SyntaxFactory.Identifier(newName).WithTriviaFrom(nameToken);

18using static SyntaxFactory;

17using static SyntaxFactory;

50var firstToken = SyntaxFactory.Token( 55trailing: [SyntaxFactory.ElasticSpace]); 57var secondToken = SyntaxFactory.Token( 64var leftExpression = SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, firstToken); 65var rightExpression = SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, secondToken); 67return SyntaxFactory.BinaryExpression(

26protected readonly SyntaxToken PlusNewLineToken = SyntaxFactory.Token( 29[SyntaxFactory.EndOfLine( 116var newRightExpression = rightExpression.WithLeadingTrivia(SyntaxFactory.ElasticWhitespace(indentString));

255if (!SyntaxFactory.AreEquivalent(node.Left, _assignmentTargetOpt))

148if (SyntaxFactory.AreEquivalent(expression, invocationExpression.Expression, topLevel: false)) 153SyntaxFactory.AreEquivalent(expression, memberAccessExpression.Expression, topLevel: false))

23using static SyntaxFactory;

27using static SyntaxFactory;

22using static SyntaxFactory;

16using static SyntaxFactory;

21using static SyntaxFactory;

19using static SyntaxFactory;

12using static SyntaxFactory;

200if (!SyntaxFactory.AreEquivalent(isExpression.Left.WalkDownParentheses(), castExpression.Expression.WalkDownParentheses(), topLevel: false) || 201!SyntaxFactory.AreEquivalent(isExpression.Right.WalkDownParentheses(), castExpression.Type, topLevel: false))

39SyntaxFactory.NameEquals( 40SyntaxFactory.IdentifierName(name)));

46return embeddedStatement is null ? currentStatement : currentStatement.ReplaceNode(embeddedStatement, SyntaxFactory.Block(embeddedStatement));

22using static SyntaxFactory;

59var newBody = SyntaxFactory.Block(statements.Add(exprOrStatement).Cast<StatementSyntax>()); 79var newBody = SyntaxFactory.Block(statements.Add(generator.ReturnStatement(exprOrStatement)).Cast<StatementSyntax>());

22using static SyntaxFactory;

18using static SyntaxFactory;

98SyntaxFactory.ParseTypeName("Task")

24using static SyntaxFactory;

412return SyntaxFactory.LiteralExpression(

25using static SyntaxFactory;

75var newDocCommentNode = SyntaxFactory.DocumentationComment(SyntaxFactory.XmlParamElement(parameterName)); 81return elementNode.WithTrailingTrivia(SyntaxFactory.ParseTrailingTrivia(Environment.NewLine)); 85SyntaxFactory.ParseLeadingTrivia(Environment.NewLine)

41=> SyntaxFactory.ParseLeadingTrivia(docCommentText);

103clause.Constraints.Insert(0, SyntaxFactory.ClassOrStructConstraint(

64identifierToken = SyntaxFactory.Token( 90identifierToken = SyntaxFactory.Token(

46var typeToInsert = SyntaxFactory.ParseTypeName(diagnostic.Properties[CSharpHiddenExplicitCastDiagnosticAnalyzer.Type]!);

112var methodDecl = SyntaxFactory.DestructorDeclaration(classType.Name).AddBodyStatements(disposeStatement);

29using static SyntaxFactory;

24using static SyntaxFactory;

75var yieldStatement = SyntaxFactory.YieldStatement(

22using static SyntaxFactory;

23using static SyntaxFactory;

64newReturnType = SyntaxFactory.PredefinedType(VoidKeyword).WithTriviaFrom(returnTypeSyntax);

31using static SyntaxFactory; 379var newFirstMember = firstMember.WithLeadingTrivia(firstMemberTrivia.Insert(0, SyntaxFactory.CarriageReturnLineFeed));

77.WithTrailingTrivia(SyntaxFactory.Space); 96replacementMap[colonToken] = colonToken.WithLeadingTrivia(thisBaseKeyword.LeadingTrivia).WithTrailingTrivia(SyntaxFactory.Space);

23using static SyntaxFactory;

105var fixedDeclaration = SyntaxFactory.NullableType(declarationTypeToFix.WithoutTrivia()).WithTriviaFrom(declarationTypeToFix);

16using static SyntaxFactory;

38var block = SyntaxFactory.Block(statement);

52return SyntaxFactory.BinaryExpression( 65SyntaxFactory.TypePattern(((DeclarationPatternSyntax)current).Type)

85editor.ReplaceNode(statement, SyntaxFactory.Block());

21using static SyntaxFactory;

19using static SyntaxFactory;

22using static SyntaxFactory;

59var remainingLeadingTrivia = SyntaxFactory.TriviaList(leadingTrivia.Skip(skippedTriviaIndex + 1)); 65.WithLeadingTrivia(SyntaxFactory.TriviaList(remainingLeadingTrivia.Skip(trailingTriviaTakeUntil))) 69.WithTrailingTrivia(SyntaxFactory.TriviaList(remainingLeadingTrivia.Take(trailingTriviaTakeUntil)));

28using static SyntaxFactory;

10using static SyntaxFactory;

27using static SyntaxFactory;

25using static SyntaxFactory;

22using static SyntaxFactory;

19using static SyntaxFactory;

31using static SyntaxFactory;

22using static SyntaxFactory;

20using static SyntaxFactory;

23=> SyntaxFactory.Token(kind); 28return SyntaxFactory.AssignmentExpression(assignmentOpKind, left, syntaxToken, right); 42=> SyntaxFactory.PostfixUnaryExpression(kind, operand); 45=> SyntaxFactory.PrefixUnaryExpression(kind, operand);

24using static SyntaxFactory;

35=> variable.WithInitializer(SyntaxFactory.EqualsValueClause(value));

22return SyntaxFactory.ThrowExpression(throwStatement.ThrowKeyword, throwStatement.Expression); 38.WithWhenTrue(conditional.WhenTrue.WithAppendedTrailingTrivia(SyntaxFactory.ElasticCarriageReturnLineFeed));

21using static SyntaxFactory;

59SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression).WithTriviaFrom(defaultExpression)),

21using static SyntaxFactory;

18using static SyntaxFactory;

25using static SyntaxFactory;

27using static SyntaxFactory;

55var implicitType = SyntaxFactory.IdentifierName("var")

29using static SyntaxFactory;

16=> SyntaxFactory.PrefixUnaryExpression(

54var newStartToken = SyntaxFactory.Token(oldStartToken.LeadingTrivia, SyntaxKind.InterpolatedVerbatimStringStartToken,

22using static SyntaxFactory;

15using static SyntaxFactory;

17using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

32using static SyntaxFactory;

54=> SyntaxFactory.ElementBindingExpression(argumentList);

21using static SyntaxFactory; 47=> SyntaxFactory.Whitespace(text);

12using static SyntaxFactory;

26using static SyntaxFactory;

23using static SyntaxFactory;

23using static SyntaxFactory;

58var updatedCondition = SyntaxFactory.IsPatternExpression( 59isExpression.Left, SyntaxFactory.DeclarationPattern( 61SyntaxFactory.SingleVariableDesignation( 66.SelectMany(t => ImmutableArray.Create(SyntaxFactory.Space, t, SyntaxFactory.ElasticCarriageReturnLineFeed))

33using static SyntaxFactory;

24using static SyntaxFactory;

27using static SyntaxFactory;

20using static SyntaxFactory;

21using static SyntaxFactory;

23using static SyntaxFactory;

245if (!SyntaxFactory.AreEquivalent(sourceIdentifier, selectorIdentifier)) 363=> DescendantTokensIgnoringLambdaBodies(oldNode).SequenceEqual(DescendantTokensIgnoringLambdaBodies(newNode), SyntaxFactory.AreEquivalent);

28return SyntaxFactory.CreateTokenParser(text,

17using static SyntaxFactory;

175if (SyntaxFactory.AreEquivalent(castExpression.Type, type) && 220var newLocalName = SyntaxFactory.Identifier(localName) 222var isPattern = SyntaxFactory.IsPatternExpression( 224SyntaxFactory.DeclarationPattern((TypeSyntax)isExpression.Right.WithTrailingTrivia(SyntaxFactory.Space), 225SyntaxFactory.SingleVariableDesignation(newLocalName))).WithTriviaFrom(isExpression); 230var localReference = SyntaxFactory.IdentifierName(localName);

30var modifiers = type.Modifiers.Replace(publicKeyword, SyntaxFactory.Token(SyntaxKind.InternalKeyword));

45return SyntaxFactory.Token(SyntaxKind.ConstKeyword);

58if (model.GetSpeculativeSymbolInfo(docOffset, SyntaxFactory.IdentifierName(baseName), SpeculativeBindingOption.BindAsExpression).Symbol is null) 65if (model.GetSpeculativeSymbolInfo(docOffset, SyntaxFactory.IdentifierName($"{baseName}{i}"), SpeculativeBindingOption.BindAsExpression).Symbol is null) 99editor.ReplaceNode(syntax, SyntaxFactory.SizeOfExpression((TypeSyntax)editor.Generator.TypeExpression(operation.TargetMethod.TypeArguments[0]))); 105editor.ReplaceNode(syntax, SyntaxFactory.SizeOfExpression(GetTypeOfTypeSyntax((TypeOfExpressionSyntax)typeOf.Syntax))); 114SyntaxFactory.PrefixUnaryExpression(SyntaxKind.PointerIndirectionExpression, 154IdentifierNameSyntax nonNullPtrIdentifierNode = SyntaxFactory.IdentifierName(nonNullPtrIdentifier); 168var nullCheckAndDecl = (IsPatternExpressionSyntax)SyntaxFactory.ParseExpression($"x is not null and var {nonNullPtrIdentifier}"); 172SyntaxFactory.PrefixUnaryExpression(SyntaxKind.PointerIndirectionExpression, nonNullPtrIdentifierNode), 178SyntaxFactory.ParenthesizedExpression(SyntaxFactory.PrefixUnaryExpression(SyntaxKind.PointerIndirectionExpression,

141SyntaxFactory.AccessorDeclaration( 145SyntaxFactory.Token(SyntaxKind.InitKeyword), 161SyntaxFactory.AccessorList( 162SyntaxFactory.List( 190SyntaxFactory.IdentifierName(EscapedThisToken), 225invocations.Add((invocationOnThis, SyntaxFactory.ThisExpression())); 251SyntaxFactory.SingletonSeparatedList((ArgumentSyntax)generator.Argument(invocation.target)) 253return currentInvocation.WithArgumentList(newArgList).WithExpression(SyntaxFactory.IdentifierName(symbol.Name)); 273SyntaxFactory.ParameterList( 274SyntaxFactory.SingletonSeparatedList( 275SyntaxFactory.Parameter(EscapedThisToken) 276.WithType(SyntaxFactory.ParseTypeName(symbol.ContainingType.Name))) 293private static readonly SyntaxToken EscapedThisToken = SyntaxFactory.Identifier( 294SyntaxFactory.TriviaList(), 298SyntaxFactory.TriviaList()); 309return SyntaxFactory.IdentifierName(EscapedThisToken);

59var newArgumentList = SyntaxFactory.ArgumentList( 60SyntaxFactory.SeparatedList(allArguments));

17private static readonly IdentifierNameSyntax s_constantExpectedIdentifier = (IdentifierNameSyntax)SyntaxFactory.ParseName(ConstantExpected); 18private static readonly IdentifierNameSyntax s_constantExpectedAttributeIdentifier = (IdentifierNameSyntax)SyntaxFactory.ParseName(ConstantExpectedAttribute); 45private readonly IdentifierNameSyntax _constantExpectedMinIdentifier = (IdentifierNameSyntax)SyntaxFactory.ParseName(ConstantExpectedMin); 46private readonly IdentifierNameSyntax _constantExpectedMaxIdentifier = (IdentifierNameSyntax)SyntaxFactory.ParseName(ConstantExpectedMax);

18using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

48var hashData = SyntaxFactory.MemberAccessExpression( 50SyntaxFactory.ParseExpression(identifier), 51SyntaxFactory.IdentifierName(PreferHashDataOverComputeHashAnalyzer.HashDataMethodName)); 55arg = arg.WithNameColon(arg.NameColon.WithName(SyntaxFactory.IdentifierName("source"))); 58var args = SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(arg)); 59return SyntaxFactory.InvocationExpression(hashData, args); 72list[secondArgIndex] = secondArg.WithNameColon(SyntaxFactory.NameColon(SyntaxFactory.IdentifierName("start"))); 78list[thirdArgIndex] = thirdArg.WithNameColon(SyntaxFactory.NameColon(SyntaxFactory.IdentifierName("length"))); 81var asSpan = SyntaxFactory.MemberAccessExpression( 84SyntaxFactory.IdentifierName("AsSpan")); 85var spanArgs = SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(list)); 86var asSpanInvoked = SyntaxFactory.InvocationExpression(asSpan, spanArgs); 87var hashData = SyntaxFactory.MemberAccessExpression( 89SyntaxFactory.ParseExpression(identifier), 90SyntaxFactory.IdentifierName(PreferHashDataOverComputeHashAnalyzer.HashDataMethodName)); 91var arg = SyntaxFactory.Argument(asSpanInvoked); 94arg = arg.WithNameColon(SyntaxFactory.NameColon(SyntaxFactory.IdentifierName("source"))); 97var args = SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(arg)); 98return SyntaxFactory.InvocationExpression(hashData, args); 104var hashData = SyntaxFactory.MemberAccessExpression( 106SyntaxFactory.ParseExpression(identifier), 107SyntaxFactory.IdentifierName(PreferHashDataOverComputeHashAnalyzer.TryHashDataMethodName)); 108return SyntaxFactory.InvocationExpression(hashData, argumentList); 182parent = parent.InsertNodesBefore(parent.GetCurrentNode(target)!, statements.Select(SyntaxFactory.GlobalStatement));

10using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

139return SyntaxFactory.LiteralExpression( 141SyntaxFactory.Token(

19=> replacement.WithTrailingTrivia(SyntaxFactory.ElasticMarker); 25arguments[index] = argumentSyntax.WithExpression(SyntaxFactory.StackAllocArrayCreationExpression( 26SyntaxFactory.ArrayType( 28SyntaxFactory.SingletonList(SyntaxFactory.ArrayRankSpecifier(SyntaxFactory.SingletonSeparatedList((ExpressionSyntax)generator.LiteralExpression(1))))), 29SyntaxFactory.InitializerExpression(SyntaxKind.ArrayInitializerExpression, SyntaxFactory.SingletonSeparatedList(argumentSyntax.Expression))

81var argumentListNode = SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(arguments));

479var successPattern = SyntaxFactory.RecursivePattern() 481SyntaxFactory.PropertyPatternClause( 482SyntaxFactory.SeparatedList(new[] 484SyntaxFactory.Subpattern( 485SyntaxFactory.NameColon(SyntaxFactory.IdentifierName("Success")), 486SyntaxFactory.ConstantPattern( 487SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression))) 490SyntaxFactory.SingleVariableDesignation( 491SyntaxFactory.Identifier(variableName))) 494return SyntaxFactory.IsPatternExpression( 498.WithTrailingTrivia(SyntaxFactory.TriviaList())

11using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

21var newNameSyntax = SyntaxFactory.IdentifierName(newName); 32var newNameSyntax = SyntaxFactory.IdentifierName(newArgumentName);

39ExpressionSyntax memberAccess = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, GetComparatorExpression(binaryExpression), SyntaxFactory.IdentifierName(IsEmpty)); 42return SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression, memberAccess);

32var shebangTrivia = SyntaxFactory.ParseLeadingTrivia("#!/usr/bin/env dotnet" + eol);

36var typeArgumentsSyntax = invocationContext.TypeArguments.Select(t => SyntaxFactory.ParseTypeName(t.ToDisplayString())); 42SyntaxFactory.GenericName( 43SyntaxFactory.Identifier(invocationContext.Method.Name), 44SyntaxFactory.TypeArgumentList(SyntaxFactory.SeparatedList(typeArgumentsSyntax))); 62.WithArgumentList(SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(otherArgumentsSyntax)))

27return argumentSyntax.WithNameColon(SyntaxFactory.NameColon(volatileReadParameter.Name)); 42yield return argumentSyntax.WithNameColon(SyntaxFactory.NameColon(parameterName));

19=> SyntaxFactory.BinaryExpression(syntaxKind, (ExpressionSyntax)generator.Parenthesize(left), (ExpressionSyntax)generator.Parenthesize(right));

69? SyntaxFactory.ParenthesizedExpression(withoutTrivia) 70: SyntaxFactory.ParenthesizedExpression( 71SyntaxFactory.Token(SyntaxTriviaList.Empty, SyntaxKind.OpenParenToken, SyntaxTriviaList.Empty), 73SyntaxFactory.Token(SyntaxTriviaList.Empty, SyntaxKind.CloseParenToken, SyntaxTriviaList.Empty)); 83? SyntaxFactory.ParenthesizedPattern(withoutTrivia) 84: SyntaxFactory.ParenthesizedPattern( 85SyntaxFactory.Token(SyntaxTriviaList.Empty, SyntaxKind.OpenParenToken, SyntaxTriviaList.Empty), 87SyntaxFactory.Token(SyntaxTriviaList.Empty, SyntaxKind.CloseParenToken, SyntaxTriviaList.Empty));

28public override bool IsCompleteSubmission(SyntaxTree tree) => SyntaxFactory.IsCompleteSubmission(tree); 31=> SyntaxFactory.ParseSyntaxTree(text, parseOptions ?? DefaultParseOptions, cancellationToken: cancellationToken); 47var tree = SyntaxFactory.ParseSyntaxTree(script.SourceText, script.Options.ParseOptions ?? DefaultParseOptions, script.Options.FilePath);

510var tokens = SyntaxFactory.ParseTokens(text2, initialTokenPosition: textSpan.Start); 539var token = SyntaxFactory.ParseToken(text);

284foreach (var token in SyntaxFactory.ParseTokens(text: trivia.ToFullString(), initialTokenPosition: trivia.SpanStart))

37SyntaxFactory.IdentifierName(SyntaxFactory.ParseToken("nameof")); 39internal override SyntaxTrivia ElasticMarker => SyntaxFactory.ElasticMarker; 45=> SyntaxFactory.Whitespace(text); 48=> SyntaxFactory.SeparatedList<TElement>(list); 55? SyntaxFactory.Token(default, SyntaxKind.InterpolatedVerbatimStringStartToken, InterpolatedVerbatimText, InterpolatedVerbatimText, default) 63=> SyntaxFactory.SeparatedList(nodes, separators); 69return SyntaxFactory.Trivia(structuredTriviaSyntax); 77var docTrivia = SyntaxFactory.DocumentationCommentTrivia( 79(SyntaxList<XmlNodeSyntax>)SyntaxFactory.List(nodes), 82docTrivia = docTrivia.WithLeadingTrivia(SyntaxFactory.DocumentationCommentExterior("/// ")) 85return docTrivia.WithTrailingTrivia(SyntaxFactory.EndOfLine(endOfLineString)); 92return SyntaxFactory.DocumentationCommentTrivia(documentationCommentTrivia.Kind(), (SyntaxList<XmlNodeSyntax>)SyntaxFactory.List(content), documentationCommentTrivia.EndOfComment); 103return SyntaxFactory.CompilationUnit() 152=> SyntaxFactory.UsingDirective((NameSyntax)name); 155=> SyntaxFactory.UsingDirective(SyntaxFactory.NameEquals(aliasIdentifierName), (NameSyntax)name); 159return SyntaxFactory.NamespaceDeclaration( 176return SyntaxFactory.FieldDeclaration( 179SyntaxFactory.VariableDeclaration( 181[SyntaxFactory.VariableDeclarator( 184initializer != null ? SyntaxFactory.EqualsValueClause((ExpressionSyntax)initializer) : null)])); 195return SyntaxFactory.Parameter( 200initializer != null ? SyntaxFactory.EqualsValueClause((ExpressionSyntax)initializer) : null); 237return SyntaxFactory.MethodDeclaration( 240returnType: returnType != null ? (TypeSyntax)returnType : SyntaxFactory.PredefinedType(VoidKeyword), 266var returnTypeNode = returnType != null ? (TypeSyntax)returnType : SyntaxFactory.PredefinedType(VoidKeyword); 276return SyntaxFactory.ConversionOperatorDeclaration( 286return SyntaxFactory.OperatorDeclaration( 291operatorToken: SyntaxFactory.Token(GetOperatorSyntaxKind(operatorName)), 354? SyntaxFactory.ParameterList([.. parameters.Cast<ParameterSyntax>()]) 355: SyntaxFactory.ParameterList(); 366return SyntaxFactory.ConstructorDeclaration( 371baseConstructorArguments != null ? SyntaxFactory.ConstructorInitializer(SyntaxKind.BaseConstructorInitializer, SyntaxFactory.ArgumentList([.. baseConstructorArguments.Select(AsArgument)])) : null, 376=> SyntaxFactory.DestructorDeclaration(destructorMethod.ContainingType.Name).WithBody(SyntaxFactory.Block()); 415return SyntaxFactory.PropertyDeclaration( 421SyntaxFactory.AccessorList([.. accessors])); 433var accessor = SyntaxFactory 463var list = SyntaxFactory.List(accessorDeclarations.Cast<AccessorDeclarationSyntax>()); 465? SyntaxFactory.AccessorList(list) 507return SyntaxFactory.IndexerDeclaration( 513SyntaxFactory.AccessorList([.. accessors])); 519? SyntaxFactory.BracketedParameterList([.. parameters.Cast<ParameterSyntax>()]) 520: SyntaxFactory.BracketedParameterList(); 525var ad = SyntaxFactory.AccessorDeclaration( 543return SyntaxFactory.EventFieldDeclaration( 546SyntaxFactory.VariableDeclaration( 548[SyntaxFactory.VariableDeclarator(name)])); 575return SyntaxFactory.EventDeclaration( 581SyntaxFactory.AccessorList([.. accessors])); 613return WithInterfaceSpecifier(d, SyntaxFactory.ExplicitInterfaceSpecifier((NameSyntax)interfaceTypeName)); 706baseTypes.Add(SyntaxFactory.SimpleBaseType((TypeSyntax)baseType)); 709baseTypes.AddRange(interfaceTypes.Select(i => SyntaxFactory.SimpleBaseType((TypeSyntax)i))); 716var baseTypeList = baseTypes.Count > 0 ? SyntaxFactory.BaseList([.. baseTypes]) : null; 720? SyntaxFactory.RecordDeclaration(default, modifierList, RecordKeyword, nameToken, typeParameterList, null, baseTypeList, default, typeMembers) 721: SyntaxFactory.ClassDeclaration(default, modifierList, nameToken, typeParameterList, baseTypeList, default, typeMembers); 757var itypes = interfaceTypes?.Select(i => (BaseTypeSyntax)SyntaxFactory.SimpleBaseType((TypeSyntax)i)).ToList(); 763var baseTypeList = itypes?.Count > 0 ? SyntaxFactory.BaseList([.. itypes]) : null; 767? SyntaxFactory.RecordDeclaration(default, modifierList, RecordKeyword, nameToken, typeParameterList, null, baseTypeList, default, structMembers).WithClassOrStructKeyword(StructKeyword) 768: SyntaxFactory.StructDeclaration(default, modifierList, nameToken, typeParameterList, baseTypeList, default, structMembers); 778var itypes = interfaceTypes?.Select(i => (BaseTypeSyntax)SyntaxFactory.SimpleBaseType((TypeSyntax)i)).ToList(); 784return SyntaxFactory.InterfaceDeclaration( 789itypes != null ? SyntaxFactory.BaseList([.. itypes]) : null, 824var modifiersToken = SyntaxFactory.TokenList(abstractVirtualModifiers); 881return SyntaxFactory.EnumDeclaration( 885underlyingType != null ? SyntaxFactory.BaseList([SyntaxFactory.SimpleBaseType((TypeSyntax)underlyingType)]) : null, 891return SyntaxFactory.EnumMemberDeclaration( 894expression != null ? SyntaxFactory.EqualsValueClause((ExpressionSyntax)expression) : null); 930return SyntaxFactory.DelegateDeclaration( 933returnType != null ? (TypeSyntax)returnType : SyntaxFactory.PredefinedType(VoidKeyword), 941=> AsAttributeList(SyntaxFactory.Attribute((NameSyntax)name, AsAttributeArgumentList(attributeArguments))); 946? SyntaxFactory.AttributeArgument(SyntaxFactory.NameEquals(name.ToIdentifierName()), nameColon: null, (ExpressionSyntax)expression) 947: SyntaxFactory.AttributeArgument((ExpressionSyntax)expression); 951=> arguments != null ? SyntaxFactory.AttributeArgumentList([.. arguments.Select(AsAttributeArgument)]) : null; 957return SyntaxFactory.AttributeArgument(expr); 962return SyntaxFactory.AttributeArgument(null, arg.NameColon, arg.Expression); 973return node.WithLeadingTrivia(SyntaxFactory.ElasticMarker) 974.WithTrailingTrivia(SyntaxFactory.ElasticMarker); 989return node is AttributeSyntax attr ? SyntaxFactory.AttributeList([attr]) : (AttributeListSyntax)node; 1083.Select(list => list.WithTarget(SyntaxFactory.AttributeTargetSpecifier(ReturnKeyword))); 1088return [.. attributes.Select(list => list.WithTarget(SyntaxFactory.AttributeTargetSpecifier(AssemblyKeyword)))]; 1720list[i] = list[i].WithTrailingTrivia(SyntaxFactory.ElasticSpace); 1733=> SyntaxFactory.TypeParameter(name); 1737return SyntaxFactory.TypeParameter( 1745SyntaxFactory.Identifier(typeParameter.Name)); 1751? SyntaxFactory.TypeParameterList([.. typeParameterNodes.Cast<TypeParameterSyntax>()]) 1792method.ParameterList.GetTrailingTrivia().Add(SyntaxFactory.ElasticMarker).AddRange(method.ConstraintClauses.Last().GetTrailingTrivia()))); 1811=> SyntaxFactory.ExplicitInterfaceSpecifier(explicitInterfaceImplementations[0].ContainingType.GenerateNameSyntax()); 1826return method.AddConstraintClauses(SyntaxFactory.TypeParameterConstraintClause( 1827typeParameterName).AddConstraints(SyntaxFactory.DefaultConstraint())); 1838? SyntaxFactory.SeparatedList<TypeParameterConstraintSyntax>(types.Select(t => SyntaxFactory.TypeConstraint((TypeSyntax)t))) 1843constraints = constraints.Add(SyntaxFactory.ConstructorConstraint()); 1851constraints = constraints.Insert(0, SyntaxFactory.ClassOrStructConstraint(isReferenceType ? SyntaxKind.ClassConstraint : SyntaxKind.StructConstraint)); 1855constraints = constraints.Insert(0, SyntaxFactory.TypeConstraint(SyntaxFactory.IdentifierName("unmanaged"))); 1864return clauses.Add(SyntaxFactory.TypeParameterConstraintClause(typeParameterName.ToIdentifierName(), constraints)); 2305? SyntaxFactory.BracketedParameterList() 2306: SyntaxFactory.ParameterList(); 2361return SyntaxFactory.Token(token.Kind()).WithTriviaFrom(rewrittenToken); 2399return SyntaxFactory.ParenthesizedLambdaExpression(AsParameterList(parameters), lambda.Body) 2531return WithEqualsValue(declaration, SyntaxFactory.EqualsValueClause(expr)); 2682currentList = SyntaxFactory.AccessorList(); 2714=> SyntaxFactory.AccessorList([.. nodes.Select(n => AsAccessor(n, parentKind)).WhereNotNull()]); 2822return WithBaseList(declaration, baseList.WithTypes(baseList.Types.Insert(0, SyntaxFactory.SimpleBaseType((TypeSyntax)baseType)))); 2826return AddBaseList(declaration, SyntaxFactory.BaseList([SyntaxFactory.SimpleBaseType((TypeSyntax)baseType)])); 2836return WithBaseList(declaration, baseList.WithTypes(baseList.Types.Insert(baseList.Types.Count, SyntaxFactory.SimpleBaseType((TypeSyntax)interfaceType)))); 2840return AddBaseList(declaration, SyntaxFactory.BaseList([SyntaxFactory.SimpleBaseType((TypeSyntax)interfaceType)])); 2950return SyntaxFactory.AreEquivalent(fd1.Modifiers, fd2.Modifiers) 2951&& SyntaxFactory.AreEquivalent(fd1.AttributeLists, fd2.AttributeLists); 2956return SyntaxFactory.AreEquivalent(efd1.Modifiers, efd2.Modifiers) 2957&& SyntaxFactory.AreEquivalent(efd1.AttributeLists, efd2.AttributeLists); 2962return SyntaxFactory.AreEquivalent(ld1.Modifiers, ld2.Modifiers); 2971return SyntaxFactory.AreEquivalent(vd1.Type, vd2.Type) && AreSimilarExceptForSubDeclarations(vd1.Parent, vd2.Parent); 2990newNodes.Add(this.WithSubDeclarationsRemoved(multiPartDeclaration, index, count - index).WithTrailingTrivia(SyntaxFactory.ElasticSpace)); 2998newNodes.Add(this.WithSubDeclarationsRemoved(multiPartDeclaration, 0, index + 1).WithLeadingTrivia(SyntaxFactory.ElasticSpace)); 3015newDeclarations = newDeclarations.Select(declaration => declaration is StatementSyntax statement ? SyntaxFactory.GlobalStatement(statement) : declaration); 3054newDeclarations = newDeclarations.Select(declaration => declaration is StatementSyntax statement ? SyntaxFactory.GlobalStatement(statement) : declaration); 3093this.WithSubDeclarationsRemoved(multiPartDeclaration, index, count - index).WithTrailingTrivia(SyntaxFactory.ElasticSpace) 3096newNodes.Add(this.WithSubDeclarationsRemoved(multiPartDeclaration, 0, index).WithLeadingTrivia(SyntaxFactory.ElasticSpace)); 3227=> SyntaxFactory.AssignmentExpression(SyntaxKind.AddAssignmentExpression, (ExpressionSyntax)@event, (ExpressionSyntax)ParenthesizeNonSimple(handler)); 3230=> SyntaxFactory.AssignmentExpression(SyntaxKind.SubtractAssignmentExpression, (ExpressionSyntax)@event, (ExpressionSyntax)ParenthesizeNonSimple(handler)); 3233=> SyntaxFactory.AwaitExpression((ExpressionSyntax)expression); 3239=> SyntaxFactory.ReturnStatement((ExpressionSyntax?)expression); 3242=> SyntaxFactory.ThrowStatement((ExpressionSyntax?)expression); 3245=> SyntaxFactory.ThrowExpression((ExpressionSyntax)expression); 3251return SyntaxFactory.IfStatement( 3260return SyntaxFactory.IfStatement( 3263SyntaxFactory.ElseClause( 3273var block = existingBlock ?? SyntaxFactory.Block(); 3293return SyntaxFactory.ExpressionStatement(expression); 3300=> SyntaxFactory.ExpressionStatement((ExpressionSyntax)expression); 3309=> SyntaxFactory.ElementBindingExpression( 3310SyntaxFactory.BracketedArgumentList([.. arguments.Cast<ArgumentSyntax>()])); 3317var arrayType = SyntaxFactory.ArrayType((TypeSyntax)elementType, [SyntaxFactory.ArrayRankSpecifier([(ExpressionSyntax)size])]); 3318return SyntaxFactory.ArrayCreationExpression(arrayType); 3323var arrayType = SyntaxFactory.ArrayType((TypeSyntax)elementType, 3324[SyntaxFactory.ArrayRankSpecifier([SyntaxFactory.OmittedArraySizeExpression()])]); 3325var initializer = SyntaxFactory.InitializerExpression(SyntaxKind.ArrayInitializerExpression, AsExpressionList(elements)); 3326return SyntaxFactory.ArrayCreationExpression(arrayType, initializer); 3330=> SyntaxFactory.ObjectCreationExpression((TypeSyntax)type, CreateArgumentList(arguments), null); 3333=> SyntaxFactory.ObjectCreationExpression( 3335SyntaxFactory.ArgumentList(openParen, (SeparatedSyntaxList<ArgumentSyntax>)arguments, closeParen), 3339=> SyntaxFactory.ArgumentList(CreateArguments(arguments)); 3345=> argOrExpression as ArgumentSyntax ?? SyntaxFactory.Argument((ExpressionSyntax)argOrExpression); 3348=> SyntaxFactory.InvocationExpression(CSharpSyntaxGeneratorInternal.ParenthesizeLeft((ExpressionSyntax)expression), CreateArgumentList(arguments)); 3351=> SyntaxFactory.ElementAccessExpression(CSharpSyntaxGeneratorInternal.ParenthesizeLeft((ExpressionSyntax)expression), SyntaxFactory.BracketedArgumentList(CreateArguments(arguments))); 3354=> SyntaxFactory.Literal(text, value); 3360=> SyntaxFactory.BinaryExpression(SyntaxKind.IsExpression, (ExpressionSyntax)ParenthesizeNonSimple(expression), (TypeSyntax)type); 3363=> SyntaxFactory.TypeOfExpression((TypeSyntax)type); 3366=> SyntaxFactory.BinaryExpression(SyntaxKind.AsExpression, (ExpressionSyntax)ParenthesizeNonSimple(expression), (TypeSyntax)type); 3369=> SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, (ExpressionSyntax)left, (ExpressionSyntax)ParenthesizeNonSimple(right)); 3399=> SyntaxFactory.PrefixUnaryExpression(SyntaxKind.UnaryMinusExpression, (ExpressionSyntax)ParenthesizeNonSimple(expression)); 3420=> SyntaxFactory.PrefixUnaryExpression(SyntaxKind.BitwiseNotExpression, (ExpressionSyntax)ParenthesizeNonSimple(operand)); 3429=> SyntaxFactory.PrefixUnaryExpression( 3434=> SyntaxFactory.ConditionalExpression((ExpressionSyntax)ParenthesizeNonSimple(condition), (ExpressionSyntax)ParenthesizeNonSimple(whenTrue), (ExpressionSyntax)ParenthesizeNonSimple(whenFalse)); 3440=> SyntaxFactory.ThisExpression(); 3443=> SyntaxFactory.BaseExpression(); 3455=> SyntaxFactory.GenericName(identifier, 3456SyntaxFactory.TypeArgumentList([.. typeArguments.Cast<TypeSyntax>()])); 3464return SyntaxFactory.GenericName(sname.Identifier, SyntaxFactory.TypeArgumentList([.. typeArguments.Cast<TypeSyntax>()])); 3468return gname.WithTypeArgumentList(SyntaxFactory.TypeArgumentList([.. typeArguments.Cast<TypeSyntax>()])); 3489=> SyntaxFactory.QualifiedName((NameSyntax)left, (SimpleNameSyntax)right).WithAdditionalAnnotations(Simplifier.Annotation); 3492=> SyntaxFactory.AliasQualifiedName( 3493SyntaxFactory.IdentifierName(GlobalKeyword), 3500=> SyntaxFactory.PredefinedType(specialType switch 3522=> SyntaxFactory.ArrayType((TypeSyntax)type, [SyntaxFactory.ArrayRankSpecifier()]); 3532return SyntaxFactory.NullableType((TypeSyntax)type); 3537=> SyntaxFactory.TupleType([.. elements.Cast<TupleElementSyntax>()]); 3540=> SyntaxFactory.TupleElement((TypeSyntax)type, name?.ToIdentifierToken() ?? default); 3544return SyntaxFactory.Argument( 3545name == null ? null : SyntaxFactory.NameColon(name), 3555return SyntaxFactory.UsingStatement( 3563return SyntaxFactory.UsingStatement( 3571return SyntaxFactory.LockStatement( 3578return SyntaxFactory.TryStatement( 3581finallyStatements != null ? SyntaxFactory.FinallyClause(CreateBlock(finallyStatements)) : null); 3586return SyntaxFactory.CatchClause( 3587SyntaxFactory.CatchDeclaration((TypeSyntax)type, name.ToIdentifierToken()), 3593=> SyntaxFactory.WhileStatement((ExpressionSyntax)condition, CreateBlock(statements)); 3599return SyntaxFactory.SwitchStatement( 3605return SyntaxFactory.SwitchStatement( 3617=> SyntaxFactory.SwitchSection(AsSwitchLabels(expressions), AsStatementList(statements)); 3621return SyntaxFactory.SwitchSection( 3627=> SyntaxFactory.SwitchSection([SyntaxFactory.DefaultSwitchLabel()], AsStatementList(statements)); 3635labels = labels.AddRange(expressions.Select(e => SyntaxFactory.CaseSwitchLabel((ExpressionSyntax)e))); 3642=> SyntaxFactory.BreakStatement(); 3645=> SyntaxFactory.Block(statements.Cast<StatementSyntax>()); 3648=> SyntaxFactory.GlobalStatement((StatementSyntax)statement); 3655? SyntaxFactory.SimpleLambdaExpression(parameter, (CSharpSyntaxNode)expression) 3656: SyntaxFactory.ParenthesizedLambdaExpression(AsParameterList(parameters), (CSharpSyntaxNode)expression); 3675=> SyntaxFactory.IdentifierName(identifier); 3679return SyntaxFactory.AnonymousObjectMemberDeclarator( 3680SyntaxFactory.NameEquals((IdentifierNameSyntax)identifier), 3685=> SyntaxFactory.TupleExpression([.. arguments.Select(AsArgument)]); 3728=> SyntaxFactory.ParseExpression(stringToParse); 3731=> SyntaxFactory.ParseTypeName(stringToParse); 3741return SyntaxFactory.ExtensionBlockDeclaration(attributeLists: default, modifiers: default, ExtensionKeyword,

25var testFileTree = SyntaxFactory.ParseSyntaxTree(testFileSourceText, semanticModel.SyntaxTree.Options, cancellationToken: cancellationToken);

602var parsedIdentifier = SyntaxFactory.ParseName(currentNewIdentifier); 614? newToken.CopyAnnotationsTo(SyntaxFactory.VerbatimIdentifier(newToken.LeadingTrivia, currentNewIdentifier, valueText, newToken.TrailingTrivia)) 615: newToken.CopyAnnotationsTo(SyntaxFactory.Identifier(newToken.LeadingTrivia, SyntaxKind.IdentifierToken, currentNewIdentifier, valueText, newToken.TrailingTrivia)); 669var newTrivia = SyntaxFactory.Comment(replacedString); 691newToken = RenameInStringLiteral(oldToken, newToken, subSpansToReplace, SyntaxFactory.Literal); 696SyntaxFactory.Token(newToken.LeadingTrivia, SyntaxKind.InterpolatedStringTextToken, text, value, newToken.TrailingTrivia)); 704newToken = RenameInStringLiteral(oldToken, newToken, subSpansToReplace, SyntaxFactory.XmlTextLiteral); 708var newIdentifierToken = SyntaxFactory.Identifier(newToken.LeadingTrivia, _replacementText, newToken.TrailingTrivia); 1094var name = SyntaxFactory.ParseName(replacementText);

129SyntaxFactory.VerbatimIdentifier( 165tokenWithLeadingWhitespace = token.WithLeadingTrivia(SyntaxFactory.ElasticMarker).WithAdditionalAnnotations(Formatter.Annotation);

27using static SyntaxFactory;

61var reparsedAncestor = SyntaxFactory.ParseExpression(reducedAncestor.ToFullString()); 64return SyntaxFactory.ParenthesizedExpression(reducedNode)

37return SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression)

121? originalToken.CopyAnnotationsTo(SyntaxFactory.VerbatimIdentifier(originalToken.LeadingTrivia, unescapedText, originalToken.ValueText, originalToken.TrailingTrivia)) 122: originalToken.CopyAnnotationsTo(SyntaxFactory.Identifier(originalToken.LeadingTrivia, SyntaxKind.IdentifierToken, unescapedText, originalToken.ValueText, originalToken.TrailingTrivia));

77newMemberAccess = SyntaxFactory.MemberAccessExpression( 84newMemberAccess = SyntaxFactory.MemberAccessExpression( 90newMemberAccess = SyntaxFactory.MemberAccessExpression( 109var newArguments = SyntaxFactory.SeparatedList<ArgumentSyntax>(argumentList.Arguments.GetWithSeparators().AsEnumerable().Skip(2)); 112var candidateRewrittenNode = SyntaxFactory.InvocationExpression(newMemberAccess, rewrittenArgumentList);

98var newSimpleLambda = SyntaxFactory.SimpleLambdaExpression(

45return SyntaxFactory.IdentifierName("var")

61return SyntaxFactory.Token(kind); 64return SyntaxFactory.Identifier(specialType == SpecialType.System_IntPtr ? "nint" : "nuint"); 121var aliasIdentifier = SyntaxFactory.IdentifierName(aliasName); 282var aliasIdentifier = SyntaxFactory.IdentifierName(aliasName); 374? SyntaxFactory.IdentifierName(token) 375: SyntaxFactory.PredefinedType(token);

152replacementNode = SyntaxFactory.IdentifierName( 153memberAccess.Name.Identifier.CopyAnnotationsTo(SyntaxFactory.Identifier(

23using static SyntaxFactory;

14using static SyntaxFactory;

7using static SyntaxFactory;

18return [SyntaxFactory.Token(argument.RefKindKeyword.Kind())];

27block = SyntaxFactory.Block(statement);

117var parsed = SyntaxFactory.ParseStatement(nextTrivia.ToFullString()); 153arrowExpression = SyntaxFactory.ArrowExpressionClause(expression); 228expression = SyntaxFactory.ThrowExpression(throwStatement.ThrowKeyword, throwStatement.Expression);

16SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression);

876return SyntaxFactory.ThrowStatement(throwExpression.ThrowKeyword, throwExpression.Expression, semicolonToken); 882return SyntaxFactory.ReturnStatement(expression.WithLeadingTrivia(SyntaxFactory.ElasticSpace)) 885.WithPrependedLeadingTrivia(SyntaxFactory.ElasticMarker); 889return SyntaxFactory.ReturnStatement(expression) 895return SyntaxFactory.ExpressionStatement(expression)

107var expr = SyntaxFactory.GetStandaloneExpression(expression);

34token = token.WithLeadingTrivia(SyntaxFactory.ElasticSpace); 38token = token.WithLeadingTrivia(SyntaxFactory.Space); 46token = token.WithTrailingTrivia(SyntaxFactory.ElasticSpace); 50token = token.WithTrailingTrivia(SyntaxFactory.Space); 65token = SyntaxFactory.Token(

247var name = SyntaxFactory.ParseName(syntaxTree.GetText(cancellationToken).ToString(TextSpan.FromBounds(genericIdentifier.SpanStart, lastToken.Span.End)));

142=> SyntaxFactory.ParseLeadingTrivia(s ?? string.Empty); 185yield return SyntaxFactory.ElasticMarker;

49=> SyntaxFactory.Whitespace(text); 55_newLine = SyntaxFactory.EndOfLine(Context.Options.NewLine); 234var multilineCommentTrivia = SyntaxFactory.ParseLeadingTrivia(multiLineComment); 348var formattedTrivia = SyntaxFactory.Trivia((StructuredTriviaSyntax)result.GetFormattedRoot(cancellationToken)); 382var formattedTrivia = SyntaxFactory.Trivia((StructuredTriviaSyntax)result.GetFormattedRoot(cancellationToken));

56var parsedNewTrivia = SyntaxFactory.DocumentationCommentExterior(newTriviaText);

90var trailingTrivia = SyntaxFactory.ParseTrailingTrivia(text); 93var leadingTrivia = SyntaxFactory.ParseLeadingTrivia(text[width..]); 146return SyntaxFactory.ParseLeadingTrivia(text);

23? SyntaxFactory.Comment(text)

39=> SyntaxFactory.ElasticMarker; 42=> SyntaxFactory.ElasticCarriageReturnLineFeed; 88=> SyntaxFactory.ParseToken(text); 91=> SyntaxFactory.ParseLeadingTrivia(text); 183=> node is ExpressionSyntax expression ? SyntaxFactory.GetStandaloneExpression(expression) : node; 459var token = SyntaxFactory.ParseToken(identifier); 465var token = SyntaxFactory.ParseToken(identifier); 1257=> SyntaxFactory.AreEquivalent(token1, token2); 1260=> SyntaxFactory.AreEquivalent(node1, node2);

97var candidateReplacementNode = SyntaxFactory.IdentifierName("var"); 177SyntaxFactory.IdentifierName("var").WithTriviaFrom(declarationTypeNode).WithAdditionalAnnotations(annotation));

17return SyntaxFactory.Argument(expression); 24=> SyntaxFactory.ArgumentList([.. arguments.Select(GenerateArgument)]); 27=> SyntaxFactory.BracketedArgumentList([.. arguments.Select(GenerateArgument)]);

16using static SyntaxFactory;

19using static SyntaxFactory;

18using static SyntaxFactory;

23using static SyntaxFactory;

26using static SyntaxFactory;

17using static SyntaxFactory;

19using static SyntaxFactory;

20using static SyntaxFactory;

20using static SyntaxFactory;

19using static SyntaxFactory;

22using static SyntaxFactory;

20using static SyntaxFactory;

20using static SyntaxFactory;

19using static SyntaxFactory;

15using static SyntaxFactory;

22using static SyntaxFactory;

19return SyntaxFactory.Block(

14using static SyntaxFactory;

14using static SyntaxFactory;

14using static SyntaxFactory;

20using static SyntaxFactory;

12using static SyntaxFactory;

18using static SyntaxFactory;

33var clauses = SyntaxFactory.List(allClauses.Take(allClauses.Count() - 1).Cast<QueryClauseSyntax>());

28: SyntaxFactory.SeparatedList<T>(newList.GetWithSeparators().Add(SyntaxFactory.Token(separator)));

39return SyntaxFactory.Identifier(escaped); 46var token = SyntaxFactory.Identifier( 58=> SyntaxFactory.IdentifierName(identifier.ToIdentifierToken());

101var leadingTrivia = prependNewLineIfMissing ? token.LeadingTrivia.Insert(0, SyntaxFactory.ElasticCarriageReturnLineFeed) : token.LeadingTrivia; 102var trailingTrivia = appendNewLineIfMissing ? token.TrailingTrivia.Insert(0, SyntaxFactory.ElasticCarriageReturnLineFeed) : token.TrailingTrivia; 103return SyntaxFactory.Token(leadingTrivia, kind, trailingTrivia).WithAdditionalAnnotations(Formatter.Annotation);

103=> SyntaxFactory.AreEquivalent(a, b, kind => kind == SyntaxKind.NullableDirectiveTrivia);

23using static SyntaxFactory;

35=> SyntaxFactory.CarriageReturnLineFeed; 38=> SyntaxFactory.ElasticCarriageReturnLineFeed; 47=> SyntaxFactory.EndOfLine(text); 50=> SyntaxFactory.Comment("//" + text); 54return SyntaxFactory.LocalDeclarationStatement( 67.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 74=> SyntaxFactory.EqualsValueClause(operatorToken, (ExpressionSyntax)value); 78return SyntaxFactory.VariableDeclaration( 79type == null ? SyntaxFactory.IdentifierName("var") : (TypeSyntax)type, 80[SyntaxFactory.VariableDeclarator( 82expression == null ? null : SyntaxFactory.EqualsValueClause((ExpressionSyntax)expression))]); 86=> SyntaxFactory.Identifier(identifier); 89=> SyntaxFactory.ConditionalAccessExpression((ExpressionSyntax)expression, (ExpressionSyntax)whenNotNull); 92=> SyntaxFactory.MemberBindingExpression((SimpleNameSyntax)name); 95=> SyntaxFactory.RefExpression((ExpressionSyntax)expression); 109=> SyntaxFactory.YieldStatement(SyntaxKind.YieldReturnStatement, (ExpressionSyntax)expression); 118=> SyntaxFactory.InterpolatedStringExpression(startToken, [.. content.Cast<InterpolatedStringContentSyntax>()], endToken); 121=> SyntaxFactory.InterpolatedStringText(textToken); 124=> SyntaxFactory.Token( 131=> SyntaxFactory.Interpolation((ExpressionSyntax)syntaxNode); 134=> SyntaxFactory.InterpolationAlignmentClause(CommaToken, (ExpressionSyntax)alignment); 137=> SyntaxFactory.InterpolationFormatClause( 139SyntaxFactory.Token(default, SyntaxKind.InterpolatedStringTextToken, format, format, default)); 142=> SyntaxFactory.TypeParameterList([.. typeParameterNames.Select(SyntaxFactory.TypeParameter)]); 187return SyntaxFactory.TokenList(result); 210=> SyntaxFactory.IsPatternExpression( 216=> SyntaxFactory.BinaryPattern(SyntaxKind.AndPattern, (PatternSyntax)ParenthesizeNonSimple(left), (PatternSyntax)ParenthesizeNonSimple(right)); 219=> SyntaxFactory.ConstantPattern((ExpressionSyntax)expression); 222=> SyntaxFactory.DeclarationPattern( 224SyntaxFactory.SingleVariableDesignation(name.ToIdentifierToken())); 227=> SyntaxFactory.RelationalPattern(LessThanToken, (ExpressionSyntax)expression); 230=> SyntaxFactory.RelationalPattern(LessThanEqualsToken, (ExpressionSyntax)expression); 233=> SyntaxFactory.RelationalPattern(GreaterThanToken, (ExpressionSyntax)expression); 236=> SyntaxFactory.RelationalPattern(GreaterThanEqualsToken, (ExpressionSyntax)expression); 239=> SyntaxFactory.UnaryPattern(NotKeyword, (PatternSyntax)ParenthesizeNonSimple(pattern)); 242=> SyntaxFactory.BinaryPattern(SyntaxKind.OrPattern, (PatternSyntax)ParenthesizeNonSimple(left), (PatternSyntax)ParenthesizeNonSimple(right)); 248=> SyntaxFactory.TypePattern((TypeSyntax)type); 251=> SyntaxFactory.UnaryPattern(operatorToken, (PatternSyntax)ParenthesizeNonSimple(pattern)); 256=> SyntaxFactory.CastExpression((TypeSyntax)type, (ExpressionSyntax)ParenthesizeNonSimple(expression)).WithAdditionalAnnotations(Simplifier.Annotation); 259=> SyntaxFactory.DefaultExpression((TypeSyntax)type).WithAdditionalAnnotations(Simplifier.Annotation); 270return SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression); 276return SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression); 288return SyntaxFactory.LiteralExpression( 289SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal("0", 0)); 301RefKind.Ref => SyntaxFactory.RefType(type), 302RefKind.RefReadOnly => SyntaxFactory.RefType(RefKeyword, ReadOnlyKeyword, type), 312return SyntaxFactory.MemberAccessExpression( 343=> SyntaxFactory.BinaryExpression(syntaxKind, (ExpressionSyntax)ParenthesizeNonSimple(left), (ExpressionSyntax)ParenthesizeNonSimple(right)); 349=> SyntaxFactory.CastExpression((TypeSyntax)type, (ExpressionSyntax)ParenthesizeNonSimple(expression)).WithAdditionalAnnotations(Simplifier.Annotation);

26using static SyntaxFactory; 275.AddAccessorListAccessors(SyntaxFactory

49SyntaxFactory.VerbatimIdentifier( 85tokenWithLeadingWhitespace = token.WithLeadingTrivia(SyntaxFactory.ElasticMarker).WithAdditionalAnnotations(Formatter.Annotation);

67return SyntaxFactory.ParseSyntaxTree(text, options, filePath, cancellationToken: cancellationToken);

38var parsed = SyntaxFactory.ParseTypeName(typeName); 71return identifier.Update(SyntaxFactory.Identifier(replacement).WithTriviaFrom(identifier.Identifier));

33var parsed = SyntaxFactory.ParseTypeName(typeName); 68return SyntaxFactory.ParseTypeName(IsGloballyQualified(node) ? node.ToString() : "global::" + node.ToString()) 98return SyntaxFactory.AliasQualifiedName(SyntaxFactory.IdentifierName(SyntaxFactory.Token(CSharp.SyntaxKind.GlobalKeyword)), node);

133var attributeValueIsLambda = SyntaxFactory.ParseExpression(GetContent(attribute)) is LambdaExpressionSyntax; 484var parsed = SyntaxFactory.ParseTypeName(typeName);

44_roslynTokenParser = CodeAnalysis.CSharp.SyntaxFactory.CreateTokenParser(source.SourceText, parseOptions);

124block = (BlockSyntax)SyntaxFactory.ParseStatement(emptyBody); 128block = (BlockSyntax)SyntaxFactory.ParseStatement(GetDefaultMessage()); 159BlockSyntax block = (BlockSyntax)SyntaxFactory.ParseStatement(GetDefaultMessage()); 165BlockSyntax block = (BlockSyntax)SyntaxFactory.ParseStatement(emptyBody); 175BlockSyntax block = (BlockSyntax)SyntaxFactory.ParseStatement(message); 185BlockSyntax block = (BlockSyntax)SyntaxFactory.ParseStatement(GetDefaultMessage()); 194BlockSyntax block = (BlockSyntax)SyntaxFactory.ParseStatement(GetDefaultMessage());

28return SyntaxFactory.CreateTokenParser(text,

26var delarations = SyntaxFactory 36var syntaxTree = SyntaxFactory.ParseSyntaxTree(generatedStruct); 45var delarations = SyntaxFactory 49.Concat(SyntaxFactory 60var syntaxTree = SyntaxFactory.ParseSyntaxTree(generatedStruct); 77var delarations = SyntaxFactory 89var syntaxTree = SyntaxFactory.ParseSyntaxTree(generatedStruct); 105var delarations = SyntaxFactory 117var syntaxTree = SyntaxFactory.ParseSyntaxTree(generatedStruct);

19var propertyDeclaration = SyntaxFactory.PropertyDeclaration( 21SyntaxFactory.TokenList( 22SyntaxFactory.Token(SyntaxKind.PublicKeyword), 23SyntaxFactory.Token(SyntaxKind.StaticKeyword), 24SyntaxFactory.Token(SyntaxKind.PartialKeyword)), 25SyntaxFactory.ParseTypeName("string"), 27SyntaxFactory.Identifier("Identifier_1"), 30var anotherPropertyDeclaration = SyntaxFactory.PropertyDeclaration( 32SyntaxFactory.TokenList( 33SyntaxFactory.Token(SyntaxKind.ProtectedKeyword), 34SyntaxFactory.Token(SyntaxKind.VirtualKeyword)), 35SyntaxFactory.ParseTypeName("object"), 37SyntaxFactory.Identifier("Identifier_2"), 60var propertyDeclaration = SyntaxFactory.FieldDeclaration( 62SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PartialKeyword)), 63SyntaxFactory.VariableDeclaration(SyntaxFactory.ParseTypeName("string")));

15using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

10using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

8using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

7using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

8using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

10using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

8using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

8using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

12using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

15using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

13using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

14using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

22Syntax = SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.VoidKeyword)) 27Syntax = SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.BoolKeyword)) 32Syntax = SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.ByteKeyword)) 37Syntax = SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.CharKeyword)) 42Syntax = SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.ShortKeyword)) 47Syntax = SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)) 52Syntax = SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.LongKeyword)) 57Syntax = SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.FloatKeyword)) 62Syntax = SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.DoubleKeyword)) 68Syntax = SyntaxFactory.IdentifierName("nint") 73Syntax = SyntaxFactory.ParseTypeName(fullTypeName.Trim()) 78Syntax = SyntaxFactory.ParseTypeName(fullTypeName.Trim()) 83Syntax = SyntaxFactory.ParseTypeName(fullTypeName.Trim()) 88Syntax = SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.ObjectKeyword)) 93Syntax = SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.StringKeyword)) 98Syntax = SyntaxFactory.ParseTypeName(fullTypeName.Trim()) 119return new JSTaskTypeInfo(new JSSimpleTypeInfo(KnownManagedType.Void, SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.VoidKeyword))));

9using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

10using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

9using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

8using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

8using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

9using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

342SyntaxFactory.Argument(SyntaxFactory.IdentifierName( 343SyntaxFactory.Identifier( 344SyntaxFactory.TriviaList(), 348SyntaxFactory.TriviaList()))) 349.WithRefKindKeyword(SyntaxFactory.Token(SyntaxKind.OutKeyword))), 378SyntaxFactory.Argument(SyntaxFactory.DeclarationExpression( 380SyntaxFactory.SingleVariableDesignation( 382.WithRefKindKeyword(SyntaxFactory.Token(SyntaxKind.OutKeyword))), 396SyntaxFactory.Argument(generator.ClearTrivia(assignment.Left)) 397.WithRefKindKeyword(SyntaxFactory.Token(SyntaxKind.OutKeyword))), 528SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, 529SyntaxFactory.Literal(AppendSuffix(entryPoint, entryPointSuffix))))); 538SyntaxFactory.BinaryExpression(SyntaxKind.AddExpression, 540SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, 541SyntaxFactory.Literal(entryPointSuffix.ToString()))))); 567SyntaxFactory.SeparatedList( 628? SyntaxFactory.CollectionExpression( 629SyntaxFactory.SingletonSeparatedList<CollectionElementSyntax>( 630SyntaxFactory.ExpressionElement(typeOfExpression)))

14using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

14using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

13using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

12using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

10using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

10using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

16public TypeSyntax Syntax => _syntax ??= SyntaxFactory.ParseTypeName(FullTypeName);

12using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

11using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

8using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

10using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

10using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

8using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

11using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

9using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

9using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

8using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

9using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

9using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

9using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

180_ => CreateWellKnownComExceptionMarshallingData($"{TypeNames.ExceptionAsDefaultMarshaller}<{MarshallerHelpers.GetCompatibleGenericTypeParameterSyntax(SyntaxFactory.ParseTypeName(unmanagedReturnType.FullTypeName))}>", unmanagedReturnType),

15using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

34block = SyntaxFactory.Block(fixedStatement.Statement); 70return SyntaxFactory.Block(statement); 117return modifiers.Insert(idxInsert, SyntaxFactory.Token(modifierToAdd));

7using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

10using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

172return SyntaxFactory.ParseTypeName(type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat));

10using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

7using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

7using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

109var exp = SyntaxFactory.ParseExpression(expression);

89candidate = SyntaxFactory.ParseExpression(node.Parent.ToString()); 169var nameofExp = SyntaxFactory.ParseExpression($"nameof({name})").WithTriviaFrom(nameArg); 178var nameofExp = (InvocationExpressionSyntax)SyntaxFactory.ParseExpression($"nameof(a)").WithTriviaFrom(nameArg);

407var newList = list.WithAttributes(SyntaxFactory.SeparatedList(remaining)); 412return removed ? method.WithAttributeLists(SyntaxFactory.List(newLists)) : method; 425var attrName = SyntaxFactory.ParseName("ActiveIssue"); 428: SyntaxFactory.AttributeArgumentList( 429SyntaxFactory.SingletonSeparatedList( 430SyntaxFactory.AttributeArgument( 431SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(issueUrl))))); 433var attr = SyntaxFactory.Attribute(attrName, attrArgs); 434var newList = SyntaxFactory.AttributeList(SyntaxFactory.SingletonSeparatedList(attr)); 440var indentation = SyntaxFactory.TriviaList(last.GetLeadingTrivia().Where(t => !t.IsKind(SyntaxKind.EndOfLineTrivia))); 444: indentation.Add(SyntaxFactory.EndOfLine("\n")); 447.WithTrailingTrivia(SyntaxFactory.EndOfLine("\n")); 453.WithTrailingTrivia(SyntaxFactory.EndOfLine("\n")); 472var usingDirective = SyntaxFactory.UsingDirective(SyntaxFactory.ParseName(namespaceName)) 474SyntaxFactory.Token(SyntaxKind.UsingKeyword) 475.WithTrailingTrivia(SyntaxFactory.Space)) 477SyntaxFactory.Token(SyntaxKind.SemicolonToken) 478.WithTrailingTrivia(SyntaxFactory.EndOfLine("\n")));

351var newList = list.WithAttributes(SyntaxFactory.SeparatedList(remaining)); 356return removed ? method.WithAttributeLists(SyntaxFactory.List(newLists)) : method; 369var attrName = SyntaxFactory.ParseName("QuarantinedTest"); 372: SyntaxFactory.AttributeArgumentList( 373SyntaxFactory.SingletonSeparatedList( 374SyntaxFactory.AttributeArgument( 375SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(issueUrl))))); 377var attr = SyntaxFactory.Attribute(attrName, attrArgs); 378var newList = SyntaxFactory.AttributeList(SyntaxFactory.SingletonSeparatedList(attr)); 384var indentation = SyntaxFactory.TriviaList(last.GetLeadingTrivia().Where(t => !t.IsKind(SyntaxKind.EndOfLineTrivia))); 388: indentation.Add(SyntaxFactory.EndOfLine("\n")); 391.WithTrailingTrivia(SyntaxFactory.EndOfLine("\n")); 397.WithTrailingTrivia(SyntaxFactory.EndOfLine("\n")); 420var usingDirective = SyntaxFactory.UsingDirective(SyntaxFactory.ParseName(namespaceName)) 422SyntaxFactory.Token(SyntaxKind.UsingKeyword) 423.WithTrailingTrivia(SyntaxFactory.Space)) 425SyntaxFactory.Token(SyntaxKind.SemicolonToken) 426.WithTrailingTrivia(SyntaxFactory.EndOfLine("\n"))); 450updated = updated.WithUsings(SyntaxFactory.List(filtered));

40var refKeyword = SyntaxFactory.Token(SyntaxKind.RefKeyword); 44RefKind.RefReadOnly => SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword), 48return SyntaxFactory.RefType(refKeyword, readOnlyKeyword, (TypeSyntax)type); 53return SyntaxFactory.RefExpression((ExpressionSyntax)expression);

17using static SyntaxFactory;

58var newToken = SyntaxFactory.Token(oldToken.LeadingTrivia, kind: oldToken.Kind(), text: newText, valueText: newValueText, oldToken.TrailingTrivia);

53ExpressionSyntax newSyntax = SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression); 63type = SyntaxFactory.NullableType(type.WithoutTrivia()).WithTriviaFrom(type); 67var castExpression = SyntaxFactory.CastExpression(type, newSyntax.WithTrailingTrivia(defaultExpression.Keyword.TrailingTrivia)); 72newSyntax = SyntaxFactory.ParenthesizedExpression(castExpression.WithAdditionalAnnotations(Simplifier.Annotation))

7using static SyntaxFactory;

18return [SyntaxFactory.Token(argument.RefKindKeyword.Kind())];

27block = SyntaxFactory.Block(statement);

117var parsed = SyntaxFactory.ParseStatement(nextTrivia.ToFullString()); 153arrowExpression = SyntaxFactory.ArrowExpressionClause(expression); 228expression = SyntaxFactory.ThrowExpression(throwStatement.ThrowKeyword, throwStatement.Expression);

16SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression);

876return SyntaxFactory.ThrowStatement(throwExpression.ThrowKeyword, throwExpression.Expression, semicolonToken); 882return SyntaxFactory.ReturnStatement(expression.WithLeadingTrivia(SyntaxFactory.ElasticSpace)) 885.WithPrependedLeadingTrivia(SyntaxFactory.ElasticMarker); 889return SyntaxFactory.ReturnStatement(expression) 895return SyntaxFactory.ExpressionStatement(expression)

107var expr = SyntaxFactory.GetStandaloneExpression(expression);

34token = token.WithLeadingTrivia(SyntaxFactory.ElasticSpace); 38token = token.WithLeadingTrivia(SyntaxFactory.Space); 46token = token.WithTrailingTrivia(SyntaxFactory.ElasticSpace); 50token = token.WithTrailingTrivia(SyntaxFactory.Space); 65token = SyntaxFactory.Token(