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

193var todoComment = SyntaxFactory.Comment("// TODO(unsafe): Baselining unsafe usage"); 194var newLine = SyntaxFactory.ElasticCarriageReturnLineFeed; 221typeSyntax = SyntaxFactory.ParseTypeName(typeInfo.Type.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat)) 222.WithTrailingTrivia(SyntaxFactory.Space); 234var forwardDeclVariable = SyntaxFactory.VariableDeclarator(variable.Identifier); 235var forwardDeclDeclaration = SyntaxFactory.VariableDeclaration(typeSyntax) 237forwardDecl = SyntaxFactory.LocalDeclarationStatement(forwardDeclDeclaration) 239.WithTrailingTrivia(SyntaxFactory.TriviaList(SyntaxFactory.ElasticCarriageReturnLineFeed)); 242var assignment = SyntaxFactory.AssignmentExpression( 244SyntaxFactory.IdentifierName(variable.Identifier), 246statementToWrap = SyntaxFactory.ExpressionStatement(assignment) 247.WithTrailingTrivia(SyntaxFactory.TriviaList(SyntaxFactory.ElasticCarriageReturnLineFeed)); 325.WithTrailingTrivia(SyntaxFactory.TriviaList(SyntaxFactory.ElasticCarriageReturnLineFeed))); 326var unsafeBlock = SyntaxFactory.UnsafeStatement( 327SyntaxFactory.Block(wrappedStatements)) 329? SyntaxFactory.TriviaList(todoComment, newLine) 357var newBlock = parentBlock.WithStatements(SyntaxFactory.List(newStatements)); 372var todoComment = SyntaxFactory.Comment("// TODO(unsafe): Baselining unsafe usage"); 373var newLine = SyntaxFactory.CarriageReturnLineFeed; 376var unsafeBlock = SyntaxFactory.UnsafeStatement( 377SyntaxFactory.Block(triggerStatement.WithoutTrivia())) 395var todoComment = SyntaxFactory.Comment("// TODO(unsafe): Baselining unsafe usage"); 396var newLine = SyntaxFactory.CarriageReturnLineFeed; 399var unsafeBlock = SyntaxFactory.UnsafeStatement( 400SyntaxFactory.Block(embeddedStatement.WithoutTrivia())) 404var wrappingBlock = SyntaxFactory.Block(unsafeBlock) 421var todoComment = SyntaxFactory.Comment("// TODO(unsafe): Baselining unsafe usage"); 422var newLine = SyntaxFactory.CarriageReturnLineFeed; 447? SyntaxFactory.ExpressionStatement(arrowExpr.Expression.WithoutTrivia()) 448: SyntaxFactory.ReturnStatement(arrowExpr.Expression.WithoutTrivia()); 451var unsafeBlock = SyntaxFactory.UnsafeStatement( 452SyntaxFactory.Block(innerStatement)) 456var blockBody = SyntaxFactory.Block(unsafeBlock); 486var getter = SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) 487.WithBody(SyntaxFactory.Block(unsafeBlock)); 488var accessorList = SyntaxFactory.AccessorList(SyntaxFactory.SingletonList(getter)); 500.WithBody(SyntaxFactory.Block(unsafeBlock)); 505var indexerGetter = SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) 506.WithBody(SyntaxFactory.Block(unsafeBlock)); 507var 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))

68var newModifiers = SyntaxFactory.TokenList( 69SyntaxFactory.Token(SyntaxKind.PublicKeyword)

68var newModifiers = SyntaxFactory.TokenList( 69SyntaxFactory.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)

2310=> SyntaxFactory.QualifiedName(left, SyntaxFactory.Token(SyntaxKind.DotToken), right); 2322=> SyntaxFactory.GenericName(identifier, SyntaxFactory.TypeArgumentList()); 2326=> SyntaxFactory.GenericName(SyntaxFactory.Identifier(identifier), SyntaxFactory.TypeArgumentList()); 2338=> SyntaxFactory.TypeArgumentList(SyntaxFactory.Token(SyntaxKind.LessThanToken), arguments, SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); 2351=> SyntaxFactory.AliasQualifiedName(alias, SyntaxFactory.Token(SyntaxKind.ColonColonToken), name); 2355=> SyntaxFactory.AliasQualifiedName(SyntaxFactory.IdentifierName(alias), SyntaxFactory.Token(SyntaxKind.ColonColonToken), name); 2392=> SyntaxFactory.ArrayType(elementType, default); 2404=> SyntaxFactory.ArrayRankSpecifier(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), sizes, SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); 2416=> SyntaxFactory.PointerType(elementType, SyntaxFactory.Token(SyntaxKind.AsteriskToken)); 2429=> SyntaxFactory.FunctionPointerType(SyntaxFactory.Token(SyntaxKind.DelegateKeyword), SyntaxFactory.Token(SyntaxKind.AsteriskToken), callingConvention, parameterList); 2433=> SyntaxFactory.FunctionPointerType(SyntaxFactory.Token(SyntaxKind.DelegateKeyword), SyntaxFactory.Token(SyntaxKind.AsteriskToken), default, SyntaxFactory.FunctionPointerParameterList()); 2445=> SyntaxFactory.FunctionPointerParameterList(SyntaxFactory.Token(SyntaxKind.LessThanToken), parameters, SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); 2461=> SyntaxFactory.FunctionPointerCallingConvention(managedOrUnmanagedKeyword, default); 2473=> SyntaxFactory.FunctionPointerUnmanagedCallingConventionList(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), callingConventions, SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); 2492=> SyntaxFactory.NullableType(elementType, SyntaxFactory.Token(SyntaxKind.QuestionToken)); 2504=> SyntaxFactory.TupleType(SyntaxFactory.Token(SyntaxKind.OpenParenToken), elements, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 2521=> SyntaxFactory.TupleElement(type, default); 2532=> SyntaxFactory.OmittedTypeArgument(SyntaxFactory.Token(SyntaxKind.OmittedTypeArgumentToken)); 2550=> SyntaxFactory.RefType(SyntaxFactory.Token(SyntaxKind.RefKeyword), default, type); 2562=> SyntaxFactory.ScopedType(SyntaxFactory.Token(SyntaxKind.ScopedKeyword), type); 2575=> SyntaxFactory.ParenthesizedExpression(SyntaxFactory.Token(SyntaxKind.OpenParenToken), expression, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 2587=> SyntaxFactory.TupleExpression(SyntaxFactory.Token(SyntaxKind.OpenParenToken), arguments, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 2624=> SyntaxFactory.PrefixUnaryExpression(kind, SyntaxFactory.Token(GetPrefixUnaryExpressionOperatorTokenKind(kind)), operand); 2651=> SyntaxFactory.AwaitExpression(SyntaxFactory.Token(SyntaxKind.AwaitKeyword), expression); 2676=> SyntaxFactory.PostfixUnaryExpression(kind, operand, SyntaxFactory.Token(GetPostfixUnaryExpressionOperatorTokenKind(kind))); 2709=> SyntaxFactory.MemberAccessExpression(kind, expression, SyntaxFactory.Token(GetMemberAccessExpressionOperatorTokenKind(kind)), name); 2730=> SyntaxFactory.ConditionalAccessExpression(expression, SyntaxFactory.Token(SyntaxKind.QuestionToken), whenNotNull); 2742=> SyntaxFactory.MemberBindingExpression(SyntaxFactory.Token(SyntaxKind.DotToken), name); 2753=> SyntaxFactory.ElementBindingExpression(SyntaxFactory.BracketedArgumentList()); 2764=> SyntaxFactory.RangeExpression(leftOperand, SyntaxFactory.Token(SyntaxKind.DotDotToken), rightOperand); 2768=> SyntaxFactory.RangeExpression(default, SyntaxFactory.Token(SyntaxKind.DotDotToken), default); 2779=> SyntaxFactory.ImplicitElementAccess(SyntaxFactory.BracketedArgumentList()); 2843=> SyntaxFactory.BinaryExpression(kind, left, SyntaxFactory.Token(GetBinaryExpressionOperatorTokenKind(kind)), right); 2917=> SyntaxFactory.AssignmentExpression(kind, left, SyntaxFactory.Token(GetAssignmentExpressionOperatorTokenKind(kind)), right); 2951=> SyntaxFactory.ConditionalExpression(condition, SyntaxFactory.Token(SyntaxKind.QuestionToken), whenTrue, SyntaxFactory.Token(SyntaxKind.ColonToken), whenFalse); 2962=> SyntaxFactory.ThisExpression(SyntaxFactory.Token(SyntaxKind.ThisKeyword)); 2973=> SyntaxFactory.BaseExpression(SyntaxFactory.Token(SyntaxKind.BaseKeyword)); 3020=> SyntaxFactory.FieldExpression(SyntaxFactory.Token(SyntaxKind.FieldKeyword)); 3034=> SyntaxFactory.MakeRefExpression(SyntaxFactory.Token(SyntaxKind.MakeRefKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), expression, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 3048=> SyntaxFactory.RefTypeExpression(SyntaxFactory.Token(SyntaxKind.RefTypeKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), expression, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 3064=> SyntaxFactory.RefValueExpression(SyntaxFactory.Token(SyntaxKind.RefValueKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), expression, SyntaxFactory.Token(SyntaxKind.CommaToken), type, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 3089=> SyntaxFactory.CheckedExpression(kind, SyntaxFactory.Token(GetCheckedExpressionKeywordKind(kind)), SyntaxFactory.Token(SyntaxKind.OpenParenToken), expression, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 3113=> SyntaxFactory.UnsafeExpression(SyntaxFactory.Token(SyntaxKind.UnsafeKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), expression, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 3127=> SyntaxFactory.DefaultExpression(SyntaxFactory.Token(SyntaxKind.DefaultKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), type, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 3141=> SyntaxFactory.TypeOfExpression(SyntaxFactory.Token(SyntaxKind.TypeOfKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), type, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 3155=> SyntaxFactory.SizeOfExpression(SyntaxFactory.Token(SyntaxKind.SizeOfKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), type, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 3167=> SyntaxFactory.InvocationExpression(expression, SyntaxFactory.ArgumentList()); 3179=> SyntaxFactory.ElementAccessExpression(expression, SyntaxFactory.BracketedArgumentList()); 3191=> SyntaxFactory.ArgumentList(SyntaxFactory.Token(SyntaxKind.OpenParenToken), arguments, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 3203=> SyntaxFactory.BracketedArgumentList(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), arguments, SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); 3222=> SyntaxFactory.Argument(default, default, expression); 3260=> SyntaxFactory.CastExpression(SyntaxFactory.Token(SyntaxKind.OpenParenToken), type, SyntaxFactory.Token(SyntaxKind.CloseParenToken), expression); 3288=> SyntaxFactory.RefExpression(SyntaxFactory.Token(SyntaxKind.RefKeyword), expression); 3300=> SyntaxFactory.ParenthesizedLambdaExpression(attributeLists, modifiers, returnType, parameterList, SyntaxFactory.Token(SyntaxKind.EqualsGreaterThanToken), block, expressionBody); 3304=> SyntaxFactory.ParenthesizedLambdaExpression(default, default(SyntaxTokenList), default, SyntaxFactory.ParameterList(), SyntaxFactory.Token(SyntaxKind.EqualsGreaterThanToken), default, default); 3325=> SyntaxFactory.InitializerExpression(kind, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), expressions, SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 3337=> SyntaxFactory.ImplicitObjectCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), argumentList, initializer); 3341=> SyntaxFactory.ImplicitObjectCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), SyntaxFactory.ArgumentList(), default); 3353=> SyntaxFactory.ObjectCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), type, argumentList, initializer); 3357=> SyntaxFactory.ObjectCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), type, default, default); 3370=> SyntaxFactory.WithExpression(expression, SyntaxFactory.Token(SyntaxKind.WithKeyword), initializer); 3381=> SyntaxFactory.AnonymousObjectMemberDeclarator(default, expression); 3394=> SyntaxFactory.AnonymousObjectCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), SyntaxFactory.Token(SyntaxKind.OpenBraceToken), initializers, SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 3406=> SyntaxFactory.ArrayCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), type, initializer); 3410=> SyntaxFactory.ArrayCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), type, default); 3424=> SyntaxFactory.ImplicitArrayCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), SyntaxFactory.Token(SyntaxKind.OpenBracketToken), commas, SyntaxFactory.Token(SyntaxKind.CloseBracketToken), initializer); 3428=> SyntaxFactory.ImplicitArrayCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), SyntaxFactory.Token(SyntaxKind.OpenBracketToken), default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.CloseBracketToken), initializer); 3440=> SyntaxFactory.StackAllocArrayCreationExpression(SyntaxFactory.Token(SyntaxKind.StackAllocKeyword), type, initializer); 3444=> SyntaxFactory.StackAllocArrayCreationExpression(SyntaxFactory.Token(SyntaxKind.StackAllocKeyword), type, default); 3458=> SyntaxFactory.ImplicitStackAllocArrayCreationExpression(SyntaxFactory.Token(SyntaxKind.StackAllocKeyword), SyntaxFactory.Token(SyntaxKind.OpenBracketToken), SyntaxFactory.Token(SyntaxKind.CloseBracketToken), initializer); 3470=> SyntaxFactory.CollectionExpression(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), elements, SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); 3489=> SyntaxFactory.SpreadElement(SyntaxFactory.Token(SyntaxKind.DotDotToken), expression); 3503=> SyntaxFactory.WithElement(SyntaxFactory.Token(SyntaxKind.WithKeyword), argumentList ?? SyntaxFactory.ArgumentList()); 3522=> SyntaxFactory.QueryBody(default, selectOrGroup, default); 3536=> SyntaxFactory.FromClause(SyntaxFactory.Token(SyntaxKind.FromKeyword), type, identifier, SyntaxFactory.Token(SyntaxKind.InKeyword), expression); 3540=> SyntaxFactory.FromClause(SyntaxFactory.Token(SyntaxKind.FromKeyword), default, identifier, SyntaxFactory.Token(SyntaxKind.InKeyword), expression); 3544=> SyntaxFactory.FromClause(SyntaxFactory.Token(SyntaxKind.FromKeyword), default, SyntaxFactory.Identifier(identifier), SyntaxFactory.Token(SyntaxKind.InKeyword), expression); 3558=> SyntaxFactory.LetClause(SyntaxFactory.Token(SyntaxKind.LetKeyword), identifier, SyntaxFactory.Token(SyntaxKind.EqualsToken), expression); 3562=> SyntaxFactory.LetClause(SyntaxFactory.Token(SyntaxKind.LetKeyword), SyntaxFactory.Identifier(identifier), SyntaxFactory.Token(SyntaxKind.EqualsToken), expression); 3580=> SyntaxFactory.JoinClause(SyntaxFactory.Token(SyntaxKind.JoinKeyword), type, identifier, SyntaxFactory.Token(SyntaxKind.InKeyword), inExpression, SyntaxFactory.Token(SyntaxKind.OnKeyword), leftExpression, SyntaxFactory.Token(SyntaxKind.EqualsKeyword), rightExpression, into); 3584=> SyntaxFactory.JoinClause(SyntaxFactory.Token(SyntaxKind.JoinKeyword), default, identifier, SyntaxFactory.Token(SyntaxKind.InKeyword), inExpression, SyntaxFactory.Token(SyntaxKind.OnKeyword), leftExpression, SyntaxFactory.Token(SyntaxKind.EqualsKeyword), rightExpression, default); 3588=> 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); 3600=> SyntaxFactory.JoinIntoClause(SyntaxFactory.Token(SyntaxKind.IntoKeyword), identifier); 3604=> SyntaxFactory.JoinIntoClause(SyntaxFactory.Token(SyntaxKind.IntoKeyword), SyntaxFactory.Identifier(identifier)); 3616=> SyntaxFactory.WhereClause(SyntaxFactory.Token(SyntaxKind.WhereKeyword), condition); 3627=> SyntaxFactory.OrderByClause(SyntaxFactory.Token(SyntaxKind.OrderByKeyword), orderings); 3651=> SyntaxFactory.Ordering(kind, expression, default); 3671=> SyntaxFactory.SelectClause(SyntaxFactory.Token(SyntaxKind.SelectKeyword), expression); 3685=> SyntaxFactory.GroupClause(SyntaxFactory.Token(SyntaxKind.GroupKeyword), groupExpression, SyntaxFactory.Token(SyntaxKind.ByKeyword), byExpression); 3698=> SyntaxFactory.QueryContinuation(SyntaxFactory.Token(SyntaxKind.IntoKeyword), identifier, body); 3702=> SyntaxFactory.QueryContinuation(SyntaxFactory.Token(SyntaxKind.IntoKeyword), SyntaxFactory.Identifier(identifier), body); 3713=> SyntaxFactory.OmittedArraySizeExpression(SyntaxFactory.Token(SyntaxKind.OmittedArraySizeExpressionToken)); 3737=> SyntaxFactory.InterpolatedStringExpression(stringStartToken, default, stringEndToken); 3750=> SyntaxFactory.IsPatternExpression(expression, SyntaxFactory.Token(SyntaxKind.IsKeyword), pattern); 3762=> SyntaxFactory.ThrowExpression(SyntaxFactory.Token(SyntaxKind.ThrowKeyword), expression); 3774=> SyntaxFactory.WhenClause(SyntaxFactory.Token(SyntaxKind.WhenKeyword), condition); 3785=> SyntaxFactory.DiscardPattern(SyntaxFactory.Token(SyntaxKind.UnderscoreToken)); 3805=> SyntaxFactory.VarPattern(SyntaxFactory.Token(SyntaxKind.VarKeyword), designation); 3815=> SyntaxFactory.RecursivePattern(default, default, default, default); 3827=> SyntaxFactory.PositionalPatternClause(SyntaxFactory.Token(SyntaxKind.OpenParenToken), subpatterns, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 3839=> SyntaxFactory.PropertyPatternClause(SyntaxFactory.Token(SyntaxKind.OpenBraceToken), subpatterns, SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 3850=> SyntaxFactory.Subpattern(default, pattern); 3870=> SyntaxFactory.ParenthesizedPattern(SyntaxFactory.Token(SyntaxKind.OpenParenToken), pattern, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 3918=> SyntaxFactory.BinaryPattern(kind, left, SyntaxFactory.Token(GetBinaryPatternOperatorTokenKind(kind)), right); 3938=> SyntaxFactory.UnaryPattern(SyntaxFactory.Token(SyntaxKind.NotKeyword), pattern); 3950=> SyntaxFactory.ListPattern(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), patterns, SyntaxFactory.Token(SyntaxKind.CloseBracketToken), designation); 3954=> SyntaxFactory.ListPattern(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), patterns, SyntaxFactory.Token(SyntaxKind.CloseBracketToken), default); 3965=> SyntaxFactory.SlicePattern(SyntaxFactory.Token(SyntaxKind.DotDotToken), pattern); 3976=> SyntaxFactory.InterpolatedStringText(SyntaxFactory.Token(SyntaxKind.InterpolatedStringTextToken)); 3989=> SyntaxFactory.Interpolation(SyntaxFactory.Token(SyntaxKind.OpenBraceToken), expression, alignmentClause, formatClause, SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 3993=> SyntaxFactory.Interpolation(SyntaxFactory.Token(SyntaxKind.OpenBraceToken), expression, default, default, SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 4011=> SyntaxFactory.InterpolationFormatClause(colonToken, SyntaxFactory.Token(SyntaxKind.InterpolatedStringTextToken)); 4022=> SyntaxFactory.GlobalStatement(default, default(SyntaxTokenList), statement); 4034=> SyntaxFactory.Block(attributeLists, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), statements, SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 4039=> SyntaxFactory.Block(default, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), statements, SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 4059=> SyntaxFactory.LocalFunctionStatement(attributeLists, modifiers, returnType, identifier, typeParameterList, parameterList, constraintClauses, body, expressionBody, default); 4063=> SyntaxFactory.LocalFunctionStatement(default, default(SyntaxTokenList), returnType, identifier, default, SyntaxFactory.ParameterList(), default, default, default, default); 4067=> SyntaxFactory.LocalFunctionStatement(default, default(SyntaxTokenList), returnType, SyntaxFactory.Identifier(identifier), default, SyntaxFactory.ParameterList(), default, default, default, default); 4091=> SyntaxFactory.LocalDeclarationStatement(attributeLists, default, default, modifiers, declaration, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4095=> SyntaxFactory.LocalDeclarationStatement(default, default, default, default(SyntaxTokenList), declaration, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4106=> SyntaxFactory.VariableDeclaration(type, default); 4117=> SyntaxFactory.VariableDeclarator(identifier, default, default); 4121=> SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(identifier), default, default); 4133=> SyntaxFactory.EqualsValueClause(SyntaxFactory.Token(SyntaxKind.EqualsToken), value); 4151=> SyntaxFactory.DiscardDesignation(SyntaxFactory.Token(SyntaxKind.UnderscoreToken)); 4163=> SyntaxFactory.ParenthesizedVariableDesignation(SyntaxFactory.Token(SyntaxKind.OpenParenToken), variables, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 4175=> SyntaxFactory.ExpressionStatement(attributeLists, expression, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4179=> SyntaxFactory.ExpressionStatement(default, expression, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4190=> SyntaxFactory.EmptyStatement(attributeLists, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4194=> SyntaxFactory.EmptyStatement(default, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4207=> SyntaxFactory.LabeledStatement(attributeLists, identifier, SyntaxFactory.Token(SyntaxKind.ColonToken), statement); 4211=> SyntaxFactory.LabeledStatement(default, identifier, SyntaxFactory.Token(SyntaxKind.ColonToken), statement); 4215=> SyntaxFactory.LabeledStatement(default, SyntaxFactory.Identifier(identifier), SyntaxFactory.Token(SyntaxKind.ColonToken), statement); 4241=> SyntaxFactory.GotoStatement(kind, attributeLists, SyntaxFactory.Token(SyntaxKind.GotoKeyword), caseOrDefaultKeyword, expression, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4246=> SyntaxFactory.GotoStatement(kind, default, SyntaxFactory.Token(SyntaxKind.GotoKeyword), default, expression, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4261=> SyntaxFactory.BreakStatement(attributeLists, SyntaxFactory.Token(SyntaxKind.BreakKeyword), name, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4267=> SyntaxFactory.BreakStatement(default, SyntaxFactory.Token(SyntaxKind.BreakKeyword), name, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4282=> SyntaxFactory.ContinueStatement(attributeLists, SyntaxFactory.Token(SyntaxKind.ContinueKeyword), name, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4288=> SyntaxFactory.ContinueStatement(default, SyntaxFactory.Token(SyntaxKind.ContinueKeyword), name, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4301=> SyntaxFactory.ReturnStatement(attributeLists, SyntaxFactory.Token(SyntaxKind.ReturnKeyword), expression, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4306=> SyntaxFactory.ReturnStatement(default, SyntaxFactory.Token(SyntaxKind.ReturnKeyword), expression, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4319=> SyntaxFactory.ThrowStatement(attributeLists, SyntaxFactory.Token(SyntaxKind.ThrowKeyword), expression, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4324=> SyntaxFactory.ThrowStatement(default, SyntaxFactory.Token(SyntaxKind.ThrowKeyword), expression, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4349=> SyntaxFactory.YieldStatement(kind, attributeLists, SyntaxFactory.Token(SyntaxKind.YieldKeyword), SyntaxFactory.Token(GetYieldStatementReturnOrBreakKeywordKind(kind)), expression, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4354=> SyntaxFactory.YieldStatement(kind, default, SyntaxFactory.Token(SyntaxKind.YieldKeyword), SyntaxFactory.Token(GetYieldStatementReturnOrBreakKeywordKind(kind)), expression, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4378=> SyntaxFactory.WhileStatement(attributeLists, SyntaxFactory.Token(SyntaxKind.WhileKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), condition, SyntaxFactory.Token(SyntaxKind.CloseParenToken), statement); 4382=> SyntaxFactory.WhileStatement(default, SyntaxFactory.Token(SyntaxKind.WhileKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), condition, SyntaxFactory.Token(SyntaxKind.CloseParenToken), statement); 4399=> 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)); 4403=> 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)); 4419=> 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); 4423=> 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); 4447=> SyntaxFactory.ForEachStatement(attributeLists, default, SyntaxFactory.Token(SyntaxKind.ForEachKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), type, identifier, SyntaxFactory.Token(SyntaxKind.InKeyword), expression, SyntaxFactory.Token(SyntaxKind.CloseParenToken), statement); 4451=> SyntaxFactory.ForEachStatement(default, default, SyntaxFactory.Token(SyntaxKind.ForEachKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), type, identifier, SyntaxFactory.Token(SyntaxKind.InKeyword), expression, SyntaxFactory.Token(SyntaxKind.CloseParenToken), statement); 4455=> 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); 4478=> SyntaxFactory.ForEachVariableStatement(attributeLists, default, SyntaxFactory.Token(SyntaxKind.ForEachKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), variable, SyntaxFactory.Token(SyntaxKind.InKeyword), expression, SyntaxFactory.Token(SyntaxKind.CloseParenToken), statement); 4482=> SyntaxFactory.ForEachVariableStatement(default, default, SyntaxFactory.Token(SyntaxKind.ForEachKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), variable, SyntaxFactory.Token(SyntaxKind.InKeyword), expression, SyntaxFactory.Token(SyntaxKind.CloseParenToken), statement); 4502=> SyntaxFactory.UsingStatement(attributeLists, default, SyntaxFactory.Token(SyntaxKind.UsingKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), declaration, expression, SyntaxFactory.Token(SyntaxKind.CloseParenToken), statement); 4506=> SyntaxFactory.UsingStatement(default, default, SyntaxFactory.Token(SyntaxKind.UsingKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), default, default, SyntaxFactory.Token(SyntaxKind.CloseParenToken), statement); 4521=> SyntaxFactory.FixedStatement(attributeLists, SyntaxFactory.Token(SyntaxKind.FixedKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), declaration, SyntaxFactory.Token(SyntaxKind.CloseParenToken), statement); 4525=> SyntaxFactory.FixedStatement(default, SyntaxFactory.Token(SyntaxKind.FixedKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), declaration, SyntaxFactory.Token(SyntaxKind.CloseParenToken), statement); 4548=> SyntaxFactory.CheckedStatement(kind, attributeLists, SyntaxFactory.Token(GetCheckedStatementKeywordKind(kind)), block); 4553=> SyntaxFactory.CheckedStatement(kind, default, SyntaxFactory.Token(GetCheckedStatementKeywordKind(kind)), block ?? SyntaxFactory.Block()); 4574=> SyntaxFactory.UnsafeStatement(attributeLists, SyntaxFactory.Token(SyntaxKind.UnsafeKeyword), block); 4579=> SyntaxFactory.UnsafeStatement(default, SyntaxFactory.Token(SyntaxKind.UnsafeKeyword), block ?? SyntaxFactory.Block()); 4595=> SyntaxFactory.LockStatement(attributeLists, SyntaxFactory.Token(SyntaxKind.LockKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), expression, SyntaxFactory.Token(SyntaxKind.CloseParenToken), statement); 4599=> SyntaxFactory.LockStatement(default, SyntaxFactory.Token(SyntaxKind.LockKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), expression, SyntaxFactory.Token(SyntaxKind.CloseParenToken), statement); 4614=> SyntaxFactory.IfStatement(attributeLists, SyntaxFactory.Token(SyntaxKind.IfKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), condition, SyntaxFactory.Token(SyntaxKind.CloseParenToken), statement, @else); 4618=> SyntaxFactory.IfStatement(default, SyntaxFactory.Token(SyntaxKind.IfKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), condition, SyntaxFactory.Token(SyntaxKind.CloseParenToken), statement, default); 4630=> SyntaxFactory.ElseClause(SyntaxFactory.Token(SyntaxKind.ElseKeyword), statement); 4662=> SyntaxFactory.SwitchSection(default, default); 4675=> SyntaxFactory.CasePatternSwitchLabel(SyntaxFactory.Token(SyntaxKind.CaseKeyword), pattern, whenClause, colonToken); 4679=> SyntaxFactory.CasePatternSwitchLabel(SyntaxFactory.Token(SyntaxKind.CaseKeyword), pattern, default, colonToken); 4692=> SyntaxFactory.CaseSwitchLabel(SyntaxFactory.Token(SyntaxKind.CaseKeyword), value, colonToken); 4704=> SyntaxFactory.DefaultSwitchLabel(SyntaxFactory.Token(SyntaxKind.DefaultKeyword), colonToken); 4718=> SyntaxFactory.SwitchExpression(governingExpression, SyntaxFactory.Token(SyntaxKind.SwitchKeyword), SyntaxFactory.Token(SyntaxKind.OpenBraceToken), arms, SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 4722=> SyntaxFactory.SwitchExpression(governingExpression, SyntaxFactory.Token(SyntaxKind.SwitchKeyword), SyntaxFactory.Token(SyntaxKind.OpenBraceToken), default, SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 4735=> SyntaxFactory.SwitchExpressionArm(pattern, whenClause, SyntaxFactory.Token(SyntaxKind.EqualsGreaterThanToken), expression); 4739=> SyntaxFactory.SwitchExpressionArm(pattern, default, SyntaxFactory.Token(SyntaxKind.EqualsGreaterThanToken), expression); 4751=> SyntaxFactory.TryStatement(attributeLists, SyntaxFactory.Token(SyntaxKind.TryKeyword), block, catches, @finally); 4756=> SyntaxFactory.TryStatement(default, SyntaxFactory.Token(SyntaxKind.TryKeyword), SyntaxFactory.Block(), catches, default); 4769=> SyntaxFactory.CatchClause(SyntaxFactory.Token(SyntaxKind.CatchKeyword), declaration, filter, block); 4773=> SyntaxFactory.CatchClause(SyntaxFactory.Token(SyntaxKind.CatchKeyword), default, default, SyntaxFactory.Block()); 4792=> SyntaxFactory.CatchDeclaration(SyntaxFactory.Token(SyntaxKind.OpenParenToken), type, identifier, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 4796=> SyntaxFactory.CatchDeclaration(SyntaxFactory.Token(SyntaxKind.OpenParenToken), type, default, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 4810=> SyntaxFactory.CatchFilterClause(SyntaxFactory.Token(SyntaxKind.WhenKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), filterExpression, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 4822=> SyntaxFactory.FinallyClause(SyntaxFactory.Token(SyntaxKind.FinallyKeyword), block ?? SyntaxFactory.Block()); 4833=> SyntaxFactory.CompilationUnit(externs, usings, attributeLists, members, SyntaxFactory.Token(SyntaxKind.EndOfFileToken)); 4837=> SyntaxFactory.CompilationUnit(default, default, default, default, SyntaxFactory.Token(SyntaxKind.EndOfFileToken)); 4851=> SyntaxFactory.ExternAliasDirective(SyntaxFactory.Token(SyntaxKind.ExternKeyword), SyntaxFactory.Token(SyntaxKind.AliasKeyword), identifier, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4855=> SyntaxFactory.ExternAliasDirective(SyntaxFactory.Token(SyntaxKind.ExternKeyword), SyntaxFactory.Token(SyntaxKind.AliasKeyword), SyntaxFactory.Identifier(identifier), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4886=> SyntaxFactory.UsingDirective(default, SyntaxFactory.Token(SyntaxKind.UsingKeyword), default, default, alias, namespaceOrType, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4890=> SyntaxFactory.UsingDirective(default, SyntaxFactory.Token(SyntaxKind.UsingKeyword), default, default, default, namespaceOrType, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 4910=> SyntaxFactory.NamespaceDeclaration(attributeLists, modifiers, SyntaxFactory.Token(SyntaxKind.NamespaceKeyword), name, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), externs, usings, members, SyntaxFactory.Token(SyntaxKind.CloseBraceToken), default); 4914=> SyntaxFactory.NamespaceDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.NamespaceKeyword), name, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), default, default, default, SyntaxFactory.Token(SyntaxKind.CloseBraceToken), default); 4927=> SyntaxFactory.FileScopedNamespaceDeclaration(attributeLists, modifiers, SyntaxFactory.Token(SyntaxKind.NamespaceKeyword), name, SyntaxFactory.Token(SyntaxKind.SemicolonToken), externs, usings, members); 4931=> SyntaxFactory.FileScopedNamespaceDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.NamespaceKeyword), name, SyntaxFactory.Token(SyntaxKind.SemicolonToken), default, default, default); 4943=> SyntaxFactory.AttributeList(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), target, attributes, SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); 4947=> SyntaxFactory.AttributeList(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), default, attributes, SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); 4958=> SyntaxFactory.AttributeTargetSpecifier(identifier, SyntaxFactory.Token(SyntaxKind.ColonToken)); 4969=> SyntaxFactory.Attribute(name, default); 4981=> SyntaxFactory.AttributeArgumentList(SyntaxFactory.Token(SyntaxKind.OpenParenToken), arguments, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 4992=> SyntaxFactory.AttributeArgument(default, default, expression); 5004=> SyntaxFactory.NameEquals(name, SyntaxFactory.Token(SyntaxKind.EqualsToken)); 5008=> SyntaxFactory.NameEquals(SyntaxFactory.IdentifierName(name), SyntaxFactory.Token(SyntaxKind.EqualsToken)); 5020=> SyntaxFactory.TypeParameterList(SyntaxFactory.Token(SyntaxKind.LessThanToken), parameters, SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); 5038=> SyntaxFactory.TypeParameter(default, default, identifier); 5042=> SyntaxFactory.TypeParameter(default, default, SyntaxFactory.Identifier(identifier)); 5189=> SyntaxFactory.RecordDeclaration(kind, attributeLists, modifiers, keyword, default, identifier, typeParameterList, parameterList, baseList, constraintClauses, default, members, default, default); 5193=> SyntaxFactory.RecordDeclaration(kind, default, default(SyntaxTokenList), keyword, default, identifier, default, default, default, default, default, default, default, default); 5197=> SyntaxFactory.RecordDeclaration(kind, default, default(SyntaxTokenList), keyword, default, SyntaxFactory.Identifier(identifier), default, default, default, default, default, default, default, default); 5246=> SyntaxFactory.DelegateDeclaration(attributeLists, modifiers, SyntaxFactory.Token(SyntaxKind.DelegateKeyword), returnType, identifier, typeParameterList, parameterList, constraintClauses, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 5250=> SyntaxFactory.DelegateDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.DelegateKeyword), returnType, identifier, default, SyntaxFactory.ParameterList(), default, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 5254=> SyntaxFactory.DelegateDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.DelegateKeyword), returnType, SyntaxFactory.Identifier(identifier), default, SyntaxFactory.ParameterList(), default, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 5265=> SyntaxFactory.EnumMemberDeclaration(default, default(SyntaxTokenList), identifier, default); 5269=> SyntaxFactory.EnumMemberDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Identifier(identifier), default); 5298=> SyntaxFactory.ExtensionBlockDeclaration(attributeLists, modifiers, SyntaxFactory.Token(SyntaxKind.ExtensionKeyword), typeParameterList, parameterList, constraintClauses, default, members, default, default); 5302=> SyntaxFactory.ExtensionBlockDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.ExtensionKeyword), default, default, default, default, default, default, default); 5313=> SyntaxFactory.BaseList(SyntaxFactory.Token(SyntaxKind.ColonToken), types); 5332=> SyntaxFactory.PrimaryConstructorBaseType(type, SyntaxFactory.ArgumentList()); 5345=> SyntaxFactory.TypeParameterConstraintClause(SyntaxFactory.Token(SyntaxKind.WhereKeyword), name, SyntaxFactory.Token(SyntaxKind.ColonToken), constraints); 5349=> SyntaxFactory.TypeParameterConstraintClause(SyntaxFactory.Token(SyntaxKind.WhereKeyword), name, SyntaxFactory.Token(SyntaxKind.ColonToken), default); 5353=> SyntaxFactory.TypeParameterConstraintClause(SyntaxFactory.Token(SyntaxKind.WhereKeyword), SyntaxFactory.IdentifierName(name), SyntaxFactory.Token(SyntaxKind.ColonToken), default); 5366=> SyntaxFactory.ConstructorConstraint(SyntaxFactory.Token(SyntaxKind.NewKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 5394=> SyntaxFactory.ClassOrStructConstraint(kind, SyntaxFactory.Token(GetClassOrStructConstraintClassOrStructKeywordKind(kind)), default); 5420=> SyntaxFactory.DefaultConstraint(SyntaxFactory.Token(SyntaxKind.DefaultKeyword)); 5431=> SyntaxFactory.AllowsConstraintClause(SyntaxFactory.Token(SyntaxKind.AllowsKeyword), constraints); 5443=> SyntaxFactory.RefStructConstraint(SyntaxFactory.Token(SyntaxKind.RefKeyword), SyntaxFactory.Token(SyntaxKind.StructKeyword)); 5455=> SyntaxFactory.FieldDeclaration(attributeLists, modifiers, declaration, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 5459=> SyntaxFactory.FieldDeclaration(default, default(SyntaxTokenList), declaration, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 5472=> SyntaxFactory.EventFieldDeclaration(attributeLists, modifiers, SyntaxFactory.Token(SyntaxKind.EventKeyword), declaration, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 5476=> SyntaxFactory.EventFieldDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.EventKeyword), declaration, SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 5488=> SyntaxFactory.ExplicitInterfaceSpecifier(name, SyntaxFactory.Token(SyntaxKind.DotToken)); 5507=> SyntaxFactory.MethodDeclaration(attributeLists, modifiers, returnType, explicitInterfaceSpecifier, identifier, typeParameterList, parameterList, constraintClauses, body, expressionBody, default); 5511=> SyntaxFactory.MethodDeclaration(default, default(SyntaxTokenList), returnType, default, identifier, default, SyntaxFactory.ParameterList(), default, default, default, default); 5515=> SyntaxFactory.MethodDeclaration(default, default(SyntaxTokenList), returnType, default, SyntaxFactory.Identifier(identifier), default, SyntaxFactory.ParameterList(), default, default, default, default); 5579=> SyntaxFactory.OperatorDeclaration(attributeLists, modifiers, returnType, explicitInterfaceSpecifier, SyntaxFactory.Token(SyntaxKind.OperatorKeyword), default, operatorToken, parameterList, body, expressionBody, default); 5583=> SyntaxFactory.OperatorDeclaration(default, default(SyntaxTokenList), returnType, default, SyntaxFactory.Token(SyntaxKind.OperatorKeyword), default, operatorToken, SyntaxFactory.ParameterList(), default, default, default); 5614=> SyntaxFactory.ConversionOperatorDeclaration(attributeLists, modifiers, implicitOrExplicitKeyword, explicitInterfaceSpecifier, SyntaxFactory.Token(SyntaxKind.OperatorKeyword), default, type, parameterList, body, expressionBody, default); 5618=> SyntaxFactory.ConversionOperatorDeclaration(default, default(SyntaxTokenList), implicitOrExplicitKeyword, default, SyntaxFactory.Token(SyntaxKind.OperatorKeyword), default, type, SyntaxFactory.ParameterList(), default, default, default); 5636=> SyntaxFactory.ConstructorDeclaration(attributeLists, modifiers, identifier, parameterList, initializer, body, expressionBody, default); 5640=> SyntaxFactory.ConstructorDeclaration(default, default(SyntaxTokenList), identifier, SyntaxFactory.ParameterList(), default, default, default, default); 5644=> SyntaxFactory.ConstructorDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Identifier(identifier), SyntaxFactory.ParameterList(), default, default, default, default); 5668=> SyntaxFactory.ConstructorInitializer(kind, SyntaxFactory.Token(SyntaxKind.ColonToken), SyntaxFactory.Token(GetConstructorInitializerThisOrBaseKeywordKind(kind)), argumentList ?? SyntaxFactory.ArgumentList()); 5695=> SyntaxFactory.DestructorDeclaration(attributeLists, modifiers, SyntaxFactory.Token(SyntaxKind.TildeToken), identifier, parameterList, body, expressionBody, default); 5699=> SyntaxFactory.DestructorDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.TildeToken), identifier, SyntaxFactory.ParameterList(), default, default, default); 5703=> SyntaxFactory.DestructorDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.TildeToken), SyntaxFactory.Identifier(identifier), SyntaxFactory.ParameterList(), default, default, default); 5721=> SyntaxFactory.PropertyDeclaration(attributeLists, modifiers, type, explicitInterfaceSpecifier, identifier, accessorList, expressionBody, initializer, default); 5725=> SyntaxFactory.PropertyDeclaration(default, default(SyntaxTokenList), type, default, identifier, default, default, default, default); 5729=> SyntaxFactory.PropertyDeclaration(default, default(SyntaxTokenList), type, default, SyntaxFactory.Identifier(identifier), default, default, default, default); 5741=> SyntaxFactory.ArrowExpressionClause(SyntaxFactory.Token(SyntaxKind.EqualsGreaterThanToken), expression); 5760=> SyntaxFactory.EventDeclaration(attributeLists, modifiers, SyntaxFactory.Token(SyntaxKind.EventKeyword), type, explicitInterfaceSpecifier, identifier, accessorList, default); 5764=> SyntaxFactory.EventDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.EventKeyword), type, default, identifier, default, default); 5768=> SyntaxFactory.EventDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.EventKeyword), type, default, SyntaxFactory.Identifier(identifier), default, default); 5787=> SyntaxFactory.IndexerDeclaration(attributeLists, modifiers, type, explicitInterfaceSpecifier, SyntaxFactory.Token(SyntaxKind.ThisKeyword), parameterList, accessorList, expressionBody, default); 5791=> SyntaxFactory.IndexerDeclaration(default, default(SyntaxTokenList), type, default, SyntaxFactory.Token(SyntaxKind.ThisKeyword), SyntaxFactory.BracketedParameterList(), default, default, default); 5803=> SyntaxFactory.AccessorList(SyntaxFactory.Token(SyntaxKind.OpenBraceToken), accessors, SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 5839=> SyntaxFactory.AccessorDeclaration(kind, attributeLists, modifiers, SyntaxFactory.Token(GetAccessorDeclarationKeywordKind(kind)), body, expressionBody, default); 5843=> SyntaxFactory.AccessorDeclaration(kind, default, default(SyntaxTokenList), SyntaxFactory.Token(GetAccessorDeclarationKeywordKind(kind)), default, default, default); 5867=> SyntaxFactory.ParameterList(SyntaxFactory.Token(SyntaxKind.OpenParenToken), parameters, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 5879=> SyntaxFactory.BracketedParameterList(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), parameters, SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); 5903=> SyntaxFactory.FunctionPointerParameter(default, default(SyntaxTokenList), type); 5914=> SyntaxFactory.IncompleteMember(default, default(SyntaxTokenList), type); 5925=> SyntaxFactory.SkippedTokensTrivia(default(SyntaxTokenList)); 5942=> SyntaxFactory.DocumentationCommentTrivia(kind, content, SyntaxFactory.Token(SyntaxKind.EndOfDocumentationCommentToken)); 5962=> SyntaxFactory.QualifiedCref(container, SyntaxFactory.Token(SyntaxKind.DotToken), member); 5973=> SyntaxFactory.NameMemberCref(name, default); 5987=> SyntaxFactory.ExtensionMemberCref(SyntaxFactory.Token(SyntaxKind.ExtensionKeyword), typeArgumentList, parameters, SyntaxFactory.Token(SyntaxKind.DotToken), member); 5991=> SyntaxFactory.ExtensionMemberCref(SyntaxFactory.Token(SyntaxKind.ExtensionKeyword), default, SyntaxFactory.CrefParameterList(), SyntaxFactory.Token(SyntaxKind.DotToken), member); 6002=> SyntaxFactory.IndexerMemberCref(SyntaxFactory.Token(SyntaxKind.ThisKeyword), parameters); 6057=> SyntaxFactory.OperatorMemberCref(SyntaxFactory.Token(SyntaxKind.OperatorKeyword), default, operatorToken, parameters); 6061=> SyntaxFactory.OperatorMemberCref(SyntaxFactory.Token(SyntaxKind.OperatorKeyword), default, operatorToken, default); 6085=> SyntaxFactory.ConversionOperatorMemberCref(implicitOrExplicitKeyword, SyntaxFactory.Token(SyntaxKind.OperatorKeyword), default, type, parameters); 6089=> SyntaxFactory.ConversionOperatorMemberCref(implicitOrExplicitKeyword, SyntaxFactory.Token(SyntaxKind.OperatorKeyword), default, type, default); 6101=> SyntaxFactory.CrefParameterList(SyntaxFactory.Token(SyntaxKind.OpenParenToken), parameters, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 6113=> SyntaxFactory.CrefBracketedParameterList(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), parameters, SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); 6138=> SyntaxFactory.CrefParameter(refKindKeyword, default, type); 6142=> SyntaxFactory.CrefParameter(default, default, type); 6154=> SyntaxFactory.XmlElement(startTag, default, endTag); 6167=> SyntaxFactory.XmlElementStartTag(SyntaxFactory.Token(SyntaxKind.LessThanToken), name, attributes, SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); 6171=> SyntaxFactory.XmlElementStartTag(SyntaxFactory.Token(SyntaxKind.LessThanToken), name, default, SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); 6184=> SyntaxFactory.XmlElementEndTag(SyntaxFactory.Token(SyntaxKind.LessThanSlashToken), name, SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); 6197=> SyntaxFactory.XmlEmptyElement(SyntaxFactory.Token(SyntaxKind.LessThanToken), name, attributes, SyntaxFactory.Token(SyntaxKind.SlashGreaterThanToken)); 6201=> SyntaxFactory.XmlEmptyElement(SyntaxFactory.Token(SyntaxKind.LessThanToken), name, default, SyntaxFactory.Token(SyntaxKind.SlashGreaterThanToken)); 6212=> SyntaxFactory.XmlName(default, localName); 6216=> SyntaxFactory.XmlName(default, SyntaxFactory.Identifier(localName)); 6228=> SyntaxFactory.XmlPrefix(prefix, SyntaxFactory.Token(SyntaxKind.ColonToken)); 6232=> SyntaxFactory.XmlPrefix(SyntaxFactory.Identifier(prefix), SyntaxFactory.Token(SyntaxKind.ColonToken)); 6256=> SyntaxFactory.XmlTextAttribute(name, SyntaxFactory.Token(SyntaxKind.EqualsToken), startQuoteToken, textTokens, endQuoteToken); 6260=> SyntaxFactory.XmlTextAttribute(name, SyntaxFactory.Token(SyntaxKind.EqualsToken), startQuoteToken, default(SyntaxTokenList), endQuoteToken); 6285=> SyntaxFactory.XmlCrefAttribute(name, SyntaxFactory.Token(SyntaxKind.EqualsToken), startQuoteToken, cref, endQuoteToken); 6310=> SyntaxFactory.XmlNameAttribute(name, SyntaxFactory.Token(SyntaxKind.EqualsToken), startQuoteToken, identifier, endQuoteToken); 6314=> SyntaxFactory.XmlNameAttribute(name, SyntaxFactory.Token(SyntaxKind.EqualsToken), startQuoteToken, SyntaxFactory.IdentifierName(identifier), endQuoteToken); 6324=> SyntaxFactory.XmlText(default(SyntaxTokenList)); 6336=> SyntaxFactory.XmlCDataSection(SyntaxFactory.Token(SyntaxKind.XmlCDataStartToken), textTokens, SyntaxFactory.Token(SyntaxKind.XmlCDataEndToken)); 6349=> SyntaxFactory.XmlProcessingInstruction(SyntaxFactory.Token(SyntaxKind.XmlProcessingInstructionStartToken), name, textTokens, SyntaxFactory.Token(SyntaxKind.XmlProcessingInstructionEndToken)); 6353=> SyntaxFactory.XmlProcessingInstruction(SyntaxFactory.Token(SyntaxKind.XmlProcessingInstructionStartToken), name, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.XmlProcessingInstructionEndToken)); 6365=> SyntaxFactory.XmlComment(SyntaxFactory.Token(SyntaxKind.XmlCommentStartToken), textTokens, SyntaxFactory.Token(SyntaxKind.XmlCommentEndToken)); 6379=> SyntaxFactory.IfDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.IfKeyword), condition, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive, branchTaken, conditionValue); 6393=> SyntaxFactory.ElifDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ElifKeyword), condition, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive, branchTaken, conditionValue); 6406=> SyntaxFactory.ElseDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ElseKeyword), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive, branchTaken); 6419=> SyntaxFactory.EndIfDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.EndIfKeyword), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6432=> SyntaxFactory.RegionDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.RegionKeyword), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6445=> SyntaxFactory.EndRegionDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.EndRegionKeyword), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6458=> SyntaxFactory.ErrorDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ErrorKeyword), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6471=> SyntaxFactory.WarningDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.WarningKeyword), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6483=> SyntaxFactory.BadDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), identifier, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6497=> SyntaxFactory.DefineDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.DefineKeyword), name, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6501=> SyntaxFactory.DefineDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.DefineKeyword), SyntaxFactory.Identifier(name), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6515=> SyntaxFactory.UndefDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.UndefKeyword), name, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6519=> SyntaxFactory.UndefDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.UndefKeyword), SyntaxFactory.Identifier(name), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6545=> SyntaxFactory.LineDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.LineKeyword), line, file, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6549=> SyntaxFactory.LineDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.LineKeyword), line, default, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6564=> SyntaxFactory.LineDirectivePosition(SyntaxFactory.Token(SyntaxKind.OpenParenToken), line, SyntaxFactory.Token(SyntaxKind.CommaToken), character, SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 6587=> SyntaxFactory.LineSpanDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.LineKeyword), start, SyntaxFactory.Token(SyntaxKind.MinusToken), end, characterOffset, file, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6591=> SyntaxFactory.LineSpanDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.LineKeyword), start, SyntaxFactory.Token(SyntaxKind.MinusToken), end, default, file, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6611=> SyntaxFactory.PragmaWarningDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.PragmaKeyword), SyntaxFactory.Token(SyntaxKind.WarningKeyword), disableOrRestoreKeyword, errorCodes, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6615=> SyntaxFactory.PragmaWarningDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.PragmaKeyword), SyntaxFactory.Token(SyntaxKind.WarningKeyword), disableOrRestoreKeyword, default, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6632=> SyntaxFactory.PragmaChecksumDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.PragmaKeyword), SyntaxFactory.Token(SyntaxKind.ChecksumKeyword), file, guid, bytes, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6646=> SyntaxFactory.ReferenceDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ReferenceKeyword), file, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6660=> SyntaxFactory.LoadDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.LoadKeyword), file, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6673=> SyntaxFactory.ShebangDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ExclamationToken), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6692=> SyntaxFactory.IgnoredDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ColonToken), content, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6696=> SyntaxFactory.IgnoredDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ColonToken), default, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6723=> SyntaxFactory.NullableDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.NullableKeyword), settingToken, targetToken, SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), isActive); 6727=> 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); 2350var newNode = SyntaxFactory.UnsafeExpression(keyword, openParenToken, expression, closeParenToken); 2403var newNode = SyntaxFactory.DefaultExpression(keyword, openParenToken, type, closeParenToken); 2456var newNode = SyntaxFactory.TypeOfExpression(keyword, openParenToken, type, closeParenToken); 2509var newNode = SyntaxFactory.SizeOfExpression(keyword, openParenToken, type, closeParenToken); 2569var newNode = SyntaxFactory.InvocationExpression(expression, argumentList); 2629var newNode = SyntaxFactory.ElementAccessExpression(expression, argumentList); 2703var newNode = SyntaxFactory.ArgumentList(openParenToken, arguments, closeParenToken); 2763var newNode = SyntaxFactory.BracketedArgumentList(openBracketToken, arguments, closeBracketToken); 2836var newNode = SyntaxFactory.Argument(nameColon, refKindKeyword, expression); 2895var newNode = SyntaxFactory.ExpressionColon(expression, colonToken); 2942var newNode = SyntaxFactory.NameColon(name, colonToken); 3000var newNode = SyntaxFactory.DeclarationExpression(type, designation); 3064var newNode = SyntaxFactory.CastExpression(openParenToken, type, closeParenToken, expression); 3186var newNode = SyntaxFactory.AnonymousMethodExpression(modifiers, delegateKeyword, parameterList, block, expressionBody); 3207var parameterList = this.ParameterList ?? SyntaxFactory.ParameterList(); 3322var newNode = SyntaxFactory.SimpleLambdaExpression(attributeLists, modifiers, parameter, arrowToken, block, expressionBody); 3351var block = this.Block ?? SyntaxFactory.Block(); 3357var block = this.Block ?? SyntaxFactory.Block(); 3392var newNode = SyntaxFactory.RefExpression(refKeyword, expression); 3484var newNode = SyntaxFactory.ParenthesizedLambdaExpression(attributeLists, modifiers, returnType, parameterList, arrowToken, block, expressionBody); 3513var block = this.Block ?? SyntaxFactory.Block(); 3519var block = this.Block ?? SyntaxFactory.Block(); 3571var newNode = SyntaxFactory.InitializerExpression(this.Kind(), openBraceToken, expressions, closeBraceToken); 3661var newNode = SyntaxFactory.ImplicitObjectCreationExpression(newKeyword, argumentList, initializer); 3735var newNode = SyntaxFactory.ObjectCreationExpression(newKeyword, type, argumentList, initializer); 3754var argumentList = this.ArgumentList ?? SyntaxFactory.ArgumentList(); 3805var newNode = SyntaxFactory.WithExpression(expression, withKeyword, initializer); 3865var newNode = SyntaxFactory.AnonymousObjectMemberDeclarator(nameEquals, expression); 3923var newNode = SyntaxFactory.AnonymousObjectCreationExpression(newKeyword, openBraceToken, initializers, closeBraceToken); 3988var newNode = SyntaxFactory.ArrayCreationExpression(newKeyword, type, initializer); 4052var newNode = SyntaxFactory.ImplicitArrayCreationExpression(newKeyword, openBracketToken, commas, closeBracketToken, initializer); 4119var newNode = SyntaxFactory.StackAllocArrayCreationExpression(stackAllocKeyword, type, initializer); 4171var newNode = SyntaxFactory.ImplicitStackAllocArrayCreationExpression(stackAllocKeyword, openBracketToken, closeBracketToken, initializer); 4227var newNode = SyntaxFactory.CollectionExpression(openBracketToken, elements, closeBracketToken); 4278var newNode = SyntaxFactory.ExpressionElement(expression); 4319var newNode = SyntaxFactory.SpreadElement(operatorToken, expression); 4363var newNode = SyntaxFactory.WithElement(withKeyword, argumentList); 4436var newNode = SyntaxFactory.QueryExpression(fromClause, body); 4498var newNode = SyntaxFactory.QueryBody(clauses, selectOrGroup, continuation); 4563var newNode = SyntaxFactory.FromClause(fromKeyword, type, identifier, inKeyword, expression); 4613var newNode = SyntaxFactory.LetClause(letKeyword, identifier, equalsToken, expression); 4696var newNode = SyntaxFactory.JoinClause(joinKeyword, type, identifier, inKeyword, inExpression, onKeyword, leftExpression, equalsKeyword, rightExpression, into); 4746var newNode = SyntaxFactory.JoinIntoClause(intoKeyword, identifier); 4788var newNode = SyntaxFactory.WhereClause(whereKeyword, condition); 4837var newNode = SyntaxFactory.OrderByClause(orderByKeyword, orderings); 4889var newNode = SyntaxFactory.Ordering(this.Kind(), expression, ascendingOrDescendingKeyword); 4931var newNode = SyntaxFactory.SelectClause(selectKeyword, expression); 4990var newNode = SyntaxFactory.GroupClause(groupKeyword, groupExpression, byKeyword, byExpression); 5037var newNode = SyntaxFactory.QueryContinuation(intoKeyword, identifier, body); 5081var newNode = SyntaxFactory.OmittedArraySizeExpression(omittedArraySizeExpressionToken); 5127var newNode = SyntaxFactory.InterpolatedStringExpression(stringStartToken, contents, stringEndToken); 5190var newNode = SyntaxFactory.IsPatternExpression(expression, isKeyword, pattern); 5233var newNode = SyntaxFactory.ThrowExpression(throwKeyword, expression); 5275var newNode = SyntaxFactory.WhenClause(whenKeyword, condition); 5322var newNode = SyntaxFactory.DiscardPattern(underscoreToken); 5376var newNode = SyntaxFactory.DeclarationPattern(type, designation); 5418var newNode = SyntaxFactory.VarPattern(varKeyword, designation); 5483var newNode = SyntaxFactory.RecursivePattern(type, positionalPatternClause, propertyPatternClause, designation); 5498var positionalPatternClause = this.PositionalPatternClause ?? SyntaxFactory.PositionalPatternClause(); 5503var propertyPatternClause = this.PropertyPatternClause ?? SyntaxFactory.PropertyPatternClause(); 5547var newNode = SyntaxFactory.PositionalPatternClause(openParenToken, subpatterns, closeParenToken); 5601var newNode = SyntaxFactory.PropertyPatternClause(openBraceToken, subpatterns, closeBraceToken); 5659var newNode = SyntaxFactory.Subpattern(expressionColon, pattern); 5700var newNode = SyntaxFactory.ConstantPattern(expression); 5743var newNode = SyntaxFactory.ParenthesizedPattern(openParenToken, pattern, closeParenToken); 5787var newNode = SyntaxFactory.RelationalPattern(operatorToken, expression); 5828var newNode = SyntaxFactory.TypePattern(type); 5885var newNode = SyntaxFactory.BinaryPattern(this.Kind(), left, operatorToken, right); 5928var newNode = SyntaxFactory.UnaryPattern(operatorToken, pattern); 5994var newNode = SyntaxFactory.ListPattern(openBracketToken, patterns, closeBracketToken, designation); 6040var newNode = SyntaxFactory.SlicePattern(dotDotToken, pattern); 6088var newNode = SyntaxFactory.InterpolatedStringText(textToken); 6155var newNode = SyntaxFactory.Interpolation(openBraceToken, expression, alignmentClause, formatClause, closeBraceToken); 6200var newNode = SyntaxFactory.InterpolationAlignmentClause(commaToken, value); 6242var newNode = SyntaxFactory.InterpolationFormatClause(colonToken, formatStringToken); 6307var newNode = SyntaxFactory.GlobalStatement(attributeLists, modifiers, statement); 6390var newNode = SyntaxFactory.Block(attributeLists, openBraceToken, statements, closeBraceToken); 6499var newNode = SyntaxFactory.LocalFunctionStatement(attributeLists, modifiers, returnType, identifier, typeParameterList, parameterList, constraintClauses, body, expressionBody, semicolonToken); 6524var typeParameterList = this.TypeParameterList ?? SyntaxFactory.TypeParameterList(); 6531var body = this.Body ?? SyntaxFactory.Block(); 6536var body = this.Body ?? SyntaxFactory.Block(); 6614var newNode = SyntaxFactory.LocalDeclarationStatement(attributeLists, awaitKeyword, usingKeyword, modifiers, declaration, semicolonToken); 6686var newNode = SyntaxFactory.VariableDeclaration(type, variables); 6746var newNode = SyntaxFactory.VariableDeclarator(identifier, argumentList, initializer); 6760var argumentList = this.ArgumentList ?? SyntaxFactory.BracketedArgumentList(); 6795var newNode = SyntaxFactory.EqualsValueClause(equalsToken, value); 6842var newNode = SyntaxFactory.SingleVariableDesignation(identifier); 6880var newNode = SyntaxFactory.DiscardDesignation(underscoreToken); 6930var newNode = SyntaxFactory.ParenthesizedVariableDesignation(openParenToken, variables, closeParenToken); 6990var newNode = SyntaxFactory.ExpressionStatement(attributeLists, expression, semicolonToken); 7037var newNode = SyntaxFactory.EmptyStatement(attributeLists, semicolonToken); 7103var newNode = SyntaxFactory.LabeledStatement(attributeLists, identifier, colonToken, statement); 7194var newNode = SyntaxFactory.GotoStatement(this.Kind(), attributeLists, gotoKeyword, caseOrDefaultKeyword, expression, semicolonToken); 7262var newNode = SyntaxFactory.BreakStatement(attributeLists, breakKeyword, name, semicolonToken); 7330var newNode = SyntaxFactory.ContinueStatement(attributeLists, continueKeyword, name, semicolonToken); 7396var newNode = SyntaxFactory.ReturnStatement(attributeLists, returnKeyword, expression, semicolonToken); 7461var newNode = SyntaxFactory.ThrowStatement(attributeLists, throwKeyword, expression, semicolonToken); 7529var newNode = SyntaxFactory.YieldStatement(this.Kind(), attributeLists, yieldKeyword, returnOrBreakKeyword, expression, semicolonToken); 7602var newNode = SyntaxFactory.WhileStatement(attributeLists, whileKeyword, openParenToken, condition, closeParenToken, statement); 7680var newNode = SyntaxFactory.DoStatement(attributeLists, doKeyword, statement, whileKeyword, openParenToken, condition, closeParenToken, semicolonToken); 7789var newNode = SyntaxFactory.ForStatement(attributeLists, forKeyword, openParenToken, declaration, initializers, firstSemicolonToken, condition, secondSemicolonToken, incrementors, closeParenToken, statement); 7929var newNode = SyntaxFactory.ForEachStatement(attributeLists, awaitKeyword, forEachKeyword, openParenToken, type, identifier, inKeyword, expression, closeParenToken, statement); 8036var newNode = SyntaxFactory.ForEachVariableStatement(attributeLists, awaitKeyword, forEachKeyword, openParenToken, variable, inKeyword, expression, closeParenToken, statement); 8134var newNode = SyntaxFactory.UsingStatement(attributeLists, awaitKeyword, usingKeyword, openParenToken, declaration, expression, closeParenToken, statement); 8210var newNode = SyntaxFactory.FixedStatement(attributeLists, fixedKeyword, openParenToken, declaration, closeParenToken, statement); 8277var newNode = SyntaxFactory.CheckedStatement(this.Kind(), attributeLists, keyword, block); 8341var newNode = SyntaxFactory.UnsafeStatement(attributeLists, unsafeKeyword, block); 8414var newNode = SyntaxFactory.LockStatement(attributeLists, lockKeyword, openParenToken, expression, closeParenToken, statement); 8514var newNode = SyntaxFactory.IfStatement(attributeLists, ifKeyword, openParenToken, condition, closeParenToken, statement, @else); 8569var newNode = SyntaxFactory.ElseClause(elseKeyword, statement); 8675var newNode = SyntaxFactory.SwitchStatement(attributeLists, switchKeyword, openParenToken, expression, closeParenToken, openBraceToken, sections, closeBraceToken); 8748var newNode = SyntaxFactory.SwitchSection(labels, statements); 8838var newNode = SyntaxFactory.CasePatternSwitchLabel(keyword, pattern, whenClause, colonToken); 8891var newNode = SyntaxFactory.CaseSwitchLabel(keyword, value, colonToken); 8937var newNode = SyntaxFactory.DefaultSwitchLabel(keyword, colonToken); 9007var newNode = SyntaxFactory.SwitchExpression(governingExpression, switchKeyword, openBraceToken, arms, closeBraceToken); 9074var newNode = SyntaxFactory.SwitchExpressionArm(pattern, whenClause, equalsGreaterThanToken, expression); 9143var newNode = SyntaxFactory.TryStatement(attributeLists, tryKeyword, block, catches, @finally); 9215var newNode = SyntaxFactory.CatchClause(catchKeyword, declaration, filter, block); 9273var newNode = SyntaxFactory.CatchDeclaration(openParenToken, type, identifier, closeParenToken); 9321var newNode = SyntaxFactory.CatchFilterClause(whenKeyword, openParenToken, filterExpression, closeParenToken); 9365var newNode = SyntaxFactory.FinallyClause(finallyKeyword, block); 9436var newNode = SyntaxFactory.CompilationUnit(externs, usings, attributeLists, members, endOfFileToken); 9496var newNode = SyntaxFactory.ExternAliasDirective(externKeyword, aliasKeyword, identifier, semicolonToken); 9584var newNode = SyntaxFactory.UsingDirective(globalKeyword, usingKeyword, staticKeyword, unsafeKeyword, alias, namespaceOrType, semicolonToken); 9753var newNode = SyntaxFactory.NamespaceDeclaration(attributeLists, modifiers, namespaceKeyword, name, openBraceToken, externs, usings, members, closeBraceToken, semicolonToken); 9862var newNode = SyntaxFactory.FileScopedNamespaceDeclaration(attributeLists, modifiers, namespaceKeyword, name, semicolonToken, externs, usings, members); 9957var newNode = SyntaxFactory.AttributeList(openBracketToken, target, attributes, closeBracketToken); 10005var newNode = SyntaxFactory.AttributeTargetSpecifier(identifier, colonToken); 10062var newNode = SyntaxFactory.Attribute(name, argumentList); 10075var argumentList = this.ArgumentList ?? SyntaxFactory.AttributeArgumentList(); 10123var newNode = SyntaxFactory.AttributeArgumentList(openParenToken, arguments, closeParenToken); 10188var newNode = SyntaxFactory.AttributeArgument(nameEquals, nameColon, expression); 10233var newNode = SyntaxFactory.NameEquals(name, equalsToken); 10288var newNode = SyntaxFactory.TypeParameterList(lessThanToken, parameters, greaterThanToken); 10345var newNode = SyntaxFactory.TypeParameter(attributeLists, varianceKeyword, identifier); 10561var newNode = SyntaxFactory.ClassDeclaration(attributeLists, modifiers, keyword, identifier, typeParameterList, parameterList, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken); 10601var typeParameterList = this.TypeParameterList ?? SyntaxFactory.TypeParameterList(); 10607var parameterList = this.ParameterList ?? SyntaxFactory.ParameterList(); 10613var baseList = this.BaseList ?? SyntaxFactory.BaseList(); 10727var newNode = SyntaxFactory.StructDeclaration(attributeLists, modifiers, keyword, identifier, typeParameterList, parameterList, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken); 10767var typeParameterList = this.TypeParameterList ?? SyntaxFactory.TypeParameterList(); 10773var parameterList = this.ParameterList ?? SyntaxFactory.ParameterList(); 10779var baseList = this.BaseList ?? SyntaxFactory.BaseList(); 10895var newNode = SyntaxFactory.UnionDeclaration(attributeLists, modifiers, keyword, identifier, typeParameterList, parameterList, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken); 10935var typeParameterList = this.TypeParameterList ?? SyntaxFactory.TypeParameterList(); 10941var parameterList = this.ParameterList ?? SyntaxFactory.ParameterList(); 10947var baseList = this.BaseList ?? SyntaxFactory.BaseList(); 11061var newNode = SyntaxFactory.InterfaceDeclaration(attributeLists, modifiers, keyword, identifier, typeParameterList, parameterList, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken); 11101var typeParameterList = this.TypeParameterList ?? SyntaxFactory.TypeParameterList(); 11107var parameterList = this.ParameterList ?? SyntaxFactory.ParameterList(); 11113var baseList = this.BaseList ?? SyntaxFactory.BaseList(); 11235var newNode = SyntaxFactory.RecordDeclaration(this.Kind(), attributeLists, modifiers, keyword, classOrStructKeyword, identifier, typeParameterList, parameterList, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken); 11276var typeParameterList = this.TypeParameterList ?? SyntaxFactory.TypeParameterList(); 11282var parameterList = this.ParameterList ?? SyntaxFactory.ParameterList(); 11288var baseList = this.BaseList ?? SyntaxFactory.BaseList(); 11396var newNode = SyntaxFactory.EnumDeclaration(attributeLists, modifiers, enumKeyword, identifier, baseList, openBraceToken, members, closeBraceToken, semicolonToken); 11428var baseList = this.BaseList ?? SyntaxFactory.BaseList(); 11514var newNode = SyntaxFactory.DelegateDeclaration(attributeLists, modifiers, delegateKeyword, returnType, identifier, typeParameterList, parameterList, constraintClauses, semicolonToken); 11540var typeParameterList = this.TypeParameterList ?? SyntaxFactory.TypeParameterList(); 11602var newNode = SyntaxFactory.EnumMemberDeclaration(attributeLists, modifiers, identifier, equalsValue); 11720var newNode = SyntaxFactory.ExtensionBlockDeclaration(attributeLists, modifiers, keyword, typeParameterList, parameterList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken); 11756var typeParameterList = this.TypeParameterList ?? SyntaxFactory.TypeParameterList(); 11762var parameterList = this.ParameterList ?? SyntaxFactory.ParameterList(); 11811var newNode = SyntaxFactory.BaseList(colonToken, types); 11866var newNode = SyntaxFactory.SimpleBaseType(type); 11921var newNode = SyntaxFactory.PrimaryConstructorBaseType(type, argumentList); 11994var newNode = SyntaxFactory.TypeParameterConstraintClause(whereKeyword, name, colonToken, constraints); 12054var newNode = SyntaxFactory.ConstructorConstraint(newKeyword, openParenToken, closeParenToken); 12107var newNode = SyntaxFactory.ClassOrStructConstraint(this.Kind(), classOrStructKeyword, questionToken); 12149var newNode = SyntaxFactory.TypeConstraint(type); 12189var newNode = SyntaxFactory.DefaultConstraint(defaultKeyword); 12239var newNode = SyntaxFactory.AllowsConstraintClause(allowsKeyword, constraints); 12294var newNode = SyntaxFactory.RefStructConstraint(refKeyword, structKeyword); 12386var newNode = SyntaxFactory.FieldDeclaration(attributeLists, modifiers, declaration, semicolonToken); 12467var newNode = SyntaxFactory.EventFieldDeclaration(attributeLists, modifiers, eventKeyword, declaration, semicolonToken); 12523var newNode = SyntaxFactory.ExplicitInterfaceSpecifier(name, dotToken); 12676var newNode = SyntaxFactory.MethodDeclaration(attributeLists, modifiers, returnType, explicitInterfaceSpecifier, identifier, typeParameterList, parameterList, constraintClauses, body, expressionBody, semicolonToken); 12708var typeParameterList = this.TypeParameterList ?? SyntaxFactory.TypeParameterList(); 12717var body = this.Body ?? SyntaxFactory.Block(); 12723var body = this.Body ?? SyntaxFactory.Block(); 12828var newNode = SyntaxFactory.OperatorDeclaration(attributeLists, modifiers, returnType, explicitInterfaceSpecifier, operatorKeyword, checkedKeyword, operatorToken, parameterList, body, expressionBody, semicolonToken); 12863var body = this.Body ?? SyntaxFactory.Block(); 12869var body = this.Body ?? SyntaxFactory.Block(); 12974var newNode = SyntaxFactory.ConversionOperatorDeclaration(attributeLists, modifiers, implicitOrExplicitKeyword, explicitInterfaceSpecifier, operatorKeyword, checkedKeyword, type, parameterList, body, expressionBody, semicolonToken); 13009var body = this.Body ?? SyntaxFactory.Block(); 13015var body = this.Body ?? SyntaxFactory.Block(); 13101var newNode = SyntaxFactory.ConstructorDeclaration(attributeLists, modifiers, identifier, parameterList, initializer, body, expressionBody, semicolonToken); 13133var body = this.Body ?? SyntaxFactory.Block(); 13139var body = this.Body ?? SyntaxFactory.Block(); 13180var newNode = SyntaxFactory.ConstructorInitializer(this.Kind(), colonToken, thisOrBaseKeyword, argumentList); 13274var newNode = SyntaxFactory.DestructorDeclaration(attributeLists, modifiers, tildeToken, identifier, parameterList, body, expressionBody, semicolonToken); 13306var body = this.Body ?? SyntaxFactory.Block(); 13312var body = this.Body ?? SyntaxFactory.Block(); 13434var newNode = SyntaxFactory.PropertyDeclaration(attributeLists, modifiers, type, explicitInterfaceSpecifier, identifier, accessorList, expressionBody, initializer, semicolonToken); 13464var accessorList = this.AccessorList ?? SyntaxFactory.AccessorList(); 13500var newNode = SyntaxFactory.ArrowExpressionClause(arrowToken, expression); 13588var newNode = SyntaxFactory.EventDeclaration(attributeLists, modifiers, eventKeyword, type, explicitInterfaceSpecifier, identifier, accessorList, semicolonToken); 13617var accessorList = this.AccessorList ?? SyntaxFactory.AccessorList(); 13706var newNode = SyntaxFactory.IndexerDeclaration(attributeLists, modifiers, type, explicitInterfaceSpecifier, thisKeyword, parameterList, accessorList, expressionBody, semicolonToken); 13737var accessorList = this.AccessorList ?? SyntaxFactory.AccessorList(); 13774var newNode = SyntaxFactory.AccessorList(openBraceToken, accessors, closeBraceToken); 13868var newNode = SyntaxFactory.AccessorDeclaration(this.Kind(), attributeLists, modifiers, keyword, body, expressionBody, semicolonToken); 13887var body = this.Body ?? SyntaxFactory.Block(); 13892var body = this.Body ?? SyntaxFactory.Block(); 13956var newNode = SyntaxFactory.ParameterList(openParenToken, parameters, closeParenToken); 14015var newNode = SyntaxFactory.BracketedParameterList(openBracketToken, parameters, closeBracketToken); 14134var newNode = SyntaxFactory.Parameter(attributeLists, modifiers, type, identifier, @default); 14212var newNode = SyntaxFactory.FunctionPointerParameter(attributeLists, modifiers, type); 14285var newNode = SyntaxFactory.IncompleteMember(attributeLists, modifiers, type); 14339var newNode = SyntaxFactory.SkippedTokensTrivia(tokens); 14383var newNode = SyntaxFactory.DocumentationCommentTrivia(this.Kind(), content, endOfComment); 14444var newNode = SyntaxFactory.TypeCref(type); 14507var newNode = SyntaxFactory.QualifiedCref(container, dotToken, member); 14584var newNode = SyntaxFactory.NameMemberCref(name, parameters); 14597var parameters = this.Parameters ?? SyntaxFactory.CrefParameterList(); 14654var newNode = SyntaxFactory.ExtensionMemberCref(extensionKeyword, typeArgumentList, parameters, dotToken, member); 14670var typeArgumentList = this.TypeArgumentList ?? SyntaxFactory.TypeArgumentList(); 14710var newNode = SyntaxFactory.IndexerMemberCref(thisKeyword, parameters); 14723var parameters = this.Parameters ?? SyntaxFactory.CrefBracketedParameterList(); 14775var newNode = SyntaxFactory.OperatorMemberCref(operatorKeyword, checkedKeyword, operatorToken, parameters); 14790var parameters = this.Parameters ?? SyntaxFactory.CrefParameterList(); 14855var newNode = SyntaxFactory.ConversionOperatorMemberCref(implicitOrExplicitKeyword, operatorKeyword, checkedKeyword, type, parameters); 14871var parameters = this.Parameters ?? SyntaxFactory.CrefParameterList(); 14940var newNode = SyntaxFactory.CrefParameterList(openParenToken, parameters, closeParenToken); 15001var newNode = SyntaxFactory.CrefBracketedParameterList(openBracketToken, parameters, closeBracketToken); 15070var newNode = SyntaxFactory.CrefParameter(refKindKeyword, readOnlyKeyword, type); 15139var newNode = SyntaxFactory.XmlElement(startTag, content, endTag); 15202var newNode = SyntaxFactory.XmlElementStartTag(lessThanToken, name, attributes, greaterThanToken); 15250var newNode = SyntaxFactory.XmlElementEndTag(lessThanSlashToken, name, greaterThanToken); 15310var newNode = SyntaxFactory.XmlEmptyElement(lessThanToken, name, attributes, slashGreaterThanToken); 15356var newNode = SyntaxFactory.XmlName(prefix, localName); 15397var newNode = SyntaxFactory.XmlPrefix(prefix, colonToken); 15476var newNode = SyntaxFactory.XmlTextAttribute(name, equalsToken, startQuoteToken, textTokens, endQuoteToken); 15546var newNode = SyntaxFactory.XmlCrefAttribute(name, equalsToken, startQuoteToken, cref, endQuoteToken); 15614var newNode = SyntaxFactory.XmlNameAttribute(name, equalsToken, startQuoteToken, identifier, endQuoteToken); 15667var newNode = SyntaxFactory.XmlText(textTokens); 15718var newNode = SyntaxFactory.XmlCDataSection(startCDataToken, textTokens, endCDataToken); 15774var newNode = SyntaxFactory.XmlProcessingInstruction(startProcessingInstructionToken, name, textTokens, endProcessingInstructionToken); 15828var newNode = SyntaxFactory.XmlComment(lessThanExclamationMinusMinusToken, textTokens, minusMinusGreaterThanToken); 15928var newNode = SyntaxFactory.IfDirectiveTrivia(hashToken, ifKeyword, condition, endOfDirectiveToken, isActive, branchTaken, conditionValue); 15988var newNode = SyntaxFactory.ElifDirectiveTrivia(hashToken, elifKeyword, condition, endOfDirectiveToken, isActive, branchTaken, conditionValue); 16043var newNode = SyntaxFactory.ElseDirectiveTrivia(hashToken, elseKeyword, endOfDirectiveToken, isActive, branchTaken); 16093var newNode = SyntaxFactory.EndIfDirectiveTrivia(hashToken, endIfKeyword, endOfDirectiveToken, isActive); 16142var newNode = SyntaxFactory.RegionDirectiveTrivia(hashToken, regionKeyword, endOfDirectiveToken, isActive); 16191var newNode = SyntaxFactory.EndRegionDirectiveTrivia(hashToken, endRegionKeyword, endOfDirectiveToken, isActive); 16240var newNode = SyntaxFactory.ErrorDirectiveTrivia(hashToken, errorKeyword, endOfDirectiveToken, isActive); 16289var newNode = SyntaxFactory.WarningDirectiveTrivia(hashToken, warningKeyword, endOfDirectiveToken, isActive); 16338var newNode = SyntaxFactory.BadDirectiveTrivia(hashToken, identifier, endOfDirectiveToken, isActive); 16389var newNode = SyntaxFactory.DefineDirectiveTrivia(hashToken, defineKeyword, name, endOfDirectiveToken, isActive); 16441var newNode = SyntaxFactory.UndefDirectiveTrivia(hashToken, undefKeyword, name, endOfDirectiveToken, isActive); 16521var newNode = SyntaxFactory.LineDirectiveTrivia(hashToken, lineKeyword, line, file, endOfDirectiveToken, isActive); 16576var newNode = SyntaxFactory.LineDirectivePosition(openParenToken, line, commaToken, character, closeParenToken); 16655var newNode = SyntaxFactory.LineSpanDirectiveTrivia(hashToken, lineKeyword, start, minusToken, end, characterOffset, file, endOfDirectiveToken, isActive); 16725var newNode = SyntaxFactory.PragmaWarningDirectiveTrivia(hashToken, pragmaKeyword, warningKeyword, disableOrRestoreKeyword, errorCodes, endOfDirectiveToken, isActive); 16787var newNode = SyntaxFactory.PragmaChecksumDirectiveTrivia(hashToken, pragmaKeyword, checksumKeyword, file, guid, bytes, endOfDirectiveToken, isActive); 16842var newNode = SyntaxFactory.ReferenceDirectiveTrivia(hashToken, referenceKeyword, file, endOfDirectiveToken, isActive); 16894var newNode = SyntaxFactory.LoadDirectiveTrivia(hashToken, loadKeyword, file, endOfDirectiveToken, isActive); 16944var newNode = SyntaxFactory.ShebangDirectiveTrivia(hashToken, exclamationToken, endOfDirectiveToken, isActive); 17002var newNode = SyntaxFactory.IgnoredDirectiveTrivia(hashToken, colonToken, content, endOfDirectiveToken, isActive); 17063var newNode = SyntaxFactory.NullableDirectiveTrivia(hashToken, nullableKeyword, settingToken, targetToken, endOfDirectiveToken, isActive);

12490var 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); 2269var tmp = SyntaxFactory.GetStandaloneNode(node); 2377bindableParent = 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(attributes, modifiers, keyword, identifier, typeParameterList, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken); 132return SyntaxFactory.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;

233: SyntaxFactory.Block(labeled)); 237=> SyntaxFactory.LabeledStatement( 238SyntaxFactory.Identifier(labelName).WithLeadingTrivia(originalLoop.GetLeadingTrivia()), 239SyntaxFactory.Token(SyntaxKind.ColonToken).WithTrailingTrivia(SyntaxFactory.Space), 245var name = SyntaxFactory.IdentifierName(labelName); 247? SyntaxFactory.BreakStatement(name) 248: SyntaxFactory.ContinueStatement(name);

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;

233: SyntaxFactory.Block(labeled)); 237=> SyntaxFactory.LabeledStatement( 238SyntaxFactory.Identifier(labelName).WithLeadingTrivia(originalLoop.GetLeadingTrivia()), 239SyntaxFactory.Token(SyntaxKind.ColonToken).WithTrailingTrivia(SyntaxFactory.Space), 245var name = SyntaxFactory.IdentifierName(labelName); 247? SyntaxFactory.BreakStatement(name) 248: SyntaxFactory.ContinueStatement(name);

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)))]; 1728list[i] = list[i].WithTrailingTrivia(SyntaxFactory.ElasticSpace); 1741=> SyntaxFactory.TypeParameter(name); 1745return SyntaxFactory.TypeParameter( 1753SyntaxFactory.Identifier(typeParameter.Name)); 1759? SyntaxFactory.TypeParameterList([.. typeParameterNodes.Cast<TypeParameterSyntax>()]) 1800method.ParameterList.GetTrailingTrivia().Add(SyntaxFactory.ElasticMarker).AddRange(method.ConstraintClauses.Last().GetTrailingTrivia()))); 1819=> SyntaxFactory.ExplicitInterfaceSpecifier(explicitInterfaceImplementations[0].ContainingType.GenerateNameSyntax()); 1834return method.AddConstraintClauses(SyntaxFactory.TypeParameterConstraintClause( 1835typeParameterName).AddConstraints(SyntaxFactory.DefaultConstraint())); 1846? SyntaxFactory.SeparatedList<TypeParameterConstraintSyntax>(types.Select(t => SyntaxFactory.TypeConstraint((TypeSyntax)t))) 1851constraints = constraints.Add(SyntaxFactory.ConstructorConstraint()); 1859constraints = constraints.Insert(0, SyntaxFactory.ClassOrStructConstraint(isReferenceType ? SyntaxKind.ClassConstraint : SyntaxKind.StructConstraint)); 1863constraints = constraints.Insert(0, SyntaxFactory.TypeConstraint(SyntaxFactory.IdentifierName("unmanaged"))); 1872return clauses.Add(SyntaxFactory.TypeParameterConstraintClause(typeParameterName.ToIdentifierName(), constraints)); 2313? SyntaxFactory.BracketedParameterList() 2314: SyntaxFactory.ParameterList(); 2369return SyntaxFactory.Token(token.Kind()).WithTriviaFrom(rewrittenToken); 2407return SyntaxFactory.ParenthesizedLambdaExpression(AsParameterList(parameters), lambda.Body) 2539return WithEqualsValue(declaration, SyntaxFactory.EqualsValueClause(expr)); 2690currentList = SyntaxFactory.AccessorList(); 2722=> SyntaxFactory.AccessorList([.. nodes.Select(n => AsAccessor(n, parentKind)).WhereNotNull()]); 2830return WithBaseList(declaration, baseList.WithTypes(baseList.Types.Insert(0, SyntaxFactory.SimpleBaseType((TypeSyntax)baseType)))); 2834return AddBaseList(declaration, SyntaxFactory.BaseList([SyntaxFactory.SimpleBaseType((TypeSyntax)baseType)])); 2844return WithBaseList(declaration, baseList.WithTypes(baseList.Types.Insert(baseList.Types.Count, SyntaxFactory.SimpleBaseType((TypeSyntax)interfaceType)))); 2848return AddBaseList(declaration, SyntaxFactory.BaseList([SyntaxFactory.SimpleBaseType((TypeSyntax)interfaceType)])); 2958return SyntaxFactory.AreEquivalent(fd1.Modifiers, fd2.Modifiers) 2959&& SyntaxFactory.AreEquivalent(fd1.AttributeLists, fd2.AttributeLists); 2964return SyntaxFactory.AreEquivalent(efd1.Modifiers, efd2.Modifiers) 2965&& SyntaxFactory.AreEquivalent(efd1.AttributeLists, efd2.AttributeLists); 2970return SyntaxFactory.AreEquivalent(ld1.Modifiers, ld2.Modifiers); 2979return SyntaxFactory.AreEquivalent(vd1.Type, vd2.Type) && AreSimilarExceptForSubDeclarations(vd1.Parent, vd2.Parent); 2998newNodes.Add(this.WithSubDeclarationsRemoved(multiPartDeclaration, index, count - index).WithTrailingTrivia(SyntaxFactory.ElasticSpace)); 3006newNodes.Add(this.WithSubDeclarationsRemoved(multiPartDeclaration, 0, index + 1).WithLeadingTrivia(SyntaxFactory.ElasticSpace)); 3023newDeclarations = newDeclarations.Select(declaration => declaration is StatementSyntax statement ? SyntaxFactory.GlobalStatement(statement) : declaration); 3062newDeclarations = newDeclarations.Select(declaration => declaration is StatementSyntax statement ? SyntaxFactory.GlobalStatement(statement) : declaration); 3101this.WithSubDeclarationsRemoved(multiPartDeclaration, index, count - index).WithTrailingTrivia(SyntaxFactory.ElasticSpace) 3104newNodes.Add(this.WithSubDeclarationsRemoved(multiPartDeclaration, 0, index).WithLeadingTrivia(SyntaxFactory.ElasticSpace)); 3235=> SyntaxFactory.AssignmentExpression(SyntaxKind.AddAssignmentExpression, (ExpressionSyntax)@event, (ExpressionSyntax)ParenthesizeNonSimple(handler)); 3238=> SyntaxFactory.AssignmentExpression(SyntaxKind.SubtractAssignmentExpression, (ExpressionSyntax)@event, (ExpressionSyntax)ParenthesizeNonSimple(handler)); 3241=> SyntaxFactory.AwaitExpression((ExpressionSyntax)expression); 3247=> SyntaxFactory.ReturnStatement((ExpressionSyntax?)expression); 3250=> SyntaxFactory.ThrowStatement((ExpressionSyntax?)expression); 3253=> SyntaxFactory.ThrowExpression((ExpressionSyntax)expression); 3259return SyntaxFactory.IfStatement( 3268return SyntaxFactory.IfStatement( 3271SyntaxFactory.ElseClause( 3281var block = existingBlock ?? SyntaxFactory.Block(); 3301return SyntaxFactory.ExpressionStatement(expression); 3308=> SyntaxFactory.ExpressionStatement((ExpressionSyntax)expression); 3317=> SyntaxFactory.ElementBindingExpression( 3318SyntaxFactory.BracketedArgumentList([.. arguments.Cast<ArgumentSyntax>()])); 3325var arrayType = SyntaxFactory.ArrayType((TypeSyntax)elementType, [SyntaxFactory.ArrayRankSpecifier([(ExpressionSyntax)size])]); 3326return SyntaxFactory.ArrayCreationExpression(arrayType); 3331var arrayType = SyntaxFactory.ArrayType((TypeSyntax)elementType, 3332[SyntaxFactory.ArrayRankSpecifier([SyntaxFactory.OmittedArraySizeExpression()])]); 3333var initializer = SyntaxFactory.InitializerExpression(SyntaxKind.ArrayInitializerExpression, AsExpressionList(elements)); 3334return SyntaxFactory.ArrayCreationExpression(arrayType, initializer); 3338=> SyntaxFactory.ObjectCreationExpression((TypeSyntax)type, CreateArgumentList(arguments), null); 3341=> SyntaxFactory.ObjectCreationExpression( 3343SyntaxFactory.ArgumentList(openParen, (SeparatedSyntaxList<ArgumentSyntax>)arguments, closeParen), 3347=> SyntaxFactory.ArgumentList(CreateArguments(arguments)); 3353=> argOrExpression as ArgumentSyntax ?? SyntaxFactory.Argument((ExpressionSyntax)argOrExpression); 3356=> SyntaxFactory.InvocationExpression(CSharpSyntaxGeneratorInternal.ParenthesizeLeft((ExpressionSyntax)expression), CreateArgumentList(arguments)); 3359=> SyntaxFactory.ElementAccessExpression(CSharpSyntaxGeneratorInternal.ParenthesizeLeft((ExpressionSyntax)expression), SyntaxFactory.BracketedArgumentList(CreateArguments(arguments))); 3362=> SyntaxFactory.Literal(text, value); 3368=> SyntaxFactory.BinaryExpression(SyntaxKind.IsExpression, (ExpressionSyntax)ParenthesizeNonSimple(expression), (TypeSyntax)type); 3371=> SyntaxFactory.TypeOfExpression((TypeSyntax)type); 3374=> SyntaxFactory.BinaryExpression(SyntaxKind.AsExpression, (ExpressionSyntax)ParenthesizeNonSimple(expression), (TypeSyntax)type); 3377=> SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, (ExpressionSyntax)left, (ExpressionSyntax)ParenthesizeNonSimple(right)); 3407=> SyntaxFactory.PrefixUnaryExpression(SyntaxKind.UnaryMinusExpression, (ExpressionSyntax)ParenthesizeNonSimple(expression)); 3428=> SyntaxFactory.PrefixUnaryExpression(SyntaxKind.BitwiseNotExpression, (ExpressionSyntax)ParenthesizeNonSimple(operand)); 3437=> SyntaxFactory.PrefixUnaryExpression( 3442=> SyntaxFactory.ConditionalExpression((ExpressionSyntax)ParenthesizeNonSimple(condition), (ExpressionSyntax)ParenthesizeNonSimple(whenTrue), (ExpressionSyntax)ParenthesizeNonSimple(whenFalse)); 3448=> SyntaxFactory.ThisExpression(); 3451=> SyntaxFactory.BaseExpression(); 3463=> SyntaxFactory.GenericName(identifier, 3464SyntaxFactory.TypeArgumentList([.. typeArguments.Cast<TypeSyntax>()])); 3472return SyntaxFactory.GenericName(sname.Identifier, SyntaxFactory.TypeArgumentList([.. typeArguments.Cast<TypeSyntax>()])); 3476return gname.WithTypeArgumentList(SyntaxFactory.TypeArgumentList([.. typeArguments.Cast<TypeSyntax>()])); 3497=> SyntaxFactory.QualifiedName((NameSyntax)left, (SimpleNameSyntax)right).WithAdditionalAnnotations(Simplifier.Annotation); 3500=> SyntaxFactory.AliasQualifiedName( 3501SyntaxFactory.IdentifierName(GlobalKeyword), 3508=> SyntaxFactory.PredefinedType(specialType switch 3530=> SyntaxFactory.ArrayType((TypeSyntax)type, [SyntaxFactory.ArrayRankSpecifier()]); 3540return SyntaxFactory.NullableType((TypeSyntax)type); 3545=> SyntaxFactory.TupleType([.. elements.Cast<TupleElementSyntax>()]); 3548=> SyntaxFactory.TupleElement((TypeSyntax)type, name?.ToIdentifierToken() ?? default); 3552return SyntaxFactory.Argument( 3553name == null ? null : SyntaxFactory.NameColon(name), 3563return SyntaxFactory.UsingStatement( 3571return SyntaxFactory.UsingStatement( 3579return SyntaxFactory.LockStatement( 3586return SyntaxFactory.TryStatement( 3589finallyStatements != null ? SyntaxFactory.FinallyClause(CreateBlock(finallyStatements)) : null); 3594return SyntaxFactory.CatchClause( 3595SyntaxFactory.CatchDeclaration((TypeSyntax)type, name.ToIdentifierToken()), 3601=> SyntaxFactory.WhileStatement((ExpressionSyntax)condition, CreateBlock(statements)); 3607return SyntaxFactory.SwitchStatement( 3613return SyntaxFactory.SwitchStatement( 3625=> SyntaxFactory.SwitchSection(AsSwitchLabels(expressions), AsStatementList(statements)); 3629return SyntaxFactory.SwitchSection( 3635=> SyntaxFactory.SwitchSection([SyntaxFactory.DefaultSwitchLabel()], AsStatementList(statements)); 3643labels = labels.AddRange(expressions.Select(e => SyntaxFactory.CaseSwitchLabel((ExpressionSyntax)e))); 3650=> SyntaxFactory.BreakStatement(); 3653=> SyntaxFactory.Block(statements.Cast<StatementSyntax>()); 3656=> SyntaxFactory.GlobalStatement((StatementSyntax)statement); 3663? SyntaxFactory.SimpleLambdaExpression(parameter, (CSharpSyntaxNode)expression) 3664: SyntaxFactory.ParenthesizedLambdaExpression(AsParameterList(parameters), (CSharpSyntaxNode)expression); 3683=> SyntaxFactory.IdentifierName(identifier); 3687return SyntaxFactory.AnonymousObjectMemberDeclarator( 3688SyntaxFactory.NameEquals((IdentifierNameSyntax)identifier), 3693=> SyntaxFactory.TupleExpression([.. arguments.Select(AsArgument)]); 3736=> SyntaxFactory.ParseExpression(stringToParse); 3739=> SyntaxFactory.ParseTypeName(stringToParse); 3749return 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")));

16using 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))